diff options
809 files changed, 6281 insertions, 4795 deletions
diff --git a/configure b/configure index ea9320c901b..61c737e0fd3 100755 --- a/configure +++ b/configure @@ -599,6 +599,18 @@ then fi putvar CFG_RELEASE_CHANNEL +# A magic value that allows the compiler to use unstable features +# during the bootstrap even when doing so would normally be an error +# because of feature staging or because the build turns on +# warnings-as-errors and unstable features default to warnings. The +# build has to match this key in an env var. Meant to be a mild +# deterrent from users just turning on unstable features on the stable +# channel. +# Basing CFG_BOOTSTRAP_KEY on CFG_BOOTSTRAP_KEY lets it get picked up +# during a Makefile reconfig. +CFG_BOOTSTRAP_KEY="${CFG_BOOTSTRAP_KEY-`date +%N`}" +putvar CFG_BOOTSTRAP_KEY + step_msg "looking for build programs" probe_need CFG_PERL perl diff --git a/mk/main.mk b/mk/main.mk index a97e68af59b..99aecc34be9 100644 --- a/mk/main.mk +++ b/mk/main.mk @@ -25,11 +25,13 @@ ifeq ($(CFG_RELEASE_CHANNEL),stable) CFG_RELEASE=$(CFG_RELEASE_NUM) # This is the string used in dist artifact file names, e.g. "0.12.0", "nightly" CFG_PACKAGE_VERS=$(CFG_RELEASE_NUM) +CFG_DISABLE_UNSTABLE_FEATURES=1 endif ifeq ($(CFG_RELEASE_CHANNEL),beta) # The beta channel is temporarily called 'alpha' CFG_RELEASE=$(CFG_RELEASE_NUM)-alpha$(CFG_BETA_CYCLE) CFG_PACKAGE_VERS=$(CFG_RELEASE_NUM)-alpha$(CFG_BETA_CYCLE) +CFG_DISABLE_UNSTABLE_FEATURES=1 endif ifeq ($(CFG_RELEASE_CHANNEL),nightly) CFG_RELEASE=$(CFG_RELEASE_NUM)-nightly @@ -121,11 +123,9 @@ CFG_JEMALLOC_FLAGS += $(JEMALLOC_FLAGS) ifdef CFG_DISABLE_DEBUG CFG_RUSTC_FLAGS += --cfg ndebug - CFG_GCCISH_CFLAGS += -DRUST_NDEBUG else $(info cfg: enabling more debugging (CFG_ENABLE_DEBUG)) CFG_RUSTC_FLAGS += --cfg debug - CFG_GCCISH_CFLAGS += -DRUST_DEBUG endif ifdef SAVE_TEMPS @@ -319,11 +319,20 @@ export CFG_VERSION_WIN export CFG_RELEASE export CFG_PACKAGE_NAME export CFG_BUILD +export CFG_RELEASE_CHANNEL export CFG_LLVM_ROOT export CFG_PREFIX export CFG_LIBDIR export CFG_LIBDIR_RELATIVE export CFG_DISABLE_INJECT_STD_VERSION +ifdef CFG_DISABLE_UNSTABLE_FEATURES +CFG_INFO := $(info cfg: disabling unstable features (CFG_DISABLE_UNSTABLE_FEATURES)) +# Turn on feature-staging +export CFG_DISABLE_UNSTABLE_FEATURES +endif +# Subvert unstable feature lints to do the self-build +export CFG_BOOTSTRAP_KEY +export RUSTC_BOOTSTRAP_KEY:=$(CFG_BOOTSTRAP_KEY) ###################################################################### # Per-stage targets and runner diff --git a/src/compiletest/compiletest.rs b/src/compiletest/compiletest.rs index e2420b0a220..9a5665e6839 100644 --- a/src/compiletest/compiletest.rs +++ b/src/compiletest/compiletest.rs @@ -9,7 +9,9 @@ // except according to those terms. #![crate_type = "bin"] +#![allow(unknown_features)] #![feature(slicing_syntax, unboxed_closures)] +#![feature(box_syntax)] #![deny(warnings)] diff --git a/src/compiletest/runtest.rs b/src/compiletest/runtest.rs index f8e2ba4828f..5de93c52029 100644 --- a/src/compiletest/runtest.rs +++ b/src/compiletest/runtest.rs @@ -908,8 +908,7 @@ fn check_error_patterns(props: &TestProps, } if done { return; } - let missing_patterns = - props.error_patterns.index(&(next_err_idx..)); + let missing_patterns = &props.error_patterns[next_err_idx..]; if missing_patterns.len() == 1u { fatal_proc_rec(format!("error pattern '{}' not found!", missing_patterns[0]).as_slice(), diff --git a/src/doc/footer.inc b/src/doc/footer.inc index 4e7d60586f2..f32f2fd443f 100644 --- a/src/doc/footer.inc +++ b/src/doc/footer.inc @@ -1,5 +1,5 @@ <footer><p> -Copyright © 2011-2014 The Rust Project Developers. Licensed under the +Copyright © 2011-2015 The Rust Project Developers. Licensed under the <a href="http://www.apache.org/licenses/LICENSE-2.0">Apache License, Version 2.0</a> or the <a href="http://opensource.org/licenses/MIT">MIT license</a>, at your option. </p><p> diff --git a/src/doc/guide-error-handling.md b/src/doc/guide-error-handling.md index d241e77f810..98b46511f04 100644 --- a/src/doc/guide-error-handling.md +++ b/src/doc/guide-error-handling.md @@ -147,10 +147,10 @@ for all but the most trivial of situations. Here's an example of using `Result`: ```rust -#[deriving(Show)] +#[derive(Show)] enum Version { Version1, Version2 } -#[deriving(Show)] +#[derive(Show)] enum ParseError { InvalidHeaderLength, InvalidVersion } fn parse_version(header: &[u8]) -> Result<Version, ParseError> { diff --git a/src/doc/guide-ffi.md b/src/doc/guide-ffi.md index 7ee1c1a7032..1f12c05f37e 100644 --- a/src/doc/guide-ffi.md +++ b/src/doc/guide-ffi.md @@ -262,6 +262,7 @@ referenced Rust object. Rust code: ~~~~no_run +# use std::boxed::Box; #[repr(C)] struct RustObject { @@ -286,7 +287,7 @@ extern { fn main() { // Create the object that will be referenced in the callback - let mut rust_object = box RustObject { a: 5 }; + let mut rust_object = Box::new(RustObject { a: 5 }); unsafe { register_callback(&mut *rust_object, callback); diff --git a/src/doc/guide-ownership.md b/src/doc/guide-ownership.md index 414a874082e..3db4da73f93 100644 --- a/src/doc/guide-ownership.md +++ b/src/doc/guide-ownership.md @@ -81,27 +81,29 @@ therefore deallocates the memory for you. Here's the equivalent example in Rust: ```rust +# use std::boxed::Box; { - let x = box 5i; + let x = Box::new(5i); } ``` -The `box` keyword creates a `Box<T>` (specifically `Box<int>` in this case) by -allocating a small segment of memory on the heap with enough space to fit an -`int`. But where in the code is the box deallocated? We said before that we -must have a deallocation for each allocation. Rust handles this for you. It +The `Box::new` function creates a `Box<T>` (specifically `Box<int>` in this +case) by allocating a small segment of memory on the heap with enough space to +fit an `int`. But where in the code is the box deallocated? We said before that +we must have a deallocation for each allocation. Rust handles this for you. It knows that our handle, `x`, is the owning reference to our box. Rust knows that `x` will go out of scope at the end of the block, and so it inserts a call to deallocate the memory at the end of the scope. Because the compiler does this -for us, it's impossible to forget. We always have exactly one deallocation paired -with each of our allocations. +for us, it's impossible to forget. We always have exactly one deallocation + paired with each of our allocations. This is pretty straightforward, but what happens when we want to pass our box to a function? Let's look at some code: ```rust +# use std::boxed::Box; fn main() { - let x = box 5i; + let x = Box::new(5i); add_one(x); } @@ -115,8 +117,9 @@ This code works, but it's not ideal. For example, let's add one more line of code, where we print out the value of `x`: ```{rust,ignore} +# use std::boxed::Box; fn main() { - let x = box 5i; + let x = Box::new(5i); add_one(x); @@ -148,8 +151,9 @@ To fix this, we can have `add_one` give ownership back when it's done with the box: ```rust +# use std::boxed::Box; fn main() { - let x = box 5i; + let x = Box::new(5i); let y = add_one(x); @@ -458,7 +462,7 @@ lifetime, and so if you elide a lifetime (like `&T` instead of `&'a T`), Rust will do three things to determine what those lifetimes should be. When talking about lifetime elision, we use the term 'input lifetime' and -'output lifetime'. An 'input liftime' is a lifetime associated with a parameter +'output lifetime'. An 'input lifetime' is a lifetime associated with a parameter of a function, and an 'output lifetime' is a lifetime associated with the return value of a function. For example, this function has an input lifetime: diff --git a/src/doc/guide-pointers.md b/src/doc/guide-pointers.md index 14e33ab0f74..4c35fae3ecc 100644 --- a/src/doc/guide-pointers.md +++ b/src/doc/guide-pointers.md @@ -455,12 +455,13 @@ fn rc_succ(x: Rc<int>) -> int { *x + 1 } Note that the caller of your function will have to modify their calls slightly: ```{rust} +# use std::boxed::Box; use std::rc::Rc; fn succ(x: &int) -> int { *x + 1 } let ref_x = &5i; -let box_x = box 5i; +let box_x = Box::new(5i); let rc_x = Rc::new(5i); succ(ref_x); @@ -477,24 +478,17 @@ those contents. heap allocation in Rust. Creating a box looks like this: ```{rust} -let x = box(std::boxed::HEAP) 5i; +# use std::boxed::Box; +let x = Box::new(5i); ``` -`box` is a keyword that does 'placement new,' which we'll talk about in a bit. -`box` will be useful for creating a number of heap-allocated types, but is not -quite finished yet. In the meantime, `box`'s type defaults to -`std::boxed::HEAP`, and so you can leave it off: - -```{rust} -let x = box 5i; -``` - -As you might assume from the `HEAP`, boxes are heap allocated. They are -deallocated automatically by Rust when they go out of scope: +Boxes are heap allocated and they are deallocated automatically by Rust when +they go out of scope: ```{rust} +# use std::boxed::Box; { - let x = box 5i; + let x = Box::new(5i); // stuff happens @@ -513,8 +507,9 @@ You don't need to fully grok the theory of affine types or regions to grok boxes, though. As a rough approximation, you can treat this Rust code: ```{rust} +# use std::boxed::Box; { - let x = box 5i; + let x = Box::new(5i); // stuff happens } @@ -553,12 +548,13 @@ for more detail on how lifetimes work. Using boxes and references together is very common. For example: ```{rust} +# use std::boxed::Box; fn add_one(x: &int) -> int { *x + 1 } fn main() { - let x = box 5i; + let x = Box::new(5i); println!("{}", add_one(&*x)); } @@ -570,12 +566,13 @@ function, and since it's only reading the value, allows it. We can borrow `x` multiple times, as long as it's not simultaneous: ```{rust} +# use std::boxed::Box; fn add_one(x: &int) -> int { *x + 1 } fn main() { - let x = box 5i; + let x = Box::new(5i); println!("{}", add_one(&*x)); println!("{}", add_one(&*x)); @@ -586,12 +583,13 @@ fn main() { Or as long as it's not a mutable borrow. This will error: ```{rust,ignore} +# use std::boxed::Box; fn add_one(x: &mut int) -> int { *x + 1 } fn main() { - let x = box 5i; + let x = Box::new(5i); println!("{}", add_one(&*x)); // error: cannot borrow immutable dereference // of `&`-pointer as mutable @@ -612,14 +610,15 @@ Sometimes, you need a recursive data structure. The simplest is known as a ```{rust} -#[deriving(Show)] +# use std::boxed::Box; +#[derive(Show)] enum List<T> { Cons(T, Box<List<T>>), Nil, } fn main() { - let list: List<int> = List::Cons(1, box List::Cons(2, box List::Cons(3, box List::Nil))); + let list: List<int> = List::Cons(1, Box::new(List::Cons(2, Box::new(List::Cons(3, Box::new(List::Nil)))))); println!("{:?}", list); } ``` @@ -627,7 +626,7 @@ fn main() { This prints: ```text -Cons(1, box Cons(2, box Cons(3, box Nil))) +Cons(1, Box(Cons(2, Box(Cons(3, Box(Nil)))))) ``` The reference to another `List` inside of the `Cons` enum variant must be a box, @@ -667,6 +666,7 @@ In many languages with pointers, you'd return a pointer from a function so as to avoid copying a large data structure. For example: ```{rust} +# use std::boxed::Box; struct BigStruct { one: int, two: int, @@ -675,15 +675,15 @@ struct BigStruct { } fn foo(x: Box<BigStruct>) -> Box<BigStruct> { - return box *x; + return Box::new(*x); } fn main() { - let x = box BigStruct { + let x = Box::new(BigStruct { one: 1, two: 2, one_hundred: 100, - }; + }); let y = foo(x); } @@ -695,6 +695,7 @@ than the hundred `int`s that make up the `BigStruct`. This is an antipattern in Rust. Instead, write this: ```{rust} +# use std::boxed::Box; struct BigStruct { one: int, two: int, @@ -707,13 +708,13 @@ fn foo(x: Box<BigStruct>) -> BigStruct { } fn main() { - let x = box BigStruct { + let x = Box::new(BigStruct { one: 1, two: 2, one_hundred: 100, - }; + }); - let y = box foo(x); + let y = Box::new(foo(x)); } ``` diff --git a/src/doc/guide-unsafe.md b/src/doc/guide-unsafe.md index 11bc0bc30f2..25ca07ad74f 100644 --- a/src/doc/guide-unsafe.md +++ b/src/doc/guide-unsafe.md @@ -197,6 +197,7 @@ extern crate libc; use libc::{c_void, size_t, malloc, free}; use std::mem; use std::ptr; +# use std::boxed::Box; // Define a wrapper around the handle returned by the foreign code. // Unique<T> has the same semantics as Box<T> @@ -265,7 +266,7 @@ impl<T: Send> Drop for Unique<T> { // A comparison between the built-in `Box` and this reimplementation fn main() { { - let mut x = box 5i; + let mut x = Box::new(5i); *x = 10; } // `x` is freed here @@ -653,7 +654,7 @@ sugar for dynamic allocations via `malloc` and `free`: ``` #![no_std] -#![feature(lang_items)] +#![feature(lang_items, box_syntax)] extern crate libc; diff --git a/src/doc/guide.md b/src/doc/guide.md index f736ef821fa..5ab3063033f 100644 --- a/src/doc/guide.md +++ b/src/doc/guide.md @@ -3802,18 +3802,19 @@ enum List { // error: illegal recursive enum type But the compiler complains that the type is recursive, that is, it could be arbitrarily large. To remedy this, Rust provides a fixed-size container called -a **box** that can hold any type. You can box up any value with the `box` -keyword. Our boxed List gets the type `Box<List>` (more on the notation when we +a **Box** that can hold any type. You can box up any value with the `Box::new` +function. Our boxed List gets the type `Box<List>` (more on the notation when we get to generics): ```{rust} +# use std::boxed::Box; enum List { Node(u32, Box<List>), Nil } fn main() { - let list = List::Node(0, box List::Node(1, box List::Nil)); + let list = List::Node(0, Box::new(List::Node(1, Box::new(List::Nil)))); } ``` @@ -3826,8 +3827,9 @@ just like regular references. This (rather silly) example dynamically allocates an integer `5` and makes `x` a pointer to it: ```{rust} +# use std::boxed::Box; { - let x = box 5; + let x = Box::new(5); println!("{}", *x); // Prints 5 } ``` @@ -3858,7 +3860,8 @@ Boxes are the sole owner of their contents, so you cannot take a mutable reference to them and then use the original box: ```{rust,ignore} -let mut x = box 5; +# use std::boxed::Box; +let mut x = Box::new(5); let y = &mut x; *x; // you might expect 5, but this is actually an error @@ -3879,7 +3882,8 @@ As long as `y` is borrowing the contents, we cannot use `x`. After `y` is done borrowing the value, we can use it again. This works fine: ```{rust} -let mut x = box 5; +# use std::boxed::Box; +let mut x = Box::new(5); { let y = &mut x; diff --git a/src/doc/intro.md b/src/doc/intro.md index fbc96a577a4..ffe33f41bc7 100644 --- a/src/doc/intro.md +++ b/src/doc/intro.md @@ -542,7 +542,7 @@ use std::thread::Thread; fn main() { let vec = vec![1i, 2, 3]; - for i in range(1u, 3) { + for i in range(0u, 3) { Thread::spawn(move || { println!("{}", vec[i]); }).detach(); @@ -558,7 +558,7 @@ a vector: ```{rust} let vec = vec![1i, 2, 3]; -for i in range(1u, vec.len()) { +for i in range(0u, vec.len()) { println!("{}", vec[i]); } ``` diff --git a/src/doc/reference.md b/src/doc/reference.md index febd5f883d1..804b6b9f63c 100644 --- a/src/doc/reference.md +++ b/src/doc/reference.md @@ -1588,10 +1588,11 @@ pointer values (pointing to a type for which an implementation of the given trait is in scope) to pointers to the trait name, used as a type. ``` +# use std::boxed::Box; # trait Shape { } # impl Shape for int { } # let mycircle = 0i; -let myshape: Box<Shape> = box mycircle as Box<Shape>; +let myshape: Box<Shape> = Box::new(mycircle) as Box<Shape>; ``` The resulting value is a box containing the value that was cast, along with @@ -1646,12 +1647,13 @@ fn radius_times_area<T: Circle>(c: T) -> f64 { Likewise, supertrait methods may also be called on trait objects. ```{.ignore} +# use std::boxed::Box; # trait Shape { fn area(&self) -> f64; } # trait Circle : Shape { fn radius(&self) -> f64; } # impl Shape for int { fn area(&self) -> f64 { 0.0 } } # impl Circle for int { fn radius(&self) -> f64 { 0.0 } } # let mycircle = 0; -let mycircle = box mycircle as Box<Circle>; +let mycircle = Box::new(mycircle) as Box<Circle>; let nonsense = mycircle.radius() * mycircle.area(); ``` @@ -3376,14 +3378,17 @@ stands for a *single* data field, whereas a wildcard `..` stands for *all* the fields of a particular variant. For example: ``` +#![feature(box_syntax)] enum List<X> { Nil, Cons(X, Box<List<X>>) } -let x: List<int> = List::Cons(10, box List::Cons(11, box List::Nil)); +fn main() { + let x: List<int> = List::Cons(10, box List::Cons(11, box List::Nil)); -match x { - List::Cons(_, box List::Nil) => panic!("singleton list"), - List::Cons(..) => return, - List::Nil => panic!("empty list") + match x { + List::Cons(_, box List::Nil) => panic!("singleton list"), + List::Cons(..) => return, + List::Nil => panic!("empty list") + } } ``` @@ -3436,25 +3441,28 @@ the inside of the match. An example of a `match` expression: ``` +#![feature(box_syntax)] # fn process_pair(a: int, b: int) { } # fn process_ten() { } enum List<X> { Nil, Cons(X, Box<List<X>>) } -let x: List<int> = List::Cons(10, box List::Cons(11, box List::Nil)); +fn main() { + let x: List<int> = List::Cons(10, box List::Cons(11, box List::Nil)); -match x { - List::Cons(a, box List::Cons(b, _)) => { - process_pair(a, b); - } - List::Cons(10, _) => { - process_ten(); - } - List::Nil => { - return; - } - _ => { - panic!(); + match x { + List::Cons(a, box List::Cons(b, _)) => { + process_pair(a, b); + } + List::Cons(10, _) => { + process_ten(); + } + List::Nil => { + return; + } + _ => { + panic!(); + } } } ``` @@ -3468,6 +3476,8 @@ Subpatterns can also be bound to variables by the use of the syntax `variable @ subpattern`. For example: ``` +#![feature(box_syntax)] + enum List { Nil, Cons(uint, Box<List>) } fn is_sorted(list: &List) -> bool { @@ -3781,12 +3791,13 @@ enclosing `enum` or `struct` type itself. Such recursion has restrictions: An example of a *recursive* type and its use: ``` +# use std::boxed::Box; enum List<T> { - Nil, - Cons(T, Box<List<T>>) + Nil, + Cons(T, Box<List<T>>) } -let a: List<int> = List::Cons(7, box List::Cons(13, box List::Nil)); +let a: List<int> = List::Cons(7, Box::new(List::Cons(13, Box::new(List::Nil)))); ``` ### Pointer types @@ -3893,6 +3904,7 @@ implementation of `R`, and the pointer value of `E`. An example of an object type: ``` +# use std::boxed::Box; trait Printable { fn stringify(&self) -> String; } @@ -3906,7 +3918,7 @@ fn print(a: Box<Printable>) { } fn main() { - print(box 10i as Box<Printable>); + print(Box::new(10i) as Box<Printable>); } ``` @@ -4100,7 +4112,8 @@ the type of a box is `std::owned::Box<T>`. An example of a box type and value: ``` -let x: Box<int> = box 10; +# use std::boxed::Box; +let x: Box<int> = Box::new(10); ``` Box values exist in 1:1 correspondence with their heap allocation, copying a @@ -4109,7 +4122,8 @@ copy of a box to move ownership of the value. After a value has been moved, the source location cannot be used unless it is reinitialized. ``` -let x: Box<int> = box 10; +# use std::boxed::Box; +let x: Box<int> = Box::new(10); let y = x; // attempting to use `x` will result in an error here ``` diff --git a/src/liballoc/arc.rs b/src/liballoc/arc.rs index 5d47602b5e1..48136bc1d96 100644 --- a/src/liballoc/arc.rs +++ b/src/liballoc/arc.rs @@ -67,21 +67,20 @@ //! } //! ``` +use core::prelude::*; + use core::atomic; use core::atomic::Ordering::{Relaxed, Release, Acquire, SeqCst}; use core::borrow::BorrowFrom; -use core::clone::Clone; use core::fmt::{self, Show}; -use core::cmp::{Eq, Ord, PartialEq, PartialOrd, Ordering}; +use core::cmp::{Ordering}; use core::default::Default; -use core::marker::{Sync, Send}; -use core::mem::{min_align_of, size_of, drop}; +use core::mem::{min_align_of, size_of}; use core::mem; use core::nonzero::NonZero; -use core::ops::{Drop, Deref}; -use core::option::Option; -use core::option::Option::{Some, None}; -use core::ptr::{self, PtrExt}; +use core::ops::Deref; +use core::ptr; +use core::hash::{Hash, Hasher}; use heap::deallocate; /// An atomically reference counted wrapper for shared state. @@ -586,11 +585,24 @@ impl<T: fmt::Show> fmt::Show for Arc<T> { } #[stable] +impl<T: fmt::String> fmt::String for Arc<T> { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::String::fmt(&**self, f) + } +} + +#[stable] impl<T: Default + Sync + Send> Default for Arc<T> { #[stable] fn default() -> Arc<T> { Arc::new(Default::default()) } } +impl<H: Hasher, T: Hash<H>> Hash<H> for Arc<T> { + fn hash(&self, state: &mut H) { + (**self).hash(state) + } +} + #[cfg(test)] #[allow(experimental)] mod tests { diff --git a/src/liballoc/boxed.rs b/src/liballoc/boxed.rs index d46f18abf97..97b198164eb 100644 --- a/src/liballoc/boxed.rs +++ b/src/liballoc/boxed.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. // @@ -33,12 +33,15 @@ use core::ops::{Deref, DerefMut}; /// The following two examples are equivalent: /// /// ```rust +/// #![feature(box_syntax)] /// use std::boxed::HEAP; /// +/// fn main() { /// # struct Bar; /// # impl Bar { fn new(_a: int) { } } -/// let foo = box(HEAP) Bar::new(2); -/// let foo = box Bar::new(2); +/// let foo = box(HEAP) Bar::new(2); +/// let foo = box Bar::new(2); +/// } /// ``` #[lang = "exchange_heap"] #[experimental = "may be renamed; uncertain about custom allocator design"] @@ -49,6 +52,14 @@ pub static HEAP: () = (); #[stable] pub struct Box<T>(Unique<T>); +impl<T> Box<T> { + /// Moves `x` into a freshly allocated box on the global exchange heap. + #[stable] + pub fn new(x: T) -> Box<T> { + box x + } +} + #[stable] impl<T: Default> Default for Box<T> { #[stable] @@ -102,16 +113,24 @@ impl<T: ?Sized + Ord> Ord for Box<T> { fn cmp(&self, other: &Box<T>) -> Ordering { Ord::cmp(&**self, &**other) } - -#[stable]} +} +#[stable] impl<T: ?Sized + Eq> Eq for Box<T> {} +#[cfg(stage0)] impl<S: hash::Writer, T: ?Sized + Hash<S>> Hash<S> for Box<T> { #[inline] fn hash(&self, state: &mut S) { (**self).hash(state); } } +#[cfg(not(stage0))] +impl<S: hash::Hasher, T: ?Sized + Hash<S>> Hash<S> for Box<T> { + #[inline] + fn hash(&self, state: &mut S) { + (**self).hash(state); + } +} /// Extension methods for an owning `Any` trait object. #[unstable = "post-DST and coherence changes, this will not be a trait but \ @@ -149,6 +168,7 @@ impl<T: ?Sized + fmt::Show> fmt::Show for Box<T> { } } +#[stable] impl<T: ?Sized + fmt::String> fmt::String for Box<T> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::String::fmt(&**self, f) @@ -177,27 +197,27 @@ impl<T: ?Sized> DerefMut for Box<T> { mod test { #[test] fn test_owned_clone() { - let a = box 5i; + let a = Box::new(5i); let b: Box<int> = a.clone(); assert!(a == b); } #[test] fn any_move() { - let a = box 8u as Box<Any>; - let b = box Test as Box<Any>; + let a = Box::new(8u) as Box<Any>; + let b = Box::new(Test) as Box<Any>; match a.downcast::<uint>() { - Ok(a) => { assert!(a == box 8u); } + Ok(a) => { assert!(a == Box::new(8u)); } Err(..) => panic!() } match b.downcast::<Test>() { - Ok(a) => { assert!(a == box Test); } + Ok(a) => { assert!(a == Box::new(Test)); } Err(..) => panic!() } - let a = box 8u as Box<Any>; - let b = box Test as Box<Any>; + let a = Box::new(8u) as Box<Any>; + let b = Box::new(Test) as Box<Any>; assert!(a.downcast::<Box<Test>>().is_err()); assert!(b.downcast::<Box<uint>>().is_err()); @@ -205,8 +225,8 @@ mod test { #[test] fn test_show() { - let a = box 8u as Box<Any>; - let b = box Test as Box<Any>; + let a = Box::new(8u) as Box<Any>; + let b = Box::new(Test) as Box<Any>; let a_str = a.to_str(); let b_str = b.to_str(); assert_eq!(a_str, "Box<Any>"); @@ -223,6 +243,6 @@ mod test { #[test] fn deref() { fn homura<T: Deref<Target=i32>>(_: T) { } - homura(box 765i32); + homura(Box::new(765i32)); } } diff --git a/src/liballoc/heap.rs b/src/liballoc/heap.rs index c57435cdc8c..02933c763ef 100644 --- a/src/liballoc/heap.rs +++ b/src/liballoc/heap.rs @@ -115,16 +115,20 @@ unsafe fn exchange_free(ptr: *mut u8, old_size: uint, align: uint) { // The minimum alignment guaranteed by the architecture. This value is used to // add fast paths for low alignment values. In practice, the alignment is a // constant at the call site and the branch will be optimized out. -#[cfg(any(target_arch = "arm", - target_arch = "mips", - target_arch = "mipsel"))] +#[cfg(all(not(feature = "external_funcs"), + not(feature = "external_crate"), + any(target_arch = "arm", + target_arch = "mips", + target_arch = "mipsel")))] const MIN_ALIGN: uint = 8; -#[cfg(any(target_arch = "x86", - target_arch = "x86_64", - target_arch = "aarch64"))] +#[cfg(all(not(feature = "external_funcs"), + not(feature = "external_crate"), + any(target_arch = "x86", + target_arch = "x86_64", + target_arch = "aarch64")))] const MIN_ALIGN: uint = 16; -#[cfg(external_funcs)] +#[cfg(feature = "external_funcs")] mod imp { extern { fn rust_allocate(size: uint, align: uint) -> *mut u8; @@ -142,14 +146,13 @@ mod imp { } #[inline] - pub unsafe fn reallocate_inplace(ptr: *mut u8, old_size: uint, size: uint, - align: uint) -> uint { - rust_reallocate_inplace(ptr, old_size, size, align) + pub unsafe fn deallocate(ptr: *mut u8, old_size: uint, align: uint) { + rust_deallocate(ptr, old_size, align) } #[inline] - pub unsafe fn deallocate(ptr: *mut u8, old_size: uint, align: uint) { - rust_deallocate(ptr, old_size, align) + pub unsafe fn reallocate(ptr: *mut u8, old_size: uint, size: uint, align: uint) -> *mut u8 { + rust_reallocate(ptr, old_size, size, align) } #[inline] @@ -169,14 +172,16 @@ mod imp { } } -#[cfg(external_crate)] +#[cfg(feature = "external_crate")] mod imp { extern crate external; pub use self::external::{allocate, deallocate, reallocate_inplace, reallocate}; pub use self::external::{usable_size, stats_print}; } -#[cfg(all(not(external_funcs), not(external_crate), jemalloc))] +#[cfg(all(not(feature = "external_funcs"), + not(feature = "external_crate"), + jemalloc))] mod imp { use core::option::Option; use core::option::Option::None; @@ -253,7 +258,10 @@ mod imp { } } -#[cfg(all(not(external_funcs), not(external_crate), not(jemalloc), unix))] +#[cfg(all(not(feature = "external_funcs"), + not(feature = "external_crate"), + not(jemalloc), + unix))] mod imp { use core::cmp; use core::ptr; @@ -314,7 +322,10 @@ mod imp { pub fn stats_print() {} } -#[cfg(all(not(external_funcs), not(external_crate), not(jemalloc), windows))] +#[cfg(all(not(feature = "external_funcs"), + not(feature = "external_crate"), + not(jemalloc), + windows))] mod imp { use libc::{c_void, size_t}; use libc; diff --git a/src/liballoc/lib.rs b/src/liballoc/lib.rs index ba6e89cdd76..0bb8ba669ec 100644 --- a/src/liballoc/lib.rs +++ b/src/liballoc/lib.rs @@ -58,6 +58,7 @@ #![crate_name = "alloc"] #![experimental] +#![staged_api] #![crate_type = "rlib"] #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png", html_favicon_url = "http://www.rust-lang.org/favicon.ico", @@ -66,9 +67,12 @@ #![no_std] #![allow(unknown_features)] #![feature(lang_items, unsafe_destructor)] +#![feature(box_syntax)] #[macro_use] extern crate core; + +#[cfg(all(not(feature = "external_funcs"), not(feature = "external_crate")))] extern crate libc; // Allow testing this library diff --git a/src/liballoc/rc.rs b/src/liballoc/rc.rs index 67b25427710..27b3f03002f 100644 --- a/src/liballoc/rc.rs +++ b/src/liballoc/rc.rs @@ -10,23 +10,26 @@ //! Thread-local reference-counted boxes (the `Rc<T>` type). //! -//! The `Rc<T>` type provides shared ownership of an immutable value. Destruction is deterministic, -//! and will occur as soon as the last owner is gone. It is marked as non-sendable because it -//! avoids the overhead of atomic reference counting. +//! The `Rc<T>` type provides shared ownership of an immutable value. +//! Destruction is deterministic, and will occur as soon as the last owner is +//! gone. It is marked as non-sendable because it avoids the overhead of atomic +//! reference counting. //! -//! The `downgrade` method can be used to create a non-owning `Weak<T>` pointer to the box. A -//! `Weak<T>` pointer can be upgraded to an `Rc<T>` pointer, but will return `None` if the value -//! has already been dropped. +//! The `downgrade` method can be used to create a non-owning `Weak<T>` pointer +//! to the box. A `Weak<T>` pointer can be upgraded to an `Rc<T>` pointer, but +//! will return `None` if the value has already been dropped. //! -//! For example, a tree with parent pointers can be represented by putting the nodes behind strong -//! `Rc<T>` pointers, and then storing the parent pointers as `Weak<T>` pointers. +//! For example, a tree with parent pointers can be represented by putting the +//! nodes behind strong `Rc<T>` pointers, and then storing the parent pointers +//! as `Weak<T>` pointers. //! //! # Examples //! -//! Consider a scenario where a set of `Gadget`s are owned by a given `Owner`. We want to have our -//! `Gadget`s point to their `Owner`. We can't do this with unique ownership, because more than one -//! gadget may belong to the same `Owner`. `Rc<T>` allows us to share an `Owner` between multiple -//! `Gadget`s, and have the `Owner` remain allocated as long as any `Gadget` points at it. +//! Consider a scenario where a set of `Gadget`s are owned by a given `Owner`. +//! We want to have our `Gadget`s point to their `Owner`. We can't do this with +//! unique ownership, because more than one gadget may belong to the same +//! `Owner`. `Rc<T>` allows us to share an `Owner` between multiple `Gadget`s, +//! and have the `Owner` remain allocated as long as any `Gadget` points at it. //! //! ```rust //! use std::rc::Rc; @@ -597,12 +600,20 @@ impl<T: Ord> Ord for Rc<T> { } // FIXME (#18248) Make `T` `Sized?` +#[cfg(stage0)] impl<S: hash::Writer, T: Hash<S>> Hash<S> for Rc<T> { #[inline] fn hash(&self, state: &mut S) { (**self).hash(state); } } +#[cfg(not(stage0))] +impl<S: hash::Hasher, T: Hash<S>> Hash<S> for Rc<T> { + #[inline] + fn hash(&self, state: &mut S) { + (**self).hash(state); + } +} #[experimental = "Show is experimental."] impl<T: fmt::Show> fmt::Show for Rc<T> { @@ -611,6 +622,13 @@ impl<T: fmt::Show> fmt::Show for Rc<T> { } } +#[stable] +impl<T: fmt::String> fmt::String for Rc<T> { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::String::fmt(&**self, f) + } +} + /// A weak version of `Rc<T>`. /// /// Weak references do not count when determining if the inner value should be dropped. diff --git a/src/libarena/lib.rs b/src/libarena/lib.rs index 423c16bfee8..f208ff9dc05 100644 --- a/src/libarena/lib.rs +++ b/src/libarena/lib.rs @@ -21,14 +21,17 @@ #![crate_name = "arena"] #![experimental] +#![staged_api] #![crate_type = "rlib"] #![crate_type = "dylib"] #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png", html_favicon_url = "http://www.rust-lang.org/favicon.ico", html_root_url = "http://doc.rust-lang.org/nightly/")] +#![allow(unknown_features)] #![feature(unsafe_destructor)] #![feature(unboxed_closures)] +#![feature(box_syntax)] #![allow(missing_docs)] extern crate alloc; diff --git a/src/libcollections/bit.rs b/src/libcollections/bit.rs index 2154d06377a..e922feff02b 100644 --- a/src/libcollections/bit.rs +++ b/src/libcollections/bit.rs @@ -330,7 +330,7 @@ impl Bitv { if extra_bytes > 0 { let mut last_word = 0u32; - for (i, &byte) in bytes.index(&((complete_words*4)..)).iter().enumerate() { + for (i, &byte) in bytes[(complete_words*4)..].iter().enumerate() { last_word |= (reverse_bits(byte) as u32) << (i * 8); } bitv.storage.push(last_word); @@ -982,7 +982,7 @@ impl fmt::Show for Bitv { } #[stable] -impl<S: hash::Writer> hash::Hash<S> for Bitv { +impl<S: hash::Writer + hash::Hasher> hash::Hash<S> for Bitv { fn hash(&self, state: &mut S) { self.nbits.hash(state); for elem in self.blocks() { @@ -1742,7 +1742,7 @@ impl fmt::Show for BitvSet { } } -impl<S: hash::Writer> hash::Hash<S> for BitvSet { +impl<S: hash::Writer + hash::Hasher> hash::Hash<S> for BitvSet { fn hash(&self, state: &mut S) { for pos in self.iter() { pos.hash(state); diff --git a/src/libcollections/btree/map.rs b/src/libcollections/btree/map.rs index 4e44779810b..3e1533dd35f 100644 --- a/src/libcollections/btree/map.rs +++ b/src/libcollections/btree/map.rs @@ -23,7 +23,9 @@ use core::borrow::BorrowFrom; use core::cmp::Ordering; use core::default::Default; use core::fmt::Show; -use core::hash::{Writer, Hash}; +use core::hash::{Hash, Hasher}; +#[cfg(stage0)] +use core::hash::Writer; use core::iter::{Map, FromIterator}; use core::ops::{Index, IndexMut}; use core::{iter, fmt, mem}; @@ -820,6 +822,7 @@ impl<K: Ord, V> Extend<(K, V)> for BTreeMap<K, V> { } #[stable] +#[cfg(stage0)] impl<S: Writer, K: Hash<S>, V: Hash<S>> Hash<S> for BTreeMap<K, V> { fn hash(&self, state: &mut S) { for elt in self.iter() { @@ -827,6 +830,15 @@ impl<S: Writer, K: Hash<S>, V: Hash<S>> Hash<S> for BTreeMap<K, V> { } } } +#[stable] +#[cfg(not(stage0))] +impl<S: Hasher, K: Hash<S>, V: Hash<S>> Hash<S> for BTreeMap<K, V> { + fn hash(&self, state: &mut S) { + for elt in self.iter() { + elt.hash(state); + } + } +} #[stable] impl<K: Ord, V> Default for BTreeMap<K, V> { diff --git a/src/libcollections/btree/set.rs b/src/libcollections/btree/set.rs index 25df4a3cc2a..812cff6fab7 100644 --- a/src/libcollections/btree/set.rs +++ b/src/libcollections/btree/set.rs @@ -678,7 +678,7 @@ mod test { use prelude::*; use super::BTreeSet; - use std::hash; + use std::hash::{self, SipHasher}; #[test] fn test_clone_eq() { @@ -703,7 +703,7 @@ mod test { y.insert(2); y.insert(1); - assert!(hash::hash(&x) == hash::hash(&y)); + assert!(hash::hash::<_, SipHasher>(&x) == hash::hash::<_, SipHasher>(&y)); } struct Counter<'a, 'b> { diff --git a/src/libcollections/dlist.rs b/src/libcollections/dlist.rs index 63ea9f7cb43..0b426f6016c 100644 --- a/src/libcollections/dlist.rs +++ b/src/libcollections/dlist.rs @@ -27,7 +27,7 @@ use alloc::boxed::Box; use core::cmp::Ordering; use core::default::Default; use core::fmt; -use core::hash::{Writer, Hash}; +use core::hash::{Writer, Hasher, Hash}; use core::iter::{self, FromIterator}; use core::mem; use core::ptr; @@ -675,7 +675,7 @@ impl<A: fmt::Show> fmt::Show for DList<A> { } #[stable] -impl<S: Writer, A: Hash<S>> Hash<S> for DList<A> { +impl<S: Writer + Hasher, A: Hash<S>> Hash<S> for DList<A> { fn hash(&self, state: &mut S) { self.len().hash(state); for elt in self.iter() { @@ -688,7 +688,7 @@ impl<S: Writer, A: Hash<S>> Hash<S> for DList<A> { mod tests { use prelude::*; use std::rand; - use std::hash; + use std::hash::{self, SipHasher}; use std::thread::Thread; use test::Bencher; use test; @@ -951,7 +951,7 @@ mod tests { let mut x = DList::new(); let mut y = DList::new(); - assert!(hash::hash(&x) == hash::hash(&y)); + assert!(hash::hash::<_, SipHasher>(&x) == hash::hash::<_, SipHasher>(&y)); x.push_back(1i); x.push_back(2); @@ -961,7 +961,7 @@ mod tests { y.push_front(2); y.push_front(1); - assert!(hash::hash(&x) == hash::hash(&y)); + assert!(hash::hash::<_, SipHasher>(&x) == hash::hash::<_, SipHasher>(&y)); } #[test] diff --git a/src/libcollections/lib.rs b/src/libcollections/lib.rs index 6eab36d8844..7692c1558a7 100644 --- a/src/libcollections/lib.rs +++ b/src/libcollections/lib.rs @@ -15,6 +15,7 @@ #![crate_name = "collections"] #![experimental] +#![staged_api] #![crate_type = "rlib"] #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png", html_favicon_url = "http://www.rust-lang.org/favicon.ico", @@ -23,8 +24,9 @@ #![allow(unknown_features)] #![feature(unsafe_destructor, slicing_syntax)] -#![feature(old_impl_check)] +#![feature(box_syntax)] #![feature(unboxed_closures)] +#![feature(old_impl_check)] #![no_std] #[macro_use] @@ -101,8 +103,6 @@ mod std { pub use core::option; // necessary for panic!() pub use core::clone; // deriving(Clone) pub use core::cmp; // deriving(Eq, Ord, etc.) - #[cfg(stage0)] - pub use core::marker as kinds; pub use core::marker; // deriving(Copy) pub use core::hash; // deriving(Hash) } diff --git a/src/libcollections/macros.rs b/src/libcollections/macros.rs index 68e2482964d..0ff869d6183 100644 --- a/src/libcollections/macros.rs +++ b/src/libcollections/macros.rs @@ -10,9 +10,10 @@ /// Creates a `Vec` containing the arguments. #[macro_export] +#[stable] macro_rules! vec { ($($x:expr),*) => ({ - let xs: $crate::boxed::Box<[_]> = box [$($x),*]; + let xs: $crate::boxed::Box<[_]> = $crate::boxed::Box::new([$($x),*]); $crate::slice::SliceExt::into_vec(xs) }); ($($x:expr,)*) => (vec![$($x),*]) diff --git a/src/libcollections/ring_buf.rs b/src/libcollections/ring_buf.rs index 42c17136a08..c3d22675868 100644 --- a/src/libcollections/ring_buf.rs +++ b/src/libcollections/ring_buf.rs @@ -27,7 +27,7 @@ use core::ops::{Index, IndexMut}; use core::ptr; use core::raw::Slice as RawSlice; -use std::hash::{Writer, Hash}; +use std::hash::{Writer, Hash, Hasher}; use std::cmp; use alloc::heap; @@ -556,7 +556,7 @@ impl<T> RingBuf<T> { let buf = self.buffer_as_slice(); if contiguous { let (empty, buf) = buf.split_at(0); - (buf.index(&(self.tail..self.head)), empty) + (&buf[self.tail..self.head], empty) } else { let (mid, right) = buf.split_at(self.tail); let (left, _) = mid.split_at(self.head); @@ -1562,7 +1562,7 @@ impl<A: Ord> Ord for RingBuf<A> { } #[stable] -impl<S: Writer, A: Hash<S>> Hash<S> for RingBuf<A> { +impl<S: Writer + Hasher, A: Hash<S>> Hash<S> for RingBuf<A> { fn hash(&self, state: &mut S) { self.len().hash(state); for elt in self.iter() { @@ -1631,7 +1631,7 @@ mod tests { use prelude::*; use core::iter; use std::fmt::Show; - use std::hash; + use std::hash::{self, SipHasher}; use test::Bencher; use test; @@ -2283,7 +2283,7 @@ mod tests { y.push_back(2); y.push_back(3); - assert!(hash::hash(&x) == hash::hash(&y)); + assert!(hash::hash::<_, SipHasher>(&x) == hash::hash::<_, SipHasher>(&y)); } #[test] diff --git a/src/libcollections/slice.rs b/src/libcollections/slice.rs index 61309f0cc0f..cb3fbd461cd 100644 --- a/src/libcollections/slice.rs +++ b/src/libcollections/slice.rs @@ -55,7 +55,7 @@ //! #![feature(slicing_syntax)] //! fn main() { //! let numbers = [0i, 1i, 2i]; -//! let last_numbers = numbers.index(&(1..3)); +//! let last_numbers = &numbers[1..3]; //! // last_numbers is now &[1i, 2i] //! } //! ``` @@ -98,7 +98,7 @@ use core::iter::{range, range_step, MultiplicativeIterator}; use core::marker::Sized; use core::mem::size_of; use core::mem; -use core::ops::{FnMut, FullRange, Index, IndexMut}; +use core::ops::{FnMut, FullRange}; use core::option::Option::{self, Some, None}; use core::ptr::PtrExt; use core::ptr; @@ -245,7 +245,7 @@ pub trait SliceExt { /// ```rust /// let v = &[1i, 2, 3, 4]; /// for win in v.windows(2) { - /// println!("{}", win); + /// println!("{:?}", win); /// } /// ``` #[stable] @@ -268,7 +268,7 @@ pub trait SliceExt { /// ```rust /// let v = &[1i, 2, 3, 4, 5]; /// for win in v.chunks(2) { - /// println!("{}", win); + /// println!("{:?}", win); /// } /// ``` #[stable] @@ -554,7 +554,7 @@ pub trait SliceExt { /// let mut perms = v.permutations(); /// /// for p in perms { - /// println!("{}", p); + /// println!("{:?}", p); /// } /// ``` /// @@ -1065,12 +1065,12 @@ impl ElementSwaps { #[unstable = "trait is unstable"] impl<T> BorrowFrom<Vec<T>> for [T] { - fn borrow_from(owned: &Vec<T>) -> &[T] { owned.index(&FullRange) } + fn borrow_from(owned: &Vec<T>) -> &[T] { &owned[] } } #[unstable = "trait is unstable"] impl<T> BorrowFromMut<Vec<T>> for [T] { - fn borrow_from_mut(owned: &mut Vec<T>) -> &mut [T] { owned.index_mut(&FullRange) } + fn borrow_from_mut(owned: &mut Vec<T>) -> &mut [T] { &mut owned[] } } #[unstable = "trait is unstable"] @@ -1400,7 +1400,6 @@ mod tests { use core::prelude::{Ord, FullRange}; use core::default::Default; use core::mem; - use core::ops::Index; use std::iter::RandomAccessIterator; use std::rand::{Rng, thread_rng}; use std::rc::Rc; @@ -1611,7 +1610,7 @@ mod tests { // Test on stack. let vec_stack: &[_] = &[1i, 2, 3]; - let v_b = vec_stack.index(&(1u..3u)).to_vec(); + let v_b = vec_stack[1u..3u].to_vec(); assert_eq!(v_b.len(), 2u); let v_b = v_b.as_slice(); assert_eq!(v_b[0], 2); @@ -1619,7 +1618,7 @@ mod tests { // Test `Box<[T]>` let vec_unique = vec![1i, 2, 3, 4, 5, 6]; - let v_d = vec_unique.index(&(1u..6u)).to_vec(); + let v_d = vec_unique[1u..6u].to_vec(); assert_eq!(v_d.len(), 5u); let v_d = v_d.as_slice(); assert_eq!(v_d[0], 2); @@ -1632,21 +1631,21 @@ mod tests { #[test] fn test_slice_from() { let vec: &[int] = &[1, 2, 3, 4]; - assert_eq!(vec.index(&(0..)), vec); + assert_eq!(&vec[0..], vec); let b: &[int] = &[3, 4]; - assert_eq!(vec.index(&(2..)), b); + assert_eq!(&vec[2..], b); let b: &[int] = &[]; - assert_eq!(vec.index(&(4..)), b); + assert_eq!(&vec[4..], b); } #[test] fn test_slice_to() { let vec: &[int] = &[1, 2, 3, 4]; - assert_eq!(vec.index(&(0..4)), vec); + assert_eq!(&vec[0..4], vec); let b: &[int] = &[1, 2]; - assert_eq!(vec.index(&(0..2)), b); + assert_eq!(&vec[0..2], b); let b: &[int] = &[]; - assert_eq!(vec.index(&(0..0)), b); + assert_eq!(&vec[0..0], b); } @@ -2572,7 +2571,7 @@ mod tests { } assert_eq!(cnt, 3); - for f in v.index(&(1..3)).iter() { + for f in v[1..3].iter() { assert!(*f == Foo); cnt += 1; } diff --git a/src/libcollections/str.rs b/src/libcollections/str.rs index 09d140067f4..ccf654ac0a0 100644 --- a/src/libcollections/str.rs +++ b/src/libcollections/str.rs @@ -386,7 +386,7 @@ macro_rules! utf8_acc_cont_byte { #[unstable = "trait is unstable"] impl BorrowFrom<String> for str { - fn borrow_from(owned: &String) -> &str { owned.index(&FullRange) } + fn borrow_from(owned: &String) -> &str { &owned[] } } #[unstable = "trait is unstable"] @@ -464,7 +464,7 @@ pub trait StrExt: Index<FullRange, Output = str> { #[unstable = "this functionality may be moved to libunicode"] fn nfd_chars<'a>(&'a self) -> Decompositions<'a> { Decompositions { - iter: self.index(&FullRange).chars(), + iter: self[].chars(), buffer: Vec::new(), sorted: false, kind: Canonical @@ -477,7 +477,7 @@ pub trait StrExt: Index<FullRange, Output = str> { #[unstable = "this functionality may be moved to libunicode"] fn nfkd_chars<'a>(&'a self) -> Decompositions<'a> { Decompositions { - iter: self.index(&FullRange).chars(), + iter: self[].chars(), buffer: Vec::new(), sorted: false, kind: Compatible @@ -525,7 +525,7 @@ pub trait StrExt: Index<FullRange, Output = str> { /// ``` #[stable] fn contains(&self, pat: &str) -> bool { - core_str::StrExt::contains(self.index(&FullRange), pat) + core_str::StrExt::contains(&self[], pat) } /// Returns true if a string contains a char pattern. @@ -541,7 +541,7 @@ pub trait StrExt: Index<FullRange, Output = str> { /// ``` #[unstable = "might get removed in favour of a more generic contains()"] fn contains_char<P: CharEq>(&self, pat: P) -> bool { - core_str::StrExt::contains_char(self.index(&FullRange), pat) + core_str::StrExt::contains_char(&self[], pat) } /// An iterator over the characters of `self`. Note, this iterates @@ -555,7 +555,7 @@ pub trait StrExt: Index<FullRange, Output = str> { /// ``` #[stable] fn chars(&self) -> Chars { - core_str::StrExt::chars(self.index(&FullRange)) + core_str::StrExt::chars(&self[]) } /// An iterator over the bytes of `self` @@ -568,13 +568,13 @@ pub trait StrExt: Index<FullRange, Output = str> { /// ``` #[stable] fn bytes(&self) -> Bytes { - core_str::StrExt::bytes(self.index(&FullRange)) + core_str::StrExt::bytes(&self[]) } /// An iterator over the characters of `self` and their byte offsets. #[stable] fn char_indices(&self) -> CharIndices { - core_str::StrExt::char_indices(self.index(&FullRange)) + core_str::StrExt::char_indices(&self[]) } /// An iterator over substrings of `self`, separated by characters @@ -597,7 +597,7 @@ pub trait StrExt: Index<FullRange, Output = str> { /// ``` #[stable] fn split<P: CharEq>(&self, pat: P) -> Split<P> { - core_str::StrExt::split(self.index(&FullRange), pat) + core_str::StrExt::split(&self[], pat) } /// An iterator over substrings of `self`, separated by characters @@ -624,7 +624,7 @@ pub trait StrExt: Index<FullRange, Output = str> { /// ``` #[stable] fn splitn<P: CharEq>(&self, count: uint, pat: P) -> SplitN<P> { - core_str::StrExt::splitn(self.index(&FullRange), count, pat) + core_str::StrExt::splitn(&self[], count, pat) } /// An iterator over substrings of `self`, separated by characters @@ -653,7 +653,7 @@ pub trait StrExt: Index<FullRange, Output = str> { /// ``` #[unstable = "might get removed"] fn split_terminator<P: CharEq>(&self, pat: P) -> SplitTerminator<P> { - core_str::StrExt::split_terminator(self.index(&FullRange), pat) + core_str::StrExt::split_terminator(&self[], pat) } /// An iterator over substrings of `self`, separated by characters @@ -674,7 +674,7 @@ pub trait StrExt: Index<FullRange, Output = str> { /// ``` #[stable] fn rsplitn<P: CharEq>(&self, count: uint, pat: P) -> RSplitN<P> { - core_str::StrExt::rsplitn(self.index(&FullRange), count, pat) + core_str::StrExt::rsplitn(&self[], count, pat) } /// An iterator over the start and end indices of the disjoint @@ -699,7 +699,7 @@ pub trait StrExt: Index<FullRange, Output = str> { /// ``` #[unstable = "might have its iterator type changed"] fn match_indices<'a>(&'a self, pat: &'a str) -> MatchIndices<'a> { - core_str::StrExt::match_indices(self.index(&FullRange), pat) + core_str::StrExt::match_indices(&self[], pat) } /// An iterator over the substrings of `self` separated by the pattern `sep`. @@ -715,7 +715,7 @@ pub trait StrExt: Index<FullRange, Output = str> { /// ``` #[unstable = "might get removed in the future in favor of a more generic split()"] fn split_str<'a>(&'a self, pat: &'a str) -> SplitStr<'a> { - core_str::StrExt::split_str(self.index(&FullRange), pat) + core_str::StrExt::split_str(&self[], pat) } /// An iterator over the lines of a string (subsequences separated @@ -731,7 +731,7 @@ pub trait StrExt: Index<FullRange, Output = str> { /// ``` #[stable] fn lines(&self) -> Lines { - core_str::StrExt::lines(self.index(&FullRange)) + core_str::StrExt::lines(&self[]) } /// An iterator over the lines of a string, separated by either @@ -747,7 +747,7 @@ pub trait StrExt: Index<FullRange, Output = str> { /// ``` #[stable] fn lines_any(&self) -> LinesAny { - core_str::StrExt::lines_any(self.index(&FullRange)) + core_str::StrExt::lines_any(&self[]) } /// Returns a slice of the given string from the byte range @@ -782,7 +782,7 @@ pub trait StrExt: Index<FullRange, Output = str> { /// ``` #[unstable = "use slice notation [a..b] instead"] fn slice(&self, begin: uint, end: uint) -> &str { - core_str::StrExt::slice(self.index(&FullRange), begin, end) + core_str::StrExt::slice(&self[], begin, end) } /// Returns a slice of the string from `begin` to its end. @@ -795,7 +795,7 @@ pub trait StrExt: Index<FullRange, Output = str> { /// See also `slice`, `slice_to` and `slice_chars`. #[unstable = "use slice notation [a..] instead"] fn slice_from(&self, begin: uint) -> &str { - core_str::StrExt::slice_from(self.index(&FullRange), begin) + core_str::StrExt::slice_from(&self[], begin) } /// Returns a slice of the string from the beginning to byte @@ -809,7 +809,7 @@ pub trait StrExt: Index<FullRange, Output = str> { /// See also `slice`, `slice_from` and `slice_chars`. #[unstable = "use slice notation [0..a] instead"] fn slice_to(&self, end: uint) -> &str { - core_str::StrExt::slice_to(self.index(&FullRange), end) + core_str::StrExt::slice_to(&self[], end) } /// Returns a slice of the string from the character range @@ -837,7 +837,7 @@ pub trait StrExt: Index<FullRange, Output = str> { /// ``` #[unstable = "may have yet to prove its worth"] fn slice_chars(&self, begin: uint, end: uint) -> &str { - core_str::StrExt::slice_chars(self.index(&FullRange), begin, end) + core_str::StrExt::slice_chars(&self[], begin, end) } /// Takes a bytewise (not UTF-8) slice from a string. @@ -848,7 +848,7 @@ pub trait StrExt: Index<FullRange, Output = str> { /// the entire slice as well. #[stable] unsafe fn slice_unchecked(&self, begin: uint, end: uint) -> &str { - core_str::StrExt::slice_unchecked(self.index(&FullRange), begin, end) + core_str::StrExt::slice_unchecked(&self[], begin, end) } /// Returns true if the pattern `pat` is a prefix of the string. @@ -860,7 +860,7 @@ pub trait StrExt: Index<FullRange, Output = str> { /// ``` #[stable] fn starts_with(&self, pat: &str) -> bool { - core_str::StrExt::starts_with(self.index(&FullRange), pat) + core_str::StrExt::starts_with(&self[], pat) } /// Returns true if the pattern `pat` is a suffix of the string. @@ -872,7 +872,7 @@ pub trait StrExt: Index<FullRange, Output = str> { /// ``` #[stable] fn ends_with(&self, pat: &str) -> bool { - core_str::StrExt::ends_with(self.index(&FullRange), pat) + core_str::StrExt::ends_with(&self[], pat) } /// Returns a string with all pre- and suffixes that match @@ -892,7 +892,7 @@ pub trait StrExt: Index<FullRange, Output = str> { /// ``` #[stable] fn trim_matches<P: CharEq>(&self, pat: P) -> &str { - core_str::StrExt::trim_matches(self.index(&FullRange), pat) + core_str::StrExt::trim_matches(&self[], pat) } /// Returns a string with all prefixes that match @@ -912,7 +912,7 @@ pub trait StrExt: Index<FullRange, Output = str> { /// ``` #[stable] fn trim_left_matches<P: CharEq>(&self, pat: P) -> &str { - core_str::StrExt::trim_left_matches(self.index(&FullRange), pat) + core_str::StrExt::trim_left_matches(&self[], pat) } /// Returns a string with all suffixes that match @@ -932,7 +932,7 @@ pub trait StrExt: Index<FullRange, Output = str> { /// ``` #[stable] fn trim_right_matches<P: CharEq>(&self, pat: P) -> &str { - core_str::StrExt::trim_right_matches(self.index(&FullRange), pat) + core_str::StrExt::trim_right_matches(&self[], pat) } /// Check that `index`-th byte lies at the start and/or end of a @@ -960,7 +960,7 @@ pub trait StrExt: Index<FullRange, Output = str> { /// ``` #[unstable = "naming is uncertain with container conventions"] fn is_char_boundary(&self, index: uint) -> bool { - core_str::StrExt::is_char_boundary(self.index(&FullRange), index) + core_str::StrExt::is_char_boundary(&self[], index) } /// Pluck a character out of a string and return the index of the next @@ -1018,7 +1018,7 @@ pub trait StrExt: Index<FullRange, Output = str> { /// If `i` is not the index of the beginning of a valid UTF-8 character. #[unstable = "naming is uncertain with container conventions"] fn char_range_at(&self, start: uint) -> CharRange { - core_str::StrExt::char_range_at(self.index(&FullRange), start) + core_str::StrExt::char_range_at(&self[], start) } /// Given a byte position and a str, return the previous char and its position. @@ -1033,7 +1033,7 @@ pub trait StrExt: Index<FullRange, Output = str> { /// If `i` is not an index following a valid UTF-8 character. #[unstable = "naming is uncertain with container conventions"] fn char_range_at_reverse(&self, start: uint) -> CharRange { - core_str::StrExt::char_range_at_reverse(self.index(&FullRange), start) + core_str::StrExt::char_range_at_reverse(&self[], start) } /// Plucks the character starting at the `i`th byte of a string. @@ -1053,7 +1053,7 @@ pub trait StrExt: Index<FullRange, Output = str> { /// If `i` is not the index of the beginning of a valid UTF-8 character. #[unstable = "naming is uncertain with container conventions"] fn char_at(&self, i: uint) -> char { - core_str::StrExt::char_at(self.index(&FullRange), i) + core_str::StrExt::char_at(&self[], i) } /// Plucks the character ending at the `i`th byte of a string. @@ -1064,7 +1064,7 @@ pub trait StrExt: Index<FullRange, Output = str> { /// If `i` is not an index following a valid UTF-8 character. #[unstable = "naming is uncertain with container conventions"] fn char_at_reverse(&self, i: uint) -> char { - core_str::StrExt::char_at_reverse(self.index(&FullRange), i) + core_str::StrExt::char_at_reverse(&self[], i) } /// Work with the byte buffer of a string as a byte slice. @@ -1076,7 +1076,7 @@ pub trait StrExt: Index<FullRange, Output = str> { /// ``` #[stable] fn as_bytes(&self) -> &[u8] { - core_str::StrExt::as_bytes(self.index(&FullRange)) + core_str::StrExt::as_bytes(&self[]) } /// Returns the byte index of the first character of `self` that @@ -1104,7 +1104,7 @@ pub trait StrExt: Index<FullRange, Output = str> { /// ``` #[stable] fn find<P: CharEq>(&self, pat: P) -> Option<uint> { - core_str::StrExt::find(self.index(&FullRange), pat) + core_str::StrExt::find(&self[], pat) } /// Returns the byte index of the last character of `self` that @@ -1132,7 +1132,7 @@ pub trait StrExt: Index<FullRange, Output = str> { /// ``` #[stable] fn rfind<P: CharEq>(&self, pat: P) -> Option<uint> { - core_str::StrExt::rfind(self.index(&FullRange), pat) + core_str::StrExt::rfind(&self[], pat) } /// Returns the byte index of the first matching substring @@ -1156,7 +1156,7 @@ pub trait StrExt: Index<FullRange, Output = str> { /// ``` #[unstable = "might get removed in favor of a more generic find in the future"] fn find_str(&self, needle: &str) -> Option<uint> { - core_str::StrExt::find_str(self.index(&FullRange), needle) + core_str::StrExt::find_str(&self[], needle) } /// Retrieves the first character from a string slice and returns @@ -1179,7 +1179,7 @@ pub trait StrExt: Index<FullRange, Output = str> { /// ``` #[unstable = "awaiting conventions about shifting and slices"] fn slice_shift_char(&self) -> Option<(char, &str)> { - core_str::StrExt::slice_shift_char(self.index(&FullRange)) + core_str::StrExt::slice_shift_char(&self[]) } /// Returns the byte offset of an inner slice relative to an enclosing outer slice. @@ -1198,7 +1198,7 @@ pub trait StrExt: Index<FullRange, Output = str> { /// ``` #[unstable = "awaiting convention about comparability of arbitrary slices"] fn subslice_offset(&self, inner: &str) -> uint { - core_str::StrExt::subslice_offset(self.index(&FullRange), inner) + core_str::StrExt::subslice_offset(&self[], inner) } /// Return an unsafe pointer to the strings buffer. @@ -1209,13 +1209,13 @@ pub trait StrExt: Index<FullRange, Output = str> { #[stable] #[inline] fn as_ptr(&self) -> *const u8 { - core_str::StrExt::as_ptr(self.index(&FullRange)) + core_str::StrExt::as_ptr(&self[]) } /// Return an iterator of `u16` over the string encoded as UTF-16. #[unstable = "this functionality may only be provided by libunicode"] fn utf16_units(&self) -> Utf16Units { - Utf16Units { encoder: Utf16Encoder::new(self.index(&FullRange).chars()) } + Utf16Units { encoder: Utf16Encoder::new(self[].chars()) } } /// Return the number of bytes in this string @@ -1229,7 +1229,7 @@ pub trait StrExt: Index<FullRange, Output = str> { #[stable] #[inline] fn len(&self) -> uint { - core_str::StrExt::len(self.index(&FullRange)) + core_str::StrExt::len(&self[]) } /// Returns true if this slice contains no bytes @@ -1242,7 +1242,7 @@ pub trait StrExt: Index<FullRange, Output = str> { #[inline] #[stable] fn is_empty(&self) -> bool { - core_str::StrExt::is_empty(self.index(&FullRange)) + core_str::StrExt::is_empty(&self[]) } /// Parse this string into the specified type. @@ -1256,7 +1256,7 @@ pub trait StrExt: Index<FullRange, Output = str> { #[inline] #[unstable = "this method was just created"] fn parse<F: FromStr>(&self) -> Option<F> { - core_str::StrExt::parse(self.index(&FullRange)) + core_str::StrExt::parse(&self[]) } /// Returns an iterator over the @@ -1280,7 +1280,7 @@ pub trait StrExt: Index<FullRange, Output = str> { /// ``` #[unstable = "this functionality may only be provided by libunicode"] fn graphemes(&self, is_extended: bool) -> Graphemes { - UnicodeStr::graphemes(self.index(&FullRange), is_extended) + UnicodeStr::graphemes(&self[], is_extended) } /// Returns an iterator over the grapheme clusters of self and their byte offsets. @@ -1295,7 +1295,7 @@ pub trait StrExt: Index<FullRange, Output = str> { /// ``` #[unstable = "this functionality may only be provided by libunicode"] fn grapheme_indices(&self, is_extended: bool) -> GraphemeIndices { - UnicodeStr::grapheme_indices(self.index(&FullRange), is_extended) + UnicodeStr::grapheme_indices(&self[], is_extended) } /// An iterator over the words of a string (subsequences separated @@ -1311,7 +1311,7 @@ pub trait StrExt: Index<FullRange, Output = str> { /// ``` #[stable] fn words(&self) -> Words { - UnicodeStr::words(self.index(&FullRange)) + UnicodeStr::words(&self[]) } /// Returns a string's displayed width in columns, treating control @@ -1325,25 +1325,25 @@ pub trait StrExt: Index<FullRange, Output = str> { /// `is_cjk` = `false`) if the locale is unknown. #[unstable = "this functionality may only be provided by libunicode"] fn width(&self, is_cjk: bool) -> uint { - UnicodeStr::width(self.index(&FullRange), is_cjk) + UnicodeStr::width(&self[], is_cjk) } /// Returns a string with leading and trailing whitespace removed. #[stable] fn trim(&self) -> &str { - UnicodeStr::trim(self.index(&FullRange)) + UnicodeStr::trim(&self[]) } /// Returns a string with leading whitespace removed. #[stable] fn trim_left(&self) -> &str { - UnicodeStr::trim_left(self.index(&FullRange)) + UnicodeStr::trim_left(&self[]) } /// Returns a string with trailing whitespace removed. #[stable] fn trim_right(&self) -> &str { - UnicodeStr::trim_right(self.index(&FullRange)) + UnicodeStr::trim_right(&self[]) } } diff --git a/src/libcollections/string.rs b/src/libcollections/string.rs index 59418f50e3c..1bb0be05b1e 100644 --- a/src/libcollections/string.rs +++ b/src/libcollections/string.rs @@ -168,7 +168,7 @@ impl String { if i > 0 { unsafe { - res.as_mut_vec().push_all(v.index(&(0..i))) + res.as_mut_vec().push_all(&v[0..i]) }; } @@ -185,7 +185,7 @@ impl String { macro_rules! error { () => ({ unsafe { if subseqidx != i_ { - res.as_mut_vec().push_all(v.index(&(subseqidx..i_))); + res.as_mut_vec().push_all(&v[subseqidx..i_]); } subseqidx = i; res.as_mut_vec().push_all(REPLACEMENT); @@ -254,7 +254,7 @@ impl String { } if subseqidx < total { unsafe { - res.as_mut_vec().push_all(v.index(&(subseqidx..total))) + res.as_mut_vec().push_all(&v[subseqidx..total]) }; } Cow::Owned(res) @@ -681,6 +681,7 @@ impl fmt::Show for FromUtf8Error { } } +#[stable] impl fmt::String for FromUtf8Error { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::String::fmt(&self.error, f) @@ -693,6 +694,7 @@ impl fmt::Show for FromUtf16Error { } } +#[stable] impl fmt::String for FromUtf16Error { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::String::fmt("invalid utf-16: lone surrogate found", f) @@ -805,7 +807,7 @@ impl Default for String { } } -#[experimental = "waiting on fmt stabilization"] +#[stable] impl fmt::String for String { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::String::fmt(&**self, f) @@ -820,12 +822,21 @@ impl fmt::Show for String { } #[experimental = "waiting on Hash stabilization"] +#[cfg(stage0)] impl<H: hash::Writer> hash::Hash<H> for String { #[inline] fn hash(&self, hasher: &mut H) { (**self).hash(hasher) } } +#[experimental = "waiting on Hash stabilization"] +#[cfg(not(stage0))] +impl<H: hash::Writer + hash::Hasher> hash::Hash<H> for String { + #[inline] + fn hash(&self, hasher: &mut H) { + (**self).hash(hasher) + } +} #[unstable = "recent addition, needs more experience"] impl<'a> Add<&'a str> for String { @@ -841,21 +852,21 @@ impl ops::Index<ops::Range<uint>> for String { type Output = str; #[inline] fn index(&self, index: &ops::Range<uint>) -> &str { - &self.index(&FullRange)[*index] + &self[][*index] } } impl ops::Index<ops::RangeTo<uint>> for String { type Output = str; #[inline] fn index(&self, index: &ops::RangeTo<uint>) -> &str { - &self.index(&FullRange)[*index] + &self[][*index] } } impl ops::Index<ops::RangeFrom<uint>> for String { type Output = str; #[inline] fn index(&self, index: &ops::RangeFrom<uint>) -> &str { - &self.index(&FullRange)[*index] + &self[][*index] } } impl ops::Index<ops::FullRange> for String { @@ -871,7 +882,7 @@ impl ops::Deref for String { type Target = str; fn deref<'a>(&'a self) -> &'a str { - unsafe { mem::transmute(self.vec.index(&FullRange)) } + unsafe { mem::transmute(&self.vec[]) } } } @@ -921,18 +932,6 @@ pub trait ToString { fn to_string(&self) -> String; } -#[cfg(stage0)] -impl<T: fmt::Show> ToString for T { - fn to_string(&self) -> String { - use core::fmt::Writer; - let mut buf = String::new(); - let _ = buf.write_fmt(format_args!("{}", self)); - buf.shrink_to_fit(); - buf - } -} - -#[cfg(not(stage0))] impl<T: fmt::String> ToString for T { fn to_string(&self) -> String { use core::fmt::Writer; @@ -1277,18 +1276,17 @@ mod tests { assert_eq!(2u8.to_string(), "2"); assert_eq!(true.to_string(), "true"); assert_eq!(false.to_string(), "false"); - assert_eq!(().to_string(), "()"); assert_eq!(("hi".to_string()).to_string(), "hi"); } #[test] fn test_vectors() { let x: Vec<int> = vec![]; - assert_eq!(x.to_string(), "[]"); - assert_eq!((vec![1i]).to_string(), "[1]"); - assert_eq!((vec![1i, 2, 3]).to_string(), "[1, 2, 3]"); - assert!((vec![vec![], vec![1i], vec![1i, 1]]).to_string() == - "[[], [1], [1, 1]]"); + assert_eq!(format!("{:?}", x), "[]"); + assert_eq!(format!("{:?}", vec![1i]), "[1i]"); + assert_eq!(format!("{:?}", vec![1i, 2, 3]), "[1i, 2i, 3i]"); + assert!(format!("{:?}", vec![vec![], vec![1i], vec![1i, 1]]) == + "[[], [1i], [1i, 1i]]"); } #[test] diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs index 5fc3fafac9e..d9344d130b2 100644 --- a/src/libcollections/vec.rs +++ b/src/libcollections/vec.rs @@ -1178,17 +1178,25 @@ impl<T:Clone> Clone for Vec<T> { // self.len <= other.len due to the truncate above, so the // slice here is always in-bounds. - let slice = other.index(&(self.len()..)); + let slice = &other[self.len()..]; self.push_all(slice); } } +#[cfg(stage0)] impl<S: hash::Writer, T: Hash<S>> Hash<S> for Vec<T> { #[inline] fn hash(&self, state: &mut S) { self.as_slice().hash(state); } } +#[cfg(not(stage0))] +impl<S: hash::Writer + hash::Hasher, T: Hash<S>> Hash<S> for Vec<T> { + #[inline] + fn hash(&self, state: &mut S) { + self.as_slice().hash(state); + } +} #[experimental = "waiting on Index stability"] impl<T> Index<uint> for Vec<T> { @@ -1454,22 +1462,6 @@ impl<T: fmt::Show> fmt::Show for Vec<T> { } } -#[cfg(stage0)] -#[experimental = "waiting on Show stability"] -impl<T: fmt::Show> fmt::String for Vec<T> { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::String::fmt(self.as_slice(), f) - } -} - -#[cfg(not(stage0))] -#[experimental = "waiting on Show stability"] -impl<T: fmt::String> fmt::String for Vec<T> { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::String::fmt(self.as_slice(), f) - } -} - impl<'a> fmt::Writer for Vec<u8> { fn write_str(&mut self, s: &str) -> fmt::Result { self.push_all(s.as_bytes()); @@ -2039,7 +2031,7 @@ mod tests { v.push(()); assert_eq!(v.iter_mut().count(), 4); - for &() in v.iter_mut() {} + for &mut () in v.iter_mut() {} unsafe { v.set_len(0); } assert_eq!(v.iter_mut().count(), 0); } diff --git a/src/libcollections/vec_map.rs b/src/libcollections/vec_map.rs index 4399a6fec22..d4ce266d3e2 100644 --- a/src/libcollections/vec_map.rs +++ b/src/libcollections/vec_map.rs @@ -18,7 +18,7 @@ use core::prelude::*; use core::cmp::Ordering; use core::default::Default; use core::fmt; -use core::hash::{Hash, Writer}; +use core::hash::{Hash, Writer, Hasher}; use core::iter::{Enumerate, FilterMap, Map, FromIterator}; use core::iter; use core::mem::replace; @@ -85,7 +85,7 @@ impl<V:Clone> Clone for VecMap<V> { } } -impl<S: Writer, V: Hash<S>> Hash<S> for VecMap<V> { +impl<S: Writer + Hasher, V: Hash<S>> Hash<S> for VecMap<V> { fn hash(&self, state: &mut S) { // In order to not traverse the `VecMap` twice, count the elements // during iteration. @@ -712,7 +712,7 @@ impl<V> DoubleEndedIterator for IntoIter<V> { #[cfg(test)] mod test_map { use prelude::*; - use core::hash::hash; + use core::hash::{hash, SipHasher}; use super::VecMap; @@ -1004,7 +1004,7 @@ mod test_map { let mut x = VecMap::new(); let mut y = VecMap::new(); - assert!(hash(&x) == hash(&y)); + assert!(hash::<_, SipHasher>(&x) == hash::<_, SipHasher>(&y)); x.insert(1, 'a'); x.insert(2, 'b'); x.insert(3, 'c'); @@ -1013,12 +1013,12 @@ mod test_map { y.insert(2, 'b'); y.insert(1, 'a'); - assert!(hash(&x) == hash(&y)); + assert!(hash::<_, SipHasher>(&x) == hash::<_, SipHasher>(&y)); x.insert(1000, 'd'); x.remove(&1000); - assert!(hash(&x) == hash(&y)); + assert!(hash::<_, SipHasher>(&x) == hash::<_, SipHasher>(&y)); } #[test] diff --git a/src/libcore/array.rs b/src/libcore/array.rs index 05db9e11760..0cea0b3d88e 100644 --- a/src/libcore/array.rs +++ b/src/libcore/array.rs @@ -18,7 +18,7 @@ use clone::Clone; use cmp::{PartialEq, Eq, PartialOrd, Ord, Ordering}; use fmt; use marker::Copy; -use ops::{Deref, FullRange, Index}; +use ops::{Deref, FullRange}; use option::Option; // macro for implementing n-ary tuple functions and operations @@ -35,7 +35,7 @@ macro_rules! array_impls { #[unstable = "waiting for Show to stabilize"] impl<T:fmt::Show> fmt::Show for [T; $N] { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::Show::fmt(&self.index(&FullRange), f) + fmt::Show::fmt(&&self[], f) } } @@ -43,11 +43,11 @@ macro_rules! array_impls { impl<A, B> PartialEq<[B; $N]> for [A; $N] where A: PartialEq<B> { #[inline] fn eq(&self, other: &[B; $N]) -> bool { - self.index(&FullRange) == other.index(&FullRange) + &self[] == &other[] } #[inline] fn ne(&self, other: &[B; $N]) -> bool { - self.index(&FullRange) != other.index(&FullRange) + &self[] != &other[] } } @@ -58,11 +58,11 @@ macro_rules! array_impls { { #[inline(always)] fn eq(&self, other: &Rhs) -> bool { - PartialEq::eq(self.index(&FullRange), &**other) + PartialEq::eq(&self[], &**other) } #[inline(always)] fn ne(&self, other: &Rhs) -> bool { - PartialEq::ne(self.index(&FullRange), &**other) + PartialEq::ne(&self[], &**other) } } @@ -73,11 +73,11 @@ macro_rules! array_impls { { #[inline(always)] fn eq(&self, other: &[B; $N]) -> bool { - PartialEq::eq(&**self, other.index(&FullRange)) + PartialEq::eq(&**self, &other[]) } #[inline(always)] fn ne(&self, other: &[B; $N]) -> bool { - PartialEq::ne(&**self, other.index(&FullRange)) + PartialEq::ne(&**self, &other[]) } } @@ -88,23 +88,23 @@ macro_rules! array_impls { impl<T:PartialOrd> PartialOrd for [T; $N] { #[inline] fn partial_cmp(&self, other: &[T; $N]) -> Option<Ordering> { - PartialOrd::partial_cmp(&self.index(&FullRange), &other.index(&FullRange)) + PartialOrd::partial_cmp(&&self[], &&other[]) } #[inline] fn lt(&self, other: &[T; $N]) -> bool { - PartialOrd::lt(&self.index(&FullRange), &other.index(&FullRange)) + PartialOrd::lt(&&self[], &&other[]) } #[inline] fn le(&self, other: &[T; $N]) -> bool { - PartialOrd::le(&self.index(&FullRange), &other.index(&FullRange)) + PartialOrd::le(&&self[], &&other[]) } #[inline] fn ge(&self, other: &[T; $N]) -> bool { - PartialOrd::ge(&self.index(&FullRange), &other.index(&FullRange)) + PartialOrd::ge(&&self[], &&other[]) } #[inline] fn gt(&self, other: &[T; $N]) -> bool { - PartialOrd::gt(&self.index(&FullRange), &other.index(&FullRange)) + PartialOrd::gt(&&self[], &&other[]) } } @@ -112,7 +112,7 @@ macro_rules! array_impls { impl<T:Ord> Ord for [T; $N] { #[inline] fn cmp(&self, other: &[T; $N]) -> Ordering { - Ord::cmp(&self.index(&FullRange), &other.index(&FullRange)) + Ord::cmp(&&self[], &&other[]) } } )+ diff --git a/src/libcore/borrow.rs b/src/libcore/borrow.rs index 31631355422..4363a0a4441 100644 --- a/src/libcore/borrow.rs +++ b/src/libcore/borrow.rs @@ -133,7 +133,7 @@ impl<T> ToOwned<T> for T where T: Clone { /// } /// } /// ``` -//#[deriving(Show)] NOTE(stage0): uncomment after snapshot +#[derive(Show)] pub enum Cow<'a, T, B: ?Sized + 'a> where B: ToOwned<T> { /// Borrowed data. Borrowed(&'a B), @@ -142,16 +142,6 @@ pub enum Cow<'a, T, B: ?Sized + 'a> where B: ToOwned<T> { Owned(T) } -//NOTE(stage0): replace with deriving(Show) after snapshot -impl<'a, T, B: ?Sized> fmt::Show for Cow<'a, T, B> where - B: fmt::String + ToOwned<T>, - T: fmt::String -{ - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::String::fmt(self, f) - } -} - #[stable] impl<'a, T, B: ?Sized> Clone for Cow<'a, T, B> where B: ToOwned<T> { fn clone(&self) -> Cow<'a, T, B> { @@ -248,6 +238,7 @@ impl<'a, T, B: ?Sized> PartialOrd for Cow<'a, T, B> where B: PartialOrd + ToOwne } } +#[stable] impl<'a, T, B: ?Sized> fmt::String for Cow<'a, T, B> where B: fmt::String + ToOwned<T>, T: fmt::String, diff --git a/src/libcore/fmt/float.rs b/src/libcore/fmt/float.rs index d833b8fed77..0ffcb014c28 100644 --- a/src/libcore/fmt/float.rs +++ b/src/libcore/fmt/float.rs @@ -20,7 +20,7 @@ use fmt; use iter::{IteratorExt, range}; use num::{cast, Float, ToPrimitive}; use num::FpCategory as Fp; -use ops::{FnOnce, Index}; +use ops::FnOnce; use result::Result::Ok; use slice::{self, SliceExt}; use str::{self, StrExt}; @@ -332,5 +332,5 @@ pub fn float_to_str_bytes_common<T: Float, U, F>( } } - f(unsafe { str::from_utf8_unchecked(buf.index(&(0..end))) }) + f(unsafe { str::from_utf8_unchecked(&buf[0..end]) }) } diff --git a/src/libcore/fmt/mod.rs b/src/libcore/fmt/mod.rs index f9027f19068..69df413a88c 100644 --- a/src/libcore/fmt/mod.rs +++ b/src/libcore/fmt/mod.rs @@ -21,7 +21,7 @@ use mem; use option::Option; use option::Option::{Some, None}; use result::Result::Ok; -use ops::{Deref, FnOnce, Index}; +use ops::{Deref, FnOnce}; use result; use slice::SliceExt; use slice; @@ -219,6 +219,7 @@ impl<'a> Show for Arguments<'a> { } } +#[stable] impl<'a> String for Arguments<'a> { fn fmt(&self, fmt: &mut Formatter) -> Result { write(fmt.buf, *self) @@ -424,7 +425,7 @@ impl<'a> Formatter<'a> { for c in sign.into_iter() { let mut b = [0; 4]; let n = c.encode_utf8(&mut b).unwrap_or(0); - let b = unsafe { str::from_utf8_unchecked(b.index(&(0..n))) }; + let b = unsafe { str::from_utf8_unchecked(&b[0..n]) }; try!(f.buf.write_str(b)); } if prefixed { f.buf.write_str(prefix) } @@ -532,7 +533,7 @@ impl<'a> Formatter<'a> { let mut fill = [0u8; 4]; let len = self.fill.encode_utf8(&mut fill).unwrap_or(0); - let fill = unsafe { str::from_utf8_unchecked(fill.index(&(..len))) }; + let fill = unsafe { str::from_utf8_unchecked(&fill[..len]) }; for _ in range(0, pre_pad) { try!(self.buf.write_str(fill)); @@ -627,22 +628,13 @@ impl Show for bool { } } +#[stable] impl String for bool { fn fmt(&self, f: &mut Formatter) -> Result { String::fmt(if *self { "true" } else { "false" }, f) } } -#[cfg(stage0)] -//NOTE(stage0): remove impl after snapshot -impl Show for str { - fn fmt(&self, f: &mut Formatter) -> Result { - String::fmt(self, f) - } -} - -#[cfg(not(stage0))] -//NOTE(stage0): remove cfg after snapshot impl Show for str { fn fmt(&self, f: &mut Formatter) -> Result { try!(write!(f, "\"")); @@ -653,22 +645,13 @@ impl Show for str { } } +#[stable] impl String for str { fn fmt(&self, f: &mut Formatter) -> Result { f.pad(self) } } -#[cfg(stage0)] -//NOTE(stage0): remove impl after snapshot -impl Show for char { - fn fmt(&self, f: &mut Formatter) -> Result { - String::fmt(self, f) - } -} - -#[cfg(not(stage0))] -//NOTE(stage0): remove cfg after snapshot impl Show for char { fn fmt(&self, f: &mut Formatter) -> Result { use char::CharExt; @@ -680,11 +663,12 @@ impl Show for char { } } +#[stable] impl String for char { fn fmt(&self, f: &mut Formatter) -> Result { let mut utf8 = [0u8; 4]; let amt = self.encode_utf8(&mut utf8).unwrap_or(0); - let s: &str = unsafe { mem::transmute(utf8.index(&(0..amt))) }; + let s: &str = unsafe { mem::transmute(&utf8[0..amt]) }; String::fmt(s, f) } } @@ -725,6 +709,7 @@ macro_rules! floating { ($ty:ident) => { } } + #[stable] impl String for $ty { fn fmt(&self, fmt: &mut Formatter) -> Result { use num::Float; @@ -796,15 +781,9 @@ floating! { f64 } impl<T> Show for *const T { fn fmt(&self, f: &mut Formatter) -> Result { Pointer::fmt(self, f) } } -impl<T> String for *const T { - fn fmt(&self, f: &mut Formatter) -> Result { Pointer::fmt(self, f) } -} impl<T> Show for *mut T { fn fmt(&self, f: &mut Formatter) -> Result { Pointer::fmt(self, f) } } -impl<T> String for *mut T { - fn fmt(&self, f: &mut Formatter) -> Result { Pointer::fmt(self, f) } -} macro_rules! peel { ($name:ident, $($other:ident,)*) => (tuple! { $($other,)* }) @@ -863,61 +842,12 @@ impl<T: Show> Show for [T] { } } -#[cfg(stage0)] -impl<T: Show> String for [T] { - fn fmt(&self, f: &mut Formatter) -> Result { - if f.flags & (1 << (rt::FlagAlternate as uint)) == 0 { - try!(write!(f, "[")); - } - let mut is_first = true; - for x in self.iter() { - if is_first { - is_first = false; - } else { - try!(write!(f, ", ")); - } - try!(write!(f, "{}", *x)) - } - if f.flags & (1 << (rt::FlagAlternate as uint)) == 0 { - try!(write!(f, "]")); - } - Ok(()) - } -} -#[cfg(not(stage0))] -impl<T: String> String for [T] { - fn fmt(&self, f: &mut Formatter) -> Result { - if f.flags & (1 << (rt::FlagAlternate as uint)) == 0 { - try!(write!(f, "[")); - } - let mut is_first = true; - for x in self.iter() { - if is_first { - is_first = false; - } else { - try!(write!(f, ", ")); - } - try!(write!(f, "{}", *x)) - } - if f.flags & (1 << (rt::FlagAlternate as uint)) == 0 { - try!(write!(f, "]")); - } - Ok(()) - } -} - impl Show for () { fn fmt(&self, f: &mut Formatter) -> Result { f.pad("()") } } -impl String for () { - fn fmt(&self, f: &mut Formatter) -> Result { - f.pad("()") - } -} - impl<T: Copy + Show> Show for Cell<T> { fn fmt(&self, f: &mut Formatter) -> Result { write!(f, "Cell {{ value: {:?} }}", self.get()) @@ -946,6 +876,7 @@ impl<'b, T: Show> Show for RefMut<'b, T> { } } +#[stable] impl String for Utf8Error { fn fmt(&self, f: &mut Formatter) -> Result { match *self { diff --git a/src/libcore/fmt/num.rs b/src/libcore/fmt/num.rs index 17149aed3db..1df6f845225 100644 --- a/src/libcore/fmt/num.rs +++ b/src/libcore/fmt/num.rs @@ -16,7 +16,6 @@ use fmt; use iter::IteratorExt; -use ops::Index; use num::{Int, cast}; use slice::SliceExt; use str; @@ -62,7 +61,7 @@ trait GenericRadix { if x == zero { break }; // No more digits left to accumulate. } } - let buf = unsafe { str::from_utf8_unchecked(buf.index(&(curr..))) }; + let buf = unsafe { str::from_utf8_unchecked(&buf[curr..]) }; f.pad_integral(is_positive, self.prefix(), buf) } } @@ -155,14 +154,6 @@ pub fn radix<T>(x: T, base: u8) -> RadixFmt<T, Radix> { macro_rules! radix_fmt { ($T:ty as $U:ty, $fmt:ident, $S:expr) => { - #[cfg(stage0)] - impl fmt::Show for RadixFmt<$T, Radix> { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::String::fmt(self, f) - } - } - - #[cfg(not(stage0))] impl fmt::Show for RadixFmt<$T, Radix> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { try!(fmt::String::fmt(self, f)); @@ -188,14 +179,6 @@ macro_rules! int_base { macro_rules! show { ($T:ident with $S:expr) => { - #[cfg(stage0)] - impl fmt::Show for $T { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::String::fmt(self, f) - } - } - - #[cfg(not(stage0))] impl fmt::Show for $T { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { try!(fmt::String::fmt(self, f)); diff --git a/src/libcore/hash/mod.rs b/src/libcore/hash/mod.rs index d8b9cf9594d..a82ea009e13 100644 --- a/src/libcore/hash/mod.rs +++ b/src/libcore/hash/mod.rs @@ -16,8 +16,7 @@ //! # Examples //! //! ```rust -//! use std::hash; -//! use std::hash::Hash; +//! use std::hash::{hash, Hash, SipHasher}; //! //! #[derive(Hash)] //! struct Person { @@ -29,16 +28,14 @@ //! let person1 = Person { id: 5, name: "Janet".to_string(), phone: 555_666_7777 }; //! let person2 = Person { id: 5, name: "Bob".to_string(), phone: 555_666_7777 }; //! -//! assert!(hash::hash(&person1) != hash::hash(&person2)); +//! assert!(hash::<_, SipHasher>(&person1) != hash::<_, SipHasher>(&person2)); //! ``` //! //! If you need more control over how a value is hashed, you need to implement //! the trait `Hash`: //! //! ```rust -//! use std::hash; -//! use std::hash::Hash; -//! use std::hash::sip::SipState; +//! use std::hash::{hash, Hash, Hasher, Writer, SipHasher}; //! //! struct Person { //! id: uint, @@ -46,8 +43,8 @@ //! phone: u64, //! } //! -//! impl Hash for Person { -//! fn hash(&self, state: &mut SipState) { +//! impl<H: Hasher + Writer> Hash<H> for Person { +//! fn hash(&self, state: &mut H) { //! self.id.hash(state); //! self.phone.hash(state); //! } @@ -56,186 +53,382 @@ //! let person1 = Person { id: 5, name: "Janet".to_string(), phone: 555_666_7777 }; //! let person2 = Person { id: 5, name: "Bob".to_string(), phone: 555_666_7777 }; //! -//! assert!(hash::hash(&person1) == hash::hash(&person2)); +//! assert_eq!(hash::<_, SipHasher>(&person1), hash::<_, SipHasher>(&person2)); //! ``` -#![allow(unused_must_use)] +#![unstable = "module was recently redesigned"] -use prelude::*; +use default::Default; -use borrow::{Cow, ToOwned}; -use intrinsics::TypeId; -use mem; -use num::Int; +pub use self::sip::SipHasher; -/// Reexport the `sip::hash` function as our default hasher. -pub use self::sip::hash as hash; +mod sip; -pub mod sip; +/// A hashable type. +/// +/// The `H` type parameter is an abstract hash state that is used by the `Hash` +/// to compute the hash. Specific implementations of this trait may specialize +/// for particular instances of `H` in order to be able to optimize the hashing +/// behavior. +#[cfg(stage0)] +pub trait Hash<H> { + /// Feeds this value into the state given, updating the hasher as necessary. + fn hash(&self, state: &mut H); +} -/// A hashable type. The `S` type parameter is an abstract hash state that is -/// used by the `Hash` to compute the hash. It defaults to -/// `std::hash::sip::SipState`. -pub trait Hash<S = sip::SipState> { - /// Computes the hash of a value. - fn hash(&self, state: &mut S); +/// A hashable type. +/// +/// The `H` type parameter is an abstract hash state that is used by the `Hash` +/// to compute the hash. Specific implementations of this trait may specialize +/// for particular instances of `H` in order to be able to optimize the hashing +/// behavior. +#[cfg(not(stage0))] +pub trait Hash<H: Hasher> { + /// Feeds this value into the state given, updating the hasher as necessary. + fn hash(&self, state: &mut H); } -/// A trait that computes a hash for a value. The main users of this trait are -/// containers like `HashMap`, which need a generic way hash multiple types. -pub trait Hasher<S> { - /// Compute the hash of a value. - fn hash<T: ?Sized + Hash<S>>(&self, value: &T) -> u64; +/// A trait which represents the ability to hash an arbitrary stream of bytes. +pub trait Hasher { + /// Result type of one run of hashing generated by this hasher. + type Output; + + /// Resets this hasher back to its initial state (as if it were just + /// created). + fn reset(&mut self); + + /// Completes a round of hashing, producing the output hash generated. + fn finish(&self) -> Self::Output; } +/// A common bound on the `Hasher` parameter to `Hash` implementations in order +/// to generically hash an aggregate. +#[experimental = "this trait will likely be replaced by io::Writer"] #[allow(missing_docs)] pub trait Writer { fn write(&mut self, bytes: &[u8]); } +/// Hash a value with the default SipHasher algorithm (two initial keys of 0). +/// +/// The specified value will be hashed with this hasher and then the resulting +/// hash will be returned. +pub fn hash<T: Hash<H>, H: Hasher + Default>(value: &T) -> H::Output { + let mut h: H = Default::default(); + value.hash(&mut h); + h.finish() +} + ////////////////////////////////////////////////////////////////////////////// -macro_rules! impl_hash { - ($ty:ident, $uty:ident) => { - impl<S: Writer> Hash<S> for $ty { - #[inline] - fn hash(&self, state: &mut S) { - let a: [u8; ::$ty::BYTES] = unsafe { - mem::transmute((*self as $uty).to_le() as $ty) - }; - state.write(a.as_slice()) +#[cfg(stage0)] +mod impls { + use prelude::*; + + use borrow::{Cow, ToOwned}; + use intrinsics::TypeId; + use mem; + use super::{Hash, Writer}; + use num::Int; + + macro_rules! impl_hash { + ($ty:ident, $uty:ident) => { + impl<S: Writer> Hash<S> for $ty { + #[inline] + fn hash(&self, state: &mut S) { + let a: [u8; ::$ty::BYTES] = unsafe { + mem::transmute((*self as $uty).to_le() as $ty) + }; + state.write(a.as_slice()) + } } } } -} -impl_hash! { u8, u8 } -impl_hash! { u16, u16 } -impl_hash! { u32, u32 } -impl_hash! { u64, u64 } -impl_hash! { uint, uint } -impl_hash! { i8, u8 } -impl_hash! { i16, u16 } -impl_hash! { i32, u32 } -impl_hash! { i64, u64 } -impl_hash! { int, uint } - -impl<S: Writer> Hash<S> for bool { - #[inline] - fn hash(&self, state: &mut S) { - (*self as u8).hash(state); + impl_hash! { u8, u8 } + impl_hash! { u16, u16 } + impl_hash! { u32, u32 } + impl_hash! { u64, u64 } + impl_hash! { uint, uint } + impl_hash! { i8, u8 } + impl_hash! { i16, u16 } + impl_hash! { i32, u32 } + impl_hash! { i64, u64 } + impl_hash! { int, uint } + + impl<S: Writer> Hash<S> for bool { + #[inline] + fn hash(&self, state: &mut S) { + (*self as u8).hash(state); + } } -} -impl<S: Writer> Hash<S> for char { - #[inline] - fn hash(&self, state: &mut S) { - (*self as u32).hash(state); + impl<S: Writer> Hash<S> for char { + #[inline] + fn hash(&self, state: &mut S) { + (*self as u32).hash(state); + } } -} -impl<S: Writer> Hash<S> for str { - #[inline] - fn hash(&self, state: &mut S) { - state.write(self.as_bytes()); - 0xffu8.hash(state) + impl<S: Writer> Hash<S> for str { + #[inline] + fn hash(&self, state: &mut S) { + state.write(self.as_bytes()); + 0xffu8.hash(state) + } } -} -macro_rules! impl_hash_tuple { - () => ( - impl<S: Writer> Hash<S> for () { - #[inline] - fn hash(&self, state: &mut S) { - state.write(&[]); + macro_rules! impl_hash_tuple { + () => ( + impl<S> Hash<S> for () { + #[inline] + fn hash(&self, _state: &mut S) {} } - } - ); - - ( $($name:ident)+) => ( - impl<S: Writer, $($name: Hash<S>),*> Hash<S> for ($($name,)*) { - #[inline] - #[allow(non_snake_case)] - fn hash(&self, state: &mut S) { - match *self { - ($(ref $name,)*) => { - $( - $name.hash(state); - )* + ); + + ( $($name:ident)+) => ( + impl<S, $($name: Hash<S>),*> Hash<S> for ($($name,)*) { + #[inline] + #[allow(non_snake_case)] + fn hash(&self, state: &mut S) { + match *self { + ($(ref $name,)*) => { + $( + $name.hash(state); + )* + } } } } + ); + } + + impl_hash_tuple! {} + impl_hash_tuple! { A } + impl_hash_tuple! { A B } + impl_hash_tuple! { A B C } + impl_hash_tuple! { A B C D } + impl_hash_tuple! { A B C D E } + impl_hash_tuple! { A B C D E F } + impl_hash_tuple! { A B C D E F G } + impl_hash_tuple! { A B C D E F G H } + impl_hash_tuple! { A B C D E F G H I } + impl_hash_tuple! { A B C D E F G H I J } + impl_hash_tuple! { A B C D E F G H I J K } + impl_hash_tuple! { A B C D E F G H I J K L } + + impl<S: Writer, T: Hash<S>> Hash<S> for [T] { + #[inline] + fn hash(&self, state: &mut S) { + self.len().hash(state); + for elt in self.iter() { + elt.hash(state); + } } - ); -} + } + -impl_hash_tuple! {} -impl_hash_tuple! { A } -impl_hash_tuple! { A B } -impl_hash_tuple! { A B C } -impl_hash_tuple! { A B C D } -impl_hash_tuple! { A B C D E } -impl_hash_tuple! { A B C D E F } -impl_hash_tuple! { A B C D E F G } -impl_hash_tuple! { A B C D E F G H } -impl_hash_tuple! { A B C D E F G H I } -impl_hash_tuple! { A B C D E F G H I J } -impl_hash_tuple! { A B C D E F G H I J K } -impl_hash_tuple! { A B C D E F G H I J K L } - -impl<S: Writer, T: Hash<S>> Hash<S> for [T] { - #[inline] - fn hash(&self, state: &mut S) { - self.len().hash(state); - for elt in self.iter() { - elt.hash(state); + impl<'a, S, T: ?Sized + Hash<S>> Hash<S> for &'a T { + #[inline] + fn hash(&self, state: &mut S) { + (**self).hash(state); } } -} + impl<'a, S, T: ?Sized + Hash<S>> Hash<S> for &'a mut T { + #[inline] + fn hash(&self, state: &mut S) { + (**self).hash(state); + } + } -impl<'a, S: Writer, T: ?Sized + Hash<S>> Hash<S> for &'a T { - #[inline] - fn hash(&self, state: &mut S) { - (**self).hash(state); + impl<S: Writer, T> Hash<S> for *const T { + #[inline] + fn hash(&self, state: &mut S) { + // NB: raw-pointer Hash does _not_ dereference + // to the target; it just gives you the pointer-bytes. + (*self as uint).hash(state); + } } -} -impl<'a, S: Writer, T: ?Sized + Hash<S>> Hash<S> for &'a mut T { - #[inline] - fn hash(&self, state: &mut S) { - (**self).hash(state); + impl<S: Writer, T> Hash<S> for *mut T { + #[inline] + fn hash(&self, state: &mut S) { + // NB: raw-pointer Hash does _not_ dereference + // to the target; it just gives you the pointer-bytes. + (*self as uint).hash(state); + } } -} -impl<S: Writer, T> Hash<S> for *const T { - #[inline] - fn hash(&self, state: &mut S) { - // NB: raw-pointer Hash does _not_ dereference - // to the target; it just gives you the pointer-bytes. - (*self as uint).hash(state); + impl<S: Writer> Hash<S> for TypeId { + #[inline] + fn hash(&self, state: &mut S) { + self.hash().hash(state) + } } -} -impl<S: Writer, T> Hash<S> for *mut T { - #[inline] - fn hash(&self, state: &mut S) { - // NB: raw-pointer Hash does _not_ dereference - // to the target; it just gives you the pointer-bytes. - (*self as uint).hash(state); + impl<'a, T, B: ?Sized, S> Hash<S> for Cow<'a, T, B> + where B: Hash<S> + ToOwned<T> + { + #[inline] + fn hash(&self, state: &mut S) { + Hash::hash(&**self, state) + } } } -impl<S: Writer> Hash<S> for TypeId { - #[inline] - fn hash(&self, state: &mut S) { - self.hash().hash(state) +#[cfg(not(stage0))] +mod impls { + use prelude::*; + + use borrow::{Cow, ToOwned}; + use intrinsics::TypeId; + use mem; + use super::{Hash, Writer, Hasher}; + use num::Int; + + macro_rules! impl_hash { + ($ty:ident, $uty:ident) => { + impl<S: Writer + Hasher> Hash<S> for $ty { + #[inline] + fn hash(&self, state: &mut S) { + let a: [u8; ::$ty::BYTES] = unsafe { + mem::transmute((*self as $uty).to_le() as $ty) + }; + state.write(a.as_slice()) + } + } + } + } + + impl_hash! { u8, u8 } + impl_hash! { u16, u16 } + impl_hash! { u32, u32 } + impl_hash! { u64, u64 } + impl_hash! { uint, uint } + impl_hash! { i8, u8 } + impl_hash! { i16, u16 } + impl_hash! { i32, u32 } + impl_hash! { i64, u64 } + impl_hash! { int, uint } + + impl<S: Writer + Hasher> Hash<S> for bool { + #[inline] + fn hash(&self, state: &mut S) { + (*self as u8).hash(state); + } + } + + impl<S: Writer + Hasher> Hash<S> for char { + #[inline] + fn hash(&self, state: &mut S) { + (*self as u32).hash(state); + } + } + + impl<S: Writer + Hasher> Hash<S> for str { + #[inline] + fn hash(&self, state: &mut S) { + state.write(self.as_bytes()); + 0xffu8.hash(state) + } + } + + macro_rules! impl_hash_tuple { + () => ( + impl<S: Hasher> Hash<S> for () { + #[inline] + fn hash(&self, _state: &mut S) {} + } + ); + + ( $($name:ident)+) => ( + impl<S: Hasher, $($name: Hash<S>),*> Hash<S> for ($($name,)*) { + #[inline] + #[allow(non_snake_case)] + fn hash(&self, state: &mut S) { + match *self { + ($(ref $name,)*) => { + $( + $name.hash(state); + )* + } + } + } + } + ); + } + + impl_hash_tuple! {} + impl_hash_tuple! { A } + impl_hash_tuple! { A B } + impl_hash_tuple! { A B C } + impl_hash_tuple! { A B C D } + impl_hash_tuple! { A B C D E } + impl_hash_tuple! { A B C D E F } + impl_hash_tuple! { A B C D E F G } + impl_hash_tuple! { A B C D E F G H } + impl_hash_tuple! { A B C D E F G H I } + impl_hash_tuple! { A B C D E F G H I J } + impl_hash_tuple! { A B C D E F G H I J K } + impl_hash_tuple! { A B C D E F G H I J K L } + + impl<S: Writer + Hasher, T: Hash<S>> Hash<S> for [T] { + #[inline] + fn hash(&self, state: &mut S) { + self.len().hash(state); + for elt in self.iter() { + elt.hash(state); + } + } + } + + + impl<'a, S: Hasher, T: ?Sized + Hash<S>> Hash<S> for &'a T { + #[inline] + fn hash(&self, state: &mut S) { + (**self).hash(state); + } + } + + impl<'a, S: Hasher, T: ?Sized + Hash<S>> Hash<S> for &'a mut T { + #[inline] + fn hash(&self, state: &mut S) { + (**self).hash(state); + } } -} -impl<'a, T, B: ?Sized, S> Hash<S> for Cow<'a, T, B> where B: Hash<S> + ToOwned<T> { - #[inline] - fn hash(&self, state: &mut S) { - Hash::hash(&**self, state) + impl<S: Writer + Hasher, T> Hash<S> for *const T { + #[inline] + fn hash(&self, state: &mut S) { + // NB: raw-pointer Hash does _not_ dereference + // to the target; it just gives you the pointer-bytes. + (*self as uint).hash(state); + } + } + + impl<S: Writer + Hasher, T> Hash<S> for *mut T { + #[inline] + fn hash(&self, state: &mut S) { + // NB: raw-pointer Hash does _not_ dereference + // to the target; it just gives you the pointer-bytes. + (*self as uint).hash(state); + } + } + + impl<S: Writer + Hasher> Hash<S> for TypeId { + #[inline] + fn hash(&self, state: &mut S) { + self.hash().hash(state) + } + } + + impl<'a, T, B: ?Sized, S: Hasher> Hash<S> for Cow<'a, T, B> + where B: Hash<S> + ToOwned<T> + { + #[inline] + fn hash(&self, state: &mut S) { + Hash::hash(&**self, state) + } } } diff --git a/src/libcore/hash/sip.rs b/src/libcore/hash/sip.rs index c4d45e9c2c8..c20fb8457d2 100644 --- a/src/libcore/hash/sip.rs +++ b/src/libcore/hash/sip.rs @@ -11,27 +11,27 @@ // ignore-lexer-test FIXME #15883 //! An implementation of SipHash 2-4. -//! -//! See: http://131002.net/siphash/ -//! -//! Consider this as a main "general-purpose" hash for all hashtables: it -//! runs at good speed (competitive with spooky and city) and permits -//! strong _keyed_ hashing. Key your hashtables from a strong RNG, -//! such as `rand::Rng`. -//! -//! Although the SipHash algorithm is considered to be cryptographically -//! strong, this implementation has not been reviewed for such purposes. -//! As such, all cryptographic uses of this implementation are strongly -//! discouraged. use prelude::*; use default::Default; -use super::{Hash, Hasher, Writer}; - -/// `SipState` computes a SipHash 2-4 hash over a stream of bytes. -#[derive(Copy)] -pub struct SipState { +use super::{Hasher, Writer}; + +/// An implementation of SipHash 2-4. +/// +/// See: http://131002.net/siphash/ +/// +/// Consider this as a main "general-purpose" hash for all hashtables: it +/// runs at good speed (competitive with spooky and city) and permits +/// strong _keyed_ hashing. Key your hashtables from a strong RNG, +/// such as `rand::Rng`. +/// +/// Although the SipHash algorithm is considered to be cryptographically +/// strong, this implementation has not been reviewed for such purposes. +/// As such, all cryptographic uses of this implementation are strongly +/// discouraged. +#[allow(missing_copy_implementations)] +pub struct SipHasher { k0: u64, k1: u64, length: uint, // how many bytes we've processed @@ -86,17 +86,17 @@ macro_rules! compress { }) } -impl SipState { - /// Creates a `SipState` that is keyed off the provided keys. +impl SipHasher { + /// Creates a new `SipHasher` with the two initial keys set to 0. #[inline] - pub fn new() -> SipState { - SipState::new_with_keys(0, 0) + pub fn new() -> SipHasher { + SipHasher::new_with_keys(0, 0) } - /// Creates a `SipState` that is keyed off the provided keys. + /// Creates a `SipHasher` that is keyed off the provided keys. #[inline] - pub fn new_with_keys(key0: u64, key1: u64) -> SipState { - let mut state = SipState { + pub fn new_with_keys(key0: u64, key1: u64) -> SipHasher { + let mut state = SipHasher { k0: key0, k1: key1, length: 0, @@ -111,43 +111,12 @@ impl SipState { state } - /// Resets the state to its initial state. - #[inline] - pub fn reset(&mut self) { - self.length = 0; - self.v0 = self.k0 ^ 0x736f6d6570736575; - self.v1 = self.k1 ^ 0x646f72616e646f6d; - self.v2 = self.k0 ^ 0x6c7967656e657261; - self.v3 = self.k1 ^ 0x7465646279746573; - self.ntail = 0; - } - /// Returns the computed hash. - #[inline] - pub fn result(&self) -> u64 { - let mut v0 = self.v0; - let mut v1 = self.v1; - let mut v2 = self.v2; - let mut v3 = self.v3; - - let b: u64 = ((self.length as u64 & 0xff) << 56) | self.tail; - - v3 ^= b; - compress!(v0, v1, v2, v3); - compress!(v0, v1, v2, v3); - v0 ^= b; - - v2 ^= 0xff; - compress!(v0, v1, v2, v3); - compress!(v0, v1, v2, v3); - compress!(v0, v1, v2, v3); - compress!(v0, v1, v2, v3); - - v0 ^ v1 ^ v2 ^ v3 - } + #[deprecated = "renamed to finish"] + pub fn result(&self) -> u64 { self.finish() } } -impl Writer for SipState { +impl Writer for SipHasher { #[inline] fn write(&mut self, msg: &[u8]) { let length = msg.len(); @@ -195,355 +164,60 @@ impl Writer for SipState { } } -#[stable] -impl Clone for SipState { - #[inline] - fn clone(&self) -> SipState { - *self - } -} +impl Hasher for SipHasher { + type Output = u64; -#[stable] -impl Default for SipState { - #[inline] - #[stable] - fn default() -> SipState { - SipState::new() + fn reset(&mut self) { + self.length = 0; + self.v0 = self.k0 ^ 0x736f6d6570736575; + self.v1 = self.k1 ^ 0x646f72616e646f6d; + self.v2 = self.k0 ^ 0x6c7967656e657261; + self.v3 = self.k1 ^ 0x7465646279746573; + self.ntail = 0; } -} -/// `SipHasher` computes the SipHash algorithm from a stream of bytes. -#[derive(Clone)] -#[allow(missing_copy_implementations)] -pub struct SipHasher { - k0: u64, - k1: u64, -} + fn finish(&self) -> u64 { + let mut v0 = self.v0; + let mut v1 = self.v1; + let mut v2 = self.v2; + let mut v3 = self.v3; -impl SipHasher { - /// Creates a `Sip`. - #[inline] - pub fn new() -> SipHasher { - SipHasher::new_with_keys(0, 0) - } + let b: u64 = ((self.length as u64 & 0xff) << 56) | self.tail; - /// Creates a `Sip` that is keyed off the provided keys. - #[inline] - pub fn new_with_keys(key0: u64, key1: u64) -> SipHasher { - SipHasher { - k0: key0, - k1: key1, - } + v3 ^= b; + compress!(v0, v1, v2, v3); + compress!(v0, v1, v2, v3); + v0 ^= b; + + v2 ^= 0xff; + compress!(v0, v1, v2, v3); + compress!(v0, v1, v2, v3); + compress!(v0, v1, v2, v3); + compress!(v0, v1, v2, v3); + + v0 ^ v1 ^ v2 ^ v3 } } -impl Hasher<SipState> for SipHasher { +impl Clone for SipHasher { #[inline] - fn hash<T: ?Sized + Hash<SipState>>(&self, value: &T) -> u64 { - let mut state = SipState::new_with_keys(self.k0, self.k1); - value.hash(&mut state); - state.result() + fn clone(&self) -> SipHasher { + SipHasher { + k0: self.k0, + k1: self.k1, + length: self.length, + v0: self.v0, + v1: self.v1, + v2: self.v2, + v3: self.v3, + tail: self.tail, + ntail: self.ntail, + } } } impl Default for SipHasher { - #[inline] fn default() -> SipHasher { SipHasher::new() } } - -/// Hashes a value using the SipHash algorithm. -#[inline] -pub fn hash<T: ?Sized + Hash<SipState>>(value: &T) -> u64 { - let mut state = SipState::new(); - value.hash(&mut state); - state.result() -} - -/// Hashes a value with the SipHash algorithm with the provided keys. -#[inline] -pub fn hash_with_keys<T: ?Sized + Hash<SipState>>(k0: u64, k1: u64, value: &T) -> u64 { - let mut state = SipState::new_with_keys(k0, k1); - value.hash(&mut state); - state.result() -} - -#[cfg(test)] -mod tests { - use test::Bencher; - use prelude::*; - use std::fmt; - - use super::super::{Hash, Writer}; - use super::{SipState, hash, hash_with_keys}; - - // Hash just the bytes of the slice, without length prefix - struct Bytes<'a>(&'a [u8]); - - impl<'a, S: Writer> Hash<S> for Bytes<'a> { - #[allow(unused_must_use)] - fn hash(&self, state: &mut S) { - let Bytes(v) = *self; - state.write(v); - } - } - - #[test] - #[allow(unused_must_use)] - fn test_siphash() { - let vecs : [[u8; 8]; 64] = [ - [ 0x31, 0x0e, 0x0e, 0xdd, 0x47, 0xdb, 0x6f, 0x72, ], - [ 0xfd, 0x67, 0xdc, 0x93, 0xc5, 0x39, 0xf8, 0x74, ], - [ 0x5a, 0x4f, 0xa9, 0xd9, 0x09, 0x80, 0x6c, 0x0d, ], - [ 0x2d, 0x7e, 0xfb, 0xd7, 0x96, 0x66, 0x67, 0x85, ], - [ 0xb7, 0x87, 0x71, 0x27, 0xe0, 0x94, 0x27, 0xcf, ], - [ 0x8d, 0xa6, 0x99, 0xcd, 0x64, 0x55, 0x76, 0x18, ], - [ 0xce, 0xe3, 0xfe, 0x58, 0x6e, 0x46, 0xc9, 0xcb, ], - [ 0x37, 0xd1, 0x01, 0x8b, 0xf5, 0x00, 0x02, 0xab, ], - [ 0x62, 0x24, 0x93, 0x9a, 0x79, 0xf5, 0xf5, 0x93, ], - [ 0xb0, 0xe4, 0xa9, 0x0b, 0xdf, 0x82, 0x00, 0x9e, ], - [ 0xf3, 0xb9, 0xdd, 0x94, 0xc5, 0xbb, 0x5d, 0x7a, ], - [ 0xa7, 0xad, 0x6b, 0x22, 0x46, 0x2f, 0xb3, 0xf4, ], - [ 0xfb, 0xe5, 0x0e, 0x86, 0xbc, 0x8f, 0x1e, 0x75, ], - [ 0x90, 0x3d, 0x84, 0xc0, 0x27, 0x56, 0xea, 0x14, ], - [ 0xee, 0xf2, 0x7a, 0x8e, 0x90, 0xca, 0x23, 0xf7, ], - [ 0xe5, 0x45, 0xbe, 0x49, 0x61, 0xca, 0x29, 0xa1, ], - [ 0xdb, 0x9b, 0xc2, 0x57, 0x7f, 0xcc, 0x2a, 0x3f, ], - [ 0x94, 0x47, 0xbe, 0x2c, 0xf5, 0xe9, 0x9a, 0x69, ], - [ 0x9c, 0xd3, 0x8d, 0x96, 0xf0, 0xb3, 0xc1, 0x4b, ], - [ 0xbd, 0x61, 0x79, 0xa7, 0x1d, 0xc9, 0x6d, 0xbb, ], - [ 0x98, 0xee, 0xa2, 0x1a, 0xf2, 0x5c, 0xd6, 0xbe, ], - [ 0xc7, 0x67, 0x3b, 0x2e, 0xb0, 0xcb, 0xf2, 0xd0, ], - [ 0x88, 0x3e, 0xa3, 0xe3, 0x95, 0x67, 0x53, 0x93, ], - [ 0xc8, 0xce, 0x5c, 0xcd, 0x8c, 0x03, 0x0c, 0xa8, ], - [ 0x94, 0xaf, 0x49, 0xf6, 0xc6, 0x50, 0xad, 0xb8, ], - [ 0xea, 0xb8, 0x85, 0x8a, 0xde, 0x92, 0xe1, 0xbc, ], - [ 0xf3, 0x15, 0xbb, 0x5b, 0xb8, 0x35, 0xd8, 0x17, ], - [ 0xad, 0xcf, 0x6b, 0x07, 0x63, 0x61, 0x2e, 0x2f, ], - [ 0xa5, 0xc9, 0x1d, 0xa7, 0xac, 0xaa, 0x4d, 0xde, ], - [ 0x71, 0x65, 0x95, 0x87, 0x66, 0x50, 0xa2, 0xa6, ], - [ 0x28, 0xef, 0x49, 0x5c, 0x53, 0xa3, 0x87, 0xad, ], - [ 0x42, 0xc3, 0x41, 0xd8, 0xfa, 0x92, 0xd8, 0x32, ], - [ 0xce, 0x7c, 0xf2, 0x72, 0x2f, 0x51, 0x27, 0x71, ], - [ 0xe3, 0x78, 0x59, 0xf9, 0x46, 0x23, 0xf3, 0xa7, ], - [ 0x38, 0x12, 0x05, 0xbb, 0x1a, 0xb0, 0xe0, 0x12, ], - [ 0xae, 0x97, 0xa1, 0x0f, 0xd4, 0x34, 0xe0, 0x15, ], - [ 0xb4, 0xa3, 0x15, 0x08, 0xbe, 0xff, 0x4d, 0x31, ], - [ 0x81, 0x39, 0x62, 0x29, 0xf0, 0x90, 0x79, 0x02, ], - [ 0x4d, 0x0c, 0xf4, 0x9e, 0xe5, 0xd4, 0xdc, 0xca, ], - [ 0x5c, 0x73, 0x33, 0x6a, 0x76, 0xd8, 0xbf, 0x9a, ], - [ 0xd0, 0xa7, 0x04, 0x53, 0x6b, 0xa9, 0x3e, 0x0e, ], - [ 0x92, 0x59, 0x58, 0xfc, 0xd6, 0x42, 0x0c, 0xad, ], - [ 0xa9, 0x15, 0xc2, 0x9b, 0xc8, 0x06, 0x73, 0x18, ], - [ 0x95, 0x2b, 0x79, 0xf3, 0xbc, 0x0a, 0xa6, 0xd4, ], - [ 0xf2, 0x1d, 0xf2, 0xe4, 0x1d, 0x45, 0x35, 0xf9, ], - [ 0x87, 0x57, 0x75, 0x19, 0x04, 0x8f, 0x53, 0xa9, ], - [ 0x10, 0xa5, 0x6c, 0xf5, 0xdf, 0xcd, 0x9a, 0xdb, ], - [ 0xeb, 0x75, 0x09, 0x5c, 0xcd, 0x98, 0x6c, 0xd0, ], - [ 0x51, 0xa9, 0xcb, 0x9e, 0xcb, 0xa3, 0x12, 0xe6, ], - [ 0x96, 0xaf, 0xad, 0xfc, 0x2c, 0xe6, 0x66, 0xc7, ], - [ 0x72, 0xfe, 0x52, 0x97, 0x5a, 0x43, 0x64, 0xee, ], - [ 0x5a, 0x16, 0x45, 0xb2, 0x76, 0xd5, 0x92, 0xa1, ], - [ 0xb2, 0x74, 0xcb, 0x8e, 0xbf, 0x87, 0x87, 0x0a, ], - [ 0x6f, 0x9b, 0xb4, 0x20, 0x3d, 0xe7, 0xb3, 0x81, ], - [ 0xea, 0xec, 0xb2, 0xa3, 0x0b, 0x22, 0xa8, 0x7f, ], - [ 0x99, 0x24, 0xa4, 0x3c, 0xc1, 0x31, 0x57, 0x24, ], - [ 0xbd, 0x83, 0x8d, 0x3a, 0xaf, 0xbf, 0x8d, 0xb7, ], - [ 0x0b, 0x1a, 0x2a, 0x32, 0x65, 0xd5, 0x1a, 0xea, ], - [ 0x13, 0x50, 0x79, 0xa3, 0x23, 0x1c, 0xe6, 0x60, ], - [ 0x93, 0x2b, 0x28, 0x46, 0xe4, 0xd7, 0x06, 0x66, ], - [ 0xe1, 0x91, 0x5f, 0x5c, 0xb1, 0xec, 0xa4, 0x6c, ], - [ 0xf3, 0x25, 0x96, 0x5c, 0xa1, 0x6d, 0x62, 0x9f, ], - [ 0x57, 0x5f, 0xf2, 0x8e, 0x60, 0x38, 0x1b, 0xe5, ], - [ 0x72, 0x45, 0x06, 0xeb, 0x4c, 0x32, 0x8a, 0x95, ] - ]; - - let k0 = 0x_07_06_05_04_03_02_01_00_u64; - let k1 = 0x_0f_0e_0d_0c_0b_0a_09_08_u64; - let mut buf = Vec::new(); - let mut t = 0; - let mut state_inc = SipState::new_with_keys(k0, k1); - let mut state_full = SipState::new_with_keys(k0, k1); - - fn to_hex_str(r: &[u8; 8]) -> String { - let mut s = String::new(); - for b in r.iter() { - s.push_str(format!("{}", fmt::radix(*b, 16)).as_slice()); - } - s - } - - fn result_bytes(h: u64) -> Vec<u8> { - vec![(h >> 0) as u8, - (h >> 8) as u8, - (h >> 16) as u8, - (h >> 24) as u8, - (h >> 32) as u8, - (h >> 40) as u8, - (h >> 48) as u8, - (h >> 56) as u8, - ] - } - - fn result_str(h: u64) -> String { - let r = result_bytes(h); - let mut s = String::new(); - for b in r.iter() { - s.push_str(format!("{}", fmt::radix(*b, 16)).as_slice()); - } - s - } - - while t < 64 { - debug!("siphash test {}: {}", t, buf); - let vec = u8to64_le!(vecs[t], 0); - let out = hash_with_keys(k0, k1, &Bytes(buf.as_slice())); - debug!("got {}, expected {}", out, vec); - assert_eq!(vec, out); - - state_full.reset(); - state_full.write(buf.as_slice()); - let f = result_str(state_full.result()); - let i = result_str(state_inc.result()); - let v = to_hex_str(&vecs[t]); - debug!("{}: ({}) => inc={} full={}", t, v, i, f); - - assert_eq!(f, i); - assert_eq!(f, v); - - buf.push(t as u8); - state_inc.write(&[t as u8]); - - t += 1; - } - } - - #[test] #[cfg(target_arch = "aarch64")] - fn test_hash_uint() { - let val = 0xdeadbeef_deadbeef_u64; - assert_eq!(hash(&(val as u64)), hash(&(val as uint))); - assert!(hash(&(val as u32)) != hash(&(val as uint))); - } - #[test] #[cfg(target_arch = "arm")] - fn test_hash_uint() { - let val = 0xdeadbeef_deadbeef_u64; - assert!(hash(&(val as u64)) != hash(&(val as uint))); - assert_eq!(hash(&(val as u32)), hash(&(val as uint))); - } - #[test] #[cfg(target_arch = "x86_64")] - fn test_hash_uint() { - let val = 0xdeadbeef_deadbeef_u64; - assert_eq!(hash(&(val as u64)), hash(&(val as uint))); - assert!(hash(&(val as u32)) != hash(&(val as uint))); - } - #[test] #[cfg(target_arch = "x86")] - fn test_hash_uint() { - let val = 0xdeadbeef_deadbeef_u64; - assert!(hash(&(val as u64)) != hash(&(val as uint))); - assert_eq!(hash(&(val as u32)), hash(&(val as uint))); - } - - #[test] - fn test_hash_idempotent() { - let val64 = 0xdeadbeef_deadbeef_u64; - assert_eq!(hash(&val64), hash(&val64)); - let val32 = 0xdeadbeef_u32; - assert_eq!(hash(&val32), hash(&val32)); - } - - #[test] - fn test_hash_no_bytes_dropped_64() { - let val = 0xdeadbeef_deadbeef_u64; - - assert!(hash(&val) != hash(&zero_byte(val, 0))); - assert!(hash(&val) != hash(&zero_byte(val, 1))); - assert!(hash(&val) != hash(&zero_byte(val, 2))); - assert!(hash(&val) != hash(&zero_byte(val, 3))); - assert!(hash(&val) != hash(&zero_byte(val, 4))); - assert!(hash(&val) != hash(&zero_byte(val, 5))); - assert!(hash(&val) != hash(&zero_byte(val, 6))); - assert!(hash(&val) != hash(&zero_byte(val, 7))); - - fn zero_byte(val: u64, byte: uint) -> u64 { - assert!(byte < 8); - val & !(0xff << (byte * 8)) - } - } - - #[test] - fn test_hash_no_bytes_dropped_32() { - let val = 0xdeadbeef_u32; - - assert!(hash(&val) != hash(&zero_byte(val, 0))); - assert!(hash(&val) != hash(&zero_byte(val, 1))); - assert!(hash(&val) != hash(&zero_byte(val, 2))); - assert!(hash(&val) != hash(&zero_byte(val, 3))); - - fn zero_byte(val: u32, byte: uint) -> u32 { - assert!(byte < 4); - val & !(0xff << (byte * 8)) - } - } - - #[test] - fn test_hash_no_concat_alias() { - let s = ("aa", "bb"); - let t = ("aabb", ""); - let u = ("a", "abb"); - - assert!(s != t && t != u); - assert!(hash(&s) != hash(&t) && hash(&s) != hash(&u)); - - let v: (&[u8], &[u8], &[u8]) = (&[1u8], &[0u8, 0], &[0u8]); - let w: (&[u8], &[u8], &[u8]) = (&[1u8, 0, 0, 0], &[], &[]); - - assert!(v != w); - assert!(hash(&v) != hash(&w)); - } - - #[bench] - fn bench_str_under_8_bytes(b: &mut Bencher) { - let s = "foo"; - b.iter(|| { - assert_eq!(hash(&s), 16262950014981195938); - }) - } - - #[bench] - fn bench_str_of_8_bytes(b: &mut Bencher) { - let s = "foobar78"; - b.iter(|| { - assert_eq!(hash(&s), 4898293253460910787); - }) - } - - #[bench] - fn bench_str_over_8_bytes(b: &mut Bencher) { - let s = "foobarbaz0"; - b.iter(|| { - assert_eq!(hash(&s), 10581415515220175264); - }) - } - - #[bench] - fn bench_long_str(b: &mut Bencher) { - let s = "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor \ -incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud \ -exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute \ -irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla \ -pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui \ -officia deserunt mollit anim id est laborum."; - b.iter(|| { - assert_eq!(hash(&s), 17717065544121360093); - }) - } - - #[bench] - fn bench_u64(b: &mut Bencher) { - let u = 16262950014981195938u64; - b.iter(|| { - assert_eq!(hash(&u), 5254097107239593357); - }) - } -} diff --git a/src/libcore/intrinsics.rs b/src/libcore/intrinsics.rs index 822416a387e..c8b3616a404 100644 --- a/src/libcore/intrinsics.rs +++ b/src/libcore/intrinsics.rs @@ -42,6 +42,9 @@ #![experimental] #![allow(missing_docs)] +#[cfg(not(stage0))] +use marker::Sized; + pub type GlueFn = extern "Rust" fn(*const i8); #[lang="ty_desc"] @@ -200,6 +203,10 @@ extern "rust-intrinsic" { /// Gets an identifier which is globally unique to the specified type. This /// function will return the same value for a type regardless of whichever /// crate it is invoked in. + #[cfg(not(stage0))] + pub fn type_id<T: ?Sized + 'static>() -> TypeId; + + #[cfg(stage0)] pub fn type_id<T: 'static>() -> TypeId; /// Create a value initialized to zero. @@ -551,8 +558,15 @@ pub struct TypeId { impl TypeId { /// Returns the `TypeId` of the type this generic function has been instantiated with + #[cfg(not(stage0))] + pub fn of<T: ?Sized + 'static>() -> TypeId { + unsafe { type_id::<T>() } + } + + #[cfg(stage0)] pub fn of<T: 'static>() -> TypeId { unsafe { type_id::<T>() } } + pub fn hash(&self) -> u64 { self.t } } diff --git a/src/libcore/iter.rs b/src/libcore/iter.rs index d30cfc405a1..273a51665ce 100644 --- a/src/libcore/iter.rs +++ b/src/libcore/iter.rs @@ -2344,7 +2344,7 @@ impl<A, I, F> RandomAccessIterator for Inspect<A, I, F> where /// /// // This iterator will yield up to the last Fibonacci number before the max value of `u32`. /// // You can simply change `u32` to `u64` in this line if you want higher values than that. -/// let mut fibonacci = Unfold::new((Some(0u32), Some(1u32)), |&(ref mut x2, ref mut x1)| { +/// let mut fibonacci = Unfold::new((Some(0u32), Some(1u32)), |&mut (ref mut x2, ref mut x1)| { /// // Attempt to get the next Fibonacci number /// // `x1` will be `None` if previously overflowed. /// let next = match (*x2, *x1) { @@ -2749,9 +2749,9 @@ macro_rules! step_impl_no_between { } step_impl!(uint u8 u16 u32 int i8 i16 i32); -#[cfg(target_word_size = "64")] +#[cfg(any(all(stage0, target_word_size = "64"), all(not(stage0), target_pointer_width = "64")))] step_impl!(u64 i64); -#[cfg(target_word_size = "32")] +#[cfg(any(all(stage0, target_word_size = "32"), all(not(stage0), target_pointer_width = "32")))] step_impl_no_between!(u64 i64); @@ -2804,7 +2804,7 @@ pub fn iterate<T, F>(seed: T, f: F) -> Iterate<T, F> where T: Clone, F: FnMut(T) -> T, { - let &(ref mut f, ref mut val, ref mut first) = st; + let &mut (ref mut f, ref mut val, ref mut first) = st; if *first { *first = false; } else { diff --git a/src/libcore/lib.rs b/src/libcore/lib.rs index a7e3b61b0d4..af5aba53bf4 100644 --- a/src/libcore/lib.rs +++ b/src/libcore/lib.rs @@ -49,6 +49,7 @@ #![crate_name = "core"] #![experimental] +#![staged_api] #![crate_type = "rlib"] #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png", html_favicon_url = "http://www.rust-lang.org/favicon.ico", @@ -57,6 +58,7 @@ #![no_std] #![allow(unknown_features, raw_pointer_derive)] +#![cfg_attr(stage0, allow(unused_attributes))] #![feature(intrinsics, lang_items)] #![feature(simd, unsafe_destructor, slicing_syntax)] #![feature(unboxed_closures)] @@ -78,12 +80,14 @@ mod int_macros; mod uint_macros; #[path = "num/int.rs"] pub mod int; +#[path = "num/isize.rs"] pub mod isize; #[path = "num/i8.rs"] pub mod i8; #[path = "num/i16.rs"] pub mod i16; #[path = "num/i32.rs"] pub mod i32; #[path = "num/i64.rs"] pub mod i64; #[path = "num/uint.rs"] pub mod uint; +#[path = "num/usize.rs"] pub mod usize; #[path = "num/u8.rs"] pub mod u8; #[path = "num/u16.rs"] pub mod u16; #[path = "num/u32.rs"] pub mod u32; @@ -146,8 +150,6 @@ mod core { mod std { pub use clone; pub use cmp; - #[cfg(stage0)] - pub use marker as kinds; pub use marker; pub use option; pub use fmt; diff --git a/src/libcore/num/int.rs b/src/libcore/num/int.rs index 91c5e4163f9..065763a0d8e 100644 --- a/src/libcore/num/int.rs +++ b/src/libcore/num/int.rs @@ -8,10 +8,16 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -//! Operations and constants for architecture-sized signed integers (`int` type) +//! Deprecated: replaced by `isize`. +//! +//! The rollout of the new type will gradually take place over the +//! alpha cycle along with the development of clearer conventions +//! around integer types. -#![stable] -#![doc(primitive = "int")] +#![deprecated = "replaced by isize"] -#[cfg(target_word_size = "32")] int_module! { int, 32 } -#[cfg(target_word_size = "64")] int_module! { int, 64 } +#[cfg(stage0)] #[cfg(target_word_size = "32")] int_module! { int, 32 } +#[cfg(stage0)] #[cfg(target_word_size = "64")] int_module! { int, 64 } + +#[cfg(not(stage0))] #[cfg(target_pointer_width = "32")] int_module! { int, 32 } +#[cfg(not(stage0))] #[cfg(target_pointer_width = "64")] int_module! { int, 64 } diff --git a/src/libcore/num/isize.rs b/src/libcore/num/isize.rs new file mode 100644 index 00000000000..c1cf3c62131 --- /dev/null +++ b/src/libcore/num/isize.rs @@ -0,0 +1,25 @@ +// 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. +// +// 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. + +//! Operations and constants for pointer-sized signed integers (`isize` type) +//! +//! This type was recently added to replace `int`. The rollout of the +//! new type will gradually take place over the alpha cycle along with +//! the development of clearer conventions around integer types. + +#![stable] +#![doc(primitive = "isize")] + +#[cfg(any(all(stage0, target_word_size = "32"), + all(not(stage0), target_pointer_width = "32")))] +int_module! { isize, 32 } +#[cfg(any(all(stage0, target_word_size = "64"), + all(not(stage0), target_pointer_width = "64")))] +int_module! { isize, 64 } diff --git a/src/libcore/num/mod.rs b/src/libcore/num/mod.rs index 490d8111f46..91fed8a31bd 100644 --- a/src/libcore/num/mod.rs +++ b/src/libcore/num/mod.rs @@ -24,7 +24,7 @@ use iter::IteratorExt; use marker::Copy; use mem::size_of; use ops::{Add, Sub, Mul, Div, Rem, Neg}; -use ops::{Not, BitAnd, BitOr, BitXor, Shl, Shr, Index}; +use ops::{Not, BitAnd, BitOr, BitXor, Shl, Shr}; use option::Option; use option::Option::{Some, None}; use str::{FromStr, StrExt}; @@ -496,7 +496,7 @@ uint_impl! { u64 = u64, 64, intrinsics::u64_sub_with_overflow, intrinsics::u64_mul_with_overflow } -#[cfg(target_word_size = "32")] +#[cfg(any(all(stage0, target_word_size = "32"), all(not(stage0), target_pointer_width = "32")))] uint_impl! { uint = u32, 32, intrinsics::ctpop32, intrinsics::ctlz32, @@ -506,7 +506,7 @@ uint_impl! { uint = u32, 32, intrinsics::u32_sub_with_overflow, intrinsics::u32_mul_with_overflow } -#[cfg(target_word_size = "64")] +#[cfg(any(all(stage0, target_word_size = "64"), all(not(stage0), target_pointer_width = "64")))] uint_impl! { uint = u64, 64, intrinsics::ctpop64, intrinsics::ctlz64, @@ -601,13 +601,13 @@ int_impl! { i64 = i64, u64, 64, intrinsics::i64_sub_with_overflow, intrinsics::i64_mul_with_overflow } -#[cfg(target_word_size = "32")] +#[cfg(any(all(stage0, target_word_size = "32"), all(not(stage0), target_pointer_width = "32")))] int_impl! { int = i32, u32, 32, intrinsics::i32_add_with_overflow, intrinsics::i32_sub_with_overflow, intrinsics::i32_mul_with_overflow } -#[cfg(target_word_size = "64")] +#[cfg(any(all(stage0, target_word_size = "64"), all(not(stage0), target_pointer_width = "64")))] int_impl! { int = i64, u64, 64, intrinsics::i64_add_with_overflow, intrinsics::i64_sub_with_overflow, @@ -1577,7 +1577,7 @@ macro_rules! from_str_radix_float_impl { }; // Parse the exponent as decimal integer - let src = src.index(&(offset..)); + let src = &src[offset..]; let (is_positive, exp) = match src.slice_shift_char() { Some(('-', src)) => (false, src.parse::<uint>()), Some(('+', src)) => (true, src.parse::<uint>()), diff --git a/src/libcore/num/uint.rs b/src/libcore/num/uint.rs index 35739f68da9..7931890ca5e 100644 --- a/src/libcore/num/uint.rs +++ b/src/libcore/num/uint.rs @@ -8,9 +8,12 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -//! Operations and constants for architecture-sized unsigned integers (`uint` type) +//! Deprecated: replaced by `usize`. +//! +//! The rollout of the new type will gradually take place over the +//! alpha cycle along with the development of clearer conventions +//! around integer types. -#![stable] -#![doc(primitive = "uint")] +#![deprecated = "replaced by usize"] uint_module! { uint, int, ::int::BITS } diff --git a/src/libcore/num/usize.rs b/src/libcore/num/usize.rs new file mode 100644 index 00000000000..5eebcd51a77 --- /dev/null +++ b/src/libcore/num/usize.rs @@ -0,0 +1,20 @@ +// 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. +// +// 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. + +//! Operations and constants for pointer-sized unsigned integers (`usize` type) +//! +//! This type was recently added to replace `uint`. The rollout of the +//! new type will gradually take place over the alpha cycle along with +//! the development of clearer conventions around integer types. + +#![stable] +#![doc(primitive = "usize")] + +uint_module! { usize, isize, ::isize::BITS } diff --git a/src/libcore/ops.rs b/src/libcore/ops.rs index 4debab91739..ab956587d82 100644 --- a/src/libcore/ops.rs +++ b/src/libcore/ops.rs @@ -65,6 +65,7 @@ use clone::Clone; use iter::{Step, Iterator,DoubleEndedIterator,ExactSizeIterator}; use marker::Sized; use option::Option::{self, Some, None}; +use fmt; /// The `Drop` trait is used to run some code when a value goes out of scope. This /// is sometimes called a 'destructor'. @@ -847,13 +848,20 @@ pub trait IndexMut<Index: ?Sized> { } /// An unbounded range. -#[derive(Copy)] +#[derive(Copy, PartialEq, Eq)] #[lang="full_range"] #[unstable = "API still in development"] pub struct FullRange; +#[unstable = "API still in development"] +impl fmt::Show for FullRange { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt::Show::fmt("..", fmt) + } +} + /// A (half-open) range which is bounded at both ends. -#[derive(Copy)] +#[derive(Copy, PartialEq, Eq)] #[lang="range"] #[unstable = "API still in development"] pub struct Range<Idx> { @@ -904,8 +912,15 @@ impl<Idx: Clone + Step> DoubleEndedIterator for Range<Idx> { #[unstable = "API still in development"] impl<Idx: Clone + Step> ExactSizeIterator for Range<Idx> {} +#[unstable = "API still in development"] +impl<Idx: fmt::Show> fmt::Show for Range<Idx> { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + write!(fmt, "{:?}..{:?}", self.start, self.end) + } +} + /// A range which is only bounded below. -#[derive(Copy)] +#[derive(Copy, PartialEq, Eq)] #[lang="range_from"] #[unstable = "API still in development"] pub struct RangeFrom<Idx> { @@ -926,8 +941,15 @@ impl<Idx: Clone + Step> Iterator for RangeFrom<Idx> { } } +#[unstable = "API still in development"] +impl<Idx: fmt::Show> fmt::Show for RangeFrom<Idx> { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + write!(fmt, "{:?}..", self.start) + } +} + /// A range which is only bounded above. -#[derive(Copy)] +#[derive(Copy, PartialEq, Eq)] #[lang="range_to"] #[unstable = "API still in development"] pub struct RangeTo<Idx> { @@ -935,6 +957,13 @@ pub struct RangeTo<Idx> { pub end: Idx, } +#[unstable = "API still in development"] +impl<Idx: fmt::Show> fmt::Show for RangeTo<Idx> { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + write!(fmt, "..{:?}", self.end) + } +} + /// The `Deref` trait is used to specify the functionality of dereferencing /// operations like `*v`. diff --git a/src/libcore/option.rs b/src/libcore/option.rs index 272570a0d5b..deee67b6d2f 100644 --- a/src/libcore/option.rs +++ b/src/libcore/option.rs @@ -66,10 +66,11 @@ //! not (`None`). //! //! ``` +//! # use std::boxed::Box; //! let optional: Option<Box<int>> = None; //! check_optional(&optional); //! -//! let optional: Option<Box<int>> = Some(box 9000); +//! let optional: Option<Box<int>> = Some(Box::new(9000)); //! check_optional(&optional); //! //! fn check_optional(optional: &Option<Box<int>>) { @@ -145,17 +146,17 @@ use self::Option::*; +use clone::Clone; use cmp::{Eq, Ord}; use default::Default; -use iter::{Iterator, IteratorExt, DoubleEndedIterator, FromIterator}; use iter::{ExactSizeIterator}; +use iter::{Iterator, IteratorExt, DoubleEndedIterator, FromIterator}; use mem; -use result::Result; +use ops::{Deref, FnOnce}; use result::Result::{Ok, Err}; -use slice; +use result::Result; use slice::AsSlice; -use clone::Clone; -use ops::{Deref, FnOnce}; +use slice; // Note that this is not a lang item per se, but it has a hidden dependency on // `Iterator`, which is one. The compiler assumes that the `next` method of @@ -533,7 +534,7 @@ impl<T> Option<T> { /// ``` /// let mut x = Some(4u); /// match x.iter_mut().next() { - /// Some(&ref mut v) => *v = 42u, + /// Some(&mut ref mut v) => *v = 42u, /// None => {}, /// } /// assert_eq!(x, Some(42)); @@ -762,7 +763,6 @@ impl<T> AsSlice<T> for Option<T> { #[stable] impl<T> Default for Option<T> { - #[stable] #[inline] #[stable] fn default() -> Option<T> { None } diff --git a/src/libcore/ptr.rs b/src/libcore/ptr.rs index 20305c3191a..a17cd410303 100644 --- a/src/libcore/ptr.rs +++ b/src/libcore/ptr.rs @@ -46,12 +46,13 @@ //! though unsafely, transformed from one type to the other. //! //! ``` +//! # use std::boxed::Box; //! use std::mem; //! //! unsafe { -//! let my_num: Box<int> = box 10; +//! let my_num: Box<int> = Box::new(10); //! let my_num: *const int = mem::transmute(my_num); -//! let my_speed: Box<int> = box 88; +//! let my_speed: Box<int> = Box::new(88); //! let my_speed: *mut int = mem::transmute(my_speed); //! //! // By taking ownership of the original `Box<T>` though diff --git a/src/libcore/result.rs b/src/libcore/result.rs index 95ae6ebfb68..7868ec67c8a 100644 --- a/src/libcore/result.rs +++ b/src/libcore/result.rs @@ -383,8 +383,8 @@ impl<T, E> Result<T, E> { /// ``` /// fn mutate(r: &mut Result<int, int>) { /// match r.as_mut() { - /// Ok(&ref mut v) => *v = 42, - /// Err(&ref mut e) => *e = 0, + /// Ok(&mut ref mut v) => *v = 42, + /// Err(&mut ref mut e) => *e = 0, /// } /// } /// @@ -529,7 +529,7 @@ impl<T, E> Result<T, E> { /// ``` /// let mut x: Result<uint, &str> = Ok(7); /// match x.iter_mut().next() { - /// Some(&ref mut x) => *x = 40, + /// Some(&mut ref mut x) => *x = 40, /// None => {}, /// } /// assert_eq!(x, Ok(40)); diff --git a/src/libcore/slice.rs b/src/libcore/slice.rs index bf2df465370..6c62bfda1fe 100644 --- a/src/libcore/slice.rs +++ b/src/libcore/slice.rs @@ -159,7 +159,7 @@ impl<T> SliceExt for [T] { #[inline] fn split_at(&self, mid: uint) -> (&[T], &[T]) { - (self.index(&(0..mid)), self.index(&(mid..))) + (&self[0..mid], &self[mid..]) } #[inline] @@ -236,11 +236,11 @@ impl<T> SliceExt for [T] { } #[inline] - fn tail(&self) -> &[T] { self.index(&(1..)) } + fn tail(&self) -> &[T] { &self[1..] } #[inline] fn init(&self) -> &[T] { - self.index(&(0..(self.len() - 1))) + &self[0..(self.len() - 1)] } #[inline] @@ -443,13 +443,13 @@ impl<T> SliceExt for [T] { #[inline] fn starts_with(&self, needle: &[T]) -> bool where T: PartialEq { let n = needle.len(); - self.len() >= n && needle == self.index(&(0..n)) + self.len() >= n && needle == &self[0..n] } #[inline] fn ends_with(&self, needle: &[T]) -> bool where T: PartialEq { let (m, n) = (self.len(), needle.len()); - m >= n && needle == self.index(&((m-n)..)) + m >= n && needle == &self[(m-n)..] } #[unstable] @@ -972,8 +972,8 @@ impl<'a, T, P> Iterator for Split<'a, T, P> where P: FnMut(&T) -> bool { match self.v.iter().position(|x| (self.pred)(x)) { None => self.finish(), Some(idx) => { - let ret = Some(self.v.index(&(0..idx))); - self.v = self.v.index(&((idx + 1)..)); + let ret = Some(&self.v[0..idx]); + self.v = &self.v[(idx + 1)..]; ret } } @@ -998,8 +998,8 @@ impl<'a, T, P> DoubleEndedIterator for Split<'a, T, P> where P: FnMut(&T) -> boo match self.v.iter().rposition(|x| (self.pred)(x)) { None => self.finish(), Some(idx) => { - let ret = Some(self.v.index(&((idx + 1)..))); - self.v = self.v.index(&(0..idx)); + let ret = Some(&self.v[(idx + 1)..]); + self.v = &self.v[0..idx]; ret } } @@ -1195,8 +1195,8 @@ impl<'a, T> Iterator for Windows<'a, T> { if self.size > self.v.len() { None } else { - let ret = Some(self.v.index(&(0..self.size))); - self.v = self.v.index(&(1..)); + let ret = Some(&self.v[0..self.size]); + self.v = &self.v[1..]; ret } } @@ -1283,7 +1283,7 @@ impl<'a, T> RandomAccessIterator for Chunks<'a, T> { let mut hi = lo + self.size; if hi < lo || hi > self.v.len() { hi = self.v.len(); } - Some(self.v.index(&(lo..hi))) + Some(&self.v[lo..hi]) } else { None } diff --git a/src/libcore/str/mod.rs b/src/libcore/str/mod.rs index 3f8ce000e21..6051c68b116 100644 --- a/src/libcore/str/mod.rs +++ b/src/libcore/str/mod.rs @@ -26,7 +26,7 @@ use iter::{Map, Iterator, IteratorExt, DoubleEndedIterator}; use marker::Sized; use mem; use num::Int; -use ops::{Fn, FnMut, Index}; +use ops::{Fn, FnMut}; use option::Option::{self, None, Some}; use ptr::PtrExt; use raw::{Repr, Slice}; @@ -580,7 +580,7 @@ impl NaiveSearcher { fn next(&mut self, haystack: &[u8], needle: &[u8]) -> Option<(uint, uint)> { while self.position + needle.len() <= haystack.len() { - if haystack.index(&(self.position .. self.position + needle.len())) == needle { + if &haystack[self.position .. self.position + needle.len()] == needle { let match_pos = self.position; self.position += needle.len(); // add 1 for all matches return Some((match_pos, match_pos + needle.len())); @@ -701,10 +701,10 @@ impl TwoWaySearcher { // // What's going on is we have some critical factorization (u, v) of the // needle, and we want to determine whether u is a suffix of - // v.index(&(0..period)). If it is, we use "Algorithm CP1". Otherwise we use + // &v[0..period]. If it is, we use "Algorithm CP1". Otherwise we use // "Algorithm CP2", which is optimized for when the period of the needle // is large. - if needle.index(&(0..crit_pos)) == needle.index(&(period.. period + crit_pos)) { + if &needle[0..crit_pos] == &needle[period.. period + crit_pos] { TwoWaySearcher { crit_pos: crit_pos, period: period, @@ -1412,13 +1412,13 @@ impl StrExt for str { #[inline] fn starts_with(&self, needle: &str) -> bool { let n = needle.len(); - self.len() >= n && needle.as_bytes() == self.as_bytes().index(&(0..n)) + self.len() >= n && needle.as_bytes() == &self.as_bytes()[0..n] } #[inline] fn ends_with(&self, needle: &str) -> bool { let (m, n) = (self.len(), needle.len()); - m >= n && needle.as_bytes() == self.as_bytes().index(&((m-n)..)) + m >= n && needle.as_bytes() == &self.as_bytes()[(m-n)..] } #[inline] diff --git a/src/libcoretest/any.rs b/src/libcoretest/any.rs index c0be3a28794..e6a7170acea 100644 --- a/src/libcoretest/any.rs +++ b/src/libcoretest/any.rs @@ -101,12 +101,12 @@ fn any_downcast_mut() { } match a_r.downcast_mut::<uint>() { - Some(&612) => {} + Some(&mut 612) => {} x => panic!("Unexpected value {:?}", x) } match b_r.downcast_mut::<uint>() { - Some(&413) => {} + Some(&mut 413) => {} x => panic!("Unexpected value {:?}", x) } } diff --git a/src/libcoretest/char.rs b/src/libcoretest/char.rs index f901e800176..7b6b4f84808 100644 --- a/src/libcoretest/char.rs +++ b/src/libcoretest/char.rs @@ -167,7 +167,7 @@ fn test_encode_utf8() { fn check(input: char, expect: &[u8]) { let mut buf = [0u8; 4]; let n = input.encode_utf8(buf.as_mut_slice()).unwrap_or(0); - assert_eq!(buf.index(&(0..n)), expect); + assert_eq!(&buf[0..n], expect); } check('x', &[0x78]); @@ -181,7 +181,7 @@ fn test_encode_utf16() { fn check(input: char, expect: &[u16]) { let mut buf = [0u16; 2]; let n = input.encode_utf16(buf.as_mut_slice()).unwrap_or(0); - assert_eq!(buf.index(&(0..n)), expect); + assert_eq!(&buf[0..n], expect); } check('x', &[0x0078]); diff --git a/src/libcoretest/hash/mod.rs b/src/libcoretest/hash/mod.rs index 63bf9ec3314..d48820aee06 100644 --- a/src/libcoretest/hash/mod.rs +++ b/src/libcoretest/hash/mod.rs @@ -7,27 +7,22 @@ // <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 core::marker::Sized; -use std::mem; - -use core::slice::SliceExt; -use core::hash::{Hash, Hasher, Writer}; -struct MyWriterHasher; +use std::mem; +use std::hash::{Hash, Hasher, Writer}; +use std::default::Default; -impl Hasher<MyWriter> for MyWriterHasher { - fn hash<T: ?Sized + Hash<MyWriter>>(&self, value: &T) -> u64 { - let mut state = MyWriter { hash: 0 }; - value.hash(&mut state); - state.hash - } +struct MyHasher { + hash: u64, } -struct MyWriter { - hash: u64, +impl Default for MyHasher { + fn default() -> MyHasher { + MyHasher { hash: 0 } + } } -impl Writer for MyWriter { +impl Writer for MyHasher { // Most things we'll just add up the bytes. fn write(&mut self, buf: &[u8]) { for byte in buf.iter() { @@ -36,66 +31,87 @@ impl Writer for MyWriter { } } +impl Hasher for MyHasher { + type Output = u64; + fn reset(&mut self) { self.hash = 0; } + fn finish(&self) -> u64 { self.hash } +} + + #[test] fn test_writer_hasher() { - let hasher = MyWriterHasher; + fn hash<T: Hash<MyHasher>>(t: &T) -> u64 { + ::std::hash::hash::<_, MyHasher>(t) + } - assert_eq!(hasher.hash(&()), 0); + assert_eq!(hash(&()), 0); - assert_eq!(hasher.hash(&5u8), 5); - assert_eq!(hasher.hash(&5u16), 5); - assert_eq!(hasher.hash(&5u32), 5); - assert_eq!(hasher.hash(&5u64), 5); - assert_eq!(hasher.hash(&5u), 5); + assert_eq!(hash(&5u8), 5); + assert_eq!(hash(&5u16), 5); + assert_eq!(hash(&5u32), 5); + assert_eq!(hash(&5u64), 5); + assert_eq!(hash(&5u), 5); - assert_eq!(hasher.hash(&5i8), 5); - assert_eq!(hasher.hash(&5i16), 5); - assert_eq!(hasher.hash(&5i32), 5); - assert_eq!(hasher.hash(&5i64), 5); - assert_eq!(hasher.hash(&5i), 5); + assert_eq!(hash(&5i8), 5); + assert_eq!(hash(&5i16), 5); + assert_eq!(hash(&5i32), 5); + assert_eq!(hash(&5i64), 5); + assert_eq!(hash(&5i), 5); - assert_eq!(hasher.hash(&false), 0); - assert_eq!(hasher.hash(&true), 1); + assert_eq!(hash(&false), 0); + assert_eq!(hash(&true), 1); - assert_eq!(hasher.hash(&'a'), 97); + assert_eq!(hash(&'a'), 97); let s: &str = "a"; - assert_eq!(hasher.hash(& s), 97 + 0xFF); + assert_eq!(hash(& s), 97 + 0xFF); // FIXME (#18283) Enable test //let s: Box<str> = box "a"; //assert_eq!(hasher.hash(& s), 97 + 0xFF); let cs: &[u8] = &[1u8, 2u8, 3u8]; - assert_eq!(hasher.hash(& cs), 9); + assert_eq!(hash(& cs), 9); let cs: Box<[u8]> = box [1u8, 2u8, 3u8]; - assert_eq!(hasher.hash(& cs), 9); + assert_eq!(hash(& cs), 9); // FIXME (#18248) Add tests for hashing Rc<str> and Rc<[T]> unsafe { let ptr: *const int = mem::transmute(5i); - assert_eq!(hasher.hash(&ptr), 5); + assert_eq!(hash(&ptr), 5); } unsafe { let ptr: *mut int = mem::transmute(5i); - assert_eq!(hasher.hash(&ptr), 5); + assert_eq!(hash(&ptr), 5); } } -struct Custom { - hash: u64 +struct Custom { hash: u64 } +struct CustomHasher { output: u64 } + +impl Hasher for CustomHasher { + type Output = u64; + fn reset(&mut self) { self.output = 0; } + fn finish(&self) -> u64 { self.output } +} + +impl Default for CustomHasher { + fn default() -> CustomHasher { + CustomHasher { output: 0 } + } } -impl Hash<u64> for Custom { - fn hash(&self, state: &mut u64) { - *state = self.hash; +impl Hash<CustomHasher> for Custom { + fn hash(&self, state: &mut CustomHasher) { + state.output = self.hash; } } #[test] fn test_custom_state() { - let custom = Custom { hash: 5 }; - let mut state = 0; - custom.hash(&mut state); - assert_eq!(state, 5); + fn hash<T: Hash<CustomHasher>>(t: &T) -> u64 { + ::std::hash::hash::<_, CustomHasher>(t) + } + + assert_eq!(hash(&Custom { hash: 5 }), 5); } diff --git a/src/libcoretest/intrinsics.rs b/src/libcoretest/intrinsics.rs new file mode 100644 index 00000000000..bcf8a6a433b --- /dev/null +++ b/src/libcoretest/intrinsics.rs @@ -0,0 +1,31 @@ +// 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 core::intrinsics::TypeId; + +#[test] +fn test_typeid_sized_types() { + struct X; struct Y(uint); + + assert_eq!(TypeId::of::<X>(), TypeId::of::<X>()); + assert_eq!(TypeId::of::<Y>(), TypeId::of::<Y>()); + assert!(TypeId::of::<X>() != TypeId::of::<Y>()); +} + +#[test] +fn test_typeid_unsized_types() { + trait Z {} + struct X(str); struct Y(Z + 'static); + + assert_eq!(TypeId::of::<X>(), TypeId::of::<X>()); + assert_eq!(TypeId::of::<Y>(), TypeId::of::<Y>()); + assert!(TypeId::of::<X>() != TypeId::of::<Y>()); +} + diff --git a/src/libcoretest/lib.rs b/src/libcoretest/lib.rs index 50ae59e70dc..c12981b7d24 100644 --- a/src/libcoretest/lib.rs +++ b/src/libcoretest/lib.rs @@ -7,8 +7,10 @@ // <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(globs, unsafe_destructor, slicing_syntax, default_type_params)] + +#![feature(unsafe_destructor, slicing_syntax)] #![feature(unboxed_closures)] +#![feature(box_syntax)] extern crate core; extern crate test; diff --git a/src/libcoretest/result.rs b/src/libcoretest/result.rs index b9403598ec2..485549cc552 100644 --- a/src/libcoretest/result.rs +++ b/src/libcoretest/result.rs @@ -8,8 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use core::iter::range; - pub fn op1() -> Result<int, &'static str> { Ok(666) } pub fn op2() -> Result<int, &'static str> { Err("sadface") } diff --git a/src/libcoretest/slice.rs b/src/libcoretest/slice.rs index b714b6a4e41..6fae384763f 100644 --- a/src/libcoretest/slice.rs +++ b/src/libcoretest/slice.rs @@ -57,17 +57,17 @@ fn iterator_to_slice() { } { let mut iter = data.iter_mut(); - assert_eq!(iter.index(&FullRange), other_data.index(&FullRange)); + assert_eq!(&iter[], &other_data[]); // mutability: assert!(&mut iter[] == other_data); iter.next(); - assert_eq!(iter.index(&FullRange), other_data.index(&(1..))); + assert_eq!(&iter[], &other_data[1..]); assert!(&mut iter[] == &mut other_data[1..]); iter.next_back(); - assert_eq!(iter.index(&FullRange), other_data.index(&(1..2))); + assert_eq!(&iter[], &other_data[1..2]); assert!(&mut iter[] == &mut other_data[1..2]); let s = iter.into_slice(); diff --git a/src/libflate/lib.rs b/src/libflate/lib.rs index f38440d86c6..1896bdd182a 100644 --- a/src/libflate/lib.rs +++ b/src/libflate/lib.rs @@ -16,6 +16,7 @@ #![crate_name = "flate"] #![experimental] +#![staged_api] #![crate_type = "rlib"] #![crate_type = "dylib"] #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png", diff --git a/src/libfmt_macros/lib.rs b/src/libfmt_macros/lib.rs index 47cc072a636..02eea5d024c 100644 --- a/src/libfmt_macros/lib.rs +++ b/src/libfmt_macros/lib.rs @@ -16,6 +16,7 @@ #![crate_name = "fmt_macros"] #![experimental] +#![staged_api] #![crate_type = "rlib"] #![crate_type = "dylib"] #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png", @@ -211,12 +212,12 @@ impl<'a> Parser<'a> { self.cur.next(); } Some((_, other)) => { - self.err(format!("expected `{:?}`, found `{:?}`", c, - other).index(&FullRange)); + self.err(&format!("expected `{:?}`, found `{:?}`", c, + other)[]); } None => { - self.err(format!("expected `{:?}` but string was terminated", - c).index(&FullRange)); + self.err(&format!("expected `{:?}` but string was terminated", + c)[]); } } } @@ -239,12 +240,12 @@ impl<'a> Parser<'a> { // we may not consume the character, so clone the iterator match self.cur.clone().next() { Some((pos, '}')) | Some((pos, '{')) => { - return self.input.index(&(start..pos)); + return &self.input[start..pos]; } Some(..) => { self.cur.next(); } None => { self.cur.next(); - return self.input.index(&(start..self.input.len())); + return &self.input[start..self.input.len()]; } } } @@ -284,7 +285,7 @@ impl<'a> Parser<'a> { flags: 0, precision: CountImplied, width: CountImplied, - ty: self.input.index(&(0..0)), + ty: &self.input[0..0], }; if !self.consume(':') { return spec } @@ -393,7 +394,7 @@ impl<'a> Parser<'a> { self.cur.next(); pos } - Some(..) | None => { return self.input.index(&(0..0)); } + Some(..) | None => { return &self.input[0..0]; } }; let mut end; loop { @@ -405,7 +406,7 @@ impl<'a> Parser<'a> { None => { end = self.input.len(); break } } } - self.input.index(&(start..end)) + &self.input[start..end] } /// Optionally parses an integer at the current position. This doesn't deal diff --git a/src/libgetopts/lib.rs b/src/libgetopts/lib.rs index f50e24c6354..1d6c99542b5 100644 --- a/src/libgetopts/lib.rs +++ b/src/libgetopts/lib.rs @@ -79,6 +79,7 @@ #![crate_name = "getopts"] #![experimental = "use the crates.io `getopts` library instead"] +#![staged_api] #![crate_type = "rlib"] #![crate_type = "dylib"] #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png", @@ -280,7 +281,7 @@ impl OptGroup { impl Matches { fn opt_vals(&self, nm: &str) -> Vec<Optval> { - match find_opt(self.opts.index(&FullRange), Name::from_str(nm)) { + match find_opt(&self.opts[], Name::from_str(nm)) { Some(id) => self.vals[id].clone(), None => panic!("No option '{}' defined", nm) } @@ -308,7 +309,7 @@ impl Matches { /// Returns true if any of several options were matched. pub fn opts_present(&self, names: &[String]) -> bool { for nm in names.iter() { - match find_opt(self.opts.as_slice(), Name::from_str(nm.index(&FullRange))) { + match find_opt(self.opts.as_slice(), Name::from_str(&nm[])) { Some(id) if !self.vals[id].is_empty() => return true, _ => (), }; @@ -319,7 +320,7 @@ impl Matches { /// Returns the string argument supplied to one of several matching options or `None`. pub fn opts_str(&self, names: &[String]) -> Option<String> { for nm in names.iter() { - match self.opt_val(nm.index(&FullRange)) { + match self.opt_val(&nm[]) { Some(Val(ref s)) => return Some(s.clone()), _ => () } @@ -584,7 +585,7 @@ pub fn getopts(args: &[String], optgrps: &[OptGroup]) -> Result { while i < l { let cur = args[i].clone(); let curlen = cur.len(); - if !is_arg(cur.index(&FullRange)) { + if !is_arg(&cur[]) { free.push(cur); } else if cur == "--" { let mut j = i + 1; @@ -594,7 +595,7 @@ pub fn getopts(args: &[String], optgrps: &[OptGroup]) -> Result { let mut names; let mut i_arg = None; if cur.as_bytes()[1] == b'-' { - let tail = cur.index(&(2..curlen)); + let tail = &cur[2..curlen]; let tail_eq: Vec<&str> = tail.split('=').collect(); if tail_eq.len() <= 1 { names = vec!(Long(tail.to_string())); @@ -630,7 +631,7 @@ pub fn getopts(args: &[String], optgrps: &[OptGroup]) -> Result { }; if arg_follows && range.next < curlen { - i_arg = Some(cur.index(&(range.next..curlen)).to_string()); + i_arg = Some((&cur[range.next..curlen]).to_string()); break; } @@ -658,7 +659,7 @@ pub fn getopts(args: &[String], optgrps: &[OptGroup]) -> Result { v.push(Val((i_arg.clone()) .unwrap())); } else if name_pos < names.len() || i + 1 == l || - is_arg(args[i + 1].index(&FullRange)) { + is_arg(&args[i + 1][]) { let v = &mut vals[optid]; v.push(Given); } else { @@ -721,7 +722,7 @@ pub fn usage(brief: &str, opts: &[OptGroup]) -> String { 0 => {} 1 => { row.push('-'); - row.push_str(short_name.index(&FullRange)); + row.push_str(&short_name[]); row.push(' '); } _ => panic!("the short name should only be 1 ascii char long"), @@ -732,7 +733,7 @@ pub fn usage(brief: &str, opts: &[OptGroup]) -> String { 0 => {} _ => { row.push_str("--"); - row.push_str(long_name.index(&FullRange)); + row.push_str(&long_name[]); row.push(' '); } } @@ -740,10 +741,10 @@ pub fn usage(brief: &str, opts: &[OptGroup]) -> String { // arg match hasarg { No => {} - Yes => row.push_str(hint.index(&FullRange)), + Yes => row.push_str(&hint[]), Maybe => { row.push('['); - row.push_str(hint.index(&FullRange)); + row.push_str(&hint[]); row.push(']'); } } @@ -756,7 +757,7 @@ pub fn usage(brief: &str, opts: &[OptGroup]) -> String { row.push(' '); } } else { - row.push_str(desc_sep.index(&FullRange)); + row.push_str(&desc_sep[]); } // Normalize desc to contain words separated by one space character @@ -768,14 +769,14 @@ pub fn usage(brief: &str, opts: &[OptGroup]) -> String { // FIXME: #5516 should be graphemes not codepoints let mut desc_rows = Vec::new(); - each_split_within(desc_normalized_whitespace.index(&FullRange), 54, |substr| { + each_split_within(&desc_normalized_whitespace[], 54, |substr| { desc_rows.push(substr.to_string()); true }); // FIXME: #5516 should be graphemes not codepoints // wrapped description - row.push_str(desc_rows.connect(desc_sep.index(&FullRange)).index(&FullRange)); + row.push_str(&desc_rows.connect(&desc_sep[])[]); row }); @@ -794,10 +795,10 @@ fn format_option(opt: &OptGroup) -> String { // Use short_name is possible, but fallback to long_name. if opt.short_name.len() > 0 { line.push('-'); - line.push_str(opt.short_name.index(&FullRange)); + line.push_str(&opt.short_name[]); } else { line.push_str("--"); - line.push_str(opt.long_name.index(&FullRange)); + line.push_str(&opt.long_name[]); } if opt.hasarg != No { @@ -805,7 +806,7 @@ fn format_option(opt: &OptGroup) -> String { if opt.hasarg == Maybe { line.push('['); } - line.push_str(opt.hint.index(&FullRange)); + line.push_str(&opt.hint[]); if opt.hasarg == Maybe { line.push(']'); } @@ -824,10 +825,10 @@ fn format_option(opt: &OptGroup) -> String { /// Derive a short one-line usage summary from a set of long options. pub fn short_usage(program_name: &str, opts: &[OptGroup]) -> String { let mut line = format!("Usage: {} ", program_name); - line.push_str(opts.iter() - .map(format_option) - .collect::<Vec<String>>() - .connect(" ").index(&FullRange)); + line.push_str(&opts.iter() + .map(format_option) + .collect::<Vec<String>>() + .connect(" ")[]); line } @@ -890,9 +891,9 @@ fn each_split_within<F>(ss: &str, lim: uint, mut it: F) -> bool where (B, Cr, UnderLim) => { B } (B, Cr, OverLim) if (i - last_start + 1) > lim => panic!("word starting with {} longer than limit!", - ss.index(&(last_start..(i + 1)))), + &ss[last_start..(i + 1)]), (B, Cr, OverLim) => { - *cont = it(ss.index(&(slice_start..last_end))); + *cont = it(&ss[slice_start..last_end]); slice_start = last_start; B } @@ -902,7 +903,7 @@ fn each_split_within<F>(ss: &str, lim: uint, mut it: F) -> bool where } (B, Ws, OverLim) => { last_end = i; - *cont = it(ss.index(&(slice_start..last_end))); + *cont = it(&ss[slice_start..last_end]); A } @@ -911,14 +912,14 @@ fn each_split_within<F>(ss: &str, lim: uint, mut it: F) -> bool where B } (C, Cr, OverLim) => { - *cont = it(ss.index(&(slice_start..last_end))); + *cont = it(&ss[slice_start..last_end]); slice_start = i; last_start = i; last_end = i; B } (C, Ws, OverLim) => { - *cont = it(ss.index(&(slice_start..last_end))); + *cont = it(&ss[slice_start..last_end]); A } (C, Ws, UnderLim) => { diff --git a/src/libgraphviz/lib.rs b/src/libgraphviz/lib.rs index 83bad70e7b1..9d2318e253e 100644 --- a/src/libgraphviz/lib.rs +++ b/src/libgraphviz/lib.rs @@ -266,6 +266,7 @@ #![crate_name = "graphviz"] #![experimental] +#![staged_api] #![crate_type = "rlib"] #![crate_type = "dylib"] #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png", @@ -452,7 +453,7 @@ impl<'a> LabelText<'a> { pub fn escape(&self) -> String { match self { &LabelStr(ref s) => s.escape_default(), - &EscStr(ref s) => LabelText::escape_str(s.index(&FullRange)), + &EscStr(ref s) => LabelText::escape_str(&s[]), } } @@ -481,7 +482,7 @@ impl<'a> LabelText<'a> { let mut prefix = self.pre_escaped_content().into_owned(); let suffix = suffix.pre_escaped_content(); prefix.push_str(r"\n\n"); - prefix.push_str(suffix.index(&FullRange)); + prefix.push_str(&suffix[]); EscStr(prefix.into_cow()) } } @@ -675,7 +676,7 @@ mod tests { impl<'a> Labeller<'a, Node, &'a Edge> for LabelledGraph { fn graph_id(&'a self) -> Id<'a> { - Id::new(self.name.index(&FullRange)).unwrap() + Id::new(&self.name[]).unwrap() } fn node_id(&'a self, n: &Node) -> Id<'a> { id_name(n) diff --git a/src/liblibc/lib.rs b/src/liblibc/lib.rs index 347a958076d..c39fd074387 100644 --- a/src/liblibc/lib.rs +++ b/src/liblibc/lib.rs @@ -11,6 +11,7 @@ #![crate_name = "libc"] #![crate_type = "rlib"] #![cfg_attr(not(feature = "cargo-build"), experimental)] +#![cfg_attr(not(feature = "cargo-build"), staged_api)] #![no_std] #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png", html_favicon_url = "http://www.rust-lang.org/favicon.ico", @@ -5065,7 +5066,5 @@ pub fn issue_14344_workaround() {} // FIXME #14344 force linkage to happen corre #[doc(hidden)] #[cfg(not(test))] mod std { - #[cfg(stage0)] - pub use core::marker as kinds; pub use core::marker; } diff --git a/src/liblog/lib.rs b/src/liblog/lib.rs index 08b01e956e1..0d5f6b65827 100644 --- a/src/liblog/lib.rs +++ b/src/liblog/lib.rs @@ -157,13 +157,17 @@ #![crate_name = "log"] #![experimental = "use the crates.io `log` library instead"] +#![staged_api] #![crate_type = "rlib"] #![crate_type = "dylib"] #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png", html_favicon_url = "http://www.rust-lang.org/favicon.ico", html_root_url = "http://doc.rust-lang.org/nightly/", html_playground_url = "http://play.rust-lang.org/")] + +#![allow(unknown_features)] #![feature(slicing_syntax)] +#![feature(box_syntax)] #![deny(missing_docs)] extern crate regex; @@ -287,7 +291,7 @@ pub fn log(level: u32, loc: &'static LogLocation, args: fmt::Arguments) { // Test the literal string from args against the current filter, if there // is one. match unsafe { FILTER.as_ref() } { - Some(filter) if !filter.is_match(args.to_string().index(&FullRange)) => return, + Some(filter) if !filter.is_match(&args.to_string()[]) => return, _ => {} } @@ -382,7 +386,7 @@ fn enabled(level: u32, // Search for the longest match, the vector is assumed to be pre-sorted. for directive in iter.rev() { match directive.name { - Some(ref name) if !module.starts_with(name.index(&FullRange)) => {}, + Some(ref name) if !module.starts_with(&name[]) => {}, Some(..) | None => { return level <= directive.level } @@ -397,7 +401,7 @@ fn enabled(level: u32, /// `Once` primitive (and this function is called from that primitive). fn init() { let (mut directives, filter) = match os::getenv("RUST_LOG") { - Some(spec) => directive::parse_logging_spec(spec.index(&FullRange)), + Some(spec) => directive::parse_logging_spec(&spec[]), None => (Vec::new(), None), }; diff --git a/src/librand/lib.rs b/src/librand/lib.rs index ad2a4dbec4e..497e339b316 100644 --- a/src/librand/lib.rs +++ b/src/librand/lib.rs @@ -25,6 +25,7 @@ #![no_std] #![experimental] +#![staged_api] #[macro_use] extern crate core; @@ -193,7 +194,7 @@ pub trait Rng : Sized { /// /// let mut rng = thread_rng(); /// let x = rng.gen_iter::<uint>().take(10).collect::<Vec<uint>>(); - /// println!("{}", x); + /// println!("{:?}", x); /// println!("{:?}", rng.gen_iter::<(f64, bool)>().take(5) /// .collect::<Vec<(f64, bool)>>()); /// ``` @@ -270,7 +271,7 @@ pub trait Rng : Sized { /// let mut rng = thread_rng(); /// println!("{:?}", rng.choose(&choices)); /// # // uncomment when slicing syntax is stable - /// //assert_eq!(rng.choose(choices.index(&(0..0))), None); + /// //assert_eq!(rng.choose(&choices[0..0]), None); /// ``` fn choose<'a, T>(&mut self, values: &'a [T]) -> Option<&'a T> { if values.is_empty() { @@ -290,9 +291,9 @@ pub trait Rng : Sized { /// let mut rng = thread_rng(); /// let mut y = [1i, 2, 3]; /// rng.shuffle(&mut y); - /// println!("{}", y.as_slice()); + /// println!("{:?}", y.as_slice()); /// rng.shuffle(&mut y); - /// println!("{}", y.as_slice()); + /// println!("{:?}", y.as_slice()); /// ``` fn shuffle<T>(&mut self, values: &mut [T]) { let mut i = values.len(); @@ -495,8 +496,6 @@ pub struct Closed01<F>(pub F); mod std { pub use core::{option, fmt}; // panic!() pub use core::clone; // derive Clone - #[cfg(stage0)] - pub use core::marker as kinds; pub use core::marker; } diff --git a/src/librbml/io.rs b/src/librbml/io.rs index 5ebec32d733..bdc00d7db97 100644 --- a/src/librbml/io.rs +++ b/src/librbml/io.rs @@ -95,7 +95,7 @@ impl Writer for SeekableMemWriter { // there (left), and what will be appended on the end (right) let cap = self.buf.len() - self.pos; let (left, right) = if cap <= buf.len() { - (buf.index(&(0..cap)), buf.index(&(cap..))) + (&buf[0..cap], &buf[cap..]) } else { let result: (_, &[_]) = (buf, &[]); result diff --git a/src/librbml/lib.rs b/src/librbml/lib.rs index a66d1dd08c1..da803aa5011 100644 --- a/src/librbml/lib.rs +++ b/src/librbml/lib.rs @@ -17,6 +17,7 @@ #![crate_name = "rbml"] #![experimental] +#![staged_api] #![crate_type = "rlib"] #![crate_type = "dylib"] #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png", @@ -56,7 +57,7 @@ impl<'doc> Doc<'doc> { } pub fn as_str_slice<'a>(&'a self) -> &'a str { - str::from_utf8(self.data.index(&(self.start..self.end))).unwrap() + str::from_utf8(&self.data[self.start..self.end]).unwrap() } pub fn as_str(&self) -> String { @@ -291,7 +292,7 @@ pub mod reader { pub fn with_doc_data<T, F>(d: Doc, f: F) -> T where F: FnOnce(&[u8]) -> T, { - f(d.data.index(&(d.start..d.end))) + f(&d.data[d.start..d.end]) } diff --git a/src/libregex/compile.rs b/src/libregex/compile.rs index 5803da1d335..d29a7a425c1 100644 --- a/src/libregex/compile.rs +++ b/src/libregex/compile.rs @@ -105,7 +105,7 @@ impl Program { // This is a bit hacky since we have to skip over the initial // 'Save' instruction. let mut pre = String::with_capacity(5); - for inst in c.insts.index(&(1..)).iter() { + for inst in c.insts[1..].iter() { match *inst { OneChar(c, FLAG_EMPTY) => pre.push(c), _ => break diff --git a/src/libregex/lib.rs b/src/libregex/lib.rs index c039abc9aff..d19ce3b460a 100644 --- a/src/libregex/lib.rs +++ b/src/libregex/lib.rs @@ -17,6 +17,7 @@ #![crate_type = "rlib"] #![crate_type = "dylib"] #![experimental = "use the crates.io `regex` library instead"] +#![staged_api] #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png", html_favicon_url = "http://www.rust-lang.org/favicon.ico", html_root_url = "http://doc.rust-lang.org/nightly/", @@ -24,6 +25,7 @@ #![allow(unknown_features)] #![feature(slicing_syntax)] +#![feature(box_syntax)] #![deny(missing_docs)] #[cfg(test)] diff --git a/src/libregex/parse.rs b/src/libregex/parse.rs index dd11d42b8aa..1cc2b271e9c 100644 --- a/src/libregex/parse.rs +++ b/src/libregex/parse.rs @@ -18,7 +18,6 @@ use std::cmp; use std::fmt; use std::iter; use std::num; -use std::ops::Index; /// Static data containing Unicode ranges for general categories and scripts. use unicode::regex::{UNICODE_CLASSES, PERLD, PERLS, PERLW}; @@ -285,8 +284,8 @@ impl<'a> Parser<'a> { match self.next_char() { true => Ok(()), false => { - self.err(format!("Expected {:?} but got EOF.", - expected).index(&FullRange)) + self.err(&format!("Expected {:?} but got EOF.", + expected)[]) } } } @@ -294,11 +293,11 @@ impl<'a> Parser<'a> { fn expect(&mut self, expected: char) -> Result<(), Error> { match self.next_char() { true if self.cur() == expected => Ok(()), - true => self.err(format!("Expected '{:?}' but got '{:?}'.", - expected, self.cur()).index(&FullRange)), + true => self.err(&format!("Expected '{:?}' but got '{:?}'.", + expected, self.cur())[]), false => { - self.err(format!("Expected '{:?}' but got EOF.", - expected).index(&FullRange)) + self.err(&format!("Expected '{:?}' but got EOF.", + expected)[]) } } } @@ -443,15 +442,15 @@ impl<'a> Parser<'a> { match try!(self.parse_escape()) { Literal(c3, _) => c2 = c3, // allow literal escapes below ast => - return self.err(format!("Expected a literal, but got {:?}.", - ast).index(&FullRange)), + return self.err(&format!("Expected a literal, but got {:?}.", + ast)[]), } } if c2 < c { - return self.err(format!("Invalid character class \ - range '{}-{}'", - c, - c2).index(&FullRange)) + return self.err(&format!("Invalid character class \ + range '{}-{}'", + c, + c2)[]) } ranges.push((c, self.cur())) } else { @@ -489,7 +488,7 @@ impl<'a> Parser<'a> { FLAG_EMPTY }; let name = self.slice(name_start, closer - 1); - match find_class(ASCII_CLASSES, name.index(&FullRange)) { + match find_class(ASCII_CLASSES, &name[]) { None => None, Some(ranges) => { self.chari = closer; @@ -511,21 +510,21 @@ impl<'a> Parser<'a> { match self.pos('}') { Some(i) => i, None => { - return self.err(format!("No closing brace for counted \ - repetition starting at position \ - {:?}.", - start).index(&FullRange)) + return self.err(&format!("No closing brace for counted \ + repetition starting at position \ + {:?}.", + start)[]) } }; self.chari = closer; let greed = try!(self.get_next_greedy()); - let inner = self.chars.index(&((start+1)..closer)).iter().cloned() + let inner = self.chars[(start+1)..closer].iter().cloned() .collect::<String>(); // Parse the min and max values from the regex. let (mut min, mut max): (uint, Option<uint>); if !inner.contains(",") { - min = try!(self.parse_uint(inner.index(&FullRange))); + min = try!(self.parse_uint(&inner[])); max = Some(min); } else { let pieces: Vec<&str> = inner.splitn(1, ',').collect(); @@ -545,21 +544,21 @@ impl<'a> Parser<'a> { // Do some bounds checking and make sure max >= min. if min > MAX_REPEAT { - return self.err(format!( + return self.err(&format!( "{} exceeds maximum allowed repetitions ({})", - min, MAX_REPEAT).index(&FullRange)); + min, MAX_REPEAT)[]); } if max.is_some() { let m = max.unwrap(); if m > MAX_REPEAT { - return self.err(format!( + return self.err(&format!( "{} exceeds maximum allowed repetitions ({})", - m, MAX_REPEAT).index(&FullRange)); + m, MAX_REPEAT)[]); } if m < min { - return self.err(format!( + return self.err(&format!( "Max repetitions ({}) cannot be smaller than min \ - repetitions ({}).", m, min).index(&FullRange)); + repetitions ({}).", m, min)[]); } } @@ -623,7 +622,7 @@ impl<'a> Parser<'a> { Ok(AstClass(ranges, flags)) } _ => { - self.err(format!("Invalid escape sequence '\\\\{}'", c).index(&FullRange)) + self.err(&format!("Invalid escape sequence '\\\\{}'", c)[]) } } } @@ -641,9 +640,9 @@ impl<'a> Parser<'a> { let closer = match self.pos('}') { Some(i) => i, - None => return self.err(format!( + None => return self.err(&format!( "Missing '}}' for unclosed '{{' at position {}", - self.chari).index(&FullRange)), + self.chari)[]), }; if closer - self.chari + 1 == 0 { return self.err("No Unicode class name found.") @@ -657,10 +656,10 @@ impl<'a> Parser<'a> { name = self.slice(self.chari + 1, self.chari + 2); self.chari += 1; } - match find_class(UNICODE_CLASSES, name.index(&FullRange)) { + match find_class(UNICODE_CLASSES, &name[]) { None => { - return self.err(format!("Could not find Unicode class '{}'", - name).index(&FullRange)) + return self.err(&format!("Could not find Unicode class '{}'", + name)[]) } Some(ranges) => { Ok(AstClass(ranges, negated | (self.flags & FLAG_NOCASE))) @@ -683,11 +682,11 @@ impl<'a> Parser<'a> { } } let s = self.slice(start, end); - match num::from_str_radix::<u32>(s.index(&FullRange), 8) { + match num::from_str_radix::<u32>(&s[], 8) { Some(n) => Ok(Literal(try!(self.char_from_u32(n)), FLAG_EMPTY)), None => { - self.err(format!("Could not parse '{:?}' as octal number.", - s).index(&FullRange)) + self.err(&format!("Could not parse '{:?}' as octal number.", + s)[]) } } } @@ -703,14 +702,14 @@ impl<'a> Parser<'a> { let closer = match self.pos('}') { None => { - return self.err(format!("Missing '}}' for unclosed \ + return self.err(&format!("Missing '}}' for unclosed \ '{{' at position {}", - start).index(&FullRange)) + start)[]) } Some(i) => i, }; self.chari = closer; - self.parse_hex_digits(self.slice(start, closer).index(&FullRange)) + self.parse_hex_digits(&self.slice(start, closer)[]) } // Parses a two-digit hex number. @@ -730,7 +729,7 @@ impl<'a> Parser<'a> { match num::from_str_radix::<u32>(s, 16) { Some(n) => Ok(Literal(try!(self.char_from_u32(n)), FLAG_EMPTY)), None => { - self.err(format!("Could not parse '{}' as hex number.", s).index(&FullRange)) + self.err(&format!("Could not parse '{}' as hex number.", s)[]) } } } @@ -755,8 +754,8 @@ impl<'a> Parser<'a> { "Capture names can only have underscores, letters and digits.") } if self.names.contains(&name) { - return self.err(format!("Duplicate capture group name '{}'.", - name).index(&FullRange)) + return self.err(&format!("Duplicate capture group name '{}'.", + name)[]) } self.names.push(name.clone()); self.chari = closer; @@ -788,9 +787,9 @@ impl<'a> Parser<'a> { 'U' => { flags = flags | FLAG_SWAP_GREED; saw_flag = true}, '-' => { if sign < 0 { - return self.err(format!( + return self.err(&format!( "Cannot negate flags twice in '{}'.", - self.slice(start, self.chari + 1)).index(&FullRange)) + self.slice(start, self.chari + 1))[]) } sign = -1; saw_flag = false; @@ -799,9 +798,9 @@ impl<'a> Parser<'a> { ':' | ')' => { if sign < 0 { if !saw_flag { - return self.err(format!( + return self.err(&format!( "A valid flag does not follow negation in '{}'", - self.slice(start, self.chari + 1)).index(&FullRange)) + self.slice(start, self.chari + 1))[]) } flags = flags ^ flags; } @@ -812,8 +811,8 @@ impl<'a> Parser<'a> { self.flags = flags; return Ok(()) } - _ => return self.err(format!( - "Unrecognized flag '{}'.", self.cur()).index(&FullRange)), + _ => return self.err(&format!( + "Unrecognized flag '{}'.", self.cur())[]), } } } @@ -910,8 +909,8 @@ impl<'a> Parser<'a> { match s.parse::<uint>() { Some(i) => Ok(i), None => { - self.err(format!("Expected an unsigned integer but got '{}'.", - s).index(&FullRange)) + self.err(&format!("Expected an unsigned integer but got '{}'.", + s)[]) } } } @@ -920,8 +919,8 @@ impl<'a> Parser<'a> { match char::from_u32(n) { Some(c) => Ok(c), None => { - self.err(format!("Could not decode '{}' to unicode \ - character.", n).index(&FullRange)) + self.err(&format!("Could not decode '{}' to unicode \ + character.", n)[]) } } } @@ -954,7 +953,7 @@ impl<'a> Parser<'a> { } fn slice(&self, start: uint, end: uint) -> String { - self.chars.index(&(start..end)).iter().cloned().collect() + self.chars[start..end].iter().cloned().collect() } } diff --git a/src/libregex/re.rs b/src/libregex/re.rs index 37f9869f3bf..16dd32b6be2 100644 --- a/src/libregex/re.rs +++ b/src/libregex/re.rs @@ -90,15 +90,6 @@ impl Clone for ExNative { } } -#[cfg(stage0)] -//FIXME: remove after stage0 snapshot -impl fmt::Show for Regex { - /// Shows the original regular expression. - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::String::fmt(self.as_str(), f) - } -} - impl fmt::String for Regex { /// Shows the original regular expression. fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { @@ -247,19 +238,19 @@ impl Regex { } let (s, e) = cap.pos(0).unwrap(); // captures only reports matches - new.push_str(text.index(&(last_match..s))); - new.push_str(rep.reg_replace(&cap).index(&FullRange)); + new.push_str(&text[last_match..s]); + new.push_str(&rep.reg_replace(&cap)[]); last_match = e; } - new.push_str(text.index(&(last_match..text.len()))); + new.push_str(&text[last_match..text.len()]); return new; } /// Returns the original string of this regex. pub fn as_str<'a>(&'a self) -> &'a str { match *self { - Dynamic(ExDynamic { ref original, .. }) => original.index(&FullRange), - Native(ExNative { ref original, .. }) => original.index(&FullRange), + Dynamic(ExDynamic { ref original, .. }) => &original[], + Native(ExNative { ref original, .. }) => &original[], } } @@ -356,13 +347,13 @@ impl<'r, 't> Iterator for RegexSplits<'r, 't> { if self.last >= text.len() { None } else { - let s = text.index(&(self.last..text.len())); + let s = &text[self.last..text.len()]; self.last = text.len(); Some(s) } } Some((s, e)) => { - let matched = text.index(&(self.last..s)); + let matched = &text[self.last..s]; self.last = e; Some(matched) } @@ -393,7 +384,7 @@ impl<'r, 't> Iterator for RegexSplitsN<'r, 't> { } else { self.cur += 1; if self.cur >= self.limit { - Some(text.index(&(self.splits.last..text.len()))) + Some(&text[self.splits.last..text.len()]) } else { self.splits.next() } @@ -526,7 +517,7 @@ impl<'t> Captures<'t> { }) }); let re = Regex::new(r"\$\$").unwrap(); - re.replace_all(text.index(&FullRange), NoExpand("$")) + re.replace_all(&text[], NoExpand("$")) } /// Returns the number of captured groups. diff --git a/src/libregex/vm.rs b/src/libregex/vm.rs index 04c430da4d2..9605536a052 100644 --- a/src/libregex/vm.rs +++ b/src/libregex/vm.rs @@ -152,7 +152,7 @@ impl<'r, 't> Nfa<'r, 't> { // out early. if self.prog.prefix.len() > 0 && clist.size == 0 { let needle = self.prog.prefix.as_bytes(); - let haystack = self.input.as_bytes().index(&(self.ic..)); + let haystack = &self.input.as_bytes()[self.ic..]; match find_prefix(needle, haystack) { None => break, Some(i) => { diff --git a/src/librustc/lib.rs b/src/librustc/lib.rs index a3a041c2497..e0143917a7c 100644 --- a/src/librustc/lib.rs +++ b/src/librustc/lib.rs @@ -16,6 +16,7 @@ #![crate_name = "rustc"] #![experimental] +#![staged_api] #![crate_type = "dylib"] #![crate_type = "rlib"] #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png", @@ -25,6 +26,7 @@ #![allow(unknown_features)] #![feature(quote)] #![feature(slicing_syntax, unsafe_destructor)] +#![feature(box_syntax)] #![feature(rustc_diagnostic_macros)] #![feature(old_impl_check)] diff --git a/src/librustc/lint/builtin.rs b/src/librustc/lint/builtin.rs index 1af8e2f29eb..7d893f3a106 100644 --- a/src/librustc/lint/builtin.rs +++ b/src/librustc/lint/builtin.rs @@ -34,7 +34,7 @@ use middle::{def, pat_util, stability}; use middle::const_eval::{eval_const_expr_partial, const_int, const_uint}; use util::ppaux::{ty_to_string}; use util::nodemap::{FnvHashMap, NodeSet}; -use lint::{Context, LintPass, LintArray}; +use lint::{Context, LintPass, LintArray, Lint}; use std::collections::hash_map::Entry::{Occupied, Vacant}; use std::num::SignedInt; @@ -506,7 +506,7 @@ impl BoxPointers { if n_uniq > 0 { let s = ty_to_string(cx.tcx, ty); let m = format!("type uses owned (Box type) pointers: {}", s); - cx.span_lint(BOX_POINTERS, span, m.index(&FullRange)); + cx.span_lint(BOX_POINTERS, span, &m[]); } } } @@ -586,7 +586,7 @@ impl LintPass for RawPointerDerive { } fn check_item(&mut self, cx: &Context, item: &ast::Item) { - if !attr::contains_name(item.attrs.index(&FullRange), "automatically_derived") { + if !attr::contains_name(&item.attrs[], "automatically_derived") { return } let did = match item.node { @@ -770,11 +770,11 @@ impl LintPass for UnusedResults { ty::ty_enum(did, _) => { if ast_util::is_local(did) { if let ast_map::NodeItem(it) = cx.tcx.map.get(did.node) { - warned |= check_must_use(cx, it.attrs.index(&FullRange), s.span); + warned |= check_must_use(cx, &it.attrs[], s.span); } } else { csearch::get_item_attrs(&cx.sess().cstore, did, |attrs| { - warned |= check_must_use(cx, attrs.index(&FullRange), s.span); + warned |= check_must_use(cx, &attrs[], s.span); }); } } @@ -796,7 +796,7 @@ impl LintPass for UnusedResults { msg.push_str(s.get()); } } - cx.span_lint(UNUSED_MUST_USE, sp, msg.index(&FullRange)); + cx.span_lint(UNUSED_MUST_USE, sp, &msg[]); return true; } } @@ -842,7 +842,7 @@ impl NonCamelCaseTypes { } else { format!("{} `{}` should have a camel case name such as `{}`", sort, s, c) }; - cx.span_lint(NON_CAMEL_CASE_TYPES, span, m.index(&FullRange)); + cx.span_lint(NON_CAMEL_CASE_TYPES, span, &m[]); } } } @@ -981,8 +981,8 @@ impl NonSnakeCase { if !is_snake_case(ident) { cx.span_lint(NON_SNAKE_CASE, span, - format!("{} `{}` should have a snake case name such as `{}`", - sort, s, to_snake_case(s.get())).index(&FullRange)); + &format!("{} `{}` should have a snake case name such as `{}`", + sort, s, to_snake_case(s.get()))[]); } } } @@ -1066,10 +1066,10 @@ impl LintPass for NonUpperCaseGlobals { // upper/lowercase) if s.get().chars().any(|c| c.is_lowercase()) { cx.span_lint(NON_UPPER_CASE_GLOBALS, it.span, - format!("static constant `{}` should have an uppercase name \ + &format!("static constant `{}` should have an uppercase name \ such as `{}`", - s.get(), s.get().chars().map(|c| c.to_uppercase()) - .collect::<String>().index(&FullRange)).index(&FullRange)); + s.get(), &s.get().chars().map(|c| c.to_uppercase()) + .collect::<String>()[])[]); } } _ => {} @@ -1083,10 +1083,10 @@ impl LintPass for NonUpperCaseGlobals { let s = token::get_ident(path1.node); if s.get().chars().any(|c| c.is_lowercase()) { cx.span_lint(NON_UPPER_CASE_GLOBALS, path1.span, - format!("static constant in pattern `{}` should have an uppercase \ + &format!("static constant in pattern `{}` should have an uppercase \ name such as `{}`", - s.get(), s.get().chars().map(|c| c.to_uppercase()) - .collect::<String>().index(&FullRange)).index(&FullRange)); + s.get(), &s.get().chars().map(|c| c.to_uppercase()) + .collect::<String>()[])[]); } } _ => {} @@ -1110,8 +1110,8 @@ impl UnusedParens { let necessary = struct_lit_needs_parens && contains_exterior_struct_lit(&**inner); if !necessary { cx.span_lint(UNUSED_PARENS, value.span, - format!("unnecessary parentheses around {}", - msg).index(&FullRange)) + &format!("unnecessary parentheses around {}", + msg)[]) } } @@ -1213,7 +1213,7 @@ impl LintPass for UnusedImportBraces { let m = format!("braces around {} is unnecessary", token::get_ident(*name).get()); cx.span_lint(UNUSED_IMPORT_BRACES, view_item.span, - m.index(&FullRange)); + &m[]); }, _ => () } @@ -1251,8 +1251,8 @@ impl LintPass for NonShorthandFieldPatterns { if let ast::PatIdent(_, ident, None) = fieldpat.node.pat.node { if ident.node.as_str() == fieldpat.node.ident.as_str() { cx.span_lint(NON_SHORTHAND_FIELD_PATTERNS, fieldpat.span, - format!("the `{}:` in this pattern is redundant and can \ - be removed", ident.node.as_str()).index(&FullRange)) + &format!("the `{}:` in this pattern is redundant and can \ + be removed", ident.node.as_str())[]) } } } @@ -1356,7 +1356,7 @@ impl LintPass for UnusedMut { fn check_expr(&mut self, cx: &Context, e: &ast::Expr) { if let ast::ExprMatch(_, ref arms, _) = e.node { for a in arms.iter() { - self.check_unused_mut_pat(cx, a.pats.index(&FullRange)) + self.check_unused_mut_pat(cx, &a.pats[]) } } } @@ -1477,7 +1477,7 @@ impl MissingDoc { }); if !has_doc { cx.span_lint(MISSING_DOCS, sp, - format!("missing documentation for {}", desc).index(&FullRange)); + &format!("missing documentation for {}", desc)[]); } } } @@ -1491,7 +1491,7 @@ impl LintPass for MissingDoc { let doc_hidden = self.doc_hidden() || attrs.iter().any(|attr| { attr.check_name("doc") && match attr.meta_item_list() { None => false, - Some(l) => attr::contains_name(l.index(&FullRange), "hidden"), + Some(l) => attr::contains_name(&l[], "hidden"), } }); self.doc_hidden_stack.push(doc_hidden); @@ -1513,7 +1513,7 @@ impl LintPass for MissingDoc { } fn check_crate(&mut self, cx: &Context, krate: &ast::Crate) { - self.check_missing_docs_attrs(cx, None, krate.attrs.index(&FullRange), + self.check_missing_docs_attrs(cx, None, &krate.attrs[], krate.span, "crate"); } @@ -1527,7 +1527,7 @@ impl LintPass for MissingDoc { ast::ItemTy(..) => "a type alias", _ => return }; - self.check_missing_docs_attrs(cx, Some(it.id), it.attrs.index(&FullRange), + self.check_missing_docs_attrs(cx, Some(it.id), &it.attrs[], it.span, desc); } @@ -1540,13 +1540,13 @@ impl LintPass for MissingDoc { // Otherwise, doc according to privacy. This will also check // doc for default methods defined on traits. - self.check_missing_docs_attrs(cx, Some(m.id), m.attrs.index(&FullRange), + self.check_missing_docs_attrs(cx, Some(m.id), &m.attrs[], m.span, "a method"); } } fn check_ty_method(&mut self, cx: &Context, tm: &ast::TypeMethod) { - self.check_missing_docs_attrs(cx, Some(tm.id), tm.attrs.index(&FullRange), + self.check_missing_docs_attrs(cx, Some(tm.id), &tm.attrs[], tm.span, "a type method"); } @@ -1556,14 +1556,14 @@ impl LintPass for MissingDoc { let cur_struct_def = *self.struct_def_stack.last() .expect("empty struct_def_stack"); self.check_missing_docs_attrs(cx, Some(cur_struct_def), - sf.node.attrs.index(&FullRange), sf.span, + &sf.node.attrs[], sf.span, "a struct field") } } } fn check_variant(&mut self, cx: &Context, v: &ast::Variant, _: &ast::Generics) { - self.check_missing_docs_attrs(cx, Some(v.node.id), v.node.attrs.index(&FullRange), + self.check_missing_docs_attrs(cx, Some(v.node.id), &v.node.attrs[], v.span, "a variant"); assert!(!self.in_variant); self.in_variant = true; @@ -1643,6 +1643,13 @@ declare_lint! { "detects use of #[unstable] items (incl. items with no stability attribute)" } +declare_lint!(STAGED_EXPERIMENTAL, Warn, + "detects use of #[experimental] items in staged builds"); + +declare_lint!(STAGED_UNSTABLE, Warn, + "detects use of #[unstable] items (incl. items with no stability attribute) \ + in staged builds"); + /// Checks for use of items with `#[deprecated]`, `#[experimental]` and /// `#[unstable]` attributes, or no stability attribute. #[derive(Copy)] @@ -1650,12 +1657,13 @@ pub struct Stability; impl Stability { fn lint(&self, cx: &Context, id: ast::DefId, span: Span) { - let stability = stability::lookup(cx.tcx, id); + + let ref stability = stability::lookup(cx.tcx, id); let cross_crate = !ast_util::is_local(id); // stability attributes are promises made across crates; only // check DEPRECATED for crate-local usage. - let (lint, label) = match stability { + let (lint, label) = match *stability { // no stability attributes == Unstable None if cross_crate => (UNSTABLE, "unmarked"), Some(attr::Stability { level: attr::Unstable, .. }) if cross_crate => @@ -1667,24 +1675,53 @@ impl Stability { _ => return }; - let msg = match stability { - Some(attr::Stability { text: Some(ref s), .. }) => { - format!("use of {} item: {}", label, *s) + output(cx, span, stability, lint, label); + if cross_crate && stability::is_staged_api(cx.tcx, id) { + if lint.name == UNSTABLE.name { + output(cx, span, stability, STAGED_UNSTABLE, label); + } else if lint.name == EXPERIMENTAL.name { + output(cx, span, stability, STAGED_EXPERIMENTAL, label); } - _ => format!("use of {} item", label) - }; + } + + fn output(cx: &Context, span: Span, stability: &Option<attr::Stability>, + lint: &'static Lint, label: &'static str) { + let msg = match *stability { + Some(attr::Stability { text: Some(ref s), .. }) => { + format!("use of {} item: {}", label, *s) + } + _ => format!("use of {} item", label) + }; - cx.span_lint(lint, span, msg.index(&FullRange)); + cx.span_lint(lint, span, &msg[]); + } } + fn is_internal(&self, cx: &Context, span: Span) -> bool { cx.tcx.sess.codemap().span_is_internal(span) } + } impl LintPass for Stability { fn get_lints(&self) -> LintArray { - lint_array!(DEPRECATED, EXPERIMENTAL, UNSTABLE) + lint_array!(DEPRECATED, EXPERIMENTAL, UNSTABLE, STAGED_EXPERIMENTAL, STAGED_UNSTABLE) + } + + fn check_crate(&mut self, _: &Context, c: &ast::Crate) { + // Just mark the #[staged_api] attribute used, though nothing else is done + // with it during this pass over the source. + for attr in c.attrs.iter() { + if attr.name().get() == "staged_api" { + match attr.node.value.node { + ast::MetaWord(_) => { + attr::mark_used(attr); + } + _ => (/*pass*/) + } + } + } } fn check_view_item(&mut self, cx: &Context, item: &ast::ViewItem) { @@ -1746,6 +1783,7 @@ impl LintPass for Stability { } _ => return }; + self.lint(cx, id, span); } @@ -1878,3 +1916,22 @@ impl LintPass for HardwiredLints { ) } } + +/// Forbids using the `#[feature(...)]` attribute +#[derive(Copy)] +pub struct UnstableFeatures; + +declare_lint!(UNSTABLE_FEATURES, Allow, + "enabling unstable features"); + +impl LintPass for UnstableFeatures { + fn get_lints(&self) -> LintArray { + lint_array!(UNSTABLE_FEATURES) + } + fn check_attribute(&mut self, ctx: &Context, attr: &ast::Attribute) { + use syntax::attr; + if attr::contains_name(&[attr.node.value.clone()], "feature") { + ctx.span_lint(UNSTABLE_FEATURES, attr.span, "unstable feature"); + } + } +} diff --git a/src/librustc/lint/context.rs b/src/librustc/lint/context.rs index 51998bdbcf2..db4d99fe494 100644 --- a/src/librustc/lint/context.rs +++ b/src/librustc/lint/context.rs @@ -28,8 +28,9 @@ use self::TargetLint::*; use middle::privacy::ExportedItems; use middle::ty::{self, Ty}; use session::{early_error, Session}; +use session::config::UnstableFeatures; use lint::{Level, LevelSource, Lint, LintId, LintArray, LintPass, LintPassObject}; -use lint::{Default, CommandLine, Node, Allow, Warn, Deny, Forbid}; +use lint::{Default, CommandLine, Node, Allow, Warn, Deny, Forbid, ReleaseChannel}; use lint::builtin; use util::nodemap::FnvHashMap; @@ -104,7 +105,7 @@ impl LintStore { } pub fn get_lints<'t>(&'t self) -> &'t [(&'static Lint, bool)] { - self.lints.index(&FullRange) + &self.lints[] } pub fn get_lint_groups<'t>(&'t self) -> Vec<(&'static str, Vec<LintId>, bool)> { @@ -124,11 +125,11 @@ impl LintStore { match (sess, from_plugin) { // We load builtin lints first, so a duplicate is a compiler bug. // Use early_error when handling -W help with no crate. - (None, _) => early_error(msg.index(&FullRange)), - (Some(sess), false) => sess.bug(msg.index(&FullRange)), + (None, _) => early_error(&msg[]), + (Some(sess), false) => sess.bug(&msg[]), // A duplicate name from a plugin is a user error. - (Some(sess), true) => sess.err(msg.index(&FullRange)), + (Some(sess), true) => sess.err(&msg[]), } } @@ -149,11 +150,11 @@ impl LintStore { match (sess, from_plugin) { // We load builtin lints first, so a duplicate is a compiler bug. // Use early_error when handling -W help with no crate. - (None, _) => early_error(msg.index(&FullRange)), - (Some(sess), false) => sess.bug(msg.index(&FullRange)), + (None, _) => early_error(&msg[]), + (Some(sess), false) => sess.bug(&msg[]), // A duplicate name from a plugin is a user error. - (Some(sess), true) => sess.err(msg.index(&FullRange)), + (Some(sess), true) => sess.err(&msg[]), } } } @@ -210,6 +211,7 @@ impl LintStore { UnusedAllocation, Stability, MissingCopyImplementations, + UnstableFeatures, ); add_builtin_with_new!(sess, @@ -267,8 +269,8 @@ impl LintStore { let warning = format!("lint {} has been renamed to {}", lint_name, new_name); match span { - Some(span) => sess.span_warn(span, warning.index(&FullRange)), - None => sess.warn(warning.index(&FullRange)), + Some(span) => sess.span_warn(span, &warning[]), + None => sess.warn(&warning[]), }; Some(lint_id) } @@ -278,26 +280,49 @@ impl LintStore { pub fn process_command_line(&mut self, sess: &Session) { for &(ref lint_name, level) in sess.opts.lint_opts.iter() { - match self.find_lint(lint_name.index(&FullRange), sess, None) { + match self.find_lint(&lint_name[], sess, None) { Some(lint_id) => self.set_level(lint_id, (level, CommandLine)), None => { match self.lint_groups.iter().map(|(&x, pair)| (x, pair.0.clone())) .collect::<FnvHashMap<&'static str, Vec<LintId>>>() - .get(lint_name.index(&FullRange)) { + .get(&lint_name[]) { Some(v) => { v.iter() .map(|lint_id: &LintId| self.set_level(*lint_id, (level, CommandLine))) .collect::<Vec<()>>(); } - None => sess.err(format!("unknown {} flag: {}", - level.as_str(), lint_name).index(&FullRange)), + None => sess.err(&format!("unknown {} flag: {}", + level.as_str(), lint_name)[]), } } } } } + + fn maybe_stage_features(&mut self, sess: &Session) { + let lvl = match sess.opts.unstable_features { + UnstableFeatures::Default => return, + UnstableFeatures::Disallow => Warn, + UnstableFeatures::Cheat => Allow + }; + match self.by_name.get("unstable_features") { + Some(&Id(lint_id)) => self.set_level(lint_id, (lvl, ReleaseChannel)), + Some(&Renamed(_, lint_id)) => self.set_level(lint_id, (lvl, ReleaseChannel)), + None => unreachable!() + } + match self.by_name.get("staged_unstable") { + Some(&Id(lint_id)) => self.set_level(lint_id, (lvl, ReleaseChannel)), + Some(&Renamed(_, lint_id)) => self.set_level(lint_id, (lvl, ReleaseChannel)), + None => unreachable!() + } + match self.by_name.get("staged_experimental") { + Some(&Id(lint_id)) => self.set_level(lint_id, (lvl, ReleaseChannel)), + Some(&Renamed(_, lint_id)) => self.set_level(lint_id, (lvl, ReleaseChannel)), + None => unreachable!() + } + } } /// Context for lint checking. @@ -380,6 +405,7 @@ pub fn raw_emit_lint(sess: &Session, lint: &'static Lint, if level == Allow { return } let name = lint.name_lower(); + let mut def = None; let mut note = None; let msg = match source { Default => { @@ -394,7 +420,13 @@ pub fn raw_emit_lint(sess: &Session, lint: &'static Lint, }, name.replace("_", "-")) }, Node(src) => { - note = Some(src); + def = Some(src); + msg.to_string() + } + ReleaseChannel => { + let release_channel = option_env!("CFG_RELEASE_CHANNEL").unwrap_or("(unknown)"); + note = Some(format!("this feature may not be used in the {} release channel", + release_channel)); msg.to_string() } }; @@ -403,14 +435,18 @@ pub fn raw_emit_lint(sess: &Session, lint: &'static Lint, if level == Forbid { level = Deny; } match (level, span) { - (Warn, Some(sp)) => sess.span_warn(sp, msg.index(&FullRange)), - (Warn, None) => sess.warn(msg.index(&FullRange)), - (Deny, Some(sp)) => sess.span_err(sp, msg.index(&FullRange)), - (Deny, None) => sess.err(msg.index(&FullRange)), + (Warn, Some(sp)) => sess.span_warn(sp, &msg[]), + (Warn, None) => sess.warn(&msg[]), + (Deny, Some(sp)) => sess.span_err(sp, &msg[]), + (Deny, None) => sess.err(&msg[]), _ => sess.bug("impossible level in raw_emit_lint"), } - for span in note.into_iter() { + for note in note.into_iter() { + sess.note(¬e[]); + } + + for span in def.into_iter() { sess.span_note(span, "lint level defined here"); } } @@ -513,9 +549,9 @@ impl<'a, 'tcx> Context<'a, 'tcx> { if now == Forbid && level != Forbid { let lint_name = lint_id.as_str(); self.tcx.sess.span_err(span, - format!("{}({}) overruled by outer forbid({})", + &format!("{}({}) overruled by outer forbid({})", level.as_str(), lint_name, - lint_name).index(&FullRange)); + lint_name)[]); } else if now != level { let src = self.lints.get_level_source(lint_id).1; self.level_stack.push((lint_id, (now, src))); @@ -550,7 +586,7 @@ impl<'a, 'tcx> Context<'a, 'tcx> { impl<'a, 'tcx, 'v> Visitor<'v> for Context<'a, 'tcx> { fn visit_item(&mut self, it: &ast::Item) { - self.with_lint_attrs(it.attrs.index(&FullRange), |cx| { + self.with_lint_attrs(&it.attrs[], |cx| { run_lints!(cx, check_item, it); cx.visit_ids(|v| v.visit_item(it)); visit::walk_item(cx, it); @@ -558,14 +594,14 @@ impl<'a, 'tcx, 'v> Visitor<'v> for Context<'a, 'tcx> { } fn visit_foreign_item(&mut self, it: &ast::ForeignItem) { - self.with_lint_attrs(it.attrs.index(&FullRange), |cx| { + self.with_lint_attrs(&it.attrs[], |cx| { run_lints!(cx, check_foreign_item, it); visit::walk_foreign_item(cx, it); }) } fn visit_view_item(&mut self, i: &ast::ViewItem) { - self.with_lint_attrs(i.attrs.index(&FullRange), |cx| { + self.with_lint_attrs(&i.attrs[], |cx| { run_lints!(cx, check_view_item, i); cx.visit_ids(|v| v.visit_view_item(i)); visit::walk_view_item(cx, i); @@ -591,7 +627,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for Context<'a, 'tcx> { body: &'v ast::Block, span: Span, id: ast::NodeId) { match fk { visit::FkMethod(_, _, m) => { - self.with_lint_attrs(m.attrs.index(&FullRange), |cx| { + self.with_lint_attrs(&m.attrs[], |cx| { run_lints!(cx, check_fn, fk, decl, body, span, id); cx.visit_ids(|v| { v.visit_fn(fk, decl, body, span, id); @@ -607,7 +643,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for Context<'a, 'tcx> { } fn visit_ty_method(&mut self, t: &ast::TypeMethod) { - self.with_lint_attrs(t.attrs.index(&FullRange), |cx| { + self.with_lint_attrs(&t.attrs[], |cx| { run_lints!(cx, check_ty_method, t); visit::walk_ty_method(cx, t); }) @@ -624,14 +660,14 @@ impl<'a, 'tcx, 'v> Visitor<'v> for Context<'a, 'tcx> { } fn visit_struct_field(&mut self, s: &ast::StructField) { - self.with_lint_attrs(s.node.attrs.index(&FullRange), |cx| { + self.with_lint_attrs(&s.node.attrs[], |cx| { run_lints!(cx, check_struct_field, s); visit::walk_struct_field(cx, s); }) } fn visit_variant(&mut self, v: &ast::Variant, g: &ast::Generics) { - self.with_lint_attrs(v.node.attrs.index(&FullRange), |cx| { + self.with_lint_attrs(&v.node.attrs[], |cx| { run_lints!(cx, check_variant, v, g); visit::walk_variant(cx, v, g); run_lints!(cx, check_variant_post, v, g); @@ -725,7 +761,7 @@ impl<'a, 'tcx> IdVisitingOperation for Context<'a, 'tcx> { None => {} Some(lints) => { for (lint_id, span, msg) in lints.into_iter() { - self.span_lint(lint_id.lint, span, msg.index(&FullRange)) + self.span_lint(lint_id.lint, span, &msg[]) } } } @@ -767,11 +803,15 @@ impl LintPass for GatherNodeLevels { /// Consumes the `lint_store` field of the `Session`. pub fn check_crate(tcx: &ty::ctxt, exported_items: &ExportedItems) { + + // If this is a feature-staged build of rustc then flip several lints to 'forbid' + tcx.sess.lint_store.borrow_mut().maybe_stage_features(&tcx.sess); + let krate = tcx.map.krate(); let mut cx = Context::new(tcx, krate, exported_items); // Visit the whole crate. - cx.with_lint_attrs(krate.attrs.index(&FullRange), |cx| { + cx.with_lint_attrs(&krate.attrs[], |cx| { cx.visit_id(ast::CRATE_NODE_ID); cx.visit_ids(|v| { v.visited_outermost = true; diff --git a/src/librustc/lint/mod.rs b/src/librustc/lint/mod.rs index e9778fa05ff..8a266a2530b 100644 --- a/src/librustc/lint/mod.rs +++ b/src/librustc/lint/mod.rs @@ -186,7 +186,7 @@ impl PartialEq for LintId { impl Eq for LintId { } -impl<S: hash::Writer> hash::Hash<S> for LintId { +impl<S: hash::Writer + hash::Hasher> hash::Hash<S> for LintId { fn hash(&self, state: &mut S) { let ptr = self.lint as *const Lint; ptr.hash(state); @@ -248,6 +248,9 @@ pub enum LintSource { /// Lint level was set by a command-line flag. CommandLine, + + /// Lint level was set by the release channel. + ReleaseChannel } pub type LevelSource = (Level, LintSource); diff --git a/src/librustc/metadata/creader.rs b/src/librustc/metadata/creader.rs index 66967a73546..310874c311b 100644 --- a/src/librustc/metadata/creader.rs +++ b/src/librustc/metadata/creader.rs @@ -65,7 +65,7 @@ fn dump_crates(cstore: &CStore) { } fn should_link(i: &ast::ViewItem) -> bool { - !attr::contains_name(i.attrs.index(&FullRange), "no_link") + !attr::contains_name(&i.attrs[], "no_link") } @@ -90,7 +90,7 @@ pub fn validate_crate_name(sess: Option<&Session>, s: &str, sp: Option<Span>) { for c in s.chars() { if c.is_alphanumeric() { continue } if c == '_' || c == '-' { continue } - err(format!("invalid character `{}` in crate name: `{}`", c, s).index(&FullRange)); + err(&format!("invalid character `{}` in crate name: `{}`", c, s)[]); } match sess { Some(sess) => sess.abort_if_errors(), @@ -189,8 +189,8 @@ impl<'a> CrateReader<'a> { match self.extract_crate_info(i) { Some(info) => { let (cnum, _, _) = self.resolve_crate(&None, - info.ident.index(&FullRange), - info.name.index(&FullRange), + &info.ident[], + &info.name[], None, i.span, PathKind::Crate); @@ -209,7 +209,7 @@ impl<'a> CrateReader<'a> { let name = match *path_opt { Some((ref path_str, _)) => { let name = path_str.get().to_string(); - validate_crate_name(Some(self.sess), name.index(&FullRange), + validate_crate_name(Some(self.sess), &name[], Some(i.span)); name } @@ -275,8 +275,8 @@ impl<'a> CrateReader<'a> { cstore::NativeUnknown } else { self.sess.span_err(m.span, - format!("unknown kind: `{}`", - k).index(&FullRange)); + &format!("unknown kind: `{}`", + k)[]); cstore::NativeUnknown } } @@ -330,7 +330,7 @@ impl<'a> CrateReader<'a> { match self.sess.opts.externs.get(name) { Some(locs) => { let found = locs.iter().any(|l| { - let l = fs::realpath(&Path::new(l.index(&FullRange))).ok(); + let l = fs::realpath(&Path::new(&l[])).ok(); l == source.dylib || l == source.rlib }); if found { @@ -409,7 +409,7 @@ impl<'a> CrateReader<'a> { crate_name: name, hash: hash.map(|a| &*a), filesearch: self.sess.target_filesearch(kind), - triple: self.sess.opts.target_triple.index(&FullRange), + triple: &self.sess.opts.target_triple[], root: root, rejected_via_hash: vec!(), rejected_via_triple: vec!(), @@ -435,8 +435,8 @@ impl<'a> CrateReader<'a> { decoder::get_crate_deps(cdata).iter().map(|dep| { debug!("resolving dep crate {} hash: `{}`", dep.name, dep.hash); let (local_cnum, _, _) = self.resolve_crate(root, - dep.name.index(&FullRange), - dep.name.index(&FullRange), + &dep.name[], + &dep.name[], Some(&dep.hash), span, PathKind::Dependency); @@ -447,7 +447,7 @@ impl<'a> CrateReader<'a> { pub fn read_plugin_metadata<'b>(&'b mut self, vi: &'b ast::ViewItem) -> PluginMetadata<'b> { let info = self.extract_crate_info(vi).unwrap(); - let target_triple = self.sess.opts.target_triple.index(&FullRange); + let target_triple = &self.sess.opts.target_triple[]; let is_cross = target_triple != config::host_triple(); let mut should_link = info.should_link && !is_cross; let mut target_only = false; @@ -456,8 +456,8 @@ impl<'a> CrateReader<'a> { let mut load_ctxt = loader::Context { sess: self.sess, span: vi.span, - ident: ident.index(&FullRange), - crate_name: name.index(&FullRange), + ident: &ident[], + crate_name: &name[], hash: None, filesearch: self.sess.host_filesearch(PathKind::Crate), triple: config::host_triple(), @@ -485,8 +485,8 @@ impl<'a> CrateReader<'a> { let register = should_link && self.existing_match(info.name.as_slice(), None).is_none(); let metadata = if register { // Register crate now to avoid double-reading metadata - let (_, cmd, _) = self.register_crate(&None, info.ident.index(&FullRange), - info.name.index(&FullRange), vi.span, library); + let (_, cmd, _) = self.register_crate(&None, &info.ident[], + &info.name[], vi.span, library); PMDSource::Registered(cmd) } else { // Not registering the crate; just hold on to the metadata @@ -507,8 +507,8 @@ impl<'a> CrateReader<'a> { impl<'a> PluginMetadata<'a> { /// Read exported macros pub fn exported_macros(&self) -> Vec<ast::MacroDef> { - let imported_from = Some(token::intern(self.info.ident.index(&FullRange)).ident()); - let source_name = format!("<{} macros>", self.info.ident.index(&FullRange)); + let imported_from = Some(token::intern(&self.info.ident[]).ident()); + let source_name = format!("<{} macros>", &self.info.ident[]); let mut macros = vec![]; decoder::each_exported_macro(self.metadata.as_slice(), &*self.sess.cstore.intr, @@ -550,7 +550,7 @@ impl<'a> PluginMetadata<'a> { self.info.ident, config::host_triple(), self.sess.opts.target_triple); - self.sess.span_err(self.vi_span, message.index(&FullRange)); + self.sess.span_err(self.vi_span, &message[]); self.sess.abort_if_errors(); } @@ -563,7 +563,7 @@ impl<'a> PluginMetadata<'a> { let message = format!("plugin crate `{}` only found in rlib format, \ but must be available in dylib format", self.info.ident); - self.sess.span_err(self.vi_span, message.index(&FullRange)); + self.sess.span_err(self.vi_span, &message[]); // No need to abort because the loading code will just ignore this // empty dylib. None diff --git a/src/librustc/metadata/csearch.rs b/src/librustc/metadata/csearch.rs index 72ce61b133a..cfff7c9935b 100644 --- a/src/librustc/metadata/csearch.rs +++ b/src/librustc/metadata/csearch.rs @@ -27,6 +27,7 @@ use std::rc::Rc; use syntax::ast; use syntax::ast_map; use syntax::attr; +use syntax::attr::AttrMetaMethods; use syntax::diagnostic::expect; use syntax::parse::token; @@ -95,7 +96,7 @@ pub fn get_item_path(tcx: &ty::ctxt, def: ast::DefId) -> Vec<ast_map::PathElem> // FIXME #1920: This path is not always correct if the crate is not linked // into the root namespace. - let mut r = vec![ast_map::PathMod(token::intern(cdata.name.index(&FullRange)))]; + let mut r = vec![ast_map::PathMod(token::intern(&cdata.name[]))]; r.push_all(path.as_slice()); r } @@ -375,6 +376,18 @@ pub fn get_stability(cstore: &cstore::CStore, decoder::get_stability(&*cdata, def.node) } +pub fn is_staged_api(cstore: &cstore::CStore, def: ast::DefId) -> bool { + let cdata = cstore.get_crate_data(def.krate); + let attrs = decoder::get_crate_attributes(cdata.data()); + for attr in attrs.iter() { + if attr.name().get() == "staged_api" { + match attr.node.value.node { ast::MetaWord(_) => return true, _ => (/*pass*/) } + } + } + + return false; +} + pub fn get_repr_attrs(cstore: &cstore::CStore, def: ast::DefId) -> Vec<attr::ReprAttr> { let cdata = cstore.get_crate_data(def.krate); diff --git a/src/librustc/metadata/decoder.rs b/src/librustc/metadata/decoder.rs index 9e71c867efa..5ac8f908bf1 100644 --- a/src/librustc/metadata/decoder.rs +++ b/src/librustc/metadata/decoder.rs @@ -33,8 +33,7 @@ use middle::ty::{self, Ty}; use middle::astencode::vtable_decoder_helpers; use std::collections::HashMap; -use std::hash::Hash; -use std::hash; +use std::hash::{self, Hash, SipHasher}; use std::io::extensions::u64_from_be_bytes; use std::io; use std::num::FromPrimitive; @@ -75,7 +74,7 @@ fn lookup_hash<'a, F>(d: rbml::Doc<'a>, mut eq_fn: F, hash: u64) -> Option<rbml: let mut ret = None; reader::tagged_docs(tagged_doc.doc, belt, |elt| { let pos = u64_from_be_bytes(elt.data, elt.start, 4) as uint; - if eq_fn(elt.data.index(&((elt.start + 4) .. elt.end))) { + if eq_fn(&elt.data[(elt.start + 4) .. elt.end]) { ret = Some(reader::doc_at(d.data, pos).unwrap().doc); false } else { @@ -89,12 +88,12 @@ pub fn maybe_find_item<'a>(item_id: ast::NodeId, items: rbml::Doc<'a>) -> Option<rbml::Doc<'a>> { fn eq_item(bytes: &[u8], item_id: ast::NodeId) -> bool { return u64_from_be_bytes( - bytes.index(&(0u..4u)), 0u, 4u) as ast::NodeId + &bytes[0u..4u], 0u, 4u) as ast::NodeId == item_id; } lookup_hash(items, |a| eq_item(a, item_id), - hash::hash(&(item_id as i64))) + hash::hash::<i64, SipHasher>(&(item_id as i64))) } fn find_item<'a>(item_id: ast::NodeId, items: rbml::Doc<'a>) -> rbml::Doc<'a> { @@ -1191,7 +1190,7 @@ pub fn get_crate_deps(data: &[u8]) -> Vec<CrateDep> { } reader::tagged_docs(depsdoc, tag_crate_dep, |depdoc| { let name = docstr(depdoc, tag_crate_dep_crate_name); - let hash = Svh::new(docstr(depdoc, tag_crate_dep_hash).index(&FullRange)); + let hash = Svh::new(&docstr(depdoc, tag_crate_dep_hash)[]); deps.push(CrateDep { cnum: crate_num, name: name, diff --git a/src/librustc/metadata/encoder.rs b/src/librustc/metadata/encoder.rs index 83038df338b..c8921f1b2fb 100644 --- a/src/librustc/metadata/encoder.rs +++ b/src/librustc/metadata/encoder.rs @@ -29,8 +29,7 @@ use util::nodemap::{FnvHashMap, NodeMap, NodeSet}; use serialize::Encodable; use std::cell::RefCell; -use std::hash::Hash; -use std::hash; +use std::hash::{Hash, Hasher, SipHasher}; use syntax::abi; use syntax::ast::{self, DefId, NodeId}; use syntax::ast_map::{PathElem, PathElems}; @@ -95,7 +94,7 @@ fn encode_impl_type_basename(rbml_w: &mut Encoder, name: ast::Ident) { } pub fn encode_def_id(rbml_w: &mut Encoder, id: DefId) { - rbml_w.wr_tagged_str(tag_def_id, def_to_string(id).index(&FullRange)); + rbml_w.wr_tagged_str(tag_def_id, &def_to_string(id)[]); } #[derive(Clone)] @@ -154,7 +153,7 @@ fn encode_variant_id(rbml_w: &mut Encoder, vid: DefId) { rbml_w.end_tag(); rbml_w.start_tag(tag_mod_child); - rbml_w.wr_str(s.index(&FullRange)); + rbml_w.wr_str(&s[]); rbml_w.end_tag(); } @@ -264,7 +263,7 @@ fn encode_symbol(ecx: &EncodeContext, } None => { ecx.diag.handler().bug( - format!("encode_symbol: id not found {}", id).index(&FullRange)); + &format!("encode_symbol: id not found {}", id)[]); } } rbml_w.end_tag(); @@ -332,8 +331,8 @@ fn encode_enum_variant_info(ecx: &EncodeContext, encode_name(rbml_w, variant.node.name.name); encode_parent_item(rbml_w, local_def(id)); encode_visibility(rbml_w, variant.node.vis); - encode_attributes(rbml_w, variant.node.attrs.index(&FullRange)); - encode_repr_attrs(rbml_w, ecx, variant.node.attrs.index(&FullRange)); + encode_attributes(rbml_w, &variant.node.attrs[]); + encode_repr_attrs(rbml_w, ecx, &variant.node.attrs[]); let stab = stability::lookup(ecx.tcx, ast_util::local_def(variant.node.id)); encode_stability(rbml_w, stab); @@ -344,9 +343,9 @@ fn encode_enum_variant_info(ecx: &EncodeContext, let fields = ty::lookup_struct_fields(ecx.tcx, def_id); let idx = encode_info_for_struct(ecx, rbml_w, - fields.index(&FullRange), + &fields[], index); - encode_struct_fields(rbml_w, fields.index(&FullRange), def_id); + encode_struct_fields(rbml_w, &fields[], def_id); encode_index(rbml_w, idx, write_i64); } } @@ -386,12 +385,12 @@ fn encode_reexported_static_method(rbml_w: &mut Encoder, exp.name, token::get_name(method_name)); rbml_w.start_tag(tag_items_data_item_reexport); rbml_w.start_tag(tag_items_data_item_reexport_def_id); - rbml_w.wr_str(def_to_string(method_def_id).index(&FullRange)); + rbml_w.wr_str(&def_to_string(method_def_id)[]); rbml_w.end_tag(); rbml_w.start_tag(tag_items_data_item_reexport_name); - rbml_w.wr_str(format!("{}::{}", + rbml_w.wr_str(&format!("{}::{}", exp.name, - token::get_name(method_name)).index(&FullRange)); + token::get_name(method_name))[]); rbml_w.end_tag(); rbml_w.end_tag(); } @@ -529,7 +528,7 @@ fn encode_reexports(ecx: &EncodeContext, id); rbml_w.start_tag(tag_items_data_item_reexport); rbml_w.start_tag(tag_items_data_item_reexport_def_id); - rbml_w.wr_str(def_to_string(exp.def_id).index(&FullRange)); + rbml_w.wr_str(&def_to_string(exp.def_id)[]); rbml_w.end_tag(); rbml_w.start_tag(tag_items_data_item_reexport_name); rbml_w.wr_str(exp.name.as_str()); @@ -562,13 +561,13 @@ fn encode_info_for_mod(ecx: &EncodeContext, // Encode info about all the module children. for item in md.items.iter() { rbml_w.start_tag(tag_mod_child); - rbml_w.wr_str(def_to_string(local_def(item.id)).index(&FullRange)); + rbml_w.wr_str(&def_to_string(local_def(item.id))[]); rbml_w.end_tag(); each_auxiliary_node_id(&**item, |auxiliary_node_id| { rbml_w.start_tag(tag_mod_child); - rbml_w.wr_str(def_to_string(local_def( - auxiliary_node_id)).index(&FullRange)); + rbml_w.wr_str(&def_to_string(local_def( + auxiliary_node_id))[]); rbml_w.end_tag(); true }); @@ -580,7 +579,7 @@ fn encode_info_for_mod(ecx: &EncodeContext, did, ecx.tcx.map.node_to_string(did)); rbml_w.start_tag(tag_mod_impl); - rbml_w.wr_str(def_to_string(local_def(did)).index(&FullRange)); + rbml_w.wr_str(&def_to_string(local_def(did))[]); rbml_w.end_tag(); } } @@ -615,7 +614,7 @@ fn encode_visibility(rbml_w: &mut Encoder, visibility: ast::Visibility) { ast::Public => 'y', ast::Inherited => 'i', }; - rbml_w.wr_str(ch.to_string().index(&FullRange)); + rbml_w.wr_str(&ch.to_string()[]); rbml_w.end_tag(); } @@ -627,7 +626,7 @@ fn encode_unboxed_closure_kind(rbml_w: &mut Encoder, ty::FnMutUnboxedClosureKind => 'm', ty::FnOnceUnboxedClosureKind => 'o', }; - rbml_w.wr_str(ch.to_string().index(&FullRange)); + rbml_w.wr_str(&ch.to_string()[]); rbml_w.end_tag(); } @@ -788,7 +787,7 @@ fn encode_generics<'a, 'tcx>(rbml_w: &mut Encoder, rbml_w.end_tag(); rbml_w.wr_tagged_str(tag_region_param_def_def_id, - def_to_string(param.def_id).index(&FullRange)); + &def_to_string(param.def_id)[]); rbml_w.wr_tagged_u64(tag_region_param_def_space, param.space.to_uint() as u64); @@ -864,9 +863,9 @@ fn encode_info_for_method<'a, 'tcx>(ecx: &EncodeContext<'a, 'tcx>, encode_path(rbml_w, impl_path.chain(Some(elem).into_iter())); match ast_item_opt { Some(&ast::MethodImplItem(ref ast_method)) => { - encode_attributes(rbml_w, ast_method.attrs.index(&FullRange)); + encode_attributes(rbml_w, &ast_method.attrs[]); let any_types = !pty.generics.types.is_empty(); - if any_types || is_default_impl || should_inline(ast_method.attrs.index(&FullRange)) { + if any_types || is_default_impl || should_inline(&ast_method.attrs[]) { encode_inlined_item(ecx, rbml_w, IIImplItemRef(local_def(parent_id), ast_item_opt.unwrap())); } @@ -912,7 +911,7 @@ fn encode_info_for_associated_type(ecx: &EncodeContext, match typedef_opt { None => {} Some(typedef) => { - encode_attributes(rbml_w, typedef.attrs.index(&FullRange)); + encode_attributes(rbml_w, &typedef.attrs[]); encode_type(ecx, rbml_w, ty::node_id_to_type(ecx.tcx, typedef.id)); } @@ -1046,7 +1045,7 @@ fn encode_info_for_item(ecx: &EncodeContext, encode_path(rbml_w, path); encode_visibility(rbml_w, vis); encode_stability(rbml_w, stab); - encode_attributes(rbml_w, item.attrs.index(&FullRange)); + encode_attributes(rbml_w, &item.attrs[]); rbml_w.end_tag(); } ast::ItemConst(_, _) => { @@ -1072,8 +1071,8 @@ fn encode_info_for_item(ecx: &EncodeContext, encode_bounds_and_type(rbml_w, ecx, &lookup_item_type(tcx, def_id)); encode_name(rbml_w, item.ident.name); encode_path(rbml_w, path); - encode_attributes(rbml_w, item.attrs.index(&FullRange)); - if tps_len > 0u || should_inline(item.attrs.index(&FullRange)) { + encode_attributes(rbml_w, &item.attrs[]); + if tps_len > 0u || should_inline(&item.attrs[]) { encode_inlined_item(ecx, rbml_w, IIItemRef(item)); } if tps_len == 0 { @@ -1089,7 +1088,7 @@ fn encode_info_for_item(ecx: &EncodeContext, encode_info_for_mod(ecx, rbml_w, m, - item.attrs.index(&FullRange), + &item.attrs[], item.id, path, item.ident, @@ -1106,7 +1105,7 @@ fn encode_info_for_item(ecx: &EncodeContext, // Encode all the items in this module. for foreign_item in fm.items.iter() { rbml_w.start_tag(tag_mod_child); - rbml_w.wr_str(def_to_string(local_def(foreign_item.id)).index(&FullRange)); + rbml_w.wr_str(&def_to_string(local_def(foreign_item.id))[]); rbml_w.end_tag(); } encode_visibility(rbml_w, vis); @@ -1134,8 +1133,8 @@ fn encode_info_for_item(ecx: &EncodeContext, encode_item_variances(rbml_w, ecx, item.id); encode_bounds_and_type(rbml_w, ecx, &lookup_item_type(tcx, def_id)); encode_name(rbml_w, item.ident.name); - encode_attributes(rbml_w, item.attrs.index(&FullRange)); - encode_repr_attrs(rbml_w, ecx, item.attrs.index(&FullRange)); + encode_attributes(rbml_w, &item.attrs[]); + encode_repr_attrs(rbml_w, ecx, &item.attrs[]); for v in (*enum_definition).variants.iter() { encode_variant_id(rbml_w, local_def(v.node.id)); } @@ -1152,7 +1151,7 @@ fn encode_info_for_item(ecx: &EncodeContext, encode_enum_variant_info(ecx, rbml_w, item.id, - (*enum_definition).variants.index(&FullRange), + &(*enum_definition).variants[], index); } ast::ItemStruct(ref struct_def, _) => { @@ -1164,7 +1163,7 @@ fn encode_info_for_item(ecx: &EncodeContext, class itself */ let idx = encode_info_for_struct(ecx, rbml_w, - fields.index(&FullRange), + &fields[], index); /* Index the class*/ @@ -1178,16 +1177,16 @@ fn encode_info_for_item(ecx: &EncodeContext, encode_item_variances(rbml_w, ecx, item.id); encode_name(rbml_w, item.ident.name); - encode_attributes(rbml_w, item.attrs.index(&FullRange)); + encode_attributes(rbml_w, &item.attrs[]); encode_path(rbml_w, path.clone()); encode_stability(rbml_w, stab); encode_visibility(rbml_w, vis); - encode_repr_attrs(rbml_w, ecx, item.attrs.index(&FullRange)); + encode_repr_attrs(rbml_w, ecx, &item.attrs[]); /* Encode def_ids for each field and method for methods, write all the stuff get_trait_method needs to know*/ - encode_struct_fields(rbml_w, fields.index(&FullRange), def_id); + encode_struct_fields(rbml_w, &fields[], def_id); encode_inlined_item(ecx, rbml_w, IIItemRef(item)); @@ -1219,7 +1218,7 @@ fn encode_info_for_item(ecx: &EncodeContext, encode_family(rbml_w, 'i'); encode_bounds_and_type(rbml_w, ecx, &lookup_item_type(tcx, def_id)); encode_name(rbml_w, item.ident.name); - encode_attributes(rbml_w, item.attrs.index(&FullRange)); + encode_attributes(rbml_w, &item.attrs[]); encode_unsafety(rbml_w, unsafety); encode_polarity(rbml_w, polarity); match ty.node { @@ -1323,7 +1322,7 @@ fn encode_info_for_item(ecx: &EncodeContext, encode_generics(rbml_w, ecx, &trait_def.generics, tag_item_generics); encode_trait_ref(rbml_w, ecx, &*trait_def.trait_ref, tag_item_trait_ref); encode_name(rbml_w, item.ident.name); - encode_attributes(rbml_w, item.attrs.index(&FullRange)); + encode_attributes(rbml_w, &item.attrs[]); encode_visibility(rbml_w, vis); encode_stability(rbml_w, stab); for &method_def_id in ty::trait_item_def_ids(tcx, def_id).iter() { @@ -1341,7 +1340,7 @@ fn encode_info_for_item(ecx: &EncodeContext, rbml_w.end_tag(); rbml_w.start_tag(tag_mod_child); - rbml_w.wr_str(def_to_string(method_def_id.def_id()).index(&FullRange)); + rbml_w.wr_str(&def_to_string(method_def_id.def_id())[]); rbml_w.end_tag(); } encode_path(rbml_w, path.clone()); @@ -1433,14 +1432,14 @@ fn encode_info_for_item(ecx: &EncodeContext, }; match trait_item { &ast::RequiredMethod(ref m) => { - encode_attributes(rbml_w, m.attrs.index(&FullRange)); + encode_attributes(rbml_w, &m.attrs[]); encode_trait_item(rbml_w); encode_item_sort(rbml_w, 'r'); encode_method_argument_names(rbml_w, &*m.decl); } &ast::ProvidedMethod(ref m) => { - encode_attributes(rbml_w, m.attrs.index(&FullRange)); + encode_attributes(rbml_w, &m.attrs[]); encode_trait_item(rbml_w); encode_item_sort(rbml_w, 'p'); encode_inlined_item(ecx, rbml_w, IITraitItemRef(def_id, trait_item)); @@ -1449,7 +1448,7 @@ fn encode_info_for_item(ecx: &EncodeContext, &ast::TypeTraitItem(ref associated_type) => { encode_attributes(rbml_w, - associated_type.attrs.index(&FullRange)); + &associated_type.attrs[]); encode_item_sort(rbml_w, 't'); } } @@ -1598,11 +1597,13 @@ fn encode_info_for_items(ecx: &EncodeContext, fn encode_index<T, F>(rbml_w: &mut Encoder, index: Vec<entry<T>>, mut write_fn: F) where F: FnMut(&mut SeekableMemWriter, &T), - T: Hash, + T: Hash<SipHasher>, { let mut buckets: Vec<Vec<entry<T>>> = range(0, 256u16).map(|_| Vec::new()).collect(); for elt in index.into_iter() { - let h = hash::hash(&elt.val) as uint; + let mut s = SipHasher::new(); + elt.val.hash(&mut s); + let h = s.finish() as uint; (&mut buckets[h % 256]).push(elt); } @@ -1826,10 +1827,10 @@ fn encode_macro_defs(rbml_w: &mut Encoder, rbml_w.start_tag(tag_macro_def); encode_name(rbml_w, def.ident.name); - encode_attributes(rbml_w, def.attrs.index(&FullRange)); + encode_attributes(rbml_w, &def.attrs[]); rbml_w.start_tag(tag_macro_def_body); - rbml_w.wr_str(pprust::tts_to_string(def.body.index(&FullRange)).index(&FullRange)); + rbml_w.wr_str(&pprust::tts_to_string(&def.body[])[]); rbml_w.end_tag(); rbml_w.end_tag(); @@ -1869,7 +1870,7 @@ fn encode_struct_field_attrs(rbml_w: &mut Encoder, krate: &ast::Crate) { fn visit_struct_field(&mut self, field: &ast::StructField) { self.rbml_w.start_tag(tag_struct_field); self.rbml_w.wr_tagged_u32(tag_struct_field_id, field.node.id); - encode_attributes(self.rbml_w, field.node.attrs.index(&FullRange)); + encode_attributes(self.rbml_w, &field.node.attrs[]); self.rbml_w.end_tag(); } } @@ -1941,13 +1942,13 @@ fn encode_misc_info(ecx: &EncodeContext, rbml_w.start_tag(tag_misc_info_crate_items); for item in krate.module.items.iter() { rbml_w.start_tag(tag_mod_child); - rbml_w.wr_str(def_to_string(local_def(item.id)).index(&FullRange)); + rbml_w.wr_str(&def_to_string(local_def(item.id))[]); rbml_w.end_tag(); each_auxiliary_node_id(&**item, |auxiliary_node_id| { rbml_w.start_tag(tag_mod_child); - rbml_w.wr_str(def_to_string(local_def( - auxiliary_node_id)).index(&FullRange)); + rbml_w.wr_str(&def_to_string(local_def( + auxiliary_node_id))[]); rbml_w.end_tag(); true }); @@ -2116,17 +2117,17 @@ fn encode_metadata_inner(wr: &mut SeekableMemWriter, let mut rbml_w = writer::Encoder::new(wr); - encode_crate_name(&mut rbml_w, ecx.link_meta.crate_name.index(&FullRange)); + encode_crate_name(&mut rbml_w, &ecx.link_meta.crate_name[]); encode_crate_triple(&mut rbml_w, - tcx.sess + &tcx.sess .opts .target_triple - .index(&FullRange)); + []); encode_hash(&mut rbml_w, &ecx.link_meta.crate_hash); encode_dylib_dependency_formats(&mut rbml_w, &ecx); let mut i = rbml_w.writer.tell().unwrap(); - encode_attributes(&mut rbml_w, krate.attrs.index(&FullRange)); + encode_attributes(&mut rbml_w, &krate.attrs[]); stats.attr_bytes = rbml_w.writer.tell().unwrap() - i; i = rbml_w.writer.tell().unwrap(); diff --git a/src/librustc/metadata/filesearch.rs b/src/librustc/metadata/filesearch.rs index 29625d0a6af..e8160487e16 100644 --- a/src/librustc/metadata/filesearch.rs +++ b/src/librustc/metadata/filesearch.rs @@ -272,12 +272,12 @@ fn find_libdir(sysroot: &Path) -> String { } } - #[cfg(target_word_size = "64")] + #[cfg(any(all(stage0, target_word_size = "64"), all(not(stage0), target_pointer_width = "64")))] fn primary_libdir_name() -> String { "lib64".to_string() } - #[cfg(target_word_size = "32")] + #[cfg(any(all(stage0, target_word_size = "32"), all(not(stage0), target_pointer_width = "32")))] fn primary_libdir_name() -> String { "lib32".to_string() } diff --git a/src/librustc/metadata/loader.rs b/src/librustc/metadata/loader.rs index 0fa9472287c..3a925aba0b7 100644 --- a/src/librustc/metadata/loader.rs +++ b/src/librustc/metadata/loader.rs @@ -315,14 +315,14 @@ impl<'a> Context<'a> { &Some(ref r) => format!("{} which `{}` depends on", message, r.ident) }; - self.sess.span_err(self.span, message.index(&FullRange)); + self.sess.span_err(self.span, &message[]); if self.rejected_via_triple.len() > 0 { let mismatches = self.rejected_via_triple.iter(); for (i, &CrateMismatch{ ref path, ref got }) in mismatches.enumerate() { self.sess.fileline_note(self.span, - format!("crate `{}`, path #{}, triple {}: {}", - self.ident, i+1, got, path.display()).index(&FullRange)); + &format!("crate `{}`, path #{}, triple {}: {}", + self.ident, i+1, got, path.display())[]); } } if self.rejected_via_hash.len() > 0 { @@ -331,16 +331,16 @@ impl<'a> Context<'a> { let mismatches = self.rejected_via_hash.iter(); for (i, &CrateMismatch{ ref path, .. }) in mismatches.enumerate() { self.sess.fileline_note(self.span, - format!("crate `{}` path {}{}: {}", - self.ident, "#", i+1, path.display()).index(&FullRange)); + &format!("crate `{}` path {}{}: {}", + self.ident, "#", i+1, path.display())[]); } match self.root { &None => {} &Some(ref r) => { for (i, path) in r.paths().iter().enumerate() { self.sess.fileline_note(self.span, - format!("crate `{}` path #{}: {}", - r.ident, i+1, path.display()).index(&FullRange)); + &format!("crate `{}` path #{}: {}", + r.ident, i+1, path.display())[]); } } } @@ -386,7 +386,7 @@ impl<'a> Context<'a> { None => return FileDoesntMatch, Some(file) => file, }; - let (hash, rlib) = if file.starts_with(rlib_prefix.index(&FullRange)) && + let (hash, rlib) = if file.starts_with(&rlib_prefix[]) && file.ends_with(".rlib") { (file.slice(rlib_prefix.len(), file.len() - ".rlib".len()), true) @@ -445,27 +445,27 @@ impl<'a> Context<'a> { 1 => Some(libraries.into_iter().next().unwrap()), _ => { self.sess.span_err(self.span, - format!("multiple matching crates for `{}`", - self.crate_name).index(&FullRange)); + &format!("multiple matching crates for `{}`", + self.crate_name)[]); self.sess.note("candidates:"); for lib in libraries.iter() { match lib.dylib { Some(ref p) => { - self.sess.note(format!("path: {}", - p.display()).index(&FullRange)); + self.sess.note(&format!("path: {}", + p.display())[]); } None => {} } match lib.rlib { Some(ref p) => { - self.sess.note(format!("path: {}", - p.display()).index(&FullRange)); + self.sess.note(&format!("path: {}", + p.display())[]); } None => {} } let data = lib.metadata.as_slice(); let name = decoder::get_crate_name(data); - note_crate_name(self.sess.diagnostic(), name.index(&FullRange)); + note_crate_name(self.sess.diagnostic(), &name[]); } None } @@ -516,22 +516,22 @@ impl<'a> Context<'a> { }; if ret.is_some() { self.sess.span_err(self.span, - format!("multiple {} candidates for `{}` \ + &format!("multiple {} candidates for `{}` \ found", flavor, - self.crate_name).index(&FullRange)); + self.crate_name)[]); self.sess.span_note(self.span, - format!(r"candidate #1: {}", + &format!(r"candidate #1: {}", ret.as_ref().unwrap() - .display()).index(&FullRange)); + .display())[]); error = 1; ret = None; } if error > 0 { error += 1; self.sess.span_note(self.span, - format!(r"candidate #{}: {}", error, - lib.display()).index(&FullRange)); + &format!(r"candidate #{}: {}", error, + lib.display())[]); continue } *slot = Some(metadata); @@ -606,17 +606,17 @@ impl<'a> Context<'a> { let mut rlibs = HashSet::new(); let mut dylibs = HashSet::new(); { - let mut locs = locs.iter().map(|l| Path::new(l.index(&FullRange))).filter(|loc| { + let mut locs = locs.iter().map(|l| Path::new(&l[])).filter(|loc| { if !loc.exists() { - sess.err(format!("extern location for {} does not exist: {}", - self.crate_name, loc.display()).index(&FullRange)); + sess.err(&format!("extern location for {} does not exist: {}", + self.crate_name, loc.display())[]); return false; } let file = match loc.filename_str() { Some(file) => file, None => { - sess.err(format!("extern location for {} is not a file: {}", - self.crate_name, loc.display()).index(&FullRange)); + sess.err(&format!("extern location for {} is not a file: {}", + self.crate_name, loc.display())[]); return false; } }; @@ -624,13 +624,13 @@ impl<'a> Context<'a> { return true } else { let (ref prefix, ref suffix) = dylibname; - if file.starts_with(prefix.index(&FullRange)) && - file.ends_with(suffix.index(&FullRange)) { + if file.starts_with(&prefix[]) && + file.ends_with(&suffix[]) { return true } } - sess.err(format!("extern location for {} is of an unknown type: {}", - self.crate_name, loc.display()).index(&FullRange)); + sess.err(&format!("extern location for {} is of an unknown type: {}", + self.crate_name, loc.display())[]); false }); @@ -663,7 +663,7 @@ impl<'a> Context<'a> { } pub fn note_crate_name(diag: &SpanHandler, name: &str) { - diag.handler().note(format!("crate name: {}", name).index(&FullRange)); + diag.handler().note(&format!("crate name: {}", name)[]); } impl ArchiveMetadata { diff --git a/src/librustc/metadata/tydecode.rs b/src/librustc/metadata/tydecode.rs index a4304bf1e2d..5aacaa04e46 100644 --- a/src/librustc/metadata/tydecode.rs +++ b/src/librustc/metadata/tydecode.rs @@ -98,7 +98,7 @@ fn scan<R, F, G>(st: &mut PState, mut is_last: F, op: G) -> R where } let end_pos = st.pos; st.pos += 1; - return op(st.data.index(&(start_pos..end_pos))); + return op(&st.data[start_pos..end_pos]); } pub fn parse_ident(st: &mut PState, last: char) -> ast::Ident { @@ -250,8 +250,8 @@ fn parse_trait_store_<F>(st: &mut PState, conv: &mut F) -> ty::TraitStore where '~' => ty::UniqTraitStore, '&' => ty::RegionTraitStore(parse_region_(st, conv), parse_mutability(st)), c => { - st.tcx.sess.bug(format!("parse_trait_store(): bad input '{}'", - c).index(&FullRange)) + st.tcx.sess.bug(&format!("parse_trait_store(): bad input '{}'", + c)[]) } } } @@ -318,7 +318,7 @@ fn parse_bound_region_<F>(st: &mut PState, conv: &mut F) -> ty::BoundRegion wher } '[' => { let def = parse_def_(st, RegionParameter, conv); - let ident = token::str_to_ident(parse_str(st, ']').index(&FullRange)); + let ident = token::str_to_ident(&parse_str(st, ']')[]); ty::BrNamed(def, ident.name) } 'f' => { @@ -357,7 +357,7 @@ fn parse_region_<F>(st: &mut PState, conv: &mut F) -> ty::Region where assert_eq!(next(st), '|'); let index = parse_u32(st); assert_eq!(next(st), '|'); - let nm = token::str_to_ident(parse_str(st, ']').index(&FullRange)); + let nm = token::str_to_ident(&parse_str(st, ']')[]); ty::ReEarlyBound(node_id, space, index, nm.name) } 'f' => { @@ -481,7 +481,7 @@ fn parse_ty_<'a, 'tcx, F>(st: &mut PState<'a, 'tcx>, conv: &mut F) -> Ty<'tcx> w assert_eq!(next(st), '|'); let space = parse_param_space(st); assert_eq!(next(st), '|'); - let name = token::intern(parse_str(st, ']').index(&FullRange)); + let name = token::intern(&parse_str(st, ']')[]); return ty::mk_param(tcx, space, index, name); } '~' => return ty::mk_uniq(tcx, parse_ty_(st, conv)), @@ -637,7 +637,7 @@ fn parse_abi_set(st: &mut PState) -> abi::Abi { assert_eq!(next(st), '['); scan(st, |c| c == ']', |bytes| { let abi_str = str::from_utf8(bytes).unwrap(); - abi::lookup(abi_str.index(&FullRange)).expect(abi_str) + abi::lookup(&abi_str[]).expect(abi_str) }) } @@ -733,8 +733,8 @@ pub fn parse_def_id(buf: &[u8]) -> ast::DefId { panic!(); } - let crate_part = buf.index(&(0u..colon_idx)); - let def_part = buf.index(&((colon_idx + 1u)..len)); + let crate_part = &buf[0u..colon_idx]; + let def_part = &buf[(colon_idx + 1u)..len]; let crate_num = match str::from_utf8(crate_part).ok().and_then(|s| s.parse::<uint>()) { Some(cn) => cn as ast::CrateNum, diff --git a/src/librustc/middle/astconv_util.rs b/src/librustc/middle/astconv_util.rs index 955f522b804..8cd3795580e 100644 --- a/src/librustc/middle/astconv_util.rs +++ b/src/librustc/middle/astconv_util.rs @@ -47,8 +47,8 @@ pub fn ast_ty_to_prim_ty<'tcx>(tcx: &ty::ctxt<'tcx>, ast_ty: &ast::Ty) let a_def = match tcx.def_map.borrow().get(&id) { None => { tcx.sess.span_bug(ast_ty.span, - format!("unbound path {}", - path.repr(tcx)).index(&FullRange)) + &format!("unbound path {}", + path.repr(tcx))[]) } Some(&d) => d }; diff --git a/src/librustc/middle/astencode.rs b/src/librustc/middle/astencode.rs index 32ce131c57a..550c0f34caf 100644 --- a/src/librustc/middle/astencode.rs +++ b/src/librustc/middle/astencode.rs @@ -132,7 +132,7 @@ pub fn decode_inlined_item<'tcx>(cdata: &cstore::crate_metadata, // Do an Option dance to use the path after it is moved below. let s = ast_map::path_to_string(ast_map::Values(path.iter())); path_as_str = Some(s); - path_as_str.as_ref().map(|x| x.index(&FullRange)) + path_as_str.as_ref().map(|x| &x[]) }); let mut ast_dsr = reader::Decoder::new(ast_doc); let from_id_range = Decodable::decode(&mut ast_dsr).unwrap(); @@ -1876,8 +1876,8 @@ fn decode_side_tables(dcx: &DecodeContext, match c::astencode_tag::from_uint(tag) { None => { dcx.tcx.sess.bug( - format!("unknown tag found in side tables: {:x}", - tag).index(&FullRange)); + &format!("unknown tag found in side tables: {:x}", + tag)[]); } Some(value) => { let val_doc = entry_doc.get(c::tag_table_val as uint); @@ -1961,8 +1961,8 @@ fn decode_side_tables(dcx: &DecodeContext, } _ => { dcx.tcx.sess.bug( - format!("unknown tag found in side tables: {:x}", - tag).index(&FullRange)); + &format!("unknown tag found in side tables: {:x}", + tag)[]); } } } diff --git a/src/librustc/middle/cfg/construct.rs b/src/librustc/middle/cfg/construct.rs index f7fc90bcef6..b601ea59486 100644 --- a/src/librustc/middle/cfg/construct.rs +++ b/src/librustc/middle/cfg/construct.rs @@ -362,7 +362,7 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> { let mut cond_exit = discr_exit; for arm in arms.iter() { cond_exit = self.add_dummy_node(&[cond_exit]); // 2 - let pats_exit = self.pats_any(arm.pats.index(&FullRange), + let pats_exit = self.pats_any(&arm.pats[], cond_exit); // 3 let guard_exit = self.opt_expr(&arm.guard, pats_exit); // 4 @@ -615,15 +615,15 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> { } self.tcx.sess.span_bug( expr.span, - format!("no loop scope for id {}", - loop_id).index(&FullRange)); + &format!("no loop scope for id {}", + loop_id)[]); } r => { self.tcx.sess.span_bug( expr.span, - format!("bad entry `{:?}` in def_map for label", - r).index(&FullRange)); + &format!("bad entry `{:?}` in def_map for label", + r)[]); } } } diff --git a/src/librustc/middle/cfg/graphviz.rs b/src/librustc/middle/cfg/graphviz.rs index 8b9a0d89b38..f4db2b6e61d 100644 --- a/src/librustc/middle/cfg/graphviz.rs +++ b/src/librustc/middle/cfg/graphviz.rs @@ -52,7 +52,7 @@ fn replace_newline_with_backslash_l(s: String) -> String { } impl<'a, 'ast> dot::Labeller<'a, Node<'a>, Edge<'a>> for LabelledCFG<'a, 'ast> { - fn graph_id(&'a self) -> dot::Id<'a> { dot::Id::new(self.name.index(&FullRange)).unwrap() } + fn graph_id(&'a self) -> dot::Id<'a> { dot::Id::new(&self.name[]).unwrap() } fn node_id(&'a self, &(i,_): &Node<'a>) -> dot::Id<'a> { dot::Id::new(format!("N{}", i.node_id())).unwrap() @@ -85,9 +85,9 @@ impl<'a, 'ast> dot::Labeller<'a, Node<'a>, Edge<'a>> for LabelledCFG<'a, 'ast> { let s = self.ast_map.node_to_string(node_id); // left-aligns the lines let s = replace_newline_with_backslash_l(s); - label.push_str(format!("exiting scope_{} {}", + label.push_str(&format!("exiting scope_{} {}", i, - s.index(&FullRange)).index(&FullRange)); + &s[])[]); } dot::LabelText::EscStr(label.into_cow()) } diff --git a/src/librustc/middle/check_loop.rs b/src/librustc/middle/check_loop.rs index 5024e5c4f77..1f779acac25 100644 --- a/src/librustc/middle/check_loop.rs +++ b/src/librustc/middle/check_loop.rs @@ -74,11 +74,11 @@ impl<'a> CheckLoopVisitor<'a> { Loop => {} Closure => { self.sess.span_err(span, - format!("`{}` inside of a closure", name).index(&FullRange)); + &format!("`{}` inside of a closure", name)[]); } Normal => { self.sess.span_err(span, - format!("`{}` outside of loop", name).index(&FullRange)); + &format!("`{}` outside of loop", name)[]); } } } diff --git a/src/librustc/middle/check_match.rs b/src/librustc/middle/check_match.rs index f1edfb37273..43f39a67f5c 100644 --- a/src/librustc/middle/check_match.rs +++ b/src/librustc/middle/check_match.rs @@ -47,7 +47,7 @@ struct Matrix<'a>(Vec<Vec<&'a Pat>>); /// Pretty-printer for matrices of patterns, example: /// ++++++++++++++++++++++++++ -/// + _ + .index(&FullRange) + +/// + _ + [] + /// ++++++++++++++++++++++++++ /// + true + [First] + /// ++++++++++++++++++++++++++ @@ -161,7 +161,7 @@ fn check_expr(cx: &mut MatchCheckCtxt, ex: &ast::Expr) { // First, check legality of move bindings. check_legality_of_move_bindings(cx, arm.guard.is_some(), - arm.pats.index(&FullRange)); + &arm.pats[]); // Second, if there is a guard on each arm, make sure it isn't // assigning or borrowing anything mutably. @@ -198,7 +198,7 @@ fn check_expr(cx: &mut MatchCheckCtxt, ex: &ast::Expr) { } // Fourth, check for unreachable arms. - check_arms(cx, inlined_arms.index(&FullRange), source); + check_arms(cx, &inlined_arms[], source); // Finally, check if the whole match expression is exhaustive. // Check for empty enum, because is_useful only works on inhabited types. @@ -228,9 +228,9 @@ fn check_expr(cx: &mut MatchCheckCtxt, ex: &ast::Expr) { is_refutable(cx, &*static_inliner.fold_pat((*pat).clone()), |uncovered_pat| { cx.tcx.sess.span_err( pat.span, - format!("refutable pattern in `for` loop binding: \ + &format!("refutable pattern in `for` loop binding: \ `{}` not covered", - pat_to_string(uncovered_pat)).index(&FullRange)); + pat_to_string(uncovered_pat))[]); }); // Check legality of move bindings. @@ -303,7 +303,7 @@ fn check_arms(cx: &MatchCheckCtxt, for pat in pats.iter() { let v = vec![&**pat]; - match is_useful(cx, &seen, v.index(&FullRange), LeaveOutWitness) { + match is_useful(cx, &seen, &v[], LeaveOutWitness) { NotUseful => { match source { ast::MatchSource::IfLetDesugar { .. } => { @@ -355,7 +355,7 @@ fn raw_pat<'a>(p: &'a Pat) -> &'a Pat { fn check_exhaustive(cx: &MatchCheckCtxt, sp: Span, matrix: &Matrix) { match is_useful(cx, matrix, &[DUMMY_WILD_PAT], ConstructWitness) { UsefulWithWitness(pats) => { - let witness = match pats.index(&FullRange) { + let witness = match &pats[] { [ref witness] => &**witness, [] => DUMMY_WILD_PAT, _ => unreachable!() @@ -609,7 +609,7 @@ fn is_useful(cx: &MatchCheckCtxt, UsefulWithWitness(pats) => UsefulWithWitness({ let arity = constructor_arity(cx, &c, left_ty); let mut result = { - let pat_slice = pats.index(&FullRange); + let pat_slice = &pats[]; let subpats: Vec<_> = range(0, arity).map(|i| { pat_slice.get(i).map_or(DUMMY_WILD_PAT, |p| &**p) }).collect(); @@ -656,10 +656,10 @@ fn is_useful_specialized(cx: &MatchCheckCtxt, &Matrix(ref m): &Matrix, witness: WitnessPreference) -> Usefulness { let arity = constructor_arity(cx, &ctor, lty); let matrix = Matrix(m.iter().filter_map(|r| { - specialize(cx, r.index(&FullRange), &ctor, 0u, arity) + specialize(cx, &r[], &ctor, 0u, arity) }).collect()); match specialize(cx, v, &ctor, 0u, arity) { - Some(v) => is_useful(cx, &matrix, v.index(&FullRange), witness), + Some(v) => is_useful(cx, &matrix, &v[], witness), None => NotUseful } } @@ -729,7 +729,7 @@ fn pat_constructors(cx: &MatchCheckCtxt, p: &Pat, /// This computes the arity of a constructor. The arity of a constructor /// is how many subpattern patterns of that constructor should be expanded to. /// -/// For instance, a tuple pattern (_, 42u, Some(.index(&FullRange))) has the arity of 3. +/// For instance, a tuple pattern (_, 42u, Some([])) has the arity of 3. /// A struct pattern's arity is the number of fields it contains, etc. pub fn constructor_arity(cx: &MatchCheckCtxt, ctor: &Constructor, ty: Ty) -> uint { match ty.sty { @@ -926,8 +926,8 @@ pub fn specialize<'a>(cx: &MatchCheckCtxt, r: &[&'a Pat], } }; head.map(|mut head| { - head.push_all(r.index(&(0..col))); - head.push_all(r.index(&((col + 1)..))); + head.push_all(&r[0..col]); + head.push_all(&r[(col + 1)..]); head }) } @@ -1041,10 +1041,10 @@ fn check_legality_of_move_bindings(cx: &MatchCheckCtxt, _ => { cx.tcx.sess.span_bug( p.span, - format!("binding pattern {} is not an \ + &format!("binding pattern {} is not an \ identifier: {:?}", p.id, - p.node).index(&FullRange)); + p.node)[]); } } } diff --git a/src/librustc/middle/check_static.rs b/src/librustc/middle/check_static.rs index 994a2b0dc8a..154272d2deb 100644 --- a/src/librustc/middle/check_static.rs +++ b/src/librustc/middle/check_static.rs @@ -111,8 +111,8 @@ impl<'a, 'tcx> CheckStaticVisitor<'a, 'tcx> { return }; - self.tcx.sess.span_err(e.span, format!("mutable statics are not allowed \ - to have {}", suffix).index(&FullRange)); + self.tcx.sess.span_err(e.span, &format!("mutable statics are not allowed \ + to have {}", suffix)[]); } fn check_static_type(&self, e: &ast::Expr) { @@ -169,8 +169,8 @@ impl<'a, 'tcx, 'v> Visitor<'v> for CheckStaticVisitor<'a, 'tcx> { ty::ty_struct(did, _) | ty::ty_enum(did, _) if ty::has_dtor(self.tcx, did) => { self.tcx.sess.span_err(e.span, - format!("{} are not allowed to have \ - destructors", self.msg()).index(&FullRange)) + &format!("{} are not allowed to have \ + destructors", self.msg())[]) } _ => {} } @@ -234,7 +234,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for CheckStaticVisitor<'a, 'tcx> { let msg = "constants cannot refer to other statics, \ insert an intermediate constant \ instead"; - self.tcx.sess.span_err(e.span, msg.index(&FullRange)); + self.tcx.sess.span_err(e.span, &msg[]); } _ => {} } diff --git a/src/librustc/middle/check_static_recursion.rs b/src/librustc/middle/check_static_recursion.rs index 75851f0a853..e2a0738def1 100644 --- a/src/librustc/middle/check_static_recursion.rs +++ b/src/librustc/middle/check_static_recursion.rs @@ -104,8 +104,8 @@ impl<'a, 'ast, 'v> Visitor<'v> for CheckItemRecursionVisitor<'a, 'ast> { ast_map::NodeForeignItem(_) => {}, _ => { self.sess.span_err(e.span, - format!("expected item, found {}", - self.ast_map.node_to_string(def_id.node)).index(&FullRange)); + &format!("expected item, found {}", + self.ast_map.node_to_string(def_id.node))[]); return; }, } diff --git a/src/librustc/middle/const_eval.rs b/src/librustc/middle/const_eval.rs index e726993bd48..04d4b41b21a 100644 --- a/src/librustc/middle/const_eval.rs +++ b/src/librustc/middle/const_eval.rs @@ -48,7 +48,7 @@ use std::rc::Rc; // target uses". This _includes_ integer-constants, plus the following // constructors: // -// fixed-size vectors and strings: .index(&FullRange) and ""/_ +// fixed-size vectors and strings: [] and ""/_ // vector and string slices: &[] and &"" // tuples: (,) // enums: foo(...) @@ -117,7 +117,7 @@ fn lookup_variant_by_id<'a>(tcx: &'a ty::ctxt, None => None, Some(ast_map::NodeItem(it)) => match it.node { ast::ItemEnum(ast::EnumDef { ref variants }, _) => { - variant_expr(variants.index(&FullRange), variant_def.node) + variant_expr(&variants[], variant_def.node) } _ => None }, @@ -138,7 +138,7 @@ fn lookup_variant_by_id<'a>(tcx: &'a ty::ctxt, // NOTE this doesn't do the right thing, it compares inlined // NodeId's to the original variant_def's NodeId, but they // come from different crates, so they will likely never match. - variant_expr(variants.index(&FullRange), variant_def.node).map(|e| e.id) + variant_expr(&variants[], variant_def.node).map(|e| e.id) } _ => None }, @@ -364,7 +364,7 @@ pub fn const_expr_to_pat(tcx: &ty::ctxt, expr: &Expr) -> P<ast::Pat> { pub fn eval_const_expr(tcx: &ty::ctxt, e: &Expr) -> const_val { match eval_const_expr_partial(tcx, e) { Ok(r) => r, - Err(s) => tcx.sess.span_fatal(e.span, s.index(&FullRange)) + Err(s) => tcx.sess.span_fatal(e.span, &s[]) } } diff --git a/src/librustc/middle/dataflow.rs b/src/librustc/middle/dataflow.rs index bdd98a94fc3..4ae0aa43406 100644 --- a/src/librustc/middle/dataflow.rs +++ b/src/librustc/middle/dataflow.rs @@ -312,7 +312,7 @@ impl<'a, 'tcx, O:DataFlowOperator> DataFlowContext<'a, 'tcx, O> { let mut t = on_entry.to_vec(); self.apply_gen_kill(cfgidx, t.as_mut_slice()); temp_bits = t; - temp_bits.index(&FullRange) + &temp_bits[] } }; debug!("{} each_bit_for_node({:?}, cfgidx={:?}) bits={}", @@ -421,7 +421,7 @@ impl<'a, 'tcx, O:DataFlowOperator> DataFlowContext<'a, 'tcx, O> { let bits = self.kills.slice_mut(start, end); debug!("{} add_kills_from_flow_exits flow_exit={:?} bits={} [before]", self.analysis_name, flow_exit, mut_bits_to_string(bits)); - bits.clone_from_slice(orig_kills.index(&FullRange)); + bits.clone_from_slice(&orig_kills[]); debug!("{} add_kills_from_flow_exits flow_exit={:?} bits={} [after]", self.analysis_name, flow_exit, mut_bits_to_string(bits)); } @@ -554,7 +554,7 @@ fn bits_to_string(words: &[uint]) -> String { let mut v = word; for _ in range(0u, uint::BYTES) { result.push(sep); - result.push_str(format!("{:02x}", v & 0xFF).index(&FullRange)); + result.push_str(&format!("{:02x}", v & 0xFF)[]); v >>= 8; sep = '-'; } diff --git a/src/librustc/middle/dependency_format.rs b/src/librustc/middle/dependency_format.rs index 0bc899a8a62..cca0b7d9ad0 100644 --- a/src/librustc/middle/dependency_format.rs +++ b/src/librustc/middle/dependency_format.rs @@ -117,8 +117,8 @@ fn calculate_type(sess: &session::Session, sess.cstore.iter_crate_data(|cnum, data| { let src = sess.cstore.get_used_crate_source(cnum).unwrap(); if src.rlib.is_some() { return } - sess.err(format!("dependency `{}` not found in rlib format", - data.name).index(&FullRange)); + sess.err(&format!("dependency `{}` not found in rlib format", + data.name)[]); }); return Vec::new(); } @@ -191,13 +191,13 @@ fn calculate_type(sess: &session::Session, Some(cstore::RequireDynamic) if src.dylib.is_some() => continue, Some(kind) => { let data = sess.cstore.get_crate_data(cnum + 1); - sess.err(format!("crate `{}` required to be available in {}, \ + sess.err(&format!("crate `{}` required to be available in {}, \ but it was not available in this form", data.name, match kind { cstore::RequireStatic => "rlib", cstore::RequireDynamic => "dylib", - }).index(&FullRange)); + })[]); } } } @@ -220,9 +220,9 @@ fn add_library(sess: &session::Session, // can be refined over time. if link2 != link || link == cstore::RequireStatic { let data = sess.cstore.get_crate_data(cnum); - sess.err(format!("cannot satisfy dependencies so `{}` only \ + sess.err(&format!("cannot satisfy dependencies so `{}` only \ shows up once", - data.name).index(&FullRange)); + data.name)[]); sess.help("having upstream crates all available in one format \ will likely make this go away"); } diff --git a/src/librustc/middle/expr_use_visitor.rs b/src/librustc/middle/expr_use_visitor.rs index 45838436e60..e5eb439d42c 100644 --- a/src/librustc/middle/expr_use_visitor.rs +++ b/src/librustc/middle/expr_use_visitor.rs @@ -857,8 +857,8 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> { let (m, r) = match self_ty.sty { ty::ty_rptr(r, ref m) => (m.mutbl, r), _ => self.tcx().sess.span_bug(expr.span, - format!("bad overloaded deref type {}", - method_ty.repr(self.tcx())).index(&FullRange)) + &format!("bad overloaded deref type {}", + method_ty.repr(self.tcx()))[]) }; let bk = ty::BorrowKind::from_mutbl(m); self.delegate.borrow(expr.id, expr.span, cmt, @@ -1180,7 +1180,7 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> { let msg = format!("Pattern has unexpected def: {:?} and type {}", def, cmt_pat.ty.repr(tcx)); - tcx.sess.span_bug(pat.span, msg.index(&FullRange)) + tcx.sess.span_bug(pat.span, &msg[]) } } } diff --git a/src/librustc/middle/infer/combine.rs b/src/librustc/middle/infer/combine.rs index 22975f54a9f..4a4328fa98b 100644 --- a/src/librustc/middle/infer/combine.rs +++ b/src/librustc/middle/infer/combine.rs @@ -142,7 +142,7 @@ pub trait Combine<'tcx> : Sized { for _ in a_regions.iter() { invariance.push(ty::Invariant); } - invariance.index(&FullRange) + &invariance[] } }; @@ -427,6 +427,16 @@ impl<'tcx> Combineable<'tcx> for ty::TraitRef<'tcx> { } } +impl<'tcx> Combineable<'tcx> for Ty<'tcx> { + fn combine<C:Combine<'tcx>>(combiner: &C, + a: &Ty<'tcx>, + b: &Ty<'tcx>) + -> cres<'tcx, Ty<'tcx>> + { + combiner.tys(*a, *b) + } +} + impl<'tcx> Combineable<'tcx> for ty::ProjectionPredicate<'tcx> { fn combine<C:Combine<'tcx>>(combiner: &C, a: &ty::ProjectionPredicate<'tcx>, @@ -477,10 +487,10 @@ pub fn super_tys<'tcx, C: Combine<'tcx>>(this: &C, (&ty::ty_infer(TyVar(_)), _) | (_, &ty::ty_infer(TyVar(_))) => { tcx.sess.bug( - format!("{}: bot and var types should have been handled ({},{})", + &format!("{}: bot and var types should have been handled ({},{})", this.tag(), a.repr(this.infcx().tcx), - b.repr(this.infcx().tcx)).index(&FullRange)); + b.repr(this.infcx().tcx))[]); } (&ty::ty_err, _) | (_, &ty::ty_err) => { @@ -855,8 +865,8 @@ impl<'cx, 'tcx> ty_fold::TypeFolder<'tcx> for Generalizer<'cx, 'tcx> { ty::ReEarlyBound(..) => { self.tcx().sess.span_bug( self.span, - format!("Encountered early bound region when generalizing: {}", - r.repr(self.tcx())).index(&FullRange)); + &format!("Encountered early bound region when generalizing: {}", + r.repr(self.tcx()))[]); } // Always make a fresh region variable for skolemized regions; diff --git a/src/librustc/middle/infer/error_reporting.rs b/src/librustc/middle/infer/error_reporting.rs index 762617fb49b..bbd12c9671d 100644 --- a/src/librustc/middle/infer/error_reporting.rs +++ b/src/librustc/middle/infer/error_reporting.rs @@ -200,9 +200,9 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { ref trace_origins, ref same_regions) => { if !same_regions.is_empty() { - self.report_processed_errors(var_origins.index(&FullRange), - trace_origins.index(&FullRange), - same_regions.index(&FullRange)); + self.report_processed_errors(&var_origins[], + &trace_origins[], + &same_regions[]); } } } @@ -373,10 +373,10 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { self.tcx.sess.span_err( trace.origin.span(), - format!("{}: {} ({})", + &format!("{}: {} ({})", message_root_str, expected_found_str, - ty::type_err_to_str(self.tcx, terr)).index(&FullRange)); + ty::type_err_to_str(self.tcx, terr))[]); match trace.origin { infer::MatchExpressionArm(_, arm_span) => @@ -445,42 +445,42 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { // Does the required lifetime have a nice name we can print? self.tcx.sess.span_err( origin.span(), - format!("{} may not live long enough", labeled_user_string).index(&FullRange)); + &format!("{} may not live long enough", labeled_user_string)[]); self.tcx.sess.span_help( origin.span(), - format!( + &format!( "consider adding an explicit lifetime bound `{}: {}`...", bound_kind.user_string(self.tcx), - sub.user_string(self.tcx)).index(&FullRange)); + sub.user_string(self.tcx))[]); } ty::ReStatic => { // Does the required lifetime have a nice name we can print? self.tcx.sess.span_err( origin.span(), - format!("{} may not live long enough", labeled_user_string).index(&FullRange)); + &format!("{} may not live long enough", labeled_user_string)[]); self.tcx.sess.span_help( origin.span(), - format!( + &format!( "consider adding an explicit lifetime bound `{}: 'static`...", - bound_kind.user_string(self.tcx)).index(&FullRange)); + bound_kind.user_string(self.tcx))[]); } _ => { // If not, be less specific. self.tcx.sess.span_err( origin.span(), - format!( + &format!( "{} may not live long enough", - labeled_user_string).index(&FullRange)); + labeled_user_string)[]); self.tcx.sess.span_help( origin.span(), - format!( + &format!( "consider adding an explicit lifetime bound for `{}`", - bound_kind.user_string(self.tcx)).index(&FullRange)); + bound_kind.user_string(self.tcx))[]); note_and_explain_region( self.tcx, - format!("{} must be valid for ", labeled_user_string).index(&FullRange), + &format!("{} must be valid for ", labeled_user_string)[], sub, "..."); } @@ -517,12 +517,12 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { infer::ReborrowUpvar(span, ref upvar_id) => { self.tcx.sess.span_err( span, - format!("lifetime of borrowed pointer outlives \ + &format!("lifetime of borrowed pointer outlives \ lifetime of captured variable `{}`...", ty::local_var_name_str(self.tcx, upvar_id.var_id) .get() - .to_string()).index(&FullRange)); + .to_string())[]); note_and_explain_region( self.tcx, "...the borrowed pointer is valid for ", @@ -530,11 +530,11 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { "..."); note_and_explain_region( self.tcx, - format!("...but `{}` is only valid for ", + &format!("...but `{}` is only valid for ", ty::local_var_name_str(self.tcx, upvar_id.var_id) .get() - .to_string()).index(&FullRange), + .to_string())[], sup, ""); } @@ -576,11 +576,11 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { infer::FreeVariable(span, id) => { self.tcx.sess.span_err( span, - format!("captured variable `{}` does not \ + &format!("captured variable `{}` does not \ outlive the enclosing closure", ty::local_var_name_str(self.tcx, id).get() - .to_string()).index(&FullRange)); + .to_string())[]); note_and_explain_region( self.tcx, "captured variable is valid for ", @@ -620,9 +620,9 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { infer::RelateParamBound(span, ty) => { self.tcx.sess.span_err( span, - format!("the type `{}` does not fulfill the \ + &format!("the type `{}` does not fulfill the \ required lifetime", - self.ty_to_string(ty)).index(&FullRange)); + self.ty_to_string(ty))[]); note_and_explain_region(self.tcx, "type must outlive ", sub, @@ -646,9 +646,9 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { infer::RelateDefaultParamBound(span, ty) => { self.tcx.sess.span_err( span, - format!("the type `{}` (provided as the value of \ + &format!("the type `{}` (provided as the value of \ a type parameter) is not valid at this point", - self.ty_to_string(ty)).index(&FullRange)); + self.ty_to_string(ty))[]); note_and_explain_region(self.tcx, "type must outlive ", sub, @@ -712,9 +712,9 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { infer::ExprTypeIsNotInScope(t, span) => { self.tcx.sess.span_err( span, - format!("type of expression contains references \ + &format!("type of expression contains references \ that are not valid during the expression: `{}`", - self.ty_to_string(t)).index(&FullRange)); + self.ty_to_string(t))[]); note_and_explain_region( self.tcx, "type is only valid for ", @@ -734,9 +734,9 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { infer::ReferenceOutlivesReferent(ty, span) => { self.tcx.sess.span_err( span, - format!("in type `{}`, reference has a longer lifetime \ + &format!("in type `{}`, reference has a longer lifetime \ than the data it references", - self.ty_to_string(ty)).index(&FullRange)); + self.ty_to_string(ty))[]); note_and_explain_region( self.tcx, "the pointer is valid for ", @@ -861,7 +861,7 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { let (fn_decl, generics, unsafety, ident, expl_self, span) = node_inner.expect("expect item fn"); let taken = lifetimes_in_scope(self.tcx, scope_id); - let life_giver = LifeGiver::with_taken(taken.index(&FullRange)); + let life_giver = LifeGiver::with_taken(&taken[]); let rebuilder = Rebuilder::new(self.tcx, fn_decl, expl_self, generics, same_regions, &life_giver); let (fn_decl, expl_self, generics) = rebuilder.rebuild(); @@ -937,7 +937,7 @@ impl<'a, 'tcx> Rebuilder<'a, 'tcx> { } expl_self_opt = self.rebuild_expl_self(expl_self_opt, lifetime, &anon_nums, ®ion_names); - inputs = self.rebuild_args_ty(inputs.index(&FullRange), lifetime, + inputs = self.rebuild_args_ty(&inputs[], lifetime, &anon_nums, ®ion_names); output = self.rebuild_output(&output, lifetime, &anon_nums, ®ion_names); ty_params = self.rebuild_ty_params(ty_params, lifetime, @@ -972,7 +972,7 @@ impl<'a, 'tcx> Rebuilder<'a, 'tcx> { names.push(lt_name); } names.sort(); - let name = token::str_to_ident(names[0].index(&FullRange)).name; + let name = token::str_to_ident(&names[0][]).name; return (name_to_dummy_lifetime(name), Kept); } return (self.life_giver.give_lifetime(), Fresh); @@ -1220,9 +1220,9 @@ impl<'a, 'tcx> Rebuilder<'a, 'tcx> { None => { self.tcx .sess - .fatal(format!( + .fatal(&format!( "unbound path {}", - pprust::path_to_string(path)).index(&FullRange)) + pprust::path_to_string(path))[]) } Some(&d) => d }; @@ -1420,7 +1420,7 @@ impl<'a, 'tcx> ErrorReportingHelpers<'tcx> for InferCtxt<'a, 'tcx> { opt_explicit_self, generics); let msg = format!("consider using an explicit lifetime \ parameter as shown: {}", suggested_fn); - self.tcx.sess.span_help(span, msg.index(&FullRange)); + self.tcx.sess.span_help(span, &msg[]); } fn report_inference_failure(&self, @@ -1461,9 +1461,9 @@ impl<'a, 'tcx> ErrorReportingHelpers<'tcx> for InferCtxt<'a, 'tcx> { self.tcx.sess.span_err( var_origin.span(), - format!("cannot infer an appropriate lifetime{} \ + &format!("cannot infer an appropriate lifetime{} \ due to conflicting requirements", - var_description).index(&FullRange)); + var_description)[]); } fn note_region_origin(&self, origin: &SubregionOrigin<'tcx>) { @@ -1510,8 +1510,8 @@ impl<'a, 'tcx> ErrorReportingHelpers<'tcx> for InferCtxt<'a, 'tcx> { Some(values_str) => { self.tcx.sess.span_note( trace.origin.span(), - format!("...so that {} ({})", - desc, values_str).index(&FullRange)); + &format!("...so that {} ({})", + desc, values_str)[]); } None => { // Really should avoid printing this error at @@ -1520,7 +1520,7 @@ impl<'a, 'tcx> ErrorReportingHelpers<'tcx> for InferCtxt<'a, 'tcx> { // doing right now. - nmatsakis self.tcx.sess.span_note( trace.origin.span(), - format!("...so that {}", desc).index(&FullRange)); + &format!("...so that {}", desc)[]); } } } @@ -1533,11 +1533,11 @@ impl<'a, 'tcx> ErrorReportingHelpers<'tcx> for InferCtxt<'a, 'tcx> { infer::ReborrowUpvar(span, ref upvar_id) => { self.tcx.sess.span_note( span, - format!( + &format!( "...so that closure can access `{}`", ty::local_var_name_str(self.tcx, upvar_id.var_id) .get() - .to_string()).index(&FullRange)) + .to_string())[]) } infer::InfStackClosure(span) => { self.tcx.sess.span_note( @@ -1558,11 +1558,11 @@ impl<'a, 'tcx> ErrorReportingHelpers<'tcx> for InferCtxt<'a, 'tcx> { infer::FreeVariable(span, id) => { self.tcx.sess.span_note( span, - format!("...so that captured variable `{}` \ + &format!("...so that captured variable `{}` \ does not outlive the enclosing closure", ty::local_var_name_str( self.tcx, - id).get().to_string()).index(&FullRange)); + id).get().to_string())[]); } infer::IndexSlice(span) => { self.tcx.sess.span_note( @@ -1604,9 +1604,9 @@ impl<'a, 'tcx> ErrorReportingHelpers<'tcx> for InferCtxt<'a, 'tcx> { infer::ExprTypeIsNotInScope(t, span) => { self.tcx.sess.span_note( span, - format!("...so type `{}` of expression is valid during the \ + &format!("...so type `{}` of expression is valid during the \ expression", - self.ty_to_string(t)).index(&FullRange)); + self.ty_to_string(t))[]); } infer::BindingTypeIsNotValidAtDecl(span) => { self.tcx.sess.span_note( @@ -1616,30 +1616,30 @@ impl<'a, 'tcx> ErrorReportingHelpers<'tcx> for InferCtxt<'a, 'tcx> { infer::ReferenceOutlivesReferent(ty, span) => { self.tcx.sess.span_note( span, - format!("...so that the reference type `{}` \ + &format!("...so that the reference type `{}` \ does not outlive the data it points at", - self.ty_to_string(ty)).index(&FullRange)); + self.ty_to_string(ty))[]); } infer::RelateParamBound(span, t) => { self.tcx.sess.span_note( span, - format!("...so that the type `{}` \ + &format!("...so that the type `{}` \ will meet the declared lifetime bounds", - self.ty_to_string(t)).index(&FullRange)); + self.ty_to_string(t))[]); } infer::RelateDefaultParamBound(span, t) => { self.tcx.sess.span_note( span, - format!("...so that type parameter \ + &format!("...so that type parameter \ instantiated with `{}`, \ will meet its declared lifetime bounds", - self.ty_to_string(t)).index(&FullRange)); + self.ty_to_string(t))[]); } infer::RelateRegionParamBound(span) => { self.tcx.sess.span_note( span, - format!("...so that the declared lifetime parameter bounds \ - are satisfied").index(&FullRange)); + &format!("...so that the declared lifetime parameter bounds \ + are satisfied")[]); } } } @@ -1691,7 +1691,7 @@ fn lifetimes_in_scope(tcx: &ty::ctxt, Some(node) => match node { ast_map::NodeItem(item) => match item.node { ast::ItemFn(_, _, _, ref gen, _) => { - taken.push_all(gen.lifetimes.index(&FullRange)); + taken.push_all(&gen.lifetimes[]); None }, _ => None @@ -1699,7 +1699,7 @@ fn lifetimes_in_scope(tcx: &ty::ctxt, ast_map::NodeImplItem(ii) => { match *ii { ast::MethodImplItem(ref m) => { - taken.push_all(m.pe_generics().lifetimes.index(&FullRange)); + taken.push_all(&m.pe_generics().lifetimes[]); Some(m.id) } ast::TypeImplItem(_) => None, @@ -1758,10 +1758,10 @@ impl LifeGiver { let mut lifetime; loop { let mut s = String::from_str("'"); - s.push_str(num_to_string(self.counter.get()).index(&FullRange)); + s.push_str(&num_to_string(self.counter.get())[]); if !self.taken.contains(&s) { lifetime = name_to_dummy_lifetime( - token::str_to_ident(s.index(&FullRange)).name); + token::str_to_ident(&s[]).name); self.generated.borrow_mut().push(lifetime); break; } diff --git a/src/librustc/middle/infer/freshen.rs b/src/librustc/middle/infer/freshen.rs index 02c52f82967..6bc424fdf95 100644 --- a/src/librustc/middle/infer/freshen.rs +++ b/src/librustc/middle/infer/freshen.rs @@ -135,10 +135,7 @@ impl<'a, 'tcx> TypeFolder<'tcx> for TypeFreshener<'a, 'tcx> { t } - ty::ty_open(..) => { - self.tcx().sess.bug("Cannot freshen an open existential type"); - } - + ty::ty_open(..) | ty::ty_bool | ty::ty_char | ty::ty_int(..) | diff --git a/src/librustc/middle/infer/higher_ranked/mod.rs b/src/librustc/middle/infer/higher_ranked/mod.rs index 073052dd368..0df84323ae5 100644 --- a/src/librustc/middle/infer/higher_ranked/mod.rs +++ b/src/librustc/middle/infer/higher_ranked/mod.rs @@ -187,9 +187,9 @@ impl<'tcx,C> HigherRankedRelations<'tcx> for C infcx.tcx.sess.span_bug( span, - format!("region {:?} is not associated with \ + &format!("region {:?} is not associated with \ any bound region from A!", - r0).index(&FullRange)) + r0)[]) } } @@ -322,7 +322,7 @@ impl<'tcx,C> HigherRankedRelations<'tcx> for C } infcx.tcx.sess.span_bug( span, - format!("could not find original bound region for {:?}", r).index(&FullRange)); + &format!("could not find original bound region for {:?}", r)[]); } fn fresh_bound_variable(infcx: &InferCtxt, debruijn: ty::DebruijnIndex) -> ty::Region { @@ -339,7 +339,7 @@ fn var_ids<'tcx, T: Combine<'tcx>>(combiner: &T, r => { combiner.infcx().tcx.sess.span_bug( combiner.trace().origin.span(), - format!("found non-region-vid: {:?}", r).index(&FullRange)); + &format!("found non-region-vid: {:?}", r)[]); } }).collect() } @@ -468,7 +468,7 @@ pub fn skolemize_late_bound_regions<'a,'tcx,T>(infcx: &InferCtxt<'a,'tcx>, * when higher-ranked things are involved. See `doc.rs` for more details. */ - let (result, map) = ty::replace_late_bound_regions(infcx.tcx, binder, |br, _| { + let (result, map) = ty::replace_late_bound_regions(infcx.tcx, binder, |br| { infcx.region_vars.new_skolemized(br, &snapshot.region_vars_snapshot) }); diff --git a/src/librustc/middle/infer/mod.rs b/src/librustc/middle/infer/mod.rs index 3f18af3d768..ab1c41f6968 100644 --- a/src/librustc/middle/infer/mod.rs +++ b/src/librustc/middle/infer/mod.rs @@ -39,7 +39,7 @@ use util::ppaux::{ty_to_string}; use util::ppaux::{Repr, UserString}; use self::coercion::Coerce; -use self::combine::{Combine, CombineFields}; +use self::combine::{Combine, Combineable, CombineFields}; use self::region_inference::{RegionVarBindings, RegionSnapshot}; use self::equate::Equate; use self::sub::Sub; @@ -360,17 +360,9 @@ pub fn can_mk_subty<'a, 'tcx>(cx: &InferCtxt<'a, 'tcx>, }) } -pub fn can_mk_eqty<'a, 'tcx>(cx: &InferCtxt<'a, 'tcx>, - a: Ty<'tcx>, b: Ty<'tcx>) - -> ures<'tcx> { - debug!("can_mk_subty({} <: {})", a.repr(cx.tcx), b.repr(cx.tcx)); - cx.probe(|_| { - let trace = TypeTrace { - origin: Misc(codemap::DUMMY_SP), - values: Types(expected_found(true, a, b)) - }; - cx.equate(true, trace).tys(a, b) - }).to_ures() +pub fn can_mk_eqty<'a, 'tcx>(cx: &InferCtxt<'a, 'tcx>, a: Ty<'tcx>, b: Ty<'tcx>) -> ures<'tcx> +{ + cx.can_equate(&a, &b) } pub fn mk_subr<'a, 'tcx>(cx: &InferCtxt<'a, 'tcx>, @@ -1000,9 +992,9 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> { format!(" ({})", ty::type_err_to_str(self.tcx, t_err)) }); - self.tcx.sess.span_err(sp, format!("{}{}", + self.tcx.sess.span_err(sp, &format!("{}{}", mk_msg(resolved_expected.map(|t| self.ty_to_string(t)), actual_ty), - error_str).index(&FullRange)); + error_str)[]); for err in err.iter() { ty::note_and_explain_type_err(self.tcx, *err) @@ -1056,7 +1048,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> { ty::replace_late_bound_regions( self.tcx, value, - |br, _| self.next_region_var(LateBoundRegion(span, br, lbrct))) + |br| self.next_region_var(LateBoundRegion(span, br, lbrct))) } /// See `verify_generic_bound` method in `region_inference` @@ -1072,6 +1064,23 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> { self.region_vars.verify_generic_bound(origin, kind, a, bs); } + + pub fn can_equate<T>(&self, a: &T, b: &T) -> ures<'tcx> + where T : Combineable<'tcx> + Repr<'tcx> + { + debug!("can_equate({}, {})", a.repr(self.tcx), b.repr(self.tcx)); + self.probe(|_| { + // Gin up a dummy trace, since this won't be committed + // anyhow. We should make this typetrace stuff more + // generic so we don't have to do anything quite this + // terrible. + let e = self.tcx.types.err; + let trace = TypeTrace { origin: Misc(codemap::DUMMY_SP), + values: Types(expected_found(true, e, e)) }; + let eq = self.equate(true, trace); + Combineable::combine(&eq, a, b) + }).to_ures() + } } impl<'tcx> TypeTrace<'tcx> { diff --git a/src/librustc/middle/infer/region_inference/mod.rs b/src/librustc/middle/infer/region_inference/mod.rs index 5c5c08b53a2..d54d0ae87ae 100644 --- a/src/librustc/middle/infer/region_inference/mod.rs +++ b/src/librustc/middle/infer/region_inference/mod.rs @@ -473,9 +473,9 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { (_, ReLateBound(..)) => { self.tcx.sess.span_bug( origin.span(), - format!("cannot relate bound region: {} <= {}", + &format!("cannot relate bound region: {} <= {}", sub.repr(self.tcx), - sup.repr(self.tcx)).index(&FullRange)); + sup.repr(self.tcx))[]); } (_, ReStatic) => { // all regions are subregions of static, so we can ignore this @@ -734,9 +734,9 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { (ReEarlyBound(..), _) | (_, ReEarlyBound(..)) => { self.tcx.sess.bug( - format!("cannot relate bound region: LUB({}, {})", + &format!("cannot relate bound region: LUB({}, {})", a.repr(self.tcx), - b.repr(self.tcx)).index(&FullRange)); + b.repr(self.tcx))[]); } (ReStatic, _) | (_, ReStatic) => { @@ -750,10 +750,10 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { (ReInfer(ReVar(v_id)), _) | (_, ReInfer(ReVar(v_id))) => { self.tcx.sess.span_bug( (*self.var_origins.borrow())[v_id.index as uint].span(), - format!("lub_concrete_regions invoked with \ + &format!("lub_concrete_regions invoked with \ non-concrete regions: {:?}, {:?}", a, - b).index(&FullRange)); + b)[]); } (ReFree(ref fr), ReScope(s_id)) | @@ -834,9 +834,9 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { (ReEarlyBound(..), _) | (_, ReEarlyBound(..)) => { self.tcx.sess.bug( - format!("cannot relate bound region: GLB({}, {})", + &format!("cannot relate bound region: GLB({}, {})", a.repr(self.tcx), - b.repr(self.tcx)).index(&FullRange)); + b.repr(self.tcx))[]); } (ReStatic, r) | (r, ReStatic) => { @@ -853,10 +853,10 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { (_, ReInfer(ReVar(v_id))) => { self.tcx.sess.span_bug( (*self.var_origins.borrow())[v_id.index as uint].span(), - format!("glb_concrete_regions invoked with \ + &format!("glb_concrete_regions invoked with \ non-concrete regions: {:?}, {:?}", a, - b).index(&FullRange)); + b)[]); } (ReFree(ref fr), ReScope(s_id)) | @@ -977,7 +977,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { self.expansion(var_data.as_mut_slice()); self.contraction(var_data.as_mut_slice()); let values = - self.extract_values_and_collect_conflicts(var_data.index(&FullRange), + self.extract_values_and_collect_conflicts(&var_data[], errors); self.collect_concrete_region_errors(&values, errors); values @@ -1411,11 +1411,11 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { self.tcx.sess.span_bug( (*self.var_origins.borrow())[node_idx.index as uint].span(), - format!("collect_error_for_expanding_node() could not find error \ + &format!("collect_error_for_expanding_node() could not find error \ for var {:?}, lower_bounds={}, upper_bounds={}", node_idx, lower_bounds.repr(self.tcx), - upper_bounds.repr(self.tcx)).index(&FullRange)); + upper_bounds.repr(self.tcx))[]); } fn collect_error_for_contracting_node( @@ -1456,10 +1456,10 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { self.tcx.sess.span_bug( (*self.var_origins.borrow())[node_idx.index as uint].span(), - format!("collect_error_for_contracting_node() could not find error \ + &format!("collect_error_for_contracting_node() could not find error \ for var {:?}, upper_bounds={}", node_idx, - upper_bounds.repr(self.tcx)).index(&FullRange)); + upper_bounds.repr(self.tcx))[]); } fn collect_concrete_regions(&self, diff --git a/src/librustc/middle/infer/resolve.rs b/src/librustc/middle/infer/resolve.rs index 9035d72e9a2..7bb3106b0ba 100644 --- a/src/librustc/middle/infer/resolve.rs +++ b/src/librustc/middle/infer/resolve.rs @@ -95,8 +95,8 @@ impl<'a, 'tcx> ty_fold::TypeFolder<'tcx> for FullTypeResolver<'a, 'tcx> { } ty::ty_infer(_) => { self.infcx.tcx.sess.bug( - format!("Unexpected type in full type resolver: {}", - t.repr(self.infcx.tcx)).index(&FullRange)); + &format!("Unexpected type in full type resolver: {}", + t.repr(self.infcx.tcx))[]); } _ => { ty_fold::super_fold_ty(self, t) diff --git a/src/librustc/middle/liveness.rs b/src/librustc/middle/liveness.rs index 850033b3ed1..1b1dca00422 100644 --- a/src/librustc/middle/liveness.rs +++ b/src/librustc/middle/liveness.rs @@ -326,8 +326,8 @@ impl<'a, 'tcx> IrMaps<'a, 'tcx> { None => { self.tcx .sess - .span_bug(span, format!("no variable registered for id {}", - node_id).index(&FullRange)); + .span_bug(span, &format!("no variable registered for id {}", + node_id)[]); } } } @@ -597,8 +597,8 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> { // creating liveness nodes for. self.ir.tcx.sess.span_bug( span, - format!("no live node registered for node {}", - node_id).index(&FullRange)); + &format!("no live node registered for node {}", + node_id)[]); } } } @@ -1133,7 +1133,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> { // Uninteresting cases: just propagate in rev exec order ast::ExprVec(ref exprs) => { - self.propagate_through_exprs(exprs.index(&FullRange), succ) + self.propagate_through_exprs(&exprs[], succ) } ast::ExprRepeat(ref element, ref count) => { @@ -1157,7 +1157,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> { } else { succ }; - let succ = self.propagate_through_exprs(args.index(&FullRange), succ); + let succ = self.propagate_through_exprs(&args[], succ); self.propagate_through_expr(&**f, succ) } @@ -1170,11 +1170,11 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> { } else { succ }; - self.propagate_through_exprs(args.index(&FullRange), succ) + self.propagate_through_exprs(&args[], succ) } ast::ExprTup(ref exprs) => { - self.propagate_through_exprs(exprs.index(&FullRange), succ) + self.propagate_through_exprs(&exprs[], succ) } ast::ExprBinary(op, ref l, ref r) if ast_util::lazy_binop(op) => { diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs index b29c24c5861..fb9a16f86e5 100644 --- a/src/librustc/middle/mem_categorization.rs +++ b/src/librustc/middle/mem_categorization.rs @@ -584,9 +584,9 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> { _ => { self.tcx().sess.span_bug( span, - format!("Upvar of non-closure {} - {}", + &format!("Upvar of non-closure {} - {}", fn_node_id, - ty.repr(self.tcx())).index(&FullRange)); + ty.repr(self.tcx()))[]); } } } diff --git a/src/librustc/middle/privacy.rs b/src/librustc/middle/privacy.rs index 861c4a2c85e..aa37c2fe348 100644 --- a/src/librustc/middle/privacy.rs +++ b/src/librustc/middle/privacy.rs @@ -615,10 +615,10 @@ impl<'a, 'tcx> PrivacyVisitor<'a, 'tcx> { match result { None => true, Some((span, msg, note)) => { - self.tcx.sess.span_err(span, msg.index(&FullRange)); + self.tcx.sess.span_err(span, &msg[]); match note { Some((span, msg)) => { - self.tcx.sess.span_note(span, msg.index(&FullRange)) + self.tcx.sess.span_note(span, &msg[]) } None => {}, } @@ -720,7 +720,7 @@ impl<'a, 'tcx> PrivacyVisitor<'a, 'tcx> { UnnamedField(idx) => format!("field #{} of {} is private", idx + 1, struct_desc), }; - self.tcx.sess.span_err(span, msg.index(&FullRange)); + self.tcx.sess.span_err(span, &msg[]); } // Given the ID of a method, checks to ensure it's in scope. @@ -741,8 +741,8 @@ impl<'a, 'tcx> PrivacyVisitor<'a, 'tcx> { self.report_error(self.ensure_public(span, method_id, None, - format!("method `{}`", - string).index(&FullRange))); + &format!("method `{}`", + string)[])); } // Checks that a path is in scope. @@ -756,7 +756,7 @@ impl<'a, 'tcx> PrivacyVisitor<'a, 'tcx> { self.ensure_public(span, def, Some(origdid), - format!("{} `{}`", tyname, name).index(&FullRange)) + &format!("{} `{}`", tyname, name)[]) }; match self.last_private_map[path_id] { diff --git a/src/librustc/middle/reachable.rs b/src/librustc/middle/reachable.rs index 51602e88f93..906607ddc5b 100644 --- a/src/librustc/middle/reachable.rs +++ b/src/librustc/middle/reachable.rs @@ -50,7 +50,7 @@ fn generics_require_inlining(generics: &ast::Generics) -> bool { // monomorphized or it was marked with `#[inline]`. This will only return // true for functions. fn item_might_be_inlined(item: &ast::Item) -> bool { - if attributes_specify_inlining(item.attrs.index(&FullRange)) { + if attributes_specify_inlining(&item.attrs[]) { return true } @@ -65,7 +65,7 @@ fn item_might_be_inlined(item: &ast::Item) -> bool { fn method_might_be_inlined(tcx: &ty::ctxt, method: &ast::Method, impl_src: ast::DefId) -> bool { - if attributes_specify_inlining(method.attrs.index(&FullRange)) || + if attributes_specify_inlining(&method.attrs[]) || generics_require_inlining(method.pe_generics()) { return true } @@ -202,7 +202,7 @@ impl<'a, 'tcx> ReachableContext<'a, 'tcx> { ast::MethodImplItem(ref method) => { if generics_require_inlining(method.pe_generics()) || attributes_specify_inlining( - method.attrs.index(&FullRange)) { + &method.attrs[]) { true } else { let impl_did = self.tcx @@ -247,9 +247,9 @@ impl<'a, 'tcx> ReachableContext<'a, 'tcx> { Some(ref item) => self.propagate_node(item, search_item), None if search_item == ast::CRATE_NODE_ID => {} None => { - self.tcx.sess.bug(format!("found unmapped ID in worklist: \ + self.tcx.sess.bug(&format!("found unmapped ID in worklist: \ {}", - search_item).index(&FullRange)) + search_item)[]) } } } @@ -338,10 +338,10 @@ impl<'a, 'tcx> ReachableContext<'a, 'tcx> { _ => { self.tcx .sess - .bug(format!("found unexpected thingy in worklist: {}", + .bug(&format!("found unexpected thingy in worklist: {}", self.tcx .map - .node_to_string(search_item)).index(&FullRange)) + .node_to_string(search_item))[]) } } } diff --git a/src/librustc/middle/region.rs b/src/librustc/middle/region.rs index 5d18843097f..5d33a7efd3b 100644 --- a/src/librustc/middle/region.rs +++ b/src/librustc/middle/region.rs @@ -643,7 +643,7 @@ fn resolve_local(visitor: &mut RegionResolutionVisitor, local: &ast::Local) { // A, but the inner rvalues `a()` and `b()` have an extended lifetime // due to rule C. // - // FIXME(#6308) -- Note that `.index(&FullRange)` patterns work more smoothly post-DST. + // FIXME(#6308) -- Note that `[]` patterns work more smoothly post-DST. match local.init { Some(ref expr) => { diff --git a/src/librustc/middle/resolve_lifetime.rs b/src/librustc/middle/resolve_lifetime.rs index 8e03d774b81..b670099ff96 100644 --- a/src/librustc/middle/resolve_lifetime.rs +++ b/src/librustc/middle/resolve_lifetime.rs @@ -398,8 +398,8 @@ impl<'a> LifetimeContext<'a> { fn unresolved_lifetime_ref(&self, lifetime_ref: &ast::Lifetime) { self.sess.span_err( lifetime_ref.span, - format!("use of undeclared lifetime name `{}`", - token::get_name(lifetime_ref.name)).index(&FullRange)); + &format!("use of undeclared lifetime name `{}`", + token::get_name(lifetime_ref.name))[]); } fn check_lifetime_defs(&mut self, old_scope: Scope, lifetimes: &Vec<ast::LifetimeDef>) { @@ -411,9 +411,9 @@ impl<'a> LifetimeContext<'a> { if special_idents.iter().any(|&i| i.name == lifetime.lifetime.name) { self.sess.span_err( lifetime.lifetime.span, - format!("illegal lifetime parameter name: `{}`", + &format!("illegal lifetime parameter name: `{}`", token::get_name(lifetime.lifetime.name)) - .index(&FullRange)); + []); } } @@ -424,10 +424,10 @@ impl<'a> LifetimeContext<'a> { if lifetime_i.lifetime.name == lifetime_j.lifetime.name { self.sess.span_err( lifetime_j.lifetime.span, - format!("lifetime name `{}` declared twice in \ + &format!("lifetime name `{}` declared twice in \ the same scope", token::get_name(lifetime_j.lifetime.name)) - .index(&FullRange)); + []); } } diff --git a/src/librustc/middle/stability.rs b/src/librustc/middle/stability.rs index 359ad8d3941..e712f510d9d 100644 --- a/src/librustc/middle/stability.rs +++ b/src/librustc/middle/stability.rs @@ -189,3 +189,19 @@ pub fn lookup(tcx: &ty::ctxt, id: DefId) -> Option<Stability> { } }) } + +pub fn is_staged_api(tcx: &ty::ctxt, id: DefId) -> bool { + match ty::trait_item_of_item(tcx, id) { + Some(ty::MethodTraitItemId(trait_method_id)) + if trait_method_id != id => { + is_staged_api(tcx, trait_method_id) + } + _ if is_local(id) => { + // Unused case + unreachable!() + } + _ => { + csearch::is_staged_api(&tcx.sess.cstore, id) + } + } +} diff --git a/src/librustc/middle/subst.rs b/src/librustc/middle/subst.rs index 98bb0645bef..5fbae6c359d 100644 --- a/src/librustc/middle/subst.rs +++ b/src/librustc/middle/subst.rs @@ -394,7 +394,7 @@ impl<T> VecPerParamSpace<T> { self.content.as_slice() } - pub fn to_vec(self) -> Vec<T> { + pub fn into_vec(self) -> Vec<T> { self.content } @@ -599,12 +599,12 @@ impl<'a, 'tcx> TypeFolder<'tcx> for SubstFolder<'a, 'tcx> { let span = self.span.unwrap_or(DUMMY_SP); self.tcx().sess.span_bug( span, - format!("Type parameter out of range \ + &format!("Type parameter out of range \ when substituting in region {} (root type={}) \ (space={:?}, index={})", region_name.as_str(), self.root_ty.repr(self.tcx()), - space, i).index(&FullRange)); + space, i)[]); } } } @@ -654,14 +654,14 @@ impl<'a,'tcx> SubstFolder<'a,'tcx> { let span = self.span.unwrap_or(DUMMY_SP); self.tcx().sess.span_bug( span, - format!("Type parameter `{}` ({}/{:?}/{}) out of range \ + &format!("Type parameter `{}` ({}/{:?}/{}) out of range \ when substituting (root type={}) substs={}", p.repr(self.tcx()), source_ty.repr(self.tcx()), p.space, p.idx, self.root_ty.repr(self.tcx()), - self.substs.repr(self.tcx())).index(&FullRange)); + self.substs.repr(self.tcx()))[]); } }; diff --git a/src/librustc/middle/traits/coherence.rs b/src/librustc/middle/traits/coherence.rs index 49c7d6aafaa..489731e7554 100644 --- a/src/librustc/middle/traits/coherence.rs +++ b/src/librustc/middle/traits/coherence.rs @@ -136,8 +136,8 @@ fn ty_is_local_constructor<'tcx>(tcx: &ty::ctxt<'tcx>, ty: Ty<'tcx>) -> bool { ty::ty_open(..) | ty::ty_err => { tcx.sess.bug( - format!("ty_is_local invoked on unexpected type: {}", - ty.repr(tcx)).index(&FullRange)) + &format!("ty_is_local invoked on unexpected type: {}", + ty.repr(tcx))[]) } } } diff --git a/src/librustc/middle/traits/error_reporting.rs b/src/librustc/middle/traits/error_reporting.rs index fd6773afb76..02c913a9e81 100644 --- a/src/librustc/middle/traits/error_reporting.rs +++ b/src/librustc/middle/traits/error_reporting.rs @@ -337,7 +337,7 @@ pub fn suggest_new_overflow_limit(tcx: &ty::ctxt, span: Span) { let suggested_limit = current_limit * 2; tcx.sess.span_note( span, - format!( + &format!( "consider adding a `#![recursion_limit=\"{}\"]` attribute to your crate", - suggested_limit).index(&FullRange)); + suggested_limit)[]); } diff --git a/src/librustc/middle/traits/fulfill.rs b/src/librustc/middle/traits/fulfill.rs index 71a3ad64faf..c3b9be85eb5 100644 --- a/src/librustc/middle/traits/fulfill.rs +++ b/src/librustc/middle/traits/fulfill.rs @@ -227,7 +227,7 @@ impl<'tcx> FulfillmentContext<'tcx> { } pub fn pending_obligations(&self) -> &[PredicateObligation<'tcx>] { - self.predicates.index(&FullRange) + &self.predicates[] } /// Attempts to select obligations using `selcx`. If `only_new_obligations` is true, then it diff --git a/src/librustc/middle/traits/object_safety.rs b/src/librustc/middle/traits/object_safety.rs index aaf0d4fcb33..c0399112c33 100644 --- a/src/librustc/middle/traits/object_safety.rs +++ b/src/librustc/middle/traits/object_safety.rs @@ -178,7 +178,7 @@ fn object_safety_violations_for_method<'tcx>(tcx: &ty::ctxt<'tcx>, // The `Self` type is erased, so it should not appear in list of // arguments or return type apart from the receiver. let ref sig = method.fty.sig; - for &input_ty in sig.0.inputs.index(&(1..)).iter() { + for &input_ty in sig.0.inputs[1..].iter() { if contains_illegal_self_type_reference(tcx, trait_def_id, input_ty) { return Some(MethodViolationCode::ReferencesSelf); } diff --git a/src/librustc/middle/traits/project.rs b/src/librustc/middle/traits/project.rs index e9eb3f4f4b0..aaf5df4ce4a 100644 --- a/src/librustc/middle/traits/project.rs +++ b/src/librustc/middle/traits/project.rs @@ -649,7 +649,7 @@ fn confirm_candidate<'cx,'tcx>( } match impl_ty { - Some(ty) => (ty, impl_vtable.nested.to_vec()), + Some(ty) => (ty, impl_vtable.nested.into_vec()), None => { // This means that the impl is missing a // definition for the associated type. This error diff --git a/src/librustc/middle/traits/select.rs b/src/librustc/middle/traits/select.rs index 7c8e0d90e11..f42f43d2576 100644 --- a/src/librustc/middle/traits/select.rs +++ b/src/librustc/middle/traits/select.rs @@ -835,7 +835,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { bounds.repr(self.tcx())); let matching_bound = - util::elaborate_predicates(self.tcx(), bounds.predicates.to_vec()) + util::elaborate_predicates(self.tcx(), bounds.predicates.into_vec()) .filter_to_traits() .find( |bound| self.infcx.probe( @@ -903,7 +903,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { let all_bounds = util::transitive_bounds( - self.tcx(), caller_trait_refs.index(&FullRange)); + self.tcx(), &caller_trait_refs[]); let matching_bounds = all_bounds.filter( @@ -1457,17 +1457,32 @@ 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 | + ty::BoundSync | + ty::BoundSend => { + Ok(If(vec!(ty))) + } + + ty::BoundSized => { + Err(Unimplemented) + } + } + } ty::ty_err => { Ok(If(Vec::new())) } - ty::ty_open(_) | ty::ty_infer(ty::FreshTy(_)) | ty::ty_infer(ty::FreshIntTy(_)) => { self.tcx().sess.bug( - format!( + &format!( "asked to assemble builtin bounds of unexpected type: {}", - self_ty.repr(self.tcx())).index(&FullRange)); + self_ty.repr(self.tcx()))[]); } }; @@ -1636,8 +1651,8 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { AmbiguousBuiltin | ParameterBuiltin => { self.tcx().sess.span_bug( obligation.cause.span, - format!("builtin bound for {} was ambig", - obligation.repr(self.tcx())).index(&FullRange)); + &format!("builtin bound for {} was ambig", + obligation.repr(self.tcx()))[]); } } } @@ -1815,8 +1830,8 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { _ => { self.tcx().sess.span_bug( obligation.cause.span, - format!("Fn pointer candidate for inappropriate self type: {}", - self_ty.repr(self.tcx())).index(&FullRange)); + &format!("Fn pointer candidate for inappropriate self type: {}", + self_ty.repr(self.tcx()))[]); } }; @@ -1944,9 +1959,9 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { } Err(()) => { self.tcx().sess.bug( - format!("Impl {} was matchable against {} but now is not", + &format!("Impl {} was matchable against {} but now is not", impl_def_id.repr(self.tcx()), - obligation.repr(self.tcx())).index(&FullRange)); + obligation.repr(self.tcx()))[]); } } } diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index 46d2ff7e1b9..64f0bcb1c88 100644 --- a/src/librustc/middle/ty.rs +++ b/src/librustc/middle/ty.rs @@ -72,7 +72,7 @@ use std::borrow::BorrowFrom; use std::cell::{Cell, RefCell}; use std::cmp::{self, Ordering}; use std::fmt::{self, Show}; -use std::hash::{Hash, sip, Writer}; +use std::hash::{Hash, Writer, SipHasher, Hasher}; use std::mem; use std::ops; use std::rc::Rc; @@ -107,7 +107,7 @@ pub struct CrateAnalysis<'tcx> { pub glob_map: Option<GlobMap>, } -#[derive(Copy, PartialEq, Eq, Hash)] +#[derive(Copy, Clone, PartialEq, Eq, Hash)] pub struct field<'tcx> { pub name: ast::Name, pub mt: mt<'tcx> @@ -946,11 +946,18 @@ impl<'tcx> PartialEq for TyS<'tcx> { } impl<'tcx> Eq for TyS<'tcx> {} +#[cfg(stage0)] impl<'tcx, S: Writer> Hash<S> for TyS<'tcx> { fn hash(&self, s: &mut S) { (self as *const _).hash(s) } } +#[cfg(not(stage0))] +impl<'tcx, S: Writer + Hasher> Hash<S> for TyS<'tcx> { + fn hash(&self, s: &mut S) { + (self as *const _).hash(s) + } +} pub type Ty<'tcx> = &'tcx TyS<'tcx>; @@ -968,7 +975,7 @@ impl<'tcx> PartialEq for InternedTy<'tcx> { impl<'tcx> Eq for InternedTy<'tcx> {} -impl<'tcx, S: Writer> Hash<S> for InternedTy<'tcx> { +impl<'tcx, S: Writer + Hasher> Hash<S> for InternedTy<'tcx> { fn hash(&self, s: &mut S) { self.ty.sty.hash(s) } @@ -1491,10 +1498,12 @@ impl<'tcx> PolyTraitRef<'tcx> { } pub fn substs(&self) -> &'tcx Substs<'tcx> { + // FIXME(#20664) every use of this fn is probably a bug, it should yield Binder<> self.0.substs } pub fn input_types(&self) -> &[Ty<'tcx>] { + // FIXME(#20664) every use of this fn is probably a bug, it should yield Binder<> self.0.input_types() } @@ -2036,8 +2045,8 @@ impl<'tcx> Predicate<'tcx> { /// struct Foo<T,U:Bar<T>> { ... } /// /// Here, the `Generics` for `Foo` would contain a list of bounds like -/// `[.index(&FullRange), [U:Bar<T>]]`. Now if there were some particular reference -/// like `Foo<int,uint>`, then the `GenericBounds` would be `[.index(&FullRange), +/// `[[], [U:Bar<T>]]`. Now if there were some particular reference +/// like `Foo<int,uint>`, then the `GenericBounds` would be `[[], /// [uint:Bar<int>]]`. #[derive(Clone, Show)] pub struct GenericBounds<'tcx> { @@ -2212,9 +2221,9 @@ impl<'a, 'tcx> ParameterEnvironment<'a, 'tcx> { ParameterEnvironment::for_item(cx, cx.map.get_parent(id)) } _ => { - cx.sess.bug(format!("ParameterEnvironment::from_item(): \ + cx.sess.bug(&format!("ParameterEnvironment::from_item(): \ `{}` is not an item", - cx.map.node_to_string(id)).index(&FullRange)) + cx.map.node_to_string(id))[]) } } } @@ -2299,7 +2308,7 @@ impl UnboxedClosureKind { }; match result { Ok(trait_did) => trait_did, - Err(err) => cx.sess.fatal(err.index(&FullRange)), + Err(err) => cx.sess.fatal(&err[]), } } } @@ -2620,7 +2629,7 @@ impl FlagComputation { } &ty_tup(ref ts) => { - self.add_tys(ts.index(&FullRange)); + self.add_tys(&ts[]); } &ty_bare_fn(_, ref f) => { @@ -2643,7 +2652,7 @@ impl FlagComputation { fn add_fn_sig(&mut self, fn_sig: &PolyFnSig) { let mut computation = FlagComputation::new(); - computation.add_tys(fn_sig.0.inputs.index(&FullRange)); + computation.add_tys(&fn_sig.0.inputs[]); if let ty::FnConverging(output) = fn_sig.0.output { computation.add_ty(output); @@ -2812,7 +2821,7 @@ pub fn mk_trait<'tcx>(cx: &ctxt<'tcx>, fn bound_list_is_sorted(bounds: &[ty::PolyProjectionPredicate]) -> bool { bounds.len() == 0 || - bounds.index(&(1..)).iter().enumerate().all( + bounds[1..].iter().enumerate().all( |(index, bound)| bounds[index].sort_key() <= bound.sort_key()) } @@ -3066,8 +3075,8 @@ pub fn sequence_element_type<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> { 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)).index(&FullRange)), + _ => cx.sess.bug(&format!("sequence_element_type called on non-sequence value: {}", + ty_to_string(cx, ty))[]), } } @@ -3401,7 +3410,7 @@ pub fn type_contents<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> TypeContents { ty_struct(did, substs) => { let flds = struct_fields(cx, did, substs); let mut res = - TypeContents::union(flds.index(&FullRange), + TypeContents::union(&flds[], |f| tc_mt(cx, f.mt, cache)); if !lookup_repr_hints(cx, did).contains(&attr::ReprExtern) { @@ -3425,15 +3434,15 @@ pub fn type_contents<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> TypeContents { } ty_tup(ref tys) => { - TypeContents::union(tys.index(&FullRange), + TypeContents::union(&tys[], |ty| tc_ty(cx, *ty, cache)) } ty_enum(did, substs) => { let variants = substd_enum_variants(cx, did, substs); let mut res = - TypeContents::union(variants.index(&FullRange), |variant| { - TypeContents::union(variant.args.index(&FullRange), + TypeContents::union(&variants[], |variant| { + TypeContents::union(&variant.args[], |arg_ty| { tc_ty(cx, *arg_ty, cache) }) @@ -4017,8 +4026,8 @@ 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)).index(&FullRange)) + _ => cx.sess.bug(&format!("Trying to close a non-open type {}", + ty_to_string(cx, ty))[]) } } @@ -4118,8 +4127,8 @@ pub fn node_id_to_trait_ref<'tcx>(cx: &ctxt<'tcx>, id: ast::NodeId) match cx.trait_refs.borrow().get(&id) { Some(ty) => ty.clone(), None => cx.sess.bug( - format!("node_id_to_trait_ref: no trait ref for node `{}`", - cx.map.node_to_string(id)).index(&FullRange)) + &format!("node_id_to_trait_ref: no trait ref for node `{}`", + cx.map.node_to_string(id))[]) } } @@ -4131,8 +4140,8 @@ pub fn node_id_to_type<'tcx>(cx: &ctxt<'tcx>, id: ast::NodeId) -> Ty<'tcx> { match try_node_id_to_type(cx, id) { Some(ty) => ty, None => cx.sess.bug( - format!("node_id_to_type: no type for node `{}`", - cx.map.node_to_string(id)).index(&FullRange)) + &format!("node_id_to_type: no type for node `{}`", + cx.map.node_to_string(id))[]) } } @@ -4218,8 +4227,8 @@ pub fn ty_region(tcx: &ctxt, ref s => { tcx.sess.span_bug( span, - format!("ty_region() invoked on an inappropriate ty: {:?}", - s).index(&FullRange)); + &format!("ty_region() invoked on an inappropriate ty: {:?}", + s)[]); } } } @@ -4278,13 +4287,13 @@ pub fn expr_span(cx: &ctxt, id: NodeId) -> Span { e.span } Some(f) => { - cx.sess.bug(format!("Node id {} is not an expr: {:?}", + cx.sess.bug(&format!("Node id {} is not an expr: {:?}", id, - f).index(&FullRange)); + f)[]); } None => { - cx.sess.bug(format!("Node id {} is not present \ - in the node map", id).index(&FullRange)); + cx.sess.bug(&format!("Node id {} is not present \ + in the node map", id)[]); } } } @@ -4298,16 +4307,16 @@ pub fn local_var_name_str(cx: &ctxt, id: NodeId) -> InternedString { } _ => { cx.sess.bug( - format!("Variable id {} maps to {:?}, not local", + &format!("Variable id {} maps to {:?}, not local", id, - pat).index(&FullRange)); + pat)[]); } } } r => { - cx.sess.bug(format!("Variable id {} maps to {:?}, not local", + cx.sess.bug(&format!("Variable id {} maps to {:?}, not local", id, - r).index(&FullRange)); + r)[]); } } } @@ -4336,9 +4345,9 @@ pub fn adjust_ty<'tcx, F>(cx: &ctxt<'tcx>, } ref b => { cx.sess.bug( - format!("AdjustReifyFnPointer adjustment on non-fn-item: \ + &format!("AdjustReifyFnPointer adjustment on non-fn-item: \ {:?}", - b).index(&FullRange)); + b)[]); } } } @@ -4365,11 +4374,11 @@ pub fn adjust_ty<'tcx, F>(cx: &ctxt<'tcx>, None => { cx.sess.span_bug( span, - format!("the {}th autoderef failed: \ + &format!("the {}th autoderef failed: \ {}", i, ty_to_string(cx, adjusted_ty)) - .index(&FullRange)); + []); } } } @@ -4431,8 +4440,8 @@ pub fn unsize_ty<'tcx>(cx: &ctxt<'tcx>, mk_vec(cx, ty, None) } _ => cx.sess.span_bug(span, - format!("UnsizeLength with bad sty: {:?}", - ty_to_string(cx, ty)).index(&FullRange)) + &format!("UnsizeLength with bad sty: {:?}", + ty_to_string(cx, ty))[]) }, &UnsizeStruct(box ref k, tp_index) => match ty.sty { ty_struct(did, substs) => { @@ -4443,8 +4452,8 @@ pub fn unsize_ty<'tcx>(cx: &ctxt<'tcx>, mk_struct(cx, did, cx.mk_substs(unsized_substs)) } _ => cx.sess.span_bug(span, - format!("UnsizeStruct with bad sty: {:?}", - ty_to_string(cx, ty)).index(&FullRange)) + &format!("UnsizeStruct with bad sty: {:?}", + ty_to_string(cx, ty))[]) }, &UnsizeVtable(TyTrait { ref principal, ref bounds }, _) => { mk_trait(cx, principal.clone(), bounds.clone()) @@ -4456,8 +4465,8 @@ pub fn resolve_expr(tcx: &ctxt, expr: &ast::Expr) -> def::Def { match tcx.def_map.borrow().get(&expr.id) { Some(&def) => def, None => { - tcx.sess.span_bug(expr.span, format!( - "no def-map entry for expr {}", expr.id).index(&FullRange)); + tcx.sess.span_bug(expr.span, &format!( + "no def-map entry for expr {}", expr.id)[]); } } } @@ -4550,9 +4559,9 @@ pub fn expr_kind(tcx: &ctxt, expr: &ast::Expr) -> ExprKind { def => { tcx.sess.span_bug( expr.span, - format!("uncategorized def for expr {}: {:?}", + &format!("uncategorized def for expr {}: {:?}", expr.id, - def).index(&FullRange)); + def)[]); } } } @@ -4672,12 +4681,12 @@ pub fn field_idx_strict(tcx: &ctxt, name: ast::Name, fields: &[field]) -> uint { let mut i = 0u; for f in fields.iter() { if f.name == name { return i; } i += 1u; } - tcx.sess.bug(format!( + tcx.sess.bug(&format!( "no field named `{}` found in the list of fields `{:?}`", token::get_name(name), fields.iter() .map(|f| token::get_name(f.name).get().to_string()) - .collect::<Vec<String>>()).index(&FullRange)); + .collect::<Vec<String>>())[]); } pub fn impl_or_trait_item_idx(id: ast::Name, trait_items: &[ImplOrTraitItem]) @@ -4932,7 +4941,7 @@ pub fn provided_trait_methods<'tcx>(cx: &ctxt<'tcx>, id: ast::DefId) match item.node { ItemTrait(_, _, _, ref ms) => { let (_, p) = - ast_util::split_trait_methods(ms.index(&FullRange)); + ast_util::split_trait_methods(&ms[]); p.iter() .map(|m| { match impl_or_trait_item( @@ -4949,16 +4958,16 @@ pub fn provided_trait_methods<'tcx>(cx: &ctxt<'tcx>, id: ast::DefId) }).collect() } _ => { - cx.sess.bug(format!("provided_trait_methods: `{:?}` is \ + cx.sess.bug(&format!("provided_trait_methods: `{:?}` is \ not a trait", - id).index(&FullRange)) + id)[]) } } } _ => { - cx.sess.bug(format!("provided_trait_methods: `{:?}` is not a \ + cx.sess.bug(&format!("provided_trait_methods: `{:?}` is not a \ trait", - id).index(&FullRange)) + id)[]) } } } else { @@ -5196,7 +5205,7 @@ impl<'tcx> VariantInfo<'tcx> { }; }, ast::StructVariantKind(ref struct_def) => { - let fields: &[StructField] = struct_def.fields.index(&FullRange); + let fields: &[StructField] = &struct_def.fields[]; assert!(fields.len() > 0); @@ -5346,8 +5355,8 @@ pub fn enum_variants<'tcx>(cx: &ctxt<'tcx>, id: ast::DefId) Err(ref err) => { cx.sess .span_err(e.span, - format!("expected constant: {}", - *err).index(&FullRange)); + &format!("expected constant: {}", + *err)[]); } }, None => {} @@ -5636,8 +5645,8 @@ pub fn lookup_struct_fields(cx: &ctxt, did: ast::DefId) -> Vec<field_ty> { Some(fields) => (**fields).clone(), _ => { cx.sess.bug( - format!("ID not mapped to struct fields: {}", - cx.map.node_to_string(did.node)).index(&FullRange)); + &format!("ID not mapped to struct fields: {}", + cx.map.node_to_string(did.node))[]); } } } else { @@ -5670,7 +5679,7 @@ pub fn struct_fields<'tcx>(cx: &ctxt<'tcx>, did: ast::DefId, substs: &Substs<'tc pub fn tup_fields<'tcx>(v: &[Ty<'tcx>]) -> Vec<field<'tcx>> { v.iter().enumerate().map(|(i, &f)| { field { - name: token::intern(i.to_string().index(&FullRange)), + name: token::intern(&i.to_string()[]), mt: mt { ty: f, mutbl: MutImmutable @@ -5845,9 +5854,9 @@ pub fn eval_repeat_count(tcx: &ctxt, count_expr: &ast::Expr) -> uint { const_eval::const_binary(_) => "binary array" }; - tcx.sess.span_err(count_expr.span, format!( + tcx.sess.span_err(count_expr.span, &format!( "expected positive integer for repeat count, found {}", - found).index(&FullRange)); + found)[]); } Err(_) => { let found = match count_expr.node { @@ -5860,9 +5869,9 @@ pub fn eval_repeat_count(tcx: &ctxt, count_expr: &ast::Expr) -> uint { _ => "non-constant expression" }; - tcx.sess.span_err(count_expr.span, format!( + tcx.sess.span_err(count_expr.span, &format!( "expected constant integer for repeat count, found {}", - found).index(&FullRange)); + found)[]); } } 0 @@ -6168,15 +6177,16 @@ pub fn trait_item_of_item(tcx: &ctxt, def_id: ast::DefId) /// Creates a hash of the type `Ty` which will be the same no matter what crate /// context it's calculated within. This is used by the `type_id` intrinsic. pub fn hash_crate_independent<'tcx>(tcx: &ctxt<'tcx>, ty: Ty<'tcx>, svh: &Svh) -> u64 { - let mut state = sip::SipState::new(); + let mut state = SipHasher::new(); helper(tcx, ty, svh, &mut state); - return state.result(); + return state.finish(); - fn helper<'tcx>(tcx: &ctxt<'tcx>, ty: Ty<'tcx>, svh: &Svh, state: &mut sip::SipState) { + fn helper<'tcx>(tcx: &ctxt<'tcx>, ty: Ty<'tcx>, svh: &Svh, + state: &mut SipHasher) { macro_rules! byte { ($b:expr) => { ($b as u8).hash(state) } } macro_rules! hash { ($e:expr) => { $e.hash(state) } } - let region = |&: state: &mut sip::SipState, r: Region| { + let region = |&: state: &mut SipHasher, r: Region| { match r { ReStatic => {} ReLateBound(db, BrAnon(i)) => { @@ -6193,7 +6203,7 @@ pub fn hash_crate_independent<'tcx>(tcx: &ctxt<'tcx>, ty: Ty<'tcx>, svh: &Svh) - } } }; - let did = |&: state: &mut sip::SipState, did: DefId| { + let did = |&: state: &mut SipHasher, did: DefId| { let h = if ast_util::is_local(did) { svh.clone() } else { @@ -6202,10 +6212,10 @@ pub fn hash_crate_independent<'tcx>(tcx: &ctxt<'tcx>, ty: Ty<'tcx>, svh: &Svh) - h.as_str().hash(state); did.node.hash(state); }; - let mt = |&: state: &mut sip::SipState, mt: mt| { + let mt = |&: state: &mut SipHasher, mt: mt| { mt.mutbl.hash(state); }; - let fn_sig = |&: state: &mut sip::SipState, sig: &Binder<FnSig<'tcx>>| { + let fn_sig = |&: state: &mut SipHasher, sig: &Binder<FnSig<'tcx>>| { let sig = anonymize_late_bound_regions(tcx, sig).0; for a in sig.inputs.iter() { helper(tcx, *a, svh, state); } if let ty::FnConverging(output) = sig.output { @@ -6646,7 +6656,7 @@ pub fn with_freevars<T, F>(tcx: &ty::ctxt, fid: ast::NodeId, f: F) -> T where { match tcx.freevars.borrow().get(&fid) { None => f(&[]), - Some(d) => f(d.index(&FullRange)) + Some(d) => f(&d[]) } } @@ -6676,7 +6686,7 @@ pub fn liberate_late_bound_regions<'tcx, T>( { replace_late_bound_regions( tcx, value, - |br, _| ty::ReFree(ty::FreeRegion{scope: scope, bound_region: br})).0 + |br| ty::ReFree(ty::FreeRegion{scope: scope, bound_region: br})).0 } pub fn count_late_bound_regions<'tcx, T>( @@ -6685,7 +6695,7 @@ pub fn count_late_bound_regions<'tcx, T>( -> uint where T : TypeFoldable<'tcx> + Repr<'tcx> { - let (_, skol_map) = replace_late_bound_regions(tcx, value, |_, _| ty::ReStatic); + let (_, skol_map) = replace_late_bound_regions(tcx, value, |_| ty::ReStatic); skol_map.len() } @@ -6716,7 +6726,7 @@ pub fn erase_late_bound_regions<'tcx, T>( -> T where T : TypeFoldable<'tcx> + Repr<'tcx> { - replace_late_bound_regions(tcx, value, |_, _| ty::ReStatic).0 + replace_late_bound_regions(tcx, value, |_| ty::ReStatic).0 } /// Rewrite any late-bound regions so that they are anonymous. Region numbers are @@ -6734,9 +6744,9 @@ pub fn anonymize_late_bound_regions<'tcx, T>( where T : TypeFoldable<'tcx> + Repr<'tcx>, { let mut counter = 0; - ty::Binder(replace_late_bound_regions(tcx, sig, |_, db| { + ty::Binder(replace_late_bound_regions(tcx, sig, |_| { counter += 1; - ReLateBound(db, BrAnon(counter)) + ReLateBound(ty::DebruijnIndex::new(1), BrAnon(counter)) }).0) } @@ -6747,7 +6757,7 @@ pub fn replace_late_bound_regions<'tcx, T, F>( mut mapf: F) -> (T, FnvHashMap<ty::BoundRegion,ty::Region>) where T : TypeFoldable<'tcx> + Repr<'tcx>, - F : FnMut(BoundRegion, DebruijnIndex) -> ty::Region, + F : FnMut(BoundRegion) -> ty::Region, { debug!("replace_late_bound_regions({})", binder.repr(tcx)); @@ -6759,8 +6769,19 @@ pub fn replace_late_bound_regions<'tcx, T, F>( debug!("region={}", region.repr(tcx)); match region { ty::ReLateBound(debruijn, br) if debruijn.depth == current_depth => { - * map.entry(br).get().unwrap_or_else( - |vacant_entry| vacant_entry.insert(mapf(br, debruijn))) + let region = + * map.entry(br).get().unwrap_or_else( + |vacant_entry| vacant_entry.insert(mapf(br))); + + if let ty::ReLateBound(debruijn1, br) = region { + // If the callback returns a late-bound region, + // that region should always use depth 1. Then we + // adjust it to the correct depth. + assert_eq!(debruijn1.depth, 1); + ty::ReLateBound(debruijn, br) + } else { + region + } } _ => { region @@ -6907,6 +6928,7 @@ pub enum CopyImplementationError { FieldDoesNotImplementCopy(ast::Name), VariantDoesNotImplementCopy(ast::Name), TypeIsStructural, + TypeHasDestructor, } pub fn can_type_implement_copy<'a,'tcx>(param_env: &ParameterEnvironment<'a, 'tcx>, @@ -6916,7 +6938,7 @@ pub fn can_type_implement_copy<'a,'tcx>(param_env: &ParameterEnvironment<'a, 'tc { let tcx = param_env.tcx; - match self_type.sty { + let did = match self_type.sty { ty::ty_struct(struct_did, substs) => { let fields = ty::struct_fields(tcx, struct_did, substs); for field in fields.iter() { @@ -6924,6 +6946,7 @@ pub fn can_type_implement_copy<'a,'tcx>(param_env: &ParameterEnvironment<'a, 'tc return Err(FieldDoesNotImplementCopy(field.name)) } } + struct_did } ty::ty_enum(enum_did, substs) => { let enum_variants = ty::enum_variants(tcx, enum_did); @@ -6936,8 +6959,13 @@ pub fn can_type_implement_copy<'a,'tcx>(param_env: &ParameterEnvironment<'a, 'tc } } } + enum_did } _ => return Err(TypeIsStructural), + }; + + if ty::has_dtor(tcx, did) { + return Err(TypeHasDestructor) } Ok(()) @@ -6962,6 +6990,13 @@ impl<'tcx> RegionEscape for Ty<'tcx> { } } +impl<'tcx> RegionEscape for Substs<'tcx> { + fn has_regions_escaping_depth(&self, depth: u32) -> bool { + self.types.has_regions_escaping_depth(depth) || + self.regions.has_regions_escaping_depth(depth) + } +} + impl<'tcx,T:RegionEscape> RegionEscape for VecPerParamSpace<T> { fn has_regions_escaping_depth(&self, depth: u32) -> bool { self.iter_enumerated().any(|(space, _, t)| { @@ -7216,6 +7251,12 @@ impl<'tcx> HasProjectionTypes for FnSig<'tcx> { } } +impl<'tcx> HasProjectionTypes for field<'tcx> { + fn has_projection_types(&self) -> bool { + self.mt.ty.has_projection_types() + } +} + impl<'tcx> HasProjectionTypes for BareFnTy<'tcx> { fn has_projection_types(&self) -> bool { self.sig.has_projection_types() @@ -7315,3 +7356,11 @@ impl<'tcx> Repr<'tcx> for UnboxedClosureUpvar<'tcx> { self.ty.repr(tcx)) } } + +impl<'tcx> Repr<'tcx> for field<'tcx> { + fn repr(&self, tcx: &ctxt<'tcx>) -> String { + format!("field({},{})", + self.name.repr(tcx), + self.mt.repr(tcx)) + } +} diff --git a/src/librustc/middle/ty_fold.rs b/src/librustc/middle/ty_fold.rs index 424e357d8d4..b81a4ed2f58 100644 --- a/src/librustc/middle/ty_fold.rs +++ b/src/librustc/middle/ty_fold.rs @@ -273,6 +273,15 @@ impl<'tcx> TypeFoldable<'tcx> for ty::TraitRef<'tcx> { } } +impl<'tcx> TypeFoldable<'tcx> for ty::field<'tcx> { + fn fold_with<F: TypeFolder<'tcx>>(&self, folder: &mut F) -> ty::field<'tcx> { + ty::field { + name: self.name, + mt: self.mt.fold_with(folder), + } + } +} + impl<'tcx> TypeFoldable<'tcx> for ty::Region { fn fold_with<F: TypeFolder<'tcx>>(&self, folder: &mut F) -> ty::Region { folder.fold_region(*self) @@ -853,7 +862,10 @@ impl<'a, 'tcx> TypeFolder<'tcx> for RegionFolder<'a, 'tcx> /////////////////////////////////////////////////////////////////////////// // Region eraser // -// Replaces all free regions with 'static. Useful in trans. +// Replaces all free regions with 'static. Useful in contexts, such as +// method probing, where precise region relationships are not +// important. Note that in trans you should use +// `common::erase_regions` instead. pub struct RegionEraser<'a, 'tcx: 'a> { tcx: &'a ty::ctxt<'tcx>, diff --git a/src/librustc/plugin/load.rs b/src/librustc/plugin/load.rs index a38298d52dd..87f5ba0246f 100644 --- a/src/librustc/plugin/load.rs +++ b/src/librustc/plugin/load.rs @@ -223,17 +223,17 @@ impl<'a> PluginLoader<'a> { // this is fatal: there are almost certainly macros we need // inside this crate, so continue would spew "macro undefined" // errors - Err(err) => self.sess.span_fatal(vi.span, err.index(&FullRange)) + Err(err) => self.sess.span_fatal(vi.span, &err[]) }; unsafe { let registrar = - match lib.symbol(symbol.index(&FullRange)) { + match lib.symbol(&symbol[]) { Ok(registrar) => { mem::transmute::<*mut u8,PluginRegistrarFun>(registrar) } // again fatal if we can't register macros - Err(err) => self.sess.span_fatal(vi.span, err.index(&FullRange)) + Err(err) => self.sess.span_fatal(vi.span, &err[]) }; // Intentionally leak the dynamic library. We can't ever unload it diff --git a/src/librustc/session/config.rs b/src/librustc/session/config.rs index 4968066f7b6..72b1669843a 100644 --- a/src/librustc/session/config.rs +++ b/src/librustc/session/config.rs @@ -111,7 +111,24 @@ pub struct Options { /// An optional name to use as the crate for std during std injection, /// written `extern crate std = "name"`. Default to "std". Used by /// out-of-tree drivers. - pub alt_std_name: Option<String> + pub alt_std_name: Option<String>, + /// Indicates how the compiler should treat unstable features + pub unstable_features: UnstableFeatures +} + +#[derive(Clone, Copy)] +pub enum UnstableFeatures { + /// Hard errors for unstable features are active, as on + /// beta/stable channels. + Disallow, + /// Use the default lint levels + Default, + /// Errors are bypassed for bootstrapping. This is required any time + /// during the build that feature-related lints are set to warn or above + /// because the build turns on warnings-as-errors and uses lots of unstable + /// features. As a result, this this is always required for building Rust + /// itself. + Cheat } #[derive(Clone, PartialEq, Eq)] @@ -217,6 +234,7 @@ pub fn basic_options() -> Options { crate_name: None, alt_std_name: None, libs: Vec::new(), + unstable_features: UnstableFeatures::Disallow } } @@ -558,18 +576,18 @@ pub fn build_codegen_options(matches: &getopts::Matches) -> CodegenOptions if !setter(&mut cg, value) { match (value, opt_type_desc) { (Some(..), None) => { - early_error(format!("codegen option `{}` takes no \ - value", key).index(&FullRange)) + early_error(&format!("codegen option `{}` takes no \ + value", key)[]) } (None, Some(type_desc)) => { - early_error(format!("codegen option `{0}` requires \ + early_error(&format!("codegen option `{0}` requires \ {1} (-C {0}=<value>)", - key, type_desc).index(&FullRange)) + key, type_desc)[]) } (Some(value), Some(type_desc)) => { - early_error(format!("incorrect value `{}` for codegen \ + early_error(&format!("incorrect value `{}` for codegen \ option `{}` - {} was expected", - value, key, type_desc).index(&FullRange)) + value, key, type_desc)[]) } (None, None) => unreachable!() } @@ -578,8 +596,8 @@ pub fn build_codegen_options(matches: &getopts::Matches) -> CodegenOptions break; } if !found { - early_error(format!("unknown codegen option: `{}`", - key).index(&FullRange)); + early_error(&format!("unknown codegen option: `{}`", + key)[]); } } return cg; @@ -592,10 +610,10 @@ pub fn default_lib_output() -> CrateType { pub fn default_configuration(sess: &Session) -> ast::CrateConfig { use syntax::parse::token::intern_and_get_ident as intern; - let end = sess.target.target.target_endian.index(&FullRange); - let arch = sess.target.target.arch.index(&FullRange); - let wordsz = sess.target.target.target_word_size.index(&FullRange); - let os = sess.target.target.target_os.index(&FullRange); + let end = &sess.target.target.target_endian[]; + let arch = &sess.target.target.arch[]; + let wordsz = &sess.target.target.target_pointer_width[]; + let os = &sess.target.target.target_os[]; let fam = match sess.target.target.options.is_like_windows { true => InternedString::new("windows"), @@ -609,7 +627,7 @@ pub fn default_configuration(sess: &Session) -> ast::CrateConfig { mk(InternedString::new("target_family"), fam), mk(InternedString::new("target_arch"), intern(arch)), mk(InternedString::new("target_endian"), intern(end)), - mk(InternedString::new("target_word_size"), + mk(InternedString::new("target_pointer_width"), intern(wordsz)) ); } @@ -631,23 +649,23 @@ pub fn build_configuration(sess: &Session) -> ast::CrateConfig { append_configuration(&mut user_cfg, InternedString::new("test")) } let mut v = user_cfg.into_iter().collect::<Vec<_>>(); - v.push_all(default_cfg.index(&FullRange)); + v.push_all(&default_cfg[]); v } pub fn build_target_config(opts: &Options, sp: &SpanHandler) -> Config { - let target = match Target::search(opts.target_triple.index(&FullRange)) { + let target = match Target::search(&opts.target_triple[]) { Ok(t) => t, Err(e) => { sp.handler().fatal((format!("Error loading target specification: {}", e)).as_slice()); } }; - let (int_type, uint_type) = match target.target_word_size.index(&FullRange) { + let (int_type, uint_type) = match &target.target_pointer_width[] { "32" => (ast::TyI32, ast::TyU32), "64" => (ast::TyI64, ast::TyU64), - w => sp.handler().fatal((format!("target specification was invalid: unrecognized \ - target-word-size {}", w)).index(&FullRange)) + w => sp.handler().fatal(&format!("target specification was invalid: unrecognized \ + target-word-size {}", w)[]) }; Config { @@ -845,7 +863,7 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options { let unparsed_crate_types = matches.opt_strs("crate-type"); let crate_types = parse_crate_types_from_list(unparsed_crate_types) - .unwrap_or_else(|e| early_error(e.index(&FullRange))); + .unwrap_or_else(|e| early_error(&e[])); let mut lint_opts = vec!(); let mut describe_lints = false; @@ -872,8 +890,8 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options { } } if this_bit == 0 { - early_error(format!("unknown debug flag: {}", - *debug_flag).index(&FullRange)) + early_error(&format!("unknown debug flag: {}", + *debug_flag)[]) } debugging_opts |= this_bit; } @@ -917,8 +935,8 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options { "link" => OutputTypeExe, "dep-info" => OutputTypeDepInfo, _ => { - early_error(format!("unknown emission type: `{}`", - part).index(&FullRange)) + early_error(&format!("unknown emission type: `{}`", + part)[]) } }; output_types.push(output_type) @@ -955,9 +973,9 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options { Some("2") => Default, Some("3") => Aggressive, Some(arg) => { - early_error(format!("optimization level needs to be \ + early_error(&format!("optimization level needs to be \ between 0-3 (instead was `{}`)", - arg).index(&FullRange)); + arg)[]); } } } else { @@ -993,9 +1011,9 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options { None | Some("2") => FullDebugInfo, Some(arg) => { - early_error(format!("debug info level needs to be between \ + early_error(&format!("debug info level needs to be between \ 0-2 (instead was `{}`)", - arg).index(&FullRange)); + arg)[]); } } } else { @@ -1013,7 +1031,7 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options { let mut search_paths = SearchPaths::new(); for s in matches.opt_strs("L").iter() { - search_paths.add_path(s.index(&FullRange)); + search_paths.add_path(&s[]); } let libs = matches.opt_strs("l").into_iter().map(|s| { @@ -1043,9 +1061,9 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options { (Some(name), "framework") => (name, cstore::NativeFramework), (Some(name), "static") => (name, cstore::NativeStatic), (_, s) => { - early_error(format!("unknown library kind `{}`, expected \ + early_error(&format!("unknown library kind `{}`, expected \ one of dylib, framework, or static", - s).index(&FullRange)); + s)[]); } }; (name.to_string(), kind) @@ -1089,7 +1107,7 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options { --debuginfo"); } - let color = match matches.opt_str("color").as_ref().map(|s| s.index(&FullRange)) { + let color = match matches.opt_str("color").as_ref().map(|s| &s[]) { Some("auto") => Auto, Some("always") => Always, Some("never") => Never, @@ -1097,9 +1115,9 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options { None => Auto, Some(arg) => { - early_error(format!("argument for --color must be auto, always \ + early_error(&format!("argument for --color must be auto, always \ or never (instead was `{}`)", - arg).index(&FullRange)) + arg)[]) } }; @@ -1149,6 +1167,7 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options { crate_name: crate_name, alt_std_name: None, libs: libs, + unstable_features: UnstableFeatures::Disallow } } @@ -1201,7 +1220,7 @@ mod test { #[test] fn test_switch_implies_cfg_test() { let matches = - &match getopts(&["--test".to_string()], optgroups().index(&FullRange)) { + &match getopts(&["--test".to_string()], &optgroups()[]) { Ok(m) => m, Err(f) => panic!("test_switch_implies_cfg_test: {}", f) }; @@ -1209,7 +1228,7 @@ mod test { let sessopts = build_session_options(matches); let sess = build_session(sessopts, None, registry); let cfg = build_configuration(&sess); - assert!((attr::contains_name(cfg.index(&FullRange), "test"))); + assert!((attr::contains_name(&cfg[], "test"))); } // When the user supplies --test and --cfg test, don't implicitly add @@ -1218,7 +1237,7 @@ mod test { fn test_switch_implies_cfg_test_unless_cfg_test() { let matches = &match getopts(&["--test".to_string(), "--cfg=test".to_string()], - optgroups().index(&FullRange)) { + &optgroups()[]) { Ok(m) => m, Err(f) => { panic!("test_switch_implies_cfg_test_unless_cfg_test: {}", f) @@ -1238,7 +1257,7 @@ mod test { { let matches = getopts(&[ "-Awarnings".to_string() - ], optgroups().index(&FullRange)).unwrap(); + ], &optgroups()[]).unwrap(); let registry = diagnostics::registry::Registry::new(&[]); let sessopts = build_session_options(&matches); let sess = build_session(sessopts, None, registry); @@ -1249,7 +1268,7 @@ mod test { let matches = getopts(&[ "-Awarnings".to_string(), "-Dwarnings".to_string() - ], optgroups().index(&FullRange)).unwrap(); + ], &optgroups()[]).unwrap(); let registry = diagnostics::registry::Registry::new(&[]); let sessopts = build_session_options(&matches); let sess = build_session(sessopts, None, registry); @@ -1259,7 +1278,7 @@ mod test { { let matches = getopts(&[ "-Adead_code".to_string() - ], optgroups().index(&FullRange)).unwrap(); + ], &optgroups()[]).unwrap(); let registry = diagnostics::registry::Registry::new(&[]); let sessopts = build_session_options(&matches); let sess = build_session(sessopts, None, registry); diff --git a/src/librustc/session/mod.rs b/src/librustc/session/mod.rs index 94a6bca4e06..65dac1a5fac 100644 --- a/src/librustc/session/mod.rs +++ b/src/librustc/session/mod.rs @@ -174,7 +174,7 @@ impl Session { // cases later on pub fn impossible_case(&self, sp: Span, msg: &str) -> ! { self.span_bug(sp, - format!("impossible case reached: {}", msg).index(&FullRange)); + &format!("impossible case reached: {}", msg)[]); } pub fn verbose(&self) -> bool { self.debugging_opt(config::VERBOSE) } pub fn time_passes(&self) -> bool { self.debugging_opt(config::TIME_PASSES) } @@ -216,7 +216,7 @@ impl Session { } pub fn target_filesearch(&self, kind: PathKind) -> filesearch::FileSearch { filesearch::FileSearch::new(self.sysroot(), - self.opts.target_triple.index(&FullRange), + &self.opts.target_triple[], &self.opts.search_paths, kind) } diff --git a/src/librustc/util/common.rs b/src/librustc/util/common.rs index 26f98e28a8d..c505e9e3112 100644 --- a/src/librustc/util/common.rs +++ b/src/librustc/util/common.rs @@ -16,6 +16,7 @@ use std::fmt::Show; use std::hash::{Hash, Hasher}; use std::iter::repeat; use std::time::Duration; +use std::collections::hash_state::HashState; use syntax::ast; use syntax::visit; @@ -140,11 +141,11 @@ pub fn block_query<P>(b: &ast::Block, p: P) -> bool where P: FnMut(&ast::Expr) - /// Efficiency note: This is implemented in an inefficient way because it is typically invoked on /// very small graphs. If the graphs become larger, a more efficient graph representation and /// algorithm would probably be advised. -pub fn can_reach<S,H:Hasher<S>,T:Eq+Clone+Hash<S>>( - edges_map: &HashMap<T,Vec<T>,H>, - source: T, - destination: T) - -> bool +pub fn can_reach<T, S>(edges_map: &HashMap<T, Vec<T>, S>, source: T, + destination: T) -> bool + where S: HashState, + <S as HashState>::Hasher: Hasher<Output=u64>, + T: Hash< <S as HashState>::Hasher> + Eq + Clone, { if source == destination { return true; @@ -202,11 +203,12 @@ pub fn can_reach<S,H:Hasher<S>,T:Eq+Clone+Hash<S>>( /// } /// ``` #[inline(always)] -pub fn memoized<T, U, S, H, F>(cache: &RefCell<HashMap<T, U, H>>, arg: T, f: F) -> U where - T: Clone + Hash<S> + Eq, - U: Clone, - H: Hasher<S>, - F: FnOnce(T) -> U, +pub fn memoized<T, U, S, F>(cache: &RefCell<HashMap<T, U, S>>, arg: T, f: F) -> U + where T: Clone + Hash<<S as HashState>::Hasher> + Eq, + U: Clone, + S: HashState, + <S as HashState>::Hasher: Hasher<Output=u64>, + F: FnOnce(T) -> U, { let key = arg.clone(); let result = cache.borrow().get(&key).map(|result| result.clone()); diff --git a/src/librustc/util/lev_distance.rs b/src/librustc/util/lev_distance.rs index 8f5820d92c5..ec840498ae6 100644 --- a/src/librustc/util/lev_distance.rs +++ b/src/librustc/util/lev_distance.rs @@ -48,7 +48,7 @@ fn test_lev_distance() { for c in range(0u32, MAX as u32) .filter_map(|i| from_u32(i)) .map(|i| i.to_string()) { - assert_eq!(lev_distance(c.index(&FullRange), c.index(&FullRange)), 0); + assert_eq!(lev_distance(&c[], &c[]), 0); } let a = "\nMäry häd ä little lämb\n\nLittle lämb\n"; diff --git a/src/librustc/util/nodemap.rs b/src/librustc/util/nodemap.rs index ee224d1ec80..044534ae852 100644 --- a/src/librustc/util/nodemap.rs +++ b/src/librustc/util/nodemap.rs @@ -12,12 +12,14 @@ #![allow(non_snake_case)] +use std::collections::hash_state::{DefaultState}; use std::collections::{HashMap, HashSet}; -use std::hash::{Hasher, Hash, Writer}; +use std::default::Default; +use std::hash::{Hasher, Writer}; use syntax::ast; -pub type FnvHashMap<K, V> = HashMap<K, V, FnvHasher>; -pub type FnvHashSet<V> = HashSet<V, FnvHasher>; +pub type FnvHashMap<K, V> = HashMap<K, V, DefaultState<FnvHasher>>; +pub type FnvHashSet<V> = HashSet<V, DefaultState<FnvHasher>>; pub type NodeMap<T> = FnvHashMap<ast::NodeId, T>; pub type DefIdMap<T> = FnvHashMap<ast::DefId, T>; @@ -28,16 +30,16 @@ pub type DefIdSet = FnvHashSet<ast::DefId>; // Hacks to get good names pub mod FnvHashMap { use std::hash::Hash; - use std::collections::HashMap; - pub fn new<K: Hash<super::FnvState> + Eq, V>() -> super::FnvHashMap<K, V> { - HashMap::with_hasher(super::FnvHasher) + use std::default::Default; + pub fn new<K: Hash<super::FnvHasher> + Eq, V>() -> super::FnvHashMap<K, V> { + Default::default() } } pub mod FnvHashSet { use std::hash::Hash; - use std::collections::HashSet; - pub fn new<V: Hash<super::FnvState> + Eq>() -> super::FnvHashSet<V> { - HashSet::with_hasher(super::FnvHasher) + use std::default::Default; + pub fn new<V: Hash<super::FnvHasher> + Eq>() -> super::FnvHashSet<V> { + Default::default() } } pub mod NodeMap { @@ -68,28 +70,26 @@ pub mod DefIdSet { /// /// This uses FNV hashing, as described here: /// http://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function -#[derive(Clone, Copy, Default)] -pub struct FnvHasher; - #[allow(missing_copy_implementations)] -pub struct FnvState(u64); +pub struct FnvHasher(u64); -impl Hasher<FnvState> for FnvHasher { - fn hash<T: ?Sized + Hash<FnvState>>(&self, t: &T) -> u64 { - let mut state = FnvState(0xcbf29ce484222325); - t.hash(&mut state); - let FnvState(ret) = state; - return ret; - } +impl Default for FnvHasher { + fn default() -> FnvHasher { FnvHasher(0xcbf29ce484222325) } +} + +impl Hasher for FnvHasher { + type Output = u64; + fn reset(&mut self) { *self = Default::default(); } + fn finish(&self) -> u64 { self.0 } } -impl Writer for FnvState { +impl Writer for FnvHasher { fn write(&mut self, bytes: &[u8]) { - let FnvState(mut hash) = *self; + let FnvHasher(mut hash) = *self; for byte in bytes.iter() { hash = hash ^ (*byte as u64); hash = hash * 0x100000001b3; } - *self = FnvState(hash); + *self = FnvHasher(hash); } } diff --git a/src/librustc/util/ppaux.rs b/src/librustc/util/ppaux.rs index 2d433369366..559ec533baa 100644 --- a/src/librustc/util/ppaux.rs +++ b/src/librustc/util/ppaux.rs @@ -26,6 +26,7 @@ use middle::ty; use middle::ty_fold::TypeFoldable; use std::collections::HashMap; +use std::collections::hash_state::HashState; use std::hash::{Hash, Hasher}; use std::rc::Rc; use syntax::abi; @@ -55,12 +56,12 @@ pub fn note_and_explain_region(cx: &ctxt, (ref str, Some(span)) => { cx.sess.span_note( span, - format!("{}{}{}", prefix, *str, suffix).index(&FullRange)); + &format!("{}{}{}", prefix, *str, suffix)[]); Some(span) } (ref str, None) => { cx.sess.note( - format!("{}{}{}", prefix, *str, suffix).index(&FullRange)); + &format!("{}{}{}", prefix, *str, suffix)[]); None } } @@ -271,7 +272,7 @@ pub fn ty_to_string<'tcx>(cx: &ctxt<'tcx>, typ: &ty::TyS<'tcx>) -> String { }; if abi != abi::Rust { - s.push_str(format!("extern {} ", abi.to_string()).index(&FullRange)); + s.push_str(&format!("extern {} ", abi.to_string())[]); }; s.push_str("fn"); @@ -290,7 +291,7 @@ pub fn ty_to_string<'tcx>(cx: &ctxt<'tcx>, typ: &ty::TyS<'tcx>) -> String { Some(def_id) => { s.push_str(" {"); let path_str = ty::item_path_str(cx, def_id); - s.push_str(path_str.index(&FullRange)); + s.push_str(&path_str[]); s.push_str("}"); } None => { } @@ -305,7 +306,7 @@ pub fn ty_to_string<'tcx>(cx: &ctxt<'tcx>, typ: &ty::TyS<'tcx>) -> String { match cty.store { ty::UniqTraitStore => {} ty::RegionTraitStore(region, _) => { - s.push_str(region_to_string(cx, "", true, region).index(&FullRange)); + s.push_str(®ion_to_string(cx, "", true, region)[]); } } @@ -324,7 +325,7 @@ pub fn ty_to_string<'tcx>(cx: &ctxt<'tcx>, typ: &ty::TyS<'tcx>) -> String { assert_eq!(cty.onceness, ast::Once); s.push_str("proc"); push_sig_to_string(cx, &mut s, '(', ')', &cty.sig, - bounds_str.index(&FullRange)); + &bounds_str[]); } ty::RegionTraitStore(..) => { match cty.onceness { @@ -332,7 +333,7 @@ pub fn ty_to_string<'tcx>(cx: &ctxt<'tcx>, typ: &ty::TyS<'tcx>) -> String { ast::Once => s.push_str("once ") } push_sig_to_string(cx, &mut s, '|', '|', &cty.sig, - bounds_str.index(&FullRange)); + &bounds_str[]); } } @@ -365,7 +366,7 @@ pub fn ty_to_string<'tcx>(cx: &ctxt<'tcx>, typ: &ty::TyS<'tcx>) -> String { ty::FnConverging(t) => { if !ty::type_is_nil(t) { s.push_str(" -> "); - s.push_str(ty_to_string(cx, t).index(&FullRange)); + s.push_str(&ty_to_string(cx, t)[]); } } ty::FnDiverging => { @@ -402,7 +403,7 @@ pub fn ty_to_string<'tcx>(cx: &ctxt<'tcx>, typ: &ty::TyS<'tcx>) -> String { } ty_rptr(r, ref tm) => { let mut buf = region_ptr_to_string(cx, *r); - buf.push_str(mt_to_string(cx, tm).index(&FullRange)); + buf.push_str(&mt_to_string(cx, tm)[]); buf } ty_open(typ) => @@ -412,7 +413,7 @@ pub fn ty_to_string<'tcx>(cx: &ctxt<'tcx>, typ: &ty::TyS<'tcx>) -> String { .iter() .map(|elem| ty_to_string(cx, *elem)) .collect::<Vec<_>>(); - match strs.index(&FullRange) { + match &strs[] { [ref string] => format!("({},)", string), strs => format!("({})", strs.connect(", ")) } @@ -541,7 +542,7 @@ pub fn parameterized<'tcx>(cx: &ctxt<'tcx>, 0 }; - for t in tps.index(&(0..(tps.len() - num_defaults))).iter() { + for t in tps[0..(tps.len() - num_defaults)].iter() { strs.push(ty_to_string(cx, *t)) } @@ -549,11 +550,11 @@ pub fn parameterized<'tcx>(cx: &ctxt<'tcx>, format!("{}({}){}", base, if strs[0].starts_with("(") && strs[0].ends_with(",)") { - strs[0].index(&(1 .. (strs[0].len() - 2))) // Remove '(' and ',)' + &strs[0][1 .. (strs[0].len() - 2)] // Remove '(' and ',)' } else if strs[0].starts_with("(") && strs[0].ends_with(")") { - strs[0].index(&(1 .. (strs[0].len() - 1))) // Remove '(' and ')' + &strs[0][1 .. (strs[0].len() - 1)] // Remove '(' and ')' } else { - strs[0].index(&FullRange) + &strs[0][] }, if &*strs[1] == "()" { String::new() } else { format!(" -> {}", strs[1]) }) } else if strs.len() > 0 { @@ -566,7 +567,7 @@ pub fn parameterized<'tcx>(cx: &ctxt<'tcx>, pub fn ty_to_short_str<'tcx>(cx: &ctxt<'tcx>, typ: Ty<'tcx>) -> String { let mut s = typ.repr(cx).to_string(); if s.len() >= 32u { - s = s.index(&(0u..32u)).to_string(); + s = (&s[0u..32u]).to_string(); } return s; } @@ -631,7 +632,7 @@ impl<'tcx, T:Repr<'tcx>> Repr<'tcx> for [T] { impl<'tcx, T:Repr<'tcx>> Repr<'tcx> for OwnedSlice<T> { fn repr(&self, tcx: &ctxt<'tcx>) -> String { - repr_vec(tcx, self.index(&FullRange)) + repr_vec(tcx, &self[]) } } @@ -639,7 +640,7 @@ impl<'tcx, T:Repr<'tcx>> Repr<'tcx> for OwnedSlice<T> { // autoderef cannot convert the &[T] handler impl<'tcx, T:Repr<'tcx>> Repr<'tcx> for Vec<T> { fn repr(&self, tcx: &ctxt<'tcx>) -> String { - repr_vec(tcx, self.index(&FullRange)) + repr_vec(tcx, &self[]) } } @@ -1182,8 +1183,8 @@ impl<'tcx, T> UserString<'tcx> for ty::Binder<T> // the output. We'll probably want to tweak this over time to // decide just how much information to give. let mut names = Vec::new(); - let (unbound_value, _) = ty::replace_late_bound_regions(tcx, self, |br, debruijn| { - ty::ReLateBound(debruijn, match br { + let (unbound_value, _) = ty::replace_late_bound_regions(tcx, self, |br| { + ty::ReLateBound(ty::DebruijnIndex::new(1), match br { ty::BrNamed(_, name) => { names.push(token::get_name(name)); br @@ -1350,11 +1351,11 @@ impl<'tcx, T:Repr<'tcx>> Repr<'tcx> for ty::Binder<T> { } } -#[old_impl_check] -impl<'tcx, S, H, K, V> Repr<'tcx> for HashMap<K,V,H> - where K : Hash<S> + Eq + Repr<'tcx>, - V : Repr<'tcx>, - H : Hasher<S> +impl<'tcx, S, K, V> Repr<'tcx> for HashMap<K, V, S> + where K: Hash<<S as HashState>::Hasher> + Eq + Repr<'tcx>, + V: Repr<'tcx>, + S: HashState, + <S as HashState>::Hasher: Hasher<Output=u64>, { fn repr(&self, tcx: &ctxt<'tcx>) -> String { format!("HashMap({})", diff --git a/src/librustc/util/snapshot_vec.rs b/src/librustc/util/snapshot_vec.rs index d68b13aa2ff..8fc95529bc0 100644 --- a/src/librustc/util/snapshot_vec.rs +++ b/src/librustc/util/snapshot_vec.rs @@ -116,7 +116,7 @@ impl<T,U,D:SnapshotVecDelegate<T,U>> SnapshotVec<T,U,D> { pub fn actions_since_snapshot(&self, snapshot: &Snapshot) -> &[UndoLog<T,U>] { - self.undo_log.index(&(snapshot.length..)) + &self.undo_log[snapshot.length..] } fn assert_open_snapshot(&self, snapshot: &Snapshot) { diff --git a/src/librustc_back/archive.rs b/src/librustc_back/archive.rs index 48004acaac0..7ea192b8d6b 100644 --- a/src/librustc_back/archive.rs +++ b/src/librustc_back/archive.rs @@ -53,7 +53,7 @@ fn run_ar(handler: &ErrorHandler, maybe_ar_prog: &Option<String>, args: &str, cwd: Option<&Path>, paths: &[&Path]) -> ProcessOutput { let ar = match *maybe_ar_prog { - Some(ref ar) => ar.index(&FullRange), + Some(ref ar) => &ar[], None => "ar" }; let mut cmd = Command::new(ar); @@ -73,24 +73,21 @@ fn run_ar(handler: &ErrorHandler, maybe_ar_prog: &Option<String>, Ok(prog) => { let o = prog.wait_with_output().unwrap(); if !o.status.success() { - handler.err(format!("{} failed with: {}", + handler.err(&format!("{} failed with: {}", cmd, - o.status).index(&FullRange)); - handler.note(format!("stdout ---\n{}", - str::from_utf8(o.output - .index(&FullRange)).unwrap()) - .index(&FullRange)); - handler.note(format!("stderr ---\n{}", - str::from_utf8(o.error - .index(&FullRange)).unwrap()) - .index(&FullRange)); + o.status)[]); + handler.note(&format!("stdout ---\n{}", + str::from_utf8(&o.output[]).unwrap())[]); + handler.note(&format!("stderr ---\n{}", + str::from_utf8(&o.error[]).unwrap()) + []); handler.abort_if_errors(); } o }, Err(e) => { - handler.err(format!("could not exec `{}`: {}", ar.index(&FullRange), - e).index(&FullRange)); + handler.err(&format!("could not exec `{}`: {}", &ar[], + e)[]); handler.abort_if_errors(); panic!("rustc::back::archive::run_ar() should not reach this point"); } @@ -106,16 +103,16 @@ pub fn find_library(name: &str, osprefix: &str, ossuffix: &str, for path in search_paths.iter() { debug!("looking for {} inside {:?}", name, path.display()); - let test = path.join(oslibname.index(&FullRange)); + let test = path.join(&oslibname[]); if test.exists() { return test } if oslibname != unixlibname { - let test = path.join(unixlibname.index(&FullRange)); + let test = path.join(&unixlibname[]); if test.exists() { return test } } } - handler.fatal(format!("could not find native static library `{}`, \ + handler.fatal(&format!("could not find native static library `{}`, \ perhaps an -L flag is missing?", - name).index(&FullRange)); + name)[]); } impl<'a> Archive<'a> { @@ -147,7 +144,7 @@ impl<'a> Archive<'a> { /// Lists all files in an archive pub fn files(&self) -> Vec<String> { let output = run_ar(self.handler, &self.maybe_ar_prog, "t", None, &[&self.dst]); - let output = str::from_utf8(output.output.index(&FullRange)).unwrap(); + let output = str::from_utf8(&output.output[]).unwrap(); // use lines_any because windows delimits output with `\r\n` instead of // just `\n` output.lines_any().map(|s| s.to_string()).collect() @@ -179,9 +176,9 @@ impl<'a> ArchiveBuilder<'a> { /// search in the relevant locations for a library named `name`. pub fn add_native_library(&mut self, name: &str) -> io::IoResult<()> { let location = find_library(name, - self.archive.slib_prefix.index(&FullRange), - self.archive.slib_suffix.index(&FullRange), - self.archive.lib_search_paths.index(&FullRange), + &self.archive.slib_prefix[], + &self.archive.slib_suffix[], + &self.archive.lib_search_paths[], self.archive.handler); self.add_archive(&location, name, |_| false) } @@ -197,12 +194,12 @@ impl<'a> ArchiveBuilder<'a> { // as simple comparison is not enough - there // might be also an extra name suffix let obj_start = format!("{}", name); - let obj_start = obj_start.index(&FullRange); + let obj_start = &obj_start[]; // Ignoring all bytecode files, no matter of // name let bc_ext = ".bytecode.deflate"; - self.add_archive(rlib, name.index(&FullRange), |fname: &str| { + self.add_archive(rlib, &name[], |fname: &str| { let skip_obj = lto && fname.starts_with(obj_start) && fname.ends_with(".o"); skip_obj || fname.ends_with(bc_ext) || fname == METADATA_FILENAME @@ -239,7 +236,7 @@ impl<'a> ArchiveBuilder<'a> { // allow running `ar s file.a` to update symbols only. if self.should_update_symbols { run_ar(self.archive.handler, &self.archive.maybe_ar_prog, - "s", Some(self.work_dir.path()), args.index(&FullRange)); + "s", Some(self.work_dir.path()), &args[]); } return self.archive; } @@ -259,7 +256,7 @@ impl<'a> ArchiveBuilder<'a> { // Add the archive members seen so far, without updating the // symbol table (`S`). run_ar(self.archive.handler, &self.archive.maybe_ar_prog, - "cruS", Some(self.work_dir.path()), args.index(&FullRange)); + "cruS", Some(self.work_dir.path()), &args[]); args.clear(); args.push(&abs_dst); @@ -274,7 +271,7 @@ impl<'a> ArchiveBuilder<'a> { // necessary. let flags = if self.should_update_symbols { "crus" } else { "cruS" }; run_ar(self.archive.handler, &self.archive.maybe_ar_prog, - flags, Some(self.work_dir.path()), args.index(&FullRange)); + flags, Some(self.work_dir.path()), &args[]); self.archive } @@ -316,7 +313,7 @@ impl<'a> ArchiveBuilder<'a> { } else { filename }; - let new_filename = self.work_dir.path().join(filename.index(&FullRange)); + let new_filename = self.work_dir.path().join(&filename[]); try!(fs::rename(file, &new_filename)); self.members.push(Path::new(filename)); } diff --git a/src/librustc_back/lib.rs b/src/librustc_back/lib.rs index ca39477fbdc..fcd20158c0a 100644 --- a/src/librustc_back/lib.rs +++ b/src/librustc_back/lib.rs @@ -23,12 +23,14 @@ #![crate_name = "rustc_back"] #![experimental] +#![staged_api] #![crate_type = "dylib"] #![crate_type = "rlib"] #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png", html_favicon_url = "http://www.rust-lang.org/favicon.ico", html_root_url = "http://doc.rust-lang.org/nightly/")] -#![feature(slicing_syntax)] +#![allow(unknown_features)] +#![feature(slicing_syntax, box_syntax)] extern crate syntax; extern crate serialize; diff --git a/src/librustc_back/rpath.rs b/src/librustc_back/rpath.rs index db1dfa6b6ee..d24fd6a5b3f 100644 --- a/src/librustc_back/rpath.rs +++ b/src/librustc_back/rpath.rs @@ -44,15 +44,15 @@ pub fn get_rpath_flags<F, G>(config: RPathConfig<F, G>) -> Vec<String> where l.map(|p| p.clone()) }).collect::<Vec<_>>(); - let rpaths = get_rpaths(config, libs.index(&FullRange)); - flags.push_all(rpaths_to_flags(rpaths.index(&FullRange)).index(&FullRange)); + let rpaths = get_rpaths(config, &libs[]); + flags.push_all(&rpaths_to_flags(&rpaths[])[]); flags } fn rpaths_to_flags(rpaths: &[String]) -> Vec<String> { let mut ret = Vec::new(); for rpath in rpaths.iter() { - ret.push(format!("-Wl,-rpath,{}", (*rpath).index(&FullRange))); + ret.push(format!("-Wl,-rpath,{}", &(*rpath)[])); } return ret; } @@ -82,14 +82,14 @@ fn get_rpaths<F, G>(mut config: RPathConfig<F, G>, libs: &[Path]) -> Vec<String> } } - log_rpaths("relative", rel_rpaths.index(&FullRange)); - log_rpaths("fallback", fallback_rpaths.index(&FullRange)); + log_rpaths("relative", &rel_rpaths[]); + log_rpaths("fallback", &fallback_rpaths[]); let mut rpaths = rel_rpaths; - rpaths.push_all(fallback_rpaths.index(&FullRange)); + rpaths.push_all(&fallback_rpaths[]); // Remove duplicates - let rpaths = minimize_rpaths(rpaths.index(&FullRange)); + let rpaths = minimize_rpaths(&rpaths[]); return rpaths; } @@ -140,7 +140,7 @@ fn minimize_rpaths(rpaths: &[String]) -> Vec<String> { let mut set = HashSet::new(); let mut minimized = Vec::new(); for rpath in rpaths.iter() { - if set.insert(rpath.index(&FullRange)) { + if set.insert(&rpath[]) { minimized.push(rpath.clone()); } } diff --git a/src/librustc_back/sha2.rs b/src/librustc_back/sha2.rs index f33971a6ac0..ac5662f534c 100644 --- a/src/librustc_back/sha2.rs +++ b/src/librustc_back/sha2.rs @@ -140,7 +140,7 @@ impl FixedBuffer for FixedBuffer64 { if input.len() >= buffer_remaining { copy_memory( self.buffer.slice_mut(self.buffer_idx, size), - input.index(&(0..buffer_remaining))); + &input[0..buffer_remaining]); self.buffer_idx = 0; func(&self.buffer); i += buffer_remaining; @@ -156,7 +156,7 @@ impl FixedBuffer for FixedBuffer64 { // While we have at least a full buffer size chunk's worth of data, process that data // without copying it into the buffer while input.len() - i >= size { - func(input.index(&(i..(i + size)))); + func(&input[i..(i + size)]); i += size; } @@ -166,7 +166,7 @@ impl FixedBuffer for FixedBuffer64 { let input_remaining = input.len() - i; copy_memory( self.buffer.slice_to_mut(input_remaining), - input.index(&(i..))); + &input[i..]); self.buffer_idx += input_remaining; } @@ -188,7 +188,7 @@ impl FixedBuffer for FixedBuffer64 { fn full_buffer<'s>(&'s mut self) -> &'s [u8] { assert!(self.buffer_idx == 64); self.buffer_idx = 0; - return self.buffer.index(&(0..64)); + return &self.buffer[0..64]; } fn position(&self) -> uint { self.buffer_idx } diff --git a/src/librustc_back/svh.rs b/src/librustc_back/svh.rs index 863c1a7c865..4e260da2e4d 100644 --- a/src/librustc_back/svh.rs +++ b/src/librustc_back/svh.rs @@ -47,8 +47,7 @@ //! Original issue: https://github.com/rust-lang/rust/issues/10207 use std::fmt; -use std::hash::Hash; -use std::hash::sip::SipState; +use std::hash::{Hash, SipHasher, Hasher}; use std::iter::range_step; use syntax::ast; use syntax::visit; @@ -65,7 +64,7 @@ impl Svh { } pub fn as_str<'a>(&'a self) -> &'a str { - self.hash.index(&FullRange) + &self.hash[] } pub fn calculate(metadata: &Vec<String>, krate: &ast::Crate) -> Svh { @@ -78,7 +77,7 @@ impl Svh { // FIXME: this should use SHA1, not SipHash. SipHash is not built to // avoid collisions. - let mut state = SipState::new(); + let mut state = SipHasher::new(); for data in metadata.iter() { data.hash(&mut state); @@ -102,7 +101,7 @@ impl Svh { attr.node.value.hash(&mut state); } - let hash = state.result(); + let hash = state.finish(); return Svh { hash: range_step(0u, 64u, 4u).map(|i| hex(hash >> i)).collect() }; @@ -120,9 +119,7 @@ impl Svh { impl fmt::Show for Svh { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - //NOTE(stage0): uncomment after snapshot - //write!(f, "Svh {{ {} }}", self.as_str()) - fmt::String::fmt(self, f) + write!(f, "Svh {{ {} }}", self.as_str()) } } @@ -149,14 +146,13 @@ mod svh_visitor { use syntax::visit; use syntax::visit::{Visitor, FnKind}; - use std::hash::Hash; - use std::hash::sip::SipState; + use std::hash::{Hash, SipHasher}; pub struct StrictVersionHashVisitor<'a> { - pub st: &'a mut SipState, + pub st: &'a mut SipHasher, } - pub fn make<'a>(st: &'a mut SipState) -> StrictVersionHashVisitor<'a> { + pub fn make<'a>(st: &'a mut SipHasher) -> StrictVersionHashVisitor<'a> { StrictVersionHashVisitor { st: st } } @@ -366,7 +362,7 @@ mod svh_visitor { fn macro_name(mac: &Mac) -> token::InternedString { match &mac.node { &MacInvocTT(ref path, ref _tts, ref _stx_ctxt) => { - let s = path.segments.index(&FullRange); + let s = &path.segments[]; assert_eq!(s.len(), 1); content(s[0].identifier) } @@ -400,7 +396,7 @@ mod svh_visitor { } // All of the remaining methods just record (in the hash - // SipState) that the visitor saw that particular variant + // SipHasher) that the visitor saw that particular variant // (with its payload), and continue walking as the default // visitor would. // diff --git a/src/librustc_back/target/aarch64_unknown_linux_gnu.rs b/src/librustc_back/target/aarch64_unknown_linux_gnu.rs index 296552a6abd..a3ef6372f06 100644 --- a/src/librustc_back/target/aarch64_unknown_linux_gnu.rs +++ b/src/librustc_back/target/aarch64_unknown_linux_gnu.rs @@ -18,7 +18,7 @@ pub fn target() -> Target { n32:64-S128".to_string(), llvm_target: "aarch64-unknown-linux-gnu".to_string(), target_endian: "little".to_string(), - target_word_size: "64".to_string(), + target_pointer_width: "64".to_string(), arch: "aarch64".to_string(), target_os: "linux".to_string(), options: base, diff --git a/src/librustc_back/target/arm_apple_ios.rs b/src/librustc_back/target/arm_apple_ios.rs index 8bb64eae625..e0afef6e390 100644 --- a/src/librustc_back/target/arm_apple_ios.rs +++ b/src/librustc_back/target/arm_apple_ios.rs @@ -19,7 +19,7 @@ pub fn target() -> Target { -a:0:64-n32".to_string(), llvm_target: "arm-apple-ios".to_string(), target_endian: "little".to_string(), - target_word_size: "32".to_string(), + target_pointer_width: "32".to_string(), arch: "arm".to_string(), target_os: "ios".to_string(), options: TargetOptions { diff --git a/src/librustc_back/target/arm_linux_androideabi.rs b/src/librustc_back/target/arm_linux_androideabi.rs index ecfb1667f60..6fc77a715a5 100644 --- a/src/librustc_back/target/arm_linux_androideabi.rs +++ b/src/librustc_back/target/arm_linux_androideabi.rs @@ -27,7 +27,7 @@ pub fn target() -> Target { -a:0:64-n32".to_string(), llvm_target: "arm-linux-androideabi".to_string(), target_endian: "little".to_string(), - target_word_size: "32".to_string(), + target_pointer_width: "32".to_string(), arch: "arm".to_string(), target_os: "android".to_string(), options: base, diff --git a/src/librustc_back/target/arm_unknown_linux_gnueabi.rs b/src/librustc_back/target/arm_unknown_linux_gnueabi.rs index 985af35e145..32eccaf54b0 100644 --- a/src/librustc_back/target/arm_unknown_linux_gnueabi.rs +++ b/src/librustc_back/target/arm_unknown_linux_gnueabi.rs @@ -20,7 +20,7 @@ pub fn target() -> Target { -a:0:64-n32".to_string(), llvm_target: "arm-unknown-linux-gnueabi".to_string(), target_endian: "little".to_string(), - target_word_size: "32".to_string(), + target_pointer_width: "32".to_string(), arch: "arm".to_string(), target_os: "linux".to_string(), diff --git a/src/librustc_back/target/arm_unknown_linux_gnueabihf.rs b/src/librustc_back/target/arm_unknown_linux_gnueabihf.rs index 3cf0c312820..eff3601250f 100644 --- a/src/librustc_back/target/arm_unknown_linux_gnueabihf.rs +++ b/src/librustc_back/target/arm_unknown_linux_gnueabihf.rs @@ -20,7 +20,7 @@ pub fn target() -> Target { -a:0:64-n32".to_string(), llvm_target: "arm-unknown-linux-gnueabihf".to_string(), target_endian: "little".to_string(), - target_word_size: "32".to_string(), + target_pointer_width: "32".to_string(), arch: "arm".to_string(), target_os: "linux".to_string(), diff --git a/src/librustc_back/target/i386_apple_ios.rs b/src/librustc_back/target/i386_apple_ios.rs index 45669bc9585..a1fcc9ac53f 100644 --- a/src/librustc_back/target/i386_apple_ios.rs +++ b/src/librustc_back/target/i386_apple_ios.rs @@ -19,7 +19,7 @@ pub fn target() -> Target { -n8:16:32".to_string(), llvm_target: "i386-apple-ios".to_string(), target_endian: "little".to_string(), - target_word_size: "32".to_string(), + target_pointer_width: "32".to_string(), arch: "x86".to_string(), target_os: "ios".to_string(), diff --git a/src/librustc_back/target/i686_apple_darwin.rs b/src/librustc_back/target/i686_apple_darwin.rs index feef5b98dcb..1b079323bf9 100644 --- a/src/librustc_back/target/i686_apple_darwin.rs +++ b/src/librustc_back/target/i686_apple_darwin.rs @@ -22,7 +22,7 @@ pub fn target() -> Target { -n8:16:32".to_string(), llvm_target: "i686-apple-darwin".to_string(), target_endian: "little".to_string(), - target_word_size: "32".to_string(), + target_pointer_width: "32".to_string(), arch: "x86".to_string(), target_os: "macos".to_string(), options: base, diff --git a/src/librustc_back/target/i686_pc_windows_gnu.rs b/src/librustc_back/target/i686_pc_windows_gnu.rs index 4d75590e664..c2ab68ee052 100644 --- a/src/librustc_back/target/i686_pc_windows_gnu.rs +++ b/src/librustc_back/target/i686_pc_windows_gnu.rs @@ -26,7 +26,7 @@ pub fn target() -> Target { data_layout: "e-p:32:32-f64:64:64-i64:64:64-f80:32:32-n8:16:32".to_string(), llvm_target: "i686-pc-windows-gnu".to_string(), target_endian: "little".to_string(), - target_word_size: "32".to_string(), + target_pointer_width: "32".to_string(), arch: "x86".to_string(), target_os: "windows".to_string(), options: options, diff --git a/src/librustc_back/target/i686_unknown_dragonfly.rs b/src/librustc_back/target/i686_unknown_dragonfly.rs index a12657ff4dc..7910eba7ea1 100644 --- a/src/librustc_back/target/i686_unknown_dragonfly.rs +++ b/src/librustc_back/target/i686_unknown_dragonfly.rs @@ -18,7 +18,7 @@ pub fn target() -> Target { data_layout: "e-p:32:32-f64:32:64-i64:32:64-f80:32:32-n8:16:32".to_string(), llvm_target: "i686-unknown-dragonfly".to_string(), target_endian: "little".to_string(), - target_word_size: "32".to_string(), + target_pointer_width: "32".to_string(), arch: "x86".to_string(), target_os: "dragonfly".to_string(), options: base, diff --git a/src/librustc_back/target/i686_unknown_linux_gnu.rs b/src/librustc_back/target/i686_unknown_linux_gnu.rs index 1a4560d5cd5..c93a564fef5 100644 --- a/src/librustc_back/target/i686_unknown_linux_gnu.rs +++ b/src/librustc_back/target/i686_unknown_linux_gnu.rs @@ -18,7 +18,7 @@ pub fn target() -> Target { data_layout: "e-p:32:32-f64:32:64-i64:32:64-f80:32:32-n8:16:32".to_string(), llvm_target: "i686-unknown-linux-gnu".to_string(), target_endian: "little".to_string(), - target_word_size: "32".to_string(), + target_pointer_width: "32".to_string(), arch: "x86".to_string(), target_os: "linux".to_string(), options: base, diff --git a/src/librustc_back/target/mips_unknown_linux_gnu.rs b/src/librustc_back/target/mips_unknown_linux_gnu.rs index c8c5ddcbd0d..8acc248e234 100644 --- a/src/librustc_back/target/mips_unknown_linux_gnu.rs +++ b/src/librustc_back/target/mips_unknown_linux_gnu.rs @@ -19,7 +19,7 @@ pub fn target() -> Target { -a:0:64-n32".to_string(), llvm_target: "mips-unknown-linux-gnu".to_string(), target_endian: "big".to_string(), - target_word_size: "32".to_string(), + target_pointer_width: "32".to_string(), arch: "mips".to_string(), target_os: "linux".to_string(), options: super::linux_base::opts() diff --git a/src/librustc_back/target/mipsel_unknown_linux_gnu.rs b/src/librustc_back/target/mipsel_unknown_linux_gnu.rs index 3571f7b26c0..604c62eb69f 100644 --- a/src/librustc_back/target/mipsel_unknown_linux_gnu.rs +++ b/src/librustc_back/target/mipsel_unknown_linux_gnu.rs @@ -19,7 +19,7 @@ pub fn target() -> Target { -a:0:64-n32".to_string(), llvm_target: "mipsel-unknown-linux-gnu".to_string(), target_endian: "little".to_string(), - target_word_size: "32".to_string(), + target_pointer_width: "32".to_string(), arch: "mips".to_string(), target_os: "linux".to_string(), diff --git a/src/librustc_back/target/mod.rs b/src/librustc_back/target/mod.rs index 23c8fc7de51..069e798887b 100644 --- a/src/librustc_back/target/mod.rs +++ b/src/librustc_back/target/mod.rs @@ -85,8 +85,8 @@ pub struct Target { pub llvm_target: String, /// String to use as the `target_endian` `cfg` variable. pub target_endian: String, - /// String to use as the `target_word_size` `cfg` variable. - pub target_word_size: String, + /// String to use as the `target_pointer_width` `cfg` variable. + pub target_pointer_width: String, /// OS name to use for conditional compilation. pub target_os: String, /// Architecture to use for ABI considerations. Valid options: "x86", "x86_64", "arm", @@ -224,8 +224,7 @@ impl Target { .and_then(|os| os.map(|s| s.to_string())) { Some(val) => val, None => - handler.fatal((format!("Field {} in target specification is required", name)) - .index(&FullRange)) + handler.fatal(&format!("Field {} in target specification is required", name)[]) } }; @@ -233,7 +232,7 @@ impl Target { data_layout: get_req_field("data-layout"), llvm_target: get_req_field("llvm-target"), target_endian: get_req_field("target-endian"), - target_word_size: get_req_field("target-word-size"), + target_pointer_width: get_req_field("target-word-size"), arch: get_req_field("arch"), target_os: get_req_field("os"), options: Default::default(), @@ -242,18 +241,18 @@ impl Target { macro_rules! key { ($key_name:ident) => ( { let name = (stringify!($key_name)).replace("_", "-"); - obj.find(name.index(&FullRange)).map(|o| o.as_string() + obj.find(&name[]).map(|o| o.as_string() .map(|s| base.options.$key_name = s.to_string())); } ); ($key_name:ident, bool) => ( { let name = (stringify!($key_name)).replace("_", "-"); - obj.find(name.index(&FullRange)) + obj.find(&name[]) .map(|o| o.as_boolean() .map(|s| base.options.$key_name = s)); } ); ($key_name:ident, list) => ( { let name = (stringify!($key_name)).replace("_", "-"); - obj.find(name.index(&FullRange)).map(|o| o.as_array() + obj.find(&name[]).map(|o| o.as_array() .map(|v| base.options.$key_name = v.iter() .map(|a| a.as_string().unwrap().to_string()).collect() ) @@ -369,7 +368,7 @@ impl Target { let target_path = os::getenv("RUST_TARGET_PATH").unwrap_or(String::new()); - let paths = os::split_paths(target_path.index(&FullRange)); + let paths = os::split_paths(&target_path[]); // FIXME 16351: add a sane default search path? for dir in paths.iter() { diff --git a/src/librustc_back/target/x86_64_apple_darwin.rs b/src/librustc_back/target/x86_64_apple_darwin.rs index 07e6cdfed2c..0ebd3bd3215 100644 --- a/src/librustc_back/target/x86_64_apple_darwin.rs +++ b/src/librustc_back/target/x86_64_apple_darwin.rs @@ -21,7 +21,7 @@ pub fn target() -> Target { s0:64:64-f80:128:128-n8:16:32:64".to_string(), llvm_target: "x86_64-apple-darwin".to_string(), target_endian: "little".to_string(), - target_word_size: "64".to_string(), + target_pointer_width: "64".to_string(), arch: "x86_64".to_string(), target_os: "macos".to_string(), options: base, diff --git a/src/librustc_back/target/x86_64_pc_windows_gnu.rs b/src/librustc_back/target/x86_64_pc_windows_gnu.rs index 6ca74eb7fc0..9e1294a8962 100644 --- a/src/librustc_back/target/x86_64_pc_windows_gnu.rs +++ b/src/librustc_back/target/x86_64_pc_windows_gnu.rs @@ -23,7 +23,7 @@ pub fn target() -> Target { s0:64:64-f80:128:128-n8:16:32:64-S128".to_string(), llvm_target: "x86_64-pc-windows-gnu".to_string(), target_endian: "little".to_string(), - target_word_size: "64".to_string(), + target_pointer_width: "64".to_string(), arch: "x86_64".to_string(), target_os: "windows".to_string(), options: base, diff --git a/src/librustc_back/target/x86_64_unknown_dragonfly.rs b/src/librustc_back/target/x86_64_unknown_dragonfly.rs index bff3eaf6bc8..6635306b0e1 100644 --- a/src/librustc_back/target/x86_64_unknown_dragonfly.rs +++ b/src/librustc_back/target/x86_64_unknown_dragonfly.rs @@ -20,7 +20,7 @@ pub fn target() -> Target { s0:64:64-f80:128:128-n8:16:32:64-S128".to_string(), llvm_target: "x86_64-unknown-dragonfly".to_string(), target_endian: "little".to_string(), - target_word_size: "64".to_string(), + target_pointer_width: "64".to_string(), arch: "x86_64".to_string(), target_os: "dragonfly".to_string(), options: base, diff --git a/src/librustc_back/target/x86_64_unknown_freebsd.rs b/src/librustc_back/target/x86_64_unknown_freebsd.rs index 8d5603a3878..2aba2b8defb 100644 --- a/src/librustc_back/target/x86_64_unknown_freebsd.rs +++ b/src/librustc_back/target/x86_64_unknown_freebsd.rs @@ -20,7 +20,7 @@ pub fn target() -> Target { s0:64:64-f80:128:128-n8:16:32:64-S128".to_string(), llvm_target: "x86_64-unknown-freebsd".to_string(), target_endian: "little".to_string(), - target_word_size: "64".to_string(), + target_pointer_width: "64".to_string(), arch: "x86_64".to_string(), target_os: "freebsd".to_string(), options: base, diff --git a/src/librustc_back/target/x86_64_unknown_linux_gnu.rs b/src/librustc_back/target/x86_64_unknown_linux_gnu.rs index e0a67cd6250..d7a6df3a8b0 100644 --- a/src/librustc_back/target/x86_64_unknown_linux_gnu.rs +++ b/src/librustc_back/target/x86_64_unknown_linux_gnu.rs @@ -20,7 +20,7 @@ pub fn target() -> Target { s0:64:64-f80:128:128-n8:16:32:64-S128".to_string(), llvm_target: "x86_64-unknown-linux-gnu".to_string(), target_endian: "little".to_string(), - target_word_size: "64".to_string(), + target_pointer_width: "64".to_string(), arch: "x86_64".to_string(), target_os: "linux".to_string(), options: base, diff --git a/src/librustc_borrowck/borrowck/check_loans.rs b/src/librustc_borrowck/borrowck/check_loans.rs index d942581ca62..d5ad201eabf 100644 --- a/src/librustc_borrowck/borrowck/check_loans.rs +++ b/src/librustc_borrowck/borrowck/check_loans.rs @@ -463,38 +463,38 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> { (ty::MutBorrow, ty::MutBorrow) => { self.bccx.span_err( new_loan.span, - format!("cannot borrow `{}`{} as mutable \ + &format!("cannot borrow `{}`{} as mutable \ more than once at a time", - nl, new_loan_msg).index(&FullRange)) + nl, new_loan_msg)[]) } (ty::UniqueImmBorrow, _) => { self.bccx.span_err( new_loan.span, - format!("closure requires unique access to `{}` \ + &format!("closure requires unique access to `{}` \ but {} is already borrowed{}", - nl, ol_pronoun, old_loan_msg).index(&FullRange)); + nl, ol_pronoun, old_loan_msg)[]); } (_, ty::UniqueImmBorrow) => { self.bccx.span_err( new_loan.span, - format!("cannot borrow `{}`{} as {} because \ + &format!("cannot borrow `{}`{} as {} because \ previous closure requires unique access", - nl, new_loan_msg, new_loan.kind.to_user_str()).index(&FullRange)); + nl, new_loan_msg, new_loan.kind.to_user_str())[]); } (_, _) => { self.bccx.span_err( new_loan.span, - format!("cannot borrow `{}`{} as {} because \ + &format!("cannot borrow `{}`{} as {} because \ {} is also borrowed as {}{}", nl, new_loan_msg, new_loan.kind.to_user_str(), ol_pronoun, old_loan.kind.to_user_str(), - old_loan_msg).index(&FullRange)); + old_loan_msg)[]); } } @@ -502,8 +502,8 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> { euv::ClosureCapture(span) => { self.bccx.span_note( span, - format!("borrow occurs due to use of `{}` in closure", - nl).index(&FullRange)); + &format!("borrow occurs due to use of `{}` in closure", + nl)[]); } _ => { } } @@ -552,7 +552,7 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> { self.bccx.span_note( old_loan.span, - format!("{}; {}", borrow_summary, rule_summary).index(&FullRange)); + &format!("{}; {}", borrow_summary, rule_summary)[]); let old_loan_span = self.tcx().map.span(old_loan.kill_scope.node_id()); self.bccx.span_end_note(old_loan_span, @@ -621,14 +621,14 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> { UseWhileBorrowed(loan_path, loan_span) => { self.bccx.span_err( span, - format!("cannot use `{}` because it was mutably borrowed", - self.bccx.loan_path_to_string(copy_path).index(&FullRange)) - .index(&FullRange)); + &format!("cannot use `{}` because it was mutably borrowed", + &self.bccx.loan_path_to_string(copy_path)[]) + []); self.bccx.span_note( loan_span, - format!("borrow of `{}` occurs here", - self.bccx.loan_path_to_string(&*loan_path).index(&FullRange)) - .index(&FullRange)); + &format!("borrow of `{}` occurs here", + &self.bccx.loan_path_to_string(&*loan_path)[]) + []); } } } @@ -647,20 +647,20 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> { let err_message = match move_kind { move_data::Captured => format!("cannot move `{}` into closure because it is borrowed", - self.bccx.loan_path_to_string(move_path).index(&FullRange)), + &self.bccx.loan_path_to_string(move_path)[]), move_data::Declared | move_data::MoveExpr | move_data::MovePat => format!("cannot move out of `{}` because it is borrowed", - self.bccx.loan_path_to_string(move_path).index(&FullRange)) + &self.bccx.loan_path_to_string(move_path)[]) }; - self.bccx.span_err(span, err_message.index(&FullRange)); + self.bccx.span_err(span, &err_message[]); self.bccx.span_note( loan_span, - format!("borrow of `{}` occurs here", - self.bccx.loan_path_to_string(&*loan_path).index(&FullRange)) - .index(&FullRange)); + &format!("borrow of `{}` occurs here", + &self.bccx.loan_path_to_string(&*loan_path)[]) + []); } } } @@ -809,34 +809,34 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> { if kind == ty::FnUnboxedClosureKind { self.bccx.span_err( assignment_span, - format!("cannot assign to {}", - self.bccx.cmt_to_string(&*assignee_cmt)).index(&FullRange)); + &format!("cannot assign to {}", + self.bccx.cmt_to_string(&*assignee_cmt))[]); self.bccx.span_help( self.tcx().map.span(upvar_id.closure_expr_id), "consider changing this closure to take self by mutable reference"); } else { self.bccx.span_err( assignment_span, - format!("cannot assign to {} {}", + &format!("cannot assign to {} {}", assignee_cmt.mutbl.to_user_str(), - self.bccx.cmt_to_string(&*assignee_cmt)).index(&FullRange)); + self.bccx.cmt_to_string(&*assignee_cmt))[]); } } _ => match opt_loan_path(&assignee_cmt) { Some(lp) => { self.bccx.span_err( assignment_span, - format!("cannot assign to {} {} `{}`", + &format!("cannot assign to {} {} `{}`", assignee_cmt.mutbl.to_user_str(), self.bccx.cmt_to_string(&*assignee_cmt), - self.bccx.loan_path_to_string(&*lp)).index(&FullRange)); + self.bccx.loan_path_to_string(&*lp))[]); } None => { self.bccx.span_err( assignment_span, - format!("cannot assign to {} {}", + &format!("cannot assign to {} {}", assignee_cmt.mutbl.to_user_str(), - self.bccx.cmt_to_string(&*assignee_cmt)).index(&FullRange)); + self.bccx.cmt_to_string(&*assignee_cmt))[]); } } } @@ -955,11 +955,11 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> { loan: &Loan) { self.bccx.span_err( span, - format!("cannot assign to `{}` because it is borrowed", - self.bccx.loan_path_to_string(loan_path)).index(&FullRange)); + &format!("cannot assign to `{}` because it is borrowed", + self.bccx.loan_path_to_string(loan_path))[]); self.bccx.span_note( loan.span, - format!("borrow of `{}` occurs here", - self.bccx.loan_path_to_string(loan_path)).index(&FullRange)); + &format!("borrow of `{}` occurs here", + self.bccx.loan_path_to_string(loan_path))[]); } } diff --git a/src/librustc_borrowck/borrowck/fragments.rs b/src/librustc_borrowck/borrowck/fragments.rs index d7527487465..1b120208217 100644 --- a/src/librustc_borrowck/borrowck/fragments.rs +++ b/src/librustc_borrowck/borrowck/fragments.rs @@ -38,7 +38,7 @@ enum Fragment { // This represents the collection of all but one of the elements // from an array at the path described by the move path index. // Note that attached MovePathIndex should have mem_categorization - // of InteriorElement (i.e. array dereference `.index(&FullRange)`). + // of InteriorElement (i.e. array dereference `&foo[]`). AllButOneFrom(MovePathIndex), } @@ -123,12 +123,12 @@ pub fn instrument_move_fragments<'tcx>(this: &MoveData<'tcx>, let attrs : &[ast::Attribute]; attrs = match tcx.map.find(id) { Some(ast_map::NodeItem(ref item)) => - item.attrs.index(&FullRange), + &item.attrs[], Some(ast_map::NodeImplItem(&ast::MethodImplItem(ref m))) => - m.attrs.index(&FullRange), + &m.attrs[], Some(ast_map::NodeTraitItem(&ast::ProvidedMethod(ref m))) => - m.attrs.index(&FullRange), - _ => [].index(&FullRange), + &m.attrs[], + _ => &[][], }; let span_err = @@ -144,7 +144,7 @@ pub fn instrument_move_fragments<'tcx>(this: &MoveData<'tcx>, for (i, mpi) in vec_rc.iter().enumerate() { let render = |&:| this.path_loan_path(*mpi).user_string(tcx); if span_err { - tcx.sess.span_err(sp, format!("{}: `{}`", kind, render()).index(&FullRange)); + tcx.sess.span_err(sp, &format!("{}: `{}`", kind, render())[]); } if print { println!("id:{} {}[{}] `{}`", id, kind, i, render()); @@ -156,7 +156,7 @@ pub fn instrument_move_fragments<'tcx>(this: &MoveData<'tcx>, for (i, f) in vec_rc.iter().enumerate() { let render = |&:| f.loan_path_user_string(this, tcx); if span_err { - tcx.sess.span_err(sp, format!("{}: `{}`", kind, render()).index(&FullRange)); + tcx.sess.span_err(sp, &format!("{}: `{}`", kind, render())[]); } if print { println!("id:{} {}[{}] `{}`", id, kind, i, render()); @@ -198,11 +198,11 @@ pub fn fixup_fragment_sets<'tcx>(this: &MoveData<'tcx>, tcx: &ty::ctxt<'tcx>) { // First, filter out duplicates moved.sort(); moved.dedup(); - debug!("fragments 1 moved: {:?}", path_lps(moved.index(&FullRange))); + debug!("fragments 1 moved: {:?}", path_lps(&moved[])); assigned.sort(); assigned.dedup(); - debug!("fragments 1 assigned: {:?}", path_lps(assigned.index(&FullRange))); + debug!("fragments 1 assigned: {:?}", path_lps(&assigned[])); // Second, build parents from the moved and assigned. for m in moved.iter() { @@ -222,14 +222,14 @@ pub fn fixup_fragment_sets<'tcx>(this: &MoveData<'tcx>, tcx: &ty::ctxt<'tcx>) { parents.sort(); parents.dedup(); - debug!("fragments 2 parents: {:?}", path_lps(parents.index(&FullRange))); + debug!("fragments 2 parents: {:?}", path_lps(&parents[])); // Third, filter the moved and assigned fragments down to just the non-parents - moved.retain(|f| non_member(*f, parents.index(&FullRange))); - debug!("fragments 3 moved: {:?}", path_lps(moved.index(&FullRange))); + moved.retain(|f| non_member(*f, &parents[])); + debug!("fragments 3 moved: {:?}", path_lps(&moved[])); - assigned.retain(|f| non_member(*f, parents.index(&FullRange))); - debug!("fragments 3 assigned: {:?}", path_lps(assigned.index(&FullRange))); + assigned.retain(|f| non_member(*f, &parents[])); + debug!("fragments 3 assigned: {:?}", path_lps(&assigned[])); // Fourth, build the leftover from the moved, assigned, and parents. for m in moved.iter() { @@ -247,16 +247,16 @@ pub fn fixup_fragment_sets<'tcx>(this: &MoveData<'tcx>, tcx: &ty::ctxt<'tcx>) { unmoved.sort(); unmoved.dedup(); - debug!("fragments 4 unmoved: {:?}", frag_lps(unmoved.index(&FullRange))); + debug!("fragments 4 unmoved: {:?}", frag_lps(&unmoved[])); // Fifth, filter the leftover fragments down to its core. unmoved.retain(|f| match *f { AllButOneFrom(_) => true, - Just(mpi) => non_member(mpi, parents.index(&FullRange)) && - non_member(mpi, moved.index(&FullRange)) && - non_member(mpi, assigned.index(&FullRange)) + Just(mpi) => non_member(mpi, &parents[]) && + non_member(mpi, &moved[]) && + non_member(mpi, &assigned[]) }); - debug!("fragments 5 unmoved: {:?}", frag_lps(unmoved.index(&FullRange))); + debug!("fragments 5 unmoved: {:?}", frag_lps(&unmoved[])); // Swap contents back in. fragments.unmoved_fragments = unmoved; @@ -433,7 +433,7 @@ fn add_fragment_siblings_for_extension<'tcx>(this: &MoveData<'tcx>, let msg = format!("type {} ({:?}) is not fragmentable", parent_ty.repr(tcx), sty_and_variant_info); let opt_span = origin_id.and_then(|id|tcx.map.opt_span(id)); - tcx.sess.opt_span_bug(opt_span, msg.index(&FullRange)) + tcx.sess.opt_span_bug(opt_span, &msg[]) } } } diff --git a/src/librustc_borrowck/borrowck/gather_loans/mod.rs b/src/librustc_borrowck/borrowck/gather_loans/mod.rs index 2c48e0da01d..889a359b019 100644 --- a/src/librustc_borrowck/borrowck/gather_loans/mod.rs +++ b/src/librustc_borrowck/borrowck/gather_loans/mod.rs @@ -306,8 +306,8 @@ impl<'a, 'tcx> GatherLoanCtxt<'a, 'tcx> { ty::ReInfer(..) => { self.tcx().sess.span_bug( cmt.span, - format!("invalid borrow lifetime: {:?}", - loan_region).index(&FullRange)); + &format!("invalid borrow lifetime: {:?}", + loan_region)[]); } }; debug!("loan_scope = {:?}", loan_scope); diff --git a/src/librustc_borrowck/borrowck/gather_loans/move_error.rs b/src/librustc_borrowck/borrowck/gather_loans/move_error.rs index 1bb143e1dc8..a7771fefec4 100644 --- a/src/librustc_borrowck/borrowck/gather_loans/move_error.rs +++ b/src/librustc_borrowck/borrowck/gather_loans/move_error.rs @@ -119,8 +119,8 @@ fn report_cannot_move_out_of<'a, 'tcx>(bccx: &BorrowckCtxt<'a, 'tcx>, mc::cat_static_item => { bccx.span_err( move_from.span, - format!("cannot move out of {}", - bccx.cmt_to_string(&*move_from)).index(&FullRange)); + &format!("cannot move out of {}", + bccx.cmt_to_string(&*move_from))[]); } mc::cat_downcast(ref b, _) | @@ -130,9 +130,9 @@ fn report_cannot_move_out_of<'a, 'tcx>(bccx: &BorrowckCtxt<'a, 'tcx>, | ty::ty_enum(did, _) if ty::has_dtor(bccx.tcx, did) => { bccx.span_err( move_from.span, - format!("cannot move out of type `{}`, \ + &format!("cannot move out of type `{}`, \ which defines the `Drop` trait", - b.ty.user_string(bccx.tcx)).index(&FullRange)); + b.ty.user_string(bccx.tcx))[]); }, _ => panic!("this path should not cause illegal move") } @@ -152,13 +152,13 @@ fn note_move_destination(bccx: &BorrowckCtxt, "attempting to move value to here"); bccx.span_help( move_to_span, - format!("to prevent the move, \ + &format!("to prevent the move, \ use `ref {0}` or `ref mut {0}` to capture value by \ reference", - pat_name).index(&FullRange)); + pat_name)[]); } else { bccx.span_note(move_to_span, - format!("and here (use `ref {0}` or `ref mut {0}`)", - pat_name).index(&FullRange)); + &format!("and here (use `ref {0}` or `ref mut {0}`)", + pat_name)[]); } } diff --git a/src/librustc_borrowck/borrowck/mod.rs b/src/librustc_borrowck/borrowck/mod.rs index 88f56f68622..e734e8fb6ff 100644 --- a/src/librustc_borrowck/borrowck/mod.rs +++ b/src/librustc_borrowck/borrowck/mod.rs @@ -137,7 +137,7 @@ fn borrowck_fn(this: &mut BorrowckCtxt, check_loans::check_loans(this, &loan_dfcx, flowed_moves, - all_loans.index(&FullRange), + &all_loans[], id, decl, body); @@ -505,7 +505,7 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> { pub fn report(&self, err: BckError<'tcx>) { self.span_err( err.span, - self.bckerr_to_string(&err).index(&FullRange)); + &self.bckerr_to_string(&err)[]); self.note_and_explain_bckerr(err); } @@ -525,9 +525,9 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> { move_data::Declared => { self.tcx.sess.span_err( use_span, - format!("{} of possibly uninitialized variable: `{}`", + &format!("{} of possibly uninitialized variable: `{}`", verb, - self.loan_path_to_string(lp)).index(&FullRange)); + self.loan_path_to_string(lp))[]); (self.loan_path_to_string(moved_lp), String::new()) } @@ -566,10 +566,10 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> { else { "" }; self.tcx.sess.span_err( use_span, - format!("{} of {}moved value: `{}`", + &format!("{} of {}moved value: `{}`", verb, msg, - nl).index(&FullRange)); + nl)[]); (ol, moved_lp_msg) } }; @@ -585,32 +585,32 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> { (ty::expr_ty_adjusted(self.tcx, &*expr), expr.span) } r => { - self.tcx.sess.bug(format!("MoveExpr({}) maps to \ + self.tcx.sess.bug(&format!("MoveExpr({}) maps to \ {:?}, not Expr", the_move.id, - r).index(&FullRange)) + r)[]) } }; 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 {}", + &format!("`{}` moved here{} because it has type `{}`, which is {}", ol, moved_lp_msg, expr_ty.user_string(self.tcx), - suggestion).index(&FullRange)); + suggestion)[]); } move_data::MovePat => { let pat_ty = ty::node_id_to_type(self.tcx, the_move.id); let span = self.tcx.map.span(the_move.id); self.tcx.sess.span_note(span, - format!("`{}` moved here{} because it has type `{}`, \ + &format!("`{}` moved here{} because it has type `{}`, \ which is moved by default", ol, moved_lp_msg, - pat_ty.user_string(self.tcx)).index(&FullRange)); + pat_ty.user_string(self.tcx))[]); self.tcx.sess.span_help(span, "use `ref` to override"); } @@ -623,10 +623,10 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> { (ty::expr_ty_adjusted(self.tcx, &*expr), expr.span) } r => { - self.tcx.sess.bug(format!("Captured({}) maps to \ + self.tcx.sess.bug(&format!("Captured({}) maps to \ {:?}, not Expr", the_move.id, - r).index(&FullRange)) + r)[]) } }; let (suggestion, help) = @@ -637,12 +637,12 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> { "make a copy and capture that instead to override")); self.tcx.sess.span_note( expr_span, - format!("`{}` moved into closure environment here{} because it \ + &format!("`{}` moved into closure environment here{} because it \ has type `{}`, which is {}", ol, moved_lp_msg, expr_ty.user_string(self.tcx), - suggestion).index(&FullRange)); + suggestion)[]); self.tcx.sess.span_help(expr_span, help); } } @@ -672,8 +672,8 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> { &move_data::Assignment) { self.tcx.sess.span_err( span, - format!("re-assignment of immutable variable `{}`", - self.loan_path_to_string(lp)).index(&FullRange)); + &format!("re-assignment of immutable variable `{}`", + self.loan_path_to_string(lp))[]); self.tcx.sess.span_note(assign.span, "prior assignment occurs here"); } @@ -798,8 +798,8 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> { mc::AliasableOther => { self.tcx.sess.span_err( span, - format!("{} in an aliasable location", - prefix).index(&FullRange)); + &format!("{} in an aliasable location", + prefix)[]); } mc::AliasableClosure(id) => { self.tcx.sess.span_err(span, @@ -812,12 +812,12 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> { mc::AliasableStaticMut(..) => { self.tcx.sess.span_err( span, - format!("{} in a static location", prefix).index(&FullRange)); + &format!("{} in a static location", prefix)[]); } mc::AliasableBorrowed => { self.tcx.sess.span_err( span, - format!("{} in a `&` reference", prefix).index(&FullRange)); + &format!("{} in a `&` reference", prefix)[]); } } @@ -884,13 +884,13 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> { }; note_and_explain_region( self.tcx, - format!("{} would have to be valid for ", - descr).index(&FullRange), + &format!("{} would have to be valid for ", + descr)[], loan_scope, "..."); note_and_explain_region( self.tcx, - format!("...but {} is only valid for ", descr).index(&FullRange), + &format!("...but {} is only valid for ", descr)[], ptr_scope, ""); } @@ -910,7 +910,7 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> { out.push('('); self.append_loan_path_to_string(&**lp_base, out); out.push_str(DOWNCAST_PRINTED_OPERATOR); - out.push_str(ty::item_path_str(self.tcx, variant_def_id).index(&FullRange)); + out.push_str(&ty::item_path_str(self.tcx, variant_def_id)[]); out.push(')'); } @@ -924,7 +924,7 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> { } mc::PositionalField(idx) => { out.push('.'); - out.push_str(idx.to_string().index(&FullRange)); + out.push_str(&idx.to_string()[]); } } } @@ -956,7 +956,7 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> { out.push('('); self.append_autoderefd_loan_path_to_string(&**lp_base, out); out.push(':'); - out.push_str(ty::item_path_str(self.tcx, variant_def_id).index(&FullRange)); + out.push_str(&ty::item_path_str(self.tcx, variant_def_id)[]); out.push(')'); } diff --git a/src/librustc_borrowck/graphviz.rs b/src/librustc_borrowck/graphviz.rs index 647a5dd559c..20ad1307da3 100644 --- a/src/librustc_borrowck/graphviz.rs +++ b/src/librustc_borrowck/graphviz.rs @@ -60,7 +60,7 @@ impl<'a, 'tcx> DataflowLabeller<'a, 'tcx> { if seen_one { sets.push_str(" "); } else { seen_one = true; } sets.push_str(variant.short_name()); sets.push_str(": "); - sets.push_str(self.dataflow_for_variant(e, n, variant).index(&FullRange)); + sets.push_str(&self.dataflow_for_variant(e, n, variant)[]); } sets } @@ -89,7 +89,7 @@ impl<'a, 'tcx> DataflowLabeller<'a, 'tcx> { set.push_str(", "); } let loan_str = self.borrowck_ctxt.loan_path_to_string(&*lp); - set.push_str(loan_str.index(&FullRange)); + set.push_str(&loan_str[]); saw_some = true; true }); diff --git a/src/librustc_borrowck/lib.rs b/src/librustc_borrowck/lib.rs index 26bcd5f4c10..452eaaaa52d 100644 --- a/src/librustc_borrowck/lib.rs +++ b/src/librustc_borrowck/lib.rs @@ -10,6 +10,7 @@ #![crate_name = "rustc_borrowck"] #![experimental] +#![staged_api] #![crate_type = "dylib"] #![crate_type = "rlib"] #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png", diff --git a/src/librustc_driver/driver.rs b/src/librustc_driver/driver.rs index 52d49924d05..019691c1e10 100644 --- a/src/librustc_driver/driver.rs +++ b/src/librustc_driver/driver.rs @@ -58,12 +58,12 @@ pub fn compile_input(sess: Session, let outputs = build_output_filenames(input, outdir, output, - krate.attrs.index(&FullRange), + &krate.attrs[], &sess); - let id = link::find_crate_name(Some(&sess), krate.attrs.index(&FullRange), + let id = link::find_crate_name(Some(&sess), &krate.attrs[], input); let expanded_crate - = match phase_2_configure_and_expand(&sess, krate, id.index(&FullRange), + = match phase_2_configure_and_expand(&sess, krate, &id[], addl_plugins) { None => return, Some(k) => k @@ -75,7 +75,7 @@ pub fn compile_input(sess: Session, let mut forest = ast_map::Forest::new(expanded_crate); let ast_map = assign_node_ids_and_map(&sess, &mut forest); - write_out_deps(&sess, input, &outputs, id.index(&FullRange)); + write_out_deps(&sess, input, &outputs, &id[]); if stop_after_phase_2(&sess) { return; } @@ -171,9 +171,9 @@ pub fn phase_2_configure_and_expand(sess: &Session, let time_passes = sess.time_passes(); *sess.crate_types.borrow_mut() = - collect_crate_types(sess, krate.attrs.index(&FullRange)); + collect_crate_types(sess, &krate.attrs[]); *sess.crate_metadata.borrow_mut() = - collect_crate_metadata(sess, krate.attrs.index(&FullRange)); + collect_crate_metadata(sess, &krate.attrs[]); time(time_passes, "recursion limit", (), |_| { middle::recursion_limit::update_recursion_limit(sess, &krate); @@ -268,8 +268,8 @@ pub fn phase_2_configure_and_expand(sess: &Session, if cfg!(windows) { _old_path = os::getenv("PATH").unwrap_or(_old_path); let mut new_path = sess.host_filesearch(PathKind::All).get_dylib_search_paths(); - new_path.extend(os::split_paths(_old_path.index(&FullRange)).into_iter()); - os::setenv("PATH", os::join_paths(new_path.index(&FullRange)).unwrap()); + new_path.extend(os::split_paths(&_old_path[]).into_iter()); + os::setenv("PATH", os::join_paths(&new_path[]).unwrap()); } let cfg = syntax::ext::expand::ExpansionConfig { crate_name: crate_name.to_string(), @@ -533,7 +533,7 @@ pub fn phase_5_run_llvm_passes(sess: &Session, time(sess.time_passes(), "LLVM passes", (), |_| write::run_passes(sess, trans, - sess.opts.output_types.index(&FullRange), + &sess.opts.output_types[], outputs)); } @@ -547,14 +547,14 @@ pub fn phase_6_link_output(sess: &Session, outputs: &OutputFilenames) { let old_path = os::getenv("PATH").unwrap_or_else(||String::new()); let mut new_path = sess.host_filesearch(PathKind::All).get_tools_search_paths(); - new_path.extend(os::split_paths(old_path.index(&FullRange)).into_iter()); - os::setenv("PATH", os::join_paths(new_path.index(&FullRange)).unwrap()); + new_path.extend(os::split_paths(&old_path[]).into_iter()); + os::setenv("PATH", os::join_paths(&new_path[]).unwrap()); time(sess.time_passes(), "linking", (), |_| link::link_binary(sess, trans, outputs, - trans.link.crate_name.index(&FullRange))); + &trans.link.crate_name[])); os::setenv("PATH", old_path); } @@ -643,7 +643,7 @@ fn write_out_deps(sess: &Session, // write Makefile-compatible dependency rules let files: Vec<String> = sess.codemap().files.borrow() .iter().filter(|fmap| fmap.is_real_file()) - .map(|fmap| escape_dep_filename(fmap.name.index(&FullRange))) + .map(|fmap| escape_dep_filename(&fmap.name[])) .collect(); let mut file = try!(io::File::create(&deps_filename)); for path in out_filenames.iter() { @@ -656,8 +656,8 @@ fn write_out_deps(sess: &Session, match result { Ok(()) => {} Err(e) => { - sess.fatal(format!("error writing dependencies to `{}`: {}", - deps_filename.display(), e).index(&FullRange)); + sess.fatal(&format!("error writing dependencies to `{}`: {}", + deps_filename.display(), e)[]); } } } @@ -726,9 +726,9 @@ pub fn collect_crate_types(session: &Session, let res = !link::invalid_output_for_target(session, *crate_type); if !res { - session.warn(format!("dropping unsupported crate type `{:?}` \ + session.warn(&format!("dropping unsupported crate type `{:?}` \ for target `{}`", - *crate_type, session.opts.target_triple).index(&FullRange)); + *crate_type, session.opts.target_triple)[]); } res diff --git a/src/librustc_driver/lib.rs b/src/librustc_driver/lib.rs index 5af114abeea..27e1eaacdfd 100644 --- a/src/librustc_driver/lib.rs +++ b/src/librustc_driver/lib.rs @@ -16,14 +16,17 @@ #![crate_name = "rustc_driver"] #![experimental] +#![staged_api] #![crate_type = "dylib"] #![crate_type = "rlib"] #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png", html_favicon_url = "http://www.rust-lang.org/favicon.ico", html_root_url = "http://doc.rust-lang.org/nightly/")] +#![allow(unknown_features)] #![feature(quote)] #![feature(slicing_syntax, unsafe_destructor)] +#![feature(box_syntax)] #![feature(rustc_diagnostic_macros)] extern crate arena; @@ -46,7 +49,7 @@ pub use syntax::diagnostic; use rustc_trans::back::link; use rustc::session::{config, Session, build_session}; -use rustc::session::config::{Input, PrintRequest}; +use rustc::session::config::{Input, PrintRequest, UnstableFeatures}; use rustc::lint::Lint; use rustc::lint; use rustc::metadata; @@ -89,12 +92,12 @@ fn run_compiler(args: &[String]) { let descriptions = diagnostics::registry::Registry::new(&DIAGNOSTICS); match matches.opt_str("explain") { Some(ref code) => { - match descriptions.find_description(code.index(&FullRange)) { + match descriptions.find_description(&code[]) { Some(ref description) => { println!("{}", description); } None => { - early_error(format!("no extended information for {}", code).index(&FullRange)); + early_error(&format!("no extended information for {}", code)[]); } } return; @@ -120,7 +123,7 @@ fn run_compiler(args: &[String]) { early_error("no input filename given"); } 1u => { - let ifile = matches.free[0].index(&FullRange); + let ifile = &matches.free[0][]; if ifile == "-" { let contents = io::stdin().read_to_end().unwrap(); let src = String::from_utf8(contents).unwrap(); @@ -132,7 +135,11 @@ fn run_compiler(args: &[String]) { _ => early_error("multiple input filenames provided") }; + let mut sopts = sopts; + sopts.unstable_features = get_unstable_features_setting(); + let mut sess = build_session(sopts, input_file_path, descriptions); + let cfg = config::build_configuration(&sess); if print_crate_info(&sess, Some(&input), &odir, &ofile) { return @@ -181,6 +188,21 @@ fn run_compiler(args: &[String]) { driver::compile_input(sess, cfg, &input, &odir, &ofile, None); } +pub fn get_unstable_features_setting() -> UnstableFeatures { + // Whether this is a feature-staged build, i.e. on the beta or stable channel + let disable_unstable_features = option_env!("CFG_DISABLE_UNSTABLE_FEATURES").is_some(); + // The secret key needed to get through the rustc build itself by + // subverting the unstable features lints + let bootstrap_secret_key = option_env!("CFG_BOOTSTRAP_KEY"); + // The matching key to the above, only known by the build system + let bootstrap_provided_key = os::getenv("RUSTC_BOOTSTRAP_KEY"); + match (disable_unstable_features, bootstrap_secret_key, bootstrap_provided_key) { + (_, Some(ref s), Some(ref p)) if s == p => UnstableFeatures::Cheat, + (true, _, _) => UnstableFeatures::Disallow, + (false, _, _) => UnstableFeatures::Default + } +} + /// Returns a version string such as "0.12.0-dev". pub fn release_str() -> Option<&'static str> { option_env!("CFG_RELEASE") @@ -297,7 +319,7 @@ Available lint options: for lint in lints.into_iter() { let name = lint.name_lower().replace("_", "-"); println!(" {} {:7.7} {}", - padded(name.index(&FullRange)), lint.default_level.as_str(), lint.desc); + padded(&name[]), lint.default_level.as_str(), lint.desc); } println!("\n"); }; @@ -327,7 +349,7 @@ Available lint options: let desc = to.into_iter().map(|x| x.as_str().replace("_", "-")) .collect::<Vec<String>>().connect(", "); println!(" {} {}", - padded(name.index(&FullRange)), desc); + padded(&name[]), desc); } println!("\n"); }; @@ -393,7 +415,7 @@ pub fn handle_options(mut args: Vec<String>) -> Option<getopts::Matches> { } let matches = - match getopts::getopts(args.index(&FullRange), config::optgroups().index(&FullRange)) { + match getopts::getopts(&args[], &config::optgroups()[]) { Ok(m) => m, Err(f_stable_attempt) => { // redo option parsing, including unstable options this time, @@ -567,15 +589,15 @@ pub fn monitor<F:FnOnce()+Send>(f: F) { "run with `RUST_BACKTRACE=1` for a backtrace".to_string(), ]; for note in xs.iter() { - emitter.emit(None, note.index(&FullRange), None, diagnostic::Note) + emitter.emit(None, ¬e[], None, diagnostic::Note) } match r.read_to_string() { Ok(s) => println!("{}", s), Err(e) => { emitter.emit(None, - format!("failed to read internal \ - stderr: {}", e).index(&FullRange), + &format!("failed to read internal \ + stderr: {}", e)[], None, diagnostic::Error) } diff --git a/src/librustc_driver/pretty.rs b/src/librustc_driver/pretty.rs index 44a35ef6be7..7592fbc05b3 100644 --- a/src/librustc_driver/pretty.rs +++ b/src/librustc_driver/pretty.rs @@ -294,9 +294,9 @@ impl<'tcx> pprust::PpAnn for TypedAnnotation<'tcx> { try!(pp::word(&mut s.s, "as")); try!(pp::space(&mut s.s)); try!(pp::word(&mut s.s, - ppaux::ty_to_string( + &ppaux::ty_to_string( tcx, - ty::expr_ty(tcx, expr)).index(&FullRange))); + ty::expr_ty(tcx, expr))[])); s.pclose() } _ => Ok(()) @@ -350,8 +350,8 @@ impl<'a, 'ast> Iterator for NodesMatchingUII<'a, 'ast> { fn next(&mut self) -> Option<ast::NodeId> { match self { - &NodesMatchingDirect(ref mut iter) => iter.next(), - &NodesMatchingSuffix(ref mut iter) => iter.next(), + &mut NodesMatchingDirect(ref mut iter) => iter.next(), + &mut NodesMatchingSuffix(ref mut iter) => iter.next(), } } } @@ -370,7 +370,7 @@ impl UserIdentifiedItem { ItemViaNode(node_id) => NodesMatchingDirect(Some(node_id).into_iter()), ItemViaPath(ref parts) => - NodesMatchingSuffix(map.nodes_matching_suffix(parts.index(&FullRange))), + NodesMatchingSuffix(map.nodes_matching_suffix(&parts[])), } } @@ -382,7 +382,7 @@ impl UserIdentifiedItem { user_option, self.reconstructed_input(), is_wrong_because); - sess.fatal(message.index(&FullRange)) + sess.fatal(&message[]) }; let mut saw_node = ast::DUMMY_NODE_ID; @@ -509,7 +509,7 @@ pub fn pretty_print_input(sess: Session, let is_expanded = needs_expansion(&ppm); let compute_ast_map = needs_ast_map(&ppm, &opt_uii); let krate = if compute_ast_map { - match driver::phase_2_configure_and_expand(&sess, krate, id.index(&FullRange), None) { + match driver::phase_2_configure_and_expand(&sess, krate, &id[], None) { None => return, Some(k) => k } @@ -528,7 +528,7 @@ pub fn pretty_print_input(sess: Session, }; let src_name = driver::source_name(input); - let src = sess.codemap().get_filemap(src_name.index(&FullRange)) + let src = sess.codemap().get_filemap(&src_name[]) .src.as_bytes().to_vec(); let mut rdr = MemReader::new(src); @@ -588,16 +588,16 @@ pub fn pretty_print_input(sess: Session, (PpmFlowGraph, opt_uii) => { debug!("pretty printing flow graph for {:?}", opt_uii); let uii = opt_uii.unwrap_or_else(|| { - sess.fatal(format!("`pretty flowgraph=..` needs NodeId (int) or - unique path suffix (b::c::d)").index(&FullRange)) + sess.fatal(&format!("`pretty flowgraph=..` needs NodeId (int) or + unique path suffix (b::c::d)")[]) }); let ast_map = ast_map.expect("--pretty flowgraph missing ast_map"); let nodeid = uii.to_one_node_id("--pretty", &sess, &ast_map); let node = ast_map.find(nodeid).unwrap_or_else(|| { - sess.fatal(format!("--pretty flowgraph couldn't find id: {}", - nodeid).index(&FullRange)) + sess.fatal(&format!("--pretty flowgraph couldn't find id: {}", + nodeid)[]) }); let code = blocks::Code::from_node(node); @@ -615,8 +615,8 @@ pub fn pretty_print_input(sess: Session, // point to what was found, if there's an // accessible span. match ast_map.opt_span(nodeid) { - Some(sp) => sess.span_fatal(sp, message.index(&FullRange)), - None => sess.fatal(message.index(&FullRange)) + Some(sp) => sess.span_fatal(sp, &message[]), + None => sess.fatal(&message[]) } } } diff --git a/src/librustc_driver/test.rs b/src/librustc_driver/test.rs index d301e9c7b5c..a798ec9aaf7 100644 --- a/src/librustc_driver/test.rs +++ b/src/librustc_driver/test.rs @@ -61,7 +61,7 @@ fn remove_message(e: &mut ExpectErrorEmitter, msg: &str, lvl: Level) { e.messages.remove(i); } None => { - panic!("Unexpected error: {} Expected: {}", + panic!("Unexpected error: {} Expected: {:?}", msg, e.messages); } } @@ -279,7 +279,7 @@ impl<'a, 'tcx> Env<'a, 'tcx> { pub fn t_param(&self, space: subst::ParamSpace, index: u32) -> Ty<'tcx> { let name = format!("T{}", index); - ty::mk_param(self.infcx.tcx, space, index, token::intern(name.index(&FullRange))) + ty::mk_param(self.infcx.tcx, space, index, token::intern(&name[])) } pub fn re_early_bound(&self, diff --git a/src/librustc_llvm/lib.rs b/src/librustc_llvm/lib.rs index 0bed754aa3c..4a281c413d6 100644 --- a/src/librustc_llvm/lib.rs +++ b/src/librustc_llvm/lib.rs @@ -15,13 +15,16 @@ #![crate_name = "rustc_llvm"] #![experimental] +#![staged_api] #![crate_type = "dylib"] #![crate_type = "rlib"] #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png", html_favicon_url = "http://www.rust-lang.org/favicon.ico", html_root_url = "http://doc.rust-lang.org/nightly/")] +#![allow(unknown_features)] #![feature(link_args)] +#![feature(box_syntax)] extern crate libc; diff --git a/src/librustc_resolve/build_reduced_graph.rs b/src/librustc_resolve/build_reduced_graph.rs index ca6b1469f85..466bd608736 100644 --- a/src/librustc_resolve/build_reduced_graph.rs +++ b/src/librustc_resolve/build_reduced_graph.rs @@ -219,16 +219,16 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { // had the duplicate. let ns = ns.unwrap(); self.resolve_error(sp, - format!("duplicate definition of {} `{}`", + &format!("duplicate definition of {} `{}`", namespace_error_to_string(duplicate_type), - token::get_name(name)).index(&FullRange)); + token::get_name(name))[]); { let r = child.span_for_namespace(ns); for sp in r.iter() { self.session.span_note(*sp, - format!("first definition of {} `{}` here", + &format!("first definition of {} `{}` here", namespace_error_to_string(duplicate_type), - token::get_name(name)).index(&FullRange)); + token::get_name(name))[]); } } } @@ -1200,8 +1200,8 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { SingleImport(target, _) => { debug!("(building import directive) building import \ directive: {}::{}", - self.names_to_string(module_.imports.borrow().last().unwrap() - .module_path.index(&FullRange)), + self.names_to_string(&module_.imports.borrow().last().unwrap(). + module_path[]), token::get_name(target)); let mut import_resolutions = module_.import_resolutions diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs index 93ad69e03b1..a1ae96490ca 100644 --- a/src/librustc_resolve/lib.rs +++ b/src/librustc_resolve/lib.rs @@ -10,6 +10,7 @@ #![crate_name = "rustc_resolve"] #![experimental] +#![staged_api] #![crate_type = "dylib"] #![crate_type = "rlib"] #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png", @@ -1057,11 +1058,10 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { }; let msg = format!("unresolved import `{}`{}", self.import_path_to_string( - import_directive.module_path - .index(&FullRange), + &import_directive.module_path[], import_directive.subclass), help); - self.resolve_error(span, msg.index(&FullRange)); + self.resolve_error(span, &msg[]); } Indeterminate => break, // Bail out. We'll come around next time. Success(()) => () // Good. Continue. @@ -1091,7 +1091,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { .iter() .map(|seg| seg.identifier.name) .collect(); - self.names_to_string(names.index(&FullRange)) + self.names_to_string(&names[]) } fn import_directive_subclass_to_string(&mut self, @@ -1155,7 +1155,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { let module_path = &import_directive.module_path; debug!("(resolving import for module) resolving import `{}::...` in `{}`", - self.names_to_string(module_path.index(&FullRange)), + self.names_to_string(&module_path[]), self.module_to_string(&*module_)); // First, resolve the module path for the directive, if necessary. @@ -1164,7 +1164,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { Some((self.graph_root.get_module(), LastMod(AllPublic))) } else { match self.resolve_module_path(module_.clone(), - module_path.index(&FullRange), + &module_path[], DontUseLexicalScope, import_directive.span, ImportSearch) { @@ -1761,7 +1761,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { ValueNS => "value", }, token::get_name(name).get()); - self.session.span_err(import_span, msg.index(&FullRange)); + self.session.span_err(import_span, &msg[]); } Some(_) | None => {} } @@ -1776,7 +1776,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { if !name_bindings.defined_in_namespace_with(namespace, IMPORTABLE) { let msg = format!("`{}` is not directly importable", token::get_name(name)); - self.session.span_err(import_span, msg.index(&FullRange)); + self.session.span_err(import_span, &msg[]); } } @@ -1801,7 +1801,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { crate in this module \ (maybe you meant `use {0}::*`?)", token::get_name(name).get()); - self.session.span_err(import_span, msg.index(&FullRange)); + self.session.span_err(import_span, &msg[]); } Some(_) | None => {} } @@ -1823,7 +1823,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { let msg = format!("import `{}` conflicts with value \ in this module", token::get_name(name).get()); - self.session.span_err(import_span, msg.index(&FullRange)); + self.session.span_err(import_span, &msg[]); if let Some(span) = value.value_span { self.session.span_note(span, "conflicting value here"); @@ -1841,7 +1841,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { let msg = format!("import `{}` conflicts with type in \ this module", token::get_name(name).get()); - self.session.span_err(import_span, msg.index(&FullRange)); + self.session.span_err(import_span, &msg[]); if let Some(span) = ty.type_span { self.session.span_note(span, "note conflicting type here") @@ -1854,7 +1854,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { let msg = format!("inherent implementations \ are only allowed on types \ defined in the current module"); - self.session.span_err(span, msg.index(&FullRange)); + self.session.span_err(span, &msg[]); self.session.span_note(import_span, "import from other module here") } @@ -1863,7 +1863,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { let msg = format!("import `{}` conflicts with existing \ submodule", token::get_name(name).get()); - self.session.span_err(import_span, msg.index(&FullRange)); + self.session.span_err(import_span, &msg[]); if let Some(span) = ty.type_span { self.session.span_note(span, "note conflicting module here") @@ -1891,9 +1891,9 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { if module.external_module_children.borrow().contains_key(&name) { self.session .span_err(span, - format!("an external crate named `{}` has already \ + &format!("an external crate named `{}` has already \ been imported into this module", - token::get_name(name).get()).index(&FullRange)); + token::get_name(name).get())[]); } } @@ -1909,10 +1909,10 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { if module.external_module_children.borrow().contains_key(&name) { self.session .span_err(span, - format!("the name `{}` conflicts with an external \ + &format!("the name `{}` conflicts with an external \ crate that has been imported into this \ module", - token::get_name(name).get()).index(&FullRange)); + token::get_name(name).get())[]); } } @@ -1960,7 +1960,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { let segment_name = token::get_name(name); let module_name = self.module_to_string(&*search_module); let mut span = span; - let msg = if "???" == module_name.index(&FullRange) { + let msg = if "???" == &module_name[] { span.hi = span.lo + Pos::from_uint(segment_name.get().len()); match search_parent_externals(name, @@ -2073,14 +2073,14 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { match module_prefix_result { Failed(None) => { let mpath = self.names_to_string(module_path); - let mpath = mpath.index(&FullRange); + let mpath = &mpath[]; match mpath.rfind(':') { Some(idx) => { let msg = format!("Could not find `{}` in `{}`", // idx +- 1 to account for the // colons on either side - mpath.index(&((idx + 1)..)), - mpath.index(&(0..(idx - 1)))); + &mpath[(idx + 1)..], + &mpath[0..(idx - 1)]); return Failed(Some((span, msg))); }, None => { @@ -2254,8 +2254,8 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { PathSearch, true) { Failed(Some((span, msg))) => - self.resolve_error(span, format!("failed to resolve. {}", - msg).index(&FullRange)), + self.resolve_error(span, &format!("failed to resolve. {}", + msg)[]), Failed(None) => (), // Continue up the search chain. Indeterminate => { // We couldn't see through the higher scope because of an @@ -2515,7 +2515,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { } else { let err = format!("unresolved import (maybe you meant `{}::*`?)", sn); - self.resolve_error((*imports)[index].span, err.index(&FullRange)); + self.resolve_error((*imports)[index].span, &err[]); } } @@ -2607,7 +2607,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { match def_like { DlDef(d @ DefUpvar(..)) => { self.session.span_bug(span, - format!("unexpected {:?} in bindings", d).index(&FullRange)) + &format!("unexpected {:?} in bindings", d)[]) } DlDef(d @ DefLocal(_)) => { let node_id = d.def_id().node; @@ -2753,7 +2753,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { for (i, rib) in ribs.iter().enumerate().rev() { match rib.bindings.get(&name).cloned() { Some(def_like) => { - return self.upvarify(ribs.index(&((i + 1)..)), def_like, span); + return self.upvarify(&ribs[(i + 1)..], def_like, span); } None => { // Continue. @@ -2846,7 +2846,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { generics, implemented_traits, &**self_type, - impl_items.index(&FullRange)); + &impl_items[]); } ItemTrait(_, ref generics, ref bounds, ref trait_items) => { @@ -2924,7 +2924,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { ItemStruct(ref struct_def, ref generics) => { self.resolve_struct(item.id, generics, - struct_def.fields.index(&FullRange)); + &struct_def.fields[]); } ItemMod(ref module_) => { @@ -2943,8 +2943,11 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { HasTypeParameters( generics, FnSpace, foreign_item.id, ItemRibKind), - |this| visit::walk_foreign_item(this, - &**foreign_item)); + |this| { + this.resolve_type_parameters(&generics.ty_params); + this.resolve_where_clause(&generics.where_clause); + visit::walk_foreign_item(this, &**foreign_item) + }); } ForeignItemStatic(..) => { visit::walk_foreign_item(this, @@ -2992,12 +2995,12 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { if seen_bindings.contains(&name) { self.resolve_error(type_parameter.span, - format!("the name `{}` is already \ + &format!("the name `{}` is already \ used for a type \ parameter in this type \ parameter list", token::get_name( - name)).index(&FullRange)) + name))[]) } seen_bindings.insert(name); @@ -3169,7 +3172,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { }; let msg = format!("attempt to {} a nonexistent trait `{}`", usage_str, path_str); - self.resolve_error(trait_reference.path.span, msg.index(&FullRange)); + self.resolve_error(trait_reference.path.span, &msg[]); } Some(def) => { match def { @@ -3179,16 +3182,16 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { } (def, _) => { self.resolve_error(trait_reference.path.span, - format!("`{}` is not a trait", + &format!("`{}` is not a trait", self.path_names_to_string( - &trait_reference.path)).index(&FullRange)); + &trait_reference.path))[]); // If it's a typedef, give a note if let DefTy(..) = def { self.session.span_note( trait_reference.path.span, - format!("`type` aliases cannot be used for traits") - .index(&FullRange)); + &format!("`type` aliases cannot be used for traits") + []); } } } @@ -3383,9 +3386,9 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { if self.trait_item_map.get(&(name, did)).is_none() { let path_str = self.path_names_to_string(&trait_ref.path); self.resolve_error(span, - format!("method `{}` is not a member of trait `{}`", + &format!("method `{}` is not a member of trait `{}`", token::get_name(name), - path_str).index(&FullRange)); + path_str)[]); } } } @@ -3451,19 +3454,19 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { None => { self.resolve_error( p.span, - format!("variable `{}` from pattern #1 is \ + &format!("variable `{}` from pattern #1 is \ not bound in pattern #{}", token::get_name(key), - i + 1).index(&FullRange)); + i + 1)[]); } Some(binding_i) => { if binding_0.binding_mode != binding_i.binding_mode { self.resolve_error( binding_i.span, - format!("variable `{}` is bound with different \ + &format!("variable `{}` is bound with different \ mode in pattern #{} than in pattern #1", token::get_name(key), - i + 1).index(&FullRange)); + i + 1)[]); } } } @@ -3473,10 +3476,10 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { if !map_0.contains_key(&key) { self.resolve_error( binding.span, - format!("variable `{}` from pattern {}{} is \ + &format!("variable `{}` from pattern {}{} is \ not bound in pattern {}1", token::get_name(key), - "#", i + 1, "#").index(&FullRange)); + "#", i + 1, "#")[]); } } } @@ -3591,7 +3594,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { None => { let msg = format!("use of undeclared type name `{}`", self.path_names_to_string(path)); - self.resolve_error(ty.span, msg.index(&FullRange)); + self.resolve_error(ty.span, &msg[]); } } } @@ -3660,10 +3663,10 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { FoundStructOrEnumVariant(..) => { self.resolve_error( pattern.span, - format!("declaration of `{}` shadows an enum \ + &format!("declaration of `{}` shadows an enum \ variant or unit-like struct in \ scope", - token::get_name(renamed)).index(&FullRange)); + token::get_name(renamed))[]); } FoundConst(ref def, lp) if mode == RefutableMode => { debug!("(resolving pattern) resolving `{}` to \ @@ -3708,23 +3711,23 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { // Forbid duplicate bindings in the same // parameter list. self.resolve_error(pattern.span, - format!("identifier `{}` \ + &format!("identifier `{}` \ is bound more \ than once in \ this parameter \ list", token::get_ident( ident)) - .index(&FullRange)) + []) } else if bindings_list.get(&renamed) == Some(&pat_id) { // Then this is a duplicate variable in the // same disjunction, which is an error. self.resolve_error(pattern.span, - format!("identifier `{}` is bound \ + &format!("identifier `{}` is bound \ more than once in the same \ pattern", - token::get_ident(ident)).index(&FullRange)); + token::get_ident(ident))[]); } // Else, not bound in the same pattern: do // nothing. @@ -3787,7 +3790,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { def: {:?}", result); let msg = format!("`{}` does not name a structure", self.path_names_to_string(path)); - self.resolve_error(path.span, msg.index(&FullRange)); + self.resolve_error(path.span, &msg[]); } } } @@ -3848,8 +3851,8 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { Failed(err) => { match err { Some((span, msg)) => { - self.resolve_error(span, format!("failed to resolve: {}", - msg).index(&FullRange)); + self.resolve_error(span, &format!("failed to resolve: {}", + msg)[]); } None => () } @@ -4044,7 +4047,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { let last_private; let module = self.current_module.clone(); match self.resolve_module_path(module, - module_path.index(&FullRange), + &module_path[], UseLexicalScope, path.span, PathSearch) { @@ -4058,8 +4061,8 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { } }; - self.resolve_error(span, format!("failed to resolve. {}", - msg).index(&FullRange)); + self.resolve_error(span, &format!("failed to resolve. {}", + msg)[]); return None; } Indeterminate => panic!("indeterminate unexpected"), @@ -4102,7 +4105,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { let containing_module; let last_private; match self.resolve_module_path_from_root(root_module, - module_path.index(&FullRange), + &module_path[], 0, path.span, PathSearch, @@ -4112,13 +4115,13 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { Some((span, msg)) => (span, msg), None => { let msg = format!("Use of undeclared module `::{}`", - self.names_to_string(module_path.index(&FullRange))); + self.names_to_string(&module_path[])); (path.span, msg) } }; - self.resolve_error(span, format!("failed to resolve. {}", - msg).index(&FullRange)); + self.resolve_error(span, &format!("failed to resolve. {}", + msg)[]); return None; } @@ -4159,7 +4162,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { } TypeNS => { let name = ident.name; - self.search_ribs(self.type_ribs.index(&FullRange), name, span) + self.search_ribs(&self.type_ribs[], name, span) } }; @@ -4213,8 +4216,8 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { Failed(err) => { match err { Some((span, msg)) => - self.resolve_error(span, format!("failed to resolve. {}", - msg).index(&FullRange)), + self.resolve_error(span, &format!("failed to resolve. {}", + msg)[]), None => () } @@ -4271,7 +4274,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { } } else { match this.resolve_module_path(root, - name_path.index(&FullRange), + &name_path[], UseLexicalScope, span, PathSearch) { @@ -4309,7 +4312,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { let name_path = path.segments.iter().map(|seg| seg.identifier.name).collect::<Vec<_>>(); // Look for a method in the current self type's impl module. - match get_module(self, path.span, name_path.index(&FullRange)) { + match get_module(self, path.span, &name_path[]) { Some(module) => match module.children.borrow().get(&name) { Some(binding) => { let p_str = self.path_names_to_string(&path); @@ -4520,7 +4523,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { def: {:?}", result); let msg = format!("`{}` does not name a structure", self.path_names_to_string(path)); - self.resolve_error(path.span, msg.index(&FullRange)); + self.resolve_error(path.span, &msg[]); } } @@ -4580,8 +4583,8 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { None => { self.resolve_error( expr.span, - format!("use of undeclared label `{}`", - token::get_ident(label)).index(&FullRange)) + &format!("use of undeclared label `{}`", + token::get_ident(label))[]) } Some(DlDef(def @ DefLabel(_))) => { // Since this def is a label, it is never read. @@ -4716,11 +4719,11 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { // the same conclusion! - nmatsakis Occupied(entry) => if def != *entry.get() { self.session - .bug(format!("node_id {} resolved first to {:?} and \ + .bug(&format!("node_id {} resolved first to {:?} and \ then {:?}", node_id, *entry.get(), - def).index(&FullRange)); + def)[]); }, Vacant(entry) => { entry.insert(def); }, } @@ -4734,9 +4737,9 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { BindByValue(_) => {} BindByRef(..) => { self.resolve_error(pat.span, - format!("cannot use `ref` binding mode \ + &format!("cannot use `ref` binding mode \ with {}", - descr).index(&FullRange)); + descr)[]); } } } @@ -4771,8 +4774,8 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { if names.len() == 0 { return "???".to_string(); } - self.names_to_string(names.into_iter().rev() - .collect::<Vec<ast::Name>>().index(&FullRange)) + self.names_to_string(&names.into_iter().rev() + .collect::<Vec<ast::Name>>()[]) } #[allow(dead_code)] // useful for debugging diff --git a/src/librustc_trans/back/link.rs b/src/librustc_trans/back/link.rs index 26241ace76f..43f8c677e30 100644 --- a/src/librustc_trans/back/link.rs +++ b/src/librustc_trans/back/link.rs @@ -128,7 +128,7 @@ pub fn find_crate_name(sess: Option<&Session>, attrs: &[ast::Attribute], input: &Input) -> String { let validate = |&: s: String, span: Option<Span>| { - creader::validate_crate_name(sess, s.index(&FullRange), span); + creader::validate_crate_name(sess, &s[], span); s }; @@ -146,7 +146,7 @@ pub fn find_crate_name(sess: Option<&Session>, let msg = format!("--crate-name and #[crate_name] are \ required to match, but `{}` != `{}`", s, name); - sess.span_err(attr.span, msg.index(&FullRange)); + sess.span_err(attr.span, &msg[]); } } return validate(s.clone(), None); @@ -192,17 +192,17 @@ fn symbol_hash<'tcx>(tcx: &ty::ctxt<'tcx>, // to be independent of one another in the crate. symbol_hasher.reset(); - symbol_hasher.input_str(link_meta.crate_name.index(&FullRange)); + symbol_hasher.input_str(&link_meta.crate_name[]); symbol_hasher.input_str("-"); symbol_hasher.input_str(link_meta.crate_hash.as_str()); for meta in tcx.sess.crate_metadata.borrow().iter() { - symbol_hasher.input_str(meta.index(&FullRange)); + symbol_hasher.input_str(&meta[]); } symbol_hasher.input_str("-"); - symbol_hasher.input_str(encoder::encoded_ty(tcx, t).index(&FullRange)); + symbol_hasher.input_str(&encoder::encoded_ty(tcx, t)[]); // Prefix with 'h' so that it never blends into adjacent digits let mut hash = String::from_str("h"); - hash.push_str(truncated_hash_result(symbol_hasher).index(&FullRange)); + hash.push_str(&truncated_hash_result(symbol_hasher)[]); hash } @@ -251,7 +251,7 @@ pub fn sanitize(s: &str) -> String { let mut tstr = String::new(); for c in c.escape_unicode() { tstr.push(c) } result.push('$'); - result.push_str(tstr.index(&(1..))); + result.push_str(&tstr[1..]); } } } @@ -260,7 +260,7 @@ pub fn sanitize(s: &str) -> String { if result.len() > 0u && result.as_bytes()[0] != '_' as u8 && ! (result.as_bytes()[0] as char).is_xid_start() { - return format!("_{}", result.index(&FullRange)); + return format!("_{}", &result[]); } return result; @@ -286,12 +286,12 @@ pub fn mangle<PI: Iterator<Item=PathElem>>(mut path: PI, fn push(n: &mut String, s: &str) { let sani = sanitize(s); - n.push_str(format!("{}{}", sani.len(), sani).index(&FullRange)); + n.push_str(&format!("{}{}", sani.len(), sani)[]); } // First, connect each component with <len, name> pairs. for e in path { - push(&mut n, token::get_name(e.name()).get().index(&FullRange)) + push(&mut n, &token::get_name(e.name()).get()[]) } match hash { @@ -329,17 +329,17 @@ pub fn mangle_exported_name<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, path: PathEl hash.push(EXTRA_CHARS.as_bytes()[extra2] as char); hash.push(EXTRA_CHARS.as_bytes()[extra3] as char); - exported_name(path, hash.index(&FullRange)) + exported_name(path, &hash[]) } pub fn mangle_internal_name_by_type_and_seq<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>, name: &str) -> String { let s = ppaux::ty_to_string(ccx.tcx(), t); - let path = [PathName(token::intern(s.index(&FullRange))), + let path = [PathName(token::intern(&s[])), gensym_name(name)]; let hash = get_symbol_hash(ccx, t); - mangle(ast_map::Values(path.iter()), Some(hash.index(&FullRange))) + mangle(ast_map::Values(path.iter()), Some(&hash[])) } pub fn mangle_internal_name_by_path_and_seq(path: PathElems, flav: &str) -> String { @@ -357,9 +357,9 @@ pub fn remove(sess: &Session, path: &Path) { match fs::unlink(path) { Ok(..) => {} Err(e) => { - sess.err(format!("failed to remove {}: {}", + sess.err(&format!("failed to remove {}: {}", path.display(), - e).index(&FullRange)); + e)[]); } } } @@ -373,8 +373,8 @@ pub fn link_binary(sess: &Session, let mut out_filenames = Vec::new(); for &crate_type in sess.crate_types.borrow().iter() { if invalid_output_for_target(sess, crate_type) { - sess.bug(format!("invalid output type `{:?}` for target os `{}`", - crate_type, sess.opts.target_triple).index(&FullRange)); + sess.bug(&format!("invalid output type `{:?}` for target os `{}`", + crate_type, sess.opts.target_triple)[]); } let out_file = link_binary_output(sess, trans, crate_type, outputs, crate_name); @@ -439,8 +439,8 @@ pub fn filename_for_input(sess: &Session, out_filename.with_filename(format!("lib{}.rlib", libname)) } config::CrateTypeDylib => { - let (prefix, suffix) = (sess.target.target.options.dll_prefix.index(&FullRange), - sess.target.target.options.dll_suffix.index(&FullRange)); + let (prefix, suffix) = (&sess.target.target.options.dll_prefix[], + &sess.target.target.options.dll_suffix[]); out_filename.with_filename(format!("{}{}{}", prefix, libname, @@ -450,7 +450,7 @@ pub fn filename_for_input(sess: &Session, out_filename.with_filename(format!("lib{}.a", libname)) } config::CrateTypeExecutable => { - let suffix = sess.target.target.options.exe_suffix.index(&FullRange); + let suffix = &sess.target.target.options.exe_suffix[]; out_filename.with_filename(format!("{}{}", libname, suffix)) } } @@ -477,14 +477,14 @@ fn link_binary_output(sess: &Session, let obj_is_writeable = is_writeable(&obj_filename); let out_is_writeable = is_writeable(&out_filename); if !out_is_writeable { - sess.fatal(format!("output file {} is not writeable -- check its \ + sess.fatal(&format!("output file {} is not writeable -- check its \ permissions.", - out_filename.display()).index(&FullRange)); + out_filename.display())[]); } else if !obj_is_writeable { - sess.fatal(format!("object file {} is not writeable -- check its \ + sess.fatal(&format!("object file {} is not writeable -- check its \ permissions.", - obj_filename.display()).index(&FullRange)); + obj_filename.display())[]); } match crate_type { @@ -539,7 +539,7 @@ fn link_rlib<'a>(sess: &'a Session, for &(ref l, kind) in sess.cstore.get_used_libraries().borrow().iter() { match kind { cstore::NativeStatic => { - ab.add_native_library(l.index(&FullRange)).unwrap(); + ab.add_native_library(&l[]).unwrap(); } cstore::NativeFramework | cstore::NativeUnknown => {} } @@ -586,13 +586,13 @@ fn link_rlib<'a>(sess: &'a Session, // the same filename for metadata (stomping over one another) let tmpdir = TempDir::new("rustc").ok().expect("needs a temp dir"); let metadata = tmpdir.path().join(METADATA_FILENAME); - match fs::File::create(&metadata).write(trans.metadata - .index(&FullRange)) { + match fs::File::create(&metadata).write(&trans.metadata + []) { Ok(..) => {} Err(e) => { - sess.err(format!("failed to write {}: {}", + sess.err(&format!("failed to write {}: {}", metadata.display(), - e).index(&FullRange)); + e)[]); sess.abort_if_errors(); } } @@ -610,25 +610,25 @@ fn link_rlib<'a>(sess: &'a Session, // was exactly 16 bytes. let bc_filename = obj_filename.with_extension(format!("{}.bc", i).as_slice()); let bc_deflated_filename = obj_filename.with_extension( - format!("{}.bytecode.deflate", i).index(&FullRange)); + &format!("{}.bytecode.deflate", i)[]); let bc_data = match fs::File::open(&bc_filename).read_to_end() { Ok(buffer) => buffer, - Err(e) => sess.fatal(format!("failed to read bytecode: {}", - e).index(&FullRange)) + Err(e) => sess.fatal(&format!("failed to read bytecode: {}", + e)[]) }; - let bc_data_deflated = match flate::deflate_bytes(bc_data.index(&FullRange)) { + let bc_data_deflated = match flate::deflate_bytes(&bc_data[]) { Some(compressed) => compressed, - None => sess.fatal(format!("failed to compress bytecode from {}", - bc_filename.display()).index(&FullRange)) + None => sess.fatal(&format!("failed to compress bytecode from {}", + bc_filename.display())[]) }; let mut bc_file_deflated = match fs::File::create(&bc_deflated_filename) { Ok(file) => file, Err(e) => { - sess.fatal(format!("failed to create compressed bytecode \ - file: {}", e).index(&FullRange)) + sess.fatal(&format!("failed to create compressed bytecode \ + file: {}", e)[]) } }; @@ -636,8 +636,8 @@ fn link_rlib<'a>(sess: &'a Session, bc_data_deflated.as_slice()) { Ok(()) => {} Err(e) => { - sess.err(format!("failed to write compressed bytecode: \ - {}", e).index(&FullRange)); + sess.err(&format!("failed to write compressed bytecode: \ + {}", e)[]); sess.abort_if_errors() } }; @@ -677,7 +677,7 @@ fn write_rlib_bytecode_object_v1<T: Writer>(writer: &mut T, try! { writer.write(RLIB_BYTECODE_OBJECT_MAGIC) }; try! { writer.write_le_u32(1) }; try! { writer.write_le_u64(bc_data_deflated_size) }; - try! { writer.write(bc_data_deflated.index(&FullRange)) }; + try! { writer.write(&bc_data_deflated[]) }; let number_of_bytes_written_so_far = RLIB_BYTECODE_OBJECT_MAGIC.len() + // magic id @@ -727,12 +727,12 @@ fn link_staticlib(sess: &Session, obj_filename: &Path, out_filename: &Path) { let ref name = sess.cstore.get_crate_data(cnum).name; let p = match *path { Some(ref p) => p.clone(), None => { - sess.err(format!("could not find rlib for: `{}`", - name).index(&FullRange)); + sess.err(&format!("could not find rlib for: `{}`", + name)[]); continue } }; - ab.add_rlib(&p, name.index(&FullRange), sess.lto()).unwrap(); + ab.add_rlib(&p, &name[], sess.lto()).unwrap(); let native_libs = csearch::get_native_libraries(&sess.cstore, cnum); all_native_libs.extend(native_libs.into_iter()); @@ -754,7 +754,7 @@ fn link_staticlib(sess: &Session, obj_filename: &Path, out_filename: &Path) { cstore::NativeUnknown => "library", cstore::NativeFramework => "framework", }; - sess.note(format!("{}: {}", name, *lib).index(&FullRange)); + sess.note(&format!("{}: {}", name, *lib)[]); } } @@ -768,12 +768,12 @@ fn link_natively(sess: &Session, trans: &CrateTranslation, dylib: bool, // The invocations of cc share some flags across platforms let pname = get_cc_prog(sess); - let mut cmd = Command::new(pname.index(&FullRange)); + let mut cmd = Command::new(&pname[]); - cmd.args(sess.target.target.options.pre_link_args.index(&FullRange)); + cmd.args(&sess.target.target.options.pre_link_args[]); link_args(&mut cmd, sess, dylib, tmpdir.path(), trans, obj_filename, out_filename); - cmd.args(sess.target.target.options.post_link_args.index(&FullRange)); + cmd.args(&sess.target.target.options.post_link_args[]); if !sess.target.target.options.no_compiler_rt { cmd.arg("-lcompiler-rt"); } @@ -791,22 +791,22 @@ fn link_natively(sess: &Session, trans: &CrateTranslation, dylib: bool, match prog { Ok(prog) => { if !prog.status.success() { - sess.err(format!("linking with `{}` failed: {}", + sess.err(&format!("linking with `{}` failed: {}", pname, - prog.status).index(&FullRange)); - sess.note(format!("{}", &cmd).index(&FullRange)); + prog.status)[]); + sess.note(&format!("{}", &cmd)[]); let mut output = prog.error.clone(); - output.push_all(prog.output.index(&FullRange)); - sess.note(str::from_utf8(output.index(&FullRange)).unwrap()); + output.push_all(&prog.output[]); + sess.note(str::from_utf8(&output[]).unwrap()); sess.abort_if_errors(); } debug!("linker stderr:\n{}", String::from_utf8(prog.error).unwrap()); debug!("linker stdout:\n{}", String::from_utf8(prog.output).unwrap()); }, Err(e) => { - sess.err(format!("could not exec the linker `{}`: {}", + sess.err(&format!("could not exec the linker `{}`: {}", pname, - e).index(&FullRange)); + e)[]); sess.abort_if_errors(); } } @@ -818,7 +818,7 @@ fn link_natively(sess: &Session, trans: &CrateTranslation, dylib: bool, match Command::new("dsymutil").arg(out_filename).output() { Ok(..) => {} Err(e) => { - sess.err(format!("failed to run dsymutil: {}", e).index(&FullRange)); + sess.err(&format!("failed to run dsymutil: {}", e)[]); sess.abort_if_errors(); } } @@ -867,7 +867,7 @@ fn link_args(cmd: &mut Command, let mut v = b"-Wl,-force_load,".to_vec(); v.push_all(morestack.as_vec()); - cmd.arg(v.index(&FullRange)); + cmd.arg(&v[]); } else { cmd.args(&["-Wl,--whole-archive", "-lmorestack", "-Wl,--no-whole-archive"]); } @@ -992,7 +992,7 @@ fn link_args(cmd: &mut Command, if sess.opts.cg.rpath { let mut v = "-Wl,-install_name,@rpath/".as_bytes().to_vec(); v.push_all(out_filename.filename().unwrap()); - cmd.arg(v.index(&FullRange)); + cmd.arg(&v[]); } } else { cmd.arg("-shared"); @@ -1004,7 +1004,7 @@ fn link_args(cmd: &mut Command, // addl_lib_search_paths if sess.opts.cg.rpath { let sysroot = sess.sysroot(); - let target_triple = sess.opts.target_triple.index(&FullRange); + let target_triple = &sess.opts.target_triple[]; let get_install_prefix_lib_path = |:| { let install_prefix = option_env!("CFG_PREFIX").expect("CFG_PREFIX"); let tlib = filesearch::relative_target_lib_path(sysroot, target_triple); @@ -1021,14 +1021,14 @@ fn link_args(cmd: &mut Command, get_install_prefix_lib_path: get_install_prefix_lib_path, realpath: ::util::fs::realpath }; - cmd.args(rpath::get_rpath_flags(rpath_config).index(&FullRange)); + cmd.args(&rpath::get_rpath_flags(rpath_config)[]); } // Finally add all the linker arguments provided on the command line along // with any #[link_args] attributes found inside the crate let empty = Vec::new(); - cmd.args(sess.opts.cg.link_args.as_ref().unwrap_or(&empty).index(&FullRange)); - cmd.args(used_link_args.index(&FullRange)); + cmd.args(&sess.opts.cg.link_args.as_ref().unwrap_or(&empty)[]); + cmd.args(&used_link_args[]); } // # Native library linking @@ -1082,14 +1082,14 @@ fn add_local_native_libraries(cmd: &mut Command, sess: &Session) { } else { // -force_load is the OSX equivalent of --whole-archive, but it // involves passing the full path to the library to link. - let lib = archive::find_library(l.index(&FullRange), + let lib = archive::find_library(&l[], sess.target.target.options.staticlib_prefix.as_slice(), sess.target.target.options.staticlib_suffix.as_slice(), - search_path.index(&FullRange), + &search_path[], &sess.diagnostic().handler); let mut v = b"-Wl,-force_load,".to_vec(); v.push_all(lib.as_vec()); - cmd.arg(v.index(&FullRange)); + cmd.arg(&v[]); } } if takes_hints { @@ -1102,7 +1102,7 @@ fn add_local_native_libraries(cmd: &mut Command, sess: &Session) { cmd.arg(format!("-l{}", l)); } cstore::NativeFramework => { - cmd.arg("-framework").arg(l.index(&FullRange)); + cmd.arg("-framework").arg(&l[]); } cstore::NativeStatic => unreachable!(), } @@ -1158,7 +1158,7 @@ fn add_upstream_rust_crates(cmd: &mut Command, sess: &Session, // Converts a library file-stem into a cc -l argument fn unlib<'a>(config: &config::Config, stem: &'a [u8]) -> &'a [u8] { if stem.starts_with("lib".as_bytes()) && !config.target.options.is_like_windows { - stem.index(&(3..)) + &stem[3..] } else { stem } @@ -1183,18 +1183,18 @@ fn add_upstream_rust_crates(cmd: &mut Command, sess: &Session, // against the archive. if sess.lto() { let name = cratepath.filename_str().unwrap(); - let name = name.index(&(3..(name.len() - 5))); // chop off lib/.rlib + let name = &name[3..(name.len() - 5)]; // chop off lib/.rlib time(sess.time_passes(), - format!("altering {}.rlib", name).index(&FullRange), + &format!("altering {}.rlib", name)[], (), |()| { let dst = tmpdir.join(cratepath.filename().unwrap()); match fs::copy(&cratepath, &dst) { Ok(..) => {} Err(e) => { - sess.err(format!("failed to copy {} to {}: {}", + sess.err(&format!("failed to copy {} to {}: {}", cratepath.display(), dst.display(), - e).index(&FullRange)); + e)[]); sess.abort_if_errors(); } } @@ -1204,9 +1204,9 @@ fn add_upstream_rust_crates(cmd: &mut Command, sess: &Session, match fs::chmod(&dst, io::USER_READ | io::USER_WRITE) { Ok(..) => {} Err(e) => { - sess.err(format!("failed to chmod {} when preparing \ + sess.err(&format!("failed to chmod {} when preparing \ for LTO: {}", dst.display(), - e).index(&FullRange)); + e)[]); sess.abort_if_errors(); } } @@ -1220,9 +1220,9 @@ fn add_upstream_rust_crates(cmd: &mut Command, sess: &Session, maybe_ar_prog: sess.opts.cg.ar.clone() }; let mut archive = Archive::open(config); - archive.remove_file(format!("{}.o", name).index(&FullRange)); + archive.remove_file(&format!("{}.o", name)[]); let files = archive.files(); - if files.iter().any(|s| s.index(&FullRange).ends_with(".o")) { + if files.iter().any(|s| s[].ends_with(".o")) { cmd.arg(dst); } }); @@ -1244,7 +1244,7 @@ fn add_upstream_rust_crates(cmd: &mut Command, sess: &Session, let mut v = "-l".as_bytes().to_vec(); v.push_all(unlib(&sess.target, cratepath.filestem().unwrap())); - cmd.arg(v.index(&FullRange)); + cmd.arg(&v[]); } } @@ -1286,7 +1286,7 @@ fn add_upstream_native_libraries(cmd: &mut Command, sess: &Session) { } cstore::NativeFramework => { cmd.arg("-framework"); - cmd.arg(lib.index(&FullRange)); + cmd.arg(&lib[]); } cstore::NativeStatic => { sess.bug("statics shouldn't be propagated"); diff --git a/src/librustc_trans/back/lto.rs b/src/librustc_trans/back/lto.rs index ecf2e9ed724..e457de6bc77 100644 --- a/src/librustc_trans/back/lto.rs +++ b/src/librustc_trans/back/lto.rs @@ -53,30 +53,30 @@ pub fn run(sess: &session::Session, llmod: ModuleRef, let path = match path { Some(p) => p, None => { - sess.fatal(format!("could not find rlib for: `{}`", - name).index(&FullRange)); + sess.fatal(&format!("could not find rlib for: `{}`", + name)[]); } }; let archive = ArchiveRO::open(&path).expect("wanted an rlib"); let file = path.filename_str().unwrap(); - let file = file.index(&(3..(file.len() - 5))); // chop off lib/.rlib + let file = &file[3..(file.len() - 5)]; // chop off lib/.rlib debug!("reading {}", file); for i in iter::count(0u, 1) { let bc_encoded = time(sess.time_passes(), format!("check for {}.{}.bytecode.deflate", name, i).as_slice(), (), |_| { - archive.read(format!("{}.{}.bytecode.deflate", - file, i).index(&FullRange)) + archive.read(&format!("{}.{}.bytecode.deflate", + file, i)[]) }); let bc_encoded = match bc_encoded { Some(data) => data, None => { if i == 0 { // No bitcode was found at all. - sess.fatal(format!("missing compressed bytecode in {}", - path.display()).index(&FullRange)); + sess.fatal(&format!("missing compressed bytecode in {}", + path.display())[]); } // No more bitcode files to read. break; @@ -91,20 +91,20 @@ pub fn run(sess: &session::Session, llmod: ModuleRef, if version == 1 { // The only version existing so far let data_size = extract_compressed_bytecode_size_v1(bc_encoded); - let compressed_data = bc_encoded.index(&( + let compressed_data = &bc_encoded[ link::RLIB_BYTECODE_OBJECT_V1_DATA_OFFSET.. - (link::RLIB_BYTECODE_OBJECT_V1_DATA_OFFSET + data_size as uint))); + (link::RLIB_BYTECODE_OBJECT_V1_DATA_OFFSET + data_size as uint)]; match flate::inflate_bytes(compressed_data) { Some(inflated) => inflated, None => { - sess.fatal(format!("failed to decompress bc of `{}`", - name).index(&FullRange)) + sess.fatal(&format!("failed to decompress bc of `{}`", + name)[]) } } } else { - sess.fatal(format!("Unsupported bytecode format version {}", - version).index(&FullRange)) + sess.fatal(&format!("Unsupported bytecode format version {}", + version)[]) } }) } else { @@ -114,8 +114,8 @@ pub fn run(sess: &session::Session, llmod: ModuleRef, match flate::inflate_bytes(bc_encoded) { Some(bc) => bc, None => { - sess.fatal(format!("failed to decompress bc of `{}`", - name).index(&FullRange)) + sess.fatal(&format!("failed to decompress bc of `{}`", + name)[]) } } }) @@ -124,7 +124,7 @@ pub fn run(sess: &session::Session, llmod: ModuleRef, let ptr = bc_decoded.as_slice().as_ptr(); debug!("linking {}, part {}", name, i); time(sess.time_passes(), - format!("ll link {}.{}", name, i).index(&FullRange), + &format!("ll link {}.{}", name, i)[], (), |()| unsafe { if !llvm::LLVMRustLinkInExternalBitcode(llmod, @@ -132,7 +132,7 @@ pub fn run(sess: &session::Session, llmod: ModuleRef, bc_decoded.len() as libc::size_t) { write::llvm_err(sess.diagnostic().handler(), format!("failed to load bc of `{}`", - name.index(&FullRange))); + &name[])); } }); } @@ -186,7 +186,7 @@ pub fn run(sess: &session::Session, llmod: ModuleRef, fn is_versioned_bytecode_format(bc: &[u8]) -> bool { let magic_id_byte_count = link::RLIB_BYTECODE_OBJECT_MAGIC.len(); return bc.len() > magic_id_byte_count && - bc.index(&(0..magic_id_byte_count)) == link::RLIB_BYTECODE_OBJECT_MAGIC; + &bc[0..magic_id_byte_count] == link::RLIB_BYTECODE_OBJECT_MAGIC; } fn extract_bytecode_format_version(bc: &[u8]) -> u32 { @@ -198,8 +198,7 @@ fn extract_compressed_bytecode_size_v1(bc: &[u8]) -> u64 { } fn read_from_le_bytes<T: Int>(bytes: &[u8], position_in_bytes: uint) -> T { - let byte_data = bytes.index(&(position_in_bytes.. - (position_in_bytes + mem::size_of::<T>()))); + let byte_data = &bytes[position_in_bytes..(position_in_bytes + mem::size_of::<T>())]; let data = unsafe { *(byte_data.as_ptr() as *const T) }; diff --git a/src/librustc_trans/back/write.rs b/src/librustc_trans/back/write.rs index 8a80019143e..e0ba6d569cc 100644 --- a/src/librustc_trans/back/write.rs +++ b/src/librustc_trans/back/write.rs @@ -47,14 +47,14 @@ pub fn llvm_err(handler: &diagnostic::Handler, msg: String) -> ! { unsafe { let cstr = llvm::LLVMRustGetLastError(); if cstr == ptr::null() { - handler.fatal(msg.index(&FullRange)); + handler.fatal(&msg[]); } else { let err = ffi::c_str_to_bytes(&cstr); let err = String::from_utf8_lossy(err.as_slice()).to_string(); libc::free(cstr as *mut _); - handler.fatal(format!("{}: {}", - msg.index(&FullRange), - err.index(&FullRange)).index(&FullRange)); + handler.fatal(&format!("{}: {}", + &msg[], + &err[])[]); } } } @@ -104,13 +104,13 @@ impl SharedEmitter { match diag.code { Some(ref code) => { handler.emit_with_code(None, - diag.msg.index(&FullRange), - code.index(&FullRange), + &diag.msg[], + &code[], diag.lvl); }, None => { handler.emit(None, - diag.msg.index(&FullRange), + &diag.msg[], diag.lvl); }, } @@ -165,8 +165,8 @@ fn get_llvm_opt_level(optimize: config::OptLevel) -> llvm::CodeGenOptLevel { fn create_target_machine(sess: &Session) -> TargetMachineRef { let reloc_model_arg = match sess.opts.cg.relocation_model { - Some(ref s) => s.index(&FullRange), - None => sess.target.target.options.relocation_model.index(&FullRange) + Some(ref s) => &s[], + None => &sess.target.target.options.relocation_model[] }; let reloc_model = match reloc_model_arg { "pic" => llvm::RelocPIC, @@ -174,10 +174,10 @@ fn create_target_machine(sess: &Session) -> TargetMachineRef { "default" => llvm::RelocDefault, "dynamic-no-pic" => llvm::RelocDynamicNoPic, _ => { - sess.err(format!("{:?} is not a valid relocation mode", + sess.err(&format!("{:?} is not a valid relocation mode", sess.opts .cg - .relocation_model).index(&FullRange)); + .relocation_model)[]); sess.abort_if_errors(); unreachable!(); } @@ -198,8 +198,8 @@ fn create_target_machine(sess: &Session) -> TargetMachineRef { let fdata_sections = ffunction_sections; let code_model_arg = match sess.opts.cg.code_model { - Some(ref s) => s.index(&FullRange), - None => sess.target.target.options.code_model.index(&FullRange) + Some(ref s) => &s[], + None => &sess.target.target.options.code_model[] }; let code_model = match code_model_arg { @@ -209,16 +209,16 @@ fn create_target_machine(sess: &Session) -> TargetMachineRef { "medium" => llvm::CodeModelMedium, "large" => llvm::CodeModelLarge, _ => { - sess.err(format!("{:?} is not a valid code model", + sess.err(&format!("{:?} is not a valid code model", sess.opts .cg - .code_model).index(&FullRange)); + .code_model)[]); sess.abort_if_errors(); unreachable!(); } }; - let triple = sess.target.target.llvm_target.index(&FullRange); + let triple = &sess.target.target.llvm_target[]; let tm = unsafe { let triple = CString::from_slice(triple.as_bytes()); @@ -350,13 +350,13 @@ unsafe extern "C" fn inline_asm_handler(diag: SMDiagnosticRef, match cgcx.lto_ctxt { Some((sess, _)) => { sess.codemap().with_expn_info(ExpnId::from_llvm_cookie(cookie), |info| match info { - Some(ei) => sess.span_err(ei.call_site, msg.index(&FullRange)), - None => sess.err(msg.index(&FullRange)), + Some(ei) => sess.span_err(ei.call_site, &msg[]), + None => sess.err(&msg[]), }); } None => { - cgcx.handler.err(msg.index(&FullRange)); + cgcx.handler.err(&msg[]); cgcx.handler.note("build without -C codegen-units for more exact errors"); } } @@ -518,14 +518,14 @@ unsafe fn optimize_and_codegen(cgcx: &CodegenContext, } if config.emit_asm { - let path = output_names.with_extension(format!("{}.s", name_extra).index(&FullRange)); + let path = output_names.with_extension(&format!("{}.s", name_extra)[]); with_codegen(tm, llmod, config.no_builtins, |cpm| { write_output_file(cgcx.handler, tm, cpm, llmod, &path, llvm::AssemblyFileType); }); } if config.emit_obj { - let path = output_names.with_extension(format!("{}.o", name_extra).index(&FullRange)); + let path = output_names.with_extension(&format!("{}.o", name_extra)[]); with_codegen(tm, llmod, config.no_builtins, |cpm| { write_output_file(cgcx.handler, tm, cpm, llmod, &path, llvm::ObjectFileType); }); @@ -639,7 +639,7 @@ pub fn run_passes(sess: &Session, // Process the work items, optionally using worker threads. if sess.opts.cg.codegen_units == 1 { - run_work_singlethreaded(sess, trans.reachable.index(&FullRange), work_items); + run_work_singlethreaded(sess, &trans.reachable[], work_items); } else { run_work_multithreaded(sess, work_items, sess.opts.cg.codegen_units); } @@ -666,8 +666,8 @@ pub fn run_passes(sess: &Session, if crate_output.single_output_file.is_some() { // 2) Multiple codegen units, with `-o some_name`. We have // no good solution for this case, so warn the user. - sess.warn(format!("ignoring -o because multiple .{} files were produced", - ext).index(&FullRange)); + sess.warn(&format!("ignoring -o because multiple .{} files were produced", + ext)[]); } else { // 3) Multiple codegen units, but no `-o some_name`. We // just leave the `foo.0.x` files in place. @@ -700,20 +700,20 @@ pub fn run_passes(sess: &Session, }; let pname = get_cc_prog(sess); - let mut cmd = Command::new(pname.index(&FullRange)); + let mut cmd = Command::new(&pname[]); - cmd.args(sess.target.target.options.pre_link_args.index(&FullRange)); + cmd.args(&sess.target.target.options.pre_link_args[]); cmd.arg("-nostdlib"); for index in range(0, trans.modules.len()) { - cmd.arg(crate_output.with_extension(format!("{}.o", index).index(&FullRange))); + cmd.arg(crate_output.with_extension(&format!("{}.o", index)[])); } cmd.arg("-r") .arg("-o") .arg(windows_output_path.as_ref().unwrap_or(output_path)); - cmd.args(sess.target.target.options.post_link_args.index(&FullRange)); + cmd.args(&sess.target.target.options.post_link_args[]); if (sess.opts.debugging_opts & config::PRINT_LINK_ARGS) != 0 { println!("{}", &cmd); @@ -725,15 +725,15 @@ pub fn run_passes(sess: &Session, match cmd.status() { Ok(status) => { if !status.success() { - sess.err(format!("linking of {} with `{}` failed", - output_path.display(), cmd).index(&FullRange)); + sess.err(&format!("linking of {} with `{}` failed", + output_path.display(), cmd)[]); sess.abort_if_errors(); } }, Err(e) => { - sess.err(format!("could not exec the linker `{}`: {}", + sess.err(&format!("could not exec the linker `{}`: {}", pname, - e).index(&FullRange)); + e)[]); sess.abort_if_errors(); }, } @@ -818,12 +818,12 @@ pub fn run_passes(sess: &Session, for i in range(0, trans.modules.len()) { if modules_config.emit_obj { let ext = format!("{}.o", i); - remove(sess, &crate_output.with_extension(ext.index(&FullRange))); + remove(sess, &crate_output.with_extension(&ext[])); } if modules_config.emit_bc && !keep_numbered_bitcode { let ext = format!("{}.bc", i); - remove(sess, &crate_output.with_extension(ext.index(&FullRange))); + remove(sess, &crate_output.with_extension(&ext[])); } } @@ -949,7 +949,7 @@ fn run_work_multithreaded(sess: &Session, pub fn run_assembler(sess: &Session, outputs: &OutputFilenames) { let pname = get_cc_prog(sess); - let mut cmd = Command::new(pname.index(&FullRange)); + let mut cmd = Command::new(&pname[]); cmd.arg("-c").arg("-o").arg(outputs.path(config::OutputTypeObject)) .arg(outputs.temp_path(config::OutputTypeAssembly)); @@ -958,20 +958,20 @@ pub fn run_assembler(sess: &Session, outputs: &OutputFilenames) { match cmd.output() { Ok(prog) => { if !prog.status.success() { - sess.err(format!("linking with `{}` failed: {}", + sess.err(&format!("linking with `{}` failed: {}", pname, - prog.status).index(&FullRange)); - sess.note(format!("{}", &cmd).index(&FullRange)); + prog.status)[]); + sess.note(&format!("{}", &cmd)[]); let mut note = prog.error.clone(); - note.push_all(prog.output.index(&FullRange)); - sess.note(str::from_utf8(note.index(&FullRange)).unwrap()); + note.push_all(&prog.output[]); + sess.note(str::from_utf8(¬e[]).unwrap()); sess.abort_if_errors(); } }, Err(e) => { - sess.err(format!("could not exec the linker `{}`: {}", + sess.err(&format!("could not exec the linker `{}`: {}", pname, - e).index(&FullRange)); + e)[]); sess.abort_if_errors(); } } @@ -1004,7 +1004,7 @@ unsafe fn configure_llvm(sess: &Session) { if sess.print_llvm_passes() { add("-debug-pass=Structure"); } for arg in sess.opts.cg.llvm_args.iter() { - add((*arg).index(&FullRange)); + add(&(*arg)[]); } } diff --git a/src/librustc_trans/lib.rs b/src/librustc_trans/lib.rs index b6f90a4c2f5..5da51697d2f 100644 --- a/src/librustc_trans/lib.rs +++ b/src/librustc_trans/lib.rs @@ -16,14 +16,17 @@ #![crate_name = "rustc_trans"] #![experimental] +#![staged_api] #![crate_type = "dylib"] #![crate_type = "rlib"] #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png", html_favicon_url = "http://www.rust-lang.org/favicon.ico", html_root_url = "http://doc.rust-lang.org/nightly/")] +#![allow(unknown_features)] #![feature(quote)] #![feature(slicing_syntax, unsafe_destructor)] +#![feature(box_syntax)] #![feature(rustc_diagnostic_macros)] extern crate arena; diff --git a/src/librustc_trans/save/mod.rs b/src/librustc_trans/save/mod.rs index 35f168f092a..eb163ed7406 100644 --- a/src/librustc_trans/save/mod.rs +++ b/src/librustc_trans/save/mod.rs @@ -94,7 +94,7 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { // dump info about all the external crates referenced from this crate self.sess.cstore.iter_crate_data(|n, cmd| { - self.fmt.external_crate_str(krate.span, cmd.name.index(&FullRange), n); + self.fmt.external_crate_str(krate.span, &cmd.name[], n); }); self.fmt.recorder.record("end_external_crates\n"); } @@ -143,7 +143,7 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { for &(ref span, ref qualname) in sub_paths.iter() { self.fmt.sub_mod_ref_str(path.span, *span, - qualname.index(&FullRange), + &qualname[], self.cur_scope); } } @@ -161,7 +161,7 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { for &(ref span, ref qualname) in sub_paths.iter() { self.fmt.sub_mod_ref_str(path.span, *span, - qualname.index(&FullRange), + &qualname[], self.cur_scope); } } @@ -180,17 +180,17 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { let (ref span, ref qualname) = sub_paths[len-2]; self.fmt.sub_type_ref_str(path.span, *span, - qualname.index(&FullRange)); + &qualname[]); // write the other sub-paths if len <= 2 { return; } - let sub_paths = sub_paths.index(&(0..(len-2))); + let sub_paths = &sub_paths[0..(len-2)]; for &(ref span, ref qualname) in sub_paths.iter() { self.fmt.sub_mod_ref_str(path.span, *span, - qualname.index(&FullRange), + &qualname[], self.cur_scope); } } @@ -198,8 +198,8 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { // looks up anything, not just a type fn lookup_type_ref(&self, ref_id: NodeId) -> Option<DefId> { if !self.analysis.ty_cx.def_map.borrow().contains_key(&ref_id) { - self.sess.bug(format!("def_map has no key for {} in lookup_type_ref", - ref_id).index(&FullRange)); + self.sess.bug(&format!("def_map has no key for {} in lookup_type_ref", + ref_id)[]); } let def = (*self.analysis.ty_cx.def_map.borrow())[ref_id]; match def { @@ -211,8 +211,8 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { fn lookup_def_kind(&self, ref_id: NodeId, span: Span) -> Option<recorder::Row> { let def_map = self.analysis.ty_cx.def_map.borrow(); if !def_map.contains_key(&ref_id) { - self.sess.span_bug(span, format!("def_map has no key for {} in lookup_def_kind", - ref_id).index(&FullRange)); + self.sess.span_bug(span, &format!("def_map has no key for {} in lookup_def_kind", + ref_id)[]); } let def = (*def_map)[ref_id]; match def { @@ -240,8 +240,8 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { def::DefUse(_) | def::DefMethod(..) | def::DefPrimTy(_) => { - self.sess.span_bug(span, format!("lookup_def_kind for unexpected item: {:?}", - def).index(&FullRange)); + self.sess.span_bug(span, &format!("lookup_def_kind for unexpected item: {:?}", + def)[]); }, } } @@ -262,8 +262,8 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { span_utils.span_for_last_ident(p.span), id, qualname, - path_to_string(p).index(&FullRange), - typ.index(&FullRange)); + &path_to_string(p)[], + &typ[]); } self.collected_paths.clear(); } @@ -285,7 +285,7 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { match item.node { ast::ItemImpl(_, _, _, _, ref ty, _) => { let mut result = String::from_str("<"); - result.push_str(ty_to_string(&**ty).index(&FullRange)); + result.push_str(&ty_to_string(&**ty)[]); match ty::trait_of_item(&self.analysis.ty_cx, ast_util::local_def(method.id)) { @@ -301,18 +301,18 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { } _ => { self.sess.span_bug(method.span, - format!("Container {} for method {} not an impl?", - impl_id.node, method.id).index(&FullRange)); + &format!("Container {} for method {} not an impl?", + impl_id.node, method.id)[]); }, } }, _ => { self.sess.span_bug(method.span, - format!("Container {} for method {} is not a node item {:?}", - impl_id.node, - method.id, - self.analysis.ty_cx.map.get(impl_id.node) - ).index(&FullRange)); + &format!( + "Container {} for method {} is not a node item {:?}", + impl_id.node, + method.id, + self.analysis.ty_cx.map.get(impl_id.node))[]); }, }, None => match ty::trait_of_item(&self.analysis.ty_cx, @@ -327,21 +327,21 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { } _ => { self.sess.span_bug(method.span, - format!("Could not find container {} for method {}", - def_id.node, method.id).index(&FullRange)); + &format!("Could not find container {} for method {}", + def_id.node, method.id)[]); } } }, None => { self.sess.span_bug(method.span, - format!("Could not find container for method {}", - method.id).index(&FullRange)); + &format!("Could not find container for method {}", + method.id)[]); }, }, }; qualname.push_str(get_ident(method.pe_ident()).get()); - let qualname = qualname.index(&FullRange); + let qualname = &qualname[]; // record the decl for this def (if it has one) let decl_id = ty::trait_item_of_item(&self.analysis.ty_cx, @@ -430,13 +430,13 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { Some(sub_span) => self.fmt.field_str(field.span, Some(sub_span), field.node.id, - name.get().index(&FullRange), - qualname.index(&FullRange), - typ.index(&FullRange), + &name.get()[], + &qualname[], + &typ[], scope_id), None => self.sess.span_bug(field.span, - format!("Could not find sub-span for field {}", - qualname).index(&FullRange)), + &format!("Could not find sub-span for field {}", + qualname)[]), } }, _ => (), @@ -463,7 +463,7 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { self.fmt.typedef_str(full_span, Some(*param_ss), param.id, - name.index(&FullRange), + &name[], ""); } self.visit_generics(generics); @@ -480,10 +480,10 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { self.fmt.fn_str(item.span, sub_span, item.id, - qualname.index(&FullRange), + &qualname[], self.cur_scope); - self.process_formals(&decl.inputs, qualname.index(&FullRange)); + self.process_formals(&decl.inputs, &qualname[]); // walk arg and return types for arg in decl.inputs.iter() { @@ -497,7 +497,7 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { // walk the body self.nest(item.id, |v| v.visit_block(&*body)); - self.process_generic_params(ty_params, item.span, qualname.index(&FullRange), item.id); + self.process_generic_params(ty_params, item.span, &qualname[], item.id); } fn process_static(&mut self, @@ -519,9 +519,9 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { sub_span, item.id, get_ident(item.ident).get(), - qualname.index(&FullRange), - value.index(&FullRange), - ty_to_string(&*typ).index(&FullRange), + &qualname[], + &value[], + &ty_to_string(&*typ)[], self.cur_scope); // walk type and init value @@ -542,9 +542,9 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { sub_span, item.id, get_ident(item.ident).get(), - qualname.index(&FullRange), + &qualname[], "", - ty_to_string(&*typ).index(&FullRange), + &ty_to_string(&*typ)[], self.cur_scope); // walk type and init value @@ -568,17 +568,17 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { sub_span, item.id, ctor_id, - qualname.index(&FullRange), + &qualname[], self.cur_scope, - val.index(&FullRange)); + &val[]); // fields for field in def.fields.iter() { - self.process_struct_field_def(field, qualname.index(&FullRange), item.id); + self.process_struct_field_def(field, &qualname[], item.id); self.visit_ty(&*field.node.ty); } - self.process_generic_params(ty_params, item.span, qualname.index(&FullRange), item.id); + self.process_generic_params(ty_params, item.span, &qualname[], item.id); } fn process_enum(&mut self, @@ -591,12 +591,12 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { Some(sub_span) => self.fmt.enum_str(item.span, Some(sub_span), item.id, - enum_name.index(&FullRange), + &enum_name[], self.cur_scope, - val.index(&FullRange)), + &val[]), None => self.sess.span_bug(item.span, - format!("Could not find subspan for enum {}", - enum_name).index(&FullRange)), + &format!("Could not find subspan for enum {}", + enum_name)[]), } for variant in enum_definition.variants.iter() { let name = get_ident(variant.node.name); @@ -612,9 +612,9 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { self.span.span_for_first_ident(variant.span), variant.node.id, name, - qualname.index(&FullRange), - enum_name.index(&FullRange), - val.index(&FullRange), + &qualname[], + &enum_name[], + &val[], item.id); for arg in args.iter() { self.visit_ty(&*arg.ty); @@ -630,9 +630,9 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { self.span.span_for_first_ident(variant.span), variant.node.id, ctor_id, - qualname.index(&FullRange), - enum_name.index(&FullRange), - val.index(&FullRange), + &qualname[], + &enum_name[], + &val[], item.id); for field in struct_def.fields.iter() { @@ -643,7 +643,7 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { } } - self.process_generic_params(ty_params, item.span, enum_name.index(&FullRange), item.id); + self.process_generic_params(ty_params, item.span, &enum_name[], item.id); } fn process_impl(&mut self, @@ -703,9 +703,9 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { self.fmt.trait_str(item.span, sub_span, item.id, - qualname.index(&FullRange), + &qualname[], self.cur_scope, - val.index(&FullRange)); + &val[]); // super-traits for super_bound in trait_refs.iter() { @@ -737,7 +737,7 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { } // walk generics and methods - self.process_generic_params(generics, item.span, qualname.index(&FullRange), item.id); + self.process_generic_params(generics, item.span, &qualname[], item.id); for method in methods.iter() { self.visit_trait_item(method) } @@ -755,9 +755,9 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { self.fmt.mod_str(item.span, sub_span, item.id, - qualname.index(&FullRange), + &qualname[], self.cur_scope, - filename.index(&FullRange)); + &filename[]); self.nest(item.id, |v| visit::walk_mod(v, m)); } @@ -840,8 +840,8 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { def_id, self.cur_scope), _ => self.sess.span_bug(span, - format!("Unexpected def kind while looking up path in '{}'", - self.span.snippet(span)).index(&FullRange)), + &format!("Unexpected def kind while looking up path in '{}'", + self.span.snippet(span))[]), } // modules or types in the path prefix match *def { @@ -959,7 +959,7 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { self.cur_scope); // walk receiver and args - visit::walk_exprs(self, args.index(&FullRange)); + visit::walk_exprs(self, &args[]); } fn process_pat(&mut self, p:&ast::Pat) { @@ -975,8 +975,8 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { Some(sd) => sd, None => { self.sess.span_bug(p.span, - format!("Could not find struct_def for `{}`", - self.span.snippet(p.span)).index(&FullRange)); + &format!("Could not find struct_def for `{}`", + self.span.snippet(p.span))[]); } }; for &Spanned { node: ref field, span } in fields.iter() { @@ -1061,8 +1061,8 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DxrVisitor<'l, 'tcx> { self.fmt.typedef_str(item.span, sub_span, item.id, - qualname.index(&FullRange), - value.index(&FullRange)); + &qualname[], + &value[]); self.visit_ty(&**ty); self.process_generic_params(ty_params, item.span, qualname.as_slice(), item.id); @@ -1121,13 +1121,13 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DxrVisitor<'l, 'tcx> { }, None => { self.sess.span_bug(method_type.span, - format!("Could not find trait for method {}", - method_type.id).index(&FullRange)); + &format!("Could not find trait for method {}", + method_type.id)[]); }, }; qualname.push_str(get_ident(method_type.ident).get()); - let qualname = qualname.index(&FullRange); + let qualname = &qualname[]; let sub_span = self.span.sub_span_after_keyword(method_type.span, keywords::Fn); self.fmt.method_decl_str(method_type.span, @@ -1262,7 +1262,7 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DxrVisitor<'l, 'tcx> { id, cnum, name, - s.index(&FullRange), + &s[], self.cur_scope); }, } @@ -1371,8 +1371,8 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DxrVisitor<'l, 'tcx> { } let mut id = String::from_str("$"); - id.push_str(ex.id.to_string().index(&FullRange)); - self.process_formals(&decl.inputs, id.index(&FullRange)); + id.push_str(&ex.id.to_string()[]); + self.process_formals(&decl.inputs, &id[]); // walk arg and return types for arg in decl.inputs.iter() { @@ -1418,8 +1418,8 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DxrVisitor<'l, 'tcx> { let def_map = self.analysis.ty_cx.def_map.borrow(); if !def_map.contains_key(&id) { self.sess.span_bug(p.span, - format!("def_map has no key for {} in visit_arm", - id).index(&FullRange)); + &format!("def_map has no key for {} in visit_arm", + id)[]); } let def = &(*def_map)[id]; match *def { @@ -1434,8 +1434,8 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DxrVisitor<'l, 'tcx> { self.fmt.variable_str(p.span, Some(p.span), id, - path_to_string(p).index(&FullRange), - value.index(&FullRange), + &path_to_string(p)[], + &value[], "") } def::DefVariant(..) => { @@ -1490,9 +1490,9 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DxrVisitor<'l, 'tcx> { self.fmt.variable_str(p.span, sub_span, id, - path_to_string(p).index(&FullRange), - value.index(&FullRange), - typ.index(&FullRange)); + &path_to_string(p)[], + &value[], + &typ[]); } self.collected_paths.clear(); @@ -1511,7 +1511,7 @@ pub fn process_crate(sess: &Session, } assert!(analysis.glob_map.is_some()); - let cratename = match attr::find_crate_name(krate.attrs.index(&FullRange)) { + let cratename = match attr::find_crate_name(&krate.attrs[]) { Some(name) => name.get().to_string(), None => { info!("Could not find crate name, using 'unknown_crate'"); @@ -1531,8 +1531,8 @@ pub fn process_crate(sess: &Session, }; match fs::mkdir_recursive(&root_path, io::USER_RWX) { - Err(e) => sess.err(format!("Could not create directory {}: {}", - root_path.display(), e).index(&FullRange)), + Err(e) => sess.err(&format!("Could not create directory {}: {}", + root_path.display(), e)[]), _ => (), } @@ -1549,7 +1549,7 @@ pub fn process_crate(sess: &Session, Ok(f) => box f, Err(e) => { let disp = root_path.display(); - sess.fatal(format!("Could not open {}: {}", disp, e).index(&FullRange)); + sess.fatal(&format!("Could not open {}: {}", disp, e)[]); } }; root_path.pop(); @@ -1575,7 +1575,7 @@ pub fn process_crate(sess: &Session, cur_scope: 0 }; - visitor.dump_crate_info(cratename.index(&FullRange), krate); + visitor.dump_crate_info(&cratename[], krate); visit::walk_crate(&mut visitor, krate); } diff --git a/src/librustc_trans/save/recorder.rs b/src/librustc_trans/save/recorder.rs index bb0fb387002..23598751c08 100644 --- a/src/librustc_trans/save/recorder.rs +++ b/src/librustc_trans/save/recorder.rs @@ -41,7 +41,7 @@ impl Recorder { assert!(self.dump_spans); let result = format!("span,kind,{},{},text,\"{}\"\n", kind, su.extent_str(span), escape(su.snippet(span))); - self.record(result.index(&FullRange)); + self.record(&result[]); } } @@ -158,17 +158,17 @@ impl<'a> FmtStrs<'a> { values: Vec<String>, span: Span) -> Option<String> { if values.len() != fields.len() { - self.span.sess.span_bug(span, format!( + self.span.sess.span_bug(span, &format!( "Mismatch between length of fields for '{}', expected '{}', found '{}'", - kind, fields.len(), values.len()).index(&FullRange)); + kind, fields.len(), values.len())[]); } let values = values.iter().map(|s| { // Never take more than 1020 chars if s.len() > 1020 { - s.index(&(0..1020)) + &s[0..1020] } else { - s.index(&FullRange) + &s[] } }); @@ -184,7 +184,7 @@ impl<'a> FmtStrs<'a> { } ))); Some(strs.fold(String::new(), |mut s, ss| { - s.push_str(ss.index(&FullRange)); + s.push_str(&ss[]); s })) } @@ -196,9 +196,9 @@ impl<'a> FmtStrs<'a> { let (label, ref fields, needs_span, dump_spans) = FmtStrs::lookup_row(kind); if needs_span { - self.span.sess.span_bug(span, format!( + self.span.sess.span_bug(span, &format!( "Called record_without_span for '{}' which does requires a span", - label).index(&FullRange)); + label)[]); } assert!(!dump_spans); @@ -212,9 +212,9 @@ impl<'a> FmtStrs<'a> { }; let mut result = String::from_str(label); - result.push_str(values_str.index(&FullRange)); + result.push_str(&values_str[]); result.push_str("\n"); - self.recorder.record(result.index(&FullRange)); + self.recorder.record(&result[]); } pub fn record_with_span(&mut self, @@ -245,7 +245,7 @@ impl<'a> FmtStrs<'a> { None => return, }; let result = format!("{},{}{}\n", label, self.span.extent_str(sub_span), values_str); - self.recorder.record(result.index(&FullRange)); + self.recorder.record(&result[]); } pub fn check_and_record(&mut self, @@ -275,7 +275,7 @@ impl<'a> FmtStrs<'a> { // variable def's node id let mut qualname = String::from_str(name); qualname.push_str("$"); - qualname.push_str(id.to_string().index(&FullRange)); + qualname.push_str(&id.to_string()[]); self.check_and_record(Variable, span, sub_span, diff --git a/src/librustc_trans/save/span_utils.rs b/src/librustc_trans/save/span_utils.rs index 8d249b8bfe9..77343612ac8 100644 --- a/src/librustc_trans/save/span_utils.rs +++ b/src/librustc_trans/save/span_utils.rs @@ -217,8 +217,8 @@ impl<'a> SpanUtils<'a> { if bracket_count != 0 { let loc = self.sess.codemap().lookup_char_pos(span.lo); self.sess.span_bug(span, - format!("Mis-counted brackets when breaking path? Parsing '{}' in {}, line {}", - self.snippet(span), loc.file.name, loc.line).index(&FullRange)); + &format!("Mis-counted brackets when breaking path? Parsing '{}' in {}, line {}", + self.snippet(span), loc.file.name, loc.line)[]); } if result.is_none() && prev.tok.is_ident() && bracket_count == 0 { return self.make_sub_span(span, Some(prev.sp)); @@ -242,9 +242,9 @@ impl<'a> SpanUtils<'a> { if ts.tok == token::Eof { if bracket_count != 0 { let loc = self.sess.codemap().lookup_char_pos(span.lo); - self.sess.span_bug(span, format!( + self.sess.span_bug(span, &format!( "Mis-counted brackets when breaking path? Parsing '{}' in {}, line {}", - self.snippet(span), loc.file.name, loc.line).index(&FullRange)); + self.snippet(span), loc.file.name, loc.line)[]); } return result } diff --git a/src/librustc_trans/trans/_match.rs b/src/librustc_trans/trans/_match.rs index 49b9ef5a40a..fc19a582db2 100644 --- a/src/librustc_trans/trans/_match.rs +++ b/src/librustc_trans/trans/_match.rs @@ -427,7 +427,7 @@ fn enter_match<'a, 'b, 'p, 'blk, 'tcx, F>(bcx: Block<'blk, 'tcx>, let _indenter = indenter(); m.iter().filter_map(|br| { - e(br.pats.index(&FullRange)).map(|pats| { + e(&br.pats[]).map(|pats| { let this = br.pats[col]; let mut bound_ptrs = br.bound_ptrs.clone(); match this.node { @@ -471,8 +471,8 @@ fn enter_default<'a, 'p, 'blk, 'tcx>(bcx: Block<'blk, 'tcx>, // Collect all of the matches that can match against anything. enter_match(bcx, dm, m, col, val, |pats| { if pat_is_binding_or_wild(dm, &*pats[col]) { - let mut r = pats.index(&(0..col)).to_vec(); - r.push_all(pats.index(&((col + 1)..))); + let mut r = pats[0..col].to_vec(); + r.push_all(&pats[(col + 1)..]); Some(r) } else { None @@ -548,7 +548,7 @@ fn enter_opt<'a, 'p, 'blk, 'tcx>( param_env: param_env, }; enter_match(bcx, dm, m, col, val, |pats| - check_match::specialize(&mcx, pats.index(&FullRange), &ctor, col, variant_size) + check_match::specialize(&mcx, &pats[], &ctor, col, variant_size) ) } @@ -789,8 +789,8 @@ fn compare_values<'blk, 'tcx>(cx: Block<'blk, 'tcx>, -> Result<'blk, 'tcx> { let did = langcall(cx, None, - format!("comparison of `{}`", - cx.ty_to_string(rhs_t)).index(&FullRange), + &format!("comparison of `{}`", + cx.ty_to_string(rhs_t))[], StrEqFnLangItem); callee::trans_lang_call(cx, did, &[lhs, rhs], None) } @@ -945,7 +945,7 @@ fn compile_submatch<'a, 'p, 'blk, 'tcx>(bcx: Block<'blk, 'tcx>, if has_nested_bindings(m, col) { let expanded = expand_nested_bindings(bcx, m, col, val); compile_submatch_continue(bcx, - expanded.index(&FullRange), + &expanded[], vals, chk, col, @@ -967,7 +967,7 @@ fn compile_submatch<'a, 'p, 'blk, 'tcx>(bcx: Block<'blk, 'tcx>, bcx = compile_guard(bcx, &**guard_expr, m[0].data, - m.index(&(1..m.len())), + &m[1..m.len()], vals, chk, has_genuine_default); @@ -990,8 +990,8 @@ fn compile_submatch_continue<'a, 'p, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>, let tcx = bcx.tcx(); let dm = &tcx.def_map; - let mut vals_left = vals.index(&(0u..col)).to_vec(); - vals_left.push_all(vals.index(&((col + 1u)..))); + let mut vals_left = vals[0u..col].to_vec(); + vals_left.push_all(&vals[(col + 1u)..]); let ccx = bcx.fcx.ccx; // Find a real id (we're adding placeholder wildcard patterns, but @@ -1191,10 +1191,10 @@ fn compile_submatch_continue<'a, 'p, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>, } let opt_ms = enter_opt(opt_cx, pat_id, dm, m, opt, col, size, val); let mut opt_vals = unpacked; - opt_vals.push_all(vals_left.index(&FullRange)); + opt_vals.push_all(&vals_left[]); compile_submatch(opt_cx, - opt_ms.index(&FullRange), - opt_vals.index(&FullRange), + &opt_ms[], + &opt_vals[], branch_chk.as_ref().unwrap_or(chk), has_genuine_default); } @@ -1213,8 +1213,8 @@ fn compile_submatch_continue<'a, 'p, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>, } _ => { compile_submatch(else_cx, - defaults.index(&FullRange), - vals_left.index(&FullRange), + &defaults[], + &vals_left[], chk, has_genuine_default); } @@ -1333,7 +1333,7 @@ fn create_bindings_map<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, pat: &ast::Pat, "__llmatch"); trmode = TrByCopy(alloca_no_lifetime(bcx, llvariable_ty, - bcx.ident(ident).index(&FullRange))); + &bcx.ident(ident)[])); } ast::BindByValue(_) => { // in this case, the final type of the variable will be T, @@ -1341,13 +1341,13 @@ fn create_bindings_map<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, pat: &ast::Pat, // above llmatch = alloca_no_lifetime(bcx, llvariable_ty.ptr_to(), - bcx.ident(ident).index(&FullRange)); + &bcx.ident(ident)[]); trmode = TrByMove; } ast::BindByRef(_) => { llmatch = alloca_no_lifetime(bcx, llvariable_ty, - bcx.ident(ident).index(&FullRange)); + &bcx.ident(ident)[]); trmode = TrByRef; } }; @@ -1415,7 +1415,7 @@ fn trans_match_inner<'blk, 'tcx>(scope_cx: Block<'blk, 'tcx>, && arm.pats.last().unwrap().node == ast::PatWild(ast::PatWildSingle) }); - compile_submatch(bcx, matches.index(&FullRange), &[discr_datum.val], &chk, has_default); + compile_submatch(bcx, &matches[], &[discr_datum.val], &chk, has_default); let mut arm_cxs = Vec::new(); for arm_data in arm_datas.iter() { @@ -1429,7 +1429,7 @@ fn trans_match_inner<'blk, 'tcx>(scope_cx: Block<'blk, 'tcx>, arm_cxs.push(bcx); } - bcx = scope_cx.fcx.join_blocks(match_id, arm_cxs.index(&FullRange)); + bcx = scope_cx.fcx.join_blocks(match_id, &arm_cxs[]); return bcx; } @@ -1582,7 +1582,7 @@ fn mk_binding_alloca<'blk, 'tcx, A, F>(bcx: Block<'blk, 'tcx>, let var_ty = node_id_type(bcx, p_id); // Allocate memory on stack for the binding. - let llval = alloc_ty(bcx, var_ty, bcx.ident(*ident).index(&FullRange)); + let llval = alloc_ty(bcx, var_ty, &bcx.ident(*ident)[]); // Subtle: be sure that we *populate* the memory *before* // we schedule the cleanup. @@ -1619,8 +1619,8 @@ fn bind_irrefutable_pat<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, pat.repr(bcx.tcx())); if bcx.sess().asm_comments() { - add_comment(bcx, format!("bind_irrefutable_pat(pat={})", - pat.repr(bcx.tcx())).index(&FullRange)); + add_comment(bcx, &format!("bind_irrefutable_pat(pat={})", + pat.repr(bcx.tcx()))[]); } let _indenter = indenter(); diff --git a/src/librustc_trans/trans/adt.rs b/src/librustc_trans/trans/adt.rs index 231de71848a..92883371ec9 100644 --- a/src/librustc_trans/trans/adt.rs +++ b/src/librustc_trans/trans/adt.rs @@ -51,7 +51,11 @@ use std::rc::Rc; use llvm::{ValueRef, True, IntEQ, IntNE}; use back::abi::FAT_PTR_ADDR; use middle::subst; -use middle::subst::Subst; +use middle::ty::{self, Ty, UnboxedClosureTyper}; +use middle::ty::Disr; +use syntax::ast; +use syntax::attr; +use syntax::attr::IntType; use trans::_match; use trans::build::*; use trans::cleanup; @@ -59,13 +63,9 @@ use trans::cleanup::CleanupMethods; use trans::common::*; use trans::datum; use trans::machine; +use trans::monomorphize; use trans::type_::Type; use trans::type_of; -use middle::ty::{self, Ty, UnboxedClosureTyper}; -use middle::ty::Disr; -use syntax::ast; -use syntax::attr; -use syntax::attr::IntType; use util::ppaux::ty_to_string; type Hint = attr::ReprAttr; @@ -154,28 +154,29 @@ fn represent_type_uncached<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> Repr<'tcx> { match t.sty { ty::ty_tup(ref elems) => { - Univariant(mk_struct(cx, elems.index(&FullRange), false, t), false) + Univariant(mk_struct(cx, &elems[], false, t), false) } ty::ty_struct(def_id, substs) => { let fields = ty::lookup_struct_fields(cx.tcx(), def_id); let mut ftys = fields.iter().map(|field| { - ty::lookup_field_type(cx.tcx(), def_id, field.id, substs) + let fty = ty::lookup_field_type(cx.tcx(), def_id, field.id, substs); + monomorphize::normalize_associated_type(cx.tcx(), &fty) }).collect::<Vec<_>>(); let packed = ty::lookup_packed(cx.tcx(), def_id); let dtor = ty::ty_dtor(cx.tcx(), def_id).has_drop_flag(); if dtor { ftys.push(cx.tcx().types.bool); } - Univariant(mk_struct(cx, ftys.index(&FullRange), packed, t), dtor) + Univariant(mk_struct(cx, &ftys[], packed, t), dtor) } ty::ty_unboxed_closure(def_id, _, substs) => { let typer = NormalizingUnboxedClosureTyper::new(cx.tcx()); let upvars = typer.unboxed_closure_upvars(def_id, substs).unwrap(); let upvar_types = upvars.iter().map(|u| u.ty).collect::<Vec<_>>(); - Univariant(mk_struct(cx, upvar_types.index(&FullRange), false, t), false) + Univariant(mk_struct(cx, &upvar_types[], false, t), false) } ty::ty_enum(def_id, substs) => { let cases = get_cases(cx.tcx(), def_id, substs); - let hint = *ty::lookup_repr_hints(cx.tcx(), def_id).index(&FullRange).get(0) + let hint = *ty::lookup_repr_hints(cx.tcx(), def_id)[].get(0) .unwrap_or(&attr::ReprAny); let dtor = ty::ty_dtor(cx.tcx(), def_id).has_drop_flag(); @@ -185,7 +186,7 @@ fn represent_type_uncached<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, // (Typechecking will reject discriminant-sizing attrs.) assert_eq!(hint, attr::ReprAny); let ftys = if dtor { vec!(cx.tcx().types.bool) } else { vec!() }; - return Univariant(mk_struct(cx, ftys.index(&FullRange), false, t), + return Univariant(mk_struct(cx, &ftys[], false, t), dtor); } @@ -205,10 +206,10 @@ fn represent_type_uncached<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, // non-empty body, explicit discriminants should have // been rejected by a checker before this point. if !cases.iter().enumerate().all(|(i,c)| c.discr == (i as Disr)) { - cx.sess().bug(format!("non-C-like enum {} with specified \ + cx.sess().bug(&format!("non-C-like enum {} with specified \ discriminants", ty::item_path_str(cx.tcx(), - def_id)).index(&FullRange)); + def_id))[]); } if cases.len() == 1 { @@ -217,7 +218,7 @@ fn represent_type_uncached<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, assert_eq!(hint, attr::ReprAny); let mut ftys = cases[0].tys.clone(); if dtor { ftys.push(cx.tcx().types.bool); } - return Univariant(mk_struct(cx, ftys.index(&FullRange), false, t), + return Univariant(mk_struct(cx, &ftys[], false, t), dtor); } @@ -226,7 +227,7 @@ fn represent_type_uncached<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, let mut discr = 0; while discr < 2 { if cases[1 - discr].is_zerolen(cx, t) { - let st = mk_struct(cx, cases[discr].tys.index(&FullRange), + let st = mk_struct(cx, &cases[discr].tys[], false, t); match cases[discr].find_ptr(cx) { Some(ref df) if df.len() == 1 && st.fields.len() == 1 => { @@ -316,17 +317,17 @@ fn represent_type_uncached<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, let fields : Vec<_> = cases.iter().map(|c| { let mut ftys = vec!(ty_of_inttype(cx.tcx(), ity)); - ftys.push_all(c.tys.index(&FullRange)); + ftys.push_all(&c.tys[]); if dtor { ftys.push(cx.tcx().types.bool); } - mk_struct(cx, ftys.index(&FullRange), false, t) + mk_struct(cx, &ftys[], false, t) }).collect(); - ensure_enum_fits_in_address_space(cx, ity, fields.index(&FullRange), t); + ensure_enum_fits_in_address_space(cx, ity, &fields[], t); General(ity, fields, dtor) } - _ => cx.sess().bug(format!("adt::represent_type called on non-ADT type: {}", - ty_to_string(cx.tcx(), t)).index(&FullRange)) + _ => cx.sess().bug(&format!("adt::represent_type called on non-ADT type: {}", + ty_to_string(cx.tcx(), t))[]) } } @@ -412,7 +413,7 @@ fn find_discr_field_candidate<'tcx>(tcx: &ty::ctxt<'tcx>, impl<'tcx> Case<'tcx> { fn is_zerolen<'a>(&self, cx: &CrateContext<'a, 'tcx>, scapegoat: Ty<'tcx>) -> bool { - mk_struct(cx, self.tys.index(&FullRange), false, scapegoat).size == 0 + mk_struct(cx, &self.tys[], false, scapegoat).size == 0 } fn find_ptr<'a>(&self, cx: &CrateContext<'a, 'tcx>) -> Option<DiscrField> { @@ -432,7 +433,7 @@ fn get_cases<'tcx>(tcx: &ty::ctxt<'tcx>, -> Vec<Case<'tcx>> { ty::enum_variants(tcx, def_id).iter().map(|vi| { let arg_tys = vi.args.iter().map(|&raw_ty| { - raw_ty.subst(tcx, substs) + monomorphize::apply_param_substs(tcx, substs, &raw_ty) }).collect(); Case { discr: vi.disr_val, tys: arg_tys } }).collect() @@ -451,9 +452,9 @@ fn mk_struct<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, .map(|&ty| type_of::sizing_type_of(cx, ty)).collect() }; - ensure_struct_fits_in_address_space(cx, lltys.index(&FullRange), packed, scapegoat); + ensure_struct_fits_in_address_space(cx, &lltys[], packed, scapegoat); - let llty_rec = Type::struct_(cx, lltys.index(&FullRange), packed); + let llty_rec = Type::struct_(cx, &lltys[], packed); Struct { size: machine::llsize_of_alloc(cx, llty_rec), align: machine::llalign_of_min(cx, llty_rec), @@ -502,7 +503,7 @@ fn range_to_inttype(cx: &CrateContext, hint: Hint, bounds: &IntBounds) -> IntTyp return ity; } attr::ReprExtern => { - attempts = match cx.sess().target.target.arch.index(&FullRange) { + attempts = match &cx.sess().target.target.arch[] { // WARNING: the ARM EABI has two variants; the one corresponding to `at_least_32` // appears to be used on Linux and NetBSD, but some systems may use the variant // corresponding to `choose_shortest`. However, we don't run on those yet...? @@ -628,7 +629,7 @@ pub fn finish_type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, match *r { CEnum(..) | General(..) | RawNullablePointer { .. } => { } Univariant(ref st, _) | StructWrappedNullablePointer { nonnull: ref st, .. } => - llty.set_struct_body(struct_llfields(cx, st, false, false).index(&FullRange), + llty.set_struct_body(&struct_llfields(cx, st, false, false)[], st.packed) } } @@ -644,7 +645,7 @@ fn generic_type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, Univariant(ref st, _) | StructWrappedNullablePointer { nonnull: ref st, .. } => { match name { None => { - Type::struct_(cx, struct_llfields(cx, st, sizing, dst).index(&FullRange), + Type::struct_(cx, &struct_llfields(cx, st, sizing, dst)[], st.packed) } Some(name) => { assert_eq!(sizing, false); Type::named_struct(cx, name) } @@ -663,7 +664,7 @@ fn generic_type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, // of the size. // // FIXME #10604: this breaks when vector types are present. - let (size, align) = union_size_and_align(sts.index(&FullRange)); + let (size, align) = union_size_and_align(&sts[]); let align_s = align as u64; let discr_ty = ll_inttype(cx, ity); let discr_size = machine::llsize_of_alloc(cx, discr_ty); @@ -684,10 +685,10 @@ fn generic_type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, Type::array(&discr_ty, align_s / discr_size - 1), fill_ty]; match name { - None => Type::struct_(cx, fields.index(&FullRange), false), + None => Type::struct_(cx, &fields[], false), Some(name) => { let mut llty = Type::named_struct(cx, name); - llty.set_struct_body(fields.index(&FullRange), false); + llty.set_struct_body(&fields[], false); llty } } @@ -765,7 +766,7 @@ pub fn trans_get_discr<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, r: &Repr<'tcx>, fn struct_wrapped_nullable_bitdiscr(bcx: Block, nndiscr: Disr, discrfield: &DiscrField, scrutinee: ValueRef) -> ValueRef { - let llptrptr = GEPi(bcx, scrutinee, discrfield.index(&FullRange)); + let llptrptr = GEPi(bcx, scrutinee, &discrfield[]); let llptr = Load(bcx, llptrptr); let cmp = if nndiscr == 0 { IntEQ } else { IntNE }; ICmp(bcx, cmp, llptr, C_null(val_ty(llptr))) @@ -853,7 +854,7 @@ pub fn trans_set_discr<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, r: &Repr<'tcx>, } StructWrappedNullablePointer { nndiscr, ref discrfield, .. } => { if discr != nndiscr { - let llptrptr = GEPi(bcx, val, discrfield.index(&FullRange)); + let llptrptr = GEPi(bcx, val, &discrfield[]); let llptrty = val_ty(llptrptr).element_type(); Store(bcx, C_null(llptrty), llptrptr) } @@ -935,7 +936,7 @@ pub fn struct_field_ptr<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, st: &Struct<'tcx>, v let val = if needs_cast { let ccx = bcx.ccx(); let fields = st.fields.iter().map(|&ty| type_of::type_of(ccx, ty)).collect::<Vec<_>>(); - let real_ty = Type::struct_(ccx, fields.index(&FullRange), st.packed); + let real_ty = Type::struct_(ccx, &fields[], st.packed); PointerCast(bcx, val, real_ty.ptr_to()) } else { val @@ -967,14 +968,14 @@ pub fn fold_variants<'blk, 'tcx, F>(bcx: Block<'blk, 'tcx>, for (discr, case) in cases.iter().enumerate() { let mut variant_cx = fcx.new_temp_block( - format!("enum-variant-iter-{}", discr.to_string()).index(&FullRange) + &format!("enum-variant-iter-{}", &discr.to_string())[] ); let rhs_val = C_integral(ll_inttype(ccx, ity), discr as u64, true); AddCase(llswitch, rhs_val, variant_cx.llbb); let fields = case.fields.iter().map(|&ty| type_of::type_of(bcx.ccx(), ty)).collect::<Vec<_>>(); - let real_ty = Type::struct_(ccx, fields.index(&FullRange), case.packed); + let real_ty = Type::struct_(ccx, &fields[], case.packed); let variant_value = PointerCast(variant_cx, value, real_ty.ptr_to()); variant_cx = f(variant_cx, case, variant_value); @@ -1051,14 +1052,14 @@ pub fn trans_const<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, r: &Repr<'tcx>, discr let lldiscr = C_integral(ll_inttype(ccx, ity), discr as u64, true); let mut f = vec![lldiscr]; f.push_all(vals); - let mut contents = build_const_struct(ccx, case, f.index(&FullRange)); + let mut contents = build_const_struct(ccx, case, &f[]); contents.push_all(&[padding(ccx, max_sz - case.size)]); - C_struct(ccx, contents.index(&FullRange), false) + C_struct(ccx, &contents[], false) } Univariant(ref st, _dro) => { assert!(discr == 0); let contents = build_const_struct(ccx, st, vals); - C_struct(ccx, contents.index(&FullRange), st.packed) + C_struct(ccx, &contents[], st.packed) } RawNullablePointer { nndiscr, nnty, .. } => { if discr == nndiscr { @@ -1070,9 +1071,9 @@ pub fn trans_const<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, r: &Repr<'tcx>, discr } StructWrappedNullablePointer { ref nonnull, nndiscr, .. } => { if discr == nndiscr { - C_struct(ccx, build_const_struct(ccx, + C_struct(ccx, &build_const_struct(ccx, nonnull, - vals).index(&FullRange), + vals)[], false) } else { let vals = nonnull.fields.iter().map(|&ty| { @@ -1080,9 +1081,9 @@ pub fn trans_const<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, r: &Repr<'tcx>, discr // field; see #8506. C_null(type_of::sizing_type_of(ccx, ty)) }).collect::<Vec<ValueRef>>(); - C_struct(ccx, build_const_struct(ccx, + C_struct(ccx, &build_const_struct(ccx, nonnull, - vals.index(&FullRange)).index(&FullRange), + &vals[])[], false) } } diff --git a/src/librustc_trans/trans/asm.rs b/src/librustc_trans/trans/asm.rs index 890f046be1b..9b6fa32405f 100644 --- a/src/librustc_trans/trans/asm.rs +++ b/src/librustc_trans/trans/asm.rs @@ -71,7 +71,7 @@ pub fn trans_inline_asm<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, ia: &ast::InlineAsm) callee::DontAutorefArg) }) }).collect::<Vec<_>>(); - inputs.push_all(ext_inputs.index(&FullRange)); + inputs.push_all(&ext_inputs[]); // no failure occurred preparing operands, no need to cleanup fcx.pop_custom_cleanup_scope(temp_scope); @@ -91,18 +91,18 @@ pub fn trans_inline_asm<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, ia: &ast::InlineAsm) if !clobbers.is_empty() { clobbers.push(','); } - clobbers.push_str(more_clobbers.index(&FullRange)); + clobbers.push_str(&more_clobbers[]); } // Add the clobbers to our constraints list if clobbers.len() != 0 && constraints.len() != 0 { constraints.push(','); - constraints.push_str(clobbers.index(&FullRange)); + constraints.push_str(&clobbers[]); } else { - constraints.push_str(clobbers.index(&FullRange)); + constraints.push_str(&clobbers[]); } - debug!("Asm Constraints: {}", constraints.index(&FullRange)); + debug!("Asm Constraints: {}", &constraints[]); let num_outputs = outputs.len(); @@ -112,7 +112,7 @@ pub fn trans_inline_asm<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, ia: &ast::InlineAsm) } else if num_outputs == 1 { output_types[0] } else { - Type::struct_(bcx.ccx(), output_types.index(&FullRange), false) + Type::struct_(bcx.ccx(), &output_types[], false) }; let dialect = match ia.dialect { diff --git a/src/librustc_trans/trans/base.rs b/src/librustc_trans/trans/base.rs index 057d0f378e6..74071a1de4c 100644 --- a/src/librustc_trans/trans/base.rs +++ b/src/librustc_trans/trans/base.rs @@ -249,7 +249,7 @@ fn get_extern_rust_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, fn_ty: Ty<'tcx>, let f = decl_rust_fn(ccx, fn_ty, name); csearch::get_item_attrs(&ccx.sess().cstore, did, |attrs| { - set_llvm_fn_attrs(ccx, attrs.index(&FullRange), f) + set_llvm_fn_attrs(ccx, &attrs[], f) }); ccx.externs().borrow_mut().insert(name.to_string(), f); @@ -281,8 +281,15 @@ pub fn kind_for_unboxed_closure(ccx: &CrateContext, closure_id: ast::DefId) pub fn decl_rust_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, fn_ty: Ty<'tcx>, name: &str) -> ValueRef { + debug!("decl_rust_fn(fn_ty={}, name={:?})", + fn_ty.repr(ccx.tcx()), + name); + let fn_ty = monomorphize::normalize_associated_type(ccx.tcx(), &fn_ty); + debug!("decl_rust_fn: fn_ty={} (after normalized associated types)", + fn_ty.repr(ccx.tcx())); + let function_type; // placeholder so that the memory ownership works out ok let (sig, abi, env) = match fn_ty.sty { @@ -305,10 +312,12 @@ pub fn decl_rust_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, let sig = ty::erase_late_bound_regions(ccx.tcx(), sig); let sig = ty::Binder(sig); + debug!("decl_rust_fn: sig={} (after erasing regions)", + sig.repr(ccx.tcx())); + let llfty = type_of_rust_fn(ccx, env, &sig, abi); - debug!("decl_rust_fn(sig={}, type={})", - sig.repr(ccx.tcx()), + debug!("decl_rust_fn: llfty={}", ccx.tn().type_to_string(llfty)); let llfn = decl_fn(ccx, name, llvm::CCallConv, llfty, sig.0.output /* (1) */); @@ -372,9 +381,9 @@ fn require_alloc_fn<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, match bcx.tcx().lang_items.require(it) { Ok(id) => id, Err(s) => { - bcx.sess().fatal(format!("allocation of `{}` {}", + bcx.sess().fatal(&format!("allocation of `{}` {}", bcx.ty_to_string(info_ty), - s).index(&FullRange)); + s)[]); } } } @@ -493,7 +502,7 @@ pub fn unset_split_stack(f: ValueRef) { // silently mangles such symbols, breaking our linkage model. pub fn note_unique_llvm_symbol(ccx: &CrateContext, sym: String) { if ccx.all_llvm_symbols().borrow().contains(&sym) { - ccx.sess().bug(format!("duplicate LLVM symbol: {}", sym).index(&FullRange)); + ccx.sess().bug(&format!("duplicate LLVM symbol: {}", sym)[]); } ccx.all_llvm_symbols().borrow_mut().insert(sym); } @@ -530,7 +539,7 @@ pub fn get_res_dtor<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, ty::mk_nil(ccx.tcx())); get_extern_fn(ccx, &mut *ccx.externs().borrow_mut(), - name.index(&FullRange), + &name[], llvm::CCallConv, llty, dtor_ty) @@ -778,9 +787,9 @@ pub fn iter_structural_ty<'blk, 'tcx, F>(cx: Block<'blk, 'tcx>, for variant in (*variants).iter() { let variant_cx = fcx.new_temp_block( - format!("enum-iter-variant-{}", - variant.disr_val.to_string().index(&FullRange)) - .index(&FullRange)); + &format!("enum-iter-variant-{}", + &variant.disr_val.to_string()[]) + []); match adt::trans_case(cx, &*repr, variant.disr_val) { _match::SingleResult(r) => { AddCase(llswitch, r.val, variant_cx.llbb) @@ -804,8 +813,8 @@ pub fn iter_structural_ty<'blk, 'tcx, F>(cx: Block<'blk, 'tcx>, } } _ => { - cx.sess().unimpl(format!("type in iter_structural_ty: {}", - ty_to_string(cx.tcx(), t)).index(&FullRange)) + cx.sess().unimpl(&format!("type in iter_structural_ty: {}", + ty_to_string(cx.tcx(), t))[]) } } return cx; @@ -886,8 +895,8 @@ pub fn fail_if_zero_or_overflows<'blk, 'tcx>( (ICmp(cx, llvm::IntEQ, rhs, zero), false) } _ => { - cx.sess().bug(format!("fail-if-zero on unexpected type: {}", - ty_to_string(cx.tcx(), rhs_t)).index(&FullRange)); + cx.sess().bug(&format!("fail-if-zero on unexpected type: {}", + ty_to_string(cx.tcx(), rhs_t))[]); } }; let bcx = with_cond(cx, is_zero, |bcx| { @@ -941,14 +950,14 @@ pub fn trans_external_path<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, ty::ty_bare_fn(_, ref fn_ty) => { match ccx.sess().target.target.adjust_abi(fn_ty.abi) { Rust | RustCall => { - get_extern_rust_fn(ccx, t, name.index(&FullRange), did) + get_extern_rust_fn(ccx, t, &name[], did) } RustIntrinsic => { ccx.sess().bug("unexpected intrinsic in trans_external_path") } _ => { foreign::register_foreign_item_fn(ccx, fn_ty.abi, t, - name.index(&FullRange)) + &name[]) } } } @@ -995,7 +1004,7 @@ pub fn invoke<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, let llresult = Invoke(bcx, llfn, - llargs.index(&FullRange), + &llargs[], normal_bcx.llbb, landing_pad, Some(attributes)); @@ -1011,7 +1020,7 @@ pub fn invoke<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, None => debuginfo::clear_source_location(bcx.fcx) }; - let llresult = Call(bcx, llfn, llargs.index(&FullRange), Some(attributes)); + let llresult = Call(bcx, llfn, &llargs[], Some(attributes)); return (llresult, bcx); } } @@ -1128,7 +1137,7 @@ pub fn call_lifetime_end(cx: Block, ptr: ValueRef) { pub fn call_memcpy(cx: Block, dst: ValueRef, src: ValueRef, n_bytes: ValueRef, align: u32) { let _icx = push_ctxt("call_memcpy"); let ccx = cx.ccx(); - let key = match ccx.sess().target.target.target_word_size.index(&FullRange) { + let key = match &ccx.sess().target.target.target_pointer_width[] { "32" => "llvm.memcpy.p0i8.p0i8.i32", "64" => "llvm.memcpy.p0i8.p0i8.i64", tws => panic!("Unsupported target word size for memcpy: {}", tws), @@ -1175,7 +1184,7 @@ fn memzero<'a, 'tcx>(b: &Builder<'a, 'tcx>, llptr: ValueRef, ty: Ty<'tcx>) { let llty = type_of::type_of(ccx, ty); - let intrinsic_key = match ccx.sess().target.target.target_word_size.index(&FullRange) { + let intrinsic_key = match &ccx.sess().target.target.target_pointer_width[] { "32" => "llvm.memset.p0i8.i32", "64" => "llvm.memset.p0i8.i64", tws => panic!("Unsupported target word size for memset: {}", tws), @@ -1663,7 +1672,7 @@ fn copy_unboxed_closure_args_to_allocas<'blk, 'tcx>( "argtuple", arg_scope_id)); let untupled_arg_types = match monomorphized_arg_types[0].sty { - ty::ty_tup(ref types) => types.index(&FullRange), + ty::ty_tup(ref types) => &types[], _ => { bcx.tcx().sess.span_bug(args[0].pat.span, "first arg to `rust-call` ABI function \ @@ -1851,12 +1860,12 @@ pub fn trans_closure<'a, 'b, 'tcx>(ccx: &CrateContext<'a, 'tcx>, let arg_datums = if abi != RustCall { create_datums_for_fn_args(&fcx, - monomorphized_arg_types.index(&FullRange)) + &monomorphized_arg_types[]) } else { create_datums_for_fn_args_under_call_abi( bcx, arg_scope, - monomorphized_arg_types.index(&FullRange)) + &monomorphized_arg_types[]) }; bcx = match closure_env.kind { @@ -1864,16 +1873,16 @@ pub fn trans_closure<'a, 'b, 'tcx>(ccx: &CrateContext<'a, 'tcx>, copy_args_to_allocas(&fcx, arg_scope, bcx, - decl.inputs.index(&FullRange), + &decl.inputs[], arg_datums) } closure::UnboxedClosure(..) => { copy_unboxed_closure_args_to_allocas( bcx, arg_scope, - decl.inputs.index(&FullRange), + &decl.inputs[], arg_datums, - monomorphized_arg_types.index(&FullRange)) + &monomorphized_arg_types[]) } }; @@ -1990,9 +1999,9 @@ pub fn trans_named_tuple_constructor<'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>, ty::erase_late_bound_regions(bcx.tcx(), &bft.sig.output()).unwrap() } _ => ccx.sess().bug( - format!("trans_enum_variant_constructor: \ + &format!("trans_enum_variant_constructor: \ unexpected ctor return type {}", - ctor_ty.repr(tcx)).index(&FullRange)) + ctor_ty.repr(tcx))[]) }; // Get location to store the result. If the user does not care about @@ -2015,7 +2024,7 @@ pub fn trans_named_tuple_constructor<'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>, bcx = expr::trans_adt(bcx, result_ty, disr, - fields.index(&FullRange), + &fields[], None, expr::SaveIn(llresult), call_info); @@ -2064,9 +2073,9 @@ fn trans_enum_variant_or_tuple_like_struct<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx ty::erase_late_bound_regions(ccx.tcx(), &bft.sig.output()) } _ => ccx.sess().bug( - format!("trans_enum_variant_or_tuple_like_struct: \ + &format!("trans_enum_variant_or_tuple_like_struct: \ unexpected ctor return type {}", - ty_to_string(ccx.tcx(), ctor_ty)).index(&FullRange)) + ty_to_string(ccx.tcx(), ctor_ty))[]) }; let arena = TypedArena::new(); @@ -2080,7 +2089,7 @@ fn trans_enum_variant_or_tuple_like_struct<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx ty::erase_late_bound_regions( ccx.tcx(), &ty::ty_fn_args(ctor_ty)); - let arg_datums = create_datums_for_fn_args(&fcx, arg_tys.index(&FullRange)); + let arg_datums = create_datums_for_fn_args(&fcx, &arg_tys[]); if !type_is_zero_size(fcx.ccx, result_ty.unwrap()) { let dest = fcx.get_ret_slot(bcx, result_ty, "eret_slot"); @@ -2164,9 +2173,9 @@ fn enum_variant_size_lint(ccx: &CrateContext, enum_def: &ast::EnumDef, sp: Span, // pass for the latter already ran. lint::raw_emit_lint(&ccx.tcx().sess, lint::builtin::VARIANT_SIZE_DIFFERENCES, *lvlsrc.unwrap(), Some(sp), - format!("enum variant is more than three times larger \ + &format!("enum variant is more than three times larger \ ({} bytes) than the next largest (ignoring padding)", - largest).index(&FullRange)); + largest)[]); ccx.sess().span_note(enum_def.variants[largest_index].span, "this variant is the largest"); @@ -2284,7 +2293,7 @@ pub fn trans_item(ccx: &CrateContext, item: &ast::Item) { match item.node { ast::ItemFn(ref decl, _fn_style, abi, ref generics, ref body) => { if !generics.is_type_parameterized() { - let trans_everywhere = attr::requests_inline(item.attrs.index(&FullRange)); + let trans_everywhere = attr::requests_inline(&item.attrs[]); // Ignore `trans_everywhere` for cross-crate inlined items // (`from_external`). `trans_item` will be called once for each // compilation unit that references the item, so it will still get @@ -2295,7 +2304,7 @@ pub fn trans_item(ccx: &CrateContext, item: &ast::Item) { foreign::trans_rust_fn_with_foreign_abi(ccx, &**decl, &**body, - item.attrs.index(&FullRange), + &item.attrs[], llfn, &Substs::trans_empty(), item.id, @@ -2307,7 +2316,7 @@ pub fn trans_item(ccx: &CrateContext, item: &ast::Item) { llfn, &Substs::trans_empty(), item.id, - item.attrs.index(&FullRange)); + &item.attrs[]); } update_linkage(ccx, llfn, @@ -2324,7 +2333,7 @@ pub fn trans_item(ccx: &CrateContext, item: &ast::Item) { ast::ItemImpl(_, _, ref generics, _, _, ref impl_items) => { meth::trans_impl(ccx, item.ident, - impl_items.index(&FullRange), + &impl_items[], generics, item.id); } @@ -2354,7 +2363,7 @@ pub fn trans_item(ccx: &CrateContext, item: &ast::Item) { // Do static_assert checking. It can't really be done much earlier // because we need to get the value of the bool out of LLVM - if attr::contains_name(item.attrs.index(&FullRange), "static_assert") { + if attr::contains_name(&item.attrs[], "static_assert") { if m == ast::MutMutable { ccx.sess().span_fatal(expr.span, "cannot have static_assert on a mutable \ @@ -2431,7 +2440,7 @@ fn register_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, _ => panic!("expected bare rust fn") }; - let llfn = decl_rust_fn(ccx, node_type, sym.index(&FullRange)); + let llfn = decl_rust_fn(ccx, node_type, &sym[]); finish_register_fn(ccx, sp, sym, node_id, llfn); llfn } @@ -2476,7 +2485,7 @@ pub fn get_fn_llvm_attributes<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, fn_ty: Ty< match fn_sig.inputs[1].sty { ty::ty_tup(ref t_in) => { - inputs.push_all(t_in.index(&FullRange)); + inputs.push_all(&t_in[]); inputs } _ => ccx.sess().bug("expected tuple'd inputs") @@ -2612,7 +2621,7 @@ pub fn register_fn_llvmty(ccx: &CrateContext, debug!("register_fn_llvmty id={} sym={}", node_id, sym); let llfn = decl_fn(ccx, - sym.index(&FullRange), + &sym[], cc, llfty, ty::FnConverging(ty::mk_nil(ccx.tcx()))); @@ -2668,7 +2677,7 @@ pub fn create_entry_wrapper(ccx: &CrateContext, let (start_fn, args) = if use_start_lang_item { let start_def_id = match ccx.tcx().lang_items.require(StartFnLangItem) { Ok(id) => id, - Err(s) => { ccx.sess().fatal(s.index(&FullRange)); } + Err(s) => { ccx.sess().fatal(&s[]); } }; let start_fn = if start_def_id.krate == ast::LOCAL_CRATE { get_item_val(ccx, start_def_id.node) @@ -2760,7 +2769,7 @@ pub fn get_item_val(ccx: &CrateContext, id: ast::NodeId) -> ValueRef { let val = match item { ast_map::NodeItem(i) => { let ty = ty::node_id_to_type(ccx.tcx(), i.id); - let sym = |&:| exported_name(ccx, id, ty, i.attrs.index(&FullRange)); + let sym = |&:| exported_name(ccx, id, ty, &i.attrs[]); let v = match i.node { ast::ItemStatic(_, _, ref expr) => { @@ -2783,16 +2792,16 @@ pub fn get_item_val(ccx: &CrateContext, id: ast::NodeId) -> ValueRef { } else { llvm::LLVMTypeOf(v) }; - if contains_null(sym.index(&FullRange)) { + if contains_null(&sym[]) { ccx.sess().fatal( - format!("Illegal null byte in export_name \ - value: `{}`", sym).index(&FullRange)); + &format!("Illegal null byte in export_name \ + value: `{}`", sym)[]); } let buf = CString::from_slice(sym.as_bytes()); let g = llvm::LLVMAddGlobal(ccx.llmod(), llty, buf.as_ptr()); - if attr::contains_name(i.attrs.index(&FullRange), + if attr::contains_name(&i.attrs[], "thread_local") { llvm::set_thread_local(g, true); } @@ -2817,19 +2826,19 @@ pub fn get_item_val(ccx: &CrateContext, id: ast::NodeId) -> ValueRef { sym, i.id) }; - set_llvm_fn_attrs(ccx, i.attrs.index(&FullRange), llfn); + set_llvm_fn_attrs(ccx, &i.attrs[], llfn); llfn } _ => panic!("get_item_val: weird result in table") }; - match attr::first_attr_value_str_by_name(i.attrs.index(&FullRange), + match attr::first_attr_value_str_by_name(&i.attrs[], "link_section") { Some(sect) => { if contains_null(sect.get()) { - ccx.sess().fatal(format!("Illegal null byte in link_section value: `{}`", - sect.get()).index(&FullRange)); + ccx.sess().fatal(&format!("Illegal null byte in link_section value: `{}`", + sect.get())[]); } unsafe { let buf = CString::from_slice(sect.get().as_bytes()); @@ -2872,7 +2881,7 @@ pub fn get_item_val(ccx: &CrateContext, id: ast::NodeId) -> ValueRef { let abi = ccx.tcx().map.get_foreign_abi(id); let ty = ty::node_id_to_type(ccx.tcx(), ni.id); let name = foreign::link_name(&*ni); - foreign::register_foreign_item_fn(ccx, abi, ty, name.get().index(&FullRange)) + foreign::register_foreign_item_fn(ccx, abi, ty, &name.get()[]) } ast::ForeignItemStatic(..) => { foreign::register_static(ccx, &*ni) @@ -2895,7 +2904,7 @@ pub fn get_item_val(ccx: &CrateContext, id: ast::NodeId) -> ValueRef { let sym = exported_name(ccx, id, ty, - enm.attrs.index(&FullRange)); + &enm.attrs[]); llfn = match enm.node { ast::ItemEnum(_, _) => { @@ -2922,8 +2931,7 @@ pub fn get_item_val(ccx: &CrateContext, id: ast::NodeId) -> ValueRef { let sym = exported_name(ccx, id, ty, - struct_item.attrs - .index(&FullRange)); + &struct_item.attrs[]); let llfn = register_fn(ccx, struct_item.span, sym, ctor_id, ty); set_inline_hint(llfn); @@ -2931,8 +2939,8 @@ pub fn get_item_val(ccx: &CrateContext, id: ast::NodeId) -> ValueRef { } ref variant => { - ccx.sess().bug(format!("get_item_val(): unexpected variant: {:?}", - variant).index(&FullRange)) + ccx.sess().bug(&format!("get_item_val(): unexpected variant: {:?}", + variant)[]) } }; @@ -2953,10 +2961,10 @@ fn register_method(ccx: &CrateContext, id: ast::NodeId, m: &ast::Method) -> ValueRef { let mty = ty::node_id_to_type(ccx.tcx(), id); - let sym = exported_name(ccx, id, mty, m.attrs.index(&FullRange)); + let sym = exported_name(ccx, id, mty, &m.attrs[]); let llfn = register_fn(ccx, m.span, sym, id, mty); - set_llvm_fn_attrs(ccx, m.attrs.index(&FullRange), llfn); + set_llvm_fn_attrs(ccx, &m.attrs[], llfn); llfn } @@ -2995,7 +3003,7 @@ pub fn write_metadata(cx: &SharedCrateContext, krate: &ast::Crate) -> Vec<u8> { Some(compressed) => compressed, None => cx.sess().fatal("failed to compress metadata"), }.as_slice()); - let llmeta = C_bytes_in_context(cx.metadata_llcx(), compressed.index(&FullRange)); + let llmeta = C_bytes_in_context(cx.metadata_llcx(), &compressed[]); let llconst = C_struct_in_context(cx.metadata_llcx(), &[llmeta], false); let name = format!("rust_metadata_{}_{}", cx.link_meta().crate_name, @@ -3124,7 +3132,7 @@ pub fn trans_crate<'tcx>(analysis: ty::CrateAnalysis<'tcx>) let link_meta = link::build_link_meta(&tcx.sess, krate, name); let codegen_units = tcx.sess.opts.cg.codegen_units; - let shared_ccx = SharedCrateContext::new(link_meta.crate_name.index(&FullRange), + let shared_ccx = SharedCrateContext::new(&link_meta.crate_name[], codegen_units, tcx, export_map, @@ -3226,7 +3234,7 @@ pub fn trans_crate<'tcx>(analysis: ty::CrateAnalysis<'tcx>) llmod: shared_ccx.metadata_llmod(), }; let formats = shared_ccx.tcx().dependency_formats.borrow().clone(); - let no_builtins = attr::contains_name(krate.attrs.index(&FullRange), "no_builtins"); + let no_builtins = attr::contains_name(&krate.attrs[], "no_builtins"); let translation = CrateTranslation { modules: modules, diff --git a/src/librustc_trans/trans/builder.rs b/src/librustc_trans/trans/builder.rs index d0eaf799af1..b80088e4690 100644 --- a/src/librustc_trans/trans/builder.rs +++ b/src/librustc_trans/trans/builder.rs @@ -552,11 +552,11 @@ impl<'a, 'tcx> Builder<'a, 'tcx> { for (small_vec_e, &ix) in small_vec.iter_mut().zip(ixs.iter()) { *small_vec_e = C_i32(self.ccx, ix as i32); } - self.inbounds_gep(base, small_vec.index(&(0..ixs.len()))) + self.inbounds_gep(base, &small_vec[0..ixs.len()]) } else { let v = ixs.iter().map(|i| C_i32(self.ccx, *i as i32)).collect::<Vec<ValueRef>>(); self.count_insn("gepi"); - self.inbounds_gep(base, v.index(&FullRange)) + self.inbounds_gep(base, &v[]) } } @@ -764,8 +764,8 @@ impl<'a, 'tcx> Builder<'a, 'tcx> { let s = format!("{} ({})", text, self.ccx.sess().codemap().span_to_string(sp)); - debug!("{}", s.index(&FullRange)); - self.add_comment(s.index(&FullRange)); + debug!("{}", &s[]); + self.add_comment(&s[]); } } @@ -802,7 +802,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> { }).collect::<Vec<_>>(); debug!("Asm Output Type: {}", self.ccx.tn().type_to_string(output)); - let fty = Type::func(argtys.index(&FullRange), &output); + let fty = Type::func(&argtys[], &output); unsafe { let v = llvm::LLVMInlineAsm( fty.to_ref(), asm, cons, volatile, alignstack, dia as c_uint); diff --git a/src/librustc_trans/trans/cabi.rs b/src/librustc_trans/trans/cabi.rs index a901142467b..8a2a2534cab 100644 --- a/src/librustc_trans/trans/cabi.rs +++ b/src/librustc_trans/trans/cabi.rs @@ -108,7 +108,7 @@ pub fn compute_abi_info(ccx: &CrateContext, atys: &[Type], rty: Type, ret_def: bool) -> FnType { - match ccx.sess().target.target.arch.index(&FullRange) { + match &ccx.sess().target.target.arch[] { "x86" => cabi_x86::compute_abi_info(ccx, atys, rty, ret_def), "x86_64" => if ccx.sess().target.target.options.is_like_windows { cabi_x86_win64::compute_abi_info(ccx, atys, rty, ret_def) @@ -118,7 +118,7 @@ pub fn compute_abi_info(ccx: &CrateContext, "arm" => cabi_arm::compute_abi_info(ccx, atys, rty, ret_def), "aarch64" => cabi_aarch64::compute_abi_info(ccx, atys, rty, ret_def), "mips" => cabi_mips::compute_abi_info(ccx, atys, rty, ret_def), - a => ccx.sess().fatal((format!("unrecognized arch \"{}\" in target specification", a)) - .index(&FullRange)), + a => ccx.sess().fatal(&format!("unrecognized arch \"{}\" in target specification", a) + []), } } diff --git a/src/librustc_trans/trans/cabi_x86_64.rs b/src/librustc_trans/trans/cabi_x86_64.rs index f40072d1cba..86190b1e566 100644 --- a/src/librustc_trans/trans/cabi_x86_64.rs +++ b/src/librustc_trans/trans/cabi_x86_64.rs @@ -318,7 +318,7 @@ fn llreg_ty(ccx: &CrateContext, cls: &[RegClass]) -> Type { tys.push(Type::i64(ccx)); } SSEFv => { - let vec_len = llvec_len(cls.index(&((i + 1u)..))); + let vec_len = llvec_len(&cls[(i + 1u)..]); let vec_ty = Type::vector(&Type::f32(ccx), (vec_len * 2u) as u64); tys.push(vec_ty); i += vec_len; diff --git a/src/librustc_trans/trans/callee.rs b/src/librustc_trans/trans/callee.rs index b7b486f1d0a..6196f9e5eab 100644 --- a/src/librustc_trans/trans/callee.rs +++ b/src/librustc_trans/trans/callee.rs @@ -112,9 +112,9 @@ fn trans<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, expr: &ast::Expr) _ => { bcx.tcx().sess.span_bug( expr.span, - format!("type of callee is neither bare-fn nor closure: \ + &format!("type of callee is neither bare-fn nor closure: \ {}", - bcx.ty_to_string(datum.ty)).index(&FullRange)); + bcx.ty_to_string(datum.ty))[]); } } } @@ -206,8 +206,8 @@ fn trans<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, expr: &ast::Expr) def::DefSelfTy(..) | def::DefAssociatedPath(..) => { bcx.tcx().sess.span_bug( ref_expr.span, - format!("cannot translate def {:?} \ - to a callable thing!", def).index(&FullRange)); + &format!("cannot translate def {:?} \ + to a callable thing!", def)[]); } } } @@ -265,7 +265,7 @@ pub fn trans_fn_pointer_shim<'a, 'tcx>( let _icx = push_ctxt("trans_fn_pointer_shim"); let tcx = ccx.tcx(); - let bare_fn_ty = normalize_ty(tcx, bare_fn_ty); + let bare_fn_ty = erase_regions(tcx, &bare_fn_ty); match ccx.fn_pointer_shims().borrow().get(&bare_fn_ty) { Some(&llval) => { return llval; } None => { } @@ -289,8 +289,8 @@ pub fn trans_fn_pointer_shim<'a, 'tcx>( } _ => { - tcx.sess.bug(format!("trans_fn_pointer_shim invoked on invalid type: {}", - bare_fn_ty.repr(tcx)).index(&FullRange)); + tcx.sess.bug(&format!("trans_fn_pointer_shim invoked on invalid type: {}", + bare_fn_ty.repr(tcx))[]); } }; let sig = ty::erase_late_bound_regions(tcx, sig); @@ -315,7 +315,7 @@ pub fn trans_fn_pointer_shim<'a, 'tcx>( let llfn = decl_internal_rust_fn(ccx, tuple_fn_ty, - function_name.index(&FullRange)); + &function_name[]); // let block_arena = TypedArena::new(); @@ -350,7 +350,7 @@ pub fn trans_fn_pointer_shim<'a, 'tcx>( None, bare_fn_ty, |bcx, _| Callee { bcx: bcx, data: Fn(llfnpointer) }, - ArgVals(llargs.index(&FullRange)), + ArgVals(&llargs[]), dest).bcx; finish_fn(&fcx, bcx, sig.output); @@ -776,7 +776,7 @@ pub fn trans_call_inner<'a, 'blk, 'tcx, F>(bcx: Block<'blk, 'tcx>, // Invoke the actual rust fn and update bcx/llresult. let (llret, b) = base::invoke(bcx, llfn, - llargs.index(&FullRange), + &llargs[], callee_ty, call_info); bcx = b; @@ -815,7 +815,7 @@ pub fn trans_call_inner<'a, 'blk, 'tcx, F>(bcx: Block<'blk, 'tcx>, bcx = foreign::trans_native_call(bcx, callee_ty, llfn, opt_llretslot.unwrap(), - llargs.index(&FullRange), arg_tys); + &llargs[], arg_tys); } fcx.pop_and_trans_custom_cleanup_scope(bcx, arg_cleanup_scope); diff --git a/src/librustc_trans/trans/cleanup.rs b/src/librustc_trans/trans/cleanup.rs index 92a96cd02b5..5658889aaf3 100644 --- a/src/librustc_trans/trans/cleanup.rs +++ b/src/librustc_trans/trans/cleanup.rs @@ -403,8 +403,8 @@ impl<'blk, 'tcx> CleanupMethods<'blk, 'tcx> for FunctionContext<'blk, 'tcx> { } self.ccx.sess().bug( - format!("no cleanup scope {} found", - self.ccx.tcx().map.node_to_string(cleanup_scope)).index(&FullRange)); + &format!("no cleanup scope {} found", + self.ccx.tcx().map.node_to_string(cleanup_scope))[]); } /// Schedules a cleanup to occur in the top-most scope, which must be a temporary scope. @@ -584,9 +584,9 @@ impl<'blk, 'tcx> CleanupHelperMethods<'blk, 'tcx> for FunctionContext<'blk, 'tcx } LoopExit(id, _) => { - self.ccx.sess().bug(format!( + self.ccx.sess().bug(&format!( "cannot exit from scope {}, \ - not in scope", id).index(&FullRange)); + not in scope", id)[]); } } } @@ -655,7 +655,7 @@ impl<'blk, 'tcx> CleanupHelperMethods<'blk, 'tcx> for FunctionContext<'blk, 'tcx let name = scope.block_name("clean"); debug!("generating cleanups for {}", name); let bcx_in = self.new_block(label.is_unwind(), - name.index(&FullRange), + &name[], None); let mut bcx_out = bcx_in; for cleanup in scope.cleanups.iter().rev() { @@ -702,7 +702,7 @@ impl<'blk, 'tcx> CleanupHelperMethods<'blk, 'tcx> for FunctionContext<'blk, 'tcx Some(llbb) => { return llbb; } None => { let name = last_scope.block_name("unwind"); - pad_bcx = self.new_block(true, name.index(&FullRange), None); + pad_bcx = self.new_block(true, &name[], None); last_scope.cached_landing_pad = Some(pad_bcx.llbb); } } @@ -1022,8 +1022,8 @@ pub fn temporary_scope(tcx: &ty::ctxt, r } None => { - tcx.sess.bug(format!("no temporary scope available for expr {}", - id).index(&FullRange)) + tcx.sess.bug(&format!("no temporary scope available for expr {}", + id)[]) } } } diff --git a/src/librustc_trans/trans/closure.rs b/src/librustc_trans/trans/closure.rs index ad2ed67b22c..8989dfd4932 100644 --- a/src/librustc_trans/trans/closure.rs +++ b/src/librustc_trans/trans/closure.rs @@ -154,7 +154,7 @@ pub fn store_environment<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, let tcx = ccx.tcx(); // compute the type of the closure - let cdata_ty = mk_closure_tys(tcx, bound_values.index(&FullRange)); + let cdata_ty = mk_closure_tys(tcx, &bound_values[]); // cbox_ty has the form of a tuple: (a, b, c) we want a ptr to a // tuple. This could be a ptr in uniq or a box or on stack, @@ -182,8 +182,8 @@ pub fn store_environment<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, debug!("Copy {} into closure", bv.to_string(ccx)); if ccx.sess().asm_comments() { - add_comment(bcx, format!("Copy {} into closure", - bv.to_string(ccx)).index(&FullRange)); + add_comment(bcx, &format!("Copy {} into closure", + bv.to_string(ccx))[]); } let bound_data = GEPi(bcx, llbox, &[0u, abi::BOX_FIELD_BODY, i]); @@ -420,7 +420,7 @@ pub fn trans_expr_fn<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, let s = tcx.map.with_path(id, |path| { mangle_internal_name_by_path_and_seq(path, "closure") }); - let llfn = decl_internal_rust_fn(ccx, fty, s.index(&FullRange)); + let llfn = decl_internal_rust_fn(ccx, fty, &s[]); // set an inline hint for all closures set_inline_hint(llfn); @@ -444,7 +444,7 @@ pub fn trans_expr_fn<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, &[], ty::erase_late_bound_regions(ccx.tcx(), &ty::ty_fn_ret(fty)), ty::ty_fn_abi(fty), - ClosureEnv::new(freevars.index(&FullRange), + ClosureEnv::new(&freevars[], BoxedClosure(cdata_ty, store))); fill_fn_pair(bcx, dest_addr, llfn, llbox); bcx @@ -466,7 +466,7 @@ pub fn get_or_create_declaration_if_unboxed_closure<'a, 'tcx>(ccx: &CrateContext // Normalize type so differences in regions and typedefs don't cause // duplicate declarations - let function_type = normalize_ty(ccx.tcx(), function_type); + let function_type = erase_regions(ccx.tcx(), &function_type); let params = match function_type.sty { ty::ty_unboxed_closure(_, _, ref substs) => substs.types.clone(), _ => unreachable!() @@ -489,7 +489,7 @@ pub fn get_or_create_declaration_if_unboxed_closure<'a, 'tcx>(ccx: &CrateContext mangle_internal_name_by_path_and_seq(path, "unboxed_closure") }); - let llfn = decl_internal_rust_fn(ccx, function_type, symbol.index(&FullRange)); + let llfn = decl_internal_rust_fn(ccx, function_type, &symbol[]); // set an inline hint for all closures set_inline_hint(llfn); @@ -544,7 +544,7 @@ pub fn trans_unboxed_closure<'blk, 'tcx>( &[], sig.output, function_type.abi, - ClosureEnv::new(freevars.index(&FullRange), + ClosureEnv::new(&freevars[], UnboxedClosure(freevar_mode))); // Don't hoist this to the top of the function. It's perfectly legitimate diff --git a/src/librustc_trans/trans/common.rs b/src/librustc_trans/trans/common.rs index 237fc185636..ab5b563b99c 100644 --- a/src/librustc_trans/trans/common.rs +++ b/src/librustc_trans/trans/common.rs @@ -50,7 +50,7 @@ use std::vec::Vec; use syntax::ast::Ident; use syntax::ast; use syntax::ast_map::{PathElem, PathName}; -use syntax::codemap::Span; +use syntax::codemap::{DUMMY_SP, Span}; use syntax::parse::token::InternedString; use syntax::parse::token; use util::common::memoized; @@ -58,16 +58,21 @@ use util::nodemap::FnvHashSet; pub use trans::context::CrateContext; -/// Returns an equivalent type with all the typedefs and self regions removed. -pub fn normalize_ty<'tcx>(cx: &ty::ctxt<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> { - let u = TypeNormalizer(cx).fold_ty(ty); - debug!("normalize_ty({}) = {}", - ty.repr(cx), u.repr(cx)); - return u; +/// Returns an equivalent value with all free regions removed (note +/// that late-bound regions remain, because they are important for +/// subtyping, but they are anonymized and normalized as well). This +/// is a stronger, caching version of `ty_fold::erase_regions`. +pub fn erase_regions<'tcx,T>(cx: &ty::ctxt<'tcx>, value: &T) -> T + where T : TypeFoldable<'tcx> + Repr<'tcx> +{ + let value1 = value.fold_with(&mut RegionEraser(cx)); + debug!("erase_regions({}) = {}", + value.repr(cx), value1.repr(cx)); + return value1; - struct TypeNormalizer<'a, 'tcx: 'a>(&'a ty::ctxt<'tcx>); + struct RegionEraser<'a, 'tcx: 'a>(&'a ty::ctxt<'tcx>); - impl<'a, 'tcx> TypeFolder<'tcx> for TypeNormalizer<'a, 'tcx> { + impl<'a, 'tcx> TypeFolder<'tcx> for RegionEraser<'a, 'tcx> { fn tcx(&self) -> &ty::ctxt<'tcx> { self.0 } fn fold_ty(&mut self, ty: Ty<'tcx>) -> Ty<'tcx> { @@ -84,7 +89,6 @@ pub fn normalize_ty<'tcx>(cx: &ty::ctxt<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> { fn fold_binder<T>(&mut self, t: &ty::Binder<T>) -> ty::Binder<T> where T : TypeFoldable<'tcx> + Repr<'tcx> { - // FIXME(#20526) this should replace `enter_region_binder`/`exit_region_binder`. let u = ty::anonymize_late_bound_regions(self.tcx(), t); ty_fold::super_fold_binder(self, &u) } @@ -114,8 +118,9 @@ pub fn normalize_ty<'tcx>(cx: &ty::ctxt<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> { } // Is the type's representation size known at compile time? -pub fn type_is_sized<'tcx>(cx: &ty::ctxt<'tcx>, ty: Ty<'tcx>) -> bool { -ty::type_contents(cx, ty).is_sized(cx) +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 { @@ -273,7 +278,7 @@ pub fn gensym_name(name: &str) -> PathElem { let num = token::gensym(name).uint(); // use one colon which will get translated to a period by the mangler, and // we're guaranteed that `num` is globally unique for this crate. -PathName(token::gensym(format!("{}:{}", name, num).index(&FullRange))) +PathName(token::gensym(&format!("{}:{}", name, num)[])) } #[derive(Copy)] @@ -600,8 +605,8 @@ pub fn def(&self, nid: ast::NodeId) -> def::Def { match self.tcx().def_map.borrow().get(&nid) { Some(v) => v.clone(), None => { - self.tcx().sess.bug(format!( - "no def associated with node id {}", nid).index(&FullRange)); + self.tcx().sess.bug(&format!( + "no def associated with node id {}", nid)[]); } } } @@ -988,7 +993,7 @@ pub fn fulfill_obligation<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, let tcx = ccx.tcx(); // Remove any references to regions; this helps improve caching. -let trait_ref = ty_fold::erase_regions(tcx, trait_ref); +let trait_ref = erase_regions(tcx, &trait_ref); // First check the cache. match ccx.trait_cache().borrow().get(&trait_ref) { @@ -1029,9 +1034,9 @@ let selection = match selcx.select(&obligation) { Err(e) => { tcx.sess.span_bug( span, - format!("Encountered error `{}` selecting `{}` during trans", + &format!("Encountered error `{}` selecting `{}` during trans", e.repr(tcx), - trait_ref.repr(tcx)).index(&FullRange)) + trait_ref.repr(tcx))[]) } }; @@ -1123,8 +1128,8 @@ match fulfill_cx.select_all_or_error(infcx, &typer) { } else { infcx.tcx.sess.span_bug( span, - format!("Encountered errors `{}` fulfilling during trans", - errors.repr(infcx.tcx)).index(&FullRange)); + &format!("Encountered errors `{}` fulfilling during trans", + errors.repr(infcx.tcx))[]); } } } @@ -1163,8 +1168,8 @@ let substs = match node { }; if substs.types.any(|t| ty::type_needs_infer(*t)) { - tcx.sess.bug(format!("type parameters for node {:?} include inference types: {:?}", - node, substs.repr(tcx)).index(&FullRange)); + tcx.sess.bug(&format!("type parameters for node {:?} include inference types: {:?}", + node, substs.repr(tcx))[]); } monomorphize::apply_param_substs(tcx, @@ -1182,8 +1187,8 @@ pub fn langcall(bcx: Block, Err(s) => { let msg = format!("{} {}", msg, s); match span { - Some(span) => bcx.tcx().sess.span_fatal(span, msg.index(&FullRange)), - None => bcx.tcx().sess.fatal(msg.index(&FullRange)), + Some(span) => bcx.tcx().sess.span_fatal(span, &msg[]), + None => bcx.tcx().sess.fatal(&msg[]), } } } diff --git a/src/librustc_trans/trans/consts.rs b/src/librustc_trans/trans/consts.rs index b0474d7e011..00b97286de3 100644 --- a/src/librustc_trans/trans/consts.rs +++ b/src/librustc_trans/trans/consts.rs @@ -52,9 +52,9 @@ pub fn const_lit(cx: &CrateContext, e: &ast::Expr, lit: &ast::Lit) C_integral(Type::uint_from_ty(cx, t), i as u64, false) } _ => cx.sess().span_bug(lit.span, - format!("integer literal has type {} (expected int \ + &format!("integer literal has type {} (expected int \ or uint)", - ty_to_string(cx.tcx(), lit_int_ty)).index(&FullRange)) + ty_to_string(cx.tcx(), lit_int_ty))[]) } } ast::LitFloat(ref fs, t) => { @@ -74,7 +74,7 @@ pub fn const_lit(cx: &CrateContext, e: &ast::Expr, lit: &ast::Lit) } ast::LitBool(b) => C_bool(cx, b), ast::LitStr(ref s, _) => C_str_slice(cx, (*s).clone()), - ast::LitBinary(ref data) => C_binary_slice(cx, data.index(&FullRange)), + ast::LitBinary(ref data) => C_binary_slice(cx, &data[]), } } @@ -93,9 +93,9 @@ fn const_vec(cx: &CrateContext, e: &ast::Expr, .collect::<Vec<_>>(); // If the vector contains enums, an LLVM array won't work. let v = if vs.iter().any(|vi| val_ty(*vi) != llunitty) { - C_struct(cx, vs.index(&FullRange), false) + C_struct(cx, &vs[], false) } else { - C_array(llunitty, vs.index(&FullRange)) + C_array(llunitty, &vs[]) }; (v, llunitty) } @@ -148,14 +148,14 @@ fn const_deref<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, v: ValueRef, (const_deref_newtype(cx, v, t), mt.ty) } _ => { - cx.sess().bug(format!("unexpected dereferenceable type {}", - ty_to_string(cx.tcx(), t)).index(&FullRange)) + cx.sess().bug(&format!("unexpected dereferenceable type {}", + ty_to_string(cx.tcx(), t))[]) } } } None => { - cx.sess().bug(format!("cannot dereference const of type {}", - ty_to_string(cx.tcx(), t)).index(&FullRange)) + cx.sess().bug(&format!("cannot dereference const of type {}", + ty_to_string(cx.tcx(), t))[]) } } } @@ -251,16 +251,16 @@ pub fn const_expr<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, e: &ast::Expr) ], false); } _ => cx.sess().span_bug(e.span, - format!("unimplemented type in const unsize: {}", - ty_to_string(cx.tcx(), ty)).index(&FullRange)) + &format!("unimplemented type in const unsize: {}", + ty_to_string(cx.tcx(), ty))[]) } } _ => { cx.sess() .span_bug(e.span, - format!("unimplemented const \ + &format!("unimplemented const \ autoref {:?}", - autoref).index(&FullRange)) + autoref)[]) } } } @@ -279,9 +279,9 @@ pub fn const_expr<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, e: &ast::Expr) llvm::LLVMDumpValue(llconst); llvm::LLVMDumpValue(C_undef(llty)); } - cx.sess().bug(format!("const {} of type {} has size {} instead of {}", + cx.sess().bug(&format!("const {} of type {} has size {} instead of {}", e.repr(cx.tcx()), ty_to_string(cx.tcx(), ety), - csize, tsize).index(&FullRange)); + csize, tsize)[]); } (llconst, ety_adjusted) } @@ -429,23 +429,23 @@ fn const_expr_unadjusted(cx: &CrateContext, e: &ast::Expr) -> ValueRef { (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 \ + &format!("index-expr base must be a vector \ or string type, found {}", - ty_to_string(cx.tcx(), bt)).index(&FullRange)) + ty_to_string(cx.tcx(), bt))[]) }, ty::ty_rptr(_, mt) => match mt.ty.sty { ty::ty_vec(_, Some(u)) => { (const_deref_ptr(cx, bv), C_uint(cx, u)) }, _ => cx.sess().span_bug(base.span, - format!("index-expr base must be a vector \ + &format!("index-expr base must be a vector \ or string type, found {}", - ty_to_string(cx.tcx(), bt)).index(&FullRange)) + ty_to_string(cx.tcx(), bt))[]) }, _ => cx.sess().span_bug(base.span, - format!("index-expr base must be a vector \ + &format!("index-expr base must be a vector \ or string type, found {}", - ty_to_string(cx.tcx(), bt)).index(&FullRange)) + ty_to_string(cx.tcx(), bt))[]) }; let len = llvm::LLVMConstIntGetZExtValue(len) as u64; @@ -546,8 +546,8 @@ fn const_expr_unadjusted(cx: &CrateContext, e: &ast::Expr) -> ValueRef { ast::ExprTup(ref es) => { let ety = ty::expr_ty(cx.tcx(), e); let repr = adt::represent_type(cx, ety); - let vals = map_list(es.index(&FullRange)); - adt::trans_const(cx, &*repr, 0, vals.index(&FullRange)) + let vals = map_list(&es[]); + adt::trans_const(cx, &*repr, 0, &vals[]) } ast::ExprStruct(_, ref fs, ref base_opt) => { let ety = ty::expr_ty(cx.tcx(), e); @@ -578,7 +578,7 @@ fn const_expr_unadjusted(cx: &CrateContext, e: &ast::Expr) -> ValueRef { } } }).collect::<Vec<_>>(); - adt::trans_const(cx, &*repr, discr, cs.index(&FullRange)) + adt::trans_const(cx, &*repr, discr, &cs[]) }) } ast::ExprVec(ref es) => { @@ -595,9 +595,9 @@ fn const_expr_unadjusted(cx: &CrateContext, e: &ast::Expr) -> ValueRef { }; let vs: Vec<_> = repeat(const_expr(cx, &**elem).0).take(n).collect(); if vs.iter().any(|vi| val_ty(*vi) != llunitty) { - C_struct(cx, vs.index(&FullRange), false) + C_struct(cx, &vs[], false) } else { - C_array(llunitty, vs.index(&FullRange)) + C_array(llunitty, &vs[]) } } ast::ExprPath(_) => { @@ -645,8 +645,8 @@ fn const_expr_unadjusted(cx: &CrateContext, e: &ast::Expr) -> ValueRef { Some(def::DefStruct(_)) => { let ety = ty::expr_ty(cx.tcx(), e); let repr = adt::represent_type(cx, ety); - let arg_vals = map_list(args.index(&FullRange)); - adt::trans_const(cx, &*repr, 0, arg_vals.index(&FullRange)) + let arg_vals = map_list(&args[]); + adt::trans_const(cx, &*repr, 0, &arg_vals[]) } Some(def::DefVariant(enum_did, variant_did, _)) => { let ety = ty::expr_ty(cx.tcx(), e); @@ -654,11 +654,11 @@ fn const_expr_unadjusted(cx: &CrateContext, e: &ast::Expr) -> ValueRef { let vinfo = ty::enum_variant_with_id(cx.tcx(), enum_did, variant_did); - let arg_vals = map_list(args.index(&FullRange)); + let arg_vals = map_list(&args[]); adt::trans_const(cx, &*repr, vinfo.disr_val, - arg_vals.index(&FullRange)) + &arg_vals[]) } _ => cx.sess().span_bug(e.span, "expected a struct or variant def") } diff --git a/src/librustc_trans/trans/context.rs b/src/librustc_trans/trans/context.rs index 35fb34eafb4..1abf3b0b886 100644 --- a/src/librustc_trans/trans/context.rs +++ b/src/librustc_trans/trans/context.rs @@ -284,7 +284,7 @@ impl<'tcx> SharedCrateContext<'tcx> { // such as a function name in the module. // 1. http://llvm.org/bugs/show_bug.cgi?id=11479 let llmod_id = format!("{}.{}.rs", crate_name, i); - let local_ccx = LocalCrateContext::new(&shared_ccx, llmod_id.index(&FullRange)); + let local_ccx = LocalCrateContext::new(&shared_ccx, &llmod_id[]); shared_ccx.local_ccxs.push(local_ccx); } @@ -369,12 +369,12 @@ impl<'tcx> LocalCrateContext<'tcx> { unsafe { let (llcx, llmod) = create_context_and_module(&shared.tcx.sess, name); - let td = mk_target_data(shared.tcx + let td = mk_target_data(&shared.tcx .sess .target .target .data_layout - .index(&FullRange)); + []); let dbg_cx = if shared.tcx.sess.opts.debuginfo != NoDebugInfo { Some(debuginfo::CrateDebugContext::new(llmod)) @@ -721,7 +721,7 @@ impl<'b, 'tcx> CrateContext<'b, 'tcx> { /// currently conservatively bounded to 1 << 47 as that is enough to cover the current usable /// address space on 64-bit ARMv8 and x86_64. pub fn obj_size_bound(&self) -> u64 { - match self.sess().target.target.target_word_size.index(&FullRange) { + match &self.sess().target.target.target_pointer_width[] { "32" => 1 << 31, "64" => 1 << 47, _ => unreachable!() // error handled by config::build_target_config @@ -730,8 +730,8 @@ impl<'b, 'tcx> CrateContext<'b, 'tcx> { pub fn report_overbig_object(&self, obj: Ty<'tcx>) -> ! { self.sess().fatal( - format!("the type `{}` is too big for the current architecture", - obj.repr(self.tcx())).index(&FullRange)) + &format!("the type `{}` is too big for the current architecture", + obj.repr(self.tcx()))[]) } } diff --git a/src/librustc_trans/trans/controlflow.rs b/src/librustc_trans/trans/controlflow.rs index 38d40a8322f..adf302501cd 100644 --- a/src/librustc_trans/trans/controlflow.rs +++ b/src/librustc_trans/trans/controlflow.rs @@ -48,7 +48,7 @@ pub fn trans_stmt<'blk, 'tcx>(cx: Block<'blk, 'tcx>, debug!("trans_stmt({})", s.repr(cx.tcx())); if cx.sess().asm_comments() { - add_span_comment(cx, s.span, s.repr(cx.tcx()).index(&FullRange)); + add_span_comment(cx, s.span, &s.repr(cx.tcx())[]); } let mut bcx = cx; @@ -188,7 +188,7 @@ pub fn trans_if<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, } let name = format!("then-block-{}-", thn.id); - let then_bcx_in = bcx.fcx.new_id_block(name.index(&FullRange), thn.id); + let then_bcx_in = bcx.fcx.new_id_block(&name[], thn.id); let then_bcx_out = trans_block(then_bcx_in, &*thn, dest); trans::debuginfo::clear_source_location(bcx.fcx); @@ -439,8 +439,8 @@ pub fn trans_break_cont<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, match bcx.tcx().def_map.borrow().get(&expr_id) { Some(&def::DefLabel(loop_id)) => loop_id, ref r => { - bcx.tcx().sess.bug(format!("{:?} in def-map for label", - r).index(&FullRange)) + bcx.tcx().sess.bug(&format!("{:?} in def-map for label", + r)[]) } } } @@ -504,7 +504,7 @@ pub fn trans_fail<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, let v_str = C_str_slice(ccx, fail_str); let loc = bcx.sess().codemap().lookup_char_pos(sp.lo); - let filename = token::intern_and_get_ident(loc.file.name.index(&FullRange)); + let filename = token::intern_and_get_ident(&loc.file.name[]); let filename = C_str_slice(ccx, filename); let line = C_uint(ccx, loc.line); let expr_file_line_const = C_struct(ccx, &[v_str, filename, line], false); @@ -513,7 +513,7 @@ pub fn trans_fail<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, let did = langcall(bcx, Some(sp), "", PanicFnLangItem); let bcx = callee::trans_lang_call(bcx, did, - args.index(&FullRange), + &args[], Some(expr::Ignore)).bcx; Unreachable(bcx); return bcx; @@ -529,7 +529,7 @@ pub fn trans_fail_bounds_check<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, // Extract the file/line from the span let loc = bcx.sess().codemap().lookup_char_pos(sp.lo); - let filename = token::intern_and_get_ident(loc.file.name.index(&FullRange)); + let filename = token::intern_and_get_ident(&loc.file.name[]); // Invoke the lang item let filename = C_str_slice(ccx, filename); @@ -540,7 +540,7 @@ pub fn trans_fail_bounds_check<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, let did = langcall(bcx, Some(sp), "", PanicBoundsCheckFnLangItem); let bcx = callee::trans_lang_call(bcx, did, - args.index(&FullRange), + &args[], Some(expr::Ignore)).bcx; Unreachable(bcx); return bcx; diff --git a/src/librustc_trans/trans/datum.rs b/src/librustc_trans/trans/datum.rs index 26518d4092f..8b52732f4ee 100644 --- a/src/librustc_trans/trans/datum.rs +++ b/src/librustc_trans/trans/datum.rs @@ -463,8 +463,8 @@ impl<'tcx> Datum<'tcx, Lvalue> { gep(base) } _ => bcx.tcx().sess.bug( - format!("Unexpected unsized type in get_element: {}", - bcx.ty_to_string(self.ty)).index(&FullRange)) + &format!("Unexpected unsized type in get_element: {}", + bcx.ty_to_string(self.ty))[]) }; Datum { val: val, diff --git a/src/librustc_trans/trans/debuginfo.rs b/src/librustc_trans/trans/debuginfo.rs index e2e1b3a799b..3a6f4b47e4e 100644 --- a/src/librustc_trans/trans/debuginfo.rs +++ b/src/librustc_trans/trans/debuginfo.rs @@ -284,8 +284,8 @@ impl<'tcx> TypeMap<'tcx> { type_: Ty<'tcx>, metadata: DIType) { if self.type_to_metadata.insert(type_, metadata).is_some() { - cx.sess().bug(format!("Type metadata for Ty '{}' is already in the TypeMap!", - ppaux::ty_to_string(cx.tcx(), type_)).index(&FullRange)); + cx.sess().bug(&format!("Type metadata for Ty '{}' is already in the TypeMap!", + ppaux::ty_to_string(cx.tcx(), type_))[]); } } @@ -297,8 +297,8 @@ impl<'tcx> TypeMap<'tcx> { metadata: DIType) { if self.unique_id_to_metadata.insert(unique_type_id, metadata).is_some() { let unique_type_id_str = self.get_unique_type_id_as_string(unique_type_id); - cx.sess().bug(format!("Type metadata for unique id '{}' is already in the TypeMap!", - unique_type_id_str.index(&FullRange)).index(&FullRange)); + cx.sess().bug(&format!("Type metadata for unique id '{}' is already in the TypeMap!", + &unique_type_id_str[])[]); } } @@ -335,13 +335,13 @@ impl<'tcx> TypeMap<'tcx> { // unique ptr (~) -> {~ :pointee-uid:} // @-ptr (@) -> {@ :pointee-uid:} // sized vec ([T; x]) -> {[:size:] :element-uid:} - // unsized vec ([T]) -> {.index(&FullRange) :element-uid:} + // unsized vec ([T]) -> {[] :element-uid:} // trait (T) -> {trait_:svh: / :node-id:_<(:param-uid:),*> } // closure -> {<unsafe_> <once_> :store-sigil: |(:param-uid:),* <,_...>| -> \ // :return-type-uid: : (:bounds:)*} // function -> {<unsafe_> <abi_> fn( (:param-uid:)* <,_...> ) -> \ // :return-type-uid:} - // unique vec box (~.index(&FullRange)) -> {HEAP_VEC_BOX<:pointee-uid:>} + // unique vec box (~[]) -> {HEAP_VEC_BOX<:pointee-uid:>} // gc box -> {GC_BOX<:pointee-uid:>} match self.type_to_unique_id.get(&type_).cloned() { @@ -379,14 +379,14 @@ impl<'tcx> TypeMap<'tcx> { self.get_unique_type_id_of_type(cx, component_type); let component_type_id = self.get_unique_type_id_as_string(component_type_id); - unique_type_id.push_str(component_type_id.index(&FullRange)); + unique_type_id.push_str(&component_type_id[]); } }, ty::ty_uniq(inner_type) => { unique_type_id.push('~'); let inner_type_id = self.get_unique_type_id_of_type(cx, inner_type); let inner_type_id = self.get_unique_type_id_as_string(inner_type_id); - unique_type_id.push_str(inner_type_id.index(&FullRange)); + unique_type_id.push_str(&inner_type_id[]); }, ty::ty_ptr(ty::mt { ty: inner_type, mutbl } ) => { unique_type_id.push('*'); @@ -396,7 +396,7 @@ impl<'tcx> TypeMap<'tcx> { let inner_type_id = self.get_unique_type_id_of_type(cx, inner_type); let inner_type_id = self.get_unique_type_id_as_string(inner_type_id); - unique_type_id.push_str(inner_type_id.index(&FullRange)); + unique_type_id.push_str(&inner_type_id[]); }, ty::ty_rptr(_, ty::mt { ty: inner_type, mutbl }) => { unique_type_id.push('&'); @@ -406,12 +406,12 @@ impl<'tcx> TypeMap<'tcx> { let inner_type_id = self.get_unique_type_id_of_type(cx, inner_type); let inner_type_id = self.get_unique_type_id_as_string(inner_type_id); - unique_type_id.push_str(inner_type_id.index(&FullRange)); + unique_type_id.push_str(&inner_type_id[]); }, ty::ty_vec(inner_type, optional_length) => { match optional_length { Some(len) => { - unique_type_id.push_str(format!("[{}]", len).index(&FullRange)); + unique_type_id.push_str(&format!("[{}]", len)[]); } None => { unique_type_id.push_str("[]"); @@ -420,7 +420,7 @@ impl<'tcx> TypeMap<'tcx> { let inner_type_id = self.get_unique_type_id_of_type(cx, inner_type); let inner_type_id = self.get_unique_type_id_as_string(inner_type_id); - unique_type_id.push_str(inner_type_id.index(&FullRange)); + unique_type_id.push_str(&inner_type_id[]); }, ty::ty_trait(ref trait_data) => { unique_type_id.push_str("trait "); @@ -451,7 +451,7 @@ impl<'tcx> TypeMap<'tcx> { self.get_unique_type_id_of_type(cx, parameter_type); let parameter_type_id = self.get_unique_type_id_as_string(parameter_type_id); - unique_type_id.push_str(parameter_type_id.index(&FullRange)); + unique_type_id.push_str(¶meter_type_id[]); unique_type_id.push(','); } @@ -464,7 +464,7 @@ impl<'tcx> TypeMap<'tcx> { ty::FnConverging(ret_ty) => { let return_type_id = self.get_unique_type_id_of_type(cx, ret_ty); let return_type_id = self.get_unique_type_id_as_string(return_type_id); - unique_type_id.push_str(return_type_id.index(&FullRange)); + unique_type_id.push_str(&return_type_id[]); } ty::FnDiverging => { unique_type_id.push_str("!"); @@ -479,9 +479,9 @@ impl<'tcx> TypeMap<'tcx> { &mut unique_type_id); }, _ => { - cx.sess().bug(format!("get_unique_type_id_of_type() - unexpected type: {}, {:?}", - ppaux::ty_to_string(cx.tcx(), type_).index(&FullRange), - type_.sty).index(&FullRange)) + cx.sess().bug(&format!("get_unique_type_id_of_type() - unexpected type: {}, {:?}", + &ppaux::ty_to_string(cx.tcx(), type_)[], + type_.sty)[]) } }; @@ -524,7 +524,7 @@ impl<'tcx> TypeMap<'tcx> { output.push_str(crate_hash.as_str()); output.push_str("/"); - output.push_str(format!("{:x}", def_id.node).index(&FullRange)); + output.push_str(&format!("{:x}", def_id.node)[]); // Maybe check that there is no self type here. @@ -537,7 +537,7 @@ impl<'tcx> TypeMap<'tcx> { type_map.get_unique_type_id_of_type(cx, type_parameter); let param_type_id = type_map.get_unique_type_id_as_string(param_type_id); - output.push_str(param_type_id.index(&FullRange)); + output.push_str(¶m_type_id[]); output.push(','); } @@ -581,7 +581,7 @@ impl<'tcx> TypeMap<'tcx> { self.get_unique_type_id_of_type(cx, parameter_type); let parameter_type_id = self.get_unique_type_id_as_string(parameter_type_id); - unique_type_id.push_str(parameter_type_id.index(&FullRange)); + unique_type_id.push_str(¶meter_type_id[]); unique_type_id.push(','); } @@ -595,7 +595,7 @@ impl<'tcx> TypeMap<'tcx> { ty::FnConverging(ret_ty) => { let return_type_id = self.get_unique_type_id_of_type(cx, ret_ty); let return_type_id = self.get_unique_type_id_as_string(return_type_id); - unique_type_id.push_str(return_type_id.index(&FullRange)); + unique_type_id.push_str(&return_type_id[]); } ty::FnDiverging => { unique_type_id.push_str("!"); @@ -625,8 +625,7 @@ impl<'tcx> TypeMap<'tcx> { -> UniqueTypeId { let enum_type_id = self.get_unique_type_id_of_type(cx, enum_type); let enum_variant_type_id = format!("{}::{}", - self.get_unique_type_id_as_string(enum_type_id) - .index(&FullRange), + &self.get_unique_type_id_as_string(enum_type_id)[], variant_name); let interner_key = self.unique_id_interner.intern(Rc::new(enum_variant_type_id)); UniqueTypeId(interner_key) @@ -803,23 +802,23 @@ pub fn create_global_var_metadata(cx: &CrateContext, _ => { cx.sess() .span_bug(item.span, - format!("debuginfo::\ + &format!("debuginfo::\ create_global_var_metadata() - Captured var-id refers to \ unexpected ast_item variant: {:?}", - var_item).index(&FullRange)) + var_item)[]) } } }, - _ => cx.sess().bug(format!("debuginfo::create_global_var_metadata() \ + _ => cx.sess().bug(&format!("debuginfo::create_global_var_metadata() \ - Captured var-id refers to unexpected \ ast_map variant: {:?}", - var_item).index(&FullRange)) + var_item)[]) }; let (file_metadata, line_number) = if span != codemap::DUMMY_SP { let loc = span_start(cx, span); - (file_metadata(cx, loc.file.name.index(&FullRange)), loc.line as c_uint) + (file_metadata(cx, &loc.file.name[]), loc.line as c_uint) } else { (UNKNOWN_FILE_METADATA, UNKNOWN_LINE_NUMBER) }; @@ -830,7 +829,7 @@ pub fn create_global_var_metadata(cx: &CrateContext, let namespace_node = namespace_for_item(cx, ast_util::local_def(node_id)); let var_name = token::get_ident(ident).get().to_string(); let linkage_name = - namespace_node.mangled_name_of_contained_item(var_name.index(&FullRange)); + namespace_node.mangled_name_of_contained_item(&var_name[]); let var_scope = namespace_node.scope; let var_name = CString::from_slice(var_name.as_bytes()); @@ -868,8 +867,8 @@ pub fn create_local_var_metadata(bcx: Block, local: &ast::Local) { Some(datum) => datum, None => { bcx.sess().span_bug(span, - format!("no entry in lllocals table for {}", - node_id).index(&FullRange)); + &format!("no entry in lllocals table for {}", + node_id)[]); } }; @@ -919,21 +918,21 @@ pub fn create_captured_var_metadata<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, _ => { cx.sess() .span_bug(span, - format!( + &format!( "debuginfo::create_captured_var_metadata() - \ Captured var-id refers to unexpected \ ast_map variant: {:?}", - ast_item).index(&FullRange)); + ast_item)[]); } } } _ => { cx.sess() .span_bug(span, - format!("debuginfo::create_captured_var_metadata() - \ + &format!("debuginfo::create_captured_var_metadata() - \ Captured var-id refers to unexpected \ ast_map variant: {:?}", - ast_item).index(&FullRange)); + ast_item)[]); } }; @@ -963,7 +962,7 @@ pub fn create_captured_var_metadata<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, let variable_access = IndirectVariable { alloca: env_pointer, - address_operations: address_operations.index(&(0..address_op_count)) + address_operations: &address_operations[0..address_op_count] }; declare_local(bcx, @@ -1039,8 +1038,8 @@ pub fn create_argument_metadata(bcx: Block, arg: &ast::Arg) { Some(v) => v, None => { bcx.sess().span_bug(span, - format!("no entry in lllocals table for {}", - node_id).index(&FullRange)); + &format!("no entry in lllocals table for {}", + node_id)[]); } }; @@ -1154,7 +1153,7 @@ pub fn get_cleanup_debug_loc_for_ast_node<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, if let Some(code_snippet) = code_snippet { let bytes = code_snippet.as_bytes(); - if bytes.len() > 0 && bytes.index(&((bytes.len()-1)..)) == b"}" { + if bytes.len() > 0 && &bytes[(bytes.len()-1)..] == b"}" { cleanup_span = Span { lo: node_span.hi - codemap::BytePos(1), hi: node_span.hi, @@ -1298,7 +1297,7 @@ pub fn create_function_debug_context<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, match expr.node { ast::ExprClosure(_, _, ref fn_decl, ref top_level_block) => { let name = format!("fn{}", token::gensym("fn")); - let name = token::str_to_ident(name.index(&FullRange)); + let name = token::str_to_ident(&name[]); (name, &**fn_decl, // This is not quite right. It should actually inherit // the generics of the enclosing function. @@ -1328,9 +1327,9 @@ pub fn create_function_debug_context<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, } _ => { cx.sess() - .bug(format!("create_function_debug_context: \ + .bug(&format!("create_function_debug_context: \ unexpected sort of node: {:?}", - fnitem).index(&FullRange)) + fnitem)[]) } } } @@ -1339,9 +1338,9 @@ pub fn create_function_debug_context<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, ast_map::NodeStructCtor(..) => { return FunctionDebugContext::FunctionWithoutDebugInfo; } - _ => cx.sess().bug(format!("create_function_debug_context: \ + _ => cx.sess().bug(&format!("create_function_debug_context: \ unexpected sort of node: {:?}", - fnitem).index(&FullRange)) + fnitem)[]) }; // This can be the case for functions inlined from another crate @@ -1350,7 +1349,7 @@ pub fn create_function_debug_context<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, } let loc = span_start(cx, span); - let file_metadata = file_metadata(cx, loc.file.name.index(&FullRange)); + let file_metadata = file_metadata(cx, &loc.file.name[]); let function_type_metadata = unsafe { let fn_signature = get_function_signature(cx, @@ -1377,7 +1376,7 @@ pub fn create_function_debug_context<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, let (linkage_name, containing_scope) = if has_path { let namespace_node = namespace_for_item(cx, ast_util::local_def(fn_ast_id)); let linkage_name = namespace_node.mangled_name_of_contained_item( - function_name.index(&FullRange)); + &function_name[]); let containing_scope = namespace_node.scope; (linkage_name, containing_scope) } else { @@ -1465,7 +1464,7 @@ pub fn create_function_debug_context<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, signature.push(type_metadata(cx, arg_type, codemap::DUMMY_SP)); } - return create_DIArray(DIB(cx), signature.index(&FullRange)); + return create_DIArray(DIB(cx), &signature[]); } fn get_template_parameters<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, @@ -1500,7 +1499,7 @@ pub fn create_function_debug_context<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, actual_self_type, true); - name_to_append_suffix_to.push_str(actual_self_type_name.index(&FullRange)); + name_to_append_suffix_to.push_str(&actual_self_type_name[]); if generics.is_type_parameterized() { name_to_append_suffix_to.push_str(","); @@ -1539,7 +1538,7 @@ pub fn create_function_debug_context<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, let actual_type_name = compute_debuginfo_type_name(cx, actual_type, true); - name_to_append_suffix_to.push_str(actual_type_name.index(&FullRange)); + name_to_append_suffix_to.push_str(&actual_type_name[]); if index != generics.ty_params.len() - 1 { name_to_append_suffix_to.push_str(","); @@ -1566,7 +1565,7 @@ pub fn create_function_debug_context<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, name_to_append_suffix_to.push('>'); - return create_DIArray(DIB(cx), template_params.index(&FullRange)); + return create_DIArray(DIB(cx), &template_params[]); } } @@ -1660,7 +1659,7 @@ fn declare_local<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, let cx: &CrateContext = bcx.ccx(); let filename = span_start(cx, span).file.name.clone(); - let file_metadata = file_metadata(cx, filename.index(&FullRange)); + let file_metadata = file_metadata(cx, &filename[]); let name = token::get_ident(variable_ident); let loc = span_start(cx, span); @@ -1746,7 +1745,7 @@ fn file_metadata(cx: &CrateContext, full_path: &str) -> DIFile { let work_dir = cx.sess().working_dir.as_str().unwrap(); let file_name = if full_path.starts_with(work_dir) { - full_path.index(&((work_dir.len() + 1u)..full_path.len())) + &full_path[(work_dir.len() + 1u)..full_path.len()] } else { full_path }; @@ -1777,8 +1776,8 @@ fn scope_metadata(fcx: &FunctionContext, let node = fcx.ccx.tcx().map.get(node_id); fcx.ccx.sess().span_bug(error_reporting_span, - format!("debuginfo: Could not find scope info for node {:?}", - node).index(&FullRange)); + &format!("debuginfo: Could not find scope info for node {:?}", + node)[]); } } } @@ -1971,10 +1970,10 @@ impl<'tcx> RecursiveTypeDescription<'tcx> { let type_map = debug_context(cx).type_map.borrow(); if type_map.find_metadata_for_unique_id(unique_type_id).is_none() || type_map.find_metadata_for_type(unfinished_type).is_none() { - cx.sess().bug(format!("Forward declaration of potentially recursive type \ + cx.sess().bug(&format!("Forward declaration of potentially recursive type \ '{}' was not found in TypeMap!", ppaux::ty_to_string(cx.tcx(), unfinished_type)) - .index(&FullRange)); + []); } } @@ -1986,7 +1985,7 @@ impl<'tcx> RecursiveTypeDescription<'tcx> { set_members_of_composite_type(cx, metadata_stub, llvm_type, - member_descriptions.index(&FullRange)); + &member_descriptions[]); return MetadataCreationResult::new(metadata_stub, true); } } @@ -2058,7 +2057,7 @@ fn prepare_struct_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, let struct_metadata_stub = create_struct_stub(cx, struct_llvm_type, - struct_name.index(&FullRange), + &struct_name[], unique_type_id, containing_scope); @@ -2119,7 +2118,7 @@ fn prepare_tuple_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, unique_type_id, create_struct_stub(cx, tuple_llvm_type, - tuple_name.index(&FullRange), + &tuple_name[], unique_type_id, UNKNOWN_SCOPE_METADATA), tuple_llvm_type, @@ -2179,7 +2178,7 @@ impl<'tcx> EnumMemberDescriptionFactory<'tcx> { set_members_of_composite_type(cx, variant_type_metadata, variant_llvm_type, - member_descriptions.index(&FullRange)); + &member_descriptions[]); MemberDescription { name: "".to_string(), llvm_type: variant_llvm_type, @@ -2212,7 +2211,7 @@ impl<'tcx> EnumMemberDescriptionFactory<'tcx> { set_members_of_composite_type(cx, variant_type_metadata, variant_llvm_type, - member_descriptions.index(&FullRange)); + &member_descriptions[]); vec![ MemberDescription { name: "".to_string(), @@ -2312,7 +2311,7 @@ impl<'tcx> EnumMemberDescriptionFactory<'tcx> { set_members_of_composite_type(cx, variant_type_metadata, variant_llvm_type, - variant_member_descriptions.index(&FullRange)); + &variant_member_descriptions[]); // Encode the information about the null variant in the union // member's name. @@ -2387,11 +2386,11 @@ fn describe_enum_variant<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, span: Span) -> (DICompositeType, Type, MemberDescriptionFactory<'tcx>) { let variant_llvm_type = - Type::struct_(cx, struct_def.fields + Type::struct_(cx, &struct_def.fields .iter() .map(|&t| type_of::type_of(cx, t)) .collect::<Vec<_>>() - .index(&FullRange), + [], struct_def.packed); // Could do some consistency checks here: size, align, field count, discr type @@ -2458,7 +2457,7 @@ fn prepare_enum_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, let (containing_scope, definition_span) = get_namespace_and_span_for_item(cx, enum_def_id); let loc = span_start(cx, definition_span); - let file_metadata = file_metadata(cx, loc.file.name.index(&FullRange)); + let file_metadata = file_metadata(cx, &loc.file.name[]); let variants = ty::enum_variants(cx.tcx(), enum_def_id); @@ -2638,14 +2637,14 @@ fn set_members_of_composite_type(cx: &CrateContext, let min_supported_llvm_version = 3 * 1000000 + 4 * 1000; if actual_llvm_version < min_supported_llvm_version { - cx.sess().warn(format!("This version of rustc was built with LLVM \ + cx.sess().warn(&format!("This version of rustc was built with LLVM \ {}.{}. Rustc just ran into a known \ debuginfo corruption problem thatoften \ occurs with LLVM versions below 3.4. \ Please use a rustc built with anewer \ version of LLVM.", llvm_version_major, - llvm_version_minor).index(&FullRange)); + llvm_version_minor)[]); } else { cx.sess().bug("debuginfo::set_members_of_composite_type() - \ Already completed forward declaration re-encountered."); @@ -2683,7 +2682,7 @@ fn set_members_of_composite_type(cx: &CrateContext, .collect(); unsafe { - let type_array = create_DIArray(DIB(cx), member_metadata.index(&FullRange)); + let type_array = create_DIArray(DIB(cx), &member_metadata[]); llvm::LLVMDICompositeTypeSetTypeArray(composite_type_metadata, type_array); } } @@ -2782,7 +2781,7 @@ fn vec_slice_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, let member_llvm_types = slice_llvm_type.field_types(); assert!(slice_layout_is_correct(cx, - member_llvm_types.index(&FullRange), + &member_llvm_types[], element_type)); let member_descriptions = [ MemberDescription { @@ -2804,11 +2803,11 @@ fn vec_slice_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, assert!(member_descriptions.len() == member_llvm_types.len()); let loc = span_start(cx, span); - let file_metadata = file_metadata(cx, loc.file.name.index(&FullRange)); + let file_metadata = file_metadata(cx, &loc.file.name[]); let metadata = composite_type_metadata(cx, slice_llvm_type, - slice_type_name.index(&FullRange), + &slice_type_name[], unique_type_id, &member_descriptions, UNKNOWN_SCOPE_METADATA, @@ -2857,7 +2856,7 @@ fn subroutine_type_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, llvm::LLVMDIBuilderCreateSubroutineType( DIB(cx), UNKNOWN_FILE_METADATA, - create_DIArray(DIB(cx), signature_metadata.index(&FullRange))) + create_DIArray(DIB(cx), &signature_metadata[])) }, false); } @@ -2881,9 +2880,9 @@ fn trait_pointer_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, ty::ty_trait(ref data) => data.principal_def_id(), _ => { let pp_type_name = ppaux::ty_to_string(cx.tcx(), trait_type); - cx.sess().bug(format!("debuginfo: Unexpected trait-object type in \ + cx.sess().bug(&format!("debuginfo: Unexpected trait-object type in \ trait_pointer_metadata(): {}", - pp_type_name.index(&FullRange)).index(&FullRange)); + &pp_type_name[])[]); } }; @@ -2897,7 +2896,7 @@ fn trait_pointer_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, composite_type_metadata(cx, trait_llvm_type, - trait_type_name.index(&FullRange), + &trait_type_name[], unique_type_id, &[], containing_scope, @@ -3017,13 +3016,13 @@ fn type_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, ty::ty_tup(ref elements) => { prepare_tuple_metadata(cx, t, - elements.index(&FullRange), + &elements[], unique_type_id, usage_site_span).finalize(cx) } _ => { - cx.sess().bug(format!("debuginfo: unexpected type in type_metadata: {:?}", - sty).index(&FullRange)) + cx.sess().bug(&format!("debuginfo: unexpected type in type_metadata: {:?}", + sty)[]) } }; @@ -3041,9 +3040,9 @@ fn type_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, type id '{}' to already be in \ the debuginfo::TypeMap but it \ was not. (Ty = {})", - unique_type_id_str.index(&FullRange), + &unique_type_id_str[], ppaux::ty_to_string(cx.tcx(), t)); - cx.sess().span_bug(usage_site_span, error_message.index(&FullRange)); + cx.sess().span_bug(usage_site_span, &error_message[]); } }; @@ -3056,9 +3055,9 @@ fn type_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, UniqueTypeId maps in \ debuginfo::TypeMap. \ UniqueTypeId={}, Ty={}", - unique_type_id_str.index(&FullRange), + &unique_type_id_str[], ppaux::ty_to_string(cx.tcx(), t)); - cx.sess().span_bug(usage_site_span, error_message.index(&FullRange)); + cx.sess().span_bug(usage_site_span, &error_message[]); } } None => { @@ -3264,7 +3263,7 @@ fn create_scope_map(cx: &CrateContext, { // Create a new lexical scope and push it onto the stack let loc = cx.sess().codemap().lookup_char_pos(scope_span.lo); - let file_metadata = file_metadata(cx, loc.file.name.index(&FullRange)); + let file_metadata = file_metadata(cx, &loc.file.name[]); let parent_scope = scope_stack.last().unwrap().scope_metadata; let scope_metadata = unsafe { @@ -3386,7 +3385,7 @@ fn create_scope_map(cx: &CrateContext, if need_new_scope { // Create a new lexical scope and push it onto the stack let loc = cx.sess().codemap().lookup_char_pos(pat.span.lo); - let file_metadata = file_metadata(cx, loc.file.name.index(&FullRange)); + let file_metadata = file_metadata(cx, &loc.file.name[]); let parent_scope = scope_stack.last().unwrap().scope_metadata; let scope_metadata = unsafe { @@ -3861,8 +3860,8 @@ fn push_debuginfo_type_name<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, ty::ty_open(_) | ty::ty_projection(..) | ty::ty_param(_) => { - cx.sess().bug(format!("debuginfo: Trying to create type name for \ - unexpected type: {}", ppaux::ty_to_string(cx.tcx(), t)).index(&FullRange)); + cx.sess().bug(&format!("debuginfo: Trying to create type name for \ + unexpected type: {}", ppaux::ty_to_string(cx.tcx(), t))[]); } } @@ -3945,13 +3944,13 @@ impl NamespaceTreeNode { None => {} } let string = token::get_name(node.name); - output.push_str(format!("{}", string.get().len()).index(&FullRange)); + output.push_str(&format!("{}", string.get().len())[]); output.push_str(string.get()); } let mut name = String::from_str("_ZN"); fill_nested(self, &mut name); - name.push_str(format!("{}", item_name.len()).index(&FullRange)); + name.push_str(&format!("{}", item_name.len())[]); name.push_str(item_name); name.push('E'); name @@ -3959,7 +3958,7 @@ impl NamespaceTreeNode { } fn crate_root_namespace<'a>(cx: &'a CrateContext) -> &'a str { - cx.link_meta().crate_name.index(&FullRange) + &cx.link_meta().crate_name[] } fn namespace_for_item(cx: &CrateContext, def_id: ast::DefId) -> Rc<NamespaceTreeNode> { @@ -4034,9 +4033,9 @@ fn namespace_for_item(cx: &CrateContext, def_id: ast::DefId) -> Rc<NamespaceTree match parent_node { Some(node) => node, None => { - cx.sess().bug(format!("debuginfo::namespace_for_item(): \ + cx.sess().bug(&format!("debuginfo::namespace_for_item(): \ path too short for {:?}", - def_id).index(&FullRange)); + def_id)[]); } } }) diff --git a/src/librustc_trans/trans/expr.rs b/src/librustc_trans/trans/expr.rs index 120e2e955e4..ac50445be2f 100644 --- a/src/librustc_trans/trans/expr.rs +++ b/src/librustc_trans/trans/expr.rs @@ -50,6 +50,7 @@ use trans::debuginfo; use trans::glue; use trans::machine; use trans::meth; +use trans::monomorphize; use trans::inline; use trans::tvec; use trans::type_of; @@ -317,8 +318,8 @@ fn apply_adjustments<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, // should just be the identity function. unsized_info(bcx, k, id, ty_substs[tp_index], identity) } - _ => bcx.sess().bug(format!("UnsizeStruct with bad sty: {}", - bcx.ty_to_string(unadjusted_ty)).index(&FullRange)) + _ => bcx.sess().bug(&format!("UnsizeStruct with bad sty: {}", + bcx.ty_to_string(unadjusted_ty))[]) }, &ty::UnsizeVtable(ty::TyTrait { ref principal, .. }, _) => { // Note that we preserve binding levels here: @@ -450,8 +451,8 @@ fn apply_adjustments<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, let datum_ty = datum.ty; let unboxed_ty = match datum_ty.sty { ty::ty_uniq(t) => t, - _ => bcx.sess().bug(format!("Expected ty_uniq, found {}", - bcx.ty_to_string(datum_ty)).index(&FullRange)) + _ => bcx.sess().bug(&format!("Expected ty_uniq, found {}", + bcx.ty_to_string(datum_ty))[]) }; let result_ty = ty::mk_uniq(tcx, ty::unsize_ty(tcx, unboxed_ty, k, expr.span)); @@ -622,9 +623,9 @@ fn trans_datum_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, _ => { bcx.tcx().sess.span_bug( expr.span, - format!("trans_rvalue_datum_unadjusted reached \ + &format!("trans_rvalue_datum_unadjusted reached \ fall-through case: {:?}", - expr.node).index(&FullRange)); + expr.node)[]); } } } @@ -975,9 +976,9 @@ fn trans_rvalue_stmt_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, _ => { bcx.tcx().sess.span_bug( expr.span, - format!("trans_rvalue_stmt_unadjusted reached \ + &format!("trans_rvalue_stmt_unadjusted reached \ fall-through case: {:?}", - expr.node).index(&FullRange)); + expr.node)[]); } } } @@ -1003,14 +1004,14 @@ fn trans_rvalue_dps_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, controlflow::trans_if(bcx, expr.id, &**cond, &**thn, els.as_ref().map(|e| &**e), dest) } ast::ExprMatch(ref discr, ref arms, _) => { - _match::trans_match(bcx, expr, &**discr, arms.index(&FullRange), dest) + _match::trans_match(bcx, expr, &**discr, &arms[], dest) } ast::ExprBlock(ref blk) => { controlflow::trans_block(bcx, &**blk, dest) } ast::ExprStruct(_, ref fields, ref base) => { trans_struct(bcx, - fields.index(&FullRange), + &fields[], base.as_ref().map(|e| &**e), expr.span, expr.id, @@ -1075,7 +1076,7 @@ fn trans_rvalue_dps_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, trans_adt(bcx, expr_ty(bcx, expr), 0, - numbered_fields.index(&FullRange), + &numbered_fields[], None, dest, Some(NodeInfo { id: expr.id, span: expr.span })) @@ -1119,13 +1120,13 @@ fn trans_rvalue_dps_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, trans_overloaded_call(bcx, expr, &**f, - args.index(&FullRange), + &args[], Some(dest)) } else { callee::trans_call(bcx, expr, &**f, - callee::ArgExprs(args.index(&FullRange)), + callee::ArgExprs(&args[]), dest) } } @@ -1133,7 +1134,7 @@ fn trans_rvalue_dps_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, callee::trans_method_call(bcx, expr, &*args[0], - callee::ArgExprs(args.index(&FullRange)), + callee::ArgExprs(&args[]), dest) } ast::ExprBinary(op, ref lhs, ref rhs) => { @@ -1180,9 +1181,9 @@ fn trans_rvalue_dps_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, _ => { bcx.tcx().sess.span_bug( expr.span, - format!("trans_rvalue_dps_unadjusted reached fall-through \ + &format!("trans_rvalue_dps_unadjusted reached fall-through \ case: {:?}", - expr.node).index(&FullRange)); + expr.node)[]); } } } @@ -1230,9 +1231,9 @@ fn trans_def_dps_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, bcx } _ => { - bcx.tcx().sess.span_bug(ref_expr.span, format!( + bcx.tcx().sess.span_bug(ref_expr.span, &format!( "Non-DPS def {:?} referened by {}", - def, bcx.node_id_to_string(ref_expr.id)).index(&FullRange)); + def, bcx.node_id_to_string(ref_expr.id))[]); } } } @@ -1258,10 +1259,10 @@ pub fn trans_def_fn_unadjusted<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, param_substs) } _ => { - ccx.tcx().sess.span_bug(ref_expr.span, format!( + ccx.tcx().sess.span_bug(ref_expr.span, &format!( "trans_def_fn_unadjusted invoked on: {:?} for {}", def, - ref_expr.repr(ccx.tcx())).index(&FullRange)); + ref_expr.repr(ccx.tcx()))[]); } } } @@ -1279,9 +1280,9 @@ pub fn trans_local_var<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, match bcx.fcx.llupvars.borrow().get(&nid) { Some(&val) => Datum::new(val, local_ty, Lvalue), None => { - bcx.sess().bug(format!( + bcx.sess().bug(&format!( "trans_local_var: no llval for upvar {} found", - nid).index(&FullRange)); + nid)[]); } } } @@ -1289,9 +1290,9 @@ pub fn trans_local_var<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, let datum = match bcx.fcx.lllocals.borrow().get(&nid) { Some(&v) => v, None => { - bcx.sess().bug(format!( + bcx.sess().bug(&format!( "trans_local_var: no datum for local/arg {} found", - nid).index(&FullRange)); + nid)[]); } }; debug!("take_local(nid={}, v={}, ty={})", @@ -1299,9 +1300,9 @@ pub fn trans_local_var<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, datum } _ => { - bcx.sess().unimpl(format!( + bcx.sess().unimpl(&format!( "unsupported def type in trans_local_var: {:?}", - def).index(&FullRange)); + def)[]); } } } @@ -1318,21 +1319,23 @@ pub fn with_field_tys<'tcx, R, F>(tcx: &ty::ctxt<'tcx>, { match ty.sty { ty::ty_struct(did, substs) => { - op(0, struct_fields(tcx, did, substs).index(&FullRange)) + let fields = struct_fields(tcx, did, substs); + let fields = monomorphize::normalize_associated_type(tcx, &fields); + op(0, &fields[]) } ty::ty_tup(ref v) => { - op(0, tup_fields(v.index(&FullRange)).index(&FullRange)) + op(0, &tup_fields(&v[])[]) } ty::ty_enum(_, substs) => { // We want the *variant* ID here, not the enum ID. match node_id_opt { None => { - tcx.sess.bug(format!( + tcx.sess.bug(&format!( "cannot get field types from the enum type {} \ without a node ID", - ty.repr(tcx)).index(&FullRange)); + ty.repr(tcx))[]); } Some(node_id) => { let def = tcx.def_map.borrow()[node_id].clone(); @@ -1340,10 +1343,9 @@ pub fn with_field_tys<'tcx, R, F>(tcx: &ty::ctxt<'tcx>, def::DefVariant(enum_id, variant_id, _) => { let variant_info = ty::enum_variant_with_id( tcx, enum_id, variant_id); - op(variant_info.disr_val, - struct_fields(tcx, - variant_id, - substs).index(&FullRange)) + let fields = struct_fields(tcx, variant_id, substs); + let fields = monomorphize::normalize_associated_type(tcx, &fields); + op(variant_info.disr_val, &fields[]) } _ => { tcx.sess.bug("resolve didn't map this expr to a \ @@ -1355,9 +1357,9 @@ pub fn with_field_tys<'tcx, R, F>(tcx: &ty::ctxt<'tcx>, } _ => { - tcx.sess.bug(format!( + tcx.sess.bug(&format!( "cannot get field types from the type {}", - ty.repr(tcx)).index(&FullRange)); + ty.repr(tcx))[]); } } } @@ -2045,21 +2047,21 @@ fn trans_imm_cast<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, lldiscrim_a, true), cast_float => SIToFP(bcx, lldiscrim_a, ll_t_out), _ => { - ccx.sess().bug(format!("translating unsupported cast: \ + ccx.sess().bug(&format!("translating unsupported cast: \ {} ({:?}) -> {} ({:?})", t_in.repr(bcx.tcx()), k_in, t_out.repr(bcx.tcx()), - k_out).index(&FullRange)) + k_out)[]) } } } - _ => ccx.sess().bug(format!("translating unsupported cast: \ + _ => ccx.sess().bug(&format!("translating unsupported cast: \ {} ({:?}) -> {} ({:?})", t_in.repr(bcx.tcx()), k_in, t_out.repr(bcx.tcx()), - k_out).index(&FullRange)) + k_out)[]) }; return immediate_rvalue_bcx(bcx, newval, t_out).to_expr_datumblock(); } @@ -2224,8 +2226,8 @@ fn deref_once<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, _ => { bcx.tcx().sess.span_bug( expr.span, - format!("deref invoked on expr of illegal type {}", - datum.ty.repr(bcx.tcx())).index(&FullRange)); + &format!("deref invoked on expr of illegal type {}", + datum.ty.repr(bcx.tcx()))[]); } }; diff --git a/src/librustc_trans/trans/foreign.rs b/src/librustc_trans/trans/foreign.rs index 25eb66ab2eb..3dfb36c854b 100644 --- a/src/librustc_trans/trans/foreign.rs +++ b/src/librustc_trans/trans/foreign.rs @@ -109,7 +109,7 @@ pub fn register_static(ccx: &CrateContext, let llty = type_of::type_of(ccx, ty); let ident = link_name(foreign_item); - match attr::first_attr_value_str_by_name(foreign_item.attrs.index(&FullRange), + match attr::first_attr_value_str_by_name(&foreign_item.attrs[], "linkage") { // If this is a static with a linkage specified, then we need to handle // it a little specially. The typesystem prevents things like &T and @@ -235,13 +235,13 @@ pub fn trans_native_call<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, _ => ccx.sess().bug("trans_native_call called on non-function type") }; let fn_sig = ty::erase_late_bound_regions(ccx.tcx(), fn_sig); - let llsig = foreign_signature(ccx, &fn_sig, passed_arg_tys.index(&FullRange)); + let llsig = foreign_signature(ccx, &fn_sig, &passed_arg_tys[]); let fn_type = cabi::compute_abi_info(ccx, - llsig.llarg_tys.index(&FullRange), + &llsig.llarg_tys[], llsig.llret_ty, llsig.ret_def); - let arg_tys: &[cabi::ArgType] = fn_type.arg_tys.index(&FullRange); + let arg_tys: &[cabi::ArgType] = &fn_type.arg_tys[]; let mut llargs_foreign = Vec::new(); @@ -367,7 +367,7 @@ pub fn trans_native_call<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, let llforeign_retval = CallWithConv(bcx, llfn, - llargs_foreign.index(&FullRange), + &llargs_foreign[], cc, Some(attrs)); @@ -437,7 +437,7 @@ pub fn trans_foreign_mod(ccx: &CrateContext, foreign_mod: &ast::ForeignMod) { abi => { let ty = ty::node_id_to_type(ccx.tcx(), foreign_item.id); register_foreign_item_fn(ccx, abi, ty, - lname.get().index(&FullRange)); + &lname.get()[]); // Unlike for other items, we shouldn't call // `base::update_linkage` here. Foreign items have // special linkage requirements, which are handled @@ -566,10 +566,10 @@ pub fn trans_rust_fn_with_foreign_abi<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, assert!(f.abi != Rust && f.abi != RustIntrinsic); } _ => { - ccx.sess().bug(format!("build_rust_fn: extern fn {} has ty {}, \ + ccx.sess().bug(&format!("build_rust_fn: extern fn {} has ty {}, \ expected a bare fn ty", ccx.tcx().map.path_to_string(id), - t.repr(tcx)).index(&FullRange)); + t.repr(tcx))[]); } }; @@ -577,7 +577,7 @@ pub fn trans_rust_fn_with_foreign_abi<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, ccx.tcx().map.path_to_string(id), id, t.repr(tcx)); - let llfn = base::decl_internal_rust_fn(ccx, t, ps.index(&FullRange)); + let llfn = base::decl_internal_rust_fn(ccx, t, &ps[]); base::set_llvm_fn_attrs(ccx, attrs, llfn); base::trans_fn(ccx, decl, body, llfn, param_substs, id, &[]); llfn @@ -817,9 +817,9 @@ pub fn trans_rust_fn_with_foreign_abi<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, // the massive simplifications that have occurred. pub fn link_name(i: &ast::ForeignItem) -> InternedString { - match attr::first_attr_value_str_by_name(i.attrs.index(&FullRange), "link_name") { + match attr::first_attr_value_str_by_name(&i.attrs[], "link_name") { Some(ln) => ln.clone(), - None => match weak_lang_items::link_name(i.attrs.index(&FullRange)) { + None => match weak_lang_items::link_name(&i.attrs[]) { Some(name) => name, None => token::get_ident(i.ident), } @@ -862,7 +862,7 @@ fn foreign_types_for_fn_ty<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, let fn_sig = ty::erase_late_bound_regions(ccx.tcx(), fn_sig); let llsig = foreign_signature(ccx, &fn_sig, fn_sig.inputs.as_slice()); let fn_ty = cabi::compute_abi_info(ccx, - llsig.llarg_tys.index(&FullRange), + &llsig.llarg_tys[], llsig.llret_ty, llsig.ret_def); debug!("foreign_types_for_fn_ty(\ @@ -871,7 +871,7 @@ fn foreign_types_for_fn_ty<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, fn_ty={} -> {}, \ ret_def={}", ty.repr(ccx.tcx()), - ccx.tn().types_to_str(llsig.llarg_tys.index(&FullRange)), + ccx.tn().types_to_str(&llsig.llarg_tys[]), ccx.tn().type_to_string(llsig.llret_ty), ccx.tn().types_to_str(fn_ty.arg_tys.iter().map(|t| t.ty).collect::<Vec<_>>().as_slice()), ccx.tn().type_to_string(fn_ty.ret_ty.ty), @@ -923,7 +923,7 @@ fn lltype_for_fn_from_foreign_types(ccx: &CrateContext, tys: &ForeignTypes) -> T if tys.fn_sig.variadic { Type::variadic_func(llargument_tys.as_slice(), &llreturn_ty) } else { - Type::func(llargument_tys.index(&FullRange), &llreturn_ty) + Type::func(&llargument_tys[], &llreturn_ty) } } diff --git a/src/librustc_trans/trans/glue.rs b/src/librustc_trans/trans/glue.rs index 52e7a986d7e..2219cd59263 100644 --- a/src/librustc_trans/trans/glue.rs +++ b/src/librustc_trans/trans/glue.rs @@ -161,7 +161,7 @@ pub fn get_drop_glue<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> Val let (glue, new_sym) = match ccx.available_drop_glues().borrow().get(&t) { Some(old_sym) => { - let glue = decl_cdecl_fn(ccx, old_sym.index(&FullRange), llfnty, ty::mk_nil(ccx.tcx())); + let glue = decl_cdecl_fn(ccx, &old_sym[], llfnty, ty::mk_nil(ccx.tcx())); (glue, None) }, None => { @@ -233,8 +233,8 @@ fn trans_struct_drop<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, assert!(sig.inputs.len() == 1); sig.inputs[0] } - _ => bcx.sess().bug(format!("Expected function type, found {}", - bcx.ty_to_string(fty)).index(&FullRange)) + _ => bcx.sess().bug(&format!("Expected function type, found {}", + bcx.ty_to_string(fty))[]) }; let (struct_data, info) = if type_is_sized(bcx.tcx(), t) { @@ -295,7 +295,7 @@ fn trans_struct_drop<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, class_did, &[get_drop_glue_type(bcx.ccx(), t)], ty::mk_nil(bcx.tcx())); - let (_, variant_cx) = invoke(variant_cx, dtor_addr, args.index(&FullRange), dtor_ty, None); + let (_, variant_cx) = invoke(variant_cx, dtor_addr, &args[], dtor_ty, None); variant_cx.fcx.pop_and_trans_custom_cleanup_scope(variant_cx, field_scope); variant_cx @@ -353,8 +353,8 @@ fn size_and_align_of_dst<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, t: Ty<'tcx>, info: let unit_size = llsize_of_alloc(bcx.ccx(), llunit_ty); (Mul(bcx, info, C_uint(bcx.ccx(), unit_size)), C_uint(bcx.ccx(), 8u)) } - _ => bcx.sess().bug(format!("Unexpected unsized type, found {}", - bcx.ty_to_string(t)).index(&FullRange)) + _ => bcx.sess().bug(&format!("Unexpected unsized type, found {}", + bcx.ty_to_string(t))[]) } } @@ -423,10 +423,10 @@ fn make_drop_glue<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, v0: ValueRef, t: Ty<'tcx>) } else { // Give the user a heads up that we are doing something // stupid and dangerous. - bcx.sess().warn(format!("Ignoring drop flag in destructor for {}\ + bcx.sess().warn(&format!("Ignoring drop flag in destructor for {}\ because the struct is unsized. See issue\ #16758", - bcx.ty_to_string(t)).index(&FullRange)); + bcx.ty_to_string(t))[]); trans_struct_drop(bcx, t, v0, dtor, did, substs) } } @@ -496,7 +496,7 @@ pub fn declare_tydesc<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) note_unique_llvm_symbol(ccx, name); let ty_name = token::intern_and_get_ident( - ppaux::ty_to_string(ccx.tcx(), t).index(&FullRange)); + &ppaux::ty_to_string(ccx.tcx(), t)[]); let ty_name = C_str_slice(ccx, ty_name); debug!("--- declare_tydesc {}", ppaux::ty_to_string(ccx.tcx(), t)); @@ -515,8 +515,8 @@ fn declare_generic_glue<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>, let fn_nm = mangle_internal_name_by_type_and_seq( ccx, t, - format!("glue_{}", name).index(&FullRange)); - let llfn = decl_cdecl_fn(ccx, fn_nm.index(&FullRange), llfnty, ty::mk_nil(ccx.tcx())); + &format!("glue_{}", name)[]); + let llfn = decl_cdecl_fn(ccx, &fn_nm[], llfnty, ty::mk_nil(ccx.tcx())); note_unique_llvm_symbol(ccx, fn_nm.clone()); return (fn_nm, llfn); } diff --git a/src/librustc_trans/trans/intrinsic.rs b/src/librustc_trans/trans/intrinsic.rs index ed75445b993..b22c7f763f0 100644 --- a/src/librustc_trans/trans/intrinsic.rs +++ b/src/librustc_trans/trans/intrinsic.rs @@ -313,7 +313,7 @@ pub fn trans_intrinsic_call<'a, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>, (_, "size_of") => { let tp_ty = *substs.types.get(FnSpace, 0); let lltp_ty = type_of::type_of(ccx, tp_ty); - C_uint(ccx, machine::llsize_of_real(ccx, lltp_ty)) + C_uint(ccx, machine::llsize_of_alloc(ccx, lltp_ty)) } (_, "min_align_of") => { let tp_ty = *substs.types.get(FnSpace, 0); diff --git a/src/librustc_trans/trans/machine.rs b/src/librustc_trans/trans/machine.rs index 41738f1e58f..95d67cd54c1 100644 --- a/src/librustc_trans/trans/machine.rs +++ b/src/librustc_trans/trans/machine.rs @@ -43,8 +43,10 @@ pub fn llsize_of_alloc(cx: &CrateContext, ty: Type) -> llsize { // Returns, as near as we can figure, the "real" size of a type. As in, the // bits in this number of bytes actually carry data related to the datum -// with the type. Not junk, padding, accidentally-damaged words, or -// whatever. Rounds up to the nearest byte though, so if you have a 1-bit +// with the type. Not junk, accidentally-damaged words, or whatever. +// Note that padding of the type will be included for structs, but not for the +// other types (i.e. SIMD types). +// Rounds up to the nearest byte though, so if you have a 1-bit // value, we return 1 here, not 0. Most of rustc works in bytes. Be warned // that LLVM *does* distinguish between e.g. a 1-bit value and an 8-bit value // at the codegen level! In general you should prefer `llbitsize_of_real` diff --git a/src/librustc_trans/trans/meth.rs b/src/librustc_trans/trans/meth.rs index 28718ffa980..7ac062108f3 100644 --- a/src/librustc_trans/trans/meth.rs +++ b/src/librustc_trans/trans/meth.rs @@ -77,7 +77,7 @@ pub fn trans_impl(ccx: &CrateContext, match *impl_item { ast::MethodImplItem(ref method) => { if method.pe_generics().ty_params.len() == 0u { - let trans_everywhere = attr::requests_inline(method.attrs.index(&FullRange)); + let trans_everywhere = attr::requests_inline(&method.attrs[]); for (ref ccx, is_origin) in ccx.maybe_iter(trans_everywhere) { let llfn = get_item_val(ccx, method.id); trans_fn(ccx, @@ -229,7 +229,7 @@ pub fn trans_static_method_callee<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, // Here, in this call, which I've written with explicit UFCS // notation, the set of type parameters will be: // - // rcvr_type: .index(&FullRange) <-- nothing declared on the trait itself + // rcvr_type: [] <-- nothing declared on the trait itself // rcvr_self: [Vec<int>] <-- the self type // rcvr_method: [String] <-- method type parameter // @@ -268,11 +268,11 @@ pub fn trans_static_method_callee<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, // // Recall that we matched `<Vec<int> as Convert>`. Trait // resolution will have given us a substitution - // containing `impl_substs=[[T=int],.index(&FullRange),.index(&FullRange)]` (the type + // containing `impl_substs=[[T=int],[],[]]` (the type // parameters defined on the impl). We combine // that with the `rcvr_method` from before, which tells us // the type parameters from the *method*, to yield - // `callee_substs=[[T=int],.index(&FullRange),[U=String]]`. + // `callee_substs=[[T=int],[],[U=String]]`. let subst::SeparateVecsPerParamSpace { types: impl_type, selfs: impl_self, @@ -289,8 +289,8 @@ pub fn trans_static_method_callee<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, callee_substs) } _ => { - tcx.sess.bug(format!("static call to invalid vtable: {}", - vtbl.repr(tcx)).index(&FullRange)); + tcx.sess.bug(&format!("static call to invalid vtable: {}", + vtbl.repr(tcx))[]); } } } @@ -377,8 +377,8 @@ fn trans_monomorphized_callee<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, traits::VtableBuiltin(..) | traits::VtableParam(..) => { bcx.sess().bug( - format!("resolved vtable bad vtable {} in trans", - vtable.repr(bcx.tcx())).index(&FullRange)); + &format!("resolved vtable bad vtable {} in trans", + vtable.repr(bcx.tcx()))[]); } } } @@ -738,9 +738,9 @@ pub fn get_vtable<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, } traits::VtableParam => { bcx.sess().bug( - format!("resolved vtable for {} to bad vtable {} in trans", + &format!("resolved vtable for {} to bad vtable {} in trans", trait_ref.repr(bcx.tcx()), - vtable.repr(bcx.tcx())).index(&FullRange)); + vtable.repr(bcx.tcx()))[]); } } }); @@ -772,7 +772,7 @@ pub fn make_vtable<I: Iterator<Item=ValueRef>>(ccx: &CrateContext, let components: Vec<_> = head.into_iter().chain(ptrs).collect(); unsafe { - let tbl = C_struct(ccx, components.index(&FullRange), false); + let tbl = C_struct(ccx, &components[], false); let sym = token::gensym("vtable"); let buf = CString::from_vec(format!("vtable{}", sym.uint()).into_bytes()); let vt_gvar = llvm::LLVMAddGlobal(ccx.llmod(), val_ty(tbl).to_ref(), diff --git a/src/librustc_trans/trans/monomorphize.rs b/src/librustc_trans/trans/monomorphize.rs index e2594765f4f..93076260349 100644 --- a/src/librustc_trans/trans/monomorphize.rs +++ b/src/librustc_trans/trans/monomorphize.rs @@ -32,7 +32,7 @@ use syntax::ast_map; use syntax::ast_util::{local_def, PostExpansionMethod}; use syntax::attr; use syntax::codemap::DUMMY_SP; -use std::hash::{sip, Hash}; +use std::hash::{Hasher, Hash, SipHasher}; pub fn monomorphic_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, fn_id: ast::DefId, @@ -125,13 +125,13 @@ pub fn monomorphic_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, let hash; let s = { - let mut state = sip::SipState::new(); + let mut state = SipHasher::new(); hash_id.hash(&mut state); mono_ty.hash(&mut state); - hash = format!("h{}", state.result()); + hash = format!("h{}", state.finish()); ccx.tcx().map.with_path(fn_id.node, |path| { - exported_name(path, hash.index(&FullRange)) + exported_name(path, &hash[]) }) }; @@ -141,9 +141,9 @@ pub fn monomorphic_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, let mut hash_id = Some(hash_id); let mut mk_lldecl = |&mut : abi: abi::Abi| { let lldecl = if abi != abi::Rust { - foreign::decl_rust_fn_with_foreign_abi(ccx, mono_ty, s.index(&FullRange)) + foreign::decl_rust_fn_with_foreign_abi(ccx, mono_ty, &s[]) } else { - decl_internal_rust_fn(ccx, mono_ty, s.index(&FullRange)) + decl_internal_rust_fn(ccx, mono_ty, &s[]) }; ccx.monomorphized().borrow_mut().insert(hash_id.take().unwrap(), lldecl); @@ -177,12 +177,12 @@ pub fn monomorphic_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, .. } => { let d = mk_lldecl(abi); - let needs_body = setup_lldecl(d, i.attrs.index(&FullRange)); + let needs_body = setup_lldecl(d, &i.attrs[]); if needs_body { if abi != abi::Rust { foreign::trans_rust_fn_with_foreign_abi( ccx, &**decl, &**body, &[], d, psubsts, fn_id.node, - Some(hash.index(&FullRange))); + Some(&hash[])); } else { trans_fn(ccx, &**decl, &**body, d, psubsts, fn_id.node, &[]); } @@ -206,7 +206,7 @@ pub fn monomorphic_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, trans_enum_variant(ccx, parent, &*v, - args.index(&FullRange), + &args[], this_tv.disr_val, psubsts, d); @@ -220,7 +220,7 @@ pub fn monomorphic_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, match *ii { ast::MethodImplItem(ref mth) => { let d = mk_lldecl(abi::Rust); - let needs_body = setup_lldecl(d, mth.attrs.index(&FullRange)); + let needs_body = setup_lldecl(d, &mth.attrs[]); if needs_body { trans_fn(ccx, mth.pe_fn_decl(), @@ -241,7 +241,7 @@ pub fn monomorphic_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, match *method { ast::ProvidedMethod(ref mth) => { let d = mk_lldecl(abi::Rust); - let needs_body = setup_lldecl(d, mth.attrs.index(&FullRange)); + let needs_body = setup_lldecl(d, &mth.attrs[]); if needs_body { trans_fn(ccx, mth.pe_fn_decl(), mth.pe_body(), d, psubsts, mth.id, &[]); @@ -249,8 +249,8 @@ pub fn monomorphic_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, d } _ => { - ccx.sess().bug(format!("can't monomorphize a {:?}", - map_node).index(&FullRange)) + ccx.sess().bug(&format!("can't monomorphize a {:?}", + map_node)[]) } } } @@ -258,7 +258,7 @@ pub fn monomorphic_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, let d = mk_lldecl(abi::Rust); set_inline_hint(d); base::trans_tuple_struct(ccx, - struct_def.fields.index(&FullRange), + &struct_def.fields[], struct_def.ctor_id.expect("ast-mapped tuple struct \ didn't have a ctor id"), psubsts, @@ -275,8 +275,8 @@ pub fn monomorphic_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, ast_map::NodeBlock(..) | ast_map::NodePat(..) | ast_map::NodeLocal(..) => { - ccx.sess().bug(format!("can't monomorphize a {:?}", - map_node).index(&FullRange)) + ccx.sess().bug(&format!("can't monomorphize a {:?}", + map_node)[]) } }; @@ -300,8 +300,6 @@ pub fn apply_param_substs<'tcx,T>(tcx: &ty::ctxt<'tcx>, -> T where T : TypeFoldable<'tcx> + Repr<'tcx> + HasProjectionTypes + Clone { - assert!(param_substs.regions.is_erased()); - let substituted = value.subst(tcx, param_substs); normalize_associated_type(tcx, &substituted) } @@ -315,8 +313,10 @@ pub fn normalize_associated_type<'tcx,T>(tcx: &ty::ctxt<'tcx>, value: &T) -> T { debug!("normalize_associated_type(t={})", value.repr(tcx)); + let value = erase_regions(tcx, value); + if !value.has_projection_types() { - return value.clone(); + return value; } // FIXME(#20304) -- cache @@ -326,7 +326,7 @@ pub fn normalize_associated_type<'tcx,T>(tcx: &ty::ctxt<'tcx>, value: &T) -> T let mut selcx = traits::SelectionContext::new(&infcx, &typer); let cause = traits::ObligationCause::dummy(); let traits::Normalized { value: result, obligations } = - traits::normalize(&mut selcx, cause, value); + traits::normalize(&mut selcx, cause, &value); debug!("normalize_associated_type: result={} obligations={}", result.repr(tcx), diff --git a/src/librustc_trans/trans/type_.rs b/src/librustc_trans/trans/type_.rs index 66e27ed1188..e2ed275d4c0 100644 --- a/src/librustc_trans/trans/type_.rs +++ b/src/librustc_trans/trans/type_.rs @@ -103,7 +103,7 @@ impl Type { } pub fn int(ccx: &CrateContext) -> Type { - match ccx.tcx().sess.target.target.target_word_size.index(&FullRange) { + match &ccx.tcx().sess.target.target.target_pointer_width[] { "32" => Type::i32(ccx), "64" => Type::i64(ccx), tws => panic!("Unsupported target word size for int: {}", tws), diff --git a/src/librustc_trans/trans/type_of.rs b/src/librustc_trans/trans/type_of.rs index 19d50cdd483..034a1ee8be5 100644 --- a/src/librustc_trans/trans/type_of.rs +++ b/src/librustc_trans/trans/type_of.rs @@ -140,7 +140,7 @@ pub fn type_of_rust_fn<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, let input_tys = inputs.iter().map(|&arg_ty| type_of_explicit_arg(cx, arg_ty)); atys.extend(input_tys); - Type::func(atys.index(&FullRange), &lloutputtype) + Type::func(&atys[], &lloutputtype) } // Given a function type and a count of ty params, construct an llvm type @@ -180,8 +180,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)).index(&FullRange)) + cx.sess().bug(&format!("trying to take the sizing type of {}, an unsized type", + ppaux::ty_to_string(cx.tcx(), t))[]) } ty::ty_bool => Type::bool(cx), @@ -233,8 +233,8 @@ pub fn sizing_type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> Typ } 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)).index(&FullRange)) + 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") }; @@ -285,7 +285,7 @@ pub fn type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> Type { // Rust types are defined as the same LLVM types. If we don't do // this then, e.g. `Option<{myfield: bool}>` would be a different // type than `Option<myrec>`. - let t_norm = normalize_ty(cx.tcx(), t); + let t_norm = erase_regions(cx.tcx(), &t); if t != t_norm { let llty = type_of(cx, t_norm); @@ -313,7 +313,7 @@ pub fn type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> Type { 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); - adt::incomplete_type_of(cx, &*repr, name.index(&FullRange)) + adt::incomplete_type_of(cx, &*repr, &name[]) } ty::ty_unboxed_closure(did, _, ref substs) => { // Only create the named struct, but don't fill it in. We @@ -324,7 +324,7 @@ pub fn type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> Type { // contents of the VecPerParamSpace to to construct the llvm // name let name = llvm_type_name(cx, an_unboxed_closure, did, substs.types.as_slice()); - adt::incomplete_type_of(cx, &*repr, name.index(&FullRange)) + adt::incomplete_type_of(cx, &*repr, &name[]) } ty::ty_uniq(ty) | ty::ty_rptr(_, ty::mt{ty, ..}) | ty::ty_ptr(ty::mt{ty, ..}) => { @@ -380,7 +380,7 @@ pub fn type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> Type { 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); - adt::incomplete_type_of(cx, &*repr, name.index(&FullRange)) + adt::incomplete_type_of(cx, &*repr, &name[]) } } @@ -398,8 +398,8 @@ pub fn type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> Type { 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)).index(&FullRange)) + _ => 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"), diff --git a/src/librustc_typeck/astconv.rs b/src/librustc_typeck/astconv.rs index 265ebe00d53..2046ee015f6 100644 --- a/src/librustc_typeck/astconv.rs +++ b/src/librustc_typeck/astconv.rs @@ -52,7 +52,6 @@ use middle::const_eval; use middle::def; use middle::resolve_lifetime as rl; use middle::subst::{FnSpace, TypeSpace, SelfSpace, Subst, Substs}; -use middle::subst::{VecPerParamSpace}; use middle::traits; use middle::ty::{self, RegionEscape, ToPolyTraitRef, Ty}; use rscope::{self, UnelidableRscope, RegionScope, SpecificRscope, @@ -193,11 +192,11 @@ pub fn opt_ast_region_to_region<'tcx>( format!("`{}`", name) }; - m.push_str(if n == 1 { + m.push_str(&(if n == 1 { help_name } else { format!("one of {}'s {} elided lifetimes", help_name, n) - }.index(&FullRange)); + })[]); if len == 2 && i == 0 { m.push_str(" or "); @@ -244,7 +243,7 @@ pub fn opt_ast_region_to_region<'tcx>( /// Given a path `path` that refers to an item `I` with the declared generics `decl_generics`, /// returns an appropriate set of substitutions for this particular reference to `I`. -fn ast_path_substs_for_ty<'tcx>( +pub fn ast_path_substs_for_ty<'tcx>( this: &AstConv<'tcx>, rscope: &RegionScope, decl_generics: &ty::Generics<'tcx>, @@ -344,10 +343,10 @@ fn create_substs_for_ast_path<'tcx>( "expected" }; this.tcx().sess.span_fatal(span, - format!("wrong number of type arguments: {} {}, found {}", + &format!("wrong number of type arguments: {} {}, found {}", expected, required_ty_param_count, - supplied_ty_param_count).index(&FullRange)); + supplied_ty_param_count)[]); } else if supplied_ty_param_count > formal_ty_param_count { let expected = if required_ty_param_count < formal_ty_param_count { "expected at most" @@ -355,10 +354,10 @@ fn create_substs_for_ast_path<'tcx>( "expected" }; this.tcx().sess.span_fatal(span, - format!("wrong number of type arguments: {} {}, found {}", + &format!("wrong number of type arguments: {} {}, found {}", expected, formal_ty_param_count, - supplied_ty_param_count).index(&FullRange)); + supplied_ty_param_count)[]); } let mut substs = Substs::new_type(types, regions); @@ -377,7 +376,7 @@ fn create_substs_for_ast_path<'tcx>( } } - for param in ty_param_defs.index(&(supplied_ty_param_count..)).iter() { + for param in ty_param_defs[supplied_ty_param_count..].iter() { match param.default { Some(default) => { // This is a default type parameter. @@ -556,8 +555,8 @@ pub fn instantiate_trait_ref<'tcx>( _ => { this.tcx().sess.span_fatal( ast_trait_ref.path.span, - format!("`{}` is not a trait", - ast_trait_ref.path.user_string(this.tcx())).index(&FullRange)); + &format!("`{}` is not a trait", + ast_trait_ref.path.user_string(this.tcx()))[]); } } } @@ -762,50 +761,6 @@ pub fn ast_path_to_ty<'tcx>( TypeAndSubsts { substs: substs, ty: ty } } -/// Returns the type that this AST path refers to. If the path has no type -/// parameters and the corresponding type has type parameters, fresh type -/// and/or region variables are substituted. -/// -/// This is used when checking the constructor in struct literals. -pub fn ast_path_to_ty_relaxed<'tcx>( - this: &AstConv<'tcx>, - rscope: &RegionScope, - did: ast::DefId, - path: &ast::Path) - -> TypeAndSubsts<'tcx> -{ - let tcx = this.tcx(); - let ty::TypeScheme { - generics, - ty: decl_ty - } = this.get_item_type_scheme(did); - - let wants_params = - generics.has_type_params(TypeSpace) || generics.has_region_params(TypeSpace); - - let needs_defaults = - wants_params && - path.segments.iter().all(|s| s.parameters.is_empty()); - - let substs = if needs_defaults { - let type_params: Vec<_> = range(0, generics.types.len(TypeSpace)) - .map(|_| this.ty_infer(path.span)).collect(); - let region_params = - rscope.anon_regions(path.span, generics.regions.len(TypeSpace)) - .unwrap(); - Substs::new(VecPerParamSpace::params_from_type(type_params), - VecPerParamSpace::params_from_type(region_params)) - } else { - ast_path_substs_for_ty(this, rscope, &generics, path) - }; - - let ty = decl_ty.subst(tcx, &substs); - TypeAndSubsts { - substs: substs, - ty: ty, - } -} - /// Converts the given AST type to a built-in type. A "built-in type" is, at /// present, either a core numeric type, a string, or `Box`. pub fn ast_ty_to_builtin_ty<'tcx>( @@ -825,8 +780,8 @@ pub fn ast_ty_to_builtin_ty<'tcx>( this.tcx() .sess .span_bug(ast_ty.span, - format!("unbound path {}", - path.repr(this.tcx())).index(&FullRange)) + &format!("unbound path {}", + path.repr(this.tcx()))[]) } Some(&d) => d }; @@ -847,8 +802,8 @@ pub fn ast_ty_to_builtin_ty<'tcx>( _ => { this.tcx().sess.span_bug( path.span, - format!("converting `Box` to `{}`", - ty.repr(this.tcx())).index(&FullRange)); + &format!("converting `Box` to `{}`", + ty.repr(this.tcx()))[]); } } } @@ -1068,14 +1023,14 @@ pub fn ast_ty_to_ty<'tcx>( ty::mk_vec(tcx, ast_ty_to_ty(this, rscope, &**ty), None) } ast::TyObjectSum(ref ty, ref bounds) => { - match ast_ty_to_trait_ref(this, rscope, &**ty, bounds.index(&FullRange)) { + match ast_ty_to_trait_ref(this, rscope, &**ty, &bounds[]) { Ok((trait_ref, projection_bounds)) => { trait_ref_to_object_type(this, rscope, ast_ty.span, trait_ref, projection_bounds, - bounds.index(&FullRange)) + &bounds[]) } Err(ErrorReported) => { this.tcx().types.err @@ -1110,15 +1065,15 @@ pub fn ast_ty_to_ty<'tcx>( ty::mk_bare_fn(tcx, None, tcx.mk_bare_fn(bare_fn)) } ast::TyPolyTraitRef(ref bounds) => { - conv_ty_poly_trait_ref(this, rscope, ast_ty.span, bounds.index(&FullRange)) + conv_ty_poly_trait_ref(this, rscope, ast_ty.span, &bounds[]) } ast::TyPath(ref path, id) => { let a_def = match tcx.def_map.borrow().get(&id) { None => { tcx.sess .span_bug(ast_ty.span, - format!("unbound path {}", - path.repr(tcx)).index(&FullRange)) + &format!("unbound path {}", + path.repr(tcx))[]) } Some(&d) => d }; @@ -1156,8 +1111,8 @@ pub fn ast_ty_to_ty<'tcx>( } def::DefMod(id) => { tcx.sess.span_fatal(ast_ty.span, - format!("found module name used as a type: {}", - tcx.map.node_to_string(id.node)).index(&FullRange)); + &format!("found module name used as a type: {}", + tcx.map.node_to_string(id.node))[]); } def::DefPrimTy(_) => { panic!("DefPrimTy arm missed in previous ast_ty_to_prim_ty call"); @@ -1166,7 +1121,7 @@ pub fn ast_ty_to_ty<'tcx>( let path_str = tcx.map.path_to_string( tcx.map.get_parent(trait_type_id.node)); tcx.sess.span_err(ast_ty.span, - format!("ambiguous associated \ + &format!("ambiguous associated \ type; specify the type \ using the syntax `<Type \ as {}>::{}`", @@ -1176,7 +1131,7 @@ pub fn ast_ty_to_ty<'tcx>( .last() .unwrap() .identifier) - .get()).index(&FullRange)); + .get())[]); this.tcx().types.err } def::DefAssociatedPath(provenance, assoc_ident) => { @@ -1184,9 +1139,9 @@ pub fn ast_ty_to_ty<'tcx>( } _ => { tcx.sess.span_fatal(ast_ty.span, - format!("found value name used \ + &format!("found value name used \ as a type: {:?}", - a_def).index(&FullRange)); + a_def)[]); } } } @@ -1212,9 +1167,9 @@ pub fn ast_ty_to_ty<'tcx>( Err(ref r) => { tcx.sess.span_fatal( ast_ty.span, - format!("expected constant expr for array \ + &format!("expected constant expr for array \ length: {}", - *r).index(&FullRange)); + *r)[]); } } } @@ -1336,7 +1291,7 @@ fn ty_of_method_or_bare_fn<'a, 'tcx>(this: &AstConv<'tcx>, let input_params = if self_ty.is_some() { decl.inputs.slice_from(1) } else { - decl.inputs.index(&FullRange) + &decl.inputs[] }; let input_tys = input_params.iter().map(|a| ty_of_arg(this, &rb, a, None)); let input_pats: Vec<String> = input_params.iter() @@ -1551,7 +1506,7 @@ fn conv_ty_poly_trait_ref<'tcx>( ast_bounds: &[ast::TyParamBound]) -> Ty<'tcx> { - let mut partitioned_bounds = partition_bounds(this.tcx(), span, ast_bounds.index(&FullRange)); + let mut partitioned_bounds = partition_bounds(this.tcx(), span, &ast_bounds[]); let mut projection_bounds = Vec::new(); let main_trait_bound = if !partitioned_bounds.trait_bounds.is_empty() { @@ -1600,8 +1555,8 @@ pub fn conv_existential_bounds_from_partitioned_bounds<'tcx>( let b = &trait_bounds[0]; this.tcx().sess.span_err( b.trait_ref.path.span, - format!("only the builtin traits can be used \ - as closure or object bounds").index(&FullRange)); + &format!("only the builtin traits can be used \ + as closure or object bounds")[]); } let region_bound = compute_region_bound(this, @@ -1673,8 +1628,8 @@ fn compute_opt_region_bound<'tcx>(tcx: &ty::ctxt<'tcx>, if derived_region_bounds.slice_from(1).iter().any(|r1| r != *r1) { tcx.sess.span_err( span, - format!("ambiguous lifetime bound, \ - explicit lifetime bound required").index(&FullRange)); + &format!("ambiguous lifetime bound, \ + explicit lifetime bound required")[]); } return Some(r); } @@ -1700,7 +1655,7 @@ fn compute_region_bound<'tcx>( None => { this.tcx().sess.span_err( span, - format!("explicit lifetime bound required").index(&FullRange)); + &format!("explicit lifetime bound required")[]); ty::ReStatic } } diff --git a/src/librustc_typeck/check/_match.rs b/src/librustc_typeck/check/_match.rs index d9829fd1416..cacf9bb19d2 100644 --- a/src/librustc_typeck/check/_match.rs +++ b/src/librustc_typeck/check/_match.rs @@ -195,14 +195,6 @@ pub fn check_pat<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>, ast::PatRegion(ref inner, mutbl) => { let inner_ty = fcx.infcx().next_ty_var(); - // SNAP 340ac04 remove this `if`-`else` entirely after next snapshot - let mutbl = if mutbl == ast::MutImmutable { - ty::deref(fcx.infcx().shallow_resolve(expected), true) - .map(|mt| mt.mutbl).unwrap_or(ast::MutImmutable) - } else { - mutbl - }; - let mt = ty::mt { ty: inner_ty, mutbl: mutbl }; let region = fcx.infcx().next_region_var(infer::PatternRegion(pat.span)); let rptr_ty = ty::mk_rptr(tcx, tcx.mk_region(region), mt); diff --git a/src/librustc_typeck/check/method/confirm.rs b/src/librustc_typeck/check/method/confirm.rs index cd27c20db45..7e72f300f41 100644 --- a/src/librustc_typeck/check/method/confirm.rs +++ b/src/librustc_typeck/check/method/confirm.rs @@ -314,8 +314,8 @@ impl<'a,'tcx> ConfirmContext<'a,'tcx> { None => { self.tcx().sess.span_bug( self.span, - format!("self-type `{}` for ObjectPick never dereferenced to an object", - self_ty.repr(self.tcx())).index(&FullRange)) + &format!("self-type `{}` for ObjectPick never dereferenced to an object", + self_ty.repr(self.tcx()))[]) } } } @@ -367,10 +367,10 @@ impl<'a,'tcx> ConfirmContext<'a,'tcx> { Err(_) => { self.tcx().sess.span_bug( self.span, - format!( + &format!( "{} was a subtype of {} but now is not?", self_ty.repr(self.tcx()), - method_self_ty.repr(self.tcx())).index(&FullRange)); + method_self_ty.repr(self.tcx()))[]); } } } diff --git a/src/librustc_typeck/check/method/mod.rs b/src/librustc_typeck/check/method/mod.rs index 87ea082b6b2..bb000742def 100644 --- a/src/librustc_typeck/check/method/mod.rs +++ b/src/librustc_typeck/check/method/mod.rs @@ -264,9 +264,9 @@ pub fn lookup_in_trait_adjusted<'a, 'tcx>(fcx: &'a FnCtxt<'a, 'tcx>, _ => { fcx.tcx().sess.span_bug( span, - format!( + &format!( "trait method is &self but first arg is: {}", - transformed_self_ty.repr(fcx.tcx())).index(&FullRange)); + transformed_self_ty.repr(fcx.tcx()))[]); } } } @@ -274,9 +274,9 @@ pub fn lookup_in_trait_adjusted<'a, 'tcx>(fcx: &'a FnCtxt<'a, 'tcx>, _ => { fcx.tcx().sess.span_bug( span, - format!( + &format!( "unexpected explicit self type in operator method: {:?}", - method_ty.explicit_self).index(&FullRange)); + method_ty.explicit_self)[]); } } } @@ -329,8 +329,8 @@ pub fn report_error<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, // If the method has the name of a field, give a help note if is_field { cx.sess.span_note(span, - format!("use `(s.{0})(...)` if you meant to call the \ - function stored in the `{0}` field", method_ustring).index(&FullRange)); + &format!("use `(s.{0})(...)` if you meant to call the \ + function stored in the `{0}` field", method_ustring)[]); } if static_sources.len() > 0 { diff --git a/src/librustc_typeck/check/method/probe.rs b/src/librustc_typeck/check/method/probe.rs index 4ba161fa835..dc4d6c9a826 100644 --- a/src/librustc_typeck/check/method/probe.rs +++ b/src/librustc_typeck/check/method/probe.rs @@ -18,7 +18,7 @@ use middle::fast_reject; use middle::subst; use middle::subst::Subst; use middle::traits; -use middle::ty::{self, Ty, ToPolyTraitRef}; +use middle::ty::{self, RegionEscape, Ty, ToPolyTraitRef}; use middle::ty_fold::TypeFoldable; use middle::infer; use middle::infer::InferCtxt; @@ -62,6 +62,7 @@ enum CandidateKind<'tcx> { subst::Substs<'tcx>, MethodIndex), UnboxedClosureCandidate(/* Trait */ ast::DefId, MethodIndex), WhereClauseCandidate(ty::PolyTraitRef<'tcx>, MethodIndex), + ProjectionCandidate(ast::DefId, MethodIndex), } pub struct Pick<'tcx> { @@ -309,18 +310,20 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> { // argument type like `&Trait`. let trait_ref = data.principal_trait_ref_with_self_ty(self.tcx(), self_ty); self.elaborate_bounds(&[trait_ref.clone()], false, |this, new_trait_ref, m, method_num| { + let new_trait_ref = this.erase_late_bound_regions(&new_trait_ref); + let vtable_index = traits::get_vtable_index_of_object_method(tcx, trait_ref.clone(), - new_trait_ref.def_id(), + new_trait_ref.def_id, method_num); - let xform_self_ty = this.xform_self_ty(&m, new_trait_ref.substs()); + let xform_self_ty = this.xform_self_ty(&m, new_trait_ref.substs); this.inherent_candidates.push(Candidate { xform_self_ty: xform_self_ty, method_ty: m, - kind: ObjectCandidate(new_trait_ref.def_id(), method_num, vtable_index) + kind: ObjectCandidate(new_trait_ref.def_id, method_num, vtable_index) }); }); } @@ -353,34 +356,37 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> { }) .collect(); - self.elaborate_bounds(bounds.as_slice(), true, |this, trait_ref, m, method_num| { + self.elaborate_bounds(bounds.as_slice(), true, |this, poly_trait_ref, m, method_num| { + let trait_ref = + this.erase_late_bound_regions(&poly_trait_ref); + let xform_self_ty = - this.xform_self_ty(&m, trait_ref.substs()); + this.xform_self_ty(&m, trait_ref.substs); debug!("found match: trait_ref={} substs={} m={}", trait_ref.repr(this.tcx()), - trait_ref.substs().repr(this.tcx()), + trait_ref.substs.repr(this.tcx()), m.repr(this.tcx())); assert_eq!(m.generics.types.get_slice(subst::TypeSpace).len(), - trait_ref.substs().types.get_slice(subst::TypeSpace).len()); + trait_ref.substs.types.get_slice(subst::TypeSpace).len()); assert_eq!(m.generics.regions.get_slice(subst::TypeSpace).len(), - trait_ref.substs().regions().get_slice(subst::TypeSpace).len()); + trait_ref.substs.regions().get_slice(subst::TypeSpace).len()); assert_eq!(m.generics.types.get_slice(subst::SelfSpace).len(), - trait_ref.substs().types.get_slice(subst::SelfSpace).len()); + trait_ref.substs.types.get_slice(subst::SelfSpace).len()); assert_eq!(m.generics.regions.get_slice(subst::SelfSpace).len(), - trait_ref.substs().regions().get_slice(subst::SelfSpace).len()); + trait_ref.substs.regions().get_slice(subst::SelfSpace).len()); // Because this trait derives from a where-clause, it // should not contain any inference variables or other // artifacts. This means it is safe to put into the // `WhereClauseCandidate` and (eventually) into the // `WhereClausePick`. - assert!(trait_ref.substs().types.iter().all(|&t| !ty::type_needs_infer(t))); + assert!(trait_ref.substs.types.iter().all(|&t| !ty::type_needs_infer(t))); this.inherent_candidates.push(Candidate { xform_self_ty: xform_self_ty, method_ty: m, - kind: WhereClauseCandidate(trait_ref, method_num) + kind: WhereClauseCandidate(poly_trait_ref, method_num) }); }); } @@ -474,6 +480,10 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> { method.clone(), matching_index); + self.assemble_projection_candidates(trait_def_id, + method.clone(), + matching_index); + self.assemble_where_clause_candidates(trait_def_id, method, matching_index); @@ -575,8 +585,8 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> { None => { self.tcx().sess.span_bug( self.span, - format!("No entry for unboxed closure: {}", - closure_def_id.repr(self.tcx())).index(&FullRange)); + &format!("No entry for unboxed closure: {}", + closure_def_id.repr(self.tcx()))[]); } }; @@ -603,6 +613,64 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> { } } + fn assemble_projection_candidates(&mut self, + trait_def_id: ast::DefId, + method: Rc<ty::Method<'tcx>>, + method_index: uint) + { + debug!("assemble_projection_candidates(\ + trait_def_id={}, \ + method={}, \ + method_index={})", + trait_def_id.repr(self.tcx()), + method.repr(self.tcx()), + method_index); + + for step in self.steps.iter() { + debug!("assemble_projection_candidates: step={}", + step.repr(self.tcx())); + + let projection_trait_ref = match step.self_ty.sty { + ty::ty_projection(ref data) => &data.trait_ref, + _ => continue, + }; + + debug!("assemble_projection_candidates: projection_trait_ref={}", + projection_trait_ref.repr(self.tcx())); + + let trait_def = ty::lookup_trait_def(self.tcx(), projection_trait_ref.def_id); + let bounds = trait_def.generics.to_bounds(self.tcx(), projection_trait_ref.substs); + let predicates = bounds.predicates.into_vec(); + debug!("assemble_projection_candidates: predicates={}", + predicates.repr(self.tcx())); + for poly_bound in + traits::elaborate_predicates(self.tcx(), predicates) + .filter_map(|p| p.to_opt_poly_trait_ref()) + .filter(|b| b.def_id() == trait_def_id) + { + let bound = self.erase_late_bound_regions(&poly_bound); + + debug!("assemble_projection_candidates: projection_trait_ref={} bound={}", + projection_trait_ref.repr(self.tcx()), + bound.repr(self.tcx())); + + if self.infcx().can_equate(&step.self_ty, &bound.self_ty()).is_ok() { + let xform_self_ty = self.xform_self_ty(&method, bound.substs); + + debug!("assemble_projection_candidates: bound={} xform_self_ty={}", + bound.repr(self.tcx()), + xform_self_ty.repr(self.tcx())); + + self.extension_candidates.push(Candidate { + xform_self_ty: xform_self_ty, + method_ty: method.clone(), + kind: ProjectionCandidate(trait_def_id, method_index) + }); + } + } + } + } + fn assemble_where_clause_candidates(&mut self, trait_def_id: ast::DefId, method_ty: Rc<ty::Method<'tcx>>, @@ -611,14 +679,14 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> { debug!("assemble_where_clause_candidates(trait_def_id={})", trait_def_id.repr(self.tcx())); - // Check whether there are any where-clauses pertaining to this trait. let caller_predicates = self.fcx.inh.param_env.caller_bounds.predicates.as_slice().to_vec(); - for bound in traits::elaborate_predicates(self.tcx(), caller_predicates) - .filter_map(|p| p.to_opt_poly_trait_ref()) - .filter(|b| b.def_id() == trait_def_id) + for poly_bound in traits::elaborate_predicates(self.tcx(), caller_predicates) + .filter_map(|p| p.to_opt_poly_trait_ref()) + .filter(|b| b.def_id() == trait_def_id) { - let xform_self_ty = self.xform_self_ty(&method_ty, bound.substs()); + let bound = self.erase_late_bound_regions(&poly_bound); + let xform_self_ty = self.xform_self_ty(&method_ty, bound.substs); debug!("assemble_where_clause_candidates: bound={} xform_self_ty={}", bound.repr(self.tcx()), @@ -627,7 +695,7 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> { self.extension_candidates.push(Candidate { xform_self_ty: xform_self_ty, method_ty: method_ty.clone(), - kind: WhereClauseCandidate(bound, method_index) + kind: WhereClauseCandidate(poly_bound, method_index) }); } } @@ -745,7 +813,7 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> { debug!("pick_method(self_ty={})", self.infcx().ty_to_string(self_ty)); debug!("searching inherent candidates"); - match self.consider_candidates(self_ty, self.inherent_candidates.index(&FullRange)) { + match self.consider_candidates(self_ty, &self.inherent_candidates[]) { None => {} Some(pick) => { return Some(pick); @@ -753,7 +821,7 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> { } debug!("searching extension candidates"); - self.consider_candidates(self_ty, self.extension_candidates.index(&FullRange)) + self.consider_candidates(self_ty, &self.extension_candidates[]) } fn consider_candidates(&self, @@ -768,7 +836,7 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> { debug!("applicable_candidates: {}", applicable_candidates.repr(self.tcx())); if applicable_candidates.len() > 1 { - match self.collapse_candidates_to_trait_pick(applicable_candidates.index(&FullRange)) { + match self.collapse_candidates_to_trait_pick(&applicable_candidates[]) { Some(pick) => { return Some(Ok(pick)); } None => { } } @@ -829,6 +897,7 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> { norm_obligations.iter().all(|o| selcx.evaluate_obligation(o)) } + ProjectionCandidate(..) | ObjectCandidate(..) | UnboxedClosureCandidate(..) | WhereClauseCandidate(..) => { @@ -864,7 +933,7 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> { Some(data) => data, None => return None, }; - if probes.index(&(1..)).iter().any(|p| p.to_trait_data() != Some(trait_data)) { + if probes[1..].iter().any(|p| p.to_trait_data() != Some(trait_data)) { return None; } @@ -920,6 +989,8 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> { method.fty.sig.0.inputs[0].repr(self.tcx()), substs.repr(self.tcx())); + assert!(!substs.has_escaping_regions()); + // It is possible for type parameters or early-bound lifetimes // to appear in the signature of `self`. The substitutions we // are given do not include type/lifetime parameters for the @@ -949,14 +1020,13 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> { substs = &placeholder; } - // Replace early-bound regions and types. - let xform_self_ty = method.fty.sig.0.inputs[0].subst(self.tcx(), substs); + // Erase any late-bound regions from the method and substitute + // in the values from the substitution. + let xform_self_ty = method.fty.sig.input(0); + let xform_self_ty = self.erase_late_bound_regions(&xform_self_ty); + let xform_self_ty = xform_self_ty.subst(self.tcx(), substs); - // Replace late-bound regions bound in the impl or - // where-clause (2 levels of binding) and method (1 level of binding). - self.erase_late_bound_regions( - &self.erase_late_bound_regions( - &ty::Binder(ty::Binder(xform_self_ty)))) + xform_self_ty } fn impl_substs(&self, @@ -1065,6 +1135,9 @@ impl<'tcx> Candidate<'tcx> { WhereClausePick((*trait_ref).clone(), index) } + ProjectionCandidate(def_id, index) => { + TraitPick(def_id, index) + } } } } @@ -1076,6 +1149,7 @@ impl<'tcx> Candidate<'tcx> { ExtensionImplCandidate(def_id, _, _, _) => ImplSource(def_id), UnboxedClosureCandidate(trait_def_id, _) => TraitSource(trait_def_id), WhereClauseCandidate(ref trait_ref, _) => TraitSource(trait_ref.def_id()), + ProjectionCandidate(trait_def_id, _) => TraitSource(trait_def_id), } } @@ -1094,6 +1168,9 @@ impl<'tcx> Candidate<'tcx> { WhereClauseCandidate(ref trait_ref, method_num) => { Some((trait_ref.def_id(), method_num)) } + ProjectionCandidate(trait_def_id, method_num) => { + Some((trait_def_id, method_num)) + } } } } @@ -1120,6 +1197,8 @@ impl<'tcx> Repr<'tcx> for CandidateKind<'tcx> { format!("UnboxedClosureCandidate({},{})", a.repr(tcx), b), WhereClauseCandidate(ref a, ref b) => format!("WhereClauseCandidate({},{})", a.repr(tcx), b), + ProjectionCandidate(ref a, ref b) => + format!("ProjectionCandidate({},{})", a.repr(tcx), b), } } } diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index 9563dd45ca2..b98b327100c 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -90,7 +90,7 @@ use middle::mem_categorization as mc; use middle::mem_categorization::McResult; use middle::pat_util::{self, pat_id_map}; use middle::region::CodeExtent; -use middle::subst::{self, Subst, Substs, VecPerParamSpace, ParamSpace}; +use middle::subst::{self, Subst, Substs, VecPerParamSpace, ParamSpace, TypeSpace}; use middle::traits; use middle::ty::{FnSig, VariantInfo, TypeScheme}; use middle::ty::{Disr, ParamTy, ParameterEnvironment}; @@ -593,7 +593,7 @@ fn check_fn<'a, 'tcx>(ccx: &'a CrateCtxt<'a, 'tcx>, let tcx = ccx.tcx; let err_count_on_creation = tcx.sess.err_count(); - let arg_tys = fn_sig.inputs.index(&FullRange); + let arg_tys = &fn_sig.inputs[]; let ret_ty = fn_sig.output; debug!("check_fn(arg_tys={}, ret_ty={}, fn_id={})", @@ -691,7 +691,7 @@ pub fn check_item(ccx: &CrateCtxt, it: &ast::Item) { ast::ItemEnum(ref enum_definition, _) => { check_enum_variants(ccx, it.span, - enum_definition.variants.index(&FullRange), + &enum_definition.variants[], it.id); } ast::ItemFn(ref decl, _, _, _, ref body) => { @@ -985,21 +985,21 @@ fn compare_impl_method<'tcx>(tcx: &ty::ctxt<'tcx>, (&ty::StaticExplicitSelfCategory, _) => { tcx.sess.span_err( impl_m_span, - format!("method `{}` has a `{}` declaration in the impl, \ + &format!("method `{}` has a `{}` declaration in the impl, \ but not in the trait", token::get_name(trait_m.name), ppaux::explicit_self_category_to_str( - &impl_m.explicit_self)).index(&FullRange)); + &impl_m.explicit_self))[]); return; } (_, &ty::StaticExplicitSelfCategory) => { tcx.sess.span_err( impl_m_span, - format!("method `{}` has a `{}` declaration in the trait, \ + &format!("method `{}` has a `{}` declaration in the trait, \ but not in the impl", token::get_name(trait_m.name), ppaux::explicit_self_category_to_str( - &trait_m.explicit_self)).index(&FullRange)); + &trait_m.explicit_self))[]); return; } _ => { @@ -1358,9 +1358,9 @@ fn compare_impl_method<'tcx>(tcx: &ty::ctxt<'tcx>, if trait_params.len() != impl_params.len() { tcx.sess.span_err( span, - format!("lifetime parameters or bounds on method `{}` do \ + &format!("lifetime parameters or bounds on method `{}` do \ not match the trait declaration", - token::get_name(impl_m.name)).index(&FullRange)); + token::get_name(impl_m.name))[]); return false; } @@ -1406,13 +1406,13 @@ fn compare_impl_method<'tcx>(tcx: &ty::ctxt<'tcx>, let err = if missing.len() != 0 || extra.len() != 0 { tcx.sess.span_err( span, - format!( + &format!( "the lifetime parameter `{}` declared in the impl \ has a distinct set of bounds \ from its counterpart `{}` \ declared in the trait", impl_param.name.user_string(tcx), - trait_param.name.user_string(tcx)).index(&FullRange)); + trait_param.name.user_string(tcx))[]); true } else { false @@ -1421,15 +1421,15 @@ fn compare_impl_method<'tcx>(tcx: &ty::ctxt<'tcx>, if missing.len() != 0 { tcx.sess.span_note( span, - format!("the impl is missing the following bounds: `{}`", - missing.user_string(tcx)).index(&FullRange)); + &format!("the impl is missing the following bounds: `{}`", + missing.user_string(tcx))[]); } if extra.len() != 0 { tcx.sess.span_note( span, - format!("the impl has the following extra bounds: `{}`", - extra.user_string(tcx)).index(&FullRange)); + &format!("the impl has the following extra bounds: `{}`", + extra.user_string(tcx))[]); } if err { @@ -1699,8 +1699,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { None => { self.tcx().sess.span_bug( span, - format!("no type for local variable {}", - nid).index(&FullRange)); + &format!("no type for local variable {}", + nid)[]); } } } @@ -1709,7 +1709,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { /// ! gets replaced with (), unconstrained ints with i32, and unconstrained floats with f64. pub fn default_type_parameters(&self) { use middle::ty::UnconstrainedNumeric::{UnconstrainedInt, UnconstrainedFloat, Neither}; - for (_, &ref ty) in self.inh.node_types.borrow_mut().iter_mut() { + for (_, &mut ref ty) in self.inh.node_types.borrow_mut().iter_mut() { let resolved = self.infcx().resolve_type_vars_if_possible(ty); if self.infcx().type_var_diverges(resolved) { demand::eqtype(self, codemap::DUMMY_SP, *ty, ty::mk_nil(self.tcx())); @@ -1947,6 +1947,43 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { } } + /// Returns the type that this AST path refers to. If the path has no type + /// parameters and the corresponding type has type parameters, fresh type + /// and/or region variables are substituted. + /// + /// This is used when checking the constructor in struct literals. + fn instantiate_struct_literal_ty(&self, + did: ast::DefId, + path: &ast::Path) + -> TypeAndSubsts<'tcx> + { + let tcx = self.tcx(); + + let ty::TypeScheme { generics, ty: decl_ty } = ty::lookup_item_type(tcx, did); + + let wants_params = + generics.has_type_params(TypeSpace) || generics.has_region_params(TypeSpace); + + let needs_defaults = + wants_params && + path.segments.iter().all(|s| s.parameters.is_empty()); + + let substs = if needs_defaults { + let tps = + self.infcx().next_ty_vars(generics.types.len(TypeSpace)); + let rps = + self.infcx().region_vars_for_defs(path.span, + generics.regions.get_slice(TypeSpace)); + Substs::new_type(tps, rps) + } else { + astconv::ast_path_substs_for_ty(self, self, &generics, path) + }; + + let ty = self.instantiate_type_scheme(path.span, &substs, &decl_ty); + + TypeAndSubsts { substs: substs, ty: ty } + } + pub fn write_nil(&self, node_id: ast::NodeId) { self.write_ty(node_id, ty::mk_nil(self.tcx())); } @@ -2033,8 +2070,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { match self.inh.node_types.borrow().get(&ex.id) { Some(&t) => t, None => { - self.tcx().sess.bug(format!("no type for expr in fcx {}", - self.tag()).index(&FullRange)); + self.tcx().sess.bug(&format!("no type for expr in fcx {}", + self.tag())[]); } } } @@ -2062,9 +2099,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { Some(&t) => t, None => { self.tcx().sess.bug( - format!("no type for node {}: {} in fcx {}", + &format!("no type for node {}: {} in fcx {}", id, self.tcx().map.node_to_string(id), - self.tag()).index(&FullRange)); + self.tag())[]); } } } @@ -2466,7 +2503,7 @@ fn lookup_method_for_for_loop<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, Ok(trait_did) => trait_did, Err(ref err_string) => { fcx.tcx().sess.span_err(iterator_expr.span, - err_string.index(&FullRange)); + &err_string[]); return fcx.tcx().types.err } }; @@ -2490,10 +2527,10 @@ fn lookup_method_for_for_loop<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, if !ty::type_is_error(true_expr_type) { let ty_string = fcx.infcx().ty_to_string(true_expr_type); fcx.tcx().sess.span_err(iterator_expr.span, - format!("`for` loop expression has type `{}` which does \ + &format!("`for` loop expression has type `{}` which does \ not implement the `Iterator` trait; \ maybe try .iter()", - ty_string).index(&FullRange)); + ty_string)[]); } fcx.tcx().types.err } @@ -2528,10 +2565,10 @@ fn lookup_method_for_for_loop<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, } _ => { fcx.tcx().sess.span_err(iterator_expr.span, - format!("`next` method of the `Iterator` \ + &format!("`next` method of the `Iterator` \ trait has an unexpected type `{}`", fcx.infcx().ty_to_string(return_type)) - .index(&FullRange)); + []); fcx.tcx().types.err } } @@ -2558,7 +2595,7 @@ fn check_method_argument_types<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, check_argument_types(fcx, sp, - err_inputs.index(&FullRange), + &err_inputs[], args_no_rcvr, autoref_args, false, @@ -3010,7 +3047,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, }; // Call the generic checker. - let args: Vec<_> = args.index(&(1..)).iter().map(|x| x).collect(); + let args: Vec<_> = args[1..].iter().map(|x| x).collect(); let ret_ty = check_method_argument_types(fcx, method_name.span, fn_ty, @@ -3328,7 +3365,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, ty::ty_struct(base_id, substs) => { debug!("struct named {}", ppaux::ty_to_string(tcx, base_t)); let fields = ty::lookup_struct_fields(tcx, base_id); - lookup_field_ty(tcx, base_id, fields.index(&FullRange), + lookup_field_ty(tcx, base_id, &fields[], field.node.name, &(*substs)) } _ => None @@ -3391,7 +3428,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, if tuple_like { debug!("tuple struct named {}", ppaux::ty_to_string(tcx, base_t)); let fields = ty::lookup_struct_fields(tcx, base_id); - lookup_tup_field_ty(tcx, base_id, fields.index(&FullRange), + lookup_tup_field_ty(tcx, base_id, &fields[], idx.node, &(*substs)) } else { None @@ -3490,17 +3527,18 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, expected_field_type = ty::lookup_field_type( tcx, class_id, field_id, substitutions); + expected_field_type = + fcx.normalize_associated_types_in( + field.span, &expected_field_type); class_field_map.insert( field.ident.node.name, (field_id, true)); fields_found += 1; } } + // Make sure to give a type to the field even if there's // an error, so we can continue typechecking - check_expr_coercable_to_type( - fcx, - &*field.expr, - expected_field_type); + check_expr_coercable_to_type(fcx, &*field.expr, expected_field_type); } if error_happened { @@ -3556,7 +3594,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, class_id, id, fcx.ccx.tcx.mk_substs(struct_substs), - class_fields.index(&FullRange), + &class_fields[], fields, base_expr.is_none(), None); @@ -3599,7 +3637,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, variant_id, id, fcx.ccx.tcx.mk_substs(substitutions), - variant_fields.index(&FullRange), + &variant_fields[], fields, true, Some(enum_id)); @@ -4066,7 +4104,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, let expected = expected.only_has_type(); let flds = expected.map_to_option(fcx, |ty| { match ty.sty { - ty::ty_tup(ref flds) => Some(flds.index(&FullRange)), + ty::ty_tup(ref flds) => Some(&flds[]), _ => None } }); @@ -4100,7 +4138,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, let struct_id = match def { Some(def::DefVariant(enum_id, variant_id, true)) => { check_struct_enum_variant(fcx, id, expr.span, enum_id, - variant_id, fields.index(&FullRange)); + variant_id, &fields[]); enum_id } Some(def::DefTrait(def_id)) => { @@ -4109,7 +4147,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, pprust::path_to_string(path)); check_struct_fields_on_error(fcx, id, - fields.index(&FullRange), + &fields[], base_expr); def_id }, @@ -4122,7 +4160,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, id, expr.span, struct_did, - fields.index(&FullRange), + &fields[], base_expr.as_ref().map(|e| &**e)); } _ => { @@ -4131,7 +4169,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, pprust::path_to_string(path)); check_struct_fields_on_error(fcx, id, - fields.index(&FullRange), + &fields[], base_expr); } } @@ -4149,10 +4187,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, // parameters correctly. let actual_structure_type = fcx.expr_ty(&*expr); if !ty::type_is_error(actual_structure_type) { - let type_and_substs = astconv::ast_path_to_ty_relaxed(fcx, - fcx, - struct_id, - path); + let type_and_substs = fcx.instantiate_struct_literal_ty(struct_id, path); match fcx.mk_subty(false, infer::Misc(path.span), actual_structure_type, @@ -4164,7 +4199,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, fcx.tcx() .sess .span_err(path.span, - format!("structure constructor specifies a \ + &format!("structure constructor specifies a \ structure of type `{}`, but this \ structure has type `{}`: {}", fcx.infcx() @@ -4172,7 +4207,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, fcx.infcx() .ty_to_string( actual_structure_type), - type_error_description).index(&FullRange)); + type_error_description)[]); ty::note_and_explain_type_err(tcx, &type_error); } } @@ -4847,7 +4882,7 @@ pub fn check_enum_variants(ccx: &CrateCtxt, } let hint = *ty::lookup_repr_hints(ccx.tcx, ast::DefId { krate: ast::LOCAL_CRATE, node: id }) - .index(&FullRange).get(0).unwrap_or(&attr::ReprAny); + [].get(0).unwrap_or(&attr::ReprAny); if hint != attr::ReprAny && vs.len() <= 1 { if vs.len() == 1 { @@ -5518,7 +5553,7 @@ pub fn check_intrinsic_type(ccx: &CrateCtxt, it: &ast::ForeignItem) { "get_tydesc" => { let tydesc_ty = match ty::get_tydesc_ty(ccx.tcx) { Ok(t) => t, - Err(s) => { tcx.sess.span_fatal(it.span, s.index(&FullRange)); } + Err(s) => { tcx.sess.span_fatal(it.span, &s[]); } }; let td_ptr = ty::mk_ptr(ccx.tcx, ty::mt { ty: tydesc_ty, @@ -5534,7 +5569,7 @@ pub fn check_intrinsic_type(ccx: &CrateCtxt, it: &ast::ForeignItem) { ty::mk_struct(ccx.tcx, did, ccx.tcx.mk_substs(subst::Substs::empty()))), Err(msg) => { - tcx.sess.span_fatal(it.span, msg.index(&FullRange)); + tcx.sess.span_fatal(it.span, &msg[]); } } }, diff --git a/src/librustc_typeck/check/regionck.rs b/src/librustc_typeck/check/regionck.rs index 11ad7bcb091..112e0053642 100644 --- a/src/librustc_typeck/check/regionck.rs +++ b/src/librustc_typeck/check/regionck.rs @@ -188,8 +188,8 @@ fn region_of_def(fcx: &FnCtxt, def: def::Def) -> ty::Region { } } _ => { - tcx.sess.bug(format!("unexpected def in region_of_def: {:?}", - def).index(&FullRange)) + tcx.sess.bug(&format!("unexpected def in region_of_def: {:?}", + def)[]) } } } @@ -282,13 +282,13 @@ impl<'a, 'tcx> Rcx<'a, 'tcx> { Some(f) => f, None => { self.tcx().sess.bug( - format!("No fn-sig entry for id={}", id).index(&FullRange)); + &format!("No fn-sig entry for id={}", id)[]); } }; let len = self.region_bound_pairs.len(); - self.relate_free_regions(fn_sig.index(&FullRange), body.id); - link_fn_args(self, CodeExtent::from_node_id(body.id), fn_decl.inputs.index(&FullRange)); + self.relate_free_regions(&fn_sig[], body.id); + link_fn_args(self, CodeExtent::from_node_id(body.id), &fn_decl.inputs[]); self.visit_block(body); self.visit_region_obligations(body.id); self.region_bound_pairs.truncate(len); @@ -629,7 +629,7 @@ fn visit_expr(rcx: &mut Rcx, expr: &ast::Expr) { } ast::ExprMatch(ref discr, ref arms, _) => { - link_match(rcx, &**discr, arms.index(&FullRange)); + link_match(rcx, &**discr, &arms[]); visit::walk_expr(rcx, expr); } @@ -953,8 +953,8 @@ fn constrain_autoderefs<'a, 'tcx>(rcx: &mut Rcx<'a, 'tcx>, let (m, r) = match self_ty.sty { ty::ty_rptr(r, ref m) => (m.mutbl, r), _ => rcx.tcx().sess.span_bug(deref_expr.span, - format!("bad overloaded deref type {}", - method.ty.repr(rcx.tcx())).index(&FullRange)) + &format!("bad overloaded deref type {}", + method.ty.repr(rcx.tcx()))[]) }; { let mc = mc::MemCategorizationContext::new(rcx.fcx); @@ -1318,9 +1318,9 @@ fn link_reborrowed_region<'a, 'tcx>(rcx: &Rcx<'a, 'tcx>, None => { rcx.tcx().sess.span_bug( span, - format!("Illegal upvar id: {}", + &format!("Illegal upvar id: {}", upvar_id.repr( - rcx.tcx())).index(&FullRange)); + rcx.tcx()))[]); } } } diff --git a/src/librustc_typeck/check/regionmanip.rs b/src/librustc_typeck/check/regionmanip.rs index 84d94b0392e..8730858f66e 100644 --- a/src/librustc_typeck/check/regionmanip.rs +++ b/src/librustc_typeck/check/regionmanip.rs @@ -146,8 +146,8 @@ impl<'a, 'tcx> Wf<'a, 'tcx> { ty::ty_open(_) => { self.tcx.sess.bug( - format!("Unexpected type encountered while doing wf check: {}", - ty.repr(self.tcx)).index(&FullRange)); + &format!("Unexpected type encountered while doing wf check: {}", + ty.repr(self.tcx))[]); } } } diff --git a/src/librustc_typeck/check/vtable.rs b/src/librustc_typeck/check/vtable.rs index e302609bf22..3940092eb72 100644 --- a/src/librustc_typeck/check/vtable.rs +++ b/src/librustc_typeck/check/vtable.rs @@ -72,17 +72,17 @@ pub fn check_object_cast<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, (_, &ty::ty_uniq(..)) => { fcx.ccx.tcx.sess.span_err( source_expr.span, - format!("can only cast an boxed pointer \ + &format!("can only cast an boxed pointer \ to a boxed object, not a {}", - ty::ty_sort_string(fcx.tcx(), source_ty)).index(&FullRange)); + ty::ty_sort_string(fcx.tcx(), source_ty))[]); } (_, &ty::ty_rptr(..)) => { fcx.ccx.tcx.sess.span_err( source_expr.span, - format!("can only cast a &-pointer \ + &format!("can only cast a &-pointer \ to an &-object, not a {}", - ty::ty_sort_string(fcx.tcx(), source_ty)).index(&FullRange)); + ty::ty_sort_string(fcx.tcx(), source_ty))[]); } _ => { diff --git a/src/librustc_typeck/check/wf.rs b/src/librustc_typeck/check/wf.rs index 898a5f9fe0c..b17ecdaf59c 100644 --- a/src/librustc_typeck/check/wf.rs +++ b/src/librustc_typeck/check/wf.rs @@ -24,6 +24,7 @@ use syntax::ast; use syntax::ast_util::{local_def}; use syntax::attr; use syntax::codemap::Span; +use syntax::parse::token; use syntax::visit; use syntax::visit::Visitor; @@ -77,6 +78,14 @@ impl<'ccx, 'tcx> CheckTypeWellFormedVisitor<'ccx, 'tcx> { enum_variants(fcx, enum_def) }); } + ast::ItemTrait(..) => { + let trait_def = + ty::lookup_trait_def(ccx.tcx, local_def(item.id)); + reject_non_type_param_bounds( + ccx.tcx, + item.span, + &trait_def.generics); + } _ => {} } } @@ -237,21 +246,32 @@ impl<'ccx, 'tcx> CheckTypeWellFormedVisitor<'ccx, 'tcx> { fn reject_non_type_param_bounds<'tcx>(tcx: &ty::ctxt<'tcx>, span: Span, generics: &ty::Generics<'tcx>) { + for predicate in generics.predicates.iter() { match predicate { &ty::Predicate::Trait(ty::Binder(ref tr)) => { - let self_ty = tr.self_ty(); - if !self_ty.walk().any(|t| is_ty_param(t)) { - tcx.sess.span_err( - span, - format!("cannot bound type `{}`, where clause \ - bounds may only be attached to types involving \ - type parameters", - self_ty.repr(tcx)).as_slice()) - } + let found_param = tr.input_types().iter() + .flat_map(|ty| ty.walk()) + .any(is_ty_param); + if !found_param { report_bound_error(tcx, span, tr.self_ty() )} + } + &ty::Predicate::TypeOutlives(ty::Binder(ty::OutlivesPredicate(ty, _))) => { + let found_param = ty.walk().any(|t| is_ty_param(t)); + if !found_param { report_bound_error(tcx, span, ty) } } _ => {} - } + }; + } + + fn report_bound_error<'t>(tcx: &ty::ctxt<'t>, + span: Span, + bounded_ty: ty::Ty<'t>) { + tcx.sess.span_err( + span, + format!("cannot bound type `{}`, where clause \ + bounds may only be attached to types involving \ + type parameters", + bounded_ty.repr(tcx)).as_slice()) } fn is_ty_param(ty: ty::Ty) -> bool { @@ -262,11 +282,68 @@ fn reject_non_type_param_bounds<'tcx>(tcx: &ty::ctxt<'tcx>, } } +fn reject_shadowing_type_parameters<'tcx>(tcx: &ty::ctxt<'tcx>, + span: Span, + generics: &ty::Generics<'tcx>) { + let impl_params = generics.types.get_slice(subst::TypeSpace).iter() + .map(|tp| tp.name).collect::<HashSet<_>>(); + + for method_param in generics.types.get_slice(subst::FnSpace).iter() { + if impl_params.contains(&method_param.name) { + tcx.sess.span_err( + span, + &*format!("type parameter `{}` shadows another type parameter of the same name", + token::get_name(method_param.name))); + } + } +} + impl<'ccx, 'tcx, 'v> Visitor<'v> for CheckTypeWellFormedVisitor<'ccx, 'tcx> { fn visit_item(&mut self, i: &ast::Item) { self.check_item_well_formed(i); visit::walk_item(self, i); } + + fn visit_fn(&mut self, + fk: visit::FnKind<'v>, fd: &'v ast::FnDecl, + b: &'v ast::Block, span: Span, id: ast::NodeId) { + match fk { + visit::FkFnBlock | visit::FkItemFn(..) => {} + visit::FkMethod(..) => { + match ty::impl_or_trait_item(self.ccx.tcx, local_def(id)) { + ty::ImplOrTraitItem::MethodTraitItem(ty_method) => { + reject_shadowing_type_parameters(self.ccx.tcx, span, &ty_method.generics) + } + _ => {} + } + } + } + visit::walk_fn(self, fk, fd, b, span) + } + + fn visit_trait_item(&mut self, t: &'v ast::TraitItem) { + match t { + &ast::TraitItem::ProvidedMethod(_) | + &ast::TraitItem::TypeTraitItem(_) => {}, + &ast::TraitItem::RequiredMethod(ref method) => { + match ty::impl_or_trait_item(self.ccx.tcx, local_def(method.id)) { + ty::ImplOrTraitItem::MethodTraitItem(ty_method) => { + reject_non_type_param_bounds( + self.ccx.tcx, + method.span, + &ty_method.generics); + reject_shadowing_type_parameters( + self.ccx.tcx, + method.span, + &ty_method.generics); + } + _ => {} + } + } + } + + visit::walk_trait_item(self, t) + } } pub struct BoundsChecker<'cx,'tcx:'cx> { @@ -455,7 +532,6 @@ fn enum_variants<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, let arg_tys = ty::assert_no_late_bound_regions( fcx.tcx(), &ty::ty_fn_args(ctor_ty)); - AdtVariant { fields: args.iter().enumerate().map(|(index, arg)| { let arg_ty = arg_tys[index]; diff --git a/src/librustc_typeck/coherence/mod.rs b/src/librustc_typeck/coherence/mod.rs index a0f30788bbd..9d4aa23960d 100644 --- a/src/librustc_typeck/coherence/mod.rs +++ b/src/librustc_typeck/coherence/mod.rs @@ -68,9 +68,13 @@ fn get_base_type_def_id<'a, 'tcx>(inference_context: &InferCtxt<'a, 'tcx>, Some(t.principal_def_id()) } + ty_uniq(_) => { + inference_context.tcx.lang_items.owned_box() + } + 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_uniq(_) | + ty_param(..) | ty_err | ty_open(..) | ty_ptr(_) | ty_rptr(_, _) | ty_projection(..) => { None } @@ -80,8 +84,8 @@ fn get_base_type_def_id<'a, 'tcx>(inference_context: &InferCtxt<'a, 'tcx>, // that the user can type inference_context.tcx.sess.span_bug( span, - format!("coherence encountered unexpected type searching for base type: {}", - ty.repr(inference_context.tcx)).index(&FullRange)); + &format!("coherence encountered unexpected type searching for base type: {}", + ty.repr(inference_context.tcx))[]); } } } @@ -487,18 +491,18 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> { Err(ty::FieldDoesNotImplementCopy(name)) => { tcx.sess .span_err(span, - format!("the trait `Copy` may not be \ + &format!("the trait `Copy` may not be \ implemented for this type; field \ `{}` does not implement `Copy`", - token::get_name(name)).index(&FullRange)) + token::get_name(name))[]) } Err(ty::VariantDoesNotImplementCopy(name)) => { tcx.sess .span_err(span, - format!("the trait `Copy` may not be \ + &format!("the trait `Copy` may not be \ implemented for this type; variant \ `{}` does not implement `Copy`", - token::get_name(name)).index(&FullRange)) + token::get_name(name))[]) } Err(ty::TypeIsStructural) => { tcx.sess @@ -507,6 +511,11 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> { for this type; type is not a structure or \ enumeration") } + Err(ty::TypeHasDestructor) => { + span_err!(tcx.sess, span, E0184, + "the trait `Copy` may not be implemented for this type; \ + the type has a destructor"); + } } } } diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs index 79e98f15a2d..c56952abc44 100644 --- a/src/librustc_typeck/collect.rs +++ b/src/librustc_typeck/collect.rs @@ -212,7 +212,7 @@ fn get_enum_variant_types<'a, 'tcx>(ccx: &CollectCtxt<'a, 'tcx>, ast::TupleVariantKind(ref args) if args.len() > 0 => { let rs = ExplicitRscope; let input_tys: Vec<_> = args.iter().map(|va| ccx.to_ty(&rs, &*va.ty)).collect(); - ty::mk_ctor_fn(tcx, variant_def_id, input_tys.index(&FullRange), enum_ty) + ty::mk_ctor_fn(tcx, variant_def_id, &input_tys[], enum_ty) } ast::TupleVariantKind(_) => { @@ -259,7 +259,7 @@ fn collect_trait_methods<'a, 'tcx>(ccx: &CollectCtxt<'a, 'tcx>, ccx, trait_id, &trait_def.generics, - trait_items.index(&FullRange), + &trait_items[], &m.id, &m.ident.name, &m.explicit_self, @@ -273,7 +273,7 @@ fn collect_trait_methods<'a, 'tcx>(ccx: &CollectCtxt<'a, 'tcx>, ccx, trait_id, &trait_def.generics, - trait_items.index(&FullRange), + &trait_items[], &m.id, &m.pe_ident().name, m.pe_explicit_self(), @@ -607,6 +607,11 @@ fn convert(ccx: &CollectCtxt, it: &ast::Item) { methods.push(&**method); } ast::TypeImplItem(ref typedef) => { + if opt_trait_ref.is_none() { + tcx.sess.span_err(typedef.span, + "associated items are not allowed in inherent impls"); + } + let typ = ccx.to_ty(&ExplicitRscope, &*typedef.typ); tcx.tcache .borrow_mut() @@ -779,7 +784,7 @@ fn convert_struct<'a, 'tcx>(ccx: &CollectCtxt<'a, 'tcx>, local_def(field.node.id)].ty).collect(); let ctor_fn_ty = ty::mk_ctor_fn(tcx, local_def(ctor_id), - inputs.index(&FullRange), + &inputs[], selfty); write_ty_to_tcx(tcx, ctor_id, ctor_fn_ty); tcx.tcache.borrow_mut().insert(local_def(ctor_id), @@ -819,8 +824,8 @@ fn get_trait_def<'a, 'tcx>(ccx: &CollectCtxt<'a, 'tcx>, match ccx.tcx.map.get(trait_id.node) { ast_map::NodeItem(item) => trait_def_of_item(ccx, &*item), _ => { - ccx.tcx.sess.bug(format!("get_trait_def({}): not an item", - trait_id.node).index(&FullRange)) + ccx.tcx.sess.bug(&format!("get_trait_def({}): not an item", + trait_id.node)[]) } } } @@ -845,7 +850,7 @@ fn trait_def_of_item<'a, 'tcx>(ccx: &CollectCtxt<'a, 'tcx>, ref s => { tcx.sess.span_bug( it.span, - format!("trait_def_of_item invoked on {:?}", s).index(&FullRange)); + &format!("trait_def_of_item invoked on {:?}", s)[]); } }; @@ -1030,8 +1035,8 @@ fn ty_generics_for_type_or_impl<'a, 'tcx>(ccx: &CollectCtxt<'a, 'tcx>, -> ty::Generics<'tcx> { ty_generics(ccx, subst::TypeSpace, - generics.lifetimes.index(&FullRange), - generics.ty_params.index(&FullRange), + &generics.lifetimes[], + &generics.ty_params[], ty::Generics::empty(), &generics.where_clause) } @@ -1049,8 +1054,8 @@ fn ty_generics_for_trait<'a, 'tcx>(ccx: &CollectCtxt<'a, 'tcx>, let mut generics = ty_generics(ccx, subst::TypeSpace, - ast_generics.lifetimes.index(&FullRange), - ast_generics.ty_params.index(&FullRange), + &ast_generics.lifetimes[], + &ast_generics.ty_params[], ty::Generics::empty(), &ast_generics.where_clause); @@ -1135,8 +1140,8 @@ fn ty_generics_for_fn_or_method<'a,'tcx>(ccx: &CollectCtxt<'a,'tcx>, let early_lifetimes = resolve_lifetime::early_bound_lifetimes(generics); ty_generics(ccx, subst::FnSpace, - early_lifetimes.index(&FullRange), - generics.ty_params.index(&FullRange), + &early_lifetimes[], + &generics.ty_params[], base_generics, &generics.where_clause) } @@ -1323,7 +1328,7 @@ fn get_or_create_type_parameter_def<'a,'tcx>(ccx: &CollectCtxt<'a,'tcx>, let param_ty = ty::ParamTy::new(space, index, param.ident.name); let bounds = compute_bounds(ccx, param_ty.to_ty(ccx.tcx), - param.bounds.index(&FullRange), + ¶m.bounds[], SizedByDefault::Yes, param.span); let default = match param.default { @@ -1404,7 +1409,7 @@ fn check_bounds_compatible<'tcx>(tcx: &ty::ctxt<'tcx>, if !param_bounds.builtin_bounds.contains(&ty::BoundSized) { ty::each_bound_trait_and_supertraits( tcx, - param_bounds.trait_bounds.index(&FullRange), + ¶m_bounds.trait_bounds[], |trait_ref| { let trait_def = ty::lookup_trait_def(tcx, trait_ref.def_id()); if trait_def.bounds.builtin_bounds.contains(&ty::BoundSized) { diff --git a/src/librustc_typeck/diagnostics.rs b/src/librustc_typeck/diagnostics.rs index 9657bf82a8b..c9e15b93ad4 100644 --- a/src/librustc_typeck/diagnostics.rs +++ b/src/librustc_typeck/diagnostics.rs @@ -157,5 +157,6 @@ register_diagnostics! { E0180, E0181, E0182, - E0183 + E0183, + E0184 } diff --git a/src/librustc_typeck/lib.rs b/src/librustc_typeck/lib.rs index ae8731dfa47..76ac4b2e8af 100644 --- a/src/librustc_typeck/lib.rs +++ b/src/librustc_typeck/lib.rs @@ -65,14 +65,17 @@ This API is completely unstable and subject to change. #![crate_name = "rustc_typeck"] #![experimental] +#![staged_api] #![crate_type = "dylib"] #![crate_type = "rlib"] #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png", html_favicon_url = "http://www.rust-lang.org/favicon.ico", html_root_url = "http://doc.rust-lang.org/nightly/")] +#![allow(unknown_features)] #![feature(quote)] #![feature(slicing_syntax, unsafe_destructor)] +#![feature(box_syntax)] #![feature(rustc_diagnostic_macros)] #![allow(non_camel_case_types)] @@ -190,10 +193,10 @@ fn require_same_types<'a, 'tcx, M>(tcx: &ty::ctxt<'tcx>, Ok(_) => true, Err(ref terr) => { tcx.sess.span_err(span, - format!("{}: {}", + &format!("{}: {}", msg(), ty::type_err_to_str(tcx, - terr)).index(&FullRange)); + terr))[]); ty::note_and_explain_type_err(tcx, terr); false } @@ -239,10 +242,10 @@ fn check_main_fn_ty(ccx: &CrateCtxt, } _ => { tcx.sess.span_bug(main_span, - format!("main has a non-function type: found \ + &format!("main has a non-function type: found \ `{}`", ppaux::ty_to_string(tcx, - main_t)).index(&FullRange)); + main_t))[]); } } } @@ -291,9 +294,9 @@ fn check_start_fn_ty(ccx: &CrateCtxt, } _ => { tcx.sess.span_bug(start_span, - format!("start has a non-function type: found \ + &format!("start has a non-function type: found \ `{}`", - ppaux::ty_to_string(tcx, start_t)).index(&FullRange)); + ppaux::ty_to_string(tcx, start_t))[]); } } } diff --git a/src/librustc_typeck/variance.rs b/src/librustc_typeck/variance.rs index 393ba19ba18..b33921e07e8 100644 --- a/src/librustc_typeck/variance.rs +++ b/src/librustc_typeck/variance.rs @@ -562,9 +562,9 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> { match self.terms_cx.inferred_map.get(¶m_id) { Some(&index) => index, None => { - self.tcx().sess.bug(format!( + self.tcx().sess.bug(&format!( "no inferred index entry for {}", - self.tcx().map.node_to_string(param_id)).index(&FullRange)); + self.tcx().map.node_to_string(param_id))[]); } } } @@ -837,9 +837,9 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> { ty::ty_infer(..) | ty::ty_err => { self.tcx().sess.bug( - format!("unexpected type encountered in \ + &format!("unexpected type encountered in \ variance inference: {}", - ty.repr(self.tcx())).index(&FullRange)); + ty.repr(self.tcx()))[]); } } } @@ -917,9 +917,9 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> { // regions when visiting member types or method types. self.tcx() .sess - .bug(format!("unexpected region encountered in variance \ + .bug(&format!("unexpected region encountered in variance \ inference: {}", - region.repr(self.tcx())).index(&FullRange)); + region.repr(self.tcx()))[]); } } } @@ -1055,7 +1055,7 @@ impl<'a, 'tcx> SolveContext<'a, 'tcx> { // attribute and report an error with various results if found. if ty::has_attr(tcx, item_def_id, "rustc_variance") { let found = item_variances.repr(tcx); - tcx.sess.span_err(tcx.map.span(item_id), found.index(&FullRange)); + tcx.sess.span_err(tcx.map.span(item_id), &found[]); } let newly_added = tcx.item_variance_map.borrow_mut() diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index bf2664bba6a..fbb3c40ee99 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -530,7 +530,8 @@ fn external_path_params(cx: &DocContext, trait_did: Option<ast::DefId>, _ => { return PathParameters::AngleBracketed { lifetimes: lifetimes, - types: types.clean(cx) + types: types.clean(cx), + bindings: vec![] } } }; @@ -547,6 +548,7 @@ fn external_path_params(cx: &DocContext, trait_did: Option<ast::DefId>, PathParameters::AngleBracketed { lifetimes: lifetimes, types: types.clean(cx), + bindings: vec![] // FIXME(#20646) } } } @@ -798,7 +800,7 @@ impl Clean<Item> for ast::Method { let all_inputs = &self.pe_fn_decl().inputs; let inputs = match self.pe_explicit_self().node { ast::SelfStatic => all_inputs.as_slice(), - _ => all_inputs.index(&(1..)) + _ => &all_inputs[1..] }; let decl = FnDecl { inputs: Arguments { @@ -836,7 +838,7 @@ impl Clean<Item> for ast::TypeMethod { fn clean(&self, cx: &DocContext) -> Item { let inputs = match self.explicit_self.node { ast::SelfStatic => self.decl.inputs.as_slice(), - _ => self.decl.inputs.index(&(1..)) + _ => &self.decl.inputs[1..] }; let decl = FnDecl { inputs: Arguments { @@ -1132,7 +1134,7 @@ impl<'tcx> Clean<Item> for ty::Method<'tcx> { self.fty.sig.clone()), s => { let sig = ty::Binder(ty::FnSig { - inputs: self.fty.sig.0.inputs.index(&(1..)).to_vec(), + inputs: self.fty.sig.0.inputs[1..].to_vec(), ..self.fty.sig.0.clone() }); let s = match s { @@ -1766,6 +1768,7 @@ pub enum PathParameters { AngleBracketed { lifetimes: Vec<Lifetime>, types: Vec<Type>, + bindings: Vec<TypeBinding> }, Parenthesized { inputs: Vec<Type>, @@ -1779,7 +1782,8 @@ impl Clean<PathParameters> for ast::PathParameters { ast::AngleBracketedParameters(ref data) => { PathParameters::AngleBracketed { lifetimes: data.lifetimes.clean(cx), - types: data.types.clean(cx) + types: data.types.clean(cx), + bindings: data.bindings.clean(cx) } } @@ -2442,8 +2446,25 @@ fn lang_struct(cx: &DocContext, did: Option<ast::DefId>, params: PathParameters::AngleBracketed { lifetimes: vec![], types: vec![t.clean(cx)], + bindings: vec![] } }], }, } } + +/// An equality constraint on an associated type, e.g. `A=Bar` in `Foo<A=Bar>` +#[derive(Clone, PartialEq, RustcDecodable, RustcEncodable, Show)] +pub struct TypeBinding { + pub name: String, + pub ty: Type +} + +impl Clean<TypeBinding> for ast::TypeBinding { + fn clean(&self, cx: &DocContext) -> TypeBinding { + TypeBinding { + name: self.ident.clean(cx), + ty: self.ty.clean(cx) + } + } +} diff --git a/src/librustdoc/core.rs b/src/librustdoc/core.rs index 46c212a9f2d..4885bd373eb 100644 --- a/src/librustdoc/core.rs +++ b/src/librustdoc/core.rs @@ -11,6 +11,7 @@ pub use self::MaybeTyped::*; use rustc_driver::driver; use rustc::session::{self, config}; +use rustc::session::config::UnstableFeatures; use rustc::session::search_paths::SearchPaths; use rustc::middle::{privacy, ty}; use rustc::lint; @@ -95,10 +96,11 @@ pub fn run_core(search_paths: SearchPaths, cfgs: Vec<String>, externs: Externs, externs: externs, target_triple: triple.unwrap_or(config::host_triple().to_string()), cfg: config::parse_cfgspecs(cfgs), + // Ensure that rustdoc works even if rustc is feature-staged + unstable_features: UnstableFeatures::Default, ..config::basic_options().clone() }; - let codemap = codemap::CodeMap::new(); let diagnostic_handler = diagnostic::default_handler(diagnostic::Auto, None); let span_diagnostic_handler = diff --git a/src/librustdoc/html/escape.rs b/src/librustdoc/html/escape.rs index 99cd467cdfc..6fb78d9a833 100644 --- a/src/librustdoc/html/escape.rs +++ b/src/librustdoc/html/escape.rs @@ -19,14 +19,6 @@ use std::fmt; /// string when passed to a format string. pub struct Escape<'a>(pub &'a str); -//NOTE(stage0): remove impl after snapshot -#[cfg(stage0)] -impl<'a> fmt::Show for Escape<'a> { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::String::fmt(self, f) - } -} - impl<'a> fmt::String for Escape<'a> { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { // Because the internet is always right, turns out there's not that many diff --git a/src/librustdoc/html/format.rs b/src/librustdoc/html/format.rs index b24e7a7a4cf..2ae22b8fc0d 100644 --- a/src/librustdoc/html/format.rs +++ b/src/librustdoc/html/format.rs @@ -51,6 +51,8 @@ pub struct ConciseStability<'a>(pub &'a Option<clean::Stability>); pub struct WhereClause<'a>(pub &'a clean::Generics); /// Wrapper struct for emitting type parameter bounds. pub struct TyParamBounds<'a>(pub &'a [clean::TyParamBound]); +/// Wrapper struct for emitting a comma-separated list of items +pub struct CommaSep<'a, T: 'a>(pub &'a [T]); impl VisSpace { pub fn get(&self) -> Option<ast::Visibility> { @@ -64,11 +66,13 @@ impl UnsafetySpace { } } -//NOTE(stage0): remove impl after snapshot -#[cfg(stage0)] -impl<'a> fmt::Show for TyParamBounds<'a> { +impl<'a, T: fmt::String> fmt::String for CommaSep<'a, T> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::String::fmt(self, f) + for (i, item) in self.0.iter().enumerate() { + if i != 0 { try!(write!(f, ", ")); } + try!(write!(f, "{}", item)); + } + Ok(()) } } @@ -85,14 +89,6 @@ impl<'a> fmt::String for TyParamBounds<'a> { } } -//NOTE(stage0): remove impl after snapshot -#[cfg(stage0)] -impl fmt::Show for clean::Generic { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::String::fmt(self, f) - } -} - impl fmt::String for clean::Generics { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { if self.lifetimes.len() == 0 && self.type_params.len() == 0 { return Ok(()) } @@ -130,14 +126,6 @@ impl fmt::String for clean::Generics { } } -//NOTE(stage0): remove impl after snapshot -#[cfg(stage0)] -impl<'a> fmt::Show for WhereClause<'a> { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::String::fmt(self, f) - } -} - impl<'a> fmt::String for WhereClause<'a> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let &WhereClause(gens) = self; @@ -175,14 +163,6 @@ impl<'a> fmt::String for WhereClause<'a> { } } -//NOTE(stage0): remove impl after snapshot -#[cfg(stage0)] -impl fmt::Show for clean::Lifetime { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::String::fmt(self, f) - } -} - impl fmt::String for clean::Lifetime { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { try!(f.write_str(self.get_ref())); @@ -190,14 +170,6 @@ impl fmt::String for clean::Lifetime { } } -//NOTE(stage0): remove impl after snapshot -#[cfg(stage0)] -impl fmt::Show for clean::PolyTrait { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::String::fmt(self, f) - } -} - impl fmt::String for clean::PolyTrait { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { if self.lifetimes.len() > 0 { @@ -214,14 +186,6 @@ impl fmt::String for clean::PolyTrait { } } -//NOTE(stage0): remove impl after snapshot -#[cfg(stage0)] -impl fmt::Show for clean::TyParamBound { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::String::fmt(self, f) - } -} - impl fmt::String for clean::TyParamBound { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match *self { @@ -239,19 +203,13 @@ impl fmt::String for clean::TyParamBound { } } -//NOTE(stage0): remove impl after snapshot -#[cfg(stage0)] -impl fmt::Show for clean::PathParameters { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::String::fmt(self, f) - } -} - impl fmt::String for clean::PathParameters { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match *self { - clean::PathParameters::AngleBracketed { ref lifetimes, ref types } => { - if lifetimes.len() > 0 || types.len() > 0 { + clean::PathParameters::AngleBracketed { + ref lifetimes, ref types, ref bindings + } => { + if lifetimes.len() > 0 || types.len() > 0 || bindings.len() > 0 { try!(f.write_str("<")); let mut comma = false; for lifetime in lifetimes.iter() { @@ -268,6 +226,13 @@ impl fmt::String for clean::PathParameters { comma = true; try!(write!(f, "{}", *ty)); } + for binding in bindings.iter() { + if comma { + try!(f.write_str(", ")); + } + comma = true; + try!(write!(f, "{}", *binding)); + } try!(f.write_str(">")); } } @@ -292,14 +257,6 @@ impl fmt::String for clean::PathParameters { } } -//NOTE(stage0): remove impl after snapshot -#[cfg(stage0)] -impl fmt::Show for clean::PathSegment { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::String::fmt(self, f) - } -} - impl fmt::String for clean::PathSegment { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { try!(f.write_str(self.name.as_slice())); @@ -307,14 +264,6 @@ impl fmt::String for clean::PathSegment { } } -//NOTE(stage0): remove impl after snapshot -#[cfg(stage0)] -impl fmt::Show for clean::Path { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::String::fmt(self, f) - } -} - impl fmt::String for clean::Path { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { if self.global { @@ -383,7 +332,7 @@ fn path<F, G>(w: &mut fmt::Formatter, match rel_root { Some(root) => { let mut root = String::from_str(root.as_slice()); - for seg in path.segments.index(&(0..amt)).iter() { + for seg in path.segments[0..amt].iter() { if "super" == seg.name || "self" == seg.name { try!(write!(w, "{}::", seg.name)); @@ -398,7 +347,7 @@ fn path<F, G>(w: &mut fmt::Formatter, } } None => { - for seg in path.segments.index(&(0..amt)).iter() { + for seg in path.segments[0..amt].iter() { try!(write!(w, "{}::", seg.name)); } } @@ -501,14 +450,6 @@ fn tybounds(w: &mut fmt::Formatter, } } -//NOTE(stage0): remove impl after snapshot -#[cfg(stage0)] -impl fmt::Show for clean::Type { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::String::fmt(self, f) - } -} - impl fmt::String for clean::Type { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match *self { @@ -530,7 +471,8 @@ impl fmt::String for clean::Type { lifetimes = if decl.lifetimes.len() == 0 { "".to_string() } else { - format!("for <{:#}>", decl.lifetimes) + format!("for <{}>", + CommaSep(decl.lifetimes.as_slice())) }, args = decl.decl.inputs, arrow = decl.decl.output, @@ -562,7 +504,8 @@ impl fmt::String for clean::Type { lifetimes = if decl.lifetimes.len() == 0 { "".to_string() } else { - format!("for <{:#}>", decl.lifetimes) + format!("for <{}>", + CommaSep(decl.lifetimes.as_slice())) }, args = decl.decl.inputs, bounds = if decl.bounds.len() == 0 { @@ -592,7 +535,8 @@ impl fmt::String for clean::Type { primitive_link(f, clean::PrimitiveTuple, match typs.as_slice() { [ref one] => format!("({},)", one), - many => format!("({:#})", many) + many => format!("({})", + CommaSep(many.as_slice())) }.as_slice()) } clean::Vector(ref t) => { @@ -650,15 +594,6 @@ impl fmt::String for clean::Type { } } -//NOTE(stage0): remove impl after snapshot -#[cfg(stage0)] -impl fmt::Show for clean::Arguments { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::String::fmt(self, f) - } -} - - impl fmt::String for clean::Arguments { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { for (i, input) in self.values.iter().enumerate() { @@ -672,14 +607,6 @@ impl fmt::String for clean::Arguments { } } -//NOTE(stage0): remove impl after snapshot -#[cfg(stage0)] -impl fmt::Show for clean::FunctionRetTy { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::String::fmt(self, f) - } -} - impl fmt::String for clean::FunctionRetTy { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match *self { @@ -690,28 +617,12 @@ impl fmt::String for clean::FunctionRetTy { } } -//NOTE(stage0): remove impl after snapshot -#[cfg(stage0)] -impl fmt::Show for clean::FnDecl { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::String::fmt(self, f) - } -} - impl fmt::String for clean::FnDecl { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "({args}){arrow}", args = self.inputs, arrow = self.output) } } -//NOTE(stage0): remove impl after snapshot -#[cfg(stage0)] -impl<'a> fmt::Show for Method<'a> { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::String::fmt(self, f) - } -} - impl<'a> fmt::String for Method<'a> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let Method(selfty, d) = *self; @@ -742,14 +653,6 @@ impl<'a> fmt::String for Method<'a> { } } -//NOTE(stage0): remove impl after snapshot -#[cfg(stage0)] -impl fmt::Show for VisSpace { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::String::fmt(self, f) - } -} - impl fmt::String for VisSpace { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self.get() { @@ -759,14 +662,6 @@ impl fmt::String for VisSpace { } } -//NOTE(stage0): remove impl after snapshot -#[cfg(stage0)] -impl fmt::Show for UnsafetySpace { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::String::fmt(self, f) - } -} - impl fmt::String for UnsafetySpace { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self.get() { @@ -776,14 +671,6 @@ impl fmt::String for UnsafetySpace { } } -//NOTE(stage0): remove impl after snapshot -#[cfg(stage0)] -impl fmt::Show for clean::ViewPath { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::String::fmt(self, f) - } -} - impl fmt::String for clean::ViewPath { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match *self { @@ -811,14 +698,6 @@ impl fmt::String for clean::ViewPath { } } -//NOTE(stage0): remove impl after snapshot -#[cfg(stage0)] -impl fmt::Show for clean::ImportSource { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::String::fmt(self, f) - } -} - impl fmt::String for clean::ImportSource { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self.did { @@ -836,14 +715,6 @@ impl fmt::String for clean::ImportSource { } } -//NOTE(stage0): remove impl after snapshot -#[cfg(stage0)] -impl fmt::Show for clean::ViewListIdent { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::String::fmt(self, f) - } -} - impl fmt::String for clean::ViewListIdent { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self.source { @@ -855,6 +726,7 @@ impl fmt::String for clean::ViewListIdent { params: clean::PathParameters::AngleBracketed { lifetimes: Vec::new(), types: Vec::new(), + bindings: Vec::new() } }) }; @@ -865,11 +737,9 @@ impl fmt::String for clean::ViewListIdent { } } -//NOTE(stage0): remove impl after snapshot -#[cfg(stage0)] -impl fmt::Show for MutableSpace { +impl fmt::String for clean::TypeBinding { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::String::fmt(self, f) + write!(f, "{}={}", self.name, self.ty) } } @@ -882,14 +752,6 @@ impl fmt::String for MutableSpace { } } -//NOTE(stage0): remove impl after snapshot -#[cfg(stage0)] -impl fmt::Show for RawMutableSpace { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::String::fmt(self, f) - } -} - impl fmt::String for RawMutableSpace { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match *self { @@ -899,14 +761,6 @@ impl fmt::String for RawMutableSpace { } } -//NOTE(stage0): remove impl after snapshot -#[cfg(stage0)] -impl<'a> fmt::Show for Stability<'a> { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::String::fmt(self, f) - } -} - impl<'a> fmt::String for Stability<'a> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let Stability(stab) = *self; @@ -921,14 +775,6 @@ impl<'a> fmt::String for Stability<'a> { } } -//NOTE(stage0): remove impl after snapshot -#[cfg(stage0)] -impl<'a> fmt::Show for ConciseStability<'a> { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::String::fmt(self, f) - } -} - impl<'a> fmt::String for ConciseStability<'a> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let ConciseStability(stab) = *self; @@ -946,14 +792,6 @@ impl<'a> fmt::String for ConciseStability<'a> { } } -//NOTE(stage0): remove impl after snapshot -#[cfg(stage0)] -impl fmt::Show for ModuleSummary { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::String::fmt(self, f) - } -} - impl fmt::String for ModuleSummary { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt_inner<'a>(f: &mut fmt::Formatter, diff --git a/src/librustdoc/html/highlight.rs b/src/librustdoc/html/highlight.rs index 3d2c5e2cbb5..885017152de 100644 --- a/src/librustdoc/html/highlight.rs +++ b/src/librustdoc/html/highlight.rs @@ -34,7 +34,7 @@ pub fn highlight(src: &str, class: Option<&str>, id: Option<&str>) -> String { class, id, &mut out).unwrap(); - String::from_utf8_lossy(out.index(&FullRange)).into_owned() + String::from_utf8_lossy(&out[]).into_owned() } /// Exhausts the `lexer` writing the output into `out`. diff --git a/src/librustdoc/html/item_type.rs b/src/librustdoc/html/item_type.rs index 13a06f842a2..db3319eb765 100644 --- a/src/librustdoc/html/item_type.rs +++ b/src/librustdoc/html/item_type.rs @@ -103,14 +103,6 @@ impl ItemType { } } -//NOTE(stage0): remove impl after snapshot -#[cfg(stage0)] -impl fmt::Show for ItemType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::String::fmt(self, f) - } -} - impl fmt::String for ItemType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { self.to_static_str().fmt(f) diff --git a/src/librustdoc/html/markdown.rs b/src/librustdoc/html/markdown.rs index f4660a81be4..a063191a12f 100644 --- a/src/librustdoc/html/markdown.rs +++ b/src/librustdoc/html/markdown.rs @@ -435,14 +435,6 @@ pub fn reset_headers() { TEST_IDX.with(|s| s.set(0)); } -//NOTE(stage0): remove impl after snapshot -#[cfg(stage0)] -impl<'a> fmt::Show for Markdown<'a> { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::String::fmt(self, f) - } -} - impl<'a> fmt::String for Markdown<'a> { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { let Markdown(md) = *self; @@ -452,14 +444,6 @@ impl<'a> fmt::String for Markdown<'a> { } } -//NOTE(stage0): remove impl after snapshot -#[cfg(stage0)] -impl<'a> fmt::Show for MarkdownWithToc<'a> { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::String::fmt(self, f) - } -} - impl<'a> fmt::String for MarkdownWithToc<'a> { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { let MarkdownWithToc(md) = *self; diff --git a/src/librustdoc/html/render.rs b/src/librustdoc/html/render.rs index 08abdc2af18..839dfa339b3 100644 --- a/src/librustdoc/html/render.rs +++ b/src/librustdoc/html/render.rs @@ -1351,14 +1351,6 @@ impl<'a> Item<'a> { } -//NOTE(stage0): remove impl after snapshot -#[cfg(stage0)] -impl<'a> fmt::Show for Item<'a> { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::String::fmt(self, f) - } -} - impl<'a> fmt::String for Item<'a> { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { // Write the breadcrumb trail header for the top @@ -1634,14 +1626,6 @@ fn item_module(w: &mut fmt::Formatter, cx: &Context, struct Initializer<'a>(&'a str); -//NOTE(stage0): remove impl after snapshot -#[cfg(stage0)] -impl<'a> fmt::Show for Initializer<'a> { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::String::fmt(self, f) - } -} - impl<'a> fmt::String for Initializer<'a> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let Initializer(s) = *self; @@ -2204,14 +2188,6 @@ fn item_typedef(w: &mut fmt::Formatter, it: &clean::Item, document(w, it) } -//NOTE(stage0): remove impl after snapshot -#[cfg(stage0)] -impl<'a> fmt::Show for Sidebar<'a> { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::String::fmt(self, f) - } -} - impl<'a> fmt::String for Sidebar<'a> { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { let cx = self.cx; @@ -2267,14 +2243,6 @@ impl<'a> fmt::String for Sidebar<'a> { } } -//NOTE(stage0): remove impl after snapshot -#[cfg(stage0)] -impl<'a> fmt::Show for Source<'a> { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::String::fmt(self, f) - } -} - impl<'a> fmt::String for Source<'a> { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { let Source(s) = *self; diff --git a/src/librustdoc/html/static/main.css b/src/librustdoc/html/static/main.css index a5a48254141..5951ac2bae7 100644 --- a/src/librustdoc/html/static/main.css +++ b/src/librustdoc/html/static/main.css @@ -157,7 +157,6 @@ nav.sub { left: 0; top: 0; min-height: 100%; - z-index: -1; } .content, nav { max-width: 960px; } @@ -221,6 +220,7 @@ nav.sub { .content pre.line-numbers { float: left; border: none; + position: relative; -webkit-user-select: none; -moz-user-select: none; diff --git a/src/librustdoc/lib.rs b/src/librustdoc/lib.rs index ee65ef06623..56f5c23f6f1 100644 --- a/src/librustdoc/lib.rs +++ b/src/librustdoc/lib.rs @@ -10,6 +10,7 @@ #![crate_name = "rustdoc"] #![experimental] +#![staged_api] #![crate_type = "dylib"] #![crate_type = "rlib"] #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png", @@ -17,6 +18,7 @@ html_root_url = "http://doc.rust-lang.org/nightly/", html_playground_url = "http://play.rust-lang.org/")] #![feature(slicing_syntax)] +#![feature(box_syntax)] extern crate arena; extern crate getopts; diff --git a/src/librustdoc/test.rs b/src/librustdoc/test.rs index bbe35eb0e9c..8e0f4b2d443 100644 --- a/src/librustdoc/test.rs +++ b/src/librustdoc/test.rs @@ -22,6 +22,7 @@ use std::collections::{HashSet, HashMap}; use testing; use rustc::session::{self, config}; use rustc::session::search_paths::{SearchPaths, PathKind}; +use rustc_driver::get_unstable_features_setting; use rustc_driver::driver; use syntax::ast; use syntax::codemap::{CodeMap, dummy_spanned}; @@ -52,6 +53,7 @@ pub fn run(input: &str, search_paths: libs.clone(), crate_types: vec!(config::CrateTypeDylib), externs: externs.clone(), + unstable_features: get_unstable_features_setting(), ..config::basic_options().clone() }; @@ -128,6 +130,7 @@ fn runtest(test: &str, cratename: &str, libs: SearchPaths, .. config::basic_codegen_options() }, test: as_test_harness, + unstable_features: get_unstable_features_setting(), ..config::basic_options().clone() }; diff --git a/src/libserialize/collection_impls.rs b/src/libserialize/collection_impls.rs index d89a4754d2e..10698259739 100644 --- a/src/libserialize/collection_impls.rs +++ b/src/libserialize/collection_impls.rs @@ -13,6 +13,7 @@ use std::uint; use std::default::Default; use std::hash::{Hash, Hasher}; +use std::collections::hash_state::HashState; use {Decodable, Encodable, Decoder, Encoder}; use std::collections::{DList, RingBuf, BTreeMap, BTreeSet, HashMap, HashSet, VecMap}; @@ -156,14 +157,13 @@ impl< } } -#[old_impl_check] -impl< - K: Encodable + Hash<X> + Eq, - V: Encodable, - X, - H: Hasher<X> -> Encodable for HashMap<K, V, H> { - fn encode<S: Encoder>(&self, e: &mut S) -> Result<(), S::Error> { +impl<K, V, S> Encodable for HashMap<K, V, S> + where K: Encodable + Hash< <S as HashState>::Hasher> + Eq, + V: Encodable, + S: HashState, + <S as HashState>::Hasher: Hasher<Output=u64> +{ + fn encode<E: Encoder>(&self, e: &mut E) -> Result<(), E::Error> { e.emit_map(self.len(), |e| { let mut i = 0; for (key, val) in self.iter() { @@ -176,17 +176,16 @@ impl< } } -#[old_impl_check] -impl< - K: Decodable + Hash<S> + Eq, - V: Decodable, - S, - H: Hasher<S> + Default -> Decodable for HashMap<K, V, H> { - fn decode<D: Decoder>(d: &mut D) -> Result<HashMap<K, V, H>, D::Error> { +impl<K, V, S> Decodable for HashMap<K, V, S> + where K: Decodable + Hash< <S as HashState>::Hasher> + Eq, + V: Decodable, + S: HashState + Default, + <S as HashState>::Hasher: Hasher<Output=u64> +{ + fn decode<D: Decoder>(d: &mut D) -> Result<HashMap<K, V, S>, D::Error> { d.read_map(|d, len| { - let hasher = Default::default(); - let mut map = HashMap::with_capacity_and_hasher(len, hasher); + let state = Default::default(); + let mut map = HashMap::with_capacity_and_hash_state(len, state); for i in range(0u, len) { let key = try!(d.read_map_elt_key(i, |d| Decodable::decode(d))); let val = try!(d.read_map_elt_val(i, |d| Decodable::decode(d))); @@ -197,13 +196,12 @@ impl< } } -#[old_impl_check] -impl< - T: Encodable + Hash<X> + Eq, - X, - H: Hasher<X> -> Encodable for HashSet<T, H> { - fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> { +impl<T, S> Encodable for HashSet<T, S> + where T: Encodable + Hash< <S as HashState>::Hasher> + Eq, + S: HashState, + <S as HashState>::Hasher: Hasher<Output=u64> +{ + fn encode<E: Encoder>(&self, s: &mut E) -> Result<(), E::Error> { s.emit_seq(self.len(), |s| { let mut i = 0; for e in self.iter() { @@ -215,15 +213,15 @@ impl< } } -#[old_impl_check] -impl< - T: Decodable + Hash<S> + Eq, - S, - H: Hasher<S> + Default -> Decodable for HashSet<T, H> { - fn decode<D: Decoder>(d: &mut D) -> Result<HashSet<T, H>, D::Error> { +impl<T, S> Decodable for HashSet<T, S> + where T: Decodable + Hash< <S as HashState>::Hasher> + Eq, + S: HashState + Default, + <S as HashState>::Hasher: Hasher<Output=u64> +{ + fn decode<D: Decoder>(d: &mut D) -> Result<HashSet<T, S>, D::Error> { d.read_seq(|d, len| { - let mut set = HashSet::with_capacity_and_hasher(len, Default::default()); + let state = Default::default(); + let mut set = HashSet::with_capacity_and_hash_state(len, state); for i in range(0u, len) { set.insert(try!(d.read_seq_elt(i, |d| Decodable::decode(d)))); } diff --git a/src/libserialize/json.rs b/src/libserialize/json.rs index b7bf40a6ec5..62acef2ca1c 100644 --- a/src/libserialize/json.rs +++ b/src/libserialize/json.rs @@ -383,7 +383,7 @@ fn escape_str(wr: &mut fmt::Writer, v: &str) -> fmt::Result { }; if start < i { - try!(wr.write_str(v.index(&(start..i)))); + try!(wr.write_str(&v[start..i])); } try!(wr.write_str(escaped)); @@ -392,7 +392,7 @@ fn escape_str(wr: &mut fmt::Writer, v: &str) -> fmt::Result { } if start != v.len() { - try!(wr.write_str(v.index(&(start..)))); + try!(wr.write_str(&v[start..])); } wr.write_str("\"") @@ -401,7 +401,7 @@ fn escape_str(wr: &mut fmt::Writer, v: &str) -> fmt::Result { fn escape_char(writer: &mut fmt::Writer, v: char) -> fmt::Result { let mut buf = [0; 4]; let n = v.encode_utf8(&mut buf).unwrap(); - let buf = unsafe { str::from_utf8_unchecked(buf.index(&(0..n))) }; + let buf = unsafe { str::from_utf8_unchecked(&buf[0..n]) }; escape_str(writer, buf) } @@ -414,7 +414,7 @@ fn spaces(wr: &mut fmt::Writer, mut n: uint) -> fmt::Result { } if n > 0 { - wr.write_str(BUF.index(&(0..n))) + wr.write_str(&BUF[0..n]) } else { Ok(()) } @@ -623,7 +623,7 @@ impl<'a> ::Encoder for Encoder<'a> { let mut check_encoder = Encoder::new(&mut buf); try!(f(transmute(&mut check_encoder))); } - let out = str::from_utf8(buf.index(&FullRange)).unwrap(); + let out = str::from_utf8(&buf[]).unwrap(); let needs_wrapping = out.char_at(0) != '"' && out.char_at_reverse(out.len()) != '"'; if needs_wrapping { try!(write!(self.writer, "\"")); } try!(f(self)); @@ -894,7 +894,7 @@ impl<'a> ::Encoder for PrettyEncoder<'a> { let mut check_encoder = PrettyEncoder::new(&mut buf); try!(f(transmute(&mut check_encoder))); } - let out = str::from_utf8(buf.index(&FullRange)).unwrap(); + let out = str::from_utf8(&buf[]).unwrap(); let needs_wrapping = out.char_at(0) != '"' && out.char_at_reverse(out.len()) != '"'; if needs_wrapping { try!(write!(self.writer, "\"")); } try!(f(self)); @@ -1027,7 +1027,7 @@ impl Json { /// Returns None otherwise. pub fn as_string<'a>(&'a self) -> Option<&'a str> { match *self { - Json::String(ref s) => Some(s.index(&FullRange)), + Json::String(ref s) => Some(&s[]), _ => None } } @@ -1137,7 +1137,7 @@ impl Index<uint> for Json { fn index<'a>(&'a self, idx: &uint) -> &'a Json { match self { - &Json::Array(ref v) => v.index(idx), + &Json::Array(ref v) => &v[*idx], _ => panic!("can only index Json with uint if it is an array") } } @@ -1222,7 +1222,7 @@ impl Stack { InternalIndex(i) => StackElement::Index(i), InternalKey(start, size) => { StackElement::Key(str::from_utf8( - self.str_buffer.index(&((start as uint) .. (start as uint + size as uint)))) + &self.str_buffer[(start as uint) .. (start as uint + size as uint)]) .unwrap()) } } @@ -1265,7 +1265,7 @@ impl Stack { Some(&InternalIndex(i)) => Some(StackElement::Index(i)), Some(&InternalKey(start, size)) => { Some(StackElement::Key(str::from_utf8( - self.str_buffer.index(&((start as uint) .. (start+size) as uint)) + &self.str_buffer[(start as uint) .. (start+size) as uint] ).unwrap())) } } @@ -1396,7 +1396,7 @@ impl<T: Iterator<Item=char>> Parser<T> { self.ch == Some(c) } - fn error<T>(&self, reason: ErrorCode) -> Result<T, ParserError> { + fn error<U>(&self, reason: ErrorCode) -> Result<U, ParserError> { Err(SyntaxError(reason, self.line, self.col)) } @@ -2144,7 +2144,7 @@ impl ::Decoder for Decoder { return Err(ExpectedError("String or Object".to_string(), format!("{}", json))) } }; - let idx = match names.iter().position(|n| *n == name.index(&FullRange)) { + let idx = match names.iter().position(|n| *n == &name[]) { Some(idx) => idx, None => return Err(UnknownVariantError(name)) }; @@ -2458,14 +2458,6 @@ impl<'a> fmt::String for PrettyJson<'a> { } } -#[cfg(stage0)] -//NOTE(stage0): remove impl after snapshot -impl<'a, T: Encodable> fmt::Show for AsJson<'a, T> { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::String::fmt(self, f) - } -} - impl<'a, T: Encodable> fmt::String for AsJson<'a, T> { /// Encodes a json value into a string fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { @@ -2519,7 +2511,6 @@ mod tests { use std::{i64, u64, f32, f64, io}; use std::collections::BTreeMap; use std::num::Float; - use std::ops::Index; use std::string; #[derive(RustcDecodable, Eq, PartialEq, Show)] @@ -3361,7 +3352,7 @@ mod tests { hm.insert(1, true); let mut mem_buf = Vec::new(); write!(&mut mem_buf, "{}", super::as_pretty_json(&hm)).unwrap(); - let json_str = from_utf8(mem_buf.index(&FullRange)).unwrap(); + let json_str = from_utf8(&mem_buf[]).unwrap(); match from_str(json_str) { Err(_) => panic!("Unable to parse json_str: {:?}", json_str), _ => {} // it parsed and we are good to go @@ -3377,7 +3368,7 @@ mod tests { hm.insert(1, true); let mut mem_buf = Vec::new(); write!(&mut mem_buf, "{}", super::as_pretty_json(&hm)).unwrap(); - let json_str = from_utf8(mem_buf.index(&FullRange)).unwrap(); + let json_str = from_utf8(&mem_buf[]).unwrap(); match from_str(json_str) { Err(_) => panic!("Unable to parse json_str: {:?}", json_str), _ => {} // it parsed and we are good to go @@ -3417,7 +3408,7 @@ mod tests { write!(&mut writer, "{}", super::as_pretty_json(&json).indent(i)).unwrap(); - let printed = from_utf8(writer.index(&FullRange)).unwrap(); + let printed = from_utf8(&writer[]).unwrap(); // Check for indents at each line let lines: Vec<&str> = printed.lines().collect(); @@ -3481,7 +3472,7 @@ mod tests { } } #[test] - #[cfg_attr(target_word_size = "32", ignore)] // FIXME(#14064) + #[cfg_attr(target_pointer_width = "32", ignore)] // FIXME(#14064) fn test_streaming_parser() { assert_stream_equal( r#"{ "foo":"bar", "array" : [0, 1, 2, 3, 4, 5], "idents":[null,true,false]}"#, @@ -3520,7 +3511,7 @@ mod tests { } #[test] - #[cfg_attr(target_word_size = "32", ignore)] // FIXME(#14064) + #[cfg_attr(target_pointer_width = "32", ignore)] // FIXME(#14064) fn test_read_object_streaming() { assert_eq!(last_event("{ "), Error(SyntaxError(EOFWhileParsingObject, 1, 3))); assert_eq!(last_event("{1"), Error(SyntaxError(KeyMustBeAString, 1, 2))); @@ -3604,7 +3595,7 @@ mod tests { ); } #[test] - #[cfg_attr(target_word_size = "32", ignore)] // FIXME(#14064) + #[cfg_attr(target_pointer_width = "32", ignore)] // FIXME(#14064) fn test_read_array_streaming() { assert_stream_equal( "[]", diff --git a/src/libserialize/lib.rs b/src/libserialize/lib.rs index 139170fc012..b3c4cec2ef1 100644 --- a/src/libserialize/lib.rs +++ b/src/libserialize/lib.rs @@ -16,6 +16,7 @@ Core encoding and decoding interfaces. #![crate_name = "serialize"] #![unstable = "deprecated in favor of rustc-serialize on crates.io"] +#![staged_api] #![crate_type = "rlib"] #![crate_type = "dylib"] #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png", @@ -23,9 +24,10 @@ Core encoding and decoding interfaces. html_root_url = "http://doc.rust-lang.org/nightly/", html_playground_url = "http://play.rust-lang.org/")] #![allow(unknown_features)] -#![feature(slicing_syntax)] -#![feature(old_impl_check)] #![cfg_attr(stage0, allow(unused_attributes))] +#![feature(box_syntax)] +#![feature(old_impl_check)] +#![feature(slicing_syntax)] // test harness access #[cfg(test)] extern crate test; diff --git a/src/libserialize/serialize.rs b/src/libserialize/serialize.rs index 7b6ca10669d..fe2d57486a8 100644 --- a/src/libserialize/serialize.rs +++ b/src/libserialize/serialize.rs @@ -326,7 +326,7 @@ impl Encodable for str { impl Encodable for String { fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> { - s.emit_str(self.index(&FullRange)) + s.emit_str(&self[]) } } diff --git a/src/libstd/bitflags.rs b/src/libstd/bitflags.rs index 5764962b51b..8dc41368e7f 100644 --- a/src/libstd/bitflags.rs +++ b/src/libstd/bitflags.rs @@ -273,7 +273,7 @@ macro_rules! bitflags { #[cfg(test)] #[allow(non_upper_case_globals)] mod tests { - use hash; + use hash::{self, SipHasher}; use option::Option::{Some, None}; bitflags! { @@ -467,9 +467,9 @@ mod tests { fn test_hash() { let mut x = Flags::empty(); let mut y = Flags::empty(); - assert!(hash::hash(&x) == hash::hash(&y)); + assert!(hash::hash::<Flags, SipHasher>(&x) == hash::hash::<Flags, SipHasher>(&y)); x = Flags::all(); y = FlagABC; - assert!(hash::hash(&x) == hash::hash(&y)); + assert!(hash::hash::<Flags, SipHasher>(&x) == hash::hash::<Flags, SipHasher>(&y)); } } diff --git a/src/libstd/collections/hash/map.rs b/src/libstd/collections/hash/map.rs index c3381d5cd64..c3bdfbb12d8 100644 --- a/src/libstd/collections/hash/map.rs +++ b/src/libstd/collections/hash/map.rs @@ -19,16 +19,15 @@ use clone::Clone; use cmp::{max, Eq, PartialEq}; use default::Default; use fmt::{self, Show}; -use hash::{Hash, Hasher, RandomSipHasher}; +use hash::{self, Hash, SipHasher}; use iter::{self, Iterator, IteratorExt, FromIterator, Extend, Map}; use marker::Sized; use mem::{self, replace}; use num::{Int, UnsignedInt}; use ops::{Deref, FnMut, Index, IndexMut}; -use option::Option; -use option::Option::{Some, None}; -use result::Result; -use result::Result::{Ok, Err}; +use option::Option::{self, Some, None}; +use rand::{self, Rng}; +use result::Result::{self, Ok, Err}; use super::table::{ self, @@ -44,6 +43,7 @@ use super::table::BucketState::{ Empty, Full, }; +use super::state::HashState; const INITIAL_LOG2_CAP: uint = 5; pub const INITIAL_CAPACITY: uint = 1 << INITIAL_LOG2_CAP; // 2^5 @@ -297,9 +297,9 @@ fn test_resize_policy() { /// ``` #[derive(Clone)] #[stable] -pub struct HashMap<K, V, H = RandomSipHasher> { +pub struct HashMap<K, V, S = RandomState> { // All hashes are keyed on these values, to prevent hash collision attacks. - hasher: H, + hash_state: S, table: RawTable<K, V>, @@ -439,17 +439,20 @@ impl<K, V, M> SearchResult<K, V, M> { } } -#[old_impl_check] -impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> HashMap<K, V, H> { - fn make_hash<X: ?Sized + Hash<S>>(&self, x: &X) -> SafeHash { - table::make_hash(&self.hasher, x) +impl<K, V, S, H> HashMap<K, V, S> + where K: Eq + Hash<H>, + S: HashState<Hasher=H>, + H: hash::Hasher<Output=u64> +{ + fn make_hash<X: ?Sized>(&self, x: &X) -> SafeHash where X: Hash<H> { + table::make_hash(&self.hash_state, x) } /// Search for a key, yielding the index if it's found in the hashtable. /// If you already have the hash for the key lying around, use /// search_hashed. fn search<'a, Q: ?Sized>(&'a self, q: &Q) -> Option<FullBucketImm<'a, K, V>> - where Q: BorrowFrom<K> + Eq + Hash<S> + where Q: BorrowFrom<K> + Eq + Hash<H> { let hash = self.make_hash(q); search_hashed(&self.table, hash, |k| q.eq(BorrowFrom::borrow_from(k))) @@ -457,7 +460,7 @@ impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> HashMap<K, V, H> { } fn search_mut<'a, Q: ?Sized>(&'a mut self, q: &Q) -> Option<FullBucketMut<'a, K, V>> - where Q: BorrowFrom<K> + Eq + Hash<S> + where Q: BorrowFrom<K> + Eq + Hash<H> { let hash = self.make_hash(q); search_hashed(&mut self.table, hash, |k| q.eq(BorrowFrom::borrow_from(k))) @@ -486,7 +489,7 @@ impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> HashMap<K, V, H> { } } -impl<K: Hash + Eq, V> HashMap<K, V, RandomSipHasher> { +impl<K: Hash<Hasher> + Eq, V> HashMap<K, V, RandomState> { /// Create an empty HashMap. /// /// # Example @@ -497,9 +500,8 @@ impl<K: Hash + Eq, V> HashMap<K, V, RandomSipHasher> { /// ``` #[inline] #[stable] - pub fn new() -> HashMap<K, V, RandomSipHasher> { - let hasher = RandomSipHasher::new(); - HashMap::with_hasher(hasher) + pub fn new() -> HashMap<K, V, RandomState> { + Default::default() } /// Creates an empty hash map with the given initial capacity. @@ -512,14 +514,16 @@ impl<K: Hash + Eq, V> HashMap<K, V, RandomSipHasher> { /// ``` #[inline] #[stable] - pub fn with_capacity(capacity: uint) -> HashMap<K, V, RandomSipHasher> { - let hasher = RandomSipHasher::new(); - HashMap::with_capacity_and_hasher(capacity, hasher) + pub fn with_capacity(capacity: uint) -> HashMap<K, V, RandomState> { + HashMap::with_capacity_and_hash_state(capacity, Default::default()) } } -#[old_impl_check] -impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> HashMap<K, V, H> { +impl<K, V, S, H> HashMap<K, V, S> + where K: Eq + Hash<H>, + S: HashState<Hasher=H>, + H: hash::Hasher<Output=u64> +{ /// Creates an empty hashmap which will use the given hasher to hash keys. /// /// The creates map has the default initial capacity. @@ -528,17 +532,17 @@ impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> HashMap<K, V, H> { /// /// ``` /// use std::collections::HashMap; - /// use std::hash::sip::SipHasher; + /// use std::collections::hash_map::RandomState; /// - /// let h = SipHasher::new(); - /// let mut map = HashMap::with_hasher(h); + /// let s = RandomState::new(); + /// let mut map = HashMap::with_hash_state(s); /// map.insert(1i, 2u); /// ``` #[inline] #[unstable = "hasher stuff is unclear"] - pub fn with_hasher(hasher: H) -> HashMap<K, V, H> { + pub fn with_hash_state(hash_state: S) -> HashMap<K, V, S> { HashMap { - hasher: hasher, + hash_state: hash_state, resize_policy: DefaultResizePolicy::new(), table: RawTable::new(0), } @@ -556,21 +560,22 @@ impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> HashMap<K, V, H> { /// /// ``` /// use std::collections::HashMap; - /// use std::hash::sip::SipHasher; + /// use std::collections::hash_map::RandomState; /// - /// let h = SipHasher::new(); - /// let mut map = HashMap::with_capacity_and_hasher(10, h); + /// let s = RandomState::new(); + /// let mut map = HashMap::with_capacity_and_hash_state(10, s); /// map.insert(1i, 2u); /// ``` #[inline] #[unstable = "hasher stuff is unclear"] - pub fn with_capacity_and_hasher(capacity: uint, hasher: H) -> HashMap<K, V, H> { + pub fn with_capacity_and_hash_state(capacity: uint, hash_state: S) + -> HashMap<K, V, S> { let resize_policy = DefaultResizePolicy::new(); let min_cap = max(INITIAL_CAPACITY, resize_policy.min_capacity(capacity)); let internal_cap = min_cap.checked_next_power_of_two().expect("capacity overflow"); assert!(internal_cap >= capacity, "capacity overflow"); HashMap { - hasher: hasher, + hash_state: hash_state, resize_policy: resize_policy, table: RawTable::new(internal_cap), } @@ -1031,7 +1036,7 @@ impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> HashMap<K, V, H> { /// ``` #[stable] pub fn get<Q: ?Sized>(&self, k: &Q) -> Option<&V> - where Q: Hash<S> + Eq + BorrowFrom<K> + where Q: Hash<H> + Eq + BorrowFrom<K> { self.search(k).map(|bucket| bucket.into_refs().1) } @@ -1054,7 +1059,7 @@ impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> HashMap<K, V, H> { /// ``` #[stable] pub fn contains_key<Q: ?Sized>(&self, k: &Q) -> bool - where Q: Hash<S> + Eq + BorrowFrom<K> + where Q: Hash<H> + Eq + BorrowFrom<K> { self.search(k).is_some() } @@ -1080,7 +1085,7 @@ impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> HashMap<K, V, H> { /// ``` #[stable] pub fn get_mut<Q: ?Sized>(&mut self, k: &Q) -> Option<&mut V> - where Q: Hash<S> + Eq + BorrowFrom<K> + where Q: Hash<H> + Eq + BorrowFrom<K> { self.search_mut(k).map(|bucket| bucket.into_mut_refs().1) } @@ -1132,7 +1137,7 @@ impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> HashMap<K, V, H> { /// ``` #[stable] pub fn remove<Q: ?Sized>(&mut self, k: &Q) -> Option<V> - where Q: Hash<S> + Eq + BorrowFrom<K> + where Q: Hash<H> + Eq + BorrowFrom<K> { if self.table.size() == 0 { return None @@ -1189,10 +1194,12 @@ fn search_entry_hashed<'a, K: Eq, V>(table: &'a mut RawTable<K,V>, hash: SafeHas } } -#[stable] -#[old_impl_check] -impl<K: Eq + Hash<S>, V: PartialEq, S, H: Hasher<S>> PartialEq for HashMap<K, V, H> { - fn eq(&self, other: &HashMap<K, V, H>) -> bool { +impl<K, V, S, H> PartialEq for HashMap<K, V, S> + where K: Eq + Hash<H>, V: PartialEq, + S: HashState<Hasher=H>, + H: hash::Hasher<Output=u64> +{ + fn eq(&self, other: &HashMap<K, V, S>) -> bool { if self.len() != other.len() { return false; } self.iter().all(|(key, value)| @@ -1202,12 +1209,18 @@ impl<K: Eq + Hash<S>, V: PartialEq, S, H: Hasher<S>> PartialEq for HashMap<K, V, } #[stable] -#[old_impl_check] -impl<K: Eq + Hash<S>, V: Eq, S, H: Hasher<S>> Eq for HashMap<K, V, H> {} +impl<K, V, S, H> Eq for HashMap<K, V, S> + where K: Eq + Hash<H>, V: Eq, + S: HashState<Hasher=H>, + H: hash::Hasher<Output=u64> +{} #[stable] -#[old_impl_check] -impl<K: Eq + Hash<S> + Show, V: Show, S, H: Hasher<S>> Show for HashMap<K, V, H> { +impl<K, V, S, H> Show for HashMap<K, V, S> + where K: Eq + Hash<H> + Show, V: Show, + S: HashState<Hasher=H>, + H: hash::Hasher<Output=u64> +{ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { try!(write!(f, "HashMap {{")); @@ -1221,18 +1234,22 @@ impl<K: Eq + Hash<S> + Show, V: Show, S, H: Hasher<S>> Show for HashMap<K, V, H> } #[stable] -#[old_impl_check] -impl<K: Eq + Hash<S>, V, S, H: Hasher<S> + Default> Default for HashMap<K, V, H> { - #[stable] - fn default() -> HashMap<K, V, H> { - HashMap::with_hasher(Default::default()) +impl<K, V, S, H> Default for HashMap<K, V, S> + where K: Eq + Hash<H>, + S: HashState<Hasher=H> + Default, + H: hash::Hasher<Output=u64> +{ + fn default() -> HashMap<K, V, S> { + HashMap::with_hash_state(Default::default()) } } #[stable] -#[old_impl_check] -impl<K: Hash<S> + Eq, Q: ?Sized, V, S, H: Hasher<S>> Index<Q> for HashMap<K, V, H> - where Q: BorrowFrom<K> + Hash<S> + Eq +impl<K, Q: ?Sized, V, S, H> Index<Q> for HashMap<K, V, S> + where K: Eq + Hash<H>, + Q: Eq + Hash<H> + BorrowFrom<K>, + S: HashState<Hasher=H>, + H: hash::Hasher<Output=u64> { type Output = V; @@ -1243,9 +1260,11 @@ impl<K: Hash<S> + Eq, Q: ?Sized, V, S, H: Hasher<S>> Index<Q> for HashMap<K, V, } #[stable] -#[old_impl_check] -impl<K: Hash<S> + Eq, Q: ?Sized, V, S, H: Hasher<S>> IndexMut<Q> for HashMap<K, V, H> - where Q: BorrowFrom<K> + Hash<S> + Eq +impl<K, V, S, H, Q: ?Sized> IndexMut<Q> for HashMap<K, V, S> + where K: Eq + Hash<H>, + Q: Eq + Hash<H> + BorrowFrom<K>, + S: HashState<Hasher=H>, + H: hash::Hasher<Output=u64> { type Output = V; @@ -1473,19 +1492,26 @@ impl<'a, K: 'a, V: 'a> VacantEntry<'a, K, V> { } #[stable] -#[old_impl_check] -impl<K: Eq + Hash<S>, V, S, H: Hasher<S> + Default> FromIterator<(K, V)> for HashMap<K, V, H> { - fn from_iter<T: Iterator<Item=(K, V)>>(iter: T) -> HashMap<K, V, H> { +impl<K, V, S, H> FromIterator<(K, V)> for HashMap<K, V, S> + where K: Eq + Hash<H>, + S: HashState<Hasher=H> + Default, + H: hash::Hasher<Output=u64> +{ + fn from_iter<T: Iterator<Item=(K, V)>>(iter: T) -> HashMap<K, V, S> { let lower = iter.size_hint().0; - let mut map = HashMap::with_capacity_and_hasher(lower, Default::default()); + let mut map = HashMap::with_capacity_and_hash_state(lower, + Default::default()); map.extend(iter); map } } #[stable] -#[old_impl_check] -impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> Extend<(K, V)> for HashMap<K, V, H> { +impl<K, V, S, H> Extend<(K, V)> for HashMap<K, V, S> + where K: Eq + Hash<H>, + S: HashState<Hasher=H>, + H: hash::Hasher<Output=u64> +{ fn extend<T: Iterator<Item=(K, V)>>(&mut self, mut iter: T) { for (k, v) in iter { self.insert(k, v); @@ -1493,6 +1519,64 @@ impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> Extend<(K, V)> for HashMap<K, V, H> { } } + +/// `RandomState` is the default state for `HashMap` types. +/// +/// A particular instance `RandomState` will create the same instances of +/// `Hasher`, but the hashers created by two different `RandomState` +/// instances are unlikely to produce the same result for the same values. +#[derive(Clone)] +#[allow(missing_copy_implementations)] +#[unstable = "hashing an hash maps may be altered"] +pub struct RandomState { + k0: u64, + k1: u64, +} + +#[unstable = "hashing an hash maps may be altered"] +impl RandomState { + /// Construct a new `RandomState` that is initialized with random keys. + #[inline] + pub fn new() -> RandomState { + let mut r = rand::thread_rng(); + RandomState { k0: r.gen(), k1: r.gen() } + } +} + +#[unstable = "hashing an hash maps may be altered"] +impl HashState for RandomState { + type Hasher = Hasher; + fn hasher(&self) -> Hasher { + Hasher { inner: SipHasher::new_with_keys(self.k0, self.k1) } + } +} + +#[unstable = "hashing an hash maps may be altered"] +impl Default for RandomState { + #[inline] + fn default() -> RandomState { + RandomState::new() + } +} + +/// A hasher implementation which is generated from `RandomState` instances. +/// +/// This is the default hasher used in a `HashMap` to hash keys. Types do not +/// typically declare an ability to explicitly hash into this particular type, +/// but rather in a `H: hash::Writer` type parameter. +#[allow(missing_copy_implementations)] +pub struct Hasher { inner: SipHasher } + +impl hash::Writer for Hasher { + fn write(&mut self, data: &[u8]) { self.inner.write(data) } +} + +impl hash::Hasher for Hasher { + type Output = u64; + fn reset(&mut self) { self.inner.reset() } + fn finish(&self) -> u64 { self.inner.finish() } +} + #[cfg(test)] mod test_map { use prelude::v1::*; diff --git a/src/libstd/collections/hash/mod.rs b/src/libstd/collections/hash/mod.rs index ee3fc1e6ac3..47e300af269 100644 --- a/src/libstd/collections/hash/mod.rs +++ b/src/libstd/collections/hash/mod.rs @@ -11,6 +11,7 @@ //! Unordered containers, implemented as hash-tables mod bench; +mod table; pub mod map; pub mod set; -mod table; +pub mod state; diff --git a/src/libstd/collections/hash/set.rs b/src/libstd/collections/hash/set.rs index f66e5384942..4003d3addf1 100644 --- a/src/libstd/collections/hash/set.rs +++ b/src/libstd/collections/hash/set.rs @@ -17,12 +17,13 @@ use core::marker::Sized; use default::Default; use fmt::Show; use fmt; -use hash::{Hash, Hasher, RandomSipHasher}; +use hash::{self, Hash}; use iter::{Iterator, IteratorExt, FromIterator, Map, Chain, Extend}; use ops::{BitOr, BitAnd, BitXor, Sub}; use option::Option::{Some, None, self}; -use super::map::{self, HashMap, Keys, INITIAL_CAPACITY}; +use super::map::{self, HashMap, Keys, INITIAL_CAPACITY, RandomState, Hasher}; +use super::state::HashState; // Future Optimization (FIXME!) // ============================= @@ -90,11 +91,11 @@ use super::map::{self, HashMap, Keys, INITIAL_CAPACITY}; /// ``` #[derive(Clone)] #[stable] -pub struct HashSet<T, H = RandomSipHasher> { - map: HashMap<T, (), H> +pub struct HashSet<T, S = RandomState> { + map: HashMap<T, (), S> } -impl<T: Hash + Eq> HashSet<T, RandomSipHasher> { +impl<T: Hash<Hasher> + Eq> HashSet<T, RandomState> { /// Create an empty HashSet. /// /// # Example @@ -105,7 +106,7 @@ impl<T: Hash + Eq> HashSet<T, RandomSipHasher> { /// ``` #[inline] #[stable] - pub fn new() -> HashSet<T, RandomSipHasher> { + pub fn new() -> HashSet<T, RandomState> { HashSet::with_capacity(INITIAL_CAPACITY) } @@ -120,13 +121,16 @@ impl<T: Hash + Eq> HashSet<T, RandomSipHasher> { /// ``` #[inline] #[stable] - pub fn with_capacity(capacity: uint) -> HashSet<T, RandomSipHasher> { + pub fn with_capacity(capacity: uint) -> HashSet<T, RandomState> { HashSet { map: HashMap::with_capacity(capacity) } } } -#[old_impl_check] -impl<T: Eq + Hash<S>, S, H: Hasher<S>> HashSet<T, H> { +impl<T, S, H> HashSet<T, S> + where T: Eq + Hash<H>, + S: HashState<Hasher=H>, + H: hash::Hasher<Output=u64> +{ /// Creates a new empty hash set which will use the given hasher to hash /// keys. /// @@ -136,16 +140,16 @@ impl<T: Eq + Hash<S>, S, H: Hasher<S>> HashSet<T, H> { /// /// ``` /// use std::collections::HashSet; - /// use std::hash::sip::SipHasher; + /// use std::collections::hash_map::RandomState; /// - /// let h = SipHasher::new(); - /// let mut set = HashSet::with_hasher(h); + /// let s = RandomState::new(); + /// let mut set = HashSet::with_hash_state(s); /// set.insert(2u); /// ``` #[inline] #[unstable = "hasher stuff is unclear"] - pub fn with_hasher(hasher: H) -> HashSet<T, H> { - HashSet::with_capacity_and_hasher(INITIAL_CAPACITY, hasher) + pub fn with_hash_state(hash_state: S) -> HashSet<T, S> { + HashSet::with_capacity_and_hash_state(INITIAL_CAPACITY, hash_state) } /// Create an empty HashSet with space for at least `capacity` @@ -160,16 +164,19 @@ impl<T: Eq + Hash<S>, S, H: Hasher<S>> HashSet<T, H> { /// /// ``` /// use std::collections::HashSet; - /// use std::hash::sip::SipHasher; + /// use std::collections::hash_map::RandomState; /// - /// let h = SipHasher::new(); - /// let mut set = HashSet::with_capacity_and_hasher(10u, h); + /// let s = RandomState::new(); + /// let mut set = HashSet::with_capacity_and_hash_state(10u, s); /// set.insert(1i); /// ``` #[inline] #[unstable = "hasher stuff is unclear"] - pub fn with_capacity_and_hasher(capacity: uint, hasher: H) -> HashSet<T, H> { - HashSet { map: HashMap::with_capacity_and_hasher(capacity, hasher) } + pub fn with_capacity_and_hash_state(capacity: uint, hash_state: S) + -> HashSet<T, S> { + HashSet { + map: HashMap::with_capacity_and_hash_state(capacity, hash_state), + } } /// Returns the number of elements the set can hold without reallocating. @@ -300,7 +307,7 @@ impl<T: Eq + Hash<S>, S, H: Hasher<S>> HashSet<T, H> { /// assert_eq!(diff, [4i].iter().map(|&x| x).collect()); /// ``` #[stable] - pub fn difference<'a>(&'a self, other: &'a HashSet<T, H>) -> Difference<'a, T, H> { + pub fn difference<'a>(&'a self, other: &'a HashSet<T, S>) -> Difference<'a, T, S> { Difference { iter: self.iter(), other: other, @@ -328,8 +335,8 @@ impl<T: Eq + Hash<S>, S, H: Hasher<S>> HashSet<T, H> { /// assert_eq!(diff1, [1i, 4].iter().map(|&x| x).collect()); /// ``` #[stable] - pub fn symmetric_difference<'a>(&'a self, other: &'a HashSet<T, H>) - -> SymmetricDifference<'a, T, H> { + pub fn symmetric_difference<'a>(&'a self, other: &'a HashSet<T, S>) + -> SymmetricDifference<'a, T, S> { SymmetricDifference { iter: self.difference(other).chain(other.difference(self)) } } @@ -351,7 +358,7 @@ impl<T: Eq + Hash<S>, S, H: Hasher<S>> HashSet<T, H> { /// assert_eq!(diff, [2i, 3].iter().map(|&x| x).collect()); /// ``` #[stable] - pub fn intersection<'a>(&'a self, other: &'a HashSet<T, H>) -> Intersection<'a, T, H> { + pub fn intersection<'a>(&'a self, other: &'a HashSet<T, S>) -> Intersection<'a, T, S> { Intersection { iter: self.iter(), other: other, @@ -376,7 +383,7 @@ impl<T: Eq + Hash<S>, S, H: Hasher<S>> HashSet<T, H> { /// assert_eq!(diff, [1i, 2, 3, 4].iter().map(|&x| x).collect()); /// ``` #[stable] - pub fn union<'a>(&'a self, other: &'a HashSet<T, H>) -> Union<'a, T, H> { + pub fn union<'a>(&'a self, other: &'a HashSet<T, S>) -> Union<'a, T, S> { Union { iter: self.iter().chain(other.difference(self)) } } @@ -452,7 +459,7 @@ impl<T: Eq + Hash<S>, S, H: Hasher<S>> HashSet<T, H> { /// ``` #[stable] pub fn contains<Q: ?Sized>(&self, value: &Q) -> bool - where Q: BorrowFrom<T> + Hash<S> + Eq + where Q: BorrowFrom<T> + Hash<H> + Eq { self.map.contains_key(value) } @@ -475,7 +482,7 @@ impl<T: Eq + Hash<S>, S, H: Hasher<S>> HashSet<T, H> { /// assert_eq!(a.is_disjoint(&b), false); /// ``` #[stable] - pub fn is_disjoint(&self, other: &HashSet<T, H>) -> bool { + pub fn is_disjoint(&self, other: &HashSet<T, S>) -> bool { self.iter().all(|v| !other.contains(v)) } @@ -496,7 +503,7 @@ impl<T: Eq + Hash<S>, S, H: Hasher<S>> HashSet<T, H> { /// assert_eq!(set.is_subset(&sup), false); /// ``` #[stable] - pub fn is_subset(&self, other: &HashSet<T, H>) -> bool { + pub fn is_subset(&self, other: &HashSet<T, S>) -> bool { self.iter().all(|v| other.contains(v)) } @@ -521,7 +528,7 @@ impl<T: Eq + Hash<S>, S, H: Hasher<S>> HashSet<T, H> { /// ``` #[inline] #[stable] - pub fn is_superset(&self, other: &HashSet<T, H>) -> bool { + pub fn is_superset(&self, other: &HashSet<T, S>) -> bool { other.is_subset(self) } @@ -562,16 +569,19 @@ impl<T: Eq + Hash<S>, S, H: Hasher<S>> HashSet<T, H> { /// ``` #[stable] pub fn remove<Q: ?Sized>(&mut self, value: &Q) -> bool - where Q: BorrowFrom<T> + Hash<S> + Eq + where Q: BorrowFrom<T> + Hash<H> + Eq { self.map.remove(value).is_some() } } #[stable] -#[old_impl_check] -impl<T: Eq + Hash<S>, S, H: Hasher<S>> PartialEq for HashSet<T, H> { - fn eq(&self, other: &HashSet<T, H>) -> bool { +impl<T, S, H> PartialEq for HashSet<T, S> + where T: Eq + Hash<H>, + S: HashState<Hasher=H>, + H: hash::Hasher<Output=u64> +{ + fn eq(&self, other: &HashSet<T, S>) -> bool { if self.len() != other.len() { return false; } self.iter().all(|key| other.contains(key)) @@ -579,12 +589,18 @@ impl<T: Eq + Hash<S>, S, H: Hasher<S>> PartialEq for HashSet<T, H> { } #[stable] -#[old_impl_check] -impl<T: Eq + Hash<S>, S, H: Hasher<S>> Eq for HashSet<T, H> {} +impl<T, S, H> Eq for HashSet<T, S> + where T: Eq + Hash<H>, + S: HashState<Hasher=H>, + H: hash::Hasher<Output=u64> +{} #[stable] -#[old_impl_check] -impl<T: Eq + Hash<S> + fmt::Show, S, H: Hasher<S>> fmt::Show for HashSet<T, H> { +impl<T, S, H> fmt::Show for HashSet<T, S> + where T: Eq + Hash<H> + fmt::Show, + S: HashState<Hasher=H>, + H: hash::Hasher<Output=u64> +{ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { try!(write!(f, "HashSet {{")); @@ -598,19 +614,25 @@ impl<T: Eq + Hash<S> + fmt::Show, S, H: Hasher<S>> fmt::Show for HashSet<T, H> { } #[stable] -#[old_impl_check] -impl<T: Eq + Hash<S>, S, H: Hasher<S> + Default> FromIterator<T> for HashSet<T, H> { - fn from_iter<I: Iterator<Item=T>>(iter: I) -> HashSet<T, H> { +impl<T, S, H> FromIterator<T> for HashSet<T, S> + where T: Eq + Hash<H>, + S: HashState<Hasher=H> + Default, + H: hash::Hasher<Output=u64> +{ + fn from_iter<I: Iterator<Item=T>>(iter: I) -> HashSet<T, S> { let lower = iter.size_hint().0; - let mut set = HashSet::with_capacity_and_hasher(lower, Default::default()); + let mut set = HashSet::with_capacity_and_hash_state(lower, Default::default()); set.extend(iter); set } } #[stable] -#[old_impl_check] -impl<T: Eq + Hash<S>, S, H: Hasher<S>> Extend<T> for HashSet<T, H> { +impl<T, S, H> Extend<T> for HashSet<T, S> + where T: Eq + Hash<H>, + S: HashState<Hasher=H>, + H: hash::Hasher<Output=u64> +{ fn extend<I: Iterator<Item=T>>(&mut self, mut iter: I) { for k in iter { self.insert(k); @@ -619,21 +641,26 @@ impl<T: Eq + Hash<S>, S, H: Hasher<S>> Extend<T> for HashSet<T, H> { } #[stable] -#[old_impl_check] -impl<T: Eq + Hash<S>, S, H: Hasher<S> + Default> Default for HashSet<T, H> { +impl<T, S, H> Default for HashSet<T, S> + where T: Eq + Hash<H>, + S: HashState<Hasher=H> + Default, + H: hash::Hasher<Output=u64> +{ #[stable] - fn default() -> HashSet<T, H> { - HashSet::with_hasher(Default::default()) + fn default() -> HashSet<T, S> { + HashSet::with_hash_state(Default::default()) } } #[stable] -#[old_impl_check] -impl<'a, 'b, T: Eq + Hash<S> + Clone, S, H: Hasher<S> + Default> -BitOr<&'b HashSet<T, H>> for &'a HashSet<T, H> { - type Output = HashSet<T, H>; +impl<'a, 'b, T, S, H> BitOr<&'b HashSet<T, S>> for &'a HashSet<T, S> + where T: Eq + Hash<H> + Clone, + S: HashState<Hasher=H> + Default, + H: hash::Hasher<Output=u64> +{ + type Output = HashSet<T, S>; - /// Returns the union of `self` and `rhs` as a new `HashSet<T, H>`. + /// Returns the union of `self` and `rhs` as a new `HashSet<T, S>`. /// /// # Examples /// @@ -653,18 +680,20 @@ BitOr<&'b HashSet<T, H>> for &'a HashSet<T, H> { /// } /// assert_eq!(i, expected.len()); /// ``` - fn bitor(self, rhs: &HashSet<T, H>) -> HashSet<T, H> { + fn bitor(self, rhs: &HashSet<T, S>) -> HashSet<T, S> { self.union(rhs).cloned().collect() } } #[stable] -#[old_impl_check] -impl<'a, 'b, T: Eq + Hash<S> + Clone, S, H: Hasher<S> + Default> -BitAnd<&'b HashSet<T, H>> for &'a HashSet<T, H> { - type Output = HashSet<T, H>; +impl<'a, 'b, T, S, H> BitAnd<&'b HashSet<T, S>> for &'a HashSet<T, S> + where T: Eq + Hash<H> + Clone, + S: HashState<Hasher=H> + Default, + H: hash::Hasher<Output=u64> +{ + type Output = HashSet<T, S>; - /// Returns the intersection of `self` and `rhs` as a new `HashSet<T, H>`. + /// Returns the intersection of `self` and `rhs` as a new `HashSet<T, S>`. /// /// # Examples /// @@ -684,18 +713,20 @@ BitAnd<&'b HashSet<T, H>> for &'a HashSet<T, H> { /// } /// assert_eq!(i, expected.len()); /// ``` - fn bitand(self, rhs: &HashSet<T, H>) -> HashSet<T, H> { + fn bitand(self, rhs: &HashSet<T, S>) -> HashSet<T, S> { self.intersection(rhs).cloned().collect() } } #[stable] -#[old_impl_check] -impl<'a, 'b, T: Eq + Hash<S> + Clone, S, H: Hasher<S> + Default> -BitXor<&'b HashSet<T, H>> for &'a HashSet<T, H> { - type Output = HashSet<T, H>; +impl<'a, 'b, T, S, H> BitXor<&'b HashSet<T, S>> for &'a HashSet<T, S> + where T: Eq + Hash<H> + Clone, + S: HashState<Hasher=H> + Default, + H: hash::Hasher<Output=u64> +{ + type Output = HashSet<T, S>; - /// Returns the symmetric difference of `self` and `rhs` as a new `HashSet<T, H>`. + /// Returns the symmetric difference of `self` and `rhs` as a new `HashSet<T, S>`. /// /// # Examples /// @@ -715,18 +746,20 @@ BitXor<&'b HashSet<T, H>> for &'a HashSet<T, H> { /// } /// assert_eq!(i, expected.len()); /// ``` - fn bitxor(self, rhs: &HashSet<T, H>) -> HashSet<T, H> { + fn bitxor(self, rhs: &HashSet<T, S>) -> HashSet<T, S> { self.symmetric_difference(rhs).cloned().collect() } } #[stable] -#[old_impl_check] -impl<'a, 'b, T: Eq + Hash<S> + Clone, S, H: Hasher<S> + Default> -Sub<&'b HashSet<T, H>> for &'a HashSet<T, H> { - type Output = HashSet<T, H>; +impl<'a, 'b, T, S, H> Sub<&'b HashSet<T, S>> for &'a HashSet<T, S> + where T: Eq + Hash<H> + Clone, + S: HashState<Hasher=H> + Default, + H: hash::Hasher<Output=u64> +{ + type Output = HashSet<T, S>; - /// Returns the difference of `self` and `rhs` as a new `HashSet<T, H>`. + /// Returns the difference of `self` and `rhs` as a new `HashSet<T, S>`. /// /// # Examples /// @@ -746,7 +779,7 @@ Sub<&'b HashSet<T, H>> for &'a HashSet<T, H> { /// } /// assert_eq!(i, expected.len()); /// ``` - fn sub(self, rhs: &HashSet<T, H>) -> HashSet<T, H> { + fn sub(self, rhs: &HashSet<T, S>) -> HashSet<T, S> { self.difference(rhs).cloned().collect() } } @@ -771,32 +804,32 @@ pub struct Drain<'a, K: 'a> { /// Intersection iterator #[stable] -pub struct Intersection<'a, T: 'a, H: 'a> { +pub struct Intersection<'a, T: 'a, S: 'a> { // iterator of the first set iter: Iter<'a, T>, // the second set - other: &'a HashSet<T, H>, + other: &'a HashSet<T, S>, } /// Difference iterator #[stable] -pub struct Difference<'a, T: 'a, H: 'a> { +pub struct Difference<'a, T: 'a, S: 'a> { // iterator of the first set iter: Iter<'a, T>, // the second set - other: &'a HashSet<T, H>, + other: &'a HashSet<T, S>, } /// Symmetric difference iterator. #[stable] -pub struct SymmetricDifference<'a, T: 'a, H: 'a> { - iter: Chain<Difference<'a, T, H>, Difference<'a, T, H>> +pub struct SymmetricDifference<'a, T: 'a, S: 'a> { + iter: Chain<Difference<'a, T, S>, Difference<'a, T, S>> } /// Set union iterator. #[stable] -pub struct Union<'a, T: 'a, H: 'a> { - iter: Chain<Iter<'a, T>, Difference<'a, T, H>> +pub struct Union<'a, T: 'a, S: 'a> { + iter: Chain<Iter<'a, T>, Difference<'a, T, S>> } #[stable] @@ -824,9 +857,10 @@ impl<'a, K: 'a> Iterator for Drain<'a, K> { } #[stable] -#[old_impl_check] -impl<'a, T, S, H> Iterator for Intersection<'a, T, H> - where T: Eq + Hash<S>, H: Hasher<S> +impl<'a, T, S, H> Iterator for Intersection<'a, T, S> + where T: Eq + Hash<H>, + S: HashState<Hasher=H>, + H: hash::Hasher<Output=u64> { type Item = &'a T; @@ -848,9 +882,10 @@ impl<'a, T, S, H> Iterator for Intersection<'a, T, H> } #[stable] -#[old_impl_check] -impl<'a, T, S, H> Iterator for Difference<'a, T, H> - where T: Eq + Hash<S>, H: Hasher<S> +impl<'a, T, S, H> Iterator for Difference<'a, T, S> + where T: Eq + Hash<H>, + S: HashState<Hasher=H>, + H: hash::Hasher<Output=u64> { type Item = &'a T; @@ -872,9 +907,10 @@ impl<'a, T, S, H> Iterator for Difference<'a, T, H> } #[stable] -#[old_impl_check] -impl<'a, T, S, H> Iterator for SymmetricDifference<'a, T, H> - where T: Eq + Hash<S>, H: Hasher<S> +impl<'a, T, S, H> Iterator for SymmetricDifference<'a, T, S> + where T: Eq + Hash<H>, + S: HashState<Hasher=H>, + H: hash::Hasher<Output=u64> { type Item = &'a T; @@ -883,9 +919,10 @@ impl<'a, T, S, H> Iterator for SymmetricDifference<'a, T, H> } #[stable] -#[old_impl_check] -impl<'a, T, S, H> Iterator for Union<'a, T, H> - where T: Eq + Hash<S>, H: Hasher<S> +impl<'a, T, S, H> Iterator for Union<'a, T, S> + where T: Eq + Hash<H>, + S: HashState<Hasher=H>, + H: hash::Hasher<Output=u64> { type Item = &'a T; diff --git a/src/libstd/collections/hash/state.rs b/src/libstd/collections/hash/state.rs new file mode 100644 index 00000000000..ffbc958f179 --- /dev/null +++ b/src/libstd/collections/hash/state.rs @@ -0,0 +1,51 @@ +// 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. + +use clone::Clone; +use default::Default; +use hash; + +/// A trait representing stateful hashes which can be used to hash keys in a +/// `HashMap`. +/// +/// A HashState is used as a factory for instances of `Hasher` which a `HashMap` +/// can then use to hash keys independently. A `HashMap` by default uses a state +/// which will create instances of a `SipHasher`, but a custom state factory can +/// be provided to the `with_hash_state` function. +/// +/// If a hashing algorithm has no initial state, then the `Hasher` type for that +/// algorithm can implement the `Default` trait and create hash maps with the +/// `DefaultState` structure. This state is 0-sized and will simply delegate +/// to `Default` when asked to create a hasher. +pub trait HashState { + type Hasher: hash::Hasher; + + /// Creates a new hasher based on the given state of this object. + fn hasher(&self) -> Self::Hasher; +} + +/// A structure which is a factory for instances of `Hasher` which implement the +/// default trait. +/// +/// This struct has is 0-sized and does not need construction. +pub struct DefaultState<H>; + +impl<H: Default + hash::Hasher> HashState for DefaultState<H> { + type Hasher = H; + fn hasher(&self) -> H { Default::default() } +} + +impl<H> Clone for DefaultState<H> { + fn clone(&self) -> DefaultState<H> { DefaultState } +} + +impl<H> Default for DefaultState<H> { + fn default() -> DefaultState<H> { DefaultState } +} diff --git a/src/libstd/collections/hash/table.rs b/src/libstd/collections/hash/table.rs index 6eb98da4da4..e43cc053ba0 100644 --- a/src/libstd/collections/hash/table.rs +++ b/src/libstd/collections/hash/table.rs @@ -26,6 +26,7 @@ use option::Option::{Some, None}; use ptr::{Unique, PtrExt, copy_nonoverlapping_memory, zero_memory}; use ptr; use rt::heap::{allocate, deallocate}; +use collections::hash_state::HashState; const EMPTY_BUCKET: u64 = 0u64; @@ -138,12 +139,18 @@ impl SafeHash { /// We need to remove hashes of 0. That's reserved for empty buckets. /// This function wraps up `hash_keyed` to be the only way outside this /// module to generate a SafeHash. -pub fn make_hash<T: ?Sized + Hash<S>, S, H: Hasher<S>>(hasher: &H, t: &T) -> SafeHash { +pub fn make_hash<T: ?Sized, S, H>(hash_state: &S, t: &T) -> SafeHash + where T: Hash<H>, + S: HashState<Hasher=H>, + H: Hasher<Output=u64> +{ + let mut state = hash_state.hasher(); + t.hash(&mut state); // We need to avoid 0u64 in order to prevent collisions with // EMPTY_HASH. We can maintain our precious uniform distribution // of initial indexes by unconditionally setting the MSB, // effectively reducing 64-bits hashes to 63 bits. - SafeHash { hash: 0x8000_0000_0000_0000 | hasher.hash(t) } + SafeHash { hash: 0x8000_0000_0000_0000 | state.finish() } } // `replace` casts a `*u64` to a `*SafeHash`. Since we statically diff --git a/src/libstd/collections/mod.rs b/src/libstd/collections/mod.rs index 9b2a4926bcb..71ab89027ff 100644 --- a/src/libstd/collections/mod.rs +++ b/src/libstd/collections/mod.rs @@ -333,3 +333,10 @@ pub mod hash_set { //! A hashset pub use super::hash::set::*; } + +/// Experimental support for providing custom hash algorithms to a HashMap and +/// HashSet. +#[unstable = "module was recently added"] +pub mod hash_state { + pub use super::hash::state::*; +} diff --git a/src/libstd/failure.rs b/src/libstd/failure.rs index 50538d3e43d..dbc88ddf0a0 100644 --- a/src/libstd/failure.rs +++ b/src/libstd/failure.rs @@ -37,7 +37,7 @@ pub fn on_fail(obj: &(Any+Send), file: &'static str, line: uint) { let msg = match obj.downcast_ref::<&'static str>() { Some(s) => *s, None => match obj.downcast_ref::<String>() { - Some(s) => s.index(&FullRange), + Some(s) => &s[], None => "Box<Any>", } }; diff --git a/src/libstd/fmt.rs b/src/libstd/fmt.rs index 1623b6452b7..96fff64d221 100644 --- a/src/libstd/fmt.rs +++ b/src/libstd/fmt.rs @@ -175,7 +175,7 @@ //! use std::f64; //! use std::num::Float; //! -//! #[deriving(Show)] +//! #[derive(Show)] //! struct Vector2D { //! x: int, //! y: int, diff --git a/src/libstd/hash.rs b/src/libstd/hash.rs deleted file mode 100644 index 69e7e429d07..00000000000 --- a/src/libstd/hash.rs +++ /dev/null @@ -1,105 +0,0 @@ -// 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. - -//! Generic hashing support. -//! -//! This module provides a generic way to compute the hash of a value. The -//! simplest way to make a type hashable is to use `#[derive(Hash)]`: -//! -//! # Example -//! -//! ```rust -//! use std::hash; -//! use std::hash::Hash; -//! -//! #[derive(Hash)] -//! struct Person { -//! id: uint, -//! name: String, -//! phone: u64, -//! } -//! -//! let person1 = Person { id: 5, name: "Janet".to_string(), phone: 555_666_7777 }; -//! let person2 = Person { id: 5, name: "Bob".to_string(), phone: 555_666_7777 }; -//! -//! assert!(hash::hash(&person1) != hash::hash(&person2)); -//! ``` -//! -//! If you need more control over how a value is hashed, you need to implement -//! the trait `Hash`: -//! -//! ```rust -//! use std::hash; -//! use std::hash::Hash; -//! use std::hash::sip::SipState; -//! -//! struct Person { -//! id: uint, -//! name: String, -//! phone: u64, -//! } -//! -//! impl Hash for Person { -//! fn hash(&self, state: &mut SipState) { -//! self.id.hash(state); -//! self.phone.hash(state); -//! } -//! } -//! -//! let person1 = Person { id: 5, name: "Janet".to_string(), phone: 555_666_7777 }; -//! let person2 = Person { id: 5, name: "Bob".to_string(), phone: 555_666_7777 }; -//! -//! assert!(hash::hash(&person1) == hash::hash(&person2)); -//! ``` - -#![experimental] - -pub use core::hash::{Hash, Hasher, Writer, hash, sip}; - -use core::marker::Sized; -use default::Default; -use rand::Rng; -use rand; - -/// `RandomSipHasher` computes the SipHash algorithm from a stream of bytes -/// initialized with random keys. -#[derive(Clone)] -pub struct RandomSipHasher { - hasher: sip::SipHasher, -} - -impl RandomSipHasher { - /// Construct a new `RandomSipHasher` that is initialized with random keys. - #[inline] - pub fn new() -> RandomSipHasher { - let mut r = rand::thread_rng(); - let r0 = r.gen(); - let r1 = r.gen(); - RandomSipHasher { - hasher: sip::SipHasher::new_with_keys(r0, r1), - } - } -} - -impl Hasher<sip::SipState> for RandomSipHasher { - #[inline] - fn hash<T: ?Sized + Hash<sip::SipState>>(&self, value: &T) -> u64 { - self.hasher.hash(value) - } -} - -#[stable] -impl Default for RandomSipHasher { - #[stable] - #[inline] - fn default() -> RandomSipHasher { - RandomSipHasher::new() - } -} diff --git a/src/libstd/io/buffered.rs b/src/libstd/io/buffered.rs index 74c503e6f2b..ba13bd05dc5 100644 --- a/src/libstd/io/buffered.rs +++ b/src/libstd/io/buffered.rs @@ -15,7 +15,7 @@ use cmp; use io::{Reader, Writer, Stream, Buffer, DEFAULT_BUF_SIZE, IoResult}; use iter::{IteratorExt, ExactSizeIterator}; -use ops::{Drop, Index}; +use ops::Drop; use option::Option; use option::Option::{Some, None}; use result::Result::Ok; @@ -97,7 +97,7 @@ impl<R: Reader> Buffer for BufferedReader<R> { self.cap = try!(self.inner.read(self.buf.as_mut_slice())); self.pos = 0; } - Ok(self.buf.index(&(self.pos..self.cap))) + Ok(&self.buf[self.pos..self.cap]) } fn consume(&mut self, amt: uint) { @@ -114,7 +114,7 @@ impl<R: Reader> Reader for BufferedReader<R> { let nread = { let available = try!(self.fill_buf()); let nread = cmp::min(available.len(), buf.len()); - slice::bytes::copy_memory(buf, available.index(&(0..nread))); + slice::bytes::copy_memory(buf, &available[0..nread]); nread }; self.pos += nread; @@ -168,7 +168,7 @@ impl<W: Writer> BufferedWriter<W> { fn flush_buf(&mut self) -> IoResult<()> { if self.pos != 0 { - let ret = self.inner.as_mut().unwrap().write(self.buf.index(&(0..self.pos))); + let ret = self.inner.as_mut().unwrap().write(&self.buf[0..self.pos]); self.pos = 0; ret } else { @@ -260,9 +260,9 @@ impl<W: Writer> Writer for LineBufferedWriter<W> { fn write(&mut self, buf: &[u8]) -> IoResult<()> { match buf.iter().rposition(|&b| b == b'\n') { Some(i) => { - try!(self.inner.write(buf.index(&(0..(i + 1))))); + try!(self.inner.write(&buf[0..(i + 1)])); try!(self.inner.flush()); - try!(self.inner.write(buf.index(&((i + 1)..)))); + try!(self.inner.write(&buf[(i + 1)..])); Ok(()) } None => self.inner.write(buf), @@ -510,7 +510,7 @@ mod test { assert_eq!(a, &w.get_ref()[]); let w = w.into_inner(); let a: &[_] = &[0, 1]; - assert_eq!(a, w.index(&FullRange)); + assert_eq!(a, &w[]); } // This is just here to make sure that we don't infinite loop in the @@ -607,14 +607,14 @@ mod test { #[test] fn read_char_buffered() { let buf = [195u8, 159u8]; - let mut reader = BufferedReader::with_capacity(1, buf.index(&FullRange)); + let mut reader = BufferedReader::with_capacity(1, &buf[]); assert_eq!(reader.read_char(), Ok('ß')); } #[test] fn test_chars() { let buf = [195u8, 159u8, b'a']; - let mut reader = BufferedReader::with_capacity(1, buf.index(&FullRange)); + let mut reader = BufferedReader::with_capacity(1, &buf[]); let mut it = reader.chars(); assert_eq!(it.next(), Some(Ok('ß'))); assert_eq!(it.next(), Some(Ok('a'))); diff --git a/src/libstd/io/comm_adapters.rs b/src/libstd/io/comm_adapters.rs index bce097e17ef..b578f4d5adc 100644 --- a/src/libstd/io/comm_adapters.rs +++ b/src/libstd/io/comm_adapters.rs @@ -13,7 +13,6 @@ use cmp; use sync::mpsc::{Sender, Receiver}; use io; use option::Option::{None, Some}; -use ops::Index; use result::Result::{Ok, Err}; use slice::{bytes, SliceExt}; use super::{Buffer, Reader, Writer, IoResult}; @@ -91,7 +90,7 @@ impl Reader for ChanReader { Some(src) => { let dst = buf.slice_from_mut(num_read); let count = cmp::min(src.len(), dst.len()); - bytes::copy_memory(dst, src.index(&(0..count))); + bytes::copy_memory(dst, &src[0..count]); count }, None => 0, diff --git a/src/libstd/io/fs.rs b/src/libstd/io/fs.rs index eadca8e42e5..dbccc81c4cc 100644 --- a/src/libstd/io/fs.rs +++ b/src/libstd/io/fs.rs @@ -889,7 +889,7 @@ mod test { let mut read_buf = [0; 1028]; let read_str = match check!(read_stream.read(&mut read_buf)) { -1|0 => panic!("shouldn't happen"), - n => str::from_utf8(read_buf.index(&(0..n))).unwrap().to_string() + n => str::from_utf8(&read_buf[0..n]).unwrap().to_string() }; assert_eq!(read_str.as_slice(), message); } diff --git a/src/libstd/io/mem.rs b/src/libstd/io/mem.rs index 9a6ad04fdbc..c5e289398e0 100644 --- a/src/libstd/io/mem.rs +++ b/src/libstd/io/mem.rs @@ -13,7 +13,6 @@ //! Readers and Writers for in-memory buffers use cmp::min; -use ops::Index; use option::Option::None; use result::Result::{Err, Ok}; use io; @@ -160,7 +159,7 @@ impl Reader for MemReader { let write_len = min(buf.len(), self.buf.len() - self.pos); { - let input = self.buf.index(&(self.pos.. (self.pos + write_len))); + let input = &self.buf[self.pos.. (self.pos + write_len)]; let output = buf.slice_to_mut(write_len); assert_eq!(input.len(), output.len()); slice::bytes::copy_memory(output, input); @@ -188,7 +187,7 @@ impl Buffer for MemReader { #[inline] fn fill_buf<'a>(&'a mut self) -> IoResult<&'a [u8]> { if self.pos < self.buf.len() { - Ok(self.buf.index(&(self.pos..))) + Ok(&self.buf[self.pos..]) } else { Err(io::standard_error(io::EndOfFile)) } @@ -205,7 +204,7 @@ impl<'a> Reader for &'a [u8] { let write_len = min(buf.len(), self.len()); { - let input = self.index(&(0..write_len)); + let input = &self[0..write_len]; let output = buf.slice_to_mut(write_len); slice::bytes::copy_memory(output, input); } @@ -228,7 +227,7 @@ impl<'a> Buffer for &'a [u8] { #[inline] fn consume(&mut self, amt: uint) { - *self = self.index(&(amt..)); + *self = &self[amt..]; } } @@ -287,7 +286,7 @@ impl<'a> Writer for BufWriter<'a> { Ok(()) } else { - slice::bytes::copy_memory(dst, src.index(&(0..dst_len))); + slice::bytes::copy_memory(dst, &src[0..dst_len]); self.pos += dst_len; @@ -350,7 +349,7 @@ impl<'a> Reader for BufReader<'a> { let write_len = min(buf.len(), self.buf.len() - self.pos); { - let input = self.buf.index(&(self.pos.. (self.pos + write_len))); + let input = &self.buf[self.pos.. (self.pos + write_len)]; let output = buf.slice_to_mut(write_len); assert_eq!(input.len(), output.len()); slice::bytes::copy_memory(output, input); @@ -378,7 +377,7 @@ impl<'a> Buffer for BufReader<'a> { #[inline] fn fill_buf(&mut self) -> IoResult<&[u8]> { if self.pos < self.buf.len() { - Ok(self.buf.index(&(self.pos..))) + Ok(&self.buf[self.pos..]) } else { Err(io::standard_error(io::EndOfFile)) } @@ -393,7 +392,7 @@ mod test { extern crate "test" as test_crate; use io::{SeekSet, SeekCur, SeekEnd, Reader, Writer, Seek}; use prelude::v1::{Ok, Err, range, Vec, Buffer, AsSlice, SliceExt}; - use prelude::v1::{IteratorExt, Index}; + use prelude::v1::IteratorExt; use io; use iter::repeat; use self::test_crate::Bencher; @@ -499,7 +498,7 @@ mod test { assert_eq!(buf, b); assert_eq!(reader.read(&mut buf), Ok(3)); let b: &[_] = &[5, 6, 7]; - assert_eq!(buf.index(&(0..3)), b); + assert_eq!(&buf[0..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)); @@ -525,7 +524,7 @@ mod test { assert_eq!(buf.as_slice(), b); assert_eq!(reader.read(&mut buf), Ok(3)); let b: &[_] = &[5, 6, 7]; - assert_eq!(buf.index(&(0..3)), b); + assert_eq!(&buf[0..3], b); assert!(reader.read(&mut buf).is_err()); let mut reader = &mut in_buf.as_slice(); assert_eq!(reader.read_until(3).unwrap(), vec!(0, 1, 2, 3)); @@ -552,7 +551,7 @@ mod test { assert_eq!(buf, b); assert_eq!(reader.read(&mut buf), Ok(3)); let b: &[_] = &[5, 6, 7]; - assert_eq!(buf.index(&(0..3)), b); + assert_eq!(&buf[0..3], b); assert!(reader.read(&mut buf).is_err()); let mut reader = BufReader::new(in_buf.as_slice()); assert_eq!(reader.read_until(3).unwrap(), vec!(0, 1, 2, 3)); diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs index 9ef9081bc3c..1c48b20c444 100644 --- a/src/libstd/io/mod.rs +++ b/src/libstd/io/mod.rs @@ -236,7 +236,7 @@ use int; use iter::{Iterator, IteratorExt}; use marker::Sized; use mem::transmute; -use ops::{FnOnce, Index}; +use ops::FnOnce; use option::Option; use option::Option::{Some, None}; use os; @@ -1069,7 +1069,7 @@ pub trait Writer { fn write_char(&mut self, c: char) -> IoResult<()> { let mut buf = [0u8; 4]; let n = c.encode_utf8(buf.as_mut_slice()).unwrap_or(0); - self.write(buf.index(&(0..n))) + self.write(&buf[0..n]) } /// Write the result of passing n through `int::to_str_bytes`. @@ -1284,7 +1284,7 @@ impl<'a> Writer for &'a mut (Writer+'a) { /// process_input(tee); /// } /// -/// println!("input processed: {}", output); +/// println!("input processed: {:?}", output); /// # } /// ``` pub struct RefWriter<'a, W:'a> { @@ -1454,7 +1454,7 @@ pub trait Buffer: Reader { }; match available.iter().position(|&b| b == byte) { Some(i) => { - res.push_all(available.index(&(0..(i + 1)))); + res.push_all(&available[0..(i + 1)]); used = i + 1; break } @@ -1493,7 +1493,7 @@ pub trait Buffer: Reader { } } } - match str::from_utf8(buf.index(&(0..width))).ok() { + match str::from_utf8(&buf[0..width]).ok() { Some(s) => Ok(s.char_at(0)), None => Err(standard_error(InvalidInput)) } @@ -1783,9 +1783,8 @@ pub struct UnstableFileStat { } -// NOTE(stage0): change this one last #[doc=..] to /// after the next snapshot bitflags! { - #[doc = "A set of permissions for a file or directory is represented by a set of"] + /// A set of permissions for a file or directory is represented by a set of /// flags which are or'd together. flags FilePermission: u32 { const USER_READ = 0o400, diff --git a/src/libstd/io/net/ip.rs b/src/libstd/io/net/ip.rs index b9f653f86c2..d09afea94dc 100644 --- a/src/libstd/io/net/ip.rs +++ b/src/libstd/io/net/ip.rs @@ -22,7 +22,7 @@ use fmt; use io::{self, IoResult, IoError}; use io::net; use iter::{Iterator, IteratorExt}; -use ops::{FnOnce, FnMut, Index}; +use ops::{FnOnce, FnMut}; use option::Option; use option::Option::{None, Some}; use result::Result::{Ok, Err}; @@ -313,7 +313,7 @@ impl<'a> Parser<'a> { let mut tail = [0u16; 8]; let (tail_size, _) = read_groups(self, &mut tail, 8 - head_size); - Some(ipv6_addr_from_head_tail(head.index(&(0..head_size)), tail.index(&(0..tail_size)))) + Some(ipv6_addr_from_head_tail(&head[0..head_size], &tail[0..tail_size])) } fn read_ipv6_addr(&mut self) -> Option<IpAddr> { diff --git a/src/libstd/io/process.rs b/src/libstd/io/process.rs index 55df6330dd3..f824d821601 100644 --- a/src/libstd/io/process.rs +++ b/src/libstd/io/process.rs @@ -34,7 +34,7 @@ use sys::process::Process as ProcessImp; use sys; use thread::Thread; -#[cfg(windows)] use std::hash::sip::SipState; +#[cfg(windows)] use hash; #[cfg(windows)] use str; /// Signal a process to exit, without forcibly killing it. Corresponds to @@ -98,7 +98,7 @@ pub struct Process { /// A representation of environment variable name /// It compares case-insensitive on Windows and case-sensitive everywhere else. #[cfg(not(windows))] -#[derive(PartialEq, Eq, Hash, Clone, Show)] +#[derive(Hash, PartialEq, Eq, Clone, Show)] struct EnvKey(CString); #[doc(hidden)] @@ -107,8 +107,8 @@ struct EnvKey(CString); struct EnvKey(CString); #[cfg(windows)] -impl Hash for EnvKey { - fn hash(&self, state: &mut SipState) { +impl<H: hash::Writer + hash::Hasher> hash::Hash<H> for EnvKey { + fn hash(&self, state: &mut H) { let &EnvKey(ref x) = self; match str::from_utf8(x.as_bytes()) { Ok(s) => for ch in s.chars() { @@ -395,13 +395,6 @@ impl Command { } } -#[cfg(stage0)] -impl fmt::Show for Command { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::String::fmt(self, f) - } -} - impl fmt::String for Command { /// Format the program and arguments of a Command for display. Any /// non-utf8 data is lossily converted using the utf8 replacement diff --git a/src/libstd/io/util.rs b/src/libstd/io/util.rs index c0254a3e7a2..5a7219495f5 100644 --- a/src/libstd/io/util.rs +++ b/src/libstd/io/util.rs @@ -59,7 +59,7 @@ impl<R: Reader> Reader for LimitReader<R> { impl<R: Buffer> Buffer for LimitReader<R> { fn fill_buf<'a>(&'a mut self) -> io::IoResult<&'a [u8]> { let amt = try!(self.inner.fill_buf()); - let buf = amt.index(&(0..cmp::min(amt.len(), self.limit))); + let buf = &amt[0..cmp::min(amt.len(), self.limit)]; if buf.len() == 0 { Err(io::standard_error(io::EndOfFile)) } else { @@ -220,7 +220,7 @@ impl<R: Reader, W: Writer> TeeReader<R, W> { impl<R: Reader, W: Writer> Reader for TeeReader<R, W> { fn read(&mut self, buf: &mut [u8]) -> io::IoResult<uint> { self.reader.read(buf).and_then(|len| { - self.writer.write(buf.index_mut(&(0..len))).map(|()| len) + self.writer.write(&mut buf[0..len]).map(|()| len) }) } } @@ -234,7 +234,7 @@ pub fn copy<R: Reader, W: Writer>(r: &mut R, w: &mut W) -> io::IoResult<()> { Err(ref e) if e.kind == io::EndOfFile => return Ok(()), Err(e) => return Err(e), }; - try!(w.write(buf.index(&(0..len)))); + try!(w.write(&buf[0..len])); } } diff --git a/src/libstd/lib.rs b/src/libstd/lib.rs index eef5bdb60ee..71221a654e8 100644 --- a/src/libstd/lib.rs +++ b/src/libstd/lib.rs @@ -96,6 +96,7 @@ #![crate_name = "std"] #![stable] +#![staged_api] #![crate_type = "rlib"] #![crate_type = "dylib"] #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png", @@ -107,8 +108,8 @@ #![feature(linkage, thread_local, asm)] #![feature(lang_items, unsafe_destructor)] #![feature(slicing_syntax, unboxed_closures)] +#![feature(box_syntax)] #![feature(old_impl_check)] -#![cfg_attr(stage0, allow(unused_attributes))] // Don't link to std. We are std. #![no_std] @@ -120,8 +121,7 @@ extern crate log; #[macro_use] -#[macro_reexport(assert, assert_eq, debug_assert, debug_assert_eq, - unreachable, unimplemented, write, writeln)] +#[macro_reexport(write, writeln)] extern crate core; #[macro_use] @@ -150,9 +150,9 @@ pub use core::clone; #[cfg(not(test))] pub use core::cmp; pub use core::default; pub use core::finally; +pub use core::hash; pub use core::intrinsics; pub use core::iter; -#[cfg(stage0)] #[cfg(not(test))] pub use core::marker as kinds; #[cfg(not(test))] pub use core::marker; pub use core::mem; #[cfg(not(test))] pub use core::ops; @@ -176,7 +176,7 @@ pub use unicode::char; /* Exported macros */ #[macro_use] -pub mod macros; +mod macros; #[macro_use] pub mod bitflags; @@ -203,12 +203,14 @@ mod int_macros; mod uint_macros; #[path = "num/int.rs"] pub mod int; +#[path = "num/isize.rs"] pub mod isize; #[path = "num/i8.rs"] pub mod i8; #[path = "num/i16.rs"] pub mod i16; #[path = "num/i32.rs"] pub mod i32; #[path = "num/i64.rs"] pub mod i64; #[path = "num/uint.rs"] pub mod uint; +#[path = "num/usize.rs"] pub mod usize; #[path = "num/u8.rs"] pub mod u8; #[path = "num/u16.rs"] pub mod u16; #[path = "num/u32.rs"] pub mod u32; @@ -242,7 +244,6 @@ pub mod time; /* Common data structures */ pub mod collections; -pub mod hash; /* Threads and communication */ @@ -274,6 +275,7 @@ mod std { pub use clone; pub use cmp; pub use hash; + pub use default; pub use sync; // used for select!() pub use error; // used for try!() @@ -284,8 +286,6 @@ mod std { pub use vec; // used for vec![] pub use cell; // used for tls! pub use thread_local; // used for thread_local! - #[cfg(stage0)] - pub use marker as kinds; pub use marker; // used for tls! pub use ops; // used for bitflags! diff --git a/src/libstd/macros.rs b/src/libstd/macros.rs index befdc156094..0594b711ad6 100644 --- a/src/libstd/macros.rs +++ b/src/libstd/macros.rs @@ -36,23 +36,27 @@ /// panic!("this is a {} {message}", "fancy", message = "message"); /// ``` #[macro_export] +#[stable] macro_rules! panic { () => ({ panic!("explicit panic") }); ($msg:expr) => ({ - // static requires less code at runtime, more constant data - static _FILE_LINE: (&'static str, uint) = (file!(), line!()); - ::std::rt::begin_unwind($msg, &_FILE_LINE) + $crate::rt::begin_unwind($msg, { + // static requires less code at runtime, more constant data + static _FILE_LINE: (&'static str, uint) = (file!(), line!()); + &_FILE_LINE + }) }); - ($fmt:expr, $($arg:tt)*) => ({ - // The leading _'s are to avoid dead code warnings if this is - // used inside a dead function. Just `#[allow(dead_code)]` is - // insufficient, since the user may have - // `#[forbid(dead_code)]` and which cannot be overridden. - static _FILE_LINE: (&'static str, uint) = (file!(), line!()); - ::std::rt::begin_unwind_fmt(format_args!($fmt, $($arg)*), &_FILE_LINE) - + ($fmt:expr, $($arg:tt)+) => ({ + $crate::rt::begin_unwind_fmt(format_args!($fmt, $($arg)+), { + // The leading _'s are to avoid dead code warnings if this is + // used inside a dead function. Just `#[allow(dead_code)]` is + // insufficient, since the user may have + // `#[forbid(dead_code)]` and which cannot be overridden. + static _FILE_LINE: (&'static str, uint) = (file!(), line!()); + &_FILE_LINE + }) }); } @@ -77,15 +81,16 @@ macro_rules! panic { /// assert!(a + b == 30, "a = {}, b = {}", a, b); /// ``` #[macro_export] +#[stable] macro_rules! assert { ($cond:expr) => ( if !$cond { panic!(concat!("assertion failed: ", stringify!($cond))) } ); - ($cond:expr, $($arg:expr),+) => ( + ($cond:expr, $($arg:tt)+) => ( if !$cond { - panic!($($arg),+) + panic!($($arg)+) } ); } @@ -103,6 +108,7 @@ macro_rules! assert { /// assert_eq!(a, b); /// ``` #[macro_export] +#[stable] macro_rules! assert_eq { ($left:expr , $right:expr) => ({ match (&($left), &($right)) { @@ -144,6 +150,7 @@ macro_rules! assert_eq { /// debug_assert!(a + b == 30, "a = {}, b = {}", a, b); /// ``` #[macro_export] +#[stable] macro_rules! debug_assert { ($($arg:tt)*) => (if cfg!(not(ndebug)) { assert!($($arg)*); }) } @@ -210,6 +217,7 @@ macro_rules! debug_assert_eq { /// } /// ``` #[macro_export] +#[unstable = "relationship with panic is unclear"] macro_rules! unreachable { () => ({ panic!("internal error: entered unreachable code") @@ -225,6 +233,7 @@ macro_rules! unreachable { /// A standardised placeholder for marking unfinished code. It panics with the /// message `"not yet implemented"` when executed. #[macro_export] +#[unstable = "relationship with panic is unclear"] macro_rules! unimplemented { () => (panic!("not yet implemented")) } @@ -242,7 +251,7 @@ macro_rules! unimplemented { #[macro_export] #[stable] macro_rules! format { - ($($arg:tt)*) => (::std::fmt::format(format_args!($($arg)*))) + ($($arg:tt)*) => ($crate::fmt::format(format_args!($($arg)*))) } /// Equivalent to the `println!` macro except that a newline is not printed at @@ -250,7 +259,7 @@ macro_rules! format { #[macro_export] #[stable] macro_rules! print { - ($($arg:tt)*) => (::std::io::stdio::print_args(format_args!($($arg)*))) + ($($arg:tt)*) => ($crate::io::stdio::print_args(format_args!($($arg)*))) } /// Macro for printing to a task's stdout handle. @@ -268,20 +277,19 @@ macro_rules! print { #[macro_export] #[stable] macro_rules! println { - ($($arg:tt)*) => (::std::io::stdio::println_args(format_args!($($arg)*))) + ($($arg:tt)*) => ($crate::io::stdio::println_args(format_args!($($arg)*))) } /// Helper macro for unwrapping `Result` values while returning early with an /// error if the value of the expression is `Err`. For more information, see /// `std::io`. #[macro_export] +#[stable] macro_rules! try { - ($expr:expr) => ({ - use $crate::result::Result::{Ok, Err}; - - match $expr { - Ok(val) => val, - Err(err) => return Err($crate::error::FromError::from_error(err)), + ($expr:expr) => (match $expr { + $crate::result::Result::Ok(val) => val, + $crate::result::Result::Err(err) => { + return $crate::result::Result::Err($crate::error::FromError::from_error(err)) } }) } @@ -412,26 +420,6 @@ pub mod builtin { #[macro_export] macro_rules! option_env { ($name:expr) => ({ /* compiler built-in */ }) } - /// Concatenate literals into a static byte slice. - /// - /// This macro takes any number of comma-separated literal expressions, - /// yielding an expression of type `&'static [u8]` which is the - /// concatenation (left to right) of all the literals in their byte format. - /// - /// This extension currently only supports string literals, character - /// literals, and integers less than 256. The byte slice returned is the - /// utf8-encoding of strings and characters. - /// - /// # Example - /// - /// ``` - /// let rust = bytes!("r", 'u', "st", 255); - /// assert_eq!(rust[1], b'u'); - /// assert_eq!(rust[4], 255); - /// ``` - #[macro_export] - macro_rules! bytes { ($($e:expr),*) => ({ /* compiler built-in */ }) } - /// Concatenate identifiers into one identifier. /// /// This macro takes any number of comma-separated identifiers, and @@ -565,10 +553,6 @@ pub mod builtin { #[macro_export] macro_rules! include_bytes { ($file:expr) => ({ /* compiler built-in */ }) } - /// Deprecated alias for `include_bytes!()`. - #[macro_export] - macro_rules! include_bin { ($file:expr) => ({ /* compiler built-in */}) } - /// Expands to a string that represents the current module path. /// /// The current module path can be thought of as the hierarchy of modules diff --git a/src/libstd/num/int.rs b/src/libstd/num/int.rs index 9ccb1544fdc..69439f85115 100644 --- a/src/libstd/num/int.rs +++ b/src/libstd/num/int.rs @@ -8,10 +8,13 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -//! Operations and constants for architecture-sized signed integers (`int` type) +//! Deprecated: replaced by `isize`. +//! +//! The rollout of the new type will gradually take place over the +//! alpha cycle along with the development of clearer conventions +//! around integer types. -#![stable] -#![doc(primitive = "int")] +#![deprecated = "replaced by isize"] pub use core::int::{BITS, BYTES, MIN, MAX}; diff --git a/src/libstd/num/isize.rs b/src/libstd/num/isize.rs new file mode 100644 index 00000000000..22395a1c0ff --- /dev/null +++ b/src/libstd/num/isize.rs @@ -0,0 +1,22 @@ +// 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. +// +// 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. + +//! Operations and constants for pointer-sized signed integers (`isize` type) +//! +//! This type was recently added to replace `int`. The rollout of the +//! new type will gradually take place over the alpha cycle along with +//! the development of clearer conventions around integer types. + +#![stable] +#![doc(primitive = "isize")] + +pub use core::isize::{BITS, BYTES, MIN, MAX}; + +int_module! { isize } diff --git a/src/libstd/num/mod.rs b/src/libstd/num/mod.rs index f433cd1e664..9c6911cf4d1 100644 --- a/src/libstd/num/mod.rs +++ b/src/libstd/num/mod.rs @@ -424,12 +424,14 @@ mod tests { assert_eq!(int::MIN.to_u32(), None); assert_eq!(int::MIN.to_u64(), None); - #[cfg(target_word_size = "32")] + #[cfg(any(all(stage0, target_word_size = "32"), + all(not(stage0), target_pointer_width = "32")))] fn check_word_size() { assert_eq!(int::MIN.to_i32(), Some(int::MIN as i32)); } - #[cfg(target_word_size = "64")] + #[cfg(any(all(stage0, target_word_size = "64"), + all(not(stage0), target_pointer_width = "64")))] fn check_word_size() { assert_eq!(int::MIN.to_i32(), None); } @@ -492,12 +494,14 @@ mod tests { assert_eq!(i64::MIN.to_u32(), None); assert_eq!(i64::MIN.to_u64(), None); - #[cfg(target_word_size = "32")] + #[cfg(any(all(stage0, target_word_size = "32"), + all(not(stage0), target_pointer_width = "32")))] fn check_word_size() { assert_eq!(i64::MIN.to_int(), None); } - #[cfg(target_word_size = "64")] + #[cfg(any(all(stage0, target_word_size = "64"), + all(not(stage0), target_pointer_width = "64")))] fn check_word_size() { assert_eq!(i64::MIN.to_int(), Some(i64::MIN as int)); } @@ -517,13 +521,15 @@ mod tests { // int::MAX.to_u32() is word-size specific assert_eq!(int::MAX.to_u64(), Some(int::MAX as u64)); - #[cfg(target_word_size = "32")] + #[cfg(any(all(stage0, target_word_size = "32"), + all(not(stage0), target_pointer_width = "32")))] fn check_word_size() { assert_eq!(int::MAX.to_i32(), Some(int::MAX as i32)); assert_eq!(int::MAX.to_u32(), Some(int::MAX as u32)); } - #[cfg(target_word_size = "64")] + #[cfg(any(all(stage0, target_word_size = "64"), + all(not(stage0), target_pointer_width = "64")))] fn check_word_size() { assert_eq!(int::MAX.to_i32(), None); assert_eq!(int::MAX.to_u32(), None); @@ -587,13 +593,15 @@ mod tests { assert_eq!(i64::MAX.to_u32(), None); assert_eq!(i64::MAX.to_u64(), Some(i64::MAX as u64)); - #[cfg(target_word_size = "32")] + #[cfg(any(all(stage0, target_word_size = "32"), + all(not(stage0), target_pointer_width = "32")))] fn check_word_size() { assert_eq!(i64::MAX.to_int(), None); assert_eq!(i64::MAX.to_uint(), None); } - #[cfg(target_word_size = "64")] + #[cfg(any(all(stage0, target_word_size = "64"), + all(not(stage0), target_pointer_width = "64")))] fn check_word_size() { assert_eq!(i64::MAX.to_int(), Some(i64::MAX as int)); assert_eq!(i64::MAX.to_uint(), Some(i64::MAX as uint)); @@ -684,13 +692,15 @@ mod tests { // uint::MAX.to_u32() is word-size specific assert_eq!(uint::MAX.to_u64(), Some(uint::MAX as u64)); - #[cfg(target_word_size = "32")] + #[cfg(any(all(stage0, target_word_size = "32"), + all(not(stage0), target_pointer_width = "32")))] fn check_word_size() { assert_eq!(uint::MAX.to_u32(), Some(uint::MAX as u32)); assert_eq!(uint::MAX.to_i64(), Some(uint::MAX as i64)); } - #[cfg(target_word_size = "64")] + #[cfg(any(all(stage0, target_word_size = "64"), + all(not(stage0), target_pointer_width = "64")))] fn check_word_size() { assert_eq!(uint::MAX.to_u32(), None); assert_eq!(uint::MAX.to_i64(), None); @@ -740,12 +750,14 @@ mod tests { assert_eq!(u32::MAX.to_u32(), Some(u32::MAX as u32)); assert_eq!(u32::MAX.to_u64(), Some(u32::MAX as u64)); - #[cfg(target_word_size = "32")] + #[cfg(any(all(stage0, target_word_size = "32"), + all(not(stage0), target_pointer_width = "32")))] fn check_word_size() { assert_eq!(u32::MAX.to_int(), None); } - #[cfg(target_word_size = "64")] + #[cfg(any(all(stage0, target_word_size = "64"), + all(not(stage0), target_pointer_width = "64")))] fn check_word_size() { assert_eq!(u32::MAX.to_int(), Some(u32::MAX as int)); } @@ -766,12 +778,14 @@ mod tests { assert_eq!(u64::MAX.to_u32(), None); assert_eq!(u64::MAX.to_u64(), Some(u64::MAX as u64)); - #[cfg(target_word_size = "32")] + #[cfg(any(all(stage0, target_word_size = "32"), + all(not(stage0), target_pointer_width = "32")))] fn check_word_size() { assert_eq!(u64::MAX.to_uint(), None); } - #[cfg(target_word_size = "64")] + #[cfg(any(all(stage0, target_word_size = "64"), + all(not(stage0), target_pointer_width = "64")))] fn check_word_size() { assert_eq!(u64::MAX.to_uint(), Some(u64::MAX as uint)); } diff --git a/src/libstd/num/uint.rs b/src/libstd/num/uint.rs index 0fbc0953b20..0e12eff205f 100644 --- a/src/libstd/num/uint.rs +++ b/src/libstd/num/uint.rs @@ -8,10 +8,13 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -//! Operations and constants for architecture-sized unsigned integers (`uint` type) +//! Deprecated: replaced by `usize`. +//! +//! The rollout of the new type will gradually take place over the +//! alpha cycle along with the development of clearer conventions +//! around integer types. -#![stable] -#![doc(primitive = "uint")] +#![deprecated = "replaced by usize"] pub use core::uint::{BITS, BYTES, MIN, MAX}; diff --git a/src/libstd/num/usize.rs b/src/libstd/num/usize.rs new file mode 100644 index 00000000000..74dd38e13c5 --- /dev/null +++ b/src/libstd/num/usize.rs @@ -0,0 +1,22 @@ +// 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. +// +// 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. + +//! Operations and constants for pointer-sized unsigned integers (`usize` type) +//! +//! This type was recently added to replace `uint`. The rollout of the +//! new type will gradually take place over the alpha cycle along with +//! the development of clearer conventions around integer types. + +#![stable] +#![doc(primitive = "usize")] + +pub use core::usize::{BITS, BYTES, MIN, MAX}; + +uint_module! { usize } diff --git a/src/libstd/path/mod.rs b/src/libstd/path/mod.rs index 581969e98fb..b474ae4e371 100644 --- a/src/libstd/path/mod.rs +++ b/src/libstd/path/mod.rs @@ -68,7 +68,7 @@ use fmt; use iter::IteratorExt; use option::Option; use option::Option::{None, Some}; -use ops::{FullRange, Index}; +use ops::FullRange; use str; use str::StrExt; use string::{String, CowString}; @@ -352,7 +352,7 @@ pub trait GenericPath: Clone + GenericPathUnsafe { match name.rposition_elem(&dot) { None | Some(0) => name, Some(1) if name == b".." => name, - Some(pos) => name.index(&(0..pos)) + Some(pos) => &name[0..pos] } }) } @@ -399,7 +399,7 @@ pub trait GenericPath: Clone + GenericPathUnsafe { match name.rposition_elem(&dot) { None | Some(0) => None, Some(1) if name == b".." => None, - Some(pos) => Some(name.index(&((pos+1)..))) + Some(pos) => Some(&name[(pos+1)..]) } } } @@ -475,7 +475,7 @@ pub trait GenericPath: Clone + GenericPathUnsafe { let extlen = extension.container_as_bytes().len(); match (name.rposition_elem(&dot), extlen) { (None, 0) | (Some(0), 0) => None, - (Some(idx), 0) => Some(name.index(&(0..idx)).to_vec()), + (Some(idx), 0) => Some(name[0..idx].to_vec()), (idx, extlen) => { let idx = match idx { None | Some(0) => name.len(), @@ -484,7 +484,7 @@ pub trait GenericPath: Clone + GenericPathUnsafe { let mut v; v = Vec::with_capacity(idx + extlen + 1); - v.push_all(name.index(&(0..idx))); + v.push_all(&name[0..idx]); v.push(dot); v.push_all(extension.container_as_bytes()); Some(v) @@ -823,7 +823,6 @@ pub struct Display<'a, P:'a> { filename: bool } -//NOTE(stage0): replace with deriving(Show) after snapshot impl<'a, P: GenericPath> fmt::Show for Display<'a, P> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::String::fmt(self, f) @@ -877,7 +876,7 @@ impl BytesContainer for String { } #[inline] fn container_as_str(&self) -> Option<&str> { - Some(self.index(&FullRange)) + Some(&self[]) } #[inline] fn is_str(_: Option<&String>) -> bool { true } @@ -893,7 +892,7 @@ impl BytesContainer for [u8] { impl BytesContainer for Vec<u8> { #[inline] fn container_as_bytes(&self) -> &[u8] { - self.index(&FullRange) + &self[] } } diff --git a/src/libstd/path/posix.rs b/src/libstd/path/posix.rs index 0b7dc19fcab..293696d5cca 100644 --- a/src/libstd/path/posix.rs +++ b/src/libstd/path/posix.rs @@ -17,7 +17,6 @@ use hash; use io::Writer; use iter::{AdditiveIterator, Extend}; use iter::{Iterator, IteratorExt, Map}; -use ops::Index; use marker::Sized; use option::Option::{self, Some, None}; use slice::{AsSlice, Split, SliceExt, SliceConcatExt}; @@ -60,7 +59,7 @@ pub fn is_sep(c: char) -> bool { impl fmt::Show for Path { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "Path {{ {} }}", self.display()) + fmt::Show::fmt(&self.display(), f) } } @@ -91,7 +90,7 @@ impl FromStr for Path { } } -impl<S: hash::Writer> hash::Hash<S> for Path { +impl<S: hash::Writer + hash::Hasher> hash::Hash<S> for Path { #[inline] fn hash(&self, state: &mut S) { self.repr.hash(state) @@ -127,7 +126,7 @@ impl GenericPathUnsafe for Path { None => { self.repr = Path::normalize(filename); } - Some(idx) if self.repr.index(&((idx+1)..)) == b".." => { + Some(idx) if &self.repr[(idx+1)..] == b".." => { let mut v = Vec::with_capacity(self.repr.len() + 1 + filename.len()); v.push_all(self.repr.as_slice()); v.push(SEP_BYTE); @@ -137,7 +136,7 @@ impl GenericPathUnsafe for Path { } Some(idx) => { let mut v = Vec::with_capacity(idx + 1 + filename.len()); - v.push_all(self.repr.index(&(0..(idx+1)))); + v.push_all(&self.repr[0..(idx+1)]); v.push_all(filename); // FIXME: this is slow self.repr = Path::normalize(v.as_slice()); @@ -178,9 +177,9 @@ impl GenericPath for Path { match self.sepidx { None if b".." == self.repr => self.repr.as_slice(), None => dot_static, - Some(0) => self.repr.index(&(0..1)), - Some(idx) if self.repr.index(&((idx+1)..)) == b".." => self.repr.as_slice(), - Some(idx) => self.repr.index(&(0..idx)) + Some(0) => &self.repr[0..1], + Some(idx) if &self.repr[(idx+1)..] == b".." => self.repr.as_slice(), + Some(idx) => &self.repr[0..idx] } } @@ -189,9 +188,9 @@ impl GenericPath for Path { None if b"." == self.repr || b".." == self.repr => None, None => Some(self.repr.as_slice()), - Some(idx) if self.repr.index(&((idx+1)..)) == b".." => None, - Some(0) if self.repr.index(&(1..)).is_empty() => None, - Some(idx) => Some(self.repr.index(&((idx+1)..))) + Some(idx) if &self.repr[(idx+1)..] == b".." => None, + Some(0) if self.repr[1..].is_empty() => None, + Some(idx) => Some(&self.repr[(idx+1)..]) } } @@ -333,7 +332,7 @@ impl Path { // borrowck is being very picky let val = { let is_abs = !v.as_slice().is_empty() && v.as_slice()[0] == SEP_BYTE; - let v_ = if is_abs { v.as_slice().index(&(1..)) } else { v.as_slice() }; + let v_ = if is_abs { &v.as_slice()[1..] } else { v.as_slice() }; let comps = normalize_helper(v_, is_abs); match comps { None => None, @@ -372,7 +371,7 @@ impl Path { /// A path of "/" yields no components. A path of "." yields one component. pub fn components<'a>(&'a self) -> Components<'a> { let v = if self.repr[0] == SEP_BYTE { - self.repr.index(&(1..)) + &self.repr[1..] } else { self.repr.as_slice() }; let is_sep_byte: fn(&u8) -> bool = is_sep_byte; // coerce to fn ptr let mut ret = v.split(is_sep_byte); diff --git a/src/libstd/path/windows.rs b/src/libstd/path/windows.rs index 5c4e7aa9ac2..2a1f1794e49 100644 --- a/src/libstd/path/windows.rs +++ b/src/libstd/path/windows.rs @@ -25,7 +25,7 @@ use iter::{AdditiveIterator, Extend}; use iter::{Iterator, IteratorExt, Map, repeat}; use mem; use option::Option::{self, Some, None}; -use ops::{FullRange, Index}; +use ops::FullRange; use slice::{SliceExt, SliceConcatExt}; use str::{SplitTerminator, FromStr, StrExt}; use string::{String, ToString}; @@ -87,7 +87,7 @@ pub struct Path { impl fmt::Show for Path { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "Path {{ {} }}", self.display()) + fmt::Show::fmt(&self.display(), f) } } @@ -118,7 +118,7 @@ impl FromStr for Path { } } -impl<S: hash::Writer> hash::Hash<S> for Path { +impl<S: hash::Writer + hash::Hasher> hash::Hash<S> for Path { #[cfg(not(test))] #[inline] fn hash(&self, state: &mut S) { @@ -173,30 +173,30 @@ impl GenericPathUnsafe for Path { s.push_str(".."); s.push(SEP); s.push_str(filename); - self.update_normalized(s.index(&FullRange)); + self.update_normalized(&s[]); } None => { self.update_normalized(filename); } - Some((_,idxa,end)) if self.repr.index(&(idxa..end)) == ".." => { + Some((_,idxa,end)) if &self.repr[idxa..end] == ".." => { let mut s = String::with_capacity(end + 1 + filename.len()); - s.push_str(self.repr.index(&(0..end))); + s.push_str(&self.repr[0..end]); s.push(SEP); s.push_str(filename); - self.update_normalized(s.index(&FullRange)); + self.update_normalized(&s[]); } Some((idxb,idxa,_)) if self.prefix == Some(DiskPrefix) && idxa == self.prefix_len() => { let mut s = String::with_capacity(idxb + filename.len()); - s.push_str(self.repr.index(&(0..idxb))); + s.push_str(&self.repr[0..idxb]); s.push_str(filename); - self.update_normalized(s.index(&FullRange)); + self.update_normalized(&s[]); } Some((idxb,_,_)) => { let mut s = String::with_capacity(idxb + 1 + filename.len()); - s.push_str(self.repr.index(&(0..idxb))); + s.push_str(&self.repr[0..idxb]); s.push(SEP); s.push_str(filename); - self.update_normalized(s.index(&FullRange)); + self.update_normalized(&s[]); } } } @@ -215,12 +215,12 @@ impl GenericPathUnsafe for Path { let path = path.container_as_str().unwrap(); fn is_vol_abs(path: &str, prefix: Option<PathPrefix>) -> bool { // assume prefix is Some(DiskPrefix) - let rest = path.index(&(prefix_len(prefix)..)); + let rest = &path[prefix_len(prefix)..]; !rest.is_empty() && rest.as_bytes()[0].is_ascii() && is_sep(rest.as_bytes()[0] as char) } fn shares_volume(me: &Path, path: &str) -> bool { // path is assumed to have a prefix of Some(DiskPrefix) - let repr = me.repr.index(&FullRange); + let repr = &me.repr[]; match me.prefix { Some(DiskPrefix) => { repr.as_bytes()[0] == path.as_bytes()[0].to_ascii_uppercase() @@ -252,7 +252,7 @@ impl GenericPathUnsafe for Path { else { None }; let pathlen = path_.as_ref().map_or(path.len(), |p| p.len()); let mut s = String::with_capacity(me.repr.len() + 1 + pathlen); - s.push_str(me.repr.index(&FullRange)); + s.push_str(&me.repr[]); let plen = me.prefix_len(); // if me is "C:" we don't want to add a path separator match me.prefix { @@ -264,9 +264,9 @@ impl GenericPathUnsafe for Path { } match path_ { None => s.push_str(path), - Some(p) => s.push_str(p.index(&FullRange)), + Some(p) => s.push_str(&p[]), }; - me.update_normalized(s.index(&FullRange)) + me.update_normalized(&s[]) } if !path.is_empty() { @@ -274,7 +274,7 @@ impl GenericPathUnsafe for Path { match prefix { Some(DiskPrefix) if !is_vol_abs(path, prefix) && shares_volume(self, path) => { // cwd-relative path, self is on the same volume - append_path(self, path.index(&(prefix_len(prefix)..))); + append_path(self, &path[prefix_len(prefix)..]); } Some(_) => { // absolute path, or cwd-relative and self is not same volume @@ -320,7 +320,7 @@ impl GenericPath for Path { /// Always returns a `Some` value. #[inline] fn as_str<'a>(&'a self) -> Option<&'a str> { - Some(self.repr.index(&FullRange)) + Some(&self.repr[]) } #[inline] @@ -342,21 +342,21 @@ impl GenericPath for Path { /// Always returns a `Some` value. fn dirname_str<'a>(&'a self) -> Option<&'a str> { Some(match self.sepidx_or_prefix_len() { - None if ".." == self.repr => self.repr.index(&FullRange), + None if ".." == self.repr => &self.repr[], None => ".", - Some((_,idxa,end)) if self.repr.index(&(idxa..end)) == ".." => { - self.repr.index(&FullRange) + Some((_,idxa,end)) if &self.repr[idxa..end] == ".." => { + &self.repr[] } - Some((idxb,_,end)) if self.repr.index(&(idxb..end)) == "\\" => { - self.repr.index(&FullRange) + Some((idxb,_,end)) if &self.repr[idxb..end] == "\\" => { + &self.repr[] } - Some((0,idxa,_)) => self.repr.index(&(0..idxa)), + Some((0,idxa,_)) => &self.repr[0..idxa], Some((idxb,idxa,_)) => { match self.prefix { Some(DiskPrefix) | Some(VerbatimDiskPrefix) if idxb == self.prefix_len() => { - self.repr.index(&(0..idxa)) + &self.repr[0..idxa] } - _ => self.repr.index(&(0..idxb)) + _ => &self.repr[0..idxb] } } }) @@ -370,13 +370,13 @@ impl GenericPath for Path { /// See `GenericPath::filename_str` for info. /// Always returns a `Some` value if `filename` returns a `Some` value. fn filename_str<'a>(&'a self) -> Option<&'a str> { - let repr = self.repr.index(&FullRange); + let repr = &self.repr[]; match self.sepidx_or_prefix_len() { None if "." == repr || ".." == repr => None, None => Some(repr), - Some((_,idxa,end)) if repr.index(&(idxa..end)) == ".." => None, + Some((_,idxa,end)) if &repr[idxa..end] == ".." => None, Some((_,idxa,end)) if idxa == end => None, - Some((_,idxa,end)) => Some(repr.index(&(idxa..end))) + Some((_,idxa,end)) => Some(&repr[idxa..end]) } } @@ -408,7 +408,7 @@ impl GenericPath for Path { true } Some((idxb,idxa,end)) if idxb == idxa && idxb == end => false, - Some((idxb,_,end)) if self.repr.index(&(idxb..end)) == "\\" => false, + Some((idxb,_,end)) if &self.repr[idxb..end] == "\\" => false, Some((idxb,idxa,_)) => { let trunc = match self.prefix { Some(DiskPrefix) | Some(VerbatimDiskPrefix) | None => { @@ -428,15 +428,15 @@ impl GenericPath for Path { if self.prefix.is_some() { Some(Path::new(match self.prefix { Some(DiskPrefix) if self.is_absolute() => { - self.repr.index(&(0..(self.prefix_len()+1))) + &self.repr[0..(self.prefix_len()+1)] } Some(VerbatimDiskPrefix) => { - self.repr.index(&(0..(self.prefix_len()+1))) + &self.repr[0..(self.prefix_len()+1)] } - _ => self.repr.index(&(0..self.prefix_len())) + _ => &self.repr[0..self.prefix_len()] })) } else if is_vol_relative(self) { - Some(Path::new(self.repr.index(&(0..1)))) + Some(Path::new(&self.repr[0..1])) } else { None } @@ -455,7 +455,7 @@ impl GenericPath for Path { fn is_absolute(&self) -> bool { match self.prefix { Some(DiskPrefix) => { - let rest = self.repr.index(&(self.prefix_len()..)); + let rest = &self.repr[self.prefix_len()..]; rest.len() > 0 && rest.as_bytes()[0] == SEP_BYTE } Some(_) => true, @@ -630,15 +630,15 @@ impl Path { /// Does not distinguish between absolute and cwd-relative paths, e.g. /// C:\foo and C:foo. pub fn str_components<'a>(&'a self) -> StrComponents<'a> { - let repr = self.repr.index(&FullRange); + let repr = &self.repr[]; let s = match self.prefix { Some(_) => { let plen = self.prefix_len(); if repr.len() > plen && repr.as_bytes()[plen] == SEP_BYTE { - repr.index(&((plen+1)..)) - } else { repr.index(&(plen..)) } + &repr[(plen+1)..] + } else { &repr[plen..] } } - None if repr.as_bytes()[0] == SEP_BYTE => repr.index(&(1..)), + None if repr.as_bytes()[0] == SEP_BYTE => &repr[1..], None => repr }; let some: fn(&'a str) -> Option<&'a str> = Some; // coerce to fn ptr @@ -658,8 +658,8 @@ impl Path { } fn equiv_prefix(&self, other: &Path) -> bool { - let s_repr = self.repr.index(&FullRange); - let o_repr = other.repr.index(&FullRange); + let s_repr = &self.repr[]; + let o_repr = &other.repr[]; match (self.prefix, other.prefix) { (Some(DiskPrefix), Some(VerbatimDiskPrefix)) => { self.is_absolute() && @@ -676,14 +676,14 @@ impl Path { o_repr.as_bytes()[4].to_ascii_lowercase() } (Some(UNCPrefix(_,_)), Some(VerbatimUNCPrefix(_,_))) => { - s_repr.index(&(2..self.prefix_len())) == o_repr.index(&(8..other.prefix_len())) + &s_repr[2..self.prefix_len()] == &o_repr[8..other.prefix_len()] } (Some(VerbatimUNCPrefix(_,_)), Some(UNCPrefix(_,_))) => { - s_repr.index(&(8..self.prefix_len())) == o_repr.index(&(2..other.prefix_len())) + &s_repr[8..self.prefix_len()] == &o_repr[2..other.prefix_len()] } (None, None) => true, (a, b) if a == b => { - s_repr.index(&(0..self.prefix_len())) == o_repr.index(&(0..other.prefix_len())) + &s_repr[0..self.prefix_len()] == &o_repr[0..other.prefix_len()] } _ => false } @@ -737,7 +737,7 @@ impl Path { match prefix.unwrap() { DiskPrefix => { let len = prefix_len(prefix) + is_abs as uint; - let mut s = String::from_str(s.index(&(0..len))); + let mut s = String::from_str(&s[0..len]); unsafe { let v = s.as_mut_vec(); v[0] = (*v)[0].to_ascii_uppercase(); @@ -752,7 +752,7 @@ impl Path { } VerbatimDiskPrefix => { let len = prefix_len(prefix) + is_abs as uint; - let mut s = String::from_str(s.index(&(0..len))); + let mut s = String::from_str(&s[0..len]); unsafe { let v = s.as_mut_vec(); v[4] = (*v)[4].to_ascii_uppercase(); @@ -762,14 +762,14 @@ impl Path { _ => { let plen = prefix_len(prefix); if s.len() > plen { - Some(String::from_str(s.index(&(0..plen)))) + Some(String::from_str(&s[0..plen])) } else { None } } } } else if is_abs && comps.is_empty() { Some(repeat(SEP).take(1).collect()) } else { - let prefix_ = s.index(&(0..prefix_len(prefix))); + let prefix_ = &s[0..prefix_len(prefix)]; let n = prefix_.len() + if is_abs { comps.len() } else { comps.len() - 1} + comps.iter().map(|v| v.len()).sum(); @@ -780,15 +780,15 @@ impl Path { s.push(':'); } Some(VerbatimDiskPrefix) => { - s.push_str(prefix_.index(&(0..4))); + s.push_str(&prefix_[0..4]); s.push(prefix_.as_bytes()[4].to_ascii_uppercase() as char); - s.push_str(prefix_.index(&(5..))); + s.push_str(&prefix_[5..]); } Some(UNCPrefix(a,b)) => { s.push_str("\\\\"); - s.push_str(prefix_.index(&(2..(a+2)))); + s.push_str(&prefix_[2..(a+2)]); s.push(SEP); - s.push_str(prefix_.index(&((3+a)..(3+a+b)))); + s.push_str(&prefix_[(3+a)..(3+a+b)]); } Some(_) => s.push_str(prefix_), None => () @@ -813,8 +813,8 @@ impl Path { fn update_sepidx(&mut self) { let s = if self.has_nonsemantic_trailing_slash() { - self.repr.index(&(0..(self.repr.len()-1))) - } else { self.repr.index(&FullRange) }; + &self.repr[0..(self.repr.len()-1)] + } else { &self.repr[] }; let sep_test: fn(char) -> bool = if !prefix_is_verbatim(self.prefix) { is_sep } else { @@ -893,17 +893,17 @@ pub fn is_verbatim(path: &Path) -> bool { /// non-verbatim, the non-verbatim version is returned. /// Otherwise, None is returned. pub fn make_non_verbatim(path: &Path) -> Option<Path> { - let repr = path.repr.index(&FullRange); + let repr = &path.repr[]; let new_path = match path.prefix { Some(VerbatimPrefix(_)) | Some(DeviceNSPrefix(_)) => return None, Some(UNCPrefix(_,_)) | Some(DiskPrefix) | None => return Some(path.clone()), Some(VerbatimDiskPrefix) => { // \\?\D:\ - Path::new(repr.index(&(4..))) + Path::new(&repr[4..]) } Some(VerbatimUNCPrefix(_,_)) => { // \\?\UNC\server\share - Path::new(format!(r"\{}", repr.index(&(7..)))) + Path::new(format!(r"\{}", &repr[7..])) } }; if new_path.prefix.is_none() { @@ -912,8 +912,7 @@ pub fn make_non_verbatim(path: &Path) -> Option<Path> { return None; } // now ensure normalization didn't change anything - if repr.index(&(path.prefix_len()..)) == - new_path.repr.index(&(new_path.prefix_len()..)) { + if &repr[path.prefix_len()..] == &new_path.repr[new_path.prefix_len()..] { Some(new_path) } else { None @@ -978,13 +977,13 @@ pub enum PathPrefix { fn parse_prefix<'a>(mut path: &'a str) -> Option<PathPrefix> { if path.starts_with("\\\\") { // \\ - path = path.index(&(2..)); + path = &path[2..]; if path.starts_with("?\\") { // \\?\ - path = path.index(&(2..)); + path = &path[2..]; if path.starts_with("UNC\\") { // \\?\UNC\server\share - path = path.index(&(4..)); + path = &path[4..]; let (idx_a, idx_b) = match parse_two_comps(path, is_sep_verbatim) { Some(x) => x, None => (path.len(), 0) @@ -1005,7 +1004,7 @@ fn parse_prefix<'a>(mut path: &'a str) -> Option<PathPrefix> { } } else if path.starts_with(".\\") { // \\.\path - path = path.index(&(2..)); + path = &path[2..]; let idx = path.find('\\').unwrap_or(path.len()); return Some(DeviceNSPrefix(idx)); } @@ -1030,7 +1029,7 @@ fn parse_prefix<'a>(mut path: &'a str) -> Option<PathPrefix> { None => return None, Some(x) => x }; - path = path.index(&((idx_a+1)..)); + path = &path[(idx_a+1)..]; let idx_b = path.find(f).unwrap_or(path.len()); Some((idx_a, idx_b)) } @@ -1044,8 +1043,8 @@ fn normalize_helper<'a>(s: &'a str, prefix: Option<PathPrefix>) -> (bool, Option is_sep_verbatim }; let is_abs = s.len() > prefix_len(prefix) && f(s.char_at(prefix_len(prefix))); - let s_ = s.index(&(prefix_len(prefix)..)); - let s_ = if is_abs { s_.index(&(1..)) } else { s_ }; + let s_ = &s[prefix_len(prefix)..]; + let s_ = if is_abs { &s_[1..] } else { s_ }; if is_abs && s_.is_empty() { return (is_abs, match prefix { diff --git a/src/libstd/prelude/v1.rs b/src/libstd/prelude/v1.rs index dcb342b9ca2..d9c942c0185 100644 --- a/src/libstd/prelude/v1.rs +++ b/src/libstd/prelude/v1.rs @@ -17,7 +17,7 @@ #[stable] #[doc(no_inline)] pub use ops::{Drop, Fn, FnMut, FnOnce}; // TEMPORARY -#[unstable] #[doc(no_inline)] pub use ops::{Index, IndexMut, FullRange}; +#[unstable] #[doc(no_inline)] pub use ops::FullRange; // Reexported functions #[stable] #[doc(no_inline)] pub use mem::drop; diff --git a/src/libstd/rand/mod.rs b/src/libstd/rand/mod.rs index d3e6cd166ec..3fa1efe1ccd 100644 --- a/src/libstd/rand/mod.rs +++ b/src/libstd/rand/mod.rs @@ -230,9 +230,9 @@ use rc::Rc; use result::Result::{Ok, Err}; use vec::Vec; -#[cfg(not(target_word_size="64"))] +#[cfg(any(all(stage0, target_word_size = "32"), all(not(stage0), target_pointer_width = "32")))] use core_rand::IsaacRng as IsaacWordRng; -#[cfg(target_word_size="64")] +#[cfg(any(all(stage0, target_word_size = "64"), all(not(stage0), target_pointer_width = "64")))] use core_rand::Isaac64Rng as IsaacWordRng; pub use core_rand::{Rand, Rng, SeedableRng, Open01, Closed01}; @@ -403,7 +403,7 @@ pub fn random<T: Rand>() -> T { /// /// let mut rng = thread_rng(); /// let sample = sample(&mut rng, range(1i, 100), 5); -/// println!("{}", sample); +/// println!("{:?}", sample); /// ``` pub fn sample<T, I: Iterator<Item=T>, R: Rng>(rng: &mut R, mut iter: I, diff --git a/src/libstd/rt/unwind.rs b/src/libstd/rt/unwind.rs index fd84f220942..03876189da9 100644 --- a/src/libstd/rt/unwind.rs +++ b/src/libstd/rt/unwind.rs @@ -544,7 +544,7 @@ fn begin_unwind_inner(msg: Box<Any + Send>, file_line: &(&'static str, uint)) -> // MAX_CALLBACKS, so we're sure to clamp it as necessary. let callbacks = { let amt = CALLBACK_CNT.load(Ordering::SeqCst); - CALLBACKS.index(&(0..cmp::min(amt, MAX_CALLBACKS))) + &CALLBACKS[0..cmp::min(amt, MAX_CALLBACKS)] }; for cb in callbacks.iter() { match cb.load(Ordering::SeqCst) { diff --git a/src/libstd/rt/util.rs b/src/libstd/rt/util.rs index 59f654a95ca..c076f0a7c6c 100644 --- a/src/libstd/rt/util.rs +++ b/src/libstd/rt/util.rs @@ -131,7 +131,7 @@ pub fn abort(args: fmt::Arguments) -> ! { impl<'a> fmt::Writer for BufWriter<'a> { fn write_str(&mut self, bytes: &str) -> fmt::Result { let left = self.buf.slice_from_mut(self.pos); - let to_write = bytes.as_bytes().index(&(0..cmp::min(bytes.len(), left.len()))); + let to_write = &bytes.as_bytes()[0..cmp::min(bytes.len(), left.len())]; slice::bytes::copy_memory(left, to_write); self.pos += to_write.len(); Ok(()) @@ -142,7 +142,7 @@ pub fn abort(args: fmt::Arguments) -> ! { let mut msg = [0u8; 512]; let mut w = BufWriter { buf: &mut msg, pos: 0 }; let _ = write!(&mut w, "{}", args); - let msg = str::from_utf8(w.buf.index_mut(&(0..w.pos))).unwrap_or("aborted"); + let msg = str::from_utf8(&w.buf[0..w.pos]).unwrap_or("aborted"); let msg = if msg.is_empty() {"aborted"} else {msg}; // Give some context to the message diff --git a/src/libstd/sync/mpsc/stream.rs b/src/libstd/sync/mpsc/stream.rs index bd1e74a3390..f4b20c7b742 100644 --- a/src/libstd/sync/mpsc/stream.rs +++ b/src/libstd/sync/mpsc/stream.rs @@ -338,7 +338,7 @@ impl<T: Send> Packet<T> { // upgrade pending, then go through the whole recv rigamarole to update // the internal state. match self.queue.peek() { - Some(&GoUp(..)) => { + Some(&mut GoUp(..)) => { match self.recv() { Err(Upgraded(port)) => Err(port), _ => unreachable!(), @@ -367,7 +367,7 @@ impl<T: Send> Packet<T> { Ok(()) => SelSuccess, Err(token) => { let ret = match self.queue.peek() { - Some(&GoUp(..)) => { + Some(&mut GoUp(..)) => { match self.queue.pop() { Some(GoUp(port)) => SelUpgraded(token, port), _ => unreachable!(), @@ -457,7 +457,7 @@ impl<T: Send> Packet<T> { // upgraded port. if has_data { match self.queue.peek() { - Some(&GoUp(..)) => { + Some(&mut GoUp(..)) => { match self.queue.pop() { Some(GoUp(port)) => Err(port), _ => unreachable!(), diff --git a/src/libstd/sys/common/backtrace.rs b/src/libstd/sys/common/backtrace.rs index be44aa99f49..f6161ec193d 100644 --- a/src/libstd/sys/common/backtrace.rs +++ b/src/libstd/sys/common/backtrace.rs @@ -12,8 +12,11 @@ use prelude::v1::*; use io::IoResult; -#[cfg(target_word_size = "64")] pub const HEX_WIDTH: uint = 18; -#[cfg(target_word_size = "32")] pub const HEX_WIDTH: uint = 10; +#[cfg(any(all(stage0, target_word_size = "64"), all(not(stage0), target_pointer_width = "64")))] +pub const HEX_WIDTH: uint = 18; + +#[cfg(any(all(stage0, target_word_size = "32"), all(not(stage0), target_pointer_width = "32")))] +pub const HEX_WIDTH: uint = 10; // All rust symbols are in theory lists of "::"-separated identifiers. Some // assemblers, however, can't handle these characters in symbol names. To get diff --git a/src/libstd/sys/common/net.rs b/src/libstd/sys/common/net.rs index 902942d7244..4cf891ac498 100644 --- a/src/libstd/sys/common/net.rs +++ b/src/libstd/sys/common/net.rs @@ -469,7 +469,7 @@ pub fn write<T, L, W>(fd: sock_t, // Also as with read(), we use MSG_DONTWAIT to guard ourselves // against unforeseen circumstances. let _guard = lock(); - let ptr = buf.index(&(written..)).as_ptr(); + let ptr = buf[written..].as_ptr(); let len = buf.len() - written; match retry(|| write(deadline.is_some(), ptr, len)) { -1 if wouldblock() => {} diff --git a/src/libstd/sys/unix/c.rs b/src/libstd/sys/unix/c.rs index cc661877bc0..1d523ed6edd 100644 --- a/src/libstd/sys/unix/c.rs +++ b/src/libstd/sys/unix/c.rs @@ -169,13 +169,13 @@ mod signal { unsafe impl ::marker::Sync for sigaction { } #[repr(C)] - #[cfg(target_word_size = "32")] + #[cfg(any(all(stage0, target_word_size = "32"), all(not(stage0), target_pointer_width = "32")))] pub struct sigset_t { __val: [libc::c_ulong; 32], } #[repr(C)] - #[cfg(target_word_size = "64")] + #[cfg(any(all(stage0, target_word_size = "64"), all(not(stage0), target_pointer_width = "64")))] pub struct sigset_t { __val: [libc::c_ulong; 16], } diff --git a/src/libstd/sys/unix/process.rs b/src/libstd/sys/unix/process.rs index 1357bbdd5a3..36bf696dba5 100644 --- a/src/libstd/sys/unix/process.rs +++ b/src/libstd/sys/unix/process.rs @@ -11,7 +11,8 @@ use prelude::v1::*; use self::Req::*; -use collections; +use collections::HashMap; +use collections::hash_map::Hasher; use ffi::CString; use hash::Hash; use io::process::{ProcessExit, ExitStatus, ExitSignal}; @@ -60,7 +61,7 @@ impl Process { out_fd: Option<P>, err_fd: Option<P>) -> IoResult<Process> where C: ProcessConfig<K, V>, P: AsInner<FileDesc>, - K: BytesContainer + Eq + Hash, V: BytesContainer + K: BytesContainer + Eq + Hash<Hasher>, V: BytesContainer { use libc::funcs::posix88::unistd::{fork, dup2, close, chdir, execvp}; use libc::funcs::bsd44::getdtablesize; @@ -553,11 +554,11 @@ fn with_argv<T,F>(prog: &CString, args: &[CString], cb(ptrs.as_ptr()) } -fn with_envp<K,V,T,F>(env: Option<&collections::HashMap<K, V>>, +fn with_envp<K,V,T,F>(env: Option<&HashMap<K, V>>, cb: F) -> T where F : FnOnce(*const c_void) -> T, - K : BytesContainer + Eq + Hash, + K : BytesContainer + Eq + Hash<Hasher>, V : BytesContainer { // On posixy systems we can pass a char** for envp, which is a diff --git a/src/libstd/sys/unix/stack_overflow.rs b/src/libstd/sys/unix/stack_overflow.rs index 1fd619a28db..48a51813ba4 100644 --- a/src/libstd/sys/unix/stack_overflow.rs +++ b/src/libstd/sys/unix/stack_overflow.rs @@ -182,12 +182,14 @@ mod imp { sa_restorer: *mut libc::c_void, } - #[cfg(target_word_size = "32")] + #[cfg(any(all(stage0, target_word_size = "32"), + all(not(stage0), target_pointer_width = "32")))] #[repr(C)] pub struct sigset_t { __val: [libc::c_ulong; 32], } - #[cfg(target_word_size = "64")] + #[cfg(any(all(stage0, target_word_size = "64"), + all(not(stage0), target_pointer_width = "64")))] #[repr(C)] pub struct sigset_t { __val: [libc::c_ulong; 16], diff --git a/src/libstd/sys/windows/backtrace.rs b/src/libstd/sys/windows/backtrace.rs index eb76f13afe7..ee2dd14955b 100644 --- a/src/libstd/sys/windows/backtrace.rs +++ b/src/libstd/sys/windows/backtrace.rs @@ -362,7 +362,7 @@ pub fn write(w: &mut Writer) -> IoResult<()> { let bytes = unsafe { ffi::c_str_to_bytes(&ptr) }; match str::from_utf8(bytes) { Ok(s) => try!(demangle(w, s)), - Err(..) => try!(w.write(bytes.index(&(..(bytes.len()-1))))), + Err(..) => try!(w.write(&bytes[..(bytes.len()-1)])), } } try!(w.write(&['\n' as u8])); diff --git a/src/libstd/sys/windows/fs.rs b/src/libstd/sys/windows/fs.rs index f8c75335b35..a7330f7c67c 100644 --- a/src/libstd/sys/windows/fs.rs +++ b/src/libstd/sys/windows/fs.rs @@ -270,7 +270,7 @@ pub fn readdir(p: &Path) -> IoResult<Vec<Path>> { return Err(IoError { kind: io::InvalidInput, desc: "path was not valid UTF-16", - detail: Some(format!("path was not valid UTF-16: {}", filename)), + detail: Some(format!("path was not valid UTF-16: {:?}", filename)), }) }, // FIXME #12056: Convert the UCS-2 to invalid utf-8 instead of erroring } diff --git a/src/libstd/sys/windows/os.rs b/src/libstd/sys/windows/os.rs index fcde5c01080..064633f321c 100644 --- a/src/libstd/sys/windows/os.rs +++ b/src/libstd/sys/windows/os.rs @@ -36,7 +36,7 @@ const BUF_BYTES : uint = 2048u; pub fn truncate_utf16_at_nul<'a>(v: &'a [u16]) -> &'a [u16] { match v.iter().position(|c| *c == 0) { // don't include the 0 - Some(i) => v.index(&(0..i)), + Some(i) => &v[0..i], None => v } } diff --git a/src/libstd/sys/windows/pipe.rs b/src/libstd/sys/windows/pipe.rs index 016757ef63e..9996909f2f5 100644 --- a/src/libstd/sys/windows/pipe.rs +++ b/src/libstd/sys/windows/pipe.rs @@ -453,7 +453,7 @@ impl UnixStream { } let ret = unsafe { libc::WriteFile(self.handle(), - buf.index(&(offset..)).as_ptr() as libc::LPVOID, + buf[offset..].as_ptr() as libc::LPVOID, (buf.len() - offset) as libc::DWORD, &mut bytes_written, &mut overlapped) diff --git a/src/libstd/sys/windows/process.rs b/src/libstd/sys/windows/process.rs index 8e1f169b5cd..1b837385d1e 100644 --- a/src/libstd/sys/windows/process.rs +++ b/src/libstd/sys/windows/process.rs @@ -13,6 +13,7 @@ use prelude::v1::*; use collections; use ffi::CString; use hash::Hash; +use collections::hash_map::Hasher; use io::fs::PathExtensions; use io::process::{ProcessExit, ExitStatus, ExitSignal}; use io::{IoResult, IoError}; @@ -109,7 +110,7 @@ impl Process { out_fd: Option<P>, err_fd: Option<P>) -> IoResult<Process> where C: ProcessConfig<K, V>, P: AsInner<FileDesc>, - K: BytesContainer + Eq + Hash, V: BytesContainer + K: BytesContainer + Eq + Hash<Hasher>, V: BytesContainer { use libc::types::os::arch::extra::{DWORD, HANDLE, STARTUPINFO}; use libc::consts::os::extra::{ @@ -424,8 +425,10 @@ fn make_command_line(prog: &CString, args: &[CString]) -> String { } } -fn with_envp<K, V, T, F>(env: Option<&collections::HashMap<K, V>>, cb: F) -> T where - K: BytesContainer + Eq + Hash, V: BytesContainer, F: FnOnce(*mut c_void) -> T, +fn with_envp<K, V, T, F>(env: Option<&collections::HashMap<K, V>>, cb: F) -> T + where K: BytesContainer + Eq + Hash<Hasher>, + V: BytesContainer, + F: FnOnce(*mut c_void) -> T, { // On Windows we pass an "environment block" which is not a char**, but // rather a concatenation of null-terminated k=v\0 sequences, with a final diff --git a/src/libstd/sys/windows/timer.rs b/src/libstd/sys/windows/timer.rs index 343b78543bf..1ae3979cd9a 100644 --- a/src/libstd/sys/windows/timer.rs +++ b/src/libstd/sys/windows/timer.rs @@ -91,7 +91,7 @@ fn helper(input: libc::HANDLE, messages: Receiver<Req>, _: ()) { } else { let remove = { match &mut chans[idx as uint - 1] { - &(ref mut c, oneshot) => { c.call(); oneshot } + &mut (ref mut c, oneshot) => { c.call(); oneshot } } }; if remove { diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index 6766127a5f1..0a9e0aedd3d 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -100,7 +100,6 @@ impl Ident { } } -//NOTE(stage0): remove after snapshot impl fmt::Show for Ident { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "{}#{}", self.name, self.ctxt) @@ -203,7 +202,7 @@ impl Encodable for Ident { impl Decodable for Ident { fn decode<D: Decoder>(d: &mut D) -> Result<Ident, D::Error> { - Ok(str_to_ident(try!(d.read_str()).index(&FullRange))) + Ok(str_to_ident(&try!(d.read_str())[])) } } @@ -1085,7 +1084,6 @@ pub enum IntTy { TyI64, } -//NOTE(stage0): remove after snapshot impl fmt::Show for IntTy { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::String::fmt(self, f) @@ -1127,7 +1125,6 @@ impl UintTy { } } -//NOTE(stage0): remove after snapshot impl fmt::Show for UintTy { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::String::fmt(self, f) @@ -1146,7 +1143,6 @@ pub enum FloatTy { TyF64, } -//NOTE(stage0): remove after snapshot impl fmt::Show for FloatTy { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::String::fmt(self, f) @@ -1734,11 +1730,8 @@ pub struct MacroDef { #[cfg(test)] mod test { - use serialize::json; use serialize; - use codemap::*; use super::*; - use std::fmt; // are ASTs encodable? #[test] diff --git a/src/libsyntax/ast_map/mod.rs b/src/libsyntax/ast_map/mod.rs index 7496a0f9f26..3ef57279175 100644 --- a/src/libsyntax/ast_map/mod.rs +++ b/src/libsyntax/ast_map/mod.rs @@ -32,7 +32,7 @@ use std::slice; pub mod blocks; -#[derive(Clone, Copy, PartialEq)] +#[derive(Clone, Copy, PartialEq, Show)] pub enum PathElem { PathMod(Name), PathName(Name) @@ -46,13 +46,6 @@ impl PathElem { } } -//NOTE(stage0): replace with deriving(Show) after snapshot -impl fmt::Show for PathElem { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::String::fmt(self, f) - } -} - impl fmt::String for PathElem { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let slot = token::get_name(self.name()); @@ -90,7 +83,7 @@ impl<'a, T: Copy> Iterator for Values<'a, T> { type Item = T; fn next(&mut self) -> Option<T> { - let &Values(ref mut items) = self; + let &mut Values(ref mut items) = self; items.next().map(|&x| x) } } @@ -106,7 +99,7 @@ pub fn path_to_string<PI: Iterator<Item=PathElem>>(path: PI) -> String { if !s.is_empty() { s.push_str("::"); } - s.push_str(e.index(&FullRange)); + s.push_str(&e[]); s }).to_string() } @@ -483,20 +476,20 @@ impl<'ast> Map<'ast> { F: FnOnce(Option<&[Attribute]>) -> T, { let attrs = match self.get(id) { - NodeItem(i) => Some(i.attrs.index(&FullRange)), - NodeForeignItem(fi) => Some(fi.attrs.index(&FullRange)), + NodeItem(i) => Some(&i.attrs[]), + NodeForeignItem(fi) => Some(&fi.attrs[]), NodeTraitItem(ref tm) => match **tm { - RequiredMethod(ref type_m) => Some(type_m.attrs.index(&FullRange)), - ProvidedMethod(ref m) => Some(m.attrs.index(&FullRange)), - TypeTraitItem(ref typ) => Some(typ.attrs.index(&FullRange)), + RequiredMethod(ref type_m) => Some(&type_m.attrs[]), + ProvidedMethod(ref m) => Some(&m.attrs[]), + TypeTraitItem(ref typ) => Some(&typ.attrs[]), }, NodeImplItem(ref ii) => { match **ii { - MethodImplItem(ref m) => Some(m.attrs.index(&FullRange)), - TypeImplItem(ref t) => Some(t.attrs.index(&FullRange)), + MethodImplItem(ref m) => Some(&m.attrs[]), + TypeImplItem(ref t) => Some(&t.attrs[]), } } - NodeVariant(ref v) => Some(v.node.attrs.index(&FullRange)), + NodeVariant(ref v) => Some(&v.node.attrs[]), // unit/tuple structs take the attributes straight from // the struct definition. // FIXME(eddyb) make this work again (requires access to the map). @@ -520,7 +513,7 @@ impl<'ast> Map<'ast> { NodesMatchingSuffix { map: self, item_name: parts.last().unwrap(), - in_which: parts.index(&(0..(parts.len() - 1))), + in_which: &parts[0..(parts.len() - 1)], idx: 0, } } @@ -597,7 +590,7 @@ impl<'a, 'ast> NodesMatchingSuffix<'a, 'ast> { None => return false, Some((node_id, name)) => (node_id, name), }; - if part.index(&FullRange) != mod_name.as_str() { + if &part[] != mod_name.as_str() { return false; } cursor = self.map.get_parent(mod_id); @@ -635,7 +628,7 @@ impl<'a, 'ast> NodesMatchingSuffix<'a, 'ast> { // We are looking at some node `n` with a given name and parent // id; do their names match what I am seeking? fn matches_names(&self, parent_of_n: NodeId, name: Name) -> bool { - name.as_str() == self.item_name.index(&FullRange) && + name.as_str() == &self.item_name[] && self.suffix_matches(parent_of_n) } } @@ -1047,7 +1040,7 @@ impl<'a> NodePrinter for pprust::State<'a> { fn node_id_to_string(map: &Map, id: NodeId, include_id: bool) -> String { let id_str = format!(" (id={})", id); - let id_str = if include_id { id_str.index(&FullRange) } else { "" }; + let id_str = if include_id { &id_str[] } else { "" }; match map.find(id) { Some(NodeItem(item)) => { diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs index 871f1237aee..b4e917e28cb 100644 --- a/src/libsyntax/ast_util.rs +++ b/src/libsyntax/ast_util.rs @@ -85,6 +85,13 @@ pub fn is_shift_binop(b: BinOp) -> bool { } } +pub fn is_comparison_binop(b: BinOp) -> bool { + match b { + BiEq | BiLt | BiLe | BiNe | BiGt | BiGe => true, + _ => false + } +} + /// Returns `true` if the binary operator takes its arguments by value pub fn is_by_value_binop(b: BinOp) -> bool { match b { @@ -238,11 +245,11 @@ pub fn impl_pretty_name(trait_ref: &Option<TraitRef>, ty: &Ty) -> Ident { match *trait_ref { Some(ref trait_ref) => { pretty.push('.'); - pretty.push_str(pprust::path_to_string(&trait_ref.path).index(&FullRange)); + pretty.push_str(&pprust::path_to_string(&trait_ref.path)[]); } None => {} } - token::gensym_ident(pretty.index(&FullRange)) + token::gensym_ident(&pretty[]) } pub fn trait_method_to_ty_method(method: &Method) -> TypeMethod { @@ -317,8 +324,7 @@ pub fn operator_prec(op: ast::BinOp) -> uint { BiBitAnd => 8u, BiBitXor => 7u, BiBitOr => 6u, - BiLt | BiLe | BiGe | BiGt => 4u, - BiEq | BiNe => 3u, + BiLt | BiLe | BiGe | BiGt | BiEq | BiNe => 3u, BiAnd => 2u, BiOr => 1u } @@ -704,7 +710,7 @@ pub fn pat_is_ident(pat: P<ast::Pat>) -> bool { pub fn path_name_eq(a : &ast::Path, b : &ast::Path) -> bool { (a.span == b.span) && (a.global == b.global) - && (segments_name_eq(a.segments.index(&FullRange), b.segments.index(&FullRange))) + && (segments_name_eq(&a.segments[], &b.segments[])) } // are two arrays of segments equal when compared unhygienically? @@ -791,14 +797,14 @@ mod test { #[test] fn idents_name_eq_test() { assert!(segments_name_eq( - [Ident{name:Name(3),ctxt:4}, Ident{name:Name(78),ctxt:82}] - .iter().map(ident_to_segment).collect::<Vec<PathSegment>>().index(&FullRange), - [Ident{name:Name(3),ctxt:104}, Ident{name:Name(78),ctxt:182}] - .iter().map(ident_to_segment).collect::<Vec<PathSegment>>().index(&FullRange))); + &[Ident{name:Name(3),ctxt:4}, Ident{name:Name(78),ctxt:82}] + .iter().map(ident_to_segment).collect::<Vec<PathSegment>>()[], + &[Ident{name:Name(3),ctxt:104}, Ident{name:Name(78),ctxt:182}] + .iter().map(ident_to_segment).collect::<Vec<PathSegment>>()[])); assert!(!segments_name_eq( - [Ident{name:Name(3),ctxt:4}, Ident{name:Name(78),ctxt:82}] - .iter().map(ident_to_segment).collect::<Vec<PathSegment>>().index(&FullRange), - [Ident{name:Name(3),ctxt:104}, Ident{name:Name(77),ctxt:182}] - .iter().map(ident_to_segment).collect::<Vec<PathSegment>>().index(&FullRange))); + &[Ident{name:Name(3),ctxt:4}, Ident{name:Name(78),ctxt:82}] + .iter().map(ident_to_segment).collect::<Vec<PathSegment>>()[], + &[Ident{name:Name(3),ctxt:104}, Ident{name:Name(77),ctxt:182}] + .iter().map(ident_to_segment).collect::<Vec<PathSegment>>()[])); } } diff --git a/src/libsyntax/attr.rs b/src/libsyntax/attr.rs index 416fc8c2278..2cea55dfc55 100644 --- a/src/libsyntax/attr.rs +++ b/src/libsyntax/attr.rs @@ -98,7 +98,7 @@ impl AttrMetaMethods for MetaItem { fn meta_item_list<'a>(&'a self) -> Option<&'a [P<MetaItem>]> { match self.node { - MetaList(_, ref l) => Some(l.index(&FullRange)), + MetaList(_, ref l) => Some(&l[]), _ => None } } @@ -136,8 +136,8 @@ impl AttributeMethods for Attribute { let comment = self.value_str().unwrap(); let meta = mk_name_value_item_str( InternedString::new("doc"), - token::intern_and_get_ident(strip_doc_comment_decoration( - comment.get()).index(&FullRange))); + token::intern_and_get_ident(&strip_doc_comment_decoration( + comment.get())[])); if self.node.style == ast::AttrOuter { f(&mk_attr_outer(self.node.id, meta)) } else { @@ -297,9 +297,9 @@ pub fn find_inline_attr(attrs: &[Attribute]) -> InlineAttr { } MetaList(ref n, ref items) if *n == "inline" => { mark_used(attr); - if contains_name(items.index(&FullRange), "always") { + if contains_name(&items[], "always") { InlineAlways - } else if contains_name(items.index(&FullRange), "never") { + } else if contains_name(&items[], "never") { InlineNever } else { InlineHint @@ -403,7 +403,7 @@ pub fn require_unique_names(diagnostic: &SpanHandler, metas: &[P<MetaItem>]) { if !set.insert(name.clone()) { diagnostic.span_fatal(meta.span, - format!("duplicate meta item `{}`", name).index(&FullRange)); + &format!("duplicate meta item `{}`", name)[]); } } } diff --git a/src/libsyntax/codemap.rs b/src/libsyntax/codemap.rs index 31fe23847d9..d1768867f0d 100644 --- a/src/libsyntax/codemap.rs +++ b/src/libsyntax/codemap.rs @@ -304,9 +304,9 @@ impl FileMap { lines.get(line_number).map(|&line| { let begin: BytePos = line - self.start_pos; let begin = begin.to_uint(); - let slice = self.src.index(&(begin..)); + let slice = &self.src[begin..]; match slice.find('\n') { - Some(e) => slice.index(&(0..e)), + Some(e) => &slice[0..e], None => slice }.to_string() }) @@ -351,9 +351,9 @@ impl CodeMap { // FIXME #12884: no efficient/safe way to remove from the start of a string // and reuse the allocation. let mut src = if src.starts_with("\u{feff}") { - String::from_str(src.index(&(3..))) + String::from_str(&src[3..]) } else { - String::from_str(src.index(&FullRange)) + String::from_str(&src[]) }; // Append '\n' in case it's not already there. @@ -440,8 +440,7 @@ impl CodeMap { if begin.fm.start_pos != end.fm.start_pos { None } else { - Some(begin.fm.src.index(&(begin.pos.to_uint().. - end.pos.to_uint())).to_string()) + Some((&begin.fm.src[begin.pos.to_uint()..end.pos.to_uint()]).to_string()) } } @@ -590,7 +589,12 @@ impl CodeMap { Some(ref info) => { // save the parent expn_id for next loop iteration expnid = info.call_site.expn_id; - if info.callee.span.is_none() { + if info.callee.name == "format_args" { + // This is a hack because the format_args builtin calls unstable APIs. + // I spent like 6 hours trying to solve this more generally but am stupid. + is_internal = true; + false + } else if info.callee.span.is_none() { // it's a compiler built-in, we *really* don't want to mess with it // so we skip it, unless it was called by a regular macro, in which case // we will handle the caller macro next turn diff --git a/src/libsyntax/diagnostic.rs b/src/libsyntax/diagnostic.rs index fde2fdb3c55..7e57709f33d 100644 --- a/src/libsyntax/diagnostic.rs +++ b/src/libsyntax/diagnostic.rs @@ -123,7 +123,7 @@ impl SpanHandler { panic!(ExplicitBug); } pub fn span_unimpl(&self, sp: Span, msg: &str) -> ! { - self.span_bug(sp, format!("unimplemented {}", msg).index(&FullRange)); + self.span_bug(sp, &format!("unimplemented {}", msg)[]); } pub fn handler<'a>(&'a self) -> &'a Handler { &self.handler @@ -166,7 +166,7 @@ impl Handler { self.err_count.get()); } } - self.fatal(s.index(&FullRange)); + self.fatal(&s[]); } pub fn warn(&self, msg: &str) { self.emit.borrow_mut().emit(None, msg, None, Warning); @@ -182,7 +182,7 @@ impl Handler { panic!(ExplicitBug); } pub fn unimpl(&self, msg: &str) -> ! { - self.bug(format!("unimplemented {}", msg).index(&FullRange)); + self.bug(&format!("unimplemented {}", msg)[]); } pub fn emit(&self, cmsp: Option<(&codemap::CodeMap, Span)>, @@ -277,7 +277,7 @@ fn print_maybe_styled(w: &mut EmitterWriter, // to be miscolored. We assume this is rare enough that we don't // have to worry about it. if msg.ends_with("\n") { - try!(t.write_str(msg.index(&(0..(msg.len()-1))))); + try!(t.write_str(&msg[0..(msg.len()-1)])); try!(t.reset()); try!(t.write_str("\n")); } else { @@ -299,16 +299,16 @@ fn print_diagnostic(dst: &mut EmitterWriter, topic: &str, lvl: Level, } try!(print_maybe_styled(dst, - format!("{}: ", lvl.to_string()).index(&FullRange), + &format!("{}: ", lvl.to_string())[], term::attr::ForegroundColor(lvl.color()))); try!(print_maybe_styled(dst, - format!("{}", msg).index(&FullRange), + &format!("{}", msg)[], term::attr::Bold)); match code { Some(code) => { let style = term::attr::ForegroundColor(term::color::BRIGHT_MAGENTA); - try!(print_maybe_styled(dst, format!(" [{}]", code.clone()).index(&FullRange), style)); + try!(print_maybe_styled(dst, &format!(" [{}]", code.clone())[], style)); } None => () } @@ -398,12 +398,12 @@ fn emit(dst: &mut EmitterWriter, cm: &codemap::CodeMap, rsp: RenderSpan, // the span) let span_end = Span { lo: sp.hi, hi: sp.hi, expn_id: sp.expn_id}; let ses = cm.span_to_string(span_end); - try!(print_diagnostic(dst, ses.index(&FullRange), lvl, msg, code)); + try!(print_diagnostic(dst, &ses[], lvl, msg, code)); if rsp.is_full_span() { try!(custom_highlight_lines(dst, cm, sp, lvl, lines)); } } else { - try!(print_diagnostic(dst, ss.index(&FullRange), lvl, msg, code)); + try!(print_diagnostic(dst, &ss[], lvl, msg, code)); if rsp.is_full_span() { try!(highlight_lines(dst, cm, sp, lvl, lines)); } @@ -413,9 +413,9 @@ fn emit(dst: &mut EmitterWriter, cm: &codemap::CodeMap, rsp: RenderSpan, Some(code) => match dst.registry.as_ref().and_then(|registry| registry.find_description(code)) { Some(_) => { - try!(print_diagnostic(dst, ss.index(&FullRange), Help, - format!("pass `--explain {}` to see a detailed \ - explanation", code).index(&FullRange), None)); + try!(print_diagnostic(dst, &ss[], Help, + &format!("pass `--explain {}` to see a detailed \ + explanation", code)[], None)); } None => () }, @@ -432,9 +432,9 @@ fn highlight_lines(err: &mut EmitterWriter, let fm = &*lines.file; let mut elided = false; - let mut display_lines = lines.lines.index(&FullRange); + let mut display_lines = &lines.lines[]; if display_lines.len() > MAX_LINES { - display_lines = display_lines.index(&(0u..MAX_LINES)); + display_lines = &display_lines[0u..MAX_LINES]; elided = true; } // Print the offending lines @@ -494,7 +494,7 @@ fn highlight_lines(err: &mut EmitterWriter, } } try!(print_maybe_styled(err, - format!("{}\n", s).index(&FullRange), + &format!("{}\n", s)[], term::attr::ForegroundColor(lvl.color()))); } Ok(()) @@ -514,7 +514,7 @@ fn custom_highlight_lines(w: &mut EmitterWriter, -> io::IoResult<()> { let fm = &*lines.file; - let lines = lines.lines.index(&FullRange); + let lines = &lines.lines[]; if lines.len() > MAX_LINES { if let Some(line) = fm.get_line(lines[0]) { try!(write!(&mut w.dst, "{}:{} {}\n", fm.name, @@ -545,7 +545,7 @@ fn custom_highlight_lines(w: &mut EmitterWriter, s.push('^'); s.push('\n'); print_maybe_styled(w, - s.index(&FullRange), + &s[], term::attr::ForegroundColor(lvl.color())) } @@ -560,12 +560,12 @@ fn print_macro_backtrace(w: &mut EmitterWriter, codemap::MacroAttribute => ("#[", "]"), codemap::MacroBang => ("", "!") }; - try!(print_diagnostic(w, ss.index(&FullRange), Note, - format!("in expansion of {}{}{}", pre, + try!(print_diagnostic(w, &ss[], Note, + &format!("in expansion of {}{}{}", pre, ei.callee.name, - post).index(&FullRange), None)); + post)[], None)); let ss = cm.span_to_string(ei.call_site); - try!(print_diagnostic(w, ss.index(&FullRange), Note, "expansion site", None)); + try!(print_diagnostic(w, &ss[], Note, "expansion site", None)); Ok(Some(ei.call_site)) } None => Ok(None) @@ -578,6 +578,6 @@ pub fn expect<T, M>(diag: &SpanHandler, opt: Option<T>, msg: M) -> T where { match opt { Some(t) => t, - None => diag.handler().bug(msg().index(&FullRange)), + None => diag.handler().bug(&msg()[]), } } diff --git a/src/libsyntax/diagnostics/plugin.rs b/src/libsyntax/diagnostics/plugin.rs index 0f4ebd74b66..1469c50061c 100644 --- a/src/libsyntax/diagnostics/plugin.rs +++ b/src/libsyntax/diagnostics/plugin.rs @@ -56,9 +56,9 @@ pub fn expand_diagnostic_used<'cx>(ecx: &'cx mut ExtCtxt, with_used_diagnostics(|diagnostics| { match diagnostics.insert(code.name, span) { Some(previous_span) => { - ecx.span_warn(span, format!( + ecx.span_warn(span, &format!( "diagnostic code {} already used", token::get_ident(code).get() - ).index(&FullRange)); + )[]); ecx.span_note(previous_span, "previous invocation"); }, None => () @@ -85,14 +85,14 @@ pub fn expand_register_diagnostic<'cx>(ecx: &'cx mut ExtCtxt, }; with_registered_diagnostics(|diagnostics| { if diagnostics.insert(code.name, description).is_some() { - ecx.span_err(span, format!( + ecx.span_err(span, &format!( "diagnostic code {} already registered", token::get_ident(*code).get() - ).index(&FullRange)); + )[]); } }); - let sym = Ident::new(token::gensym(( + let sym = Ident::new(token::gensym(&( "__register_diagnostic_".to_string() + token::get_ident(*code).get() - ).index(&FullRange))); + )[])); MacItems::new(vec![quote_item!(ecx, mod $sym {}).unwrap()].into_iter()) } diff --git a/src/libsyntax/ext/asm.rs b/src/libsyntax/ext/asm.rs index 04dec0e8028..fd3bac5b2fc 100644 --- a/src/libsyntax/ext/asm.rs +++ b/src/libsyntax/ext/asm.rs @@ -99,8 +99,8 @@ pub fn expand_asm<'cx>(cx: &'cx mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) let output = match constraint.get().slice_shift_char() { Some(('=', _)) => None, Some(('+', operand)) => { - Some(token::intern_and_get_ident(format!( - "={}", operand).index(&FullRange))) + Some(token::intern_and_get_ident(&format!( + "={}", operand)[])) } _ => { cx.span_err(span, "output operand constraint lacks '=' or '+'"); diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs index 52e402689ba..9b9d8a9ceb3 100644 --- a/src/libsyntax/ext/base.rs +++ b/src/libsyntax/ext/base.rs @@ -341,9 +341,6 @@ fn initial_syntax_expander_table(ecfg: &expand::ExpansionConfig) -> SyntaxEnv { let mut syntax_expanders = SyntaxEnv::new(); syntax_expanders.insert(intern("macro_rules"), MacroRulesTT); - syntax_expanders.insert(intern("fmt"), - builtin_normal_expander( - ext::fmt::expand_syntax_ext)); syntax_expanders.insert(intern("format_args"), builtin_normal_expander( ext::format::expand_format_args)); @@ -353,9 +350,6 @@ fn initial_syntax_expander_table(ecfg: &expand::ExpansionConfig) -> SyntaxEnv { syntax_expanders.insert(intern("option_env"), builtin_normal_expander( ext::env::expand_option_env)); - syntax_expanders.insert(intern("bytes"), - builtin_normal_expander( - ext::bytes::expand_syntax_ext)); syntax_expanders.insert(intern("concat_idents"), builtin_normal_expander( ext::concat_idents::expand_syntax_ext)); @@ -367,8 +361,6 @@ fn initial_syntax_expander_table(ecfg: &expand::ExpansionConfig) -> SyntaxEnv { ext::log_syntax::expand_syntax_ext)); syntax_expanders.insert(intern("derive"), Decorator(box ext::deriving::expand_meta_derive)); - syntax_expanders.insert(intern("deriving"), - Decorator(box ext::deriving::expand_meta_deriving)); if ecfg.enable_quotes { // Quasi-quoting expanders @@ -416,9 +408,6 @@ fn initial_syntax_expander_table(ecfg: &expand::ExpansionConfig) -> SyntaxEnv { syntax_expanders.insert(intern("include_str"), builtin_normal_expander( ext::source_util::expand_include_str)); - syntax_expanders.insert(intern("include_bin"), - builtin_normal_expander( - ext::source_util::expand_include_bin)); syntax_expanders.insert(intern("include_bytes"), builtin_normal_expander( ext::source_util::expand_include_bytes)); @@ -539,7 +528,7 @@ impl<'a> ExtCtxt<'a> { pub fn mod_pop(&mut self) { self.mod_path.pop().unwrap(); } pub fn mod_path(&self) -> Vec<ast::Ident> { let mut v = Vec::new(); - v.push(token::str_to_ident(self.ecfg.crate_name.index(&FullRange))); + v.push(token::str_to_ident(&self.ecfg.crate_name[])); v.extend(self.mod_path.iter().map(|a| *a)); return v; } @@ -547,8 +536,8 @@ impl<'a> ExtCtxt<'a> { self.recursion_count += 1; if self.recursion_count > self.ecfg.recursion_limit { self.span_fatal(ei.call_site, - format!("recursion limit reached while expanding the macro `{}`", - ei.callee.name).index(&FullRange)); + &format!("recursion limit reached while expanding the macro `{}`", + ei.callee.name)[]); } let mut call_site = ei.call_site; @@ -670,7 +659,7 @@ pub fn check_zero_tts(cx: &ExtCtxt, tts: &[ast::TokenTree], name: &str) { if tts.len() != 0 { - cx.span_err(sp, format!("{} takes no arguments", name).index(&FullRange)); + cx.span_err(sp, &format!("{} takes no arguments", name)[]); } } @@ -683,12 +672,12 @@ pub fn get_single_str_from_tts(cx: &mut ExtCtxt, -> Option<String> { let mut p = cx.new_parser_from_tts(tts); if p.token == token::Eof { - cx.span_err(sp, format!("{} takes 1 argument", name).index(&FullRange)); + cx.span_err(sp, &format!("{} takes 1 argument", name)[]); return None } let ret = cx.expander().fold_expr(p.parse_expr()); if p.token != token::Eof { - cx.span_err(sp, format!("{} takes 1 argument", name).index(&FullRange)); + cx.span_err(sp, &format!("{} takes 1 argument", name)[]); } expr_to_string(cx, ret, "argument must be a string literal").map(|(s, _)| { s.get().to_string() diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs index bd4f295401c..27523ea4535 100644 --- a/src/libsyntax/ext/build.rs +++ b/src/libsyntax/ext/build.rs @@ -708,8 +708,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> { fn expr_fail(&self, span: Span, msg: InternedString) -> P<ast::Expr> { let loc = self.codemap().lookup_char_pos(span.lo); let expr_file = self.expr_str(span, - token::intern_and_get_ident(loc.file - .name.index(&FullRange))); + token::intern_and_get_ident(&loc.file.name[])); let expr_line = self.expr_uint(span, loc.line); let expr_file_line_tuple = self.expr_tuple(span, vec!(expr_file, expr_line)); let expr_file_line_ptr = self.expr_addr_of(span, expr_file_line_tuple); diff --git a/src/libsyntax/ext/bytes.rs b/src/libsyntax/ext/bytes.rs deleted file mode 100644 index 9f225d55b44..00000000000 --- a/src/libsyntax/ext/bytes.rs +++ /dev/null @@ -1,117 +0,0 @@ -// Copyright 2013 The Rust Project Developers. See the COPYRIGHT -// file at the top-level directory of this distribution and at -// http://rust-lang.org/COPYRIGHT. -// -// Licensed under the Apache License, Version 2.0 <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. - -/* The compiler code necessary to support the bytes! extension. */ - -use ast; -use codemap::Span; -use ext::base::*; -use ext::base; -use ext::build::AstBuilder; -use std::ascii::AsciiExt; - -pub fn expand_syntax_ext<'cx>(cx: &'cx mut ExtCtxt, - sp: Span, - tts: &[ast::TokenTree]) - -> Box<base::MacResult+'cx> { - cx.span_warn(sp, "`bytes!` is deprecated, use `b\"foo\"` literals instead"); - cx.parse_sess.span_diagnostic.span_help(sp, - "see http://doc.rust-lang.org/reference.html#byte-and-byte-string-literals \ - for documentation"); - cx.parse_sess.span_diagnostic.span_help(sp, - "see https://github.com/rust-lang/rust/blob/master/src/etc/2014-06-rewrite-bytes-macros.py \ - for an automated migration"); - - // Gather all argument expressions - let exprs = match get_exprs_from_tts(cx, sp, tts) { - None => return DummyResult::expr(sp), - Some(e) => e, - }; - let mut bytes = Vec::new(); - let mut err = false; - - for expr in exprs.iter() { - match expr.node { - // expression is a literal - ast::ExprLit(ref lit) => match lit.node { - // string literal, push each byte to vector expression - ast::LitStr(ref s, _) => { - for byte in s.get().bytes() { - bytes.push(cx.expr_u8(expr.span, byte)); - } - } - - // u8 literal, push to vector expression - ast::LitInt(v, ast::UnsignedIntLit(ast::TyU8)) => { - if v > 0xFF { - cx.span_err(expr.span, "too large u8 literal in bytes!"); - err = true; - } else { - bytes.push(cx.expr_u8(expr.span, v as u8)); - } - } - - // integer literal, push to vector expression - ast::LitInt(_, ast::UnsuffixedIntLit(ast::Minus)) => { - cx.span_err(expr.span, "negative integer literal in bytes!"); - err = true; - } - ast::LitInt(v, ast::UnsuffixedIntLit(ast::Plus)) => { - if v > 0xFF { - cx.span_err(expr.span, "too large integer literal in bytes!"); - err = true; - } else { - bytes.push(cx.expr_u8(expr.span, v as u8)); - } - } - - // char literal, push to vector expression - ast::LitChar(v) => { - if v.is_ascii() { - bytes.push(cx.expr_u8(expr.span, v as u8)); - } else { - cx.span_err(expr.span, "non-ascii char literal in bytes!"); - err = true; - } - } - - _ => { - cx.span_err(expr.span, "unsupported literal in bytes!"); - err = true; - } - }, - - _ => { - cx.span_err(expr.span, "non-literal in bytes!"); - err = true; - } - } - } - - // For some reason using quote_expr!() here aborts if we threw an error. - // I'm assuming that the end of the recursive parse tricks the compiler - // into thinking this is a good time to stop. But we'd rather keep going. - if err { - // Since the compiler will stop after the macro expansion phase anyway, we - // don't need type info, so we can just return a DummyResult - return DummyResult::expr(sp); - } - - let len = bytes.len(); - let e = cx.expr_vec(sp, bytes); - let ty = cx.ty(sp, ast::TyFixedLengthVec(cx.ty_ident(sp, cx.ident_of("u8")), - cx.expr_uint(sp, len))); - let item = cx.item_static(sp, cx.ident_of("BYTES"), ty, ast::MutImmutable, e); - let ret = cx.expr_ident(sp, cx.ident_of("BYTES")); - let ret = cx.expr_addr_of(sp, ret); - let e = cx.expr_block(cx.block(sp, vec![cx.stmt_item(sp, item)], - Some(ret))); - MacExpr::new(e) -} diff --git a/src/libsyntax/ext/concat.rs b/src/libsyntax/ext/concat.rs index 1f1781dceb3..39895a3946a 100644 --- a/src/libsyntax/ext/concat.rs +++ b/src/libsyntax/ext/concat.rs @@ -40,14 +40,14 @@ pub fn expand_syntax_ext(cx: &mut base::ExtCtxt, ast::LitInt(i, ast::UnsignedIntLit(_)) | ast::LitInt(i, ast::SignedIntLit(_, ast::Plus)) | ast::LitInt(i, ast::UnsuffixedIntLit(ast::Plus)) => { - accumulator.push_str(format!("{}", i).index(&FullRange)); + accumulator.push_str(&format!("{}", i)[]); } ast::LitInt(i, ast::SignedIntLit(_, ast::Minus)) | ast::LitInt(i, ast::UnsuffixedIntLit(ast::Minus)) => { - accumulator.push_str(format!("-{}", i).index(&FullRange)); + accumulator.push_str(&format!("-{}", i)[]); } ast::LitBool(b) => { - accumulator.push_str(format!("{}", b).index(&FullRange)); + accumulator.push_str(&format!("{}", b)[]); } ast::LitByte(..) | ast::LitBinary(..) => { @@ -62,5 +62,5 @@ pub fn expand_syntax_ext(cx: &mut base::ExtCtxt, } base::MacExpr::new(cx.expr_str( sp, - token::intern_and_get_ident(accumulator.index(&FullRange)))) + token::intern_and_get_ident(&accumulator[]))) } diff --git a/src/libsyntax/ext/concat_idents.rs b/src/libsyntax/ext/concat_idents.rs index 02f702248cb..1af3ba1d326 100644 --- a/src/libsyntax/ext/concat_idents.rs +++ b/src/libsyntax/ext/concat_idents.rs @@ -40,7 +40,7 @@ pub fn expand_syntax_ext<'cx>(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree] } } } - let res = str_to_ident(res_str.index(&FullRange)); + let res = str_to_ident(&res_str[]); let e = P(ast::Expr { id: ast::DUMMY_NODE_ID, diff --git a/src/libsyntax/ext/deriving/clone.rs b/src/libsyntax/ext/deriving/clone.rs index d9d6cebd05c..784a92b9a0e 100644 --- a/src/libsyntax/ext/deriving/clone.rs +++ b/src/libsyntax/ext/deriving/clone.rs @@ -79,12 +79,12 @@ fn cs_clone( }, EnumNonMatchingCollapsed (..) => { cx.span_bug(trait_span, - format!("non-matching enum variants in \ - `deriving({})`", name).index(&FullRange)) + &format!("non-matching enum variants in \ + `deriving({})`", name)[]) } StaticEnum(..) | StaticStruct(..) => { cx.span_bug(trait_span, - format!("static method in `deriving({})`", name).index(&FullRange)) + &format!("static method in `deriving({})`", name)[]) } } @@ -100,8 +100,8 @@ fn cs_clone( Some(i) => i, None => { cx.span_bug(trait_span, - format!("unnamed field in normal struct in \ - `deriving({})`", name).index(&FullRange)) + &format!("unnamed field in normal struct in \ + `deriving({})`", name)[]) } }; cx.field_imm(field.span, ident, subcall(field)) diff --git a/src/libsyntax/ext/deriving/decodable.rs b/src/libsyntax/ext/deriving/decodable.rs index a9289f0175a..7c65d2b4ff4 100644 --- a/src/libsyntax/ext/deriving/decodable.rs +++ b/src/libsyntax/ext/deriving/decodable.rs @@ -197,8 +197,7 @@ fn decode_static_fields<F>(cx: &mut ExtCtxt, } else { let fields = fields.iter().enumerate().map(|(i, &span)| { getarg(cx, span, - token::intern_and_get_ident(format!("_field{}", - i).index(&FullRange)), + token::intern_and_get_ident(&format!("_field{}", i)[]), i) }).collect(); diff --git a/src/libsyntax/ext/deriving/encodable.rs b/src/libsyntax/ext/deriving/encodable.rs index 7114217d51d..616390467f0 100644 --- a/src/libsyntax/ext/deriving/encodable.rs +++ b/src/libsyntax/ext/deriving/encodable.rs @@ -183,7 +183,7 @@ fn encodable_substructure(cx: &mut ExtCtxt, trait_span: Span, let name = match name { Some(id) => token::get_ident(id), None => { - token::intern_and_get_ident(format!("_field{}", i).index(&FullRange)) + token::intern_and_get_ident(&format!("_field{}", i)[]) } }; let enc = cx.expr_method_call(span, self_.clone(), diff --git a/src/libsyntax/ext/deriving/generic/mod.rs b/src/libsyntax/ext/deriving/generic/mod.rs index 50b3559f369..47b29a4db3e 100644 --- a/src/libsyntax/ext/deriving/generic/mod.rs +++ b/src/libsyntax/ext/deriving/generic/mod.rs @@ -510,15 +510,15 @@ impl<'a> TraitDef<'a> { self, struct_def, type_ident, - self_args.index(&FullRange), - nonself_args.index(&FullRange)) + &self_args[], + &nonself_args[]) } else { method_def.expand_struct_method_body(cx, self, struct_def, type_ident, - self_args.index(&FullRange), - nonself_args.index(&FullRange)) + &self_args[], + &nonself_args[]) }; method_def.create_method(cx, @@ -550,15 +550,15 @@ impl<'a> TraitDef<'a> { self, enum_def, type_ident, - self_args.index(&FullRange), - nonself_args.index(&FullRange)) + &self_args[], + &nonself_args[]) } else { method_def.expand_enum_method_body(cx, self, enum_def, type_ident, self_args, - nonself_args.index(&FullRange)) + &nonself_args[]) }; method_def.create_method(cx, @@ -645,7 +645,7 @@ impl<'a> MethodDef<'a> { for (i, ty) in self.args.iter().enumerate() { let ast_ty = ty.to_ty(cx, trait_.span, type_ident, generics); - let ident = cx.ident_of(format!("__arg_{}", i).index(&FullRange)); + let ident = cx.ident_of(&format!("__arg_{}", i)[]); arg_tys.push((ident, ast_ty)); let arg_expr = cx.expr_ident(trait_.span, ident); @@ -751,8 +751,8 @@ impl<'a> MethodDef<'a> { trait_.create_struct_pattern(cx, struct_path, struct_def, - format!("__self_{}", - i).index(&FullRange), + &format!("__self_{}", + i)[], ast::MutImmutable); patterns.push(pat); raw_fields.push(ident_expr); @@ -908,22 +908,22 @@ impl<'a> MethodDef<'a> { .collect::<Vec<String>>(); let self_arg_idents = self_arg_names.iter() - .map(|name|cx.ident_of(name.index(&FullRange))) + .map(|name|cx.ident_of(&name[])) .collect::<Vec<ast::Ident>>(); // The `vi_idents` will be bound, solely in the catch-all, to // a series of let statements mapping each self_arg to a uint // corresponding to its variant index. let vi_idents: Vec<ast::Ident> = self_arg_names.iter() - .map(|name| { let vi_suffix = format!("{}_vi", name.index(&FullRange)); - cx.ident_of(vi_suffix.index(&FullRange)) }) + .map(|name| { let vi_suffix = format!("{}_vi", &name[]); + cx.ident_of(&vi_suffix[]) }) .collect::<Vec<ast::Ident>>(); // Builds, via callback to call_substructure_method, the // delegated expression that handles the catch-all case, // using `__variants_tuple` to drive logic if necessary. let catch_all_substructure = EnumNonMatchingCollapsed( - self_arg_idents, variants.index(&FullRange), vi_idents.index(&FullRange)); + self_arg_idents, &variants[], &vi_idents[]); // These arms are of the form: // (Variant1, Variant1, ...) => Body1 @@ -945,12 +945,12 @@ impl<'a> MethodDef<'a> { let mut subpats = Vec::with_capacity(self_arg_names.len()); let mut self_pats_idents = Vec::with_capacity(self_arg_names.len() - 1); let first_self_pat_idents = { - let (p, idents) = mk_self_pat(cx, self_arg_names[0].index(&FullRange)); + let (p, idents) = mk_self_pat(cx, &self_arg_names[0][]); subpats.push(p); idents }; for self_arg_name in self_arg_names.tail().iter() { - let (p, idents) = mk_self_pat(cx, self_arg_name.index(&FullRange)); + let (p, idents) = mk_self_pat(cx, &self_arg_name[]); subpats.push(p); self_pats_idents.push(idents); } @@ -1006,7 +1006,7 @@ impl<'a> MethodDef<'a> { &**variant, field_tuples); let arm_expr = self.call_substructure_method( - cx, trait_, type_ident, self_args.index(&FullRange), nonself_args, + cx, trait_, type_ident, &self_args[], nonself_args, &substructure); cx.arm(sp, vec![single_pat], arm_expr) @@ -1059,7 +1059,7 @@ impl<'a> MethodDef<'a> { } let arm_expr = self.call_substructure_method( - cx, trait_, type_ident, self_args.index(&FullRange), nonself_args, + cx, trait_, type_ident, &self_args[], nonself_args, &catch_all_substructure); // Builds the expression: @@ -1263,7 +1263,7 @@ impl<'a> TraitDef<'a> { cx.span_bug(sp, "a struct with named and unnamed fields in `derive`"); } }; - let ident = cx.ident_of(format!("{}_{}", prefix, i).index(&FullRange)); + let ident = cx.ident_of(&format!("{}_{}", prefix, i)[]); paths.push(codemap::Spanned{span: sp, node: ident}); let val = cx.expr( sp, ast::ExprParen(cx.expr_deref(sp, cx.expr_path(cx.path_ident(sp,ident))))); @@ -1309,7 +1309,7 @@ impl<'a> TraitDef<'a> { let mut ident_expr = Vec::new(); for (i, va) in variant_args.iter().enumerate() { let sp = self.set_expn_info(cx, va.ty.span); - let ident = cx.ident_of(format!("{}_{}", prefix, i).index(&FullRange)); + let ident = cx.ident_of(&format!("{}_{}", prefix, i)[]); let path1 = codemap::Spanned{span: sp, node: ident}; paths.push(path1); let expr_path = cx.expr_path(cx.path_ident(sp, ident)); @@ -1352,7 +1352,7 @@ pub fn cs_fold<F>(use_foldl: bool, field.span, old, field.self_.clone(), - field.other.index(&FullRange)) + &field.other[]) }) } else { all_fields.iter().rev().fold(base, |old, field| { @@ -1360,12 +1360,12 @@ pub fn cs_fold<F>(use_foldl: bool, field.span, old, field.self_.clone(), - field.other.index(&FullRange)) + &field.other[]) }) } }, EnumNonMatchingCollapsed(ref all_args, _, tuple) => - enum_nonmatch_f(cx, trait_span, (all_args.index(&FullRange), tuple), + enum_nonmatch_f(cx, trait_span, (&all_args[], tuple), substructure.nonself_args), StaticEnum(..) | StaticStruct(..) => { cx.span_bug(trait_span, "static function in `derive`") @@ -1405,7 +1405,7 @@ pub fn cs_same_method<F>(f: F, f(cx, trait_span, called) }, EnumNonMatchingCollapsed(ref all_self_args, _, tuple) => - enum_nonmatch_f(cx, trait_span, (all_self_args.index(&FullRange), tuple), + enum_nonmatch_f(cx, trait_span, (&all_self_args[], tuple), substructure.nonself_args), StaticEnum(..) | StaticStruct(..) => { cx.span_bug(trait_span, "static function in `derive`") diff --git a/src/libsyntax/ext/deriving/hash.rs b/src/libsyntax/ext/deriving/hash.rs index 844bd80d161..db99c142443 100644 --- a/src/libsyntax/ext/deriving/hash.rs +++ b/src/libsyntax/ext/deriving/hash.rs @@ -30,7 +30,8 @@ pub fn expand_deriving_hash<F>(cx: &mut ExtCtxt, let generics = LifetimeBounds { lifetimes: Vec::new(), bounds: vec!(("__S", - vec!(Path::new(vec!("std", "hash", "Writer"))))), + vec!(Path::new(vec!("std", "hash", "Writer")), + Path::new(vec!("std", "hash", "Hasher"))))), }; let args = Path::new_local("__S"); let inline = cx.meta_word(span, InternedString::new("inline")); diff --git a/src/libsyntax/ext/deriving/mod.rs b/src/libsyntax/ext/deriving/mod.rs index 43a0e0606f8..603c4478007 100644 --- a/src/libsyntax/ext/deriving/mod.rs +++ b/src/libsyntax/ext/deriving/mod.rs @@ -40,16 +40,6 @@ pub mod totalord; pub mod generic; -pub fn expand_meta_deriving(cx: &mut ExtCtxt, - _span: Span, - mitem: &MetaItem, - item: &Item, - push: Box<FnMut(P<Item>)>) { - cx.span_warn(mitem.span, "`deriving` is deprecated; use `derive`"); - - expand_meta_derive(cx, _span, mitem, item, push) -} - pub fn expand_meta_derive(cx: &mut ExtCtxt, _span: Span, mitem: &MetaItem, @@ -121,9 +111,9 @@ pub fn expand_meta_derive(cx: &mut ExtCtxt, ref tname => { cx.span_err(titem.span, - format!("unknown `derive` \ + &format!("unknown `derive` \ trait: `{}`", - *tname).index(&FullRange)); + *tname)[]); } }; } diff --git a/src/libsyntax/ext/deriving/show.rs b/src/libsyntax/ext/deriving/show.rs index fa9a7899a12..48034ce50ab 100644 --- a/src/libsyntax/ext/deriving/show.rs +++ b/src/libsyntax/ext/deriving/show.rs @@ -127,7 +127,7 @@ fn show_substructure(cx: &mut ExtCtxt, span: Span, let formatter = substr.nonself_args[0].clone(); let meth = cx.ident_of("write_fmt"); - let s = token::intern_and_get_ident(format_string.index(&FullRange)); + let s = token::intern_and_get_ident(&format_string[]); let format_string = cx.expr_str(span, s); // phew, not our responsibility any more! diff --git a/src/libsyntax/ext/env.rs b/src/libsyntax/ext/env.rs index eb3544e3c5c..9b54e259761 100644 --- a/src/libsyntax/ext/env.rs +++ b/src/libsyntax/ext/env.rs @@ -30,7 +30,7 @@ pub fn expand_option_env<'cx>(cx: &'cx mut ExtCtxt, sp: Span, tts: &[ast::TokenT Some(v) => v }; - let e = match os::getenv(var.index(&FullRange)) { + let e = match os::getenv(&var[]) { None => { cx.expr_path(cx.path_all(sp, true, @@ -56,7 +56,7 @@ pub fn expand_option_env<'cx>(cx: &'cx mut ExtCtxt, sp: Span, tts: &[ast::TokenT cx.ident_of("Some")), vec!(cx.expr_str(sp, token::intern_and_get_ident( - s.index(&FullRange))))) + &s[])))) } }; MacExpr::new(e) @@ -81,9 +81,9 @@ pub fn expand_env<'cx>(cx: &'cx mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) }; let msg = match exprs.next() { None => { - token::intern_and_get_ident(format!("environment variable `{}` \ + token::intern_and_get_ident(&format!("environment variable `{}` \ not defined", - var).index(&FullRange)) + var)[]) } Some(second) => { match expr_to_string(cx, second, "expected string literal") { @@ -106,7 +106,7 @@ pub fn expand_env<'cx>(cx: &'cx mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) cx.span_err(sp, msg.get()); cx.expr_uint(sp, 0) } - Some(s) => cx.expr_str(sp, token::intern_and_get_ident(s.index(&FullRange))) + Some(s) => cx.expr_str(sp, token::intern_and_get_ident(&s[])) }; MacExpr::new(e) } diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs index 3e1bccf394a..9ef996ac317 100644 --- a/src/libsyntax/ext/expand.rs +++ b/src/libsyntax/ext/expand.rs @@ -286,8 +286,8 @@ fn expand_mac_invoc<T, F, G>(mac: ast::Mac, span: codemap::Span, None => { fld.cx.span_err( pth.span, - format!("macro undefined: '{}!'", - extnamestr.get()).index(&FullRange)); + &format!("macro undefined: '{}!'", + extnamestr.get())[]); // let compilation continue None @@ -303,7 +303,7 @@ fn expand_mac_invoc<T, F, G>(mac: ast::Mac, span: codemap::Span, }, }); let fm = fresh_mark(); - let marked_before = mark_tts(tts.index(&FullRange), fm); + let marked_before = mark_tts(&tts[], fm); // The span that we pass to the expanders we want to // be the root of the call stack. That's the most @@ -314,7 +314,7 @@ fn expand_mac_invoc<T, F, G>(mac: ast::Mac, span: codemap::Span, let opt_parsed = { let expanded = expandfun.expand(fld.cx, mac_span, - marked_before.index(&FullRange)); + &marked_before[]); parse_thunk(expanded) }; let parsed = match opt_parsed { @@ -322,9 +322,9 @@ fn expand_mac_invoc<T, F, G>(mac: ast::Mac, span: codemap::Span, None => { fld.cx.span_err( pth.span, - format!("non-expression macro in expression position: {}", - extnamestr.get().index(&FullRange) - ).index(&FullRange)); + &format!("non-expression macro in expression position: {}", + &extnamestr.get()[] + )[]); return None; } }; @@ -333,8 +333,8 @@ fn expand_mac_invoc<T, F, G>(mac: ast::Mac, span: codemap::Span, _ => { fld.cx.span_err( pth.span, - format!("'{}' is not a tt-style macro", - extnamestr.get()).index(&FullRange)); + &format!("'{}' is not a tt-style macro", + extnamestr.get())[]); None } } @@ -439,7 +439,7 @@ pub fn expand_item(it: P<ast::Item>, fld: &mut MacroExpander) if valid_ident { fld.cx.mod_push(it.ident); } - let macro_use = contains_macro_use(fld, new_attrs.index(&FullRange)); + let macro_use = contains_macro_use(fld, &new_attrs[]); let result = with_exts_frame!(fld.cx.syntax_env, macro_use, noop_fold_item(it, fld)); @@ -565,8 +565,8 @@ pub fn expand_item_mac(it: P<ast::Item>, let expanded = match fld.cx.syntax_env.find(&extname.name) { None => { fld.cx.span_err(path_span, - format!("macro undefined: '{}!'", - extnamestr).index(&FullRange)); + &format!("macro undefined: '{}!'", + extnamestr)[]); // let compilation continue return SmallVector::zero(); } @@ -576,10 +576,10 @@ pub fn expand_item_mac(it: P<ast::Item>, if it.ident.name != parse::token::special_idents::invalid.name { fld.cx .span_err(path_span, - format!("macro {}! expects no ident argument, \ + &format!("macro {}! expects no ident argument, \ given '{}'", extnamestr, - token::get_ident(it.ident)).index(&FullRange)); + token::get_ident(it.ident))[]); return SmallVector::zero(); } fld.cx.bt_push(ExpnInfo { @@ -591,14 +591,14 @@ pub fn expand_item_mac(it: P<ast::Item>, } }); // mark before expansion: - let marked_before = mark_tts(tts.index(&FullRange), fm); - expander.expand(fld.cx, it.span, marked_before.index(&FullRange)) + let marked_before = mark_tts(&tts[], fm); + expander.expand(fld.cx, it.span, &marked_before[]) } IdentTT(ref expander, span) => { if it.ident.name == parse::token::special_idents::invalid.name { fld.cx.span_err(path_span, - format!("macro {}! expects an ident argument", - extnamestr.get()).index(&FullRange)); + &format!("macro {}! expects an ident argument", + extnamestr.get())[]); return SmallVector::zero(); } fld.cx.bt_push(ExpnInfo { @@ -610,14 +610,14 @@ pub fn expand_item_mac(it: P<ast::Item>, } }); // mark before expansion: - let marked_tts = mark_tts(tts.index(&FullRange), fm); + let marked_tts = mark_tts(&tts[], fm); expander.expand(fld.cx, it.span, it.ident, marked_tts) } MacroRulesTT => { if it.ident.name == parse::token::special_idents::invalid.name { fld.cx.span_err(path_span, - format!("macro_rules! expects an ident argument") - .index(&FullRange)); + &format!("macro_rules! expects an ident argument") + []); return SmallVector::zero(); } fld.cx.bt_push(ExpnInfo { @@ -648,8 +648,8 @@ pub fn expand_item_mac(it: P<ast::Item>, } _ => { fld.cx.span_err(it.span, - format!("{}! is not legal in item position", - extnamestr.get()).index(&FullRange)); + &format!("{}! is not legal in item position", + extnamestr.get())[]); return SmallVector::zero(); } } @@ -667,8 +667,8 @@ pub fn expand_item_mac(it: P<ast::Item>, } None => { fld.cx.span_err(path_span, - format!("non-item macro in item position: {}", - extnamestr.get()).index(&FullRange)); + &format!("non-item macro in item position: {}", + extnamestr.get())[]); return SmallVector::zero(); } }; @@ -913,8 +913,8 @@ fn expand_pat(p: P<ast::Pat>, fld: &mut MacroExpander) -> P<ast::Pat> { let marked_after = match fld.cx.syntax_env.find(&extname.name) { None => { fld.cx.span_err(pth.span, - format!("macro undefined: '{}!'", - extnamestr).index(&FullRange)); + &format!("macro undefined: '{}!'", + extnamestr)[]); // let compilation continue return DummyResult::raw_pat(span); } @@ -931,19 +931,19 @@ fn expand_pat(p: P<ast::Pat>, fld: &mut MacroExpander) -> P<ast::Pat> { }); let fm = fresh_mark(); - let marked_before = mark_tts(tts.index(&FullRange), fm); + let marked_before = mark_tts(&tts[], fm); let mac_span = fld.cx.original_span(); let expanded = match expander.expand(fld.cx, mac_span, - marked_before.index(&FullRange)).make_pat() { + &marked_before[]).make_pat() { Some(e) => e, None => { fld.cx.span_err( pth.span, - format!( + &format!( "non-pattern macro in pattern position: {}", extnamestr.get() - ).index(&FullRange) + )[] ); return DummyResult::raw_pat(span); } @@ -954,8 +954,8 @@ fn expand_pat(p: P<ast::Pat>, fld: &mut MacroExpander) -> P<ast::Pat> { } _ => { fld.cx.span_err(span, - format!("{}! is not legal in pattern position", - extnamestr.get()).index(&FullRange)); + &format!("{}! is not legal in pattern position", + extnamestr.get())[]); return DummyResult::raw_pat(span); } } @@ -1232,7 +1232,7 @@ impl Folder for Marker { node: match node { MacInvocTT(path, tts, ctxt) => { MacInvocTT(self.fold_path(path), - self.fold_tts(tts.index(&FullRange)), + self.fold_tts(&tts[]), mtwt::apply_mark(self.mark, ctxt)) } }, @@ -1295,7 +1295,7 @@ impl<'a, 'v> Visitor<'v> for MacroExterminator<'a> { #[cfg(test)] mod test { - use super::{pattern_bindings, expand_crate, contains_macro_use}; + use super::{pattern_bindings, expand_crate}; use super::{PatIdentFinder, IdentRenamer, PatIdentRenamer, ExpansionConfig}; use ast; use ast::{Attribute_, AttrOuter, MetaWord, Name}; @@ -1404,22 +1404,6 @@ mod test { expand_crate(&sess, test_ecfg(), vec!(), vec!(), crate_ast); } - // make a MetaWord outer attribute with the given name - fn make_dummy_attr(s: &str) -> ast::Attribute { - Spanned { - span:codemap::DUMMY_SP, - node: Attribute_ { - id: attr::mk_attr_id(), - style: AttrOuter, - value: P(Spanned { - node: MetaWord(token::intern_and_get_ident(s)), - span: codemap::DUMMY_SP, - }), - is_sugared_doc: false, - } - } - } - fn expand_crate_str(crate_str: String) -> ast::Crate { let ps = parse::new_parse_sess(); let crate_ast = string_to_parser(&ps, crate_str).parse_crate_mod(); @@ -1655,7 +1639,7 @@ mod test { let varref_idents : Vec<ast::Ident> = varref.segments.iter().map(|s| s.identifier) .collect(); - println!("varref #{}: {}, resolves to {}",idx, varref_idents, varref_name); + println!("varref #{}: {:?}, resolves to {}",idx, varref_idents, varref_name); let string = token::get_ident(final_varref_ident); println!("varref's first segment's string: \"{}\"", string.get()); println!("binding #{}: {}, resolves to {}", @@ -1713,7 +1697,7 @@ foo_module!(); let string = ident.get(); "xx" == string }).collect(); - let cxbinds: &[&ast::Ident] = cxbinds.index(&FullRange); + let cxbinds: &[&ast::Ident] = &cxbinds[]; let cxbind = match cxbinds { [b] => b, _ => panic!("expected just one binding for ext_cx") diff --git a/src/libsyntax/ext/fmt.rs b/src/libsyntax/ext/fmt.rs deleted file mode 100644 index 5352cfaf749..00000000000 --- a/src/libsyntax/ext/fmt.rs +++ /dev/null @@ -1,29 +0,0 @@ -// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT -// file at the top-level directory of this distribution and at -// http://rust-lang.org/COPYRIGHT. -// -// Licensed under the Apache License, Version 2.0 <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. - -/// Deprecated fmt! syntax extension - -use ast; -use codemap::Span; -use ext::base; -use ext::build::AstBuilder; - - -pub fn expand_syntax_ext(ecx: &mut base::ExtCtxt, - sp: Span, - _tts: &[ast::TokenTree]) - -> Box<base::MacResult+'static> { - ecx.span_err(sp, "`fmt!` is deprecated, use `format!` instead"); - ecx.parse_sess.span_diagnostic.span_note(sp, - "see http://doc.rust-lang.org/std/fmt/ \ - for documentation"); - - base::MacExpr::new(ecx.expr_uint(sp, 2)) -} diff --git a/src/libsyntax/ext/format.rs b/src/libsyntax/ext/format.rs index 44a596d2657..637b6d4649d 100644 --- a/src/libsyntax/ext/format.rs +++ b/src/libsyntax/ext/format.rs @@ -112,8 +112,8 @@ fn parse_args(ecx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) } _ => { ecx.span_err(p.span, - format!("expected ident for named argument, found `{}`", - p.this_token_to_string()).index(&FullRange)); + &format!("expected ident for named argument, found `{}`", + p.this_token_to_string())[]); return None; } }; @@ -125,8 +125,8 @@ fn parse_args(ecx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) None => {} Some(prev) => { ecx.span_err(e.span, - format!("duplicate argument named `{}`", - name).index(&FullRange)); + &format!("duplicate argument named `{}`", + name)[]); ecx.parse_sess.span_diagnostic.span_note(prev.span, "previously here"); continue } @@ -217,7 +217,7 @@ impl<'a, 'b> Context<'a, 'b> { let msg = format!("invalid reference to argument `{}` ({})", arg, self.describe_num_args()); - self.ecx.span_err(self.fmtsp, msg.index(&FullRange)); + self.ecx.span_err(self.fmtsp, &msg[]); return; } { @@ -237,7 +237,7 @@ impl<'a, 'b> Context<'a, 'b> { Some(e) => e.span, None => { let msg = format!("there is no argument named `{}`", name); - self.ecx.span_err(self.fmtsp, msg.index(&FullRange)); + self.ecx.span_err(self.fmtsp, &msg[]); return; } }; @@ -277,22 +277,22 @@ impl<'a, 'b> Context<'a, 'b> { match (cur, ty) { (&Known(ref cur), &Known(ref ty)) => { self.ecx.span_err(sp, - format!("argument redeclared with type `{}` when \ + &format!("argument redeclared with type `{}` when \ it was previously `{}`", *ty, - *cur).index(&FullRange)); + *cur)[]); } (&Known(ref cur), _) => { self.ecx.span_err(sp, - format!("argument used to format with `{}` was \ + &format!("argument used to format with `{}` was \ attempted to not be used for formatting", - *cur).index(&FullRange)); + *cur)[]); } (_, &Known(ref ty)) => { self.ecx.span_err(sp, - format!("argument previously used as a format \ + &format!("argument previously used as a format \ argument attempted to be used as `{}`", - *ty).index(&FullRange)); + *ty)[]); } (_, _) => { self.ecx.span_err(sp, "argument declared with multiple formats"); @@ -357,7 +357,7 @@ impl<'a, 'b> Context<'a, 'b> { /// Translate the accumulated string literals to a literal expression fn trans_literal_string(&mut self) -> P<ast::Expr> { let sp = self.fmtsp; - let s = token::intern_and_get_ident(self.literal.index(&FullRange)); + let s = token::intern_and_get_ident(&self.literal[]); self.literal.clear(); self.ecx.expr_str(sp, s) } @@ -509,7 +509,7 @@ impl<'a, 'b> Context<'a, 'b> { None => continue // error already generated }; - let name = self.ecx.ident_of(format!("__arg{}", i).index(&FullRange)); + let name = self.ecx.ident_of(&format!("__arg{}", i)[]); pats.push(self.ecx.pat_ident(e.span, name)); locals.push(Context::format_arg(self.ecx, e.span, arg_ty, self.ecx.expr_ident(e.span, name))); @@ -525,8 +525,8 @@ impl<'a, 'b> Context<'a, 'b> { None => continue }; - let lname = self.ecx.ident_of(format!("__arg{}", - *name).index(&FullRange)); + let lname = self.ecx.ident_of(&format!("__arg{}", + *name)[]); pats.push(self.ecx.pat_ident(e.span, lname)); names[self.name_positions[*name]] = Some(Context::format_arg(self.ecx, e.span, arg_ty, @@ -606,7 +606,7 @@ impl<'a, 'b> Context<'a, 'b> { -> P<ast::Expr> { let trait_ = match *ty { Known(ref tyname) => { - match tyname.index(&FullRange) { + match &tyname[] { "" => "String", "?" => "Show", "e" => "LowerExp", @@ -618,8 +618,8 @@ impl<'a, 'b> Context<'a, 'b> { "X" => "UpperHex", _ => { ecx.span_err(sp, - format!("unknown format trait `{}`", - *tyname).index(&FullRange)); + &format!("unknown format trait `{}`", + *tyname)[]); "Dummy" } } @@ -709,8 +709,8 @@ pub fn expand_preparsed_format_args(ecx: &mut ExtCtxt, sp: Span, } } if !parser.errors.is_empty() { - cx.ecx.span_err(cx.fmtsp, format!("invalid format string: {}", - parser.errors.remove(0)).index(&FullRange)); + cx.ecx.span_err(cx.fmtsp, &format!("invalid format string: {}", + parser.errors.remove(0))[]); return DummyResult::raw_expr(sp); } if !cx.literal.is_empty() { diff --git a/src/libsyntax/ext/mtwt.rs b/src/libsyntax/ext/mtwt.rs index bebd803ac4f..ae8ff118fcc 100644 --- a/src/libsyntax/ext/mtwt.rs +++ b/src/libsyntax/ext/mtwt.rs @@ -223,7 +223,7 @@ pub fn marksof(ctxt: SyntaxContext, stopname: Name) -> Vec<Mrk> { } // the internal function for computing marks -// it's not clear to me whether it's better to use a .index(&FullRange) mutable +// it's not clear to me whether it's better to use a [] mutable // vector or a cons-list for this. fn marksof_internal(ctxt: SyntaxContext, stopname: Name, diff --git a/src/libsyntax/ext/quote.rs b/src/libsyntax/ext/quote.rs index 77aea0c370a..2dbf29c145c 100644 --- a/src/libsyntax/ext/quote.rs +++ b/src/libsyntax/ext/quote.rs @@ -473,7 +473,7 @@ pub fn expand_quote_stmt(cx: &mut ExtCtxt, } fn ids_ext(strs: Vec<String> ) -> Vec<ast::Ident> { - strs.iter().map(|str| str_to_ident((*str).index(&FullRange))).collect() + strs.iter().map(|str| str_to_ident(&(*str)[])).collect() } fn id_ext(str: &str) -> ast::Ident { @@ -675,7 +675,7 @@ fn mk_tt(cx: &ExtCtxt, tt: &ast::TokenTree) -> Vec<P<ast::Stmt>> { for i in range(0, tt.len()) { seq.push(tt.get_tt(i)); } - mk_tts(cx, seq.index(&FullRange)) + mk_tts(cx, &seq[]) } ast::TtToken(sp, ref tok) => { let e_sp = cx.expr_ident(sp, id_ext("_sp")); @@ -764,7 +764,7 @@ fn expand_tts(cx: &ExtCtxt, sp: Span, tts: &[ast::TokenTree]) let stmt_let_tt = cx.stmt_let(sp, true, id_ext("tt"), cx.expr_vec_ng(sp)); let mut vector = vec!(stmt_let_sp, stmt_let_tt); - vector.extend(mk_tts(cx, tts.index(&FullRange)).into_iter()); + vector.extend(mk_tts(cx, &tts[]).into_iter()); let block = cx.expr_block( cx.block_all(sp, Vec::new(), diff --git a/src/libsyntax/ext/source_util.rs b/src/libsyntax/ext/source_util.rs index 1ba91dd371c..31a1a838b13 100644 --- a/src/libsyntax/ext/source_util.rs +++ b/src/libsyntax/ext/source_util.rs @@ -57,7 +57,7 @@ pub fn expand_file(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) let topmost = cx.original_span_in_file(); let loc = cx.codemap().lookup_char_pos(topmost.lo); - let filename = token::intern_and_get_ident(loc.file.name.index(&FullRange)); + let filename = token::intern_and_get_ident(&loc.file.name[]); base::MacExpr::new(cx.expr_str(topmost, filename)) } @@ -65,7 +65,7 @@ pub fn expand_stringify(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) -> Box<base::MacResult+'static> { let s = pprust::tts_to_string(tts); base::MacExpr::new(cx.expr_str(sp, - token::intern_and_get_ident(s.index(&FullRange)))) + token::intern_and_get_ident(&s[]))) } pub fn expand_mod(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) @@ -78,7 +78,7 @@ pub fn expand_mod(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) .connect("::"); base::MacExpr::new(cx.expr_str( sp, - token::intern_and_get_ident(string.index(&FullRange)))) + token::intern_and_get_ident(&string[]))) } /// include! : parse the given file as an expr @@ -135,9 +135,9 @@ pub fn expand_include_str(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) let bytes = match File::open(&file).read_to_end() { Err(e) => { cx.span_err(sp, - format!("couldn't read {:?}: {}", + &format!("couldn't read {:?}: {}", file.display(), - e).index(&FullRange)); + e)[]); return DummyResult::expr(sp); } Ok(bytes) => bytes, @@ -147,26 +147,20 @@ pub fn expand_include_str(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) // Add this input file to the code map to make it available as // dependency information let filename = format!("{:?}", file.display()); - let interned = token::intern_and_get_ident(src.index(&FullRange)); + let interned = token::intern_and_get_ident(&src[]); cx.codemap().new_filemap(filename, src); base::MacExpr::new(cx.expr_str(sp, interned)) } Err(_) => { cx.span_err(sp, - format!("{:?} wasn't a utf-8 file", - file.display()).index(&FullRange)); + &format!("{:?} wasn't a utf-8 file", + file.display())[]); return DummyResult::expr(sp); } } } -pub fn expand_include_bin(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) - -> Box<base::MacResult+'static> { - cx.span_warn(sp, "include_bin! is deprecated; use include_bytes! instead"); - expand_include_bytes(cx, sp, tts) -} - pub fn expand_include_bytes(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) -> Box<base::MacResult+'static> { let file = match get_single_str_from_tts(cx, sp, tts, "include_bytes!") { @@ -177,7 +171,7 @@ pub fn expand_include_bytes(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) match File::open(&file).read_to_end() { Err(e) => { cx.span_err(sp, - format!("couldn't read {:?}: {}", file.display(), e).index(&FullRange)); + &format!("couldn't read {:?}: {}", file.display(), e)[]); return DummyResult::expr(sp); } Ok(bytes) => { diff --git a/src/libsyntax/ext/tt/macro_parser.rs b/src/libsyntax/ext/tt/macro_parser.rs index d33d03bbfa9..9eda4bcef99 100644 --- a/src/libsyntax/ext/tt/macro_parser.rs +++ b/src/libsyntax/ext/tt/macro_parser.rs @@ -153,7 +153,7 @@ pub fn count_names(ms: &[TokenTree]) -> uint { seq.num_captures } &TtDelimited(_, ref delim) => { - count_names(delim.tts.index(&FullRange)) + count_names(&delim.tts[]) } &TtToken(_, MatchNt(..)) => { 1 @@ -165,7 +165,7 @@ pub fn count_names(ms: &[TokenTree]) -> uint { pub fn initial_matcher_pos(ms: Rc<Vec<TokenTree>>, sep: Option<Token>, lo: BytePos) -> Box<MatcherPos> { - let match_idx_hi = count_names(ms.index(&FullRange)); + let match_idx_hi = count_names(&ms[]); let matches: Vec<_> = range(0, match_idx_hi).map(|_| Vec::new()).collect(); box MatcherPos { stack: vec![], @@ -228,8 +228,8 @@ pub fn nameize(p_s: &ParseSess, ms: &[TokenTree], res: &[Rc<NamedMatch>]) let string = token::get_ident(bind_name); p_s.span_diagnostic .span_fatal(sp, - format!("duplicated bind name: {}", - string.get()).index(&FullRange)) + &format!("duplicated bind name: {}", + string.get())[]) } } } @@ -254,13 +254,13 @@ pub fn parse_or_else(sess: &ParseSess, rdr: TtReader, ms: Vec<TokenTree> ) -> HashMap<Ident, Rc<NamedMatch>> { - match parse(sess, cfg, rdr, ms.index(&FullRange)) { + match parse(sess, cfg, rdr, &ms[]) { Success(m) => m, Failure(sp, str) => { - sess.span_diagnostic.span_fatal(sp, str.index(&FullRange)) + sess.span_diagnostic.span_fatal(sp, &str[]) } Error(sp, str) => { - sess.span_diagnostic.span_fatal(sp, str.index(&FullRange)) + sess.span_diagnostic.span_fatal(sp, &str[]) } } } @@ -447,7 +447,7 @@ pub fn parse(sess: &ParseSess, for dv in (&mut eof_eis[0]).matches.iter_mut() { v.push(dv.pop().unwrap()); } - return Success(nameize(sess, ms, v.index(&FullRange))); + return Success(nameize(sess, ms, &v[])); } else if eof_eis.len() > 1u { return Error(sp, "ambiguity: multiple successful parses".to_string()); } else { @@ -532,8 +532,8 @@ pub fn parse_nt(p: &mut Parser, name: &str) -> Nonterminal { token::Ident(sn,b) => { p.bump(); token::NtIdent(box sn,b) } _ => { let token_str = pprust::token_to_string(&p.token); - p.fatal((format!("expected ident, found {}", - token_str.index(&FullRange))).index(&FullRange)) + p.fatal(&format!("expected ident, found {}", + &token_str[])[]) } }, "path" => { @@ -541,7 +541,7 @@ pub fn parse_nt(p: &mut Parser, name: &str) -> Nonterminal { } "meta" => token::NtMeta(p.parse_meta_item()), _ => { - p.fatal(format!("unsupported builtin nonterminal parser: {}", name).index(&FullRange)) + p.fatal(&format!("unsupported builtin nonterminal parser: {}", name)[]) } } } diff --git a/src/libsyntax/ext/tt/macro_rules.rs b/src/libsyntax/ext/tt/macro_rules.rs index 64c53e298ef..fc341e3bd85 100644 --- a/src/libsyntax/ext/tt/macro_rules.rs +++ b/src/libsyntax/ext/tt/macro_rules.rs @@ -52,7 +52,7 @@ impl<'a> ParserAnyMacro<'a> { following", token_str); let span = parser.span; - parser.span_err(span, msg.index(&FullRange)); + parser.span_err(span, &msg[]); } } } @@ -126,8 +126,8 @@ impl TTMacroExpander for MacroRulesMacroExpander { self.name, self.imported_from, arg, - self.lhses.index(&FullRange), - self.rhses.index(&FullRange)) + &self.lhses[], + &self.rhses[]) } } @@ -154,7 +154,7 @@ fn generic_extension<'cx>(cx: &'cx ExtCtxt, match **lhs { MatchedNonterminal(NtTT(ref lhs_tt)) => { let lhs_tt = match **lhs_tt { - TtDelimited(_, ref delim) => delim.tts.index(&FullRange), + TtDelimited(_, ref delim) => &delim.tts[], _ => cx.span_fatal(sp, "malformed macro lhs") }; // `None` is because we're not interpolating @@ -195,13 +195,13 @@ fn generic_extension<'cx>(cx: &'cx ExtCtxt, best_fail_spot = sp; best_fail_msg = (*msg).clone(); }, - Error(sp, ref msg) => cx.span_fatal(sp, msg.index(&FullRange)) + Error(sp, ref msg) => cx.span_fatal(sp, &msg[]) } } _ => cx.bug("non-matcher found in parsed lhses") } } - cx.span_fatal(best_fail_spot, best_fail_msg.index(&FullRange)); + cx.span_fatal(best_fail_spot, &best_fail_msg[]); } // Note that macro-by-example's input is also matched against a token tree: diff --git a/src/libsyntax/ext/tt/transcribe.rs b/src/libsyntax/ext/tt/transcribe.rs index bc07c7f6cae..94b8356130a 100644 --- a/src/libsyntax/ext/tt/transcribe.rs +++ b/src/libsyntax/ext/tt/transcribe.rs @@ -255,7 +255,7 @@ pub fn tt_next_token(r: &mut TtReader) -> TokenAndSpan { } LisContradiction(ref msg) => { // FIXME #2887 blame macro invoker instead - r.sp_diag.span_fatal(sp.clone(), msg.index(&FullRange)); + r.sp_diag.span_fatal(sp.clone(), &msg[]); } LisConstraint(len, _) => { if len == 0 { @@ -308,8 +308,8 @@ pub fn tt_next_token(r: &mut TtReader) -> TokenAndSpan { MatchedSeq(..) => { r.sp_diag.span_fatal( r.cur_span, /* blame the macro writer */ - format!("variable '{:?}' is still repeating at this depth", - token::get_ident(ident)).index(&FullRange)); + &format!("variable '{:?}' is still repeating at this depth", + token::get_ident(ident))[]); } } } diff --git a/src/libsyntax/feature_gate.rs b/src/libsyntax/feature_gate.rs index f10113254de..2cfcd38d48f 100644 --- a/src/libsyntax/feature_gate.rs +++ b/src/libsyntax/feature_gate.rs @@ -70,6 +70,7 @@ static KNOWN_FEATURES: &'static [(&'static str, Status)] = &[ ("associated_types", Accepted), ("visible_private_types", Active), ("slicing_syntax", Active), + ("box_syntax", Active), ("if_let", Accepted), ("while_let", Accepted), @@ -150,9 +151,9 @@ impl<'a> Context<'a> { fn gate_feature(&self, feature: &str, span: Span, explain: &str) { if !self.has_feature(feature) { self.span_handler.span_err(span, explain); - self.span_handler.span_help(span, format!("add #![feature({})] to the \ + self.span_handler.span_help(span, &format!("add #![feature({})] to the \ crate attributes to enable", - feature).index(&FullRange)); + feature)[]); } } @@ -243,7 +244,7 @@ impl<'a, 'v> Visitor<'v> for PostExpansionVisitor<'a> { } match i.node { ast::ItemForeignMod(ref foreign_module) => { - if attr::contains_name(i.attrs.index(&FullRange), "link_args") { + if attr::contains_name(&i.attrs[], "link_args") { self.gate_feature("link_args", i.span, "the `link_args` attribute is not portable \ across platforms, it is recommended to \ @@ -257,14 +258,14 @@ impl<'a, 'v> Visitor<'v> for PostExpansionVisitor<'a> { } ast::ItemFn(..) => { - if attr::contains_name(i.attrs.index(&FullRange), "plugin_registrar") { + if attr::contains_name(&i.attrs[], "plugin_registrar") { self.gate_feature("plugin_registrar", i.span, "compiler plugins are experimental and possibly buggy"); } } ast::ItemStruct(..) => { - if attr::contains_name(i.attrs.index(&FullRange), "simd") { + if attr::contains_name(&i.attrs[], "simd") { self.gate_feature("simd", i.span, "SIMD types are experimental and possibly buggy"); } @@ -290,7 +291,7 @@ impl<'a, 'v> Visitor<'v> for PostExpansionVisitor<'a> { removed in the future"); } - if attr::contains_name(i.attrs.index(&FullRange), + if attr::contains_name(&i.attrs[], "old_orphan_check") { self.gate_feature( "old_orphan_check", @@ -298,7 +299,7 @@ impl<'a, 'v> Visitor<'v> for PostExpansionVisitor<'a> { "the new orphan check rules will eventually be strictly enforced"); } - if attr::contains_name(i.attrs.index(&FullRange), + if attr::contains_name(&i.attrs[], "old_impl_check") { self.gate_feature("old_impl_check", i.span, @@ -313,7 +314,7 @@ impl<'a, 'v> Visitor<'v> for PostExpansionVisitor<'a> { } fn visit_foreign_item(&mut self, i: &ast::ForeignItem) { - if attr::contains_name(i.attrs.index(&FullRange), "linkage") { + if attr::contains_name(&i.attrs[], "linkage") { self.gate_feature("linkage", i.span, "the `linkage` attribute is experimental \ and not portable across platforms") @@ -338,10 +339,11 @@ impl<'a, 'v> Visitor<'v> for PostExpansionVisitor<'a> { fn visit_expr(&mut self, e: &ast::Expr) { match e.node { - ast::ExprRange(..) => { - self.gate_feature("slicing_syntax", + ast::ExprBox(..) | ast::ExprUnary(ast::UnOp::UnUniq, _) => { + self.gate_feature("box_syntax", e.span, - "range syntax is experimental"); + "box expression syntax is experimental in alpha release; \ + you can call `Box::new` instead."); } _ => {} } @@ -365,6 +367,11 @@ impl<'a, 'v> Visitor<'v> for PostExpansionVisitor<'a> { but at the end of a slice (e.g. \ `[0, ..xs, 0]` are experimental") } + ast::PatBox(..) => { + self.gate_feature("box_syntax", + pattern.span, + "box pattern syntax is experimental in alpha release"); + } _ => {} } visit::walk_pat(self, pattern) diff --git a/src/libsyntax/lib.rs b/src/libsyntax/lib.rs index 9e14f9dd1ea..1efd6a87f86 100644 --- a/src/libsyntax/lib.rs +++ b/src/libsyntax/lib.rs @@ -16,6 +16,7 @@ #![crate_name = "syntax"] #![experimental] +#![staged_api] #![crate_type = "dylib"] #![crate_type = "rlib"] #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png", @@ -24,6 +25,7 @@ #![allow(unknown_features)] #![feature(slicing_syntax)] +#![feature(box_syntax)] #![feature(quote, unsafe_destructor)] extern crate arena; @@ -81,7 +83,6 @@ pub mod ext { pub mod asm; pub mod base; pub mod build; - pub mod bytes; pub mod cfg; pub mod cfg_attr; pub mod concat; @@ -89,7 +90,6 @@ pub mod ext { pub mod deriving; pub mod env; pub mod expand; - pub mod fmt; pub mod format; pub mod log_syntax; pub mod mtwt; diff --git a/src/libsyntax/parse/attr.rs b/src/libsyntax/parse/attr.rs index 4aad7f911db..54ec9c7b146 100644 --- a/src/libsyntax/parse/attr.rs +++ b/src/libsyntax/parse/attr.rs @@ -92,7 +92,7 @@ impl<'a> ParserAttr for Parser<'a> { } _ => { let token_str = self.this_token_to_string(); - self.fatal(format!("expected `#`, found `{}`", token_str).index(&FullRange)); + self.fatal(&format!("expected `#`, found `{}`", token_str)[]); } }; diff --git a/src/libsyntax/parse/lexer/comments.rs b/src/libsyntax/parse/lexer/comments.rs index e7fc5aac9c7..16ade904be8 100644 --- a/src/libsyntax/parse/lexer/comments.rs +++ b/src/libsyntax/parse/lexer/comments.rs @@ -82,7 +82,7 @@ pub fn strip_doc_comment_decoration(comment: &str) -> String { while j > i && lines[j - 1].trim().is_empty() { j -= 1; } - return lines.index(&(i..j)).iter().map(|x| (*x).clone()).collect(); + return lines[i..j].iter().map(|x| (*x).clone()).collect(); } /// remove a "[ \t]*\*" block from each line, if possible @@ -116,7 +116,7 @@ pub fn strip_doc_comment_decoration(comment: &str) -> String { if can_trim { lines.iter().map(|line| { - line.index(&((i + 1)..line.len())).to_string() + (&line[(i + 1)..line.len()]).to_string() }).collect() } else { lines @@ -127,12 +127,12 @@ pub fn strip_doc_comment_decoration(comment: &str) -> String { static ONLINERS: &'static [&'static str] = &["///!", "///", "//!", "//"]; for prefix in ONLINERS.iter() { if comment.starts_with(*prefix) { - return comment.index(&(prefix.len()..)).to_string(); + return (&comment[prefix.len()..]).to_string(); } } if comment.starts_with("/*") { - let lines = comment.index(&(3u..(comment.len() - 2u))) + let lines = comment[3u..(comment.len() - 2u)] .lines_any() .map(|s| s.to_string()) .collect::<Vec<String> >(); @@ -187,7 +187,7 @@ fn read_line_comments(rdr: &mut StringReader, code_to_the_left: bool, let line = rdr.read_one_line_comment(); debug!("{}", line); // Doc comments are not put in comments. - if is_doc_comment(line.index(&FullRange)) { + if is_doc_comment(&line[]) { break; } lines.push(line); @@ -224,10 +224,10 @@ fn all_whitespace(s: &str, col: CharPos) -> Option<uint> { fn trim_whitespace_prefix_and_push_line(lines: &mut Vec<String> , s: String, col: CharPos) { let len = s.len(); - let s1 = match all_whitespace(s.index(&FullRange), col) { + let s1 = match all_whitespace(&s[], col) { Some(col) => { if col < len { - s.index(&(col..len)).to_string() + (&s[col..len]).to_string() } else { "".to_string() } @@ -261,7 +261,7 @@ fn read_block_comment(rdr: &mut StringReader, rdr.bump(); rdr.bump(); } - if is_block_doc_comment(curr_line.index(&FullRange)) { + if is_block_doc_comment(&curr_line[]) { return } assert!(!curr_line.contains_char('\n')); diff --git a/src/libsyntax/parse/lexer/mod.rs b/src/libsyntax/parse/lexer/mod.rs index 153b18b8760..4cdafb36eec 100644 --- a/src/libsyntax/parse/lexer/mod.rs +++ b/src/libsyntax/parse/lexer/mod.rs @@ -196,7 +196,7 @@ impl<'a> StringReader<'a> { let mut m = m.to_string(); m.push_str(": "); for c in c.escape_default() { m.push(c) } - self.fatal_span_(from_pos, to_pos, m.index(&FullRange)); + self.fatal_span_(from_pos, to_pos, &m[]); } /// Report a lexical error spanning [`from_pos`, `to_pos`), appending an @@ -205,7 +205,7 @@ impl<'a> StringReader<'a> { let mut m = m.to_string(); m.push_str(": "); for c in c.escape_default() { m.push(c) } - self.err_span_(from_pos, to_pos, m.index(&FullRange)); + self.err_span_(from_pos, to_pos, &m[]); } /// Report a lexical error spanning [`from_pos`, `to_pos`), appending the @@ -214,8 +214,8 @@ impl<'a> StringReader<'a> { m.push_str(": "); let from = self.byte_offset(from_pos).to_uint(); let to = self.byte_offset(to_pos).to_uint(); - m.push_str(self.filemap.src.index(&(from..to))); - self.fatal_span_(from_pos, to_pos, m.index(&FullRange)); + m.push_str(&self.filemap.src[from..to]); + self.fatal_span_(from_pos, to_pos, &m[]); } /// Advance peek_tok and peek_span to refer to the next token, and @@ -301,7 +301,7 @@ impl<'a> StringReader<'a> { while i < s.len() { let str::CharRange { ch, next } = s.char_range_at(i); if ch == '\r' { - if j < i { buf.push_str(s.index(&(j..i))); } + if j < i { buf.push_str(&s[j..i]); } j = next; if next >= s.len() || s.char_at(next) != '\n' { let pos = start + BytePos(i as u32); @@ -311,7 +311,7 @@ impl<'a> StringReader<'a> { } i = next; } - if j < s.len() { buf.push_str(s.index(&(j..))); } + if j < s.len() { buf.push_str(&s[j..]); } buf } } @@ -556,7 +556,7 @@ impl<'a> StringReader<'a> { self.translate_crlf(start_bpos, string, "bare CR not allowed in block doc-comment") } else { string.into_cow() }; - token::DocComment(token::intern(string.index(&FullRange))) + token::DocComment(token::intern(&string[])) } else { token::Comment }; @@ -1110,7 +1110,7 @@ impl<'a> StringReader<'a> { // expansion purposes. See #12512 for the gory details of why // this is necessary. let ident = self.with_str_from(start, |lifetime_name| { - str_to_ident(format!("'{}", lifetime_name).index(&FullRange)) + str_to_ident(&format!("'{}", lifetime_name)[]) }); // Conjure up a "keyword checking ident" to make sure that diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs index d26b3af67bd..c42a6beea2d 100644 --- a/src/libsyntax/parse/mod.rs +++ b/src/libsyntax/parse/mod.rs @@ -253,19 +253,19 @@ pub fn file_to_filemap(sess: &ParseSess, path: &Path, spanopt: Option<Span>) let bytes = match File::open(path).read_to_end() { Ok(bytes) => bytes, Err(e) => { - err(format!("couldn't read {:?}: {:?}", + err(&format!("couldn't read {:?}: {:?}", path.display(), - e).index(&FullRange)); + e)[]); unreachable!() } }; - match str::from_utf8(bytes.index(&FullRange)).ok() { + match str::from_utf8(&bytes[]).ok() { Some(s) => { return string_to_filemap(sess, s.to_string(), path.as_str().unwrap().to_string()) } None => { - err(format!("{:?} is not UTF-8 encoded", path.display()).index(&FullRange)) + err(&format!("{:?} is not UTF-8 encoded", path.display())[]) } } unreachable!() @@ -399,10 +399,10 @@ pub fn char_lit(lit: &str) -> (char, int) { } let msg = format!("lexer should have rejected a bad character escape {}", lit); - let msg2 = msg.index(&FullRange); + let msg2 = &msg[]; fn esc(len: uint, lit: &str) -> Option<(char, int)> { - num::from_str_radix(lit.index(&(2..len)), 16) + num::from_str_radix(&lit[2..len], 16) .and_then(char::from_u32) .map(|x| (x, len as int)) } @@ -410,7 +410,7 @@ pub fn char_lit(lit: &str) -> (char, int) { let unicode_escape = |&: | -> Option<(char, int)> if lit.as_bytes()[2] == b'{' { let idx = lit.find('}').expect(msg2); - let subslice = lit.index(&(3..idx)); + let subslice = &lit[3..idx]; num::from_str_radix(subslice, 16) .and_then(char::from_u32) .map(|x| (x, subslice.chars().count() as int + 4)) @@ -472,7 +472,7 @@ pub fn str_lit(lit: &str) -> String { eat(&mut chars); } else { // otherwise, a normal escape - let (c, n) = char_lit(lit.index(&(i..))); + let (c, n) = char_lit(&lit[i..]); for _ in range(0, n - 1) { // we don't need to move past the first \ chars.next(); } @@ -535,7 +535,7 @@ pub fn raw_str_lit(lit: &str) -> String { fn looks_like_width_suffix(first_chars: &[char], s: &str) -> bool { s.len() > 1 && first_chars.contains(&s.char_at(0)) && - s.index(&(1..)).chars().all(|c| '0' <= c && c <= '9') + s[1..].chars().all(|c| '0' <= c && c <= '9') } fn filtered_float_lit(data: token::InternedString, suffix: Option<&str>, @@ -548,7 +548,7 @@ fn filtered_float_lit(data: token::InternedString, suffix: Option<&str>, if suf.len() >= 2 && looks_like_width_suffix(&['f'], suf) { // if it looks like a width, lets try to be helpful. sd.span_err(sp, &*format!("illegal width `{}` for float literal, \ - valid widths are 32 and 64", suf.index(&(1..)))); + valid widths are 32 and 64", &suf[1..])); } else { sd.span_err(sp, &*format!("illegal suffix `{}` for float literal, \ valid suffixes are `f32` and `f64`", suf)); @@ -584,7 +584,7 @@ pub fn byte_lit(lit: &str) -> (u8, uint) { b'\'' => b'\'', b'0' => b'\0', _ => { - match ::std::num::from_str_radix::<u64>(lit.index(&(2..4)), 16) { + match ::std::num::from_str_radix::<u64>(&lit[2..4], 16) { Some(c) => if c > 0xFF { panic!(err(2)) @@ -634,7 +634,7 @@ pub fn binary_lit(lit: &str) -> Rc<Vec<u8>> { } _ => { // otherwise, a normal escape - let (c, n) = byte_lit(lit.index(&(i..))); + let (c, n) = byte_lit(&lit[i..]); // we don't need to move past the first \ for _ in range(0, n - 1) { chars.next(); @@ -663,7 +663,7 @@ pub fn integer_lit(s: &str, suffix: Option<&str>, sd: &SpanHandler, sp: Span) -> // s can only be ascii, byte indexing is fine let s2 = s.chars().filter(|&c| c != '_').collect::<String>(); - let mut s = s2.index(&FullRange); + let mut s = &s2[]; debug!("integer_lit: {}, {:?}", s, suffix); @@ -696,7 +696,7 @@ pub fn integer_lit(s: &str, suffix: Option<&str>, sd: &SpanHandler, sp: Span) -> } if base != 10 { - s = s.index(&(2..)); + s = &s[2..]; } if let Some(suf) = suffix { @@ -720,7 +720,7 @@ pub fn integer_lit(s: &str, suffix: Option<&str>, sd: &SpanHandler, sp: Span) -> if looks_like_width_suffix(&['i', 'u'], suf) { sd.span_err(sp, &*format!("illegal width `{}` for integer literal; \ valid widths are 8, 16, 32 and 64", - suf.index(&(1..)))); + &suf[1..])); } else { sd.span_err(sp, &*format!("illegal suffix `{}` for numeric literal", suf)); } @@ -818,7 +818,7 @@ mod test { #[test] fn string_to_tts_macro () { let tts = string_to_tts("macro_rules! zip (($a)=>($a))".to_string()); - let tts: &[ast::TokenTree] = tts.index(&FullRange); + let tts: &[ast::TokenTree] = &tts[]; match tts { [ast::TtToken(_, token::Ident(name_macro_rules, token::Plain)), ast::TtToken(_, token::Not), @@ -826,19 +826,19 @@ mod test { ast::TtDelimited(_, ref macro_delimed)] if name_macro_rules.as_str() == "macro_rules" && name_zip.as_str() == "zip" => { - match macro_delimed.tts.index(&FullRange) { + match ¯o_delimed.tts[] { [ast::TtDelimited(_, ref first_delimed), ast::TtToken(_, token::FatArrow), ast::TtDelimited(_, ref second_delimed)] if macro_delimed.delim == token::Paren => { - match first_delimed.tts.index(&FullRange) { + match &first_delimed.tts[] { [ast::TtToken(_, token::Dollar), ast::TtToken(_, token::Ident(name, token::Plain))] if first_delimed.delim == token::Paren && name.as_str() == "a" => {}, _ => panic!("value 3: {:?}", **first_delimed), } - match second_delimed.tts.index(&FullRange) { + match &second_delimed.tts[] { [ast::TtToken(_, token::Dollar), ast::TtToken(_, token::Ident(name, token::Plain))] if second_delimed.delim == token::Paren @@ -1116,24 +1116,24 @@ mod test { let use_s = "use foo::bar::baz;"; let vitem = string_to_view_item(use_s.to_string()); let vitem_s = view_item_to_string(&vitem); - assert_eq!(vitem_s.index(&FullRange), use_s); + assert_eq!(&vitem_s[], use_s); let use_s = "use foo::bar as baz;"; let vitem = string_to_view_item(use_s.to_string()); let vitem_s = view_item_to_string(&vitem); - assert_eq!(vitem_s.index(&FullRange), use_s); + assert_eq!(&vitem_s[], use_s); } #[test] fn parse_extern_crate() { let ex_s = "extern crate foo;"; let vitem = string_to_view_item(ex_s.to_string()); let vitem_s = view_item_to_string(&vitem); - assert_eq!(vitem_s.index(&FullRange), ex_s); + assert_eq!(&vitem_s[], ex_s); let ex_s = "extern crate \"foo\" as bar;"; let vitem = string_to_view_item(ex_s.to_string()); let vitem_s = view_item_to_string(&vitem); - assert_eq!(vitem_s.index(&FullRange), ex_s); + assert_eq!(&vitem_s[], ex_s); } fn get_spans_of_pat_idents(src: &str) -> Vec<Span> { @@ -1212,7 +1212,7 @@ mod test { let docs = item.attrs.iter().filter(|a| a.name().get() == "doc") .map(|a| a.value_str().unwrap().get().to_string()).collect::<Vec<_>>(); let b: &[_] = &["/// doc comment".to_string(), "/// line 2".to_string()]; - assert_eq!(docs.index(&FullRange), b); + assert_eq!(&docs[], b); let source = "/** doc comment\r\n * with CRLF */\r\nfn foo() {}".to_string(); let item = parse_item_from_source_str(name, source, Vec::new(), &sess).unwrap(); diff --git a/src/libsyntax/parse/obsolete.rs b/src/libsyntax/parse/obsolete.rs index 23728c74ae8..e9e207e7dbc 100644 --- a/src/libsyntax/parse/obsolete.rs +++ b/src/libsyntax/parse/obsolete.rs @@ -127,13 +127,13 @@ impl<'a> ParserObsoleteMethods for parser::Parser<'a> { kind_str: &str, desc: &str) { self.span_err(sp, - format!("obsolete syntax: {}", kind_str).index(&FullRange)); + &format!("obsolete syntax: {}", kind_str)[]); if !self.obsolete_set.contains(&kind) { self.sess .span_diagnostic .handler() - .note(format!("{}", desc).index(&FullRange)); + .note(&format!("{}", desc)[]); self.obsolete_set.insert(kind); } } diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 9c16dbb2c5c..531e611594a 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -16,7 +16,7 @@ use ast::{AssociatedType, BareFnTy}; use ast::{RegionTyParamBound, TraitTyParamBound, TraitBoundModifier}; use ast::{ProvidedMethod, Public, Unsafety}; use ast::{Mod, BiAdd, Arg, Arm, Attribute, BindByRef, BindByValue}; -use ast::{BiBitAnd, BiBitOr, BiBitXor, BiRem, Block}; +use ast::{BiBitAnd, BiBitOr, BiBitXor, BiRem, BiLt, BiGt, Block}; use ast::{BlockCheckMode, CaptureByRef, CaptureByValue, CaptureClause}; use ast::{Crate, CrateConfig, Decl, DeclItem}; use ast::{DeclLocal, DefaultBlock, UnDeref, BiDiv, EMPTY_CTXT, EnumDef, ExplicitSelf}; @@ -388,13 +388,13 @@ impl<'a> Parser<'a> { pub fn unexpected_last(&mut self, t: &token::Token) -> ! { let token_str = Parser::token_to_string(t); let last_span = self.last_span; - self.span_fatal(last_span, format!("unexpected token: `{}`", - token_str).index(&FullRange)); + self.span_fatal(last_span, &format!("unexpected token: `{}`", + token_str)[]); } pub fn unexpected(&mut self) -> ! { let this_token = self.this_token_to_string(); - self.fatal(format!("unexpected token: `{}`", this_token).index(&FullRange)); + self.fatal(&format!("unexpected token: `{}`", this_token)[]); } /// Expect and consume the token t. Signal an error if @@ -406,9 +406,9 @@ impl<'a> Parser<'a> { } else { let token_str = Parser::token_to_string(t); let this_token_str = self.this_token_to_string(); - self.fatal(format!("expected `{}`, found `{}`", + self.fatal(&format!("expected `{}`, found `{}`", token_str, - this_token_str).index(&FullRange)) + this_token_str)[]) } } else { self.expect_one_of(slice::ref_slice(t), &[]); @@ -449,10 +449,10 @@ impl<'a> Parser<'a> { expected.push_all(&*self.expected_tokens); expected.sort_by(|a, b| a.to_string().cmp(&b.to_string())); expected.dedup(); - let expect = tokens_to_string(expected.index(&FullRange)); + let expect = tokens_to_string(&expected[]); let actual = self.this_token_to_string(); self.fatal( - (if expected.len() != 1 { + &(if expected.len() != 1 { (format!("expected one of {}, found `{}`", expect, actual)) @@ -460,7 +460,7 @@ impl<'a> Parser<'a> { (format!("expected {}, found `{}`", expect, actual)) - }).index(&FullRange) + }[]) ) } } @@ -493,7 +493,7 @@ impl<'a> Parser<'a> { // might be unit-struct construction; check for recoverableinput error. let mut expected = edible.iter().map(|x| x.clone()).collect::<Vec<_>>(); expected.push_all(inedible); - self.check_for_erroneous_unit_struct_expecting(expected.index(&FullRange)); + self.check_for_erroneous_unit_struct_expecting(&expected[]); } self.expect_one_of(edible, inedible) } @@ -510,9 +510,9 @@ impl<'a> Parser<'a> { .as_ref() .map_or(false, |t| t.is_ident() || t.is_path()) { let mut expected = edible.iter().map(|x| x.clone()).collect::<Vec<_>>(); - expected.push_all(inedible.index(&FullRange)); + expected.push_all(&inedible[]); self.check_for_erroneous_unit_struct_expecting( - expected.index(&FullRange)); + &expected[]); } self.expect_one_of(edible, inedible) } @@ -534,8 +534,8 @@ impl<'a> Parser<'a> { } _ => { let token_str = self.this_token_to_string(); - self.fatal((format!("expected ident, found `{}`", - token_str)).index(&FullRange)) + self.fatal(&format!("expected ident, found `{}`", + token_str)[]) } } } @@ -592,8 +592,8 @@ impl<'a> Parser<'a> { if !self.eat_keyword(kw) { let id_interned_str = token::get_name(kw.to_name()); let token_str = self.this_token_to_string(); - self.fatal(format!("expected `{}`, found `{}`", - id_interned_str, token_str).index(&FullRange)) + self.fatal(&format!("expected `{}`, found `{}`", + id_interned_str, token_str)[]) } } @@ -603,8 +603,8 @@ impl<'a> Parser<'a> { let token_str = self.this_token_to_string(); let span = self.span; self.span_err(span, - format!("expected identifier, found keyword `{}`", - token_str).index(&FullRange)); + &format!("expected identifier, found keyword `{}`", + token_str)[]); } } @@ -612,8 +612,8 @@ impl<'a> Parser<'a> { pub fn check_reserved_keywords(&mut self) { if self.token.is_reserved_keyword() { let token_str = self.this_token_to_string(); - self.fatal(format!("`{}` is a reserved keyword", - token_str).index(&FullRange)) + self.fatal(&format!("`{}` is a reserved keyword", + token_str)[]) } } @@ -631,9 +631,9 @@ impl<'a> Parser<'a> { let token_str = self.this_token_to_string(); let found_token = Parser::token_to_string(&token::BinOp(token::And)); - self.fatal(format!("expected `{}`, found `{}`", + self.fatal(&format!("expected `{}`, found `{}`", found_token, - token_str).index(&FullRange)) + token_str)[]) } } } @@ -652,9 +652,9 @@ impl<'a> Parser<'a> { let found_token = self.this_token_to_string(); let token_str = Parser::token_to_string(&token::BinOp(token::Or)); - self.fatal(format!("expected `{}`, found `{}`", + self.fatal(&format!("expected `{}`, found `{}`", token_str, - found_token).index(&FullRange)) + found_token)[]) } } } @@ -695,9 +695,9 @@ impl<'a> Parser<'a> { if !self.eat_lt() { let found_token = self.this_token_to_string(); let token_str = Parser::token_to_string(&token::Lt); - self.fatal(format!("expected `{}`, found `{}`", + self.fatal(&format!("expected `{}`, found `{}`", token_str, - found_token).index(&FullRange)) + found_token)[]) } } @@ -747,9 +747,9 @@ impl<'a> Parser<'a> { _ => { let gt_str = Parser::token_to_string(&token::Gt); let this_token_str = self.this_token_to_string(); - self.fatal(format!("expected `{}`, found `{}`", + self.fatal(&format!("expected `{}`, found `{}`", gt_str, - this_token_str).index(&FullRange)) + this_token_str)[]) } } } @@ -1371,7 +1371,7 @@ impl<'a> Parser<'a> { let (inner_attrs, body) = p.parse_inner_attrs_and_block(); let mut attrs = attrs; - attrs.push_all(inner_attrs.index(&FullRange)); + attrs.push_all(&inner_attrs[]); ProvidedMethod(P(ast::Method { attrs: attrs, id: ast::DUMMY_NODE_ID, @@ -1389,8 +1389,8 @@ impl<'a> Parser<'a> { _ => { let token_str = p.this_token_to_string(); - p.fatal((format!("expected `;` or `{{`, found `{}`", - token_str)).index(&FullRange)) + p.fatal(&format!("expected `;` or `{{`, found `{}`", + token_str)[]) } } } @@ -1586,7 +1586,7 @@ impl<'a> Parser<'a> { } else { let this_token_str = self.this_token_to_string(); let msg = format!("expected type, found `{}`", this_token_str); - self.fatal(msg.index(&FullRange)); + self.fatal(&msg[]); }; let sp = mk_sp(lo, self.last_span.hi); @@ -1734,8 +1734,7 @@ impl<'a> Parser<'a> { token::StrRaw(s, n) => { (true, LitStr( - token::intern_and_get_ident( - parse::raw_str_lit(s.as_str()).index(&FullRange)), + token::intern_and_get_ident(&parse::raw_str_lit(s.as_str())[]), ast::RawStr(n))) } token::Binary(i) => @@ -1979,7 +1978,7 @@ impl<'a> Parser<'a> { }; } _ => { - self.fatal(format!("expected a lifetime name").index(&FullRange)); + self.fatal(&format!("expected a lifetime name")[]); } } } @@ -2017,7 +2016,7 @@ impl<'a> Parser<'a> { let msg = format!("expected `,` or `>` after lifetime \ name, found `{}`", this_token_str); - self.fatal(msg.index(&FullRange)); + self.fatal(&msg[]); } } } @@ -2501,16 +2500,16 @@ impl<'a> Parser<'a> { let last_span = self.last_span; let fstr = n.as_str(); self.span_err(last_span, - format!("unexpected token: `{}`", n.as_str()).index(&FullRange)); + &format!("unexpected token: `{}`", n.as_str())[]); if fstr.chars().all(|x| "0123456789.".contains_char(x)) { let float = match fstr.parse::<f64>() { Some(f) => f, None => continue, }; self.span_help(last_span, - format!("try parenthesizing the first index; e.g., `(foo.{}){}`", + &format!("try parenthesizing the first index; e.g., `(foo.{}){}`", float.trunc() as uint, - float.fract().to_string().index(&(1..))).index(&FullRange)); + &float.fract().to_string()[1..])[]); } self.abort_if_errors(); @@ -2536,7 +2535,7 @@ impl<'a> Parser<'a> { } // expr[...] - // An index expression. + // Could be either an index expression or a slicing expression. token::OpenDelim(token::Bracket) => { let bracket_pos = self.span.lo; self.bump(); @@ -2576,22 +2575,6 @@ impl<'a> Parser<'a> { "use `&expr[]` to construct a slice of the whole of expr"); } } - - // A range expression, either `expr..expr` or `expr..`. - token::DotDot if !self.restrictions.contains(RESTRICTION_NO_DOTS) => { - self.bump(); - - let opt_end = if self.token.can_begin_expr() { - let end = self.parse_expr_res(RESTRICTION_NO_DOTS); - Some(end) - } else { - None - }; - - let hi = self.span.hi; - let range = self.mk_range(Some(e), opt_end); - return self.mk_expr(lo, hi, range); - } _ => return e } } @@ -2655,8 +2638,8 @@ impl<'a> Parser<'a> { if self.quote_depth == 0u { match self.token { token::SubstNt(name, _) => - self.fatal(format!("unknown macro variable `{}`", - token::get_ident(name)).index(&FullRange)), + self.fatal(&format!("unknown macro variable `{}`", + token::get_ident(name))[]), _ => {} } } @@ -2717,8 +2700,8 @@ impl<'a> Parser<'a> { Some(&sp) => p.span_note(sp, "unclosed delimiter"), }; let token_str = p.this_token_to_string(); - p.fatal(format!("incorrect close delimiter: `{}`", - token_str).index(&FullRange)) + p.fatal(&format!("incorrect close delimiter: `{}`", + token_str)[]) }, /* we ought to allow different depths of unquotation */ token::Dollar | token::SubstNt(..) if p.quote_depth > 0u => { @@ -2834,7 +2817,7 @@ impl<'a> Parser<'a> { token::DotDot if !self.restrictions.contains(RESTRICTION_NO_DOTS) => { // A range, closed above: `..expr`. self.bump(); - let e = self.parse_prefix_expr(); + let e = self.parse_expr(); hi = e.span.hi; ex = self.mk_range(None, Some(e)); } @@ -2858,8 +2841,8 @@ impl<'a> Parser<'a> { let span = self.span; let this_token_to_string = self.this_token_to_string(); self.span_err(span, - format!("expected expression, found `{}`", - this_token_to_string).index(&FullRange)); + &format!("expected expression, found `{}`", + this_token_to_string)[]); let box_span = mk_sp(lo, self.last_span.hi); self.span_help(box_span, "perhaps you meant `box() (foo)` instead?"); @@ -2901,11 +2884,15 @@ impl<'a> Parser<'a> { self.restrictions.contains(RESTRICTION_NO_BAR_OP) { return lhs; } + self.expected_tokens.push(TokenType::Operator); let cur_opt = self.token.to_binop(); match cur_opt { Some(cur_op) => { + if ast_util::is_comparison_binop(cur_op) { + self.check_no_chained_comparison(&*lhs, cur_op) + } let cur_prec = operator_prec(cur_op); if cur_prec > min_prec { self.bump(); @@ -2934,6 +2921,25 @@ impl<'a> Parser<'a> { } } + /// Produce an error if comparison operators are chained (RFC #558). + /// We only need to check lhs, not rhs, because all comparison ops + /// have same precedence and are left-associative + fn check_no_chained_comparison(&mut self, lhs: &Expr, outer_op: ast::BinOp) { + debug_assert!(ast_util::is_comparison_binop(outer_op)); + match lhs.node { + ExprBinary(op, _, _) if ast_util::is_comparison_binop(op) => { + let op_span = self.span; + self.span_err(op_span, + "Chained comparison operators require parentheses"); + if op == BiLt && outer_op == BiGt { + self.span_help(op_span, + "Use ::< instead of < if you meant to specify type arguments."); + } + } + _ => {} + } + } + /// Parse an assignment expression.... /// actually, this seems to be the main entry point for /// parsing an arbitrary expression. @@ -2970,6 +2976,23 @@ impl<'a> Parser<'a> { let assign_op = self.mk_assign_op(aop, lhs, rhs); self.mk_expr(span.lo, rhs_span.hi, assign_op) } + // A range expression, either `expr..expr` or `expr..`. + token::DotDot if !self.restrictions.contains(RESTRICTION_NO_DOTS) => { + self.bump(); + + let opt_end = if self.token.can_begin_expr() { + let end = self.parse_expr_res(RESTRICTION_NO_DOTS); + Some(end) + } else { + None + }; + + let lo = lhs.span.lo; + let hi = self.span.hi; + let range = self.mk_range(Some(lhs), opt_end); + return self.mk_expr(lo, hi, range); + } + _ => { lhs } @@ -3241,8 +3264,8 @@ impl<'a> Parser<'a> { self.bump(); if self.token != token::CloseDelim(token::Brace) { let token_str = self.this_token_to_string(); - self.fatal(format!("expected `{}`, found `{}`", "}", - token_str).index(&FullRange)) + self.fatal(&format!("expected `{}`, found `{}`", "}", + token_str)[]) } etc = true; break; @@ -3262,8 +3285,8 @@ impl<'a> Parser<'a> { match bind_type { BindByRef(..) | BindByValue(MutMutable) => { let token_str = self.this_token_to_string(); - self.fatal(format!("unexpected `{}`", - token_str).index(&FullRange)) + self.fatal(&format!("unexpected `{}`", + token_str)[]) } _ => {} } @@ -3546,7 +3569,7 @@ impl<'a> Parser<'a> { let span = self.span; let tok_str = self.this_token_to_string(); self.span_fatal(span, - format!("expected identifier, found `{}`", tok_str).index(&FullRange)); + &format!("expected identifier, found `{}`", tok_str)[]); } let ident = self.parse_ident(); let last_span = self.last_span; @@ -3643,7 +3666,7 @@ impl<'a> Parser<'a> { let lo = self.span.lo; if self.token.is_keyword(keywords::Let) { - check_expected_item(self, item_attrs.index(&FullRange)); + check_expected_item(self, &item_attrs[]); self.expect_keyword(keywords::Let); let decl = self.parse_let(); P(spanned(lo, decl.span.hi, StmtDecl(decl, ast::DUMMY_NODE_ID))) @@ -3652,7 +3675,7 @@ impl<'a> Parser<'a> { && self.look_ahead(1, |t| *t == token::Not) { // it's a macro invocation: - check_expected_item(self, item_attrs.index(&FullRange)); + check_expected_item(self, &item_attrs[]); // Potential trouble: if we allow macros with paths instead of // idents, we'd need to look ahead past the whole path here... @@ -3678,9 +3701,9 @@ impl<'a> Parser<'a> { "" }; let tok_str = self.this_token_to_string(); - self.fatal(format!("expected {}`(` or `{{`, found `{}`", + self.fatal(&format!("expected {}`(` or `{{`, found `{}`", ident_str, - tok_str).index(&FullRange)) + tok_str)[]) }, }; @@ -3728,7 +3751,7 @@ impl<'a> Parser<'a> { } } else { let found_attrs = !item_attrs.is_empty(); - let item_err = Parser::expected_item_err(item_attrs.index(&FullRange)); + let item_err = Parser::expected_item_err(&item_attrs[]); match self.parse_item_or_view_item(item_attrs, false) { IoviItem(i) => { let hi = i.span.hi; @@ -3772,7 +3795,7 @@ impl<'a> Parser<'a> { let sp = self.span; let tok = self.this_token_to_string(); self.span_fatal_help(sp, - format!("expected `{{`, found `{}`", tok).index(&FullRange), + &format!("expected `{{`, found `{}`", tok)[], "place this code inside a block"); } @@ -3826,13 +3849,13 @@ impl<'a> Parser<'a> { while self.token != token::CloseDelim(token::Brace) { // parsing items even when they're not allowed lets us give // better error messages and recover more gracefully. - attributes_box.push_all(self.parse_outer_attributes().index(&FullRange)); + attributes_box.push_all(&self.parse_outer_attributes()[]); match self.token { token::Semi => { if !attributes_box.is_empty() { let last_span = self.last_span; self.span_err(last_span, - Parser::expected_item_err(attributes_box.index(&FullRange))); + Parser::expected_item_err(&attributes_box[])); attributes_box = Vec::new(); } self.bump(); // empty @@ -3924,7 +3947,7 @@ impl<'a> Parser<'a> { if !attributes_box.is_empty() { let last_span = self.last_span; self.span_err(last_span, - Parser::expected_item_err(attributes_box.index(&FullRange))); + Parser::expected_item_err(&attributes_box[])); } let hi = self.span.hi; @@ -4367,8 +4390,8 @@ impl<'a> Parser<'a> { }, _ => { let token_str = self.this_token_to_string(); - self.fatal(format!("expected `self`, found `{}`", - token_str).index(&FullRange)) + self.fatal(&format!("expected `self`, found `{}`", + token_str)[]) } } } @@ -4521,8 +4544,8 @@ impl<'a> Parser<'a> { } _ => { let token_str = self.this_token_to_string(); - self.fatal(format!("expected `,` or `)`, found `{}`", - token_str).index(&FullRange)) + self.fatal(&format!("expected `,` or `)`, found `{}`", + token_str)[]) } } } @@ -4698,7 +4721,7 @@ impl<'a> Parser<'a> { let (inner_attrs, body) = self.parse_inner_attrs_and_block(); let body_span = body.span; let mut new_attrs = attrs; - new_attrs.push_all(inner_attrs.index(&FullRange)); + new_attrs.push_all(&inner_attrs[]); (ast::MethDecl(ident, generics, abi, @@ -4915,17 +4938,17 @@ impl<'a> Parser<'a> { } if fields.len() == 0 { - self.fatal(format!("unit-like struct definition should be \ + self.fatal(&format!("unit-like struct definition should be \ written as `struct {};`", - token::get_ident(class_name.clone())).index(&FullRange)); + token::get_ident(class_name.clone()))[]); } self.bump(); } else { let token_str = self.this_token_to_string(); - self.fatal(format!("expected `where`, or `{}` after struct \ + self.fatal(&format!("expected `where`, or `{}` after struct \ name, found `{}`", "{", - token_str).index(&FullRange)); + token_str)[]); } fields @@ -4954,9 +4977,9 @@ impl<'a> Parser<'a> { }); if fields.len() == 0 { - self.fatal(format!("unit-like struct definition should be \ + self.fatal(&format!("unit-like struct definition should be \ written as `struct {};`", - token::get_ident(class_name.clone())).index(&FullRange)); + token::get_ident(class_name.clone()))[]); } self.parse_where_clause(generics); @@ -4970,8 +4993,8 @@ impl<'a> Parser<'a> { // This case is where we see: `struct Foo<T>;` } else { let token_str = self.this_token_to_string(); - self.fatal(format!("expected `where`, `{}`, `(`, or `;` after struct \ - name, found `{}`", "{", token_str).index(&FullRange)); + self.fatal(&format!("expected `where`, `{}`, `(`, or `;` after struct \ + name, found `{}`", "{", token_str)[]); } } @@ -4990,8 +5013,8 @@ impl<'a> Parser<'a> { let span = self.span; let token_str = self.this_token_to_string(); self.span_fatal_help(span, - format!("expected `,`, or `}}`, found `{}`", - token_str).index(&FullRange), + &format!("expected `,`, or `}}`, found `{}`", + token_str)[], "struct fields should be separated by commas") } } @@ -5078,7 +5101,7 @@ impl<'a> Parser<'a> { let mut attrs = self.parse_outer_attributes(); if first { let mut tmp = attrs_remaining.clone(); - tmp.push_all(attrs.index(&FullRange)); + tmp.push_all(&attrs[]); attrs = tmp; first = false; } @@ -5094,8 +5117,8 @@ impl<'a> Parser<'a> { } _ => { let token_str = self.this_token_to_string(); - self.fatal(format!("expected item, found `{}`", - token_str).index(&FullRange)) + self.fatal(&format!("expected item, found `{}`", + token_str)[]) } } } @@ -5104,7 +5127,7 @@ impl<'a> Parser<'a> { // We parsed attributes for the first item but didn't find it let last_span = self.last_span; self.span_err(last_span, - Parser::expected_item_err(attrs_remaining.index(&FullRange))); + Parser::expected_item_err(&attrs_remaining[])); } ast::Mod { @@ -5174,7 +5197,7 @@ impl<'a> Parser<'a> { -> (ast::Item_, Vec<ast::Attribute> ) { let mut prefix = Path::new(self.sess.span_diagnostic.cm.span_to_filename(self.span)); prefix.pop(); - let mod_path = Path::new(".").join_many(self.mod_path_stack.index(&FullRange)); + let mod_path = Path::new(".").join_many(&self.mod_path_stack[]); let dir_path = prefix.join(&mod_path); let mod_string = token::get_ident(id); let (file_path, owns_directory) = match ::attr::first_attr_value_str_by_name( @@ -5184,8 +5207,8 @@ impl<'a> Parser<'a> { let mod_name = mod_string.get().to_string(); let default_path_str = format!("{}.rs", mod_name); let secondary_path_str = format!("{}/mod.rs", mod_name); - let default_path = dir_path.join(default_path_str.index(&FullRange)); - let secondary_path = dir_path.join(secondary_path_str.index(&FullRange)); + let default_path = dir_path.join(&default_path_str[]); + let secondary_path = dir_path.join(&secondary_path_str[]); let default_exists = default_path.exists(); let secondary_exists = secondary_path.exists(); @@ -5197,16 +5220,16 @@ impl<'a> Parser<'a> { None => self.root_module_name.as_ref().unwrap().clone(), }; self.span_note(id_sp, - format!("maybe move this module `{0}` \ + &format!("maybe move this module `{0}` \ to its own directory via \ `{0}/mod.rs`", - this_module).index(&FullRange)); + this_module)[]); if default_exists || secondary_exists { self.span_note(id_sp, - format!("... or maybe `use` the module \ + &format!("... or maybe `use` the module \ `{}` instead of possibly \ redeclaring it", - mod_name).index(&FullRange)); + mod_name)[]); } self.abort_if_errors(); } @@ -5216,22 +5239,22 @@ impl<'a> Parser<'a> { (false, true) => (secondary_path, true), (false, false) => { self.span_fatal_help(id_sp, - format!("file not found for module `{}`", - mod_name).index(&FullRange), - format!("name the file either {} or {} inside \ + &format!("file not found for module `{}`", + mod_name)[], + &format!("name the file either {} or {} inside \ the directory {:?}", default_path_str, secondary_path_str, - dir_path.display()).index(&FullRange)); + dir_path.display())[]); } (true, true) => { self.span_fatal_help( id_sp, - format!("file for module `{}` found at both {} \ + &format!("file for module `{}` found at both {} \ and {}", mod_name, default_path_str, - secondary_path_str).index(&FullRange), + secondary_path_str)[], "delete or rename one of them to remove the ambiguity"); } } @@ -5253,11 +5276,11 @@ impl<'a> Parser<'a> { let mut err = String::from_str("circular modules: "); let len = included_mod_stack.len(); for p in included_mod_stack.slice(i, len).iter() { - err.push_str(p.display().as_cow().index(&FullRange)); + err.push_str(&p.display().as_cow()[]); err.push_str(" -> "); } - err.push_str(path.display().as_cow().index(&FullRange)); - self.span_fatal(id_sp, err.index(&FullRange)); + err.push_str(&path.display().as_cow()[]); + self.span_fatal(id_sp, &err[]); } None => () } @@ -5338,7 +5361,7 @@ impl<'a> Parser<'a> { if !attrs_remaining.is_empty() { let last_span = self.last_span; self.span_err(last_span, - Parser::expected_item_err(attrs_remaining.index(&FullRange))); + Parser::expected_item_err(&attrs_remaining[])); } assert!(self.token == token::CloseDelim(token::Brace)); ast::ForeignMod { @@ -5377,9 +5400,9 @@ impl<'a> Parser<'a> { self.span_err(span, "expected `;`, found `as`"); self.span_help(span, - format!("perhaps you meant to enclose the crate name `{}` in \ + &format!("perhaps you meant to enclose the crate name `{}` in \ a string?", - the_ident.as_str()).index(&FullRange)); + the_ident.as_str())[]); None } else { None @@ -5403,9 +5426,9 @@ impl<'a> Parser<'a> { let span = self.span; let token_str = self.this_token_to_string(); self.span_fatal(span, - format!("expected extern crate name but \ + &format!("expected extern crate name but \ found `{}`", - token_str).index(&FullRange)); + token_str)[]); } }; @@ -5501,9 +5524,9 @@ impl<'a> Parser<'a> { let struct_def = self.parse_struct_def(); if struct_def.fields.len() == 0 { self.span_err(start_span, - format!("unit-like struct variant should be written \ + &format!("unit-like struct variant should be written \ without braces, as `{},`", - token::get_ident(ident)).index(&FullRange)); + token::get_ident(ident))[]); } kind = StructVariantKind(struct_def); } else if self.check(&token::OpenDelim(token::Paren)) { @@ -5585,10 +5608,10 @@ impl<'a> Parser<'a> { let last_span = self.last_span; self.span_err( last_span, - format!("illegal ABI: expected one of [{}], \ + &format!("illegal ABI: expected one of [{}], \ found `{}`", abi::all_names().connect(", "), - the_string).index(&FullRange)); + the_string)[]); None } } @@ -5647,10 +5670,10 @@ impl<'a> Parser<'a> { if next_is_mod { let last_span = self.last_span; self.span_err(mk_sp(lo, last_span.hi), - format!("`extern mod` is obsolete, use \ + &format!("`extern mod` is obsolete, use \ `extern crate` instead \ to refer to external \ - crates.").index(&FullRange)) + crates.")[]) } return self.parse_item_extern_crate(lo, visibility, attrs); } @@ -5677,8 +5700,8 @@ impl<'a> Parser<'a> { let span = self.span; let token_str = self.this_token_to_string(); self.span_fatal(span, - format!("expected `{}` or `fn`, found `{}`", "{", - token_str).index(&FullRange)); + &format!("expected `{}` or `fn`, found `{}`", "{", + token_str)[]); } if self.eat_keyword(keywords::Virtual) { @@ -5791,7 +5814,7 @@ impl<'a> Parser<'a> { if self.eat_keyword(keywords::Mod) { // MODULE ITEM let (ident, item_, extra_attrs) = - self.parse_item_mod(attrs.index(&FullRange)); + self.parse_item_mod(&attrs[]); let last_span = self.last_span; let item = self.mk_item(lo, last_span.hi, @@ -6131,7 +6154,7 @@ impl<'a> Parser<'a> { macros_allowed: bool) -> ParsedItemsAndViewItems { let mut attrs = first_item_attrs; - attrs.push_all(self.parse_outer_attributes().index(&FullRange)); + attrs.push_all(&self.parse_outer_attributes()[]); // First, parse view items. let mut view_items : Vec<ast::ViewItem> = Vec::new(); let mut items = Vec::new(); @@ -6213,7 +6236,7 @@ impl<'a> Parser<'a> { macros_allowed: bool) -> ParsedItemsAndViewItems { let mut attrs = first_item_attrs; - attrs.push_all(self.parse_outer_attributes().index(&FullRange)); + attrs.push_all(&self.parse_outer_attributes()[]); let mut foreign_items = Vec::new(); loop { match self.parse_foreign_item(attrs, macros_allowed) { diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs index 43786738910..4b3573f84c5 100644 --- a/src/libsyntax/parse/token.rs +++ b/src/libsyntax/parse/token.rs @@ -480,7 +480,7 @@ macro_rules! declare_special_idents_and_keywords {( $(init_vec.push($si_str);)* $(init_vec.push($sk_str);)* $(init_vec.push($rk_str);)* - interner::StrInterner::prefill(init_vec.index(&FullRange)) + interner::StrInterner::prefill(&init_vec[]) } }} @@ -629,7 +629,7 @@ impl InternedString { #[inline] pub fn get<'a>(&'a self) -> &'a str { - self.string.index(&FullRange) + &self.string[] } } @@ -659,41 +659,41 @@ impl fmt::Show for InternedString { impl fmt::String for InternedString { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "{}", self.string.index(&FullRange)) + write!(f, "{}", &self.string[]) } } impl<'a> PartialEq<&'a str> for InternedString { #[inline(always)] fn eq(&self, other: & &'a str) -> bool { - PartialEq::eq(self.string.index(&FullRange), *other) + PartialEq::eq(&self.string[], *other) } #[inline(always)] fn ne(&self, other: & &'a str) -> bool { - PartialEq::ne(self.string.index(&FullRange), *other) + PartialEq::ne(&self.string[], *other) } } impl<'a> PartialEq<InternedString > for &'a str { #[inline(always)] fn eq(&self, other: &InternedString) -> bool { - PartialEq::eq(*self, other.string.index(&FullRange)) + PartialEq::eq(*self, &other.string[]) } #[inline(always)] fn ne(&self, other: &InternedString) -> bool { - PartialEq::ne(*self, other.string.index(&FullRange)) + PartialEq::ne(*self, &other.string[]) } } impl Decodable for InternedString { fn decode<D: Decoder>(d: &mut D) -> Result<InternedString, D::Error> { - Ok(get_name(get_ident_interner().intern(try!(d.read_str()).index(&FullRange)))) + Ok(get_name(get_ident_interner().intern(&try!(d.read_str())[]))) } } impl Encodable for InternedString { fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> { - s.emit_str(self.string.index(&FullRange)) + s.emit_str(&self.string[]) } } diff --git a/src/libsyntax/print/pp.rs b/src/libsyntax/print/pp.rs index 52306075c21..b69b812c958 100644 --- a/src/libsyntax/print/pp.rs +++ b/src/libsyntax/print/pp.rs @@ -138,9 +138,9 @@ pub fn buf_str(toks: Vec<Token>, if i != left { s.push_str(", "); } - s.push_str(format!("{}={}", + s.push_str(&format!("{}={}", szs[i], - tok_str(toks[i].clone())).index(&FullRange)); + tok_str(toks[i].clone()))[]); i += 1u; i %= n; } @@ -602,7 +602,7 @@ impl Printer { assert_eq!(l, len); // assert!(l <= space); self.space -= len; - self.print_str(s.index(&FullRange)) + self.print_str(&s[]) } Eof => { // Eof should never get here. diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index 87dcc9e70f4..9b6f8e6002d 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -114,7 +114,7 @@ pub fn print_crate<'a>(cm: &'a CodeMap, out, ann, is_expanded); - try!(s.print_mod(&krate.module, krate.attrs.index(&FullRange))); + try!(s.print_mod(&krate.module, &krate.attrs[])); try!(s.print_remaining_comments()); eof(&mut s.s) } @@ -580,7 +580,7 @@ impl<'a> State<'a> { pub fn synth_comment(&mut self, text: String) -> IoResult<()> { try!(word(&mut self.s, "/*")); try!(space(&mut self.s)); - try!(word(&mut self.s, text.index(&FullRange))); + try!(word(&mut self.s, &text[])); try!(space(&mut self.s)); word(&mut self.s, "*/") } @@ -685,7 +685,7 @@ impl<'a> State<'a> { } ast::TyTup(ref elts) => { try!(self.popen()); - try!(self.commasep(Inconsistent, elts.index(&FullRange), + try!(self.commasep(Inconsistent, &elts[], |s, ty| s.print_type(&**ty))); if elts.len() == 1 { try!(word(&mut self.s, ",")); @@ -721,10 +721,10 @@ impl<'a> State<'a> { } ast::TyObjectSum(ref ty, ref bounds) => { try!(self.print_type(&**ty)); - try!(self.print_bounds("+", bounds.index(&FullRange))); + try!(self.print_bounds("+", &bounds[])); } ast::TyPolyTraitRef(ref bounds) => { - try!(self.print_bounds("", bounds.index(&FullRange))); + try!(self.print_bounds("", &bounds[])); } ast::TyQPath(ref qpath) => { try!(word(&mut self.s, "<")); @@ -759,7 +759,7 @@ impl<'a> State<'a> { item: &ast::ForeignItem) -> IoResult<()> { try!(self.hardbreak_if_not_bol()); try!(self.maybe_print_comment(item.span.lo)); - try!(self.print_outer_attributes(item.attrs.index(&FullRange))); + try!(self.print_outer_attributes(&item.attrs[])); match item.node { ast::ForeignItemFn(ref decl, ref generics) => { try!(self.print_fn(&**decl, None, abi::Rust, item.ident, generics, @@ -769,8 +769,8 @@ impl<'a> State<'a> { self.end() // end the outer fn box } ast::ForeignItemStatic(ref t, m) => { - try!(self.head(visibility_qualified(item.vis, - "static").index(&FullRange))); + try!(self.head(&visibility_qualified(item.vis, + "static")[])); if m { try!(self.word_space("mut")); } @@ -787,7 +787,7 @@ impl<'a> State<'a> { fn print_associated_type(&mut self, typedef: &ast::AssociatedType) -> IoResult<()> { - try!(self.print_outer_attributes(typedef.attrs.index(&FullRange))); + try!(self.print_outer_attributes(&typedef.attrs[])); try!(self.word_space("type")); try!(self.print_ty_param(&typedef.ty_param)); word(&mut self.s, ";") @@ -806,12 +806,12 @@ impl<'a> State<'a> { pub fn print_item(&mut self, item: &ast::Item) -> IoResult<()> { try!(self.hardbreak_if_not_bol()); try!(self.maybe_print_comment(item.span.lo)); - try!(self.print_outer_attributes(item.attrs.index(&FullRange))); + try!(self.print_outer_attributes(&item.attrs[])); try!(self.ann.pre(self, NodeItem(item))); match item.node { ast::ItemStatic(ref ty, m, ref expr) => { - try!(self.head(visibility_qualified(item.vis, - "static").index(&FullRange))); + try!(self.head(&visibility_qualified(item.vis, + "static")[])); if m == ast::MutMutable { try!(self.word_space("mut")); } @@ -827,8 +827,8 @@ impl<'a> State<'a> { try!(self.end()); // end the outer cbox } ast::ItemConst(ref ty, ref expr) => { - try!(self.head(visibility_qualified(item.vis, - "const").index(&FullRange))); + try!(self.head(&visibility_qualified(item.vis, + "const")[])); try!(self.print_ident(item.ident)); try!(self.word_space(":")); try!(self.print_type(&**ty)); @@ -851,29 +851,28 @@ impl<'a> State<'a> { item.vis )); try!(word(&mut self.s, " ")); - try!(self.print_block_with_attrs(&**body, item.attrs.index(&FullRange))); + try!(self.print_block_with_attrs(&**body, &item.attrs[])); } ast::ItemMod(ref _mod) => { - try!(self.head(visibility_qualified(item.vis, - "mod").index(&FullRange))); + try!(self.head(&visibility_qualified(item.vis, + "mod")[])); try!(self.print_ident(item.ident)); try!(self.nbsp()); try!(self.bopen()); - try!(self.print_mod(_mod, item.attrs.index(&FullRange))); + try!(self.print_mod(_mod, &item.attrs[])); try!(self.bclose(item.span)); } ast::ItemForeignMod(ref nmod) => { try!(self.head("extern")); - try!(self.word_nbsp(nmod.abi.to_string().index(&FullRange))); + try!(self.word_nbsp(&nmod.abi.to_string()[])); try!(self.bopen()); - try!(self.print_foreign_mod(nmod, item.attrs.index(&FullRange))); + try!(self.print_foreign_mod(nmod, &item.attrs[])); try!(self.bclose(item.span)); } ast::ItemTy(ref ty, ref params) => { try!(self.ibox(indent_unit)); try!(self.ibox(0u)); - try!(self.word_nbsp(visibility_qualified(item.vis, - "type").index(&FullRange))); + try!(self.word_nbsp(&visibility_qualified(item.vis, "type")[])); try!(self.print_ident(item.ident)); try!(self.print_generics(params)); try!(self.end()); // end the inner ibox @@ -895,7 +894,7 @@ impl<'a> State<'a> { )); } ast::ItemStruct(ref struct_def, ref generics) => { - try!(self.head(visibility_qualified(item.vis,"struct").index(&FullRange))); + try!(self.head(&visibility_qualified(item.vis,"struct")[])); try!(self.print_struct(&**struct_def, generics, item.ident, item.span)); } @@ -936,7 +935,7 @@ impl<'a> State<'a> { try!(space(&mut self.s)); try!(self.bopen()); - try!(self.print_inner_attributes(item.attrs.index(&FullRange))); + try!(self.print_inner_attributes(&item.attrs[])); for impl_item in impl_items.iter() { match *impl_item { ast::MethodImplItem(ref meth) => { @@ -967,7 +966,7 @@ impl<'a> State<'a> { real_bounds.push(b); } } - try!(self.print_bounds(":", real_bounds.index(&FullRange))); + try!(self.print_bounds(":", &real_bounds[])); try!(self.print_where_clause(generics)); try!(word(&mut self.s, " ")); try!(self.bopen()); @@ -985,7 +984,7 @@ impl<'a> State<'a> { try!(self.print_ident(item.ident)); try!(self.cbox(indent_unit)); try!(self.popen()); - try!(self.print_tts(tts.index(&FullRange))); + try!(self.print_tts(&tts[])); try!(self.pclose()); try!(word(&mut self.s, ";")); try!(self.end()); @@ -1019,12 +1018,12 @@ impl<'a> State<'a> { generics: &ast::Generics, ident: ast::Ident, span: codemap::Span, visibility: ast::Visibility) -> IoResult<()> { - try!(self.head(visibility_qualified(visibility, "enum").index(&FullRange))); + try!(self.head(&visibility_qualified(visibility, "enum")[])); try!(self.print_ident(ident)); try!(self.print_generics(generics)); try!(self.print_where_clause(generics)); try!(space(&mut self.s)); - self.print_variants(enum_definition.variants.index(&FullRange), span) + self.print_variants(&enum_definition.variants[], span) } pub fn print_variants(&mut self, @@ -1034,7 +1033,7 @@ impl<'a> State<'a> { for v in variants.iter() { try!(self.space_if_not_bol()); try!(self.maybe_print_comment(v.span.lo)); - try!(self.print_outer_attributes(v.node.attrs.index(&FullRange))); + try!(self.print_outer_attributes(&v.node.attrs[])); try!(self.ibox(indent_unit)); try!(self.print_variant(&**v)); try!(word(&mut self.s, ",")); @@ -1062,7 +1061,7 @@ impl<'a> State<'a> { if !struct_def.fields.is_empty() { try!(self.popen()); try!(self.commasep( - Inconsistent, struct_def.fields.index(&FullRange), + Inconsistent, &struct_def.fields[], |s, field| { match field.node.kind { ast::NamedField(..) => panic!("unexpected named field"), @@ -1092,7 +1091,7 @@ impl<'a> State<'a> { ast::NamedField(ident, visibility) => { try!(self.hardbreak_if_not_bol()); try!(self.maybe_print_comment(field.span.lo)); - try!(self.print_outer_attributes(field.node.attrs.index(&FullRange))); + try!(self.print_outer_attributes(&field.node.attrs[])); try!(self.print_visibility(visibility)); try!(self.print_ident(ident)); try!(self.word_nbsp(":")); @@ -1116,7 +1115,7 @@ impl<'a> State<'a> { pub fn print_tt(&mut self, tt: &ast::TokenTree) -> IoResult<()> { match *tt { ast::TtToken(_, ref tk) => { - try!(word(&mut self.s, token_to_string(tk).index(&FullRange))); + try!(word(&mut self.s, &token_to_string(tk)[])); match *tk { parse::token::DocComment(..) => { hardbreak(&mut self.s) @@ -1125,11 +1124,11 @@ impl<'a> State<'a> { } } ast::TtDelimited(_, ref delimed) => { - try!(word(&mut self.s, token_to_string(&delimed.open_token()).index(&FullRange))); + try!(word(&mut self.s, &token_to_string(&delimed.open_token())[])); try!(space(&mut self.s)); - try!(self.print_tts(delimed.tts.index(&FullRange))); + try!(self.print_tts(&delimed.tts[])); try!(space(&mut self.s)); - word(&mut self.s, token_to_string(&delimed.close_token()).index(&FullRange)) + word(&mut self.s, &token_to_string(&delimed.close_token())[]) }, ast::TtSequence(_, ref seq) => { try!(word(&mut self.s, "$(")); @@ -1139,7 +1138,7 @@ impl<'a> State<'a> { try!(word(&mut self.s, ")")); match seq.separator { Some(ref tk) => { - try!(word(&mut self.s, token_to_string(tk).index(&FullRange))); + try!(word(&mut self.s, &token_to_string(tk)[])); } None => {}, } @@ -1170,7 +1169,7 @@ impl<'a> State<'a> { if !args.is_empty() { try!(self.popen()); try!(self.commasep(Consistent, - args.index(&FullRange), + &args[], |s, arg| s.print_type(&*arg.ty))); try!(self.pclose()); } @@ -1194,7 +1193,7 @@ impl<'a> State<'a> { pub fn print_ty_method(&mut self, m: &ast::TypeMethod) -> IoResult<()> { try!(self.hardbreak_if_not_bol()); try!(self.maybe_print_comment(m.span.lo)); - try!(self.print_outer_attributes(m.attrs.index(&FullRange))); + try!(self.print_outer_attributes(&m.attrs[])); try!(self.print_ty_fn(None, None, m.unsafety, @@ -1226,7 +1225,7 @@ impl<'a> State<'a> { pub fn print_method(&mut self, meth: &ast::Method) -> IoResult<()> { try!(self.hardbreak_if_not_bol()); try!(self.maybe_print_comment(meth.span.lo)); - try!(self.print_outer_attributes(meth.attrs.index(&FullRange))); + try!(self.print_outer_attributes(&meth.attrs[])); match meth.node { ast::MethDecl(ident, ref generics, @@ -1244,7 +1243,7 @@ impl<'a> State<'a> { Some(&explicit_self.node), vis)); try!(word(&mut self.s, " ")); - self.print_block_with_attrs(&**body, meth.attrs.index(&FullRange)) + self.print_block_with_attrs(&**body, &meth.attrs[]) }, ast::MethMac(codemap::Spanned { node: ast::MacInvocTT(ref pth, ref tts, _), ..}) => { @@ -1253,7 +1252,7 @@ impl<'a> State<'a> { try!(word(&mut self.s, "! ")); try!(self.cbox(indent_unit)); try!(self.popen()); - try!(self.print_tts(tts.index(&FullRange))); + try!(self.print_tts(&tts[])); try!(self.pclose()); try!(word(&mut self.s, ";")); self.end() @@ -1520,7 +1519,7 @@ impl<'a> State<'a> { ast::ExprVec(ref exprs) => { try!(self.ibox(indent_unit)); try!(word(&mut self.s, "[")); - try!(self.commasep_exprs(Inconsistent, exprs.index(&FullRange))); + try!(self.commasep_exprs(Inconsistent, &exprs[])); try!(word(&mut self.s, "]")); try!(self.end()); } @@ -1541,7 +1540,7 @@ impl<'a> State<'a> { try!(word(&mut self.s, "{")); try!(self.commasep_cmnt( Consistent, - fields.index(&FullRange), + &fields[], |s, field| { try!(s.ibox(indent_unit)); try!(s.print_ident(field.ident.node)); @@ -1568,7 +1567,7 @@ impl<'a> State<'a> { } ast::ExprTup(ref exprs) => { try!(self.popen()); - try!(self.commasep_exprs(Inconsistent, exprs.index(&FullRange))); + try!(self.commasep_exprs(Inconsistent, &exprs[])); if exprs.len() == 1 { try!(word(&mut self.s, ",")); } @@ -1576,7 +1575,7 @@ impl<'a> State<'a> { } ast::ExprCall(ref func, ref args) => { try!(self.print_expr_maybe_paren(&**func)); - try!(self.print_call_post(args.index(&FullRange))); + try!(self.print_call_post(&args[])); } ast::ExprMethodCall(ident, ref tys, ref args) => { let base_args = args.slice_from(1); @@ -1585,7 +1584,7 @@ impl<'a> State<'a> { try!(self.print_ident(ident.node)); if tys.len() > 0u { try!(word(&mut self.s, "::<")); - try!(self.commasep(Inconsistent, tys.index(&FullRange), + try!(self.commasep(Inconsistent, &tys[], |s, ty| s.print_type(&**ty))); try!(word(&mut self.s, ">")); } @@ -1782,11 +1781,11 @@ impl<'a> State<'a> { try!(self.print_string(a.asm.get(), a.asm_str_style)); try!(self.word_space(":")); - try!(self.commasep(Inconsistent, a.outputs.index(&FullRange), + try!(self.commasep(Inconsistent, &a.outputs[], |s, &(ref co, ref o, is_rw)| { match co.get().slice_shift_char() { Some(('=', operand)) if is_rw => { - try!(s.print_string(format!("+{}", operand).index(&FullRange), + try!(s.print_string(&format!("+{}", operand)[], ast::CookedStr)) } _ => try!(s.print_string(co.get(), ast::CookedStr)) @@ -1799,7 +1798,7 @@ impl<'a> State<'a> { try!(space(&mut self.s)); try!(self.word_space(":")); - try!(self.commasep(Inconsistent, a.inputs.index(&FullRange), + try!(self.commasep(Inconsistent, &a.inputs[], |s, &(ref co, ref o)| { try!(s.print_string(co.get(), ast::CookedStr)); try!(s.popen()); @@ -1810,7 +1809,7 @@ impl<'a> State<'a> { try!(space(&mut self.s)); try!(self.word_space(":")); - try!(self.commasep(Inconsistent, a.clobbers.index(&FullRange), + try!(self.commasep(Inconsistent, &a.clobbers[], |s, co| { try!(s.print_string(co.get(), ast::CookedStr)); Ok(()) @@ -1884,7 +1883,7 @@ impl<'a> State<'a> { pub fn print_ident(&mut self, ident: ast::Ident) -> IoResult<()> { if self.encode_idents_with_hygiene { let encoded = ident.encode_with_hygiene(); - try!(word(&mut self.s, encoded.index(&FullRange))) + try!(word(&mut self.s, &encoded[])) } else { try!(word(&mut self.s, token::get_ident(ident).get())) } @@ -1892,7 +1891,7 @@ impl<'a> State<'a> { } pub fn print_uint(&mut self, i: uint) -> IoResult<()> { - word(&mut self.s, i.to_string().index(&FullRange)) + word(&mut self.s, &i.to_string()[]) } pub fn print_name(&mut self, name: ast::Name) -> IoResult<()> { @@ -1966,7 +1965,7 @@ impl<'a> State<'a> { } try!(self.commasep( Inconsistent, - data.types.index(&FullRange), + &data.types[], |s, ty| s.print_type(&**ty))); comma = true; } @@ -1989,7 +1988,7 @@ impl<'a> State<'a> { try!(word(&mut self.s, "(")); try!(self.commasep( Inconsistent, - data.inputs.index(&FullRange), + &data.inputs[], |s, ty| s.print_type(&**ty))); try!(word(&mut self.s, ")")); @@ -2042,7 +2041,7 @@ impl<'a> State<'a> { Some(ref args) => { if !args.is_empty() { try!(self.popen()); - try!(self.commasep(Inconsistent, args.index(&FullRange), + try!(self.commasep(Inconsistent, &args[], |s, p| s.print_pat(&**p))); try!(self.pclose()); } @@ -2054,7 +2053,7 @@ impl<'a> State<'a> { try!(self.nbsp()); try!(self.word_space("{")); try!(self.commasep_cmnt( - Consistent, fields.index(&FullRange), + Consistent, &fields[], |s, f| { try!(s.cbox(indent_unit)); if !f.node.is_shorthand { @@ -2075,7 +2074,7 @@ impl<'a> State<'a> { ast::PatTup(ref elts) => { try!(self.popen()); try!(self.commasep(Inconsistent, - elts.index(&FullRange), + &elts[], |s, p| s.print_pat(&**p))); if elts.len() == 1 { try!(word(&mut self.s, ",")); @@ -2103,7 +2102,7 @@ impl<'a> State<'a> { ast::PatVec(ref before, ref slice, ref after) => { try!(word(&mut self.s, "[")); try!(self.commasep(Inconsistent, - before.index(&FullRange), + &before[], |s, p| s.print_pat(&**p))); for p in slice.iter() { if !before.is_empty() { try!(self.word_space(",")); } @@ -2117,7 +2116,7 @@ impl<'a> State<'a> { if !after.is_empty() { try!(self.word_space(",")); } } try!(self.commasep(Inconsistent, - after.index(&FullRange), + &after[], |s, p| s.print_pat(&**p))); try!(word(&mut self.s, "]")); } @@ -2134,7 +2133,7 @@ impl<'a> State<'a> { } try!(self.cbox(indent_unit)); try!(self.ibox(0u)); - try!(self.print_outer_attributes(arm.attrs.index(&FullRange))); + try!(self.print_outer_attributes(&arm.attrs[])); let mut first = true; for p in arm.pats.iter() { if first { @@ -2234,7 +2233,7 @@ impl<'a> State<'a> { // HACK(eddyb) ignore the separately printed self argument. let args = if first { - decl.inputs.index(&FullRange) + &decl.inputs[] } else { decl.inputs.slice_from(1) }; @@ -2400,7 +2399,7 @@ impl<'a> State<'a> { ints.push(i); } - try!(self.commasep(Inconsistent, ints.index(&FullRange), |s, &idx| { + try!(self.commasep(Inconsistent, &ints[], |s, &idx| { if idx < generics.lifetimes.len() { let lifetime = &generics.lifetimes[idx]; s.print_lifetime_def(lifetime) @@ -2417,7 +2416,7 @@ impl<'a> State<'a> { pub fn print_ty_param(&mut self, param: &ast::TyParam) -> IoResult<()> { try!(self.print_ident(param.ident)); - try!(self.print_bounds(":", param.bounds.index(&FullRange))); + try!(self.print_bounds(":", ¶m.bounds[])); match param.default { Some(ref default) => { try!(space(&mut self.s)); @@ -2493,7 +2492,7 @@ impl<'a> State<'a> { try!(word(&mut self.s, name.get())); try!(self.popen()); try!(self.commasep(Consistent, - items.index(&FullRange), + &items[], |s, i| s.print_meta_item(&**i))); try!(self.pclose()); } @@ -2529,7 +2528,7 @@ impl<'a> State<'a> { try!(self.print_path(path, false)); try!(word(&mut self.s, "::{")); } - try!(self.commasep(Inconsistent, idents.index(&FullRange), |s, w| { + try!(self.commasep(Inconsistent, &idents[], |s, w| { match w.node { ast::PathListIdent { name, .. } => { s.print_ident(name) @@ -2547,7 +2546,7 @@ impl<'a> State<'a> { pub fn print_view_item(&mut self, item: &ast::ViewItem) -> IoResult<()> { try!(self.hardbreak_if_not_bol()); try!(self.maybe_print_comment(item.span.lo)); - try!(self.print_outer_attributes(item.attrs.index(&FullRange))); + try!(self.print_outer_attributes(&item.attrs[])); try!(self.print_visibility(item.vis)); match item.node { ast::ViewItemExternCrate(id, ref optional_path, _) => { @@ -2689,7 +2688,7 @@ impl<'a> State<'a> { try!(self.pclose()); } - try!(self.print_bounds(":", bounds.index(&FullRange))); + try!(self.print_bounds(":", &bounds[])); try!(self.print_fn_output(decl)); @@ -2748,7 +2747,7 @@ impl<'a> State<'a> { try!(self.maybe_print_comment(lit.span.lo)); match self.next_lit(lit.span.lo) { Some(ref ltrl) => { - return word(&mut self.s, (*ltrl).lit.index(&FullRange)); + return word(&mut self.s, &(*ltrl).lit[]); } _ => () } @@ -2758,7 +2757,7 @@ impl<'a> State<'a> { let mut res = String::from_str("b'"); ascii::escape_default(byte, |c| res.push(c as char)); res.push('\''); - word(&mut self.s, res.index(&FullRange)) + word(&mut self.s, &res[]) } ast::LitChar(ch) => { let mut res = String::from_str("'"); @@ -2766,36 +2765,36 @@ impl<'a> State<'a> { res.push(c); } res.push('\''); - word(&mut self.s, res.index(&FullRange)) + word(&mut self.s, &res[]) } ast::LitInt(i, t) => { match t { ast::SignedIntLit(st, ast::Plus) => { word(&mut self.s, - ast_util::int_ty_to_string(st, Some(i as i64)).index(&FullRange)) + &ast_util::int_ty_to_string(st, Some(i as i64))[]) } ast::SignedIntLit(st, ast::Minus) => { let istr = ast_util::int_ty_to_string(st, Some(-(i as i64))); word(&mut self.s, - format!("-{}", istr).index(&FullRange)) + &format!("-{}", istr)[]) } ast::UnsignedIntLit(ut) => { word(&mut self.s, ast_util::uint_ty_to_string(ut, Some(i)).as_slice()) } ast::UnsuffixedIntLit(ast::Plus) => { - word(&mut self.s, format!("{}", i).index(&FullRange)) + word(&mut self.s, &format!("{}", i)[]) } ast::UnsuffixedIntLit(ast::Minus) => { - word(&mut self.s, format!("-{}", i).index(&FullRange)) + word(&mut self.s, &format!("-{}", i)[]) } } } ast::LitFloat(ref f, t) => { word(&mut self.s, - format!( + &format!( "{}{}", f.get(), - ast_util::float_ty_to_string(t).index(&FullRange)).index(&FullRange)) + &ast_util::float_ty_to_string(t)[])[]) } ast::LitFloatUnsuffixed(ref f) => word(&mut self.s, f.get()), ast::LitBool(val) => { @@ -2807,7 +2806,7 @@ impl<'a> State<'a> { ascii::escape_default(ch as u8, |ch| escaped.push(ch as char)); } - word(&mut self.s, format!("b\"{}\"", escaped).index(&FullRange)) + word(&mut self.s, &format!("b\"{}\"", escaped)[]) } } } @@ -2848,7 +2847,7 @@ impl<'a> State<'a> { comments::Mixed => { assert_eq!(cmnt.lines.len(), 1u); try!(zerobreak(&mut self.s)); - try!(word(&mut self.s, cmnt.lines[0].index(&FullRange))); + try!(word(&mut self.s, &cmnt.lines[0][])); zerobreak(&mut self.s) } comments::Isolated => { @@ -2857,7 +2856,7 @@ impl<'a> State<'a> { // Don't print empty lines because they will end up as trailing // whitespace if !line.is_empty() { - try!(word(&mut self.s, line.index(&FullRange))); + try!(word(&mut self.s, &line[])); } try!(hardbreak(&mut self.s)); } @@ -2866,13 +2865,13 @@ impl<'a> State<'a> { comments::Trailing => { try!(word(&mut self.s, " ")); if cmnt.lines.len() == 1u { - try!(word(&mut self.s, cmnt.lines[0].index(&FullRange))); + try!(word(&mut self.s, &cmnt.lines[0][])); hardbreak(&mut self.s) } else { try!(self.ibox(0u)); for line in cmnt.lines.iter() { if !line.is_empty() { - try!(word(&mut self.s, line.index(&FullRange))); + try!(word(&mut self.s, &line[])); } try!(hardbreak(&mut self.s)); } @@ -2905,7 +2904,7 @@ impl<'a> State<'a> { string=st)) } }; - word(&mut self.s, st.index(&FullRange)) + word(&mut self.s, &st[]) } pub fn next_comment(&mut self) -> Option<comments::Comment> { @@ -2936,7 +2935,7 @@ impl<'a> State<'a> { Some(abi::Rust) => Ok(()), Some(abi) => { try!(self.word_nbsp("extern")); - self.word_nbsp(abi.to_string().index(&FullRange)) + self.word_nbsp(&abi.to_string()[]) } None => Ok(()) } @@ -2947,7 +2946,7 @@ impl<'a> State<'a> { match opt_abi { Some(abi) => { try!(self.word_nbsp("extern")); - self.word_nbsp(abi.to_string().index(&FullRange)) + self.word_nbsp(&abi.to_string()[]) } None => Ok(()) } @@ -2963,7 +2962,7 @@ impl<'a> State<'a> { if abi != abi::Rust { try!(self.word_nbsp("extern")); - try!(self.word_nbsp(abi.to_string().index(&FullRange))); + try!(self.word_nbsp(&abi.to_string()[])); } word(&mut self.s, "fn") diff --git a/src/libsyntax/ptr.rs b/src/libsyntax/ptr.rs index 8abb46011e6..13a14d069d7 100644 --- a/src/libsyntax/ptr.rs +++ b/src/libsyntax/ptr.rs @@ -37,9 +37,11 @@ //! Moreover, a switch to, e.g. `P<'a, T>` would be easy and mostly automated. use std::fmt::{self, Show}; -use std::hash::Hash; +use std::hash::{Hash, Hasher}; +#[cfg(stage0)] use std::hash::Writer; use std::ops::Deref; use std::ptr; + use serialize::{Encodable, Decodable, Encoder, Decoder}; /// An owned smart pointer. @@ -105,7 +107,14 @@ impl<T: Show> Show for P<T> { } } -impl<S, T: Hash<S>> Hash<S> for P<T> { +#[cfg(stage0)] +impl<S: Writer, T: Hash<S>> Hash<S> for P<T> { + fn hash(&self, state: &mut S) { + (**self).hash(state); + } +} +#[cfg(not(stage0))] +impl<S: Hasher, T: Hash<S>> Hash<S> for P<T> { fn hash(&self, state: &mut S) { (**self).hash(state); } diff --git a/src/libsyntax/std_inject.rs b/src/libsyntax/std_inject.rs index daa51203287..28b9eaa54aa 100644 --- a/src/libsyntax/std_inject.rs +++ b/src/libsyntax/std_inject.rs @@ -40,7 +40,7 @@ pub fn maybe_inject_prelude(krate: ast::Crate) -> ast::Crate { } fn use_std(krate: &ast::Crate) -> bool { - !attr::contains_name(krate.attrs.index(&FullRange), "no_std") + !attr::contains_name(&krate.attrs[], "no_std") } fn no_prelude(attrs: &[ast::Attribute]) -> bool { @@ -48,7 +48,7 @@ fn no_prelude(attrs: &[ast::Attribute]) -> bool { } struct StandardLibraryInjector<'a> { - alt_std_name: Option<String>, + alt_std_name: Option<String> } impl<'a> fold::Folder for StandardLibraryInjector<'a> { @@ -56,7 +56,7 @@ impl<'a> fold::Folder for StandardLibraryInjector<'a> { // The name to use in `extern crate "name" as std;` let actual_crate_name = match self.alt_std_name { - Some(ref s) => token::intern_and_get_ident(s.index(&FullRange)), + Some(ref s) => token::intern_and_get_ident(&s[]), None => token::intern_and_get_ident("std"), }; @@ -84,14 +84,13 @@ impl<'a> fold::Folder for StandardLibraryInjector<'a> { fn inject_crates_ref(krate: ast::Crate, alt_std_name: Option<String>) -> ast::Crate { let mut fold = StandardLibraryInjector { - alt_std_name: alt_std_name, + alt_std_name: alt_std_name }; fold.fold_crate(krate) } struct PreludeInjector<'a>; - impl<'a> fold::Folder for PreludeInjector<'a> { fn fold_crate(&mut self, mut krate: ast::Crate) -> ast::Crate { // Add #![no_std] here, so we don't re-inject when compiling pretty-printed source. @@ -104,27 +103,17 @@ impl<'a> fold::Folder for PreludeInjector<'a> { attr::mark_used(&no_std_attr); krate.attrs.push(no_std_attr); - if !no_prelude(krate.attrs.index(&FullRange)) { - // only add `use std::prelude::*;` if there wasn't a - // `#![no_implicit_prelude]` at the crate level. - // fold_mod() will insert glob path. - let globs_attr = attr::mk_attr_inner(attr::mk_attr_id(), - attr::mk_list_item( - InternedString::new("feature"), - vec!( - attr::mk_word_item(InternedString::new("globs")), - ))); - // std_inject runs after feature checking so manually mark this attr - attr::mark_used(&globs_attr); - krate.attrs.push(globs_attr); - + // only add `use std::prelude::*;` if there wasn't a + // `#![no_implicit_prelude]` at the crate level. + // fold_mod() will insert glob path. + if !no_prelude(&krate.attrs[]) { krate.module = self.fold_mod(krate.module); } krate } fn fold_item(&mut self, item: P<ast::Item>) -> SmallVector<P<ast::Item>> { - if !no_prelude(item.attrs.index(&FullRange)) { + if !no_prelude(&item.attrs[]) { // only recur if there wasn't `#![no_implicit_prelude]` // on this item, i.e. this means that the prelude is not // implicitly imported though the whole subtree diff --git a/src/libsyntax/test.rs b/src/libsyntax/test.rs index 711715355e9..bacfa0bbfce 100644 --- a/src/libsyntax/test.rs +++ b/src/libsyntax/test.rs @@ -73,14 +73,14 @@ pub fn modify_for_testing(sess: &ParseSess, // We generate the test harness when building in the 'test' // configuration, either with the '--test' or '--cfg test' // command line options. - let should_test = attr::contains_name(krate.config.index(&FullRange), "test"); + let should_test = attr::contains_name(&krate.config[], "test"); // Check for #[reexport_test_harness_main = "some_name"] which // creates a `use some_name = __test::main;`. This needs to be // unconditional, so that the attribute is still marked as used in // non-test builds. let reexport_test_harness_main = - attr::first_attr_value_str_by_name(krate.attrs.index(&FullRange), + attr::first_attr_value_str_by_name(&krate.attrs[], "reexport_test_harness_main"); if should_test { @@ -119,7 +119,7 @@ impl<'a> fold::Folder for TestHarnessGenerator<'a> { self.cx.path.push(ident); } debug!("current path: {}", - ast_util::path_name_i(self.cx.path.index(&FullRange))); + ast_util::path_name_i(&self.cx.path[])); if is_test_fn(&self.cx, &*i) || is_bench_fn(&self.cx, &*i) { match i.node { @@ -277,8 +277,8 @@ fn strip_test_functions(krate: ast::Crate) -> ast::Crate { // When not compiling with --test we should not compile the // #[test] functions config::strip_items(krate, |attrs| { - !attr::contains_name(attrs.index(&FullRange), "test") && - !attr::contains_name(attrs.index(&FullRange), "bench") + !attr::contains_name(&attrs[], "test") && + !attr::contains_name(&attrs[], "bench") }) } @@ -291,7 +291,7 @@ enum HasTestSignature { fn is_test_fn(cx: &TestCtxt, i: &ast::Item) -> bool { - let has_test_attr = attr::contains_name(i.attrs.index(&FullRange), "test"); + let has_test_attr = attr::contains_name(&i.attrs[], "test"); fn has_test_signature(i: &ast::Item) -> HasTestSignature { match &i.node { @@ -329,7 +329,7 @@ fn is_test_fn(cx: &TestCtxt, i: &ast::Item) -> bool { } fn is_bench_fn(cx: &TestCtxt, i: &ast::Item) -> bool { - let has_bench_attr = attr::contains_name(i.attrs.index(&FullRange), "bench"); + let has_bench_attr = attr::contains_name(&i.attrs[], "bench"); fn has_test_signature(i: &ast::Item) -> bool { match i.node { @@ -384,7 +384,7 @@ We're going to be building a module that looks more or less like: mod __test { extern crate test (name = "test", vers = "..."); fn main() { - test::test_main_static(::os::args().index(&FullRange), tests) + test::test_main_static(&::os::args()[], tests) } static tests : &'static [test::TestDescAndFn] = &[ @@ -510,8 +510,8 @@ fn mk_tests(cx: &TestCtxt) -> P<ast::Item> { } fn is_test_crate(krate: &ast::Crate) -> bool { - match attr::find_crate_name(krate.attrs.index(&FullRange)) { - Some(ref s) if "test" == s.get().index(&FullRange) => true, + match attr::find_crate_name(&krate.attrs[]) { + Some(ref s) if "test" == &s.get()[] => true, _ => false } } @@ -551,11 +551,11 @@ fn mk_test_desc_and_fn_rec(cx: &TestCtxt, test: &Test) -> P<ast::Expr> { // creates $name: $expr let field = |&: name, expr| ecx.field_imm(span, ecx.ident_of(name), expr); - debug!("encoding {}", ast_util::path_name_i(path.index(&FullRange))); + debug!("encoding {}", ast_util::path_name_i(&path[])); // path to the #[test] function: "foo::bar::baz" - let path_string = ast_util::path_name_i(path.index(&FullRange)); - let name_expr = ecx.expr_str(span, token::intern_and_get_ident(path_string.index(&FullRange))); + let path_string = ast_util::path_name_i(&path[]); + let name_expr = ecx.expr_str(span, token::intern_and_get_ident(&path_string[])); // self::test::StaticTestName($name_expr) let name_expr = ecx.expr_call(span, diff --git a/src/libsyntax/util/interner.rs b/src/libsyntax/util/interner.rs index 93de342d487..5dca39f1aea 100644 --- a/src/libsyntax/util/interner.rs +++ b/src/libsyntax/util/interner.rs @@ -20,6 +20,7 @@ use std::cmp::Ordering; use std::collections::HashMap; use std::fmt; use std::hash::Hash; +use std::collections::hash_map::Hasher; use std::ops::Deref; use std::rc::Rc; @@ -28,8 +29,8 @@ pub struct Interner<T> { vect: RefCell<Vec<T> >, } -// when traits can extend traits, we should extend index<Name,T> to get .index(&FullRange) -impl<T: Eq + Hash + Clone + 'static> Interner<T> { +// when traits can extend traits, we should extend index<Name,T> to get [] +impl<T: Eq + Hash<Hasher> + Clone + 'static> Interner<T> { pub fn new() -> Interner<T> { Interner { map: RefCell::new(HashMap::new()), @@ -78,7 +79,7 @@ impl<T: Eq + Hash + Clone + 'static> Interner<T> { } pub fn find<Q: ?Sized>(&self, val: &Q) -> Option<Name> - where Q: BorrowFrom<T> + Eq + Hash { + where Q: BorrowFrom<T> + Eq + Hash<Hasher> { let map = self.map.borrow(); match (*map).get(val) { Some(v) => Some(*v), @@ -109,27 +110,27 @@ impl Eq for RcStr {} impl Ord for RcStr { fn cmp(&self, other: &RcStr) -> Ordering { - self.index(&FullRange).cmp(other.index(&FullRange)) + self[].cmp(&other[]) } } impl fmt::Show for RcStr { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { use std::fmt::Show; - self.index(&FullRange).fmt(f) + self[].fmt(f) } } impl BorrowFrom<RcStr> for str { fn borrow_from(owned: &RcStr) -> &str { - owned.string.index(&FullRange) + &owned.string[] } } impl Deref for RcStr { type Target = str; - fn deref(&self) -> &str { self.string.index(&FullRange) } + fn deref(&self) -> &str { &self.string[] } } /// A StrInterner differs from Interner<String> in that it accepts @@ -139,7 +140,7 @@ pub struct StrInterner { vect: RefCell<Vec<RcStr> >, } -/// When traits can extend traits, we should extend index<Name,T> to get .index(&FullRange) +/// When traits can extend traits, we should extend index<Name,T> to get [] impl StrInterner { pub fn new() -> StrInterner { StrInterner { @@ -203,7 +204,7 @@ impl StrInterner { } pub fn find<Q: ?Sized>(&self, val: &Q) -> Option<Name> - where Q: BorrowFrom<RcStr> + Eq + Hash { + where Q: BorrowFrom<RcStr> + Eq + Hash<Hasher> { match (*self.map.borrow()).get(val) { Some(v) => Some(*v), None => None, diff --git a/src/libterm/lib.rs b/src/libterm/lib.rs index c953f591d80..b4f224cb4a7 100644 --- a/src/libterm/lib.rs +++ b/src/libterm/lib.rs @@ -40,6 +40,7 @@ #![crate_name = "term"] #![experimental = "use the crates.io `term` library instead"] +#![staged_api] #![crate_type = "rlib"] #![crate_type = "dylib"] #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png", @@ -49,6 +50,7 @@ #![allow(unknown_features)] #![feature(slicing_syntax)] +#![feature(box_syntax)] #![deny(missing_docs)] #[macro_use] extern crate log; diff --git a/src/libterm/terminfo/mod.rs b/src/libterm/terminfo/mod.rs index f2dcdc6160a..4933938f338 100644 --- a/src/libterm/terminfo/mod.rs +++ b/src/libterm/terminfo/mod.rs @@ -180,7 +180,7 @@ impl<T: Writer+Send> TerminfoTerminal<T> { } }; - let entry = open(term.index(&FullRange)); + let entry = open(&term[]); if entry.is_err() { if os::getenv("MSYSCON").map_or(false, |s| { "mintty.exe" == s diff --git a/src/libterm/terminfo/parser/compiled.rs b/src/libterm/terminfo/parser/compiled.rs index 7a06849abd1..4735b6e8f2a 100644 --- a/src/libterm/terminfo/parser/compiled.rs +++ b/src/libterm/terminfo/parser/compiled.rs @@ -284,13 +284,13 @@ pub fn parse(file: &mut io::Reader, longnames: bool) // Find the offset of the NUL we want to go to - let nulpos = string_table.index(&((offset as uint) .. (string_table_bytes as uint))) + let nulpos = string_table[(offset as uint) .. (string_table_bytes as uint)] .iter().position(|&b| b == 0); match nulpos { Some(len) => { string_map.insert(name.to_string(), - string_table.index(&((offset as uint) .. - (offset as uint + len))).to_vec()) + string_table[(offset as uint) .. + (offset as uint + len)].to_vec()) }, None => { return Err("invalid file: missing NUL in \ diff --git a/src/libterm/terminfo/searcher.rs b/src/libterm/terminfo/searcher.rs index 2651be1ebb8..1fca3c62f78 100644 --- a/src/libterm/terminfo/searcher.rs +++ b/src/libterm/terminfo/searcher.rs @@ -61,13 +61,13 @@ pub fn get_dbpath_for_term(term: &str) -> Option<Box<Path>> { for p in dirs_to_search.iter() { if p.exists() { let f = first_char.to_string(); - let newp = p.join_many(&[f.index(&FullRange), term]); + let newp = p.join_many(&[&f[], term]); if newp.exists() { return Some(box newp); } // on some installations the dir is named after the hex of the char (e.g. OS X) let f = format!("{:x}", first_char as uint); - let newp = p.join_many(&[f.index(&FullRange), term]); + let newp = p.join_many(&[&f[], term]); if newp.exists() { return Some(box newp); } diff --git a/src/libtest/lib.rs b/src/libtest/lib.rs index 68d06cc4dab..d04308814f8 100644 --- a/src/libtest/lib.rs +++ b/src/libtest/lib.rs @@ -25,12 +25,15 @@ #![crate_name = "test"] #![experimental] +#![staged_api] #![crate_type = "rlib"] #![crate_type = "dylib"] #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png", html_favicon_url = "http://www.rust-lang.org/favicon.ico", html_root_url = "http://doc.rust-lang.org/nightly/")] +#![allow(unknown_features)] #![feature(asm, slicing_syntax)] +#![feature(box_syntax)] extern crate getopts; extern crate regex; @@ -948,7 +951,7 @@ fn should_sort_failures_before_printing_them() { st.write_failures().unwrap(); let s = match st.out { - Raw(ref m) => String::from_utf8_lossy(m.index(&FullRange)), + Raw(ref m) => String::from_utf8_lossy(&m[]), Pretty(_) => unreachable!() }; diff --git a/src/libtest/stats.rs b/src/libtest/stats.rs index 1abb52459e4..6061c4fd1d3 100644 --- a/src/libtest/stats.rs +++ b/src/libtest/stats.rs @@ -12,7 +12,7 @@ use std::cmp::Ordering::{self, Less, Greater, Equal}; use std::collections::hash_map::Entry::{Occupied, Vacant}; -use std::collections::hash_map; +use std::collections::hash_map::{self, Hasher}; use std::fmt; use std::hash::Hash; use std::io; @@ -440,7 +440,7 @@ pub fn write_boxplot<W: Writer, T: Float + fmt::String + fmt::Show + FromPrimiti /// Returns a HashMap with the number of occurrences of every element in the /// sequence that the iterator exposes. pub fn freq_count<T, U>(mut iter: T) -> hash_map::HashMap<U, uint> - where T: Iterator<Item=U>, U: Eq + Clone + Hash + where T: Iterator<Item=U>, U: Eq + Clone + Hash<Hasher> { let mut map: hash_map::HashMap<U,uint> = hash_map::HashMap::new(); for elem in iter { diff --git a/src/libunicode/lib.rs b/src/libunicode/lib.rs index db98b429e40..33b5bc4b5a4 100644 --- a/src/libunicode/lib.rs +++ b/src/libunicode/lib.rs @@ -22,6 +22,7 @@ #![crate_name = "unicode"] #![experimental] +#![staged_api] #![crate_type = "rlib"] #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png", html_favicon_url = "http://www.rust-lang.org/favicon.ico", diff --git a/src/snapshots.txt b/src/snapshots.txt index d6134898cbd..aa31974c67a 100644 --- a/src/snapshots.txt +++ b/src/snapshots.txt @@ -1,3 +1,12 @@ +S 2015-01-07 9e4e524 + freebsd-x86_64 2563d33151bce1bbe08a85d712564bddc7503fc6 + linux-i386 d8b73fc9aa3ad72ce1408a41e35d78dba10eb4d4 + linux-x86_64 697880d3640e981bbbf23284363e8e9a158b588d + macos-i386 a73b1fc03e8cac747aab0aa186292bb4332a7a98 + macos-x86_64 e4ae2670ea4ba5c2e5b4245409c9cab45c9eeb5b + winnt-i386 ddffa59d9605aa05e83e8f664db802da512611e9 + winnt-x86_64 a56261ebbc580c6c14b1c1d0be25010f5201dc3f + S 2015-01-06 340ac04 freebsd-x86_64 5413b8931d7076e90c873e0cc7a43e0793c2b17a linux-i386 cacb8e3ad15937916e455d8f63e740c30a807b10 diff --git a/src/test/auxiliary/cci_nested_lib.rs b/src/test/auxiliary/cci_nested_lib.rs index 44d001d45fd..8494917c615 100644 --- a/src/test/auxiliary/cci_nested_lib.rs +++ b/src/test/auxiliary/cci_nested_lib.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] use std::cell::RefCell; diff --git a/src/test/auxiliary/issue-2380.rs b/src/test/auxiliary/issue-2380.rs index af6bb050ef5..8eb6cd6e263 100644 --- a/src/test/auxiliary/issue-2380.rs +++ b/src/test/auxiliary/issue-2380.rs @@ -11,6 +11,8 @@ #![crate_name="a"] #![crate_type = "lib"] +#![allow(unknown_features)] +#![feature(box_syntax)] pub trait i<T> { } diff --git a/src/test/auxiliary/lint_group_plugin_test.rs b/src/test/auxiliary/lint_group_plugin_test.rs index 097a5827fc4..ae9804423bb 100644 --- a/src/test/auxiliary/lint_group_plugin_test.rs +++ b/src/test/auxiliary/lint_group_plugin_test.rs @@ -11,6 +11,7 @@ // force-host #![feature(plugin_registrar)] +#![feature(box_syntax)] extern crate syntax; diff --git a/src/test/auxiliary/lint_plugin_test.rs b/src/test/auxiliary/lint_plugin_test.rs index 01ef08c4752..06051b87493 100644 --- a/src/test/auxiliary/lint_plugin_test.rs +++ b/src/test/auxiliary/lint_plugin_test.rs @@ -11,6 +11,7 @@ // force-host #![feature(plugin_registrar)] +#![feature(box_syntax)] extern crate syntax; diff --git a/src/test/auxiliary/macro_crate_test.rs b/src/test/auxiliary/macro_crate_test.rs index 99f02cf2d58..9eeb7ee8857 100644 --- a/src/test/auxiliary/macro_crate_test.rs +++ b/src/test/auxiliary/macro_crate_test.rs @@ -11,6 +11,7 @@ // force-host #![feature(plugin_registrar, quote)] +#![feature(box_syntax)] extern crate syntax; extern crate rustc; diff --git a/src/test/auxiliary/method_self_arg1.rs b/src/test/auxiliary/method_self_arg1.rs index 37022131c3d..5865a8f467b 100644 --- a/src/test/auxiliary/method_self_arg1.rs +++ b/src/test/auxiliary/method_self_arg1.rs @@ -10,6 +10,9 @@ #![crate_type = "lib"] +#![allow(unknown_features)] +#![feature(box_syntax)] + static mut COUNT: u64 = 1; pub fn get_count() -> u64 { unsafe { COUNT } } diff --git a/src/test/auxiliary/method_self_arg2.rs b/src/test/auxiliary/method_self_arg2.rs index eb4d62b01ad..a28a877a374 100644 --- a/src/test/auxiliary/method_self_arg2.rs +++ b/src/test/auxiliary/method_self_arg2.rs @@ -10,6 +10,9 @@ #![crate_type = "lib"] +#![allow(unknown_features)] +#![feature(box_syntax)] + static mut COUNT: u64 = 1; pub fn get_count() -> u64 { unsafe { COUNT } } diff --git a/src/test/auxiliary/plugin_args.rs b/src/test/auxiliary/plugin_args.rs index b90c3f1d727..e01a95d461b 100644 --- a/src/test/auxiliary/plugin_args.rs +++ b/src/test/auxiliary/plugin_args.rs @@ -11,6 +11,7 @@ // force-host #![feature(plugin_registrar)] +#![feature(box_syntax)] extern crate syntax; extern crate rustc; diff --git a/src/test/auxiliary/plugin_crate_outlive_expansion_phase.rs b/src/test/auxiliary/plugin_crate_outlive_expansion_phase.rs index 021eae90cf8..c460c60b02b 100644 --- a/src/test/auxiliary/plugin_crate_outlive_expansion_phase.rs +++ b/src/test/auxiliary/plugin_crate_outlive_expansion_phase.rs @@ -11,6 +11,7 @@ // force-host #![feature(plugin_registrar)] +#![feature(box_syntax)] extern crate rustc; diff --git a/src/test/bench/core-set.rs b/src/test/bench/core-set.rs index 1dcac9fe074..edeb07c960e 100644 --- a/src/test/bench/core-set.rs +++ b/src/test/bench/core-set.rs @@ -18,6 +18,7 @@ extern crate rand; use std::collections::BTreeSet; use std::collections::BitvSet; use std::collections::HashSet; +use std::collections::hash_map::Hasher; use std::hash::Hash; use std::os; use std::time::Duration; @@ -43,7 +44,7 @@ trait MutableSet<T> { fn contains(&self, k: &T) -> bool; } -impl<T: Hash + Eq> MutableSet<T> for HashSet<T> { +impl<T: Hash<Hasher> + Eq> MutableSet<T> for HashSet<T> { fn insert(&mut self, k: T) { self.insert(k); } fn remove(&mut self, k: &T) -> bool { self.remove(k) } fn contains(&self, k: &T) -> bool { self.contains(k) } diff --git a/src/test/bench/msgsend-pipes-shared.rs b/src/test/bench/msgsend-pipes-shared.rs index 387601de828..a091e0853f9 100644 --- a/src/test/bench/msgsend-pipes-shared.rs +++ b/src/test/bench/msgsend-pipes-shared.rs @@ -103,6 +103,6 @@ fn main() { args.into_iter().map(|x| x.to_string()).collect() }; - println!("{}", args); + println!("{:?}", args); run(args.as_slice()); } diff --git a/src/test/bench/msgsend-pipes.rs b/src/test/bench/msgsend-pipes.rs index d6d01e5452b..a9e6cef38aa 100644 --- a/src/test/bench/msgsend-pipes.rs +++ b/src/test/bench/msgsend-pipes.rs @@ -112,6 +112,6 @@ fn main() { args.clone().into_iter().map(|x| x.to_string()).collect() }; - println!("{}", args); + println!("{:?}", args); run(args.as_slice()); } diff --git a/src/test/bench/shootout-fannkuch-redux.rs b/src/test/bench/shootout-fannkuch-redux.rs index 261741c073f..bd4b8e5e97f 100644 --- a/src/test/bench/shootout-fannkuch-redux.rs +++ b/src/test/bench/shootout-fannkuch-redux.rs @@ -38,8 +38,6 @@ // ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED // OF THE POSSIBILITY OF SUCH DAMAGE. -#![feature(slicing_syntax)] - use std::{cmp, iter, mem}; use std::thread::Thread; diff --git a/src/test/bench/shootout-fasta-redux.rs b/src/test/bench/shootout-fasta-redux.rs index 9a6152dc13c..5a47f9fbc57 100644 --- a/src/test/bench/shootout-fasta-redux.rs +++ b/src/test/bench/shootout-fasta-redux.rs @@ -38,8 +38,6 @@ // ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED // OF THE POSSIBILITY OF SUCH DAMAGE. -#![feature(slicing_syntax)] - use std::cmp::min; use std::io::{stdout, IoResult}; use std::iter::repeat; diff --git a/src/test/bench/shootout-fasta.rs b/src/test/bench/shootout-fasta.rs index 29994f45d3a..e9da34615c1 100644 --- a/src/test/bench/shootout-fasta.rs +++ b/src/test/bench/shootout-fasta.rs @@ -38,8 +38,6 @@ // ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED // OF THE POSSIBILITY OF SUCH DAMAGE. -#![feature(slicing_syntax)] - use std::cmp::min; use std::io::{BufferedWriter, File}; use std::io; diff --git a/src/test/bench/shootout-k-nucleotide-pipes.rs b/src/test/bench/shootout-k-nucleotide-pipes.rs index 3845c6c593c..03268b40193 100644 --- a/src/test/bench/shootout-k-nucleotide-pipes.rs +++ b/src/test/bench/shootout-k-nucleotide-pipes.rs @@ -13,7 +13,7 @@ // multi tasking k-nucleotide -#![feature(slicing_syntax)] +#![feature(box_syntax)] use std::ascii::{AsciiExt, OwnedAsciiExt}; use std::cmp::Ordering::{self, Less, Greater, Equal}; @@ -64,7 +64,7 @@ fn sort_and_fmt(mm: &HashMap<Vec<u8> , uint>, total: uint) -> String { let mut buffer = String::new(); for &(ref k, v) in pairs_sorted.iter() { - buffer.push_str(format!("{} {:0.3}\n", + buffer.push_str(format!("{:?} {:0.3}\n", k.to_ascii_uppercase(), v).as_slice()); } @@ -193,8 +193,8 @@ fn main() { // start processing if this is the one ('>', false) => { match line.as_slice().slice_from(1).find_str("THREE") { - option::Option::Some(_) => { proc_mode = true; } - option::Option::None => { } + Some(_) => { proc_mode = true; } + None => { } } } @@ -223,6 +223,6 @@ fn main() { // now fetch and print result messages for (ii, _sz) in sizes.iter().enumerate() { - println!("{}", from_child[ii].recv().unwrap()); + println!("{:?}", from_child[ii].recv().unwrap()); } } diff --git a/src/test/bench/shootout-k-nucleotide.rs b/src/test/bench/shootout-k-nucleotide.rs index d0ff47628d4..9057372d2cf 100644 --- a/src/test/bench/shootout-k-nucleotide.rs +++ b/src/test/bench/shootout-k-nucleotide.rs @@ -40,7 +40,7 @@ // ignore-android see #10393 #13206 -#![feature(slicing_syntax)] +#![feature(box_syntax)] use std::ascii::OwnedAsciiExt; use std::iter::repeat; diff --git a/src/test/bench/shootout-meteor.rs b/src/test/bench/shootout-meteor.rs index 34a036eff37..0480c9d884a 100644 --- a/src/test/bench/shootout-meteor.rs +++ b/src/test/bench/shootout-meteor.rs @@ -118,7 +118,7 @@ fn transform(piece: Vec<(int, int)> , all: bool) -> Vec<Vec<(int, int)>> { // translating to (0, 0) as minimum coordinates. for cur_piece in res.iter_mut() { let (dy, dx) = *cur_piece.iter().min_by(|e| *e).unwrap(); - for &(ref mut y, ref mut x) in cur_piece.iter_mut() { + for &mut (ref mut y, ref mut x) in cur_piece.iter_mut() { *y -= dy; *x -= dx; } } diff --git a/src/test/bench/shootout-regex-dna.rs b/src/test/bench/shootout-regex-dna.rs index ef538eb6991..074c0592312 100644 --- a/src/test/bench/shootout-regex-dna.rs +++ b/src/test/bench/shootout-regex-dna.rs @@ -41,7 +41,7 @@ // ignore-stage1 // ignore-cross-compile #12102 -#![feature(plugin, slicing_syntax)] +#![feature(box_syntax)] extern crate regex; diff --git a/src/test/bench/shootout-reverse-complement.rs b/src/test/bench/shootout-reverse-complement.rs index 3003a88e972..841f70e13c4 100644 --- a/src/test/bench/shootout-reverse-complement.rs +++ b/src/test/bench/shootout-reverse-complement.rs @@ -40,7 +40,7 @@ // ignore-android see #10393 #13206 -#![feature(slicing_syntax, unboxed_closures)] +#![feature(unboxed_closures)] extern crate libc; diff --git a/src/test/bench/sudoku.rs b/src/test/bench/sudoku.rs index 85e8288b5cd..786bbdfc803 100644 --- a/src/test/bench/sudoku.rs +++ b/src/test/bench/sudoku.rs @@ -10,6 +10,7 @@ // ignore-pretty very bad with line comments +#![feature(box_syntax)] #![allow(non_snake_case)] use std::io::BufferedReader; diff --git a/src/test/bench/task-perf-alloc-unwind.rs b/src/test/bench/task-perf-alloc-unwind.rs index 55e8dcbb6e8..dc536102d5d 100644 --- a/src/test/bench/task-perf-alloc-unwind.rs +++ b/src/test/bench/task-perf-alloc-unwind.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![feature(unsafe_destructor)] +#![feature(unsafe_destructor, box_syntax)] use std::os; use std::thread::Thread; diff --git a/src/test/compile-fail/syntax-extension-bytes-too-large-u8-literal.rs b/src/test/compile-fail/assoc-inherent.rs index 1a9aa3753ee..8025011bfa7 100644 --- a/src/test/compile-fail/syntax-extension-bytes-too-large-u8-literal.rs +++ b/src/test/compile-fail/assoc-inherent.rs @@ -1,4 +1,4 @@ -// Copyright 2013 The Rust Project Developers. See the COPYRIGHT +// 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. // @@ -8,7 +8,12 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -fn main() { - let vec = bytes!(1024u8); //~ ERROR too large u8 literal in bytes! - //~^ WARN `bytes!` is deprecated +// Test associated types are forbidden in inherant impls. + +struct Foo; + +impl Foo { + type Bar = int; //~ERROR associated items are not allowed in inherent impls } + +fn main() {} diff --git a/src/test/compile-fail/autoderef-full-lval.rs b/src/test/compile-fail/autoderef-full-lval.rs index bbe5af1b516..fb58028658e 100644 --- a/src/test/compile-fail/autoderef-full-lval.rs +++ b/src/test/compile-fail/autoderef-full-lval.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + struct clam { x: Box<isize>, y: Box<isize>, diff --git a/src/test/compile-fail/borrow-tuple-fields.rs b/src/test/compile-fail/borrow-tuple-fields.rs index 1d09143c24d..59ed0e5fa06 100644 --- a/src/test/compile-fail/borrow-tuple-fields.rs +++ b/src/test/compile-fail/borrow-tuple-fields.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + struct Foo(Box<int>, int); struct Bar(int, int); diff --git a/src/test/compile-fail/borrowck-array-double-move.rs b/src/test/compile-fail/borrowck-array-double-move.rs index c872d0dc4b9..ef2c629acfe 100644 --- a/src/test/compile-fail/borrowck-array-double-move.rs +++ b/src/test/compile-fail/borrowck-array-double-move.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + fn f() { let mut a = [box 0i, box 1i]; drop(a[0]); diff --git a/src/test/compile-fail/borrowck-bad-nested-calls-free.rs b/src/test/compile-fail/borrowck-bad-nested-calls-free.rs index ab2fc6c67b4..5a7788ed855 100644 --- a/src/test/compile-fail/borrowck-bad-nested-calls-free.rs +++ b/src/test/compile-fail/borrowck-bad-nested-calls-free.rs @@ -11,6 +11,7 @@ // Test that we detect nested calls that could free pointers evaluated // for earlier arguments. +#![feature(box_syntax)] fn rewrite(v: &mut Box<uint>) -> uint { *v = box 22; diff --git a/src/test/compile-fail/borrowck-bad-nested-calls-move.rs b/src/test/compile-fail/borrowck-bad-nested-calls-move.rs index 708eed0d113..263b7f9576b 100644 --- a/src/test/compile-fail/borrowck-bad-nested-calls-move.rs +++ b/src/test/compile-fail/borrowck-bad-nested-calls-move.rs @@ -11,6 +11,7 @@ // Test that we detect nested calls that could free pointers evaluated // for earlier arguments. +#![feature(box_syntax)] fn rewrite(v: &mut Box<uint>) -> uint { *v = box 22; diff --git a/src/test/compile-fail/borrowck-borrow-immut-deref-of-box-as-mut.rs b/src/test/compile-fail/borrowck-borrow-immut-deref-of-box-as-mut.rs index 7e3c4658fc8..84f4e4f8817 100644 --- a/src/test/compile-fail/borrowck-borrow-immut-deref-of-box-as-mut.rs +++ b/src/test/compile-fail/borrowck-borrow-immut-deref-of-box-as-mut.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] + struct A; impl A { diff --git a/src/test/compile-fail/borrowck-borrowed-uniq-rvalue-2.rs b/src/test/compile-fail/borrowck-borrowed-uniq-rvalue-2.rs index 10c63965a7b..d983c5d5087 100644 --- a/src/test/compile-fail/borrowck-borrowed-uniq-rvalue-2.rs +++ b/src/test/compile-fail/borrowck-borrowed-uniq-rvalue-2.rs @@ -18,7 +18,7 @@ struct defer<'a> { impl<'a> Drop for defer<'a> { fn drop(&mut self) { unsafe { - println!("{}", self.x); + println!("{:?}", self.x); } } } diff --git a/src/test/compile-fail/borrowck-borrowed-uniq-rvalue.rs b/src/test/compile-fail/borrowck-borrowed-uniq-rvalue.rs index f2ff5f86f63..04ad583a2db 100644 --- a/src/test/compile-fail/borrowck-borrowed-uniq-rvalue.rs +++ b/src/test/compile-fail/borrowck-borrowed-uniq-rvalue.rs @@ -10,6 +10,8 @@ //buggy.rs +#![feature(box_syntax)] + extern crate collections; use std::collections::HashMap; diff --git a/src/test/compile-fail/borrowck-box-insensitivity.rs b/src/test/compile-fail/borrowck-box-insensitivity.rs index d05c03547ac..bd22b61fe3b 100644 --- a/src/test/compile-fail/borrowck-box-insensitivity.rs +++ b/src/test/compile-fail/borrowck-box-insensitivity.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] + struct A { x: Box<int>, y: int, diff --git a/src/test/compile-fail/borrowck-call-is-borrow-issue-12224.rs b/src/test/compile-fail/borrowck-call-is-borrow-issue-12224.rs index 6dbdff9441d..9aec8de46b6 100644 --- a/src/test/compile-fail/borrowck-call-is-borrow-issue-12224.rs +++ b/src/test/compile-fail/borrowck-call-is-borrow-issue-12224.rs @@ -11,6 +11,7 @@ // Ensure that invoking a closure counts as a unique immutable borrow #![feature(unboxed_closures)] +#![feature(box_syntax)] type Fn<'a> = Box<FnMut() + 'a>; diff --git a/src/test/compile-fail/borrowck-closures-mut-and-imm.rs b/src/test/compile-fail/borrowck-closures-mut-and-imm.rs index 47a47d04432..126003b5d82 100644 --- a/src/test/compile-fail/borrowck-closures-mut-and-imm.rs +++ b/src/test/compile-fail/borrowck-closures-mut-and-imm.rs @@ -11,6 +11,7 @@ // Tests that two closures cannot simultaneously have mutable // and immutable access to the variable. Issue #6801. +#![feature(box_syntax)] fn get(x: &int) -> int { *x diff --git a/src/test/compile-fail/borrowck-closures-two-mut.rs b/src/test/compile-fail/borrowck-closures-two-mut.rs index 0f284b53849..e1f557cfab2 100644 --- a/src/test/compile-fail/borrowck-closures-two-mut.rs +++ b/src/test/compile-fail/borrowck-closures-two-mut.rs @@ -12,6 +12,7 @@ // access to the variable, whether that mutable access be used // for direct assignment or for taking mutable ref. Issue #6801. +#![feature(box_syntax)] fn a() { let mut x = 3i; diff --git a/src/test/compile-fail/borrowck-closures-use-after-free.rs b/src/test/compile-fail/borrowck-closures-use-after-free.rs index 23c90fcf574..9aa9a50483c 100644 --- a/src/test/compile-fail/borrowck-closures-use-after-free.rs +++ b/src/test/compile-fail/borrowck-closures-use-after-free.rs @@ -12,6 +12,7 @@ // cannot also be supplied a borrowed version of that // variable's contents. Issue #11192. +#![feature(box_syntax)] struct Foo { x: int diff --git a/src/test/compile-fail/borrowck-field-sensitivity.rs b/src/test/compile-fail/borrowck-field-sensitivity.rs index 49c93e3aa9e..52761fa3488 100644 --- a/src/test/compile-fail/borrowck-field-sensitivity.rs +++ b/src/test/compile-fail/borrowck-field-sensitivity.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] + struct A { a: int, b: Box<int> } fn deref_after_move() { diff --git a/src/test/compile-fail/borrowck-for-loop-correct-cmt-for-pattern.rs b/src/test/compile-fail/borrowck-for-loop-correct-cmt-for-pattern.rs index f0d42bb9ac1..bdcbc839c00 100644 --- a/src/test/compile-fail/borrowck-for-loop-correct-cmt-for-pattern.rs +++ b/src/test/compile-fail/borrowck-for-loop-correct-cmt-for-pattern.rs @@ -10,6 +10,8 @@ // Issue #16205. +#![feature(box_syntax)] + struct Foo { a: [Box<int>; 3], } diff --git a/src/test/compile-fail/borrowck-issue-14498.rs b/src/test/compile-fail/borrowck-issue-14498.rs index 45dda5fee5a..8e46db5eba8 100644 --- a/src/test/compile-fail/borrowck-issue-14498.rs +++ b/src/test/compile-fail/borrowck-issue-14498.rs @@ -11,6 +11,8 @@ // This tests that we can't modify Box<&mut T> contents while they // are borrowed. +#![feature(box_syntax)] + struct A { a: int } struct B<'a> { a: Box<&'a mut int> } diff --git a/src/test/compile-fail/borrowck-issue-2657-1.rs b/src/test/compile-fail/borrowck-issue-2657-1.rs index 9d28b2a436f..fa80bf38cfe 100644 --- a/src/test/compile-fail/borrowck-issue-2657-1.rs +++ b/src/test/compile-fail/borrowck-issue-2657-1.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] + fn main() { let x = Some(box 1i); match x { diff --git a/src/test/compile-fail/borrowck-issue-2657-2.rs b/src/test/compile-fail/borrowck-issue-2657-2.rs index 973cf3bf8c8..f531b585dde 100644 --- a/src/test/compile-fail/borrowck-issue-2657-2.rs +++ b/src/test/compile-fail/borrowck-issue-2657-2.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] + fn main() { let x = Some(box 1i); match x { diff --git a/src/test/compile-fail/borrowck-lend-flow-if.rs b/src/test/compile-fail/borrowck-lend-flow-if.rs index f798d170f96..8a618dfec11 100644 --- a/src/test/compile-fail/borrowck-lend-flow-if.rs +++ b/src/test/compile-fail/borrowck-lend-flow-if.rs @@ -14,6 +14,7 @@ // either genuine or would require more advanced changes. The latter // cases are noted. +#![feature(box_syntax)] fn borrow(_v: &int) {} fn borrow_mut(_v: &mut int) {} diff --git a/src/test/compile-fail/borrowck-lend-flow-loop.rs b/src/test/compile-fail/borrowck-lend-flow-loop.rs index ff038b545d5..954b8010244 100644 --- a/src/test/compile-fail/borrowck-lend-flow-loop.rs +++ b/src/test/compile-fail/borrowck-lend-flow-loop.rs @@ -14,6 +14,7 @@ // either genuine or would require more advanced changes. The latter // cases are noted. +#![feature(box_syntax)] fn borrow(_v: &int) {} fn borrow_mut(_v: &mut int) {} diff --git a/src/test/compile-fail/borrowck-lend-flow.rs b/src/test/compile-fail/borrowck-lend-flow.rs index 85fc7fb87b3..d5419b05851 100644 --- a/src/test/compile-fail/borrowck-lend-flow.rs +++ b/src/test/compile-fail/borrowck-lend-flow.rs @@ -14,6 +14,7 @@ // either genuine or would require more advanced changes. The latter // cases are noted. +#![feature(box_syntax)] fn borrow(_v: &int) {} fn borrow_mut(_v: &mut int) {} diff --git a/src/test/compile-fail/borrowck-loan-blocks-move-cc.rs b/src/test/compile-fail/borrowck-loan-blocks-move-cc.rs index 5c282495cc2..8b39b6ff661 100644 --- a/src/test/compile-fail/borrowck-loan-blocks-move-cc.rs +++ b/src/test/compile-fail/borrowck-loan-blocks-move-cc.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] + use std::thread::Thread; fn borrow<F>(v: &int, f: F) where F: FnOnce(&int) { diff --git a/src/test/compile-fail/borrowck-loan-blocks-move.rs b/src/test/compile-fail/borrowck-loan-blocks-move.rs index 3c284ede0c8..f588dbab4fa 100644 --- a/src/test/compile-fail/borrowck-loan-blocks-move.rs +++ b/src/test/compile-fail/borrowck-loan-blocks-move.rs @@ -8,6 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] fn take(_v: Box<int>) { } diff --git a/src/test/compile-fail/borrowck-loan-blocks-mut-uniq.rs b/src/test/compile-fail/borrowck-loan-blocks-mut-uniq.rs index b6a71fcd446..e59baa1e37c 100644 --- a/src/test/compile-fail/borrowck-loan-blocks-mut-uniq.rs +++ b/src/test/compile-fail/borrowck-loan-blocks-mut-uniq.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] + fn borrow<F>(v: &int, f: F) where F: FnOnce(&int) { f(v); } diff --git a/src/test/compile-fail/borrowck-loan-in-overloaded-op.rs b/src/test/compile-fail/borrowck-loan-in-overloaded-op.rs index 924d70e9f46..d955e8984bf 100644 --- a/src/test/compile-fail/borrowck-loan-in-overloaded-op.rs +++ b/src/test/compile-fail/borrowck-loan-in-overloaded-op.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] + use std::ops::Add; #[derive(Clone)] diff --git a/src/test/compile-fail/borrowck-move-by-capture.rs b/src/test/compile-fail/borrowck-move-by-capture.rs index 35f0751aa78..20212762188 100644 --- a/src/test/compile-fail/borrowck-move-by-capture.rs +++ b/src/test/compile-fail/borrowck-move-by-capture.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] + pub fn main() { let bar = box 3; let _g = |&mut:| { diff --git a/src/test/compile-fail/borrowck-move-error-with-note.rs b/src/test/compile-fail/borrowck-move-error-with-note.rs index c61ec39ec50..4984987c5ca 100644 --- a/src/test/compile-fail/borrowck-move-error-with-note.rs +++ b/src/test/compile-fail/borrowck-move-error-with-note.rs @@ -8,6 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] enum Foo { Foo1(Box<u32>, Box<u32>), diff --git a/src/test/compile-fail/borrowck-move-from-subpath-of-borrowed-path.rs b/src/test/compile-fail/borrowck-move-from-subpath-of-borrowed-path.rs index 63409f5afb0..936092df42e 100644 --- a/src/test/compile-fail/borrowck-move-from-subpath-of-borrowed-path.rs +++ b/src/test/compile-fail/borrowck-move-from-subpath-of-borrowed-path.rs @@ -11,6 +11,8 @@ // verify that an error is raised when trying to move out of a // borrowed path. +#![feature(box_syntax)] + fn main() { let a = box box 2i; let b = &a; diff --git a/src/test/compile-fail/borrowck-move-moved-value-into-closure.rs b/src/test/compile-fail/borrowck-move-moved-value-into-closure.rs index ca484738cb6..35aef1352d1 100644 --- a/src/test/compile-fail/borrowck-move-moved-value-into-closure.rs +++ b/src/test/compile-fail/borrowck-move-moved-value-into-closure.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] + fn call_f<F:FnOnce() -> int>(f: F) -> int { f() } diff --git a/src/test/compile-fail/borrowck-move-subcomponent.rs b/src/test/compile-fail/borrowck-move-subcomponent.rs index a29a171e935..bdf6fe1f21d 100644 --- a/src/test/compile-fail/borrowck-move-subcomponent.rs +++ b/src/test/compile-fail/borrowck-move-subcomponent.rs @@ -11,6 +11,7 @@ // Tests that the borrow checker checks all components of a path when moving // out. +#![feature(box_syntax)] struct S { x : Box<int> diff --git a/src/test/compile-fail/borrowck-multiple-captures.rs b/src/test/compile-fail/borrowck-multiple-captures.rs index 2a26ff7d4a1..e90d25c781b 100644 --- a/src/test/compile-fail/borrowck-multiple-captures.rs +++ b/src/test/compile-fail/borrowck-multiple-captures.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] + use std::thread::Thread; fn borrow<T>(_: &T) { } diff --git a/src/test/compile-fail/borrowck-no-cycle-in-exchange-heap.rs b/src/test/compile-fail/borrowck-no-cycle-in-exchange-heap.rs index db3fa6247db..6985d203fb1 100644 --- a/src/test/compile-fail/borrowck-no-cycle-in-exchange-heap.rs +++ b/src/test/compile-fail/borrowck-no-cycle-in-exchange-heap.rs @@ -8,6 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] struct node_ { a: Box<cycle> diff --git a/src/test/compile-fail/borrowck-overloaded-index-2.rs b/src/test/compile-fail/borrowck-overloaded-index-2.rs index 53fb935755c..5e6d235574e 100644 --- a/src/test/compile-fail/borrowck-overloaded-index-2.rs +++ b/src/test/compile-fail/borrowck-overloaded-index-2.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] + use std::ops::Index; struct MyVec<T> { diff --git a/src/test/compile-fail/borrowck-uniq-via-lend.rs b/src/test/compile-fail/borrowck-uniq-via-lend.rs index 9785b6a8f69..b0e8b2a523b 100644 --- a/src/test/compile-fail/borrowck-uniq-via-lend.rs +++ b/src/test/compile-fail/borrowck-uniq-via-lend.rs @@ -8,6 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] fn borrow(_v: &int) {} diff --git a/src/test/compile-fail/borrowck-use-mut-borrow.rs b/src/test/compile-fail/borrowck-use-mut-borrow.rs index 0d27473cb2d..45813c45f03 100644 --- a/src/test/compile-fail/borrowck-use-mut-borrow.rs +++ b/src/test/compile-fail/borrowck-use-mut-borrow.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] + struct A { a: int, b: int } impl Copy for A {} diff --git a/src/test/compile-fail/borrowck-vec-pattern-nesting.rs b/src/test/compile-fail/borrowck-vec-pattern-nesting.rs index 2eec7887856..c0abc3a2560 100644 --- a/src/test/compile-fail/borrowck-vec-pattern-nesting.rs +++ b/src/test/compile-fail/borrowck-vec-pattern-nesting.rs @@ -9,6 +9,7 @@ // except according to those terms. #![feature(advanced_slice_patterns)] +#![feature(box_syntax)] fn a() { let mut vec = [box 1i, box 2, box 3]; diff --git a/src/test/compile-fail/check-static-values-constraints.rs b/src/test/compile-fail/check-static-values-constraints.rs index 1c7ae05961e..c13faacfee4 100644 --- a/src/test/compile-fail/check-static-values-constraints.rs +++ b/src/test/compile-fail/check-static-values-constraints.rs @@ -10,6 +10,8 @@ // Verifies all possible restrictions for statics values. +#![feature(box_syntax)] + use std::marker; struct WithDtor; diff --git a/src/test/compile-fail/class-cast-to-trait.rs b/src/test/compile-fail/class-cast-to-trait.rs index ae0f377ba87..25abd904d21 100644 --- a/src/test/compile-fail/class-cast-to-trait.rs +++ b/src/test/compile-fail/class-cast-to-trait.rs @@ -8,6 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] trait noisy { fn speak(&self); diff --git a/src/test/compile-fail/cross-borrow-trait.rs b/src/test/compile-fail/cross-borrow-trait.rs index 1ccd5290fef..ff96ea93184 100644 --- a/src/test/compile-fail/cross-borrow-trait.rs +++ b/src/test/compile-fail/cross-borrow-trait.rs @@ -11,6 +11,8 @@ // Test that cross-borrowing (implicitly converting from `Box<T>` to `&T`) is // forbidden when `T` is a trait. +#![feature(box_syntax)] + struct Foo; trait Trait {} impl Trait for Foo {} diff --git a/src/test/compile-fail/destructure-trait-ref.rs b/src/test/compile-fail/destructure-trait-ref.rs index a2a5a3e257f..0351040d329 100644 --- a/src/test/compile-fail/destructure-trait-ref.rs +++ b/src/test/compile-fail/destructure-trait-ref.rs @@ -11,6 +11,8 @@ // The regression test for #15031 to make sure destructuring trait // reference work properly. +#![feature(box_syntax)] + trait T {} impl T for int {} diff --git a/src/test/compile-fail/drop-on-non-struct.rs b/src/test/compile-fail/drop-on-non-struct.rs index 238700254b8..8d2ca0b0a6b 100644 --- a/src/test/compile-fail/drop-on-non-struct.rs +++ b/src/test/compile-fail/drop-on-non-struct.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -impl Drop for int { +impl<'a> Drop for &'a mut int { //~^ ERROR the Drop trait may only be implemented on structures //~^^ ERROR E0117 fn drop(&mut self) { diff --git a/src/test/compile-fail/drop-with-active-borrows-2.rs b/src/test/compile-fail/drop-with-active-borrows-2.rs index 1cbd6292e99..d9d3d79b5af 100644 --- a/src/test/compile-fail/drop-with-active-borrows-2.rs +++ b/src/test/compile-fail/drop-with-active-borrows-2.rs @@ -15,5 +15,5 @@ fn read_lines_borrowed<'a>() -> Vec<&'a str> { } fn main() { - println!("{}", read_lines_borrowed()); + println!("{:?}", read_lines_borrowed()); } diff --git a/src/test/compile-fail/dst-bad-assign-2.rs b/src/test/compile-fail/dst-bad-assign-2.rs index ebd0ee97efe..6c40ca558de 100644 --- a/src/test/compile-fail/dst-bad-assign-2.rs +++ b/src/test/compile-fail/dst-bad-assign-2.rs @@ -10,6 +10,8 @@ // Forbid assignment into a dynamically sized type. +#![feature(box_syntax)] + struct Fat<T: ?Sized> { f1: int, f2: &'static str, diff --git a/src/test/compile-fail/dst-bad-assign.rs b/src/test/compile-fail/dst-bad-assign.rs index f52c990ca52..78f70b9add0 100644 --- a/src/test/compile-fail/dst-bad-assign.rs +++ b/src/test/compile-fail/dst-bad-assign.rs @@ -10,6 +10,8 @@ // Forbid assignment into a dynamically sized type. +#![feature(box_syntax)] + struct Fat<T: ?Sized> { f1: int, f2: &'static str, diff --git a/src/test/compile-fail/dst-rvalue.rs b/src/test/compile-fail/dst-rvalue.rs index 4c1dafd8c1a..74e952364cd 100644 --- a/src/test/compile-fail/dst-rvalue.rs +++ b/src/test/compile-fail/dst-rvalue.rs @@ -10,6 +10,8 @@ // Check that dynamically sized rvalues are forbidden +#![feature(box_syntax)] + pub fn main() { let _x: Box<str> = box *"hello world"; //~^ ERROR E0161 diff --git a/src/test/compile-fail/exclusive-drop-and-copy.rs b/src/test/compile-fail/exclusive-drop-and-copy.rs new file mode 100644 index 00000000000..17453bc677f --- /dev/null +++ b/src/test/compile-fail/exclusive-drop-and-copy.rs @@ -0,0 +1,30 @@ +// 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(unsafe_destructor)] + +// issue #20126 + +#[derive(Copy)] //~ ERROR the trait `Copy` may not be implemented +struct Foo; + +impl Drop for Foo { + fn drop(&mut self) {} +} + +#[derive(Copy)] //~ ERROR the trait `Copy` may not be implemented +struct Bar<T>; + +#[unsafe_destructor] +impl<T> Drop for Bar<T> { + fn drop(&mut self) {} +} + +fn main() {} diff --git a/src/test/compile-fail/extern-with-type-bounds.rs b/src/test/compile-fail/extern-with-type-bounds.rs new file mode 100644 index 00000000000..8c7d00a9a11 --- /dev/null +++ b/src/test/compile-fail/extern-with-type-bounds.rs @@ -0,0 +1,33 @@ +// 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(intrinsics)] + +use std::intrinsics::TypeId; + +extern "rust-intrinsic" { + // Real example from libcore + fn type_id<T: ?Sized + 'static>() -> TypeId; + + // Silent bounds made explicit to make sure they are actually + // resolved. + fn transmute<T: Sized, U: Sized>(val: T) -> U; + + // Bounds aren't checked right now, so this should work + // even though it's incorrect. + fn size_of<T: Clone>() -> uint; + + // Unresolved bounds should still error. + fn align_of<T: NoSuchTrait>() -> uint; + //~^ ERROR attempt to bound type parameter with a nonexistent trait `NoSuchTrait` +} + +fn main() {} + diff --git a/src/test/compile-fail/feature-gate-box-expr.rs b/src/test/compile-fail/feature-gate-box-expr.rs new file mode 100644 index 00000000000..bc7a70471cd --- /dev/null +++ b/src/test/compile-fail/feature-gate-box-expr.rs @@ -0,0 +1,23 @@ +// 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() { + use std::boxed::HEAP; + + let x = box 'c'; //~ ERROR box expression syntax is experimental in alpha release + println!("x: {}", x); + + let x = box () 'c'; //~ ERROR box expression syntax is experimental in alpha release + println!("x: {}", x); + + let x = box (HEAP) 'c'; //~ ERROR box expression syntax is experimental in alpha release + println!("x: {}", x); +} + diff --git a/src/test/compile-fail/syntax-extension-bytes-too-large-integer-literal.rs b/src/test/compile-fail/feature-gate-box-pat.rs index 8e7c6147758..b36bc22b9dc 100644 --- a/src/test/compile-fail/syntax-extension-bytes-too-large-integer-literal.rs +++ b/src/test/compile-fail/feature-gate-box-pat.rs @@ -1,4 +1,4 @@ -// Copyright 2013 The Rust Project Developers. See the COPYRIGHT +// 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. // @@ -9,6 +9,6 @@ // except according to those terms. fn main() { - let vec = bytes!(1024); //~ ERROR too large integer literal in bytes! - //~^ WARN `bytes!` is deprecated + let box x = Box::new('c'); //~ ERROR box pattern syntax is experimental in alpha release + println!("x: {}", x); } diff --git a/src/test/compile-fail/syntax-extension-bytes-too-small-integer-literal.rs b/src/test/compile-fail/feature-gate-feature-gate.rs index c2d49735943..b903b29658b 100644 --- a/src/test/compile-fail/syntax-extension-bytes-too-small-integer-literal.rs +++ b/src/test/compile-fail/feature-gate-feature-gate.rs @@ -1,4 +1,4 @@ -// Copyright 2013 The Rust Project Developers. See the COPYRIGHT +// Copyright 2014 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -fn main() { - let vec = bytes!(-1024); //~ ERROR non-literal in bytes - //~^ WARN `bytes!` is deprecated -} +#![forbid(unstable_features)] +#![feature(intrinsics)] //~ ERROR unstable feature + +fn main() { } diff --git a/src/test/compile-fail/feature-gated-feature-in-macro-arg.rs b/src/test/compile-fail/feature-gated-feature-in-macro-arg.rs index cd49c7c016e..1e15e67876e 100644 --- a/src/test/compile-fail/feature-gated-feature-in-macro-arg.rs +++ b/src/test/compile-fail/feature-gated-feature-in-macro-arg.rs @@ -8,6 +8,14 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +// FIXME #20661: format_args! emits calls to the unstable std::fmt::rt +// module, so the compiler has some hacks to make that possible +// (in span_is_internal). Unnfortunately those hacks defeat this +// particular scenario of checking feature gates in arguments to +// println!(). + +// ignore-test + // tests that input to a macro is checked for use of gated features. If this // test succeeds due to the acceptance of a feature, pick a new feature to // test. Not ideal, but oh well :( diff --git a/src/test/compile-fail/fn-trait-formatting.rs b/src/test/compile-fail/fn-trait-formatting.rs index 06e8412ddaa..723192952f2 100644 --- a/src/test/compile-fail/fn-trait-formatting.rs +++ b/src/test/compile-fail/fn-trait-formatting.rs @@ -9,6 +9,7 @@ // except according to those terms. #![feature(unboxed_closures)] +#![feature(box_syntax)] fn needs_fn<F>(x: F) where F: Fn(isize) -> isize {} diff --git a/src/test/compile-fail/huge-enum.rs b/src/test/compile-fail/huge-enum.rs index 7c7a75abf3f..aef1fa85e0d 100644 --- a/src/test/compile-fail/huge-enum.rs +++ b/src/test/compile-fail/huge-enum.rs @@ -12,12 +12,12 @@ // FIXME: work properly with higher limits -#[cfg(target_word_size = "32")] +#[cfg(any(all(stage0, target_word_size = "32"), all(not(stage0), target_pointer_width = "32")))] fn main() { let big: Option<[u32; (1<<29)-1]> = None; } -#[cfg(target_word_size = "64")] +#[cfg(any(all(stage0, target_word_size = "64"), all(not(stage0), target_pointer_width = "64")))] fn main() { let big: Option<[u32; (1<<45)-1]> = None; } diff --git a/src/test/compile-fail/infinite-autoderef.rs b/src/test/compile-fail/infinite-autoderef.rs index f0b9e796ae6..3635c4dbb02 100644 --- a/src/test/compile-fail/infinite-autoderef.rs +++ b/src/test/compile-fail/infinite-autoderef.rs @@ -10,6 +10,8 @@ // error-pattern: reached the recursion limit while auto-dereferencing +#![feature(box_syntax)] + use std::ops::Deref; struct Foo; diff --git a/src/test/compile-fail/issue-10291.rs b/src/test/compile-fail/issue-10291.rs index dec4fc3b8f5..453746ffd6a 100644 --- a/src/test/compile-fail/issue-10291.rs +++ b/src/test/compile-fail/issue-10291.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] + fn test<'x>(x: &'x int) { drop::<Box<for<'z> FnMut(&'z int) -> &'z int>>(box |z| { x diff --git a/src/test/compile-fail/issue-10398.rs b/src/test/compile-fail/issue-10398.rs index c90f064bf90..11c577f9dc3 100644 --- a/src/test/compile-fail/issue-10398.rs +++ b/src/test/compile-fail/issue-10398.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] + fn main() { let x = box 1i; let f = move|:| { diff --git a/src/test/compile-fail/issue-11192.rs b/src/test/compile-fail/issue-11192.rs index f496c1e1227..3784d3d6437 100644 --- a/src/test/compile-fail/issue-11192.rs +++ b/src/test/compile-fail/issue-11192.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] + struct Foo { x: int } diff --git a/src/test/compile-fail/issue-11515.rs b/src/test/compile-fail/issue-11515.rs index 46fcb2ec340..f0089b0ae5b 100644 --- a/src/test/compile-fail/issue-11515.rs +++ b/src/test/compile-fail/issue-11515.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] + struct Test<'s> { func: Box<FnMut()+'static> } diff --git a/src/test/compile-fail/issue-11844.rs b/src/test/compile-fail/issue-11844.rs index 55c12b051b9..560cbe1b8a8 100644 --- a/src/test/compile-fail/issue-11844.rs +++ b/src/test/compile-fail/issue-11844.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] + fn main() { let a = Some(box 1); match a { diff --git a/src/test/compile-fail/issue-11925.rs b/src/test/compile-fail/issue-11925.rs index c561f0a696a..71e4598d635 100644 --- a/src/test/compile-fail/issue-11925.rs +++ b/src/test/compile-fail/issue-11925.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] + fn main() { let r = { let x = box 42i; diff --git a/src/test/compile-fail/issue-12116.rs b/src/test/compile-fail/issue-12116.rs index 47907ac2be9..8a5e8c27259 100644 --- a/src/test/compile-fail/issue-12116.rs +++ b/src/test/compile-fail/issue-12116.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] + enum IntList { Cons(int, Box<IntList>), Nil diff --git a/src/test/compile-fail/issue-12127.rs b/src/test/compile-fail/issue-12127.rs index 5f2837d2875..2d87bdaf524 100644 --- a/src/test/compile-fail/issue-12127.rs +++ b/src/test/compile-fail/issue-12127.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] + fn do_it(x: &int) { } fn main() { diff --git a/src/test/compile-fail/issue-12470.rs b/src/test/compile-fail/issue-12470.rs index 0202d538cf6..31874655302 100644 --- a/src/test/compile-fail/issue-12470.rs +++ b/src/test/compile-fail/issue-12470.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] + trait X { fn get_i(&self) -> int; } diff --git a/src/test/compile-fail/issue-14084.rs b/src/test/compile-fail/issue-14084.rs index d247bf0913c..92e0dd3ad0e 100644 --- a/src/test/compile-fail/issue-14084.rs +++ b/src/test/compile-fail/issue-14084.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] + fn main() { box ( () ) 0; //~^ ERROR: only the managed heap and exchange heap are currently supported diff --git a/src/test/compile-fail/issue-14915.rs b/src/test/compile-fail/issue-14915.rs index 142fecc31fe..18e4ccc3311 100644 --- a/src/test/compile-fail/issue-14915.rs +++ b/src/test/compile-fail/issue-14915.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] + fn main() { let x: Box<isize> = box 0; diff --git a/src/test/compile-fail/issue-15756.rs b/src/test/compile-fail/issue-15756.rs index c2d30224dc8..02ccf9c0e08 100644 --- a/src/test/compile-fail/issue-15756.rs +++ b/src/test/compile-fail/issue-15756.rs @@ -14,7 +14,7 @@ use std::slice::ChunksMut; fn dft_iter<'a, T>(arg1: Chunks<'a,T>, arg2: ChunksMut<'a,T>) { for - &something + &mut something //~^ ERROR the trait `core::marker::Sized` is not implemented for the type `[T]` in arg2 { diff --git a/src/test/compile-fail/issue-17263.rs b/src/test/compile-fail/issue-17263.rs index b610a2b0c91..ba993259216 100644 --- a/src/test/compile-fail/issue-17263.rs +++ b/src/test/compile-fail/issue-17263.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] + struct Foo { a: int, b: int } fn main() { diff --git a/src/test/compile-fail/issue-17441.rs b/src/test/compile-fail/issue-17441.rs index 6ae4fbca8b0..a28162159a5 100644 --- a/src/test/compile-fail/issue-17441.rs +++ b/src/test/compile-fail/issue-17441.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] + fn main() { let _foo = &[1u, 2] as [usize]; //~^ ERROR cast to unsized type: `&[usize; 2]` as `[usize]` diff --git a/src/test/compile-fail/issue-17651.rs b/src/test/compile-fail/issue-17651.rs index 589f1cf44bf..d3678f7d87f 100644 --- a/src/test/compile-fail/issue-17651.rs +++ b/src/test/compile-fail/issue-17651.rs @@ -11,6 +11,8 @@ // Test that moves of unsized values within closures are caught // and rejected. +#![feature(box_syntax)] + fn main() { (|&:| box *[0us].as_slice())(); //~^ ERROR cannot move out of dereference diff --git a/src/test/compile-fail/issue-17913.rs b/src/test/compile-fail/issue-17913.rs index 3224edb381c..e2dbad56f84 100644 --- a/src/test/compile-fail/issue-17913.rs +++ b/src/test/compile-fail/issue-17913.rs @@ -8,16 +8,19 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. + // error-pattern: too big for the current architecture -#[cfg(target_word_size = "64")] +#![feature(box_syntax)] + +#[cfg(any(all(stage0, target_word_size = "64"), all(not(stage0), target_pointer_width = "64")))] fn main() { let n = 0u; let a = box [&n; 0xF000000000000000u]; println!("{}", a[0xFFFFFFu]); } -#[cfg(target_word_size = "32")] +#[cfg(any(all(stage0, target_word_size = "32"), all(not(stage0), target_pointer_width = "32")))] fn main() { let n = 0u; let a = box [&n; 0xFFFFFFFFu]; diff --git a/src/test/compile-fail/issue-18783.rs b/src/test/compile-fail/issue-18783.rs index 3a0fbddf818..657ef85233d 100644 --- a/src/test/compile-fail/issue-18783.rs +++ b/src/test/compile-fail/issue-18783.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] + use std::cell::RefCell; fn main() { diff --git a/src/test/compile-fail/issue-3601.rs b/src/test/compile-fail/issue-3601.rs index f10305d017d..15b3ec0bfe7 100644 --- a/src/test/compile-fail/issue-3601.rs +++ b/src/test/compile-fail/issue-3601.rs @@ -8,6 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] struct HTMLImageData { image: Option<String> diff --git a/src/test/compile-fail/issue-3763.rs b/src/test/compile-fail/issue-3763.rs index 73d42aa0de1..06939d8f358 100644 --- a/src/test/compile-fail/issue-3763.rs +++ b/src/test/compile-fail/issue-3763.rs @@ -8,6 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] mod my_mod { pub struct MyStruct { diff --git a/src/test/compile-fail/issue-4335.rs b/src/test/compile-fail/issue-4335.rs index d4f9ea5b276..f35332a2f03 100644 --- a/src/test/compile-fail/issue-4335.rs +++ b/src/test/compile-fail/issue-4335.rs @@ -9,6 +9,7 @@ // except according to those terms. #![feature(unboxed_closures)] +#![feature(box_syntax)] fn id<T>(t: T) -> T { t } diff --git a/src/test/compile-fail/issue-4972.rs b/src/test/compile-fail/issue-4972.rs index 765aec35fc6..b2b9dfce092 100644 --- a/src/test/compile-fail/issue-4972.rs +++ b/src/test/compile-fail/issue-4972.rs @@ -8,6 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] trait MyTrait { } diff --git a/src/test/compile-fail/issue-5100.rs b/src/test/compile-fail/issue-5100.rs index df3748ac934..ca7f87ff61a 100644 --- a/src/test/compile-fail/issue-5100.rs +++ b/src/test/compile-fail/issue-5100.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] + enum A { B, C } fn main() { diff --git a/src/test/compile-fail/issue-5439.rs b/src/test/compile-fail/issue-5439.rs index 55e3459a589..72074d64edc 100644 --- a/src/test/compile-fail/issue-5439.rs +++ b/src/test/compile-fail/issue-5439.rs @@ -8,6 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] struct Foo { foo: int, diff --git a/src/test/compile-fail/issue-5543.rs b/src/test/compile-fail/issue-5543.rs index 2d64013dc27..cf98f1572e5 100644 --- a/src/test/compile-fail/issue-5543.rs +++ b/src/test/compile-fail/issue-5543.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] + trait Foo {} impl Foo for u8 {} diff --git a/src/test/compile-fail/issue-6801.rs b/src/test/compile-fail/issue-6801.rs index 433ae3bf89e..27230989f63 100644 --- a/src/test/compile-fail/issue-6801.rs +++ b/src/test/compile-fail/issue-6801.rs @@ -12,6 +12,7 @@ // transferring ownership of the owned box before invoking the stack // closure results in a crash. +#![feature(box_syntax)] fn twice(x: Box<uint>) -> uint { *x * 2 diff --git a/src/test/compile-fail/issue-7013.rs b/src/test/compile-fail/issue-7013.rs index d2f9ee47603..d246e4e54d0 100644 --- a/src/test/compile-fail/issue-7013.rs +++ b/src/test/compile-fail/issue-7013.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] + use std::cell::RefCell; use std::rc::Rc; diff --git a/src/test/compile-fail/issue-7364.rs b/src/test/compile-fail/issue-7364.rs index c8c7ef4ed89..b4df38a6aac 100644 --- a/src/test/compile-fail/issue-7364.rs +++ b/src/test/compile-fail/issue-7364.rs @@ -8,6 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] use std::cell::RefCell; diff --git a/src/test/compile-fail/kindck-impl-type-params-2.rs b/src/test/compile-fail/kindck-impl-type-params-2.rs index 9e7c983195a..e188fa9b813 100644 --- a/src/test/compile-fail/kindck-impl-type-params-2.rs +++ b/src/test/compile-fail/kindck-impl-type-params-2.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] + trait Foo { } diff --git a/src/test/compile-fail/kindck-impl-type-params.rs b/src/test/compile-fail/kindck-impl-type-params.rs index 6ecf2593d00..34e77353463 100644 --- a/src/test/compile-fail/kindck-impl-type-params.rs +++ b/src/test/compile-fail/kindck-impl-type-params.rs @@ -11,6 +11,8 @@ // Issue #14061: tests the interaction between generic implementation // parameter bounds and trait objects. +#![feature(box_syntax)] + struct S<T>; trait Gettable<T> {} diff --git a/src/test/compile-fail/kindck-inherited-copy-bound.rs b/src/test/compile-fail/kindck-inherited-copy-bound.rs index 7f610176b65..192e358283f 100644 --- a/src/test/compile-fail/kindck-inherited-copy-bound.rs +++ b/src/test/compile-fail/kindck-inherited-copy-bound.rs @@ -10,6 +10,8 @@ // Test that Copy bounds inherited by trait are checked. +#![feature(box_syntax)] + use std::any::Any; trait Foo : Copy { diff --git a/src/test/compile-fail/lint-owned-heap-memory.rs b/src/test/compile-fail/lint-owned-heap-memory.rs index 5ee16f0aa26..1702cefec6d 100644 --- a/src/test/compile-fail/lint-owned-heap-memory.rs +++ b/src/test/compile-fail/lint-owned-heap-memory.rs @@ -10,7 +10,7 @@ #![allow(dead_code)] #![forbid(box_pointers)] - +#![feature(box_syntax)] struct Foo { x: Box<int> //~ ERROR type uses owned diff --git a/src/test/compile-fail/liveness-move-call-arg.rs b/src/test/compile-fail/liveness-move-call-arg.rs index b9ad1c0fb65..08a523fb8ff 100644 --- a/src/test/compile-fail/liveness-move-call-arg.rs +++ b/src/test/compile-fail/liveness-move-call-arg.rs @@ -8,6 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] fn take(_x: Box<int>) {} diff --git a/src/test/compile-fail/liveness-move-in-loop.rs b/src/test/compile-fail/liveness-move-in-loop.rs index 127a68bd339..b2142258fb0 100644 --- a/src/test/compile-fail/liveness-move-in-loop.rs +++ b/src/test/compile-fail/liveness-move-in-loop.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] + fn main() { let y: Box<int> = box 42; let mut x: Box<int>; diff --git a/src/test/compile-fail/liveness-move-in-while.rs b/src/test/compile-fail/liveness-move-in-while.rs index 2cebe3f573b..549cf523d03 100644 --- a/src/test/compile-fail/liveness-move-in-while.rs +++ b/src/test/compile-fail/liveness-move-in-while.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] + fn main() { let y: Box<int> = box 42; let mut x: Box<int>; diff --git a/src/test/compile-fail/liveness-use-after-move.rs b/src/test/compile-fail/liveness-use-after-move.rs index a988254141a..e1cd12989ca 100644 --- a/src/test/compile-fail/liveness-use-after-move.rs +++ b/src/test/compile-fail/liveness-use-after-move.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] + fn main() { let x = box 5i; let y = x; diff --git a/src/test/compile-fail/macros-nonfatal-errors.rs b/src/test/compile-fail/macros-nonfatal-errors.rs index f97cad559a1..ce1b372a4c1 100644 --- a/src/test/compile-fail/macros-nonfatal-errors.rs +++ b/src/test/compile-fail/macros-nonfatal-errors.rs @@ -22,9 +22,6 @@ enum CantDeriveThose {} fn main() { doesnt_exist!(); //~ ERROR - bytes!(invalid); //~ ERROR non-literal in bytes! - //~^ WARN `bytes!` is deprecated - asm!(invalid); //~ ERROR concat_idents!("not", "idents"); //~ ERROR diff --git a/src/test/compile-fail/map-types.rs b/src/test/compile-fail/map-types.rs index 7aafeced3a6..ba2205f5868 100644 --- a/src/test/compile-fail/map-types.rs +++ b/src/test/compile-fail/map-types.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] + extern crate collections; use std::collections::HashMap; diff --git a/src/test/compile-fail/move-out-of-tuple-field.rs b/src/test/compile-fail/move-out-of-tuple-field.rs index 7fcb54e0467..78b6736c1c8 100644 --- a/src/test/compile-fail/move-out-of-tuple-field.rs +++ b/src/test/compile-fail/move-out-of-tuple-field.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] + struct Foo(Box<int>); fn main() { diff --git a/src/test/compile-fail/moves-based-on-type-block-bad.rs b/src/test/compile-fail/moves-based-on-type-block-bad.rs index 14af49dfc49..379397f22bd 100644 --- a/src/test/compile-fail/moves-based-on-type-block-bad.rs +++ b/src/test/compile-fail/moves-based-on-type-block-bad.rs @@ -10,6 +10,8 @@ // ignore-tidy-linelength +#![feature(box_syntax)] + struct S { x: Box<E> } diff --git a/src/test/compile-fail/moves-based-on-type-move-out-of-closure-env-issue-1965.rs b/src/test/compile-fail/moves-based-on-type-move-out-of-closure-env-issue-1965.rs index ab762332ee4..0f5e012ef19 100644 --- a/src/test/compile-fail/moves-based-on-type-move-out-of-closure-env-issue-1965.rs +++ b/src/test/compile-fail/moves-based-on-type-move-out-of-closure-env-issue-1965.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] + use std::uint; fn test(_x: Box<uint>) {} diff --git a/src/test/compile-fail/moves-based-on-type-no-recursive-stack-closure.rs b/src/test/compile-fail/moves-based-on-type-no-recursive-stack-closure.rs index 9053f97e8a7..f410541f0b7 100644 --- a/src/test/compile-fail/moves-based-on-type-no-recursive-stack-closure.rs +++ b/src/test/compile-fail/moves-based-on-type-no-recursive-stack-closure.rs @@ -12,6 +12,7 @@ // bound must be noncopyable. For details see // http://smallcultfollowing.com/babysteps/blog/2013/04/30/the-case-of-the-recurring-closure/ +#![feature(box_syntax)] #![feature(unboxed_closures)] struct R<'a> { diff --git a/src/test/compile-fail/moves-based-on-type-tuple.rs b/src/test/compile-fail/moves-based-on-type-tuple.rs index 85c435ef0db..397b22c486e 100644 --- a/src/test/compile-fail/moves-based-on-type-tuple.rs +++ b/src/test/compile-fail/moves-based-on-type-tuple.rs @@ -8,6 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] fn dup(x: Box<int>) -> Box<(Box<int>,Box<int>)> { box() (x, x) } //~ ERROR use of moved value fn main() { diff --git a/src/test/compile-fail/moves-sru-moved-field.rs b/src/test/compile-fail/moves-sru-moved-field.rs index 2cf7618d92d..6c351f88713 100644 --- a/src/test/compile-fail/moves-sru-moved-field.rs +++ b/src/test/compile-fail/moves-sru-moved-field.rs @@ -8,6 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] type Noncopyable = Box<int>; diff --git a/src/test/compile-fail/mut-cross-borrowing.rs b/src/test/compile-fail/mut-cross-borrowing.rs index 657c2832c49..90bc0019531 100644 --- a/src/test/compile-fail/mut-cross-borrowing.rs +++ b/src/test/compile-fail/mut-cross-borrowing.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] + fn f(_: &mut int) {} fn main() { diff --git a/src/test/compile-fail/mut-pattern-mismatched.rs b/src/test/compile-fail/mut-pattern-mismatched.rs index 443be7d7b69..9f1d3d1fb39 100644 --- a/src/test/compile-fail/mut-pattern-mismatched.rs +++ b/src/test/compile-fail/mut-pattern-mismatched.rs @@ -13,10 +13,8 @@ fn main() { // (separate lines to ensure the spans are accurate) - // SNAP 340ac04 uncomment this after the next snapshot - // NOTE(stage0) just in case tidy doesn't check snap's in tests - // let &_ // ~ ERROR expected `&mut isize`, found `&_` - // = foo; + let &_ //~ ERROR expected `&mut isize`, found `&_` + = foo; let &mut _ = foo; let bar = &1is; diff --git a/src/test/compile-fail/no-capture-arc.rs b/src/test/compile-fail/no-capture-arc.rs index 9a09448ff01..3d4d0fee0bf 100644 --- a/src/test/compile-fail/no-capture-arc.rs +++ b/src/test/compile-fail/no-capture-arc.rs @@ -23,5 +23,5 @@ fn main() { assert_eq!((*arc_v)[2], 3); - println!("{}", *arc_v); + println!("{:?}", *arc_v); } diff --git a/src/test/compile-fail/no-reuse-move-arc.rs b/src/test/compile-fail/no-reuse-move-arc.rs index de230743685..02028fe62e5 100644 --- a/src/test/compile-fail/no-reuse-move-arc.rs +++ b/src/test/compile-fail/no-reuse-move-arc.rs @@ -21,5 +21,5 @@ fn main() { assert_eq!((*arc_v)[2], 3); //~ ERROR use of moved value: `arc_v` - println!("{}", *arc_v); //~ ERROR use of moved value: `arc_v` + println!("{:?}", *arc_v); //~ ERROR use of moved value: `arc_v` } diff --git a/src/test/compile-fail/occurs-check-2.rs b/src/test/compile-fail/occurs-check-2.rs index 2765182225f..bfabcff5116 100644 --- a/src/test/compile-fail/occurs-check-2.rs +++ b/src/test/compile-fail/occurs-check-2.rs @@ -8,6 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] fn main() { let f; diff --git a/src/test/compile-fail/occurs-check.rs b/src/test/compile-fail/occurs-check.rs index 44318b36f4b..417bd9b57ee 100644 --- a/src/test/compile-fail/occurs-check.rs +++ b/src/test/compile-fail/occurs-check.rs @@ -8,6 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] fn main() { let f; diff --git a/src/test/compile-fail/packed-struct-generic-transmute.rs b/src/test/compile-fail/packed-struct-generic-transmute.rs index 38177d07645..6b6ab3f2970 100644 --- a/src/test/compile-fail/packed-struct-generic-transmute.rs +++ b/src/test/compile-fail/packed-struct-generic-transmute.rs @@ -15,8 +15,6 @@ // error-pattern: transmute called on types with different size -#![feature(slicing_syntax)] - use std::mem; #[repr(packed)] @@ -34,6 +32,6 @@ fn main() { let foo = Foo { bar: [1u8, 2, 3, 4, 5], baz: 10i32 }; unsafe { let oof: Oof<[u8; 5], i32> = mem::transmute(foo); - println!("{} {}", &oof.rab[], oof.zab); + println!("{:?} {:?}", &oof.rab[], oof.zab); } } diff --git a/src/test/compile-fail/pattern-bindings-after-at.rs b/src/test/compile-fail/pattern-bindings-after-at.rs index 9cd2d0d28b1..54ac3cba636 100644 --- a/src/test/compile-fail/pattern-bindings-after-at.rs +++ b/src/test/compile-fail/pattern-bindings-after-at.rs @@ -15,7 +15,7 @@ enum Option<T> { fn main() { match &mut Some(1i) { - ref mut z @ &Some(ref a) => { + ref mut z @ &mut Some(ref a) => { //~^ ERROR pattern bindings are not allowed after an `@` **z = None; println!("{}", *a); diff --git a/src/test/compile-fail/range-1.rs b/src/test/compile-fail/range-1.rs index 0ade2975044..1668b868e64 100644 --- a/src/test/compile-fail/range-1.rs +++ b/src/test/compile-fail/range-1.rs @@ -9,7 +9,6 @@ // except according to those terms. // Test range syntax - type errors. -#![feature(slicing_syntax)] pub fn main() { // Mixed types. diff --git a/src/test/compile-fail/range-2.rs b/src/test/compile-fail/range-2.rs index 74c304884a0..40690bd844b 100644 --- a/src/test/compile-fail/range-2.rs +++ b/src/test/compile-fail/range-2.rs @@ -9,7 +9,6 @@ // except according to those terms. // Test range syntax - borrow errors. -#![feature(slicing_syntax)] pub fn main() { let r = { diff --git a/src/test/compile-fail/recursion.rs b/src/test/compile-fail/recursion.rs index 67177eff9f9..da05514f763 100644 --- a/src/test/compile-fail/recursion.rs +++ b/src/test/compile-fail/recursion.rs @@ -8,6 +8,13 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +//~^^^^^^^^^^ 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. + enum Nil {NilValue} struct Cons<T> {head:int, tail:T} trait Dot {fn dot(&self, other:Self) -> int;} diff --git a/src/test/compile-fail/region-object-lifetime-in-coercion.rs b/src/test/compile-fail/region-object-lifetime-in-coercion.rs index b2b2d3337c4..e4521873a61 100644 --- a/src/test/compile-fail/region-object-lifetime-in-coercion.rs +++ b/src/test/compile-fail/region-object-lifetime-in-coercion.rs @@ -11,6 +11,8 @@ // Test that attempts to implicitly coerce a value into an // object respect the lifetime bound on the object type. +#![feature(box_syntax)] + trait Foo {} impl<'a> Foo for &'a [u8] {} diff --git a/src/test/compile-fail/regions-close-associated-type-into-object.rs b/src/test/compile-fail/regions-close-associated-type-into-object.rs index 816314529b5..8a03f36972d 100644 --- a/src/test/compile-fail/regions-close-associated-type-into-object.rs +++ b/src/test/compile-fail/regions-close-associated-type-into-object.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] + trait X {} trait Iter { diff --git a/src/test/compile-fail/regions-close-object-into-object.rs b/src/test/compile-fail/regions-close-object-into-object.rs index 48945868bd3..675f86b58f4 100644 --- a/src/test/compile-fail/regions-close-object-into-object.rs +++ b/src/test/compile-fail/regions-close-object-into-object.rs @@ -8,6 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] trait A<T> {} struct B<'a, T>(&'a (A<T>+'a)); diff --git a/src/test/compile-fail/regions-close-over-borrowed-ref-in-obj.rs b/src/test/compile-fail/regions-close-over-borrowed-ref-in-obj.rs index 037514f45c7..e17786e6a51 100644 --- a/src/test/compile-fail/regions-close-over-borrowed-ref-in-obj.rs +++ b/src/test/compile-fail/regions-close-over-borrowed-ref-in-obj.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] + trait Foo { } impl<'a> Foo for &'a int { } diff --git a/src/test/compile-fail/regions-close-over-type-parameter-1.rs b/src/test/compile-fail/regions-close-over-type-parameter-1.rs index 5465f199f40..985ae6116f0 100644 --- a/src/test/compile-fail/regions-close-over-type-parameter-1.rs +++ b/src/test/compile-fail/regions-close-over-type-parameter-1.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] + // Test for what happens when a type parameter `A` is closed over into // an object. This should yield errors unless `A` (and the object) // both have suitable bounds. diff --git a/src/test/compile-fail/regions-close-over-type-parameter-2.rs b/src/test/compile-fail/regions-close-over-type-parameter-2.rs index 0ee349aaebf..85ff336b4cb 100644 --- a/src/test/compile-fail/regions-close-over-type-parameter-2.rs +++ b/src/test/compile-fail/regions-close-over-type-parameter-2.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] + // Test for what happens when a type parameter `A` is closed over into // an object. This should yield errors unless `A` (and the object) // both have suitable bounds. diff --git a/src/test/compile-fail/regions-close-over-type-parameter-multiple.rs b/src/test/compile-fail/regions-close-over-type-parameter-multiple.rs index cec785c6e96..2aa77b2e53d 100644 --- a/src/test/compile-fail/regions-close-over-type-parameter-multiple.rs +++ b/src/test/compile-fail/regions-close-over-type-parameter-multiple.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] + // Various tests where we over type parameters with multiple lifetime // bounds. diff --git a/src/test/compile-fail/regions-close-param-into-object.rs b/src/test/compile-fail/regions-close-param-into-object.rs index 3e91d090c31..74b36958c92 100644 --- a/src/test/compile-fail/regions-close-param-into-object.rs +++ b/src/test/compile-fail/regions-close-param-into-object.rs @@ -8,6 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] trait X {} diff --git a/src/test/compile-fail/regions-nested-fns.rs b/src/test/compile-fail/regions-nested-fns.rs index 5d8ef718ef0..e8054779774 100644 --- a/src/test/compile-fail/regions-nested-fns.rs +++ b/src/test/compile-fail/regions-nested-fns.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] + fn ignore<T>(t: T) {} fn nested<'x>(x: &'x int) { diff --git a/src/test/compile-fail/regions-proc-bound-capture.rs b/src/test/compile-fail/regions-proc-bound-capture.rs index 0841c1852f8..b849ddf7b82 100644 --- a/src/test/compile-fail/regions-proc-bound-capture.rs +++ b/src/test/compile-fail/regions-proc-bound-capture.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] + fn borrowed_proc<'a>(x: &'a int) -> Box<FnMut()->(int) + 'a> { // This is legal, because the region bound on `proc` // states that it captures `x`. diff --git a/src/test/compile-fail/regions-ref-in-fn-arg.rs b/src/test/compile-fail/regions-ref-in-fn-arg.rs index f9eecb60c6a..e47fddbdc36 100644 --- a/src/test/compile-fail/regions-ref-in-fn-arg.rs +++ b/src/test/compile-fail/regions-ref-in-fn-arg.rs @@ -8,6 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] fn arg_item(box ref x: Box<int>) -> &'static int { x //~^ ERROR borrowed value does not live long enough diff --git a/src/test/compile-fail/regions-steal-closure.rs b/src/test/compile-fail/regions-steal-closure.rs index 991040bc62f..12f5f295499 100644 --- a/src/test/compile-fail/regions-steal-closure.rs +++ b/src/test/compile-fail/regions-steal-closure.rs @@ -8,6 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] #![feature(unboxed_closures)] struct closure_box<'a> { diff --git a/src/test/compile-fail/regions-trait-1.rs b/src/test/compile-fail/regions-trait-1.rs index 7771a71c79b..32d89607e4b 100644 --- a/src/test/compile-fail/regions-trait-1.rs +++ b/src/test/compile-fail/regions-trait-1.rs @@ -8,6 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] struct ctxt { v: uint } diff --git a/src/test/compile-fail/regions-trait-variance.rs b/src/test/compile-fail/regions-trait-variance.rs index 4e31a41c4e0..22e43c0bf89 100644 --- a/src/test/compile-fail/regions-trait-variance.rs +++ b/src/test/compile-fail/regions-trait-variance.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] + // Issue #12470. trait X { diff --git a/src/test/compile-fail/require-parens-for-chained-comparison.rs b/src/test/compile-fail/require-parens-for-chained-comparison.rs new file mode 100644 index 00000000000..7513815ad73 --- /dev/null +++ b/src/test/compile-fail/require-parens-for-chained-comparison.rs @@ -0,0 +1,23 @@ +// 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 f<T>() {} + +fn main() { + false == false == false; + //~^ ERROR: Chained comparison operators require parentheses + + false == 0 < 2; + //~^ ERROR: Chained comparison operators require parentheses + + f<X>(); + //~^ ERROR: Chained comparison operators require parentheses + //~^^ HELP: Use ::< instead of < if you meant to specify type arguments. +} diff --git a/src/test/compile-fail/shadowed-type-parameter.rs b/src/test/compile-fail/shadowed-type-parameter.rs new file mode 100644 index 00000000000..1a3d7821159 --- /dev/null +++ b/src/test/compile-fail/shadowed-type-parameter.rs @@ -0,0 +1,38 @@ +// Copyright 2013 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// Test that shadowed lifetimes generate an error. + +#![feature(box_syntax)] + +struct Foo<T>; + +impl<T> Foo<T> { + fn shadow_in_method<T>(&self) {} + //~^ ERROR type parameter `T` shadows another type parameter + + fn not_shadow_in_item<U>(&self) { + struct Bar<T, U>; // not a shadow, separate item + fn foo<T, U>() {} // same + } +} + +trait Bar<T> { + fn shadow_in_required<T>(&self); + //~^ ERROR type parameter `T` shadows another type parameter + + fn shadow_in_provided<T>(&self) {} + //~^ ERROR type parameter `T` shadows another type parameter + + fn not_shadow_in_required<U>(&self); + fn not_shadow_in_provided<U>(&self) {} +} + +fn main() {} diff --git a/src/test/compile-fail/slice-2.rs b/src/test/compile-fail/slice-2.rs index a03693b5fad..07162293565 100644 --- a/src/test/compile-fail/slice-2.rs +++ b/src/test/compile-fail/slice-2.rs @@ -10,8 +10,6 @@ // Test that slicing syntax gives errors if we have not implemented the trait. -#![feature(slicing_syntax)] - struct Foo; fn main() { diff --git a/src/test/compile-fail/slice-borrow.rs b/src/test/compile-fail/slice-borrow.rs index aab187f9751..43c4326628d 100644 --- a/src/test/compile-fail/slice-borrow.rs +++ b/src/test/compile-fail/slice-borrow.rs @@ -10,8 +10,6 @@ // Test slicing expressions doesn't defeat the borrow checker. -#![feature(slicing_syntax)] - fn main() { let y; { diff --git a/src/test/compile-fail/slice-mut-2.rs b/src/test/compile-fail/slice-mut-2.rs index 1dedb0cf888..12f184d410c 100644 --- a/src/test/compile-fail/slice-mut-2.rs +++ b/src/test/compile-fail/slice-mut-2.rs @@ -10,8 +10,6 @@ // Test mutability and slicing syntax. -#![feature(slicing_syntax)] - fn main() { let x: &[int] = &[1, 2, 3, 4, 5]; // Can't mutably slice an immutable slice diff --git a/src/test/compile-fail/slice-mut.rs b/src/test/compile-fail/slice-mut.rs index f0f525a5535..9bd9a752e4e 100644 --- a/src/test/compile-fail/slice-mut.rs +++ b/src/test/compile-fail/slice-mut.rs @@ -10,8 +10,6 @@ // Test mutability and slicing syntax. -#![feature(slicing_syntax)] - fn main() { let x: &[int] = &[1, 2, 3, 4, 5]; // Immutable slices are not mutable. diff --git a/src/test/compile-fail/static-mut-not-constant.rs b/src/test/compile-fail/static-mut-not-constant.rs index 84c72de5548..fd05f05502e 100644 --- a/src/test/compile-fail/static-mut-not-constant.rs +++ b/src/test/compile-fail/static-mut-not-constant.rs @@ -8,6 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] static mut a: Box<int> = box 3; //~^ ERROR statics are not allowed to have custom pointers diff --git a/src/test/compile-fail/static-region-bound.rs b/src/test/compile-fail/static-region-bound.rs index 1e5a5ecc08e..42f9d24bc52 100644 --- a/src/test/compile-fail/static-region-bound.rs +++ b/src/test/compile-fail/static-region-bound.rs @@ -8,6 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] fn f<T:'static>(_: T) {} diff --git a/src/test/compile-fail/syntax-extension-bytes-too-small-u8-literal.rs b/src/test/compile-fail/syntax-extension-bytes-too-small-u8-literal.rs deleted file mode 100644 index ac33ffb60e2..00000000000 --- a/src/test/compile-fail/syntax-extension-bytes-too-small-u8-literal.rs +++ /dev/null @@ -1,14 +0,0 @@ -// Copyright 2013 The Rust Project Developers. See the COPYRIGHT -// file at the top-level directory of this distribution and at -// http://rust-lang.org/COPYRIGHT. -// -// Licensed under the Apache License, Version 2.0 <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 vec = bytes!(-1024u8); //~ ERROR non-literal in bytes - //~^ WARN `bytes!` is deprecated -} diff --git a/src/test/compile-fail/syntax-extension-bytes-unsupported-literal.rs b/src/test/compile-fail/syntax-extension-bytes-unsupported-literal.rs deleted file mode 100644 index f6b3659354c..00000000000 --- a/src/test/compile-fail/syntax-extension-bytes-unsupported-literal.rs +++ /dev/null @@ -1,14 +0,0 @@ -// Copyright 2013 The Rust Project Developers. See the COPYRIGHT -// file at the top-level directory of this distribution and at -// http://rust-lang.org/COPYRIGHT. -// -// Licensed under the Apache License, Version 2.0 <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 vec = bytes!(45f64); //~ ERROR unsupported literal in bytes! - //~^ WARN `bytes!` is deprecated -} diff --git a/src/test/compile-fail/trait-coercion-generic-bad.rs b/src/test/compile-fail/trait-coercion-generic-bad.rs index e6ea8e10b22..1ddfc5b7ccd 100644 --- a/src/test/compile-fail/trait-coercion-generic-bad.rs +++ b/src/test/compile-fail/trait-coercion-generic-bad.rs @@ -8,6 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] struct Struct { person: &'static str diff --git a/src/test/compile-fail/trait-coercion-generic-regions.rs b/src/test/compile-fail/trait-coercion-generic-regions.rs index 5f4d51918ed..9c78d7ea243 100644 --- a/src/test/compile-fail/trait-coercion-generic-regions.rs +++ b/src/test/compile-fail/trait-coercion-generic-regions.rs @@ -8,6 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] struct Struct { person: &'static str diff --git a/src/test/compile-fail/trait-test-2.rs b/src/test/compile-fail/trait-test-2.rs index a24f7710d7b..f66034e395c 100644 --- a/src/test/compile-fail/trait-test-2.rs +++ b/src/test/compile-fail/trait-test-2.rs @@ -8,6 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] trait bar { fn dup(&self) -> Self; fn blah<X>(&self); } impl bar for int { fn dup(&self) -> int { *self } fn blah<X>(&self) {} } diff --git a/src/test/compile-fail/ufcs-explicit-self-bad.rs b/src/test/compile-fail/ufcs-explicit-self-bad.rs index 8d3610affdf..5ba660495f7 100644 --- a/src/test/compile-fail/ufcs-explicit-self-bad.rs +++ b/src/test/compile-fail/ufcs-explicit-self-bad.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] + struct Foo { f: int, } diff --git a/src/test/compile-fail/unboxed-closure-illegal-move.rs b/src/test/compile-fail/unboxed-closure-illegal-move.rs index 9e981f2c9bb..4d6f04da026 100644 --- a/src/test/compile-fail/unboxed-closure-illegal-move.rs +++ b/src/test/compile-fail/unboxed-closure-illegal-move.rs @@ -8,6 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] #![feature(unboxed_closures)] // Tests that we can't move out of an unboxed closure environment diff --git a/src/test/compile-fail/unique-object-noncopyable.rs b/src/test/compile-fail/unique-object-noncopyable.rs index e237e2c8b75..2dde11ada28 100644 --- a/src/test/compile-fail/unique-object-noncopyable.rs +++ b/src/test/compile-fail/unique-object-noncopyable.rs @@ -8,6 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] trait Foo { fn f(&self); diff --git a/src/test/compile-fail/unique-pinned-nocopy.rs b/src/test/compile-fail/unique-pinned-nocopy.rs index d306d171ca8..04eaa3d7ae0 100644 --- a/src/test/compile-fail/unique-pinned-nocopy.rs +++ b/src/test/compile-fail/unique-pinned-nocopy.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] + #[derive(Show)] struct r { b: bool, diff --git a/src/test/compile-fail/unique-unique-kind.rs b/src/test/compile-fail/unique-unique-kind.rs index 49cebbf5255..ae354729b92 100644 --- a/src/test/compile-fail/unique-unique-kind.rs +++ b/src/test/compile-fail/unique-unique-kind.rs @@ -8,6 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] use std::rc::Rc; diff --git a/src/test/compile-fail/unique-vec-res.rs b/src/test/compile-fail/unique-vec-res.rs index 4848c988300..b558989304f 100644 --- a/src/test/compile-fail/unique-vec-res.rs +++ b/src/test/compile-fail/unique-vec-res.rs @@ -10,6 +10,8 @@ #![feature(unsafe_destructor)] +#![feature(box_syntax)] + use std::cell::Cell; #[derive(Show)] diff --git a/src/test/compile-fail/unreachable-arm.rs b/src/test/compile-fail/unreachable-arm.rs index 3ff6c733026..934ddb5f80b 100644 --- a/src/test/compile-fail/unreachable-arm.rs +++ b/src/test/compile-fail/unreachable-arm.rs @@ -10,6 +10,7 @@ // error-pattern:unreachable pattern +#![feature(box_syntax)] enum foo { a(Box<foo>, int), b(uint), } diff --git a/src/test/compile-fail/unsized2.rs b/src/test/compile-fail/unsized2.rs index c5f9e8d5991..604f7ba3255 100644 --- a/src/test/compile-fail/unsized2.rs +++ b/src/test/compile-fail/unsized2.rs @@ -13,5 +13,8 @@ fn f<X>() {} pub fn main() { - f<type>(); //~ ERROR expected identifier, found keyword `type` + f<type>(); + //~^ ERROR expected identifier, found keyword `type` + //~^^ ERROR: Chained comparison operators require parentheses + //~^^^ HELP: Use ::< instead of < if you meant to specify type arguments. } 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 364bfc42985..d8a82d8fbf0 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 @@ -10,6 +10,8 @@ // ignore-tidy-linelength +#![feature(box_syntax)] + use std::fmt; struct Number { diff --git a/src/test/compile-fail/use-after-move-self.rs b/src/test/compile-fail/use-after-move-self.rs index 607d6163208..ce0f2808e33 100644 --- a/src/test/compile-fail/use-after-move-self.rs +++ b/src/test/compile-fail/use-after-move-self.rs @@ -8,6 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] struct S { x: Box<int>, diff --git a/src/test/compile-fail/where-clauses-not-parameter.rs b/src/test/compile-fail/where-clauses-not-parameter.rs index 148473f8987..d8af859c081 100644 --- a/src/test/compile-fail/where-clauses-not-parameter.rs +++ b/src/test/compile-fail/where-clauses-not-parameter.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -fn equal<T>(_: &T, _: &T) -> bool where int : Eq { +fn equal<T>(_: &T, _: &T) -> bool where isize : Eq { true //~^ ERROR cannot bound type `isize`, where clause bounds may only be attached } @@ -16,24 +16,26 @@ fn equal<T>(_: &T, _: &T) -> bool where int : Eq { fn test<T: Eq>() -> bool where Option<T> : Eq {} // This should be rejected as well. -fn test2() -> bool where Option<int> : Eq {} -//~^ ERROR cannot bound type `core::option::Option<isize>`, where clause bounds +fn test2() -> bool where Option<isize> : Eq {} +//~^ ERROR cannot bound type `core::option::Option<isize>`, where clause bounds may #[derive(PartialEq)] //~^ ERROR cannot bound type `isize`, where clause bounds -enum Foo<T> where int : Eq { MkFoo } +enum Foo<T> where isize : Eq { MkFoo } //~^ ERROR cannot bound type `isize`, where clause bounds fn test3<T: Eq>() -> bool where Option<Foo<T>> : Eq {} -fn test4() -> bool where Option<Foo<int>> : Eq {} +fn test4() -> bool where Option<Foo<isize>> : Eq {} //~^ ERROR cannot bound type `core::option::Option<Foo<isize>>`, where clause bounds -trait Baz<T> where int : Eq { - fn baz() where String : Eq; +trait Baz<T> where isize : Eq { + //~^ ERROR cannot bound type `isize`, where clause bounds may only + fn baz() where String : Eq; //~ ERROR cannot bound type `collections::string::String` + //~^ ERROR cannot bound type `isize`, where clause } -impl Baz<int> for int where int : Eq { +impl Baz<int> for int where isize : Eq { //~^ ERROR cannot bound type `isize`, where clause bounds fn baz() where String : Eq {} } diff --git a/src/test/debuginfo/borrowed-struct.rs b/src/test/debuginfo/borrowed-struct.rs index e3cf438be43..53d2befc49d 100644 --- a/src/test/debuginfo/borrowed-struct.rs +++ b/src/test/debuginfo/borrowed-struct.rs @@ -64,6 +64,7 @@ // lldb-check:[...]$6 = 26.5 #![allow(unused_variables)] +#![feature(box_syntax)] #![omit_gdb_pretty_printer_section] struct SomeStruct { diff --git a/src/test/debuginfo/borrowed-tuple.rs b/src/test/debuginfo/borrowed-tuple.rs index ce0930f2fbf..c7e5987fbcf 100644 --- a/src/test/debuginfo/borrowed-tuple.rs +++ b/src/test/debuginfo/borrowed-tuple.rs @@ -42,6 +42,7 @@ #![allow(unused_variables)] +#![feature(box_syntax)] #![omit_gdb_pretty_printer_section] fn main() { diff --git a/src/test/debuginfo/borrowed-unique-basic.rs b/src/test/debuginfo/borrowed-unique-basic.rs index d152775a8ed..fc186a0b5b2 100644 --- a/src/test/debuginfo/borrowed-unique-basic.rs +++ b/src/test/debuginfo/borrowed-unique-basic.rs @@ -112,6 +112,7 @@ // lldb-check:[...]$12 = 3.5 #![allow(unused_variables)] +#![feature(box_syntax)] #![omit_gdb_pretty_printer_section] fn main() { diff --git a/src/test/debuginfo/box.rs b/src/test/debuginfo/box.rs index 5a70eb19041..0439e3dc34d 100644 --- a/src/test/debuginfo/box.rs +++ b/src/test/debuginfo/box.rs @@ -32,6 +32,7 @@ // lldb-check:[...]$1 = (2, 3.5) #![allow(unused_variables)] +#![feature(box_syntax)] #![omit_gdb_pretty_printer_section] fn main() { diff --git a/src/test/debuginfo/boxed-struct.rs b/src/test/debuginfo/boxed-struct.rs index f9d762bf99d..6397efa0a96 100644 --- a/src/test/debuginfo/boxed-struct.rs +++ b/src/test/debuginfo/boxed-struct.rs @@ -35,6 +35,7 @@ // lldb-check:[...]$1 = StructWithDestructor { x: 77, y: 777, z: 7777, w: 77777 } #![allow(unused_variables)] +#![feature(box_syntax)] #![omit_gdb_pretty_printer_section] struct StructWithSomePadding { diff --git a/src/test/debuginfo/closure-in-generic-function.rs b/src/test/debuginfo/closure-in-generic-function.rs index e3cb190c3f2..f8b12569400 100644 --- a/src/test/debuginfo/closure-in-generic-function.rs +++ b/src/test/debuginfo/closure-in-generic-function.rs @@ -46,6 +46,7 @@ // lldb-check:[...]$3 = 110 // lldb-command:continue +#![feature(box_syntax)] #![omit_gdb_pretty_printer_section] fn some_generic_fun<T1, T2>(a: T1, b: T2) -> (T2, T1) { diff --git a/src/test/debuginfo/destructured-fn-argument.rs b/src/test/debuginfo/destructured-fn-argument.rs index b4688e4928a..73289c56bef 100644 --- a/src/test/debuginfo/destructured-fn-argument.rs +++ b/src/test/debuginfo/destructured-fn-argument.rs @@ -311,6 +311,7 @@ // lldb-command:continue #![allow(unused_variables)] +#![feature(box_syntax)] #![omit_gdb_pretty_printer_section] use self::Univariant::Unit; diff --git a/src/test/debuginfo/destructured-for-loop-variable.rs b/src/test/debuginfo/destructured-for-loop-variable.rs index 364720d0e4f..103bdc03550 100644 --- a/src/test/debuginfo/destructured-for-loop-variable.rs +++ b/src/test/debuginfo/destructured-for-loop-variable.rs @@ -153,6 +153,7 @@ // lldb-command:continue #![allow(unused_variables)] +#![feature(box_syntax)] #![omit_gdb_pretty_printer_section] struct Struct { diff --git a/src/test/debuginfo/destructured-local.rs b/src/test/debuginfo/destructured-local.rs index d5a6b36f1fc..1fd598e18c1 100644 --- a/src/test/debuginfo/destructured-local.rs +++ b/src/test/debuginfo/destructured-local.rs @@ -244,6 +244,7 @@ #![allow(unused_variables)] +#![feature(box_syntax)] #![omit_gdb_pretty_printer_section] use self::Univariant::Unit; diff --git a/src/test/debuginfo/generic-method-on-generic-struct.rs b/src/test/debuginfo/generic-method-on-generic-struct.rs index 0e358499a3d..66cd73622ff 100644 --- a/src/test/debuginfo/generic-method-on-generic-struct.rs +++ b/src/test/debuginfo/generic-method-on-generic-struct.rs @@ -112,6 +112,7 @@ // lldb-check:[...]$14 = -10.5 // lldb-command:continue +#![feature(box_syntax)] #![omit_gdb_pretty_printer_section] struct Struct<T> { diff --git a/src/test/debuginfo/method-on-enum.rs b/src/test/debuginfo/method-on-enum.rs index b1ebb124d4e..732e1d5c500 100644 --- a/src/test/debuginfo/method-on-enum.rs +++ b/src/test/debuginfo/method-on-enum.rs @@ -113,6 +113,7 @@ // lldb-check:[...]$14 = -10 // lldb-command:continue +#![feature(box_syntax)] #![omit_gdb_pretty_printer_section] enum Enum { diff --git a/src/test/debuginfo/method-on-generic-struct.rs b/src/test/debuginfo/method-on-generic-struct.rs index 68a6ac8c1f3..c1785951e23 100644 --- a/src/test/debuginfo/method-on-generic-struct.rs +++ b/src/test/debuginfo/method-on-generic-struct.rs @@ -113,6 +113,7 @@ // lldb-command:continue +#![feature(box_syntax)] #![omit_gdb_pretty_printer_section] struct Struct<T> { diff --git a/src/test/debuginfo/method-on-struct.rs b/src/test/debuginfo/method-on-struct.rs index 84e74d4364c..d88a32b8475 100644 --- a/src/test/debuginfo/method-on-struct.rs +++ b/src/test/debuginfo/method-on-struct.rs @@ -113,6 +113,7 @@ // lldb-command:continue +#![feature(box_syntax)] #![omit_gdb_pretty_printer_section] struct Struct { diff --git a/src/test/debuginfo/method-on-trait.rs b/src/test/debuginfo/method-on-trait.rs index f53bb11eac4..5622d17225b 100644 --- a/src/test/debuginfo/method-on-trait.rs +++ b/src/test/debuginfo/method-on-trait.rs @@ -113,6 +113,7 @@ // lldb-command:continue +#![feature(box_syntax)] #![omit_gdb_pretty_printer_section] struct Struct { diff --git a/src/test/debuginfo/method-on-tuple-struct.rs b/src/test/debuginfo/method-on-tuple-struct.rs index 6994c38818c..02f7808221a 100644 --- a/src/test/debuginfo/method-on-tuple-struct.rs +++ b/src/test/debuginfo/method-on-tuple-struct.rs @@ -113,6 +113,7 @@ // lldb-command:continue +#![feature(box_syntax)] #![omit_gdb_pretty_printer_section] struct TupleStruct(int, f64); diff --git a/src/test/debuginfo/recursive-struct.rs b/src/test/debuginfo/recursive-struct.rs index 90c32ad8da1..2cbe9f43789 100644 --- a/src/test/debuginfo/recursive-struct.rs +++ b/src/test/debuginfo/recursive-struct.rs @@ -69,6 +69,7 @@ // gdb-command:continue #![allow(unused_variables)] +#![feature(box_syntax)] #![omit_gdb_pretty_printer_section] use self::Opt::{Empty, Val}; diff --git a/src/test/debuginfo/self-in-default-method.rs b/src/test/debuginfo/self-in-default-method.rs index 87884d2f956..a1074e490f7 100644 --- a/src/test/debuginfo/self-in-default-method.rs +++ b/src/test/debuginfo/self-in-default-method.rs @@ -112,6 +112,7 @@ // lldb-check:[...]$14 = -10 // lldb-command:continue +#![feature(box_syntax)] #![omit_gdb_pretty_printer_section] struct Struct { diff --git a/src/test/debuginfo/self-in-generic-default-method.rs b/src/test/debuginfo/self-in-generic-default-method.rs index 62b5e6872ee..f0da6e26870 100644 --- a/src/test/debuginfo/self-in-generic-default-method.rs +++ b/src/test/debuginfo/self-in-generic-default-method.rs @@ -112,6 +112,7 @@ // lldb-check:[...]$14 = -10.5 // lldb-command:continue +#![feature(box_syntax)] #![omit_gdb_pretty_printer_section] struct Struct { diff --git a/src/test/debuginfo/trait-pointers.rs b/src/test/debuginfo/trait-pointers.rs index 9f8c0aa06e6..b95190f875a 100644 --- a/src/test/debuginfo/trait-pointers.rs +++ b/src/test/debuginfo/trait-pointers.rs @@ -16,6 +16,7 @@ // lldb-command:run #![allow(unused_variables)] +#![feature(box_syntax)] #![omit_gdb_pretty_printer_section] trait Trait { diff --git a/src/test/debuginfo/type-names.rs b/src/test/debuginfo/type-names.rs index b508da73f4a..156e5f12ad5 100644 --- a/src/test/debuginfo/type-names.rs +++ b/src/test/debuginfo/type-names.rs @@ -173,6 +173,7 @@ // gdb-command:whatis closure2 // gdb-check:type = struct (closure, usize) +#![feature(box_syntax)] #![omit_gdb_pretty_printer_section] use self::Enum1::{Variant1_1, Variant1_2}; diff --git a/src/test/debuginfo/unique-enum.rs b/src/test/debuginfo/unique-enum.rs index 3d028eb1077..08622b2dca8 100644 --- a/src/test/debuginfo/unique-enum.rs +++ b/src/test/debuginfo/unique-enum.rs @@ -42,6 +42,7 @@ // lldb-check:[...]$2 = TheOnlyCase(123234) #![allow(unused_variables)] +#![feature(box_syntax)] #![omit_gdb_pretty_printer_section] // The first element is to ensure proper alignment, irrespective of the machines word size. Since diff --git a/src/test/debuginfo/var-captured-in-nested-closure.rs b/src/test/debuginfo/var-captured-in-nested-closure.rs index 3a7fbb9a3a1..d7831c983c0 100644 --- a/src/test/debuginfo/var-captured-in-nested-closure.rs +++ b/src/test/debuginfo/var-captured-in-nested-closure.rs @@ -79,6 +79,7 @@ // lldb-command:continue #![allow(unused_variables)] +#![feature(box_syntax)] #![omit_gdb_pretty_printer_section] struct Struct { diff --git a/src/test/debuginfo/var-captured-in-sendable-closure.rs b/src/test/debuginfo/var-captured-in-sendable-closure.rs index b34749260f3..30a07ea46dd 100644 --- a/src/test/debuginfo/var-captured-in-sendable-closure.rs +++ b/src/test/debuginfo/var-captured-in-sendable-closure.rs @@ -41,7 +41,7 @@ // lldb-check:[...]$2 = 5 #![allow(unused_variables)] -#![feature(unboxed_closures)] +#![feature(unboxed_closures, box_syntax)] #![omit_gdb_pretty_printer_section] struct Struct { diff --git a/src/test/debuginfo/var-captured-in-stack-closure.rs b/src/test/debuginfo/var-captured-in-stack-closure.rs index a743adae51e..9daf6abba11 100644 --- a/src/test/debuginfo/var-captured-in-stack-closure.rs +++ b/src/test/debuginfo/var-captured-in-stack-closure.rs @@ -70,7 +70,7 @@ // lldb-command:print *owned // lldb-check:[...]$9 = 6 -#![feature(unboxed_closures)] +#![feature(unboxed_closures, box_syntax)] #![allow(unused_variables)] #![omit_gdb_pretty_printer_section] diff --git a/src/test/debuginfo/vec-slices.rs b/src/test/debuginfo/vec-slices.rs index 14f1dbb9d65..949dffaac06 100644 --- a/src/test/debuginfo/vec-slices.rs +++ b/src/test/debuginfo/vec-slices.rs @@ -77,7 +77,6 @@ // lldb-check:[...]$5 = &[AStruct { x: 10, y: 11, z: 12 }, AStruct { x: 13, y: 14, z: 15 }] #![allow(unused_variables)] -#![feature(slicing_syntax)] #![omit_gdb_pretty_printer_section] struct AStruct { diff --git a/src/test/pretty/issue-4264.pp b/src/test/pretty/issue-4264.pp index f20087ef677..dac6e628d10 100644 --- a/src/test/pretty/issue-4264.pp +++ b/src/test/pretty/issue-4264.pp @@ -1,5 +1,4 @@ #![no_std] -#![feature(globs)] #[macro_use] extern crate "std" as std; #[prelude_import] diff --git a/src/test/pretty/path-type-bounds.rs b/src/test/pretty/path-type-bounds.rs index f575fb32924..382394b1407 100644 --- a/src/test/pretty/path-type-bounds.rs +++ b/src/test/pretty/path-type-bounds.rs @@ -19,6 +19,6 @@ fn foo<'a>(x: Box<Tr+ Sync + 'a>) -> Box<Tr+ Sync + 'a> { x } fn main() { let x: Box<Tr+ Sync>; - box() 1i as Box<Tr+ Sync>; + Box::new(1i) as Box<Tr+ Sync>; } diff --git a/src/test/run-fail/args-panic.rs b/src/test/run-fail/args-panic.rs index 4878ec59fd4..eab7475bc86 100644 --- a/src/test/run-fail/args-panic.rs +++ b/src/test/run-fail/args-panic.rs @@ -11,6 +11,9 @@ // error-pattern:meep +#![allow(unknown_features)] +#![feature(box_syntax)] + fn f(_a: int, _b: int, _c: Box<int>) { panic!("moop"); } fn main() { f(1, panic!("meep"), box 42); } diff --git a/src/test/run-fail/panic-macro-any-wrapped.rs b/src/test/run-fail/panic-macro-any-wrapped.rs index e25390a7986..89e47bf46ab 100644 --- a/src/test/run-fail/panic-macro-any-wrapped.rs +++ b/src/test/run-fail/panic-macro-any-wrapped.rs @@ -10,6 +10,9 @@ // error-pattern:panicked at 'Box<Any>' +#![allow(unknown_features)] +#![feature(box_syntax)] + fn main() { panic!(box 612_i64); } diff --git a/src/test/run-fail/panic-macro-any.rs b/src/test/run-fail/panic-macro-any.rs index b73c66c4f21..231c57390b3 100644 --- a/src/test/run-fail/panic-macro-any.rs +++ b/src/test/run-fail/panic-macro-any.rs @@ -10,6 +10,9 @@ // error-pattern:panicked at 'Box<Any>' +#![allow(unknown_features)] +#![feature(box_syntax)] + fn main() { panic!(box 413i as Box<::std::any::Any+Send>); } diff --git a/src/test/run-fail/unique-panic.rs b/src/test/run-fail/unique-panic.rs index 07c9a21c5c1..9f643c09795 100644 --- a/src/test/run-fail/unique-panic.rs +++ b/src/test/run-fail/unique-panic.rs @@ -9,4 +9,8 @@ // except according to those terms. // error-pattern: panic + +#![allow(unknown_features)] +#![feature(box_syntax)] + fn main() { box panic!(); } diff --git a/src/test/run-fail/unwind-unique.rs b/src/test/run-fail/unwind-unique.rs index 6b5aefbab80..f39ded8f98e 100644 --- a/src/test/run-fail/unwind-unique.rs +++ b/src/test/run-fail/unwind-unique.rs @@ -10,6 +10,8 @@ // error-pattern:fail +#![allow(unknown_features)] +#![feature(box_syntax)] fn failfn() { panic!(); diff --git a/src/test/run-make/save-analysis/foo.rs b/src/test/run-make/save-analysis/foo.rs index 61c5312f234..c72d685b311 100644 --- a/src/test/run-make/save-analysis/foo.rs +++ b/src/test/run-make/save-analysis/foo.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] + struct Foo { f: int } diff --git a/src/test/run-pass-valgrind/cleanup-auto-borrow-obj.rs b/src/test/run-pass-valgrind/cleanup-auto-borrow-obj.rs index 5d7dbbe5a29..195055f12d1 100644 --- a/src/test/run-pass-valgrind/cleanup-auto-borrow-obj.rs +++ b/src/test/run-pass-valgrind/cleanup-auto-borrow-obj.rs @@ -13,6 +13,7 @@ // schedule cleanups when auto borrowing trait objects. // This program should be valgrind clean. +#![feature(box_syntax)] static mut DROP_RAN: bool = false; diff --git a/src/test/run-pass-valgrind/dst-dtor-1.rs b/src/test/run-pass-valgrind/dst-dtor-1.rs index 8b8b7f169c5..47e2a18a999 100644 --- a/src/test/run-pass-valgrind/dst-dtor-1.rs +++ b/src/test/run-pass-valgrind/dst-dtor-1.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] + static mut DROP_RAN: bool = false; struct Foo; diff --git a/src/test/run-pass-valgrind/dst-dtor-2.rs b/src/test/run-pass-valgrind/dst-dtor-2.rs index 743293c23f6..2c7b89d680a 100644 --- a/src/test/run-pass-valgrind/dst-dtor-2.rs +++ b/src/test/run-pass-valgrind/dst-dtor-2.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(box_syntax)] + static mut DROP_RAN: int = 0; struct Foo; diff --git a/src/test/run-pass/alignment-gep-tup-like-1.rs b/src/test/run-pass/alignment-gep-tup-like-1.rs index ecc1a6a495c..72a79e188b3 100644 --- a/src/test/run-pass/alignment-gep-tup-like-1.rs +++ b/src/test/run-pass/alignment-gep-tup-like-1.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + struct pair<A,B> { a: A, b: B } diff --git a/src/test/run-pass/assert-eq-macro-success.rs b/src/test/run-pass/assert-eq-macro-success.rs index 3da245efd79..089e1b8c5c2 100644 --- a/src/test/run-pass/assert-eq-macro-success.rs +++ b/src/test/run-pass/assert-eq-macro-success.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] #[derive(PartialEq, Show)] struct Point { x : int } diff --git a/src/test/run-pass/associated-type-doubleendediterator-object.rs b/src/test/run-pass/associated-type-doubleendediterator-object.rs index 429027cbf30..7365e052171 100644 --- a/src/test/run-pass/associated-type-doubleendediterator-object.rs +++ b/src/test/run-pass/associated-type-doubleendediterator-object.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + fn pairwise_sub(mut t: Box<DoubleEndedIterator<Item=int>>) -> int { let mut result = 0; loop { diff --git a/src/test/run-pass/associated-types-ref-from-struct.rs b/src/test/run-pass/associated-types-ref-from-struct.rs new file mode 100644 index 00000000000..3c7cc7c4975 --- /dev/null +++ b/src/test/run-pass/associated-types-ref-from-struct.rs @@ -0,0 +1,62 @@ +// Copyright 2014 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// Test associated type references in structure fields. + +trait Test { + type V; + + fn test(&self, value: &Self::V) -> bool; +} + +/////////////////////////////////////////////////////////////////////////// + +struct TesterPair<T:Test> { + tester: T, + value: T::V, +} + +impl<T:Test> TesterPair<T> { + fn new(tester: T, value: T::V) -> TesterPair<T> { + TesterPair { tester: tester, value: value } + } + + fn test(&self) -> bool { + self.tester.test(&self.value) + } +} + +/////////////////////////////////////////////////////////////////////////// + +struct EqU32(u32); +impl Test for EqU32 { + type V = u32; + + fn test(&self, value: &u32) -> bool { + self.0 == *value + } +} + +struct EqI32(i32); +impl Test for EqI32 { + type V = i32; + + fn test(&self, value: &i32) -> bool { + self.0 == *value + } +} + +fn main() { + let tester = TesterPair::new(EqU32(22), 23); + tester.test(); + + let tester = TesterPair::new(EqI32(22), 23); + tester.test(); +} diff --git a/src/test/run-pass/bytes-macro-static.rs b/src/test/run-pass/associated-types-ref-in-struct-literal.rs index 2ce8c40c771..b51d44a0c24 100644 --- a/src/test/run-pass/bytes-macro-static.rs +++ b/src/test/run-pass/associated-types-ref-in-struct-literal.rs @@ -8,14 +8,22 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -static FOO: &'static [u8] = bytes!("hello, world"); +// Test associated type references in a struct literal. Issue #20535. -pub fn main() { - let b: &'static [u8] = match true { - true => bytes!("test"), - false => unreachable!() - }; +pub trait Foo { + type Bar; +} + +impl Foo for int { + type Bar = int; +} + +struct Thing<F: Foo> { + a: F, + b: F::Bar, +} - assert_eq!(b, "test".as_bytes()); - assert_eq!(FOO, "hello, world".as_bytes()); +fn main() { + let thing = Thing{a: 1i, b: 2i}; + assert_eq!(thing.a + 1, thing.b); } diff --git a/src/test/compile-fail/syntax-extension-bytes-non-ascii-char-literal.rs b/src/test/run-pass/associated-types-region-erasure-issue-20582.rs index d03696cbbbc..03ab8f7e431 100644 --- a/src/test/compile-fail/syntax-extension-bytes-non-ascii-char-literal.rs +++ b/src/test/run-pass/associated-types-region-erasure-issue-20582.rs @@ -1,4 +1,4 @@ -// Copyright 2013 The Rust Project Developers. See the COPYRIGHT +// 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. // @@ -8,7 +8,20 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +// Regression test for #20582. This test caused an ICE related to +// inconsistent region erasure in trans. + +struct Foo<'a> { + buf: &'a[u8] +} + +impl<'a> Iterator for Foo<'a> { + type Item = &'a[u8]; + + fn next(&mut self) -> Option<<Self as Iterator>::Item> { + Some(self.buf) + } +} + fn main() { - let vec = bytes!('λ'); //~ ERROR non-ascii char literal in bytes! - //~^ WARN `bytes!` is deprecated } diff --git a/src/test/run-pass/autoderef-method-on-trait.rs b/src/test/run-pass/autoderef-method-on-trait.rs index f13f598fda2..876fc123f48 100644 --- a/src/test/run-pass/autoderef-method-on-trait.rs +++ b/src/test/run-pass/autoderef-method-on-trait.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] trait double { fn double(self: Box<Self>) -> uint; diff --git a/src/test/run-pass/autoderef-method-priority.rs b/src/test/run-pass/autoderef-method-priority.rs index cc4dd13cf61..f5d5c81117e 100644 --- a/src/test/run-pass/autoderef-method-priority.rs +++ b/src/test/run-pass/autoderef-method-priority.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] trait double { fn double(self) -> uint; diff --git a/src/test/run-pass/autoderef-method-twice-but-not-thrice.rs b/src/test/run-pass/autoderef-method-twice-but-not-thrice.rs index 856ee686db3..282cf62190c 100644 --- a/src/test/run-pass/autoderef-method-twice-but-not-thrice.rs +++ b/src/test/run-pass/autoderef-method-twice-but-not-thrice.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] trait double { fn double(self: Box<Self>) -> uint; diff --git a/src/test/run-pass/autoderef-method-twice.rs b/src/test/run-pass/autoderef-method-twice.rs index 94da61483ea..eb44e3b52b9 100644 --- a/src/test/run-pass/autoderef-method-twice.rs +++ b/src/test/run-pass/autoderef-method-twice.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + trait double { fn double(self: Box<Self>) -> uint; } diff --git a/src/test/run-pass/autoderef-method.rs b/src/test/run-pass/autoderef-method.rs index 2e9751ce6ac..4bbb17c6dd6 100644 --- a/src/test/run-pass/autoderef-method.rs +++ b/src/test/run-pass/autoderef-method.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + trait double { fn double(self: Box<Self>) -> uint; } diff --git a/src/test/run-pass/autoref-intermediate-types-issue-3585.rs b/src/test/run-pass/autoref-intermediate-types-issue-3585.rs index 7f44bcdb50c..e026ac9dcba 100644 --- a/src/test/run-pass/autoref-intermediate-types-issue-3585.rs +++ b/src/test/run-pass/autoref-intermediate-types-issue-3585.rs @@ -9,6 +9,9 @@ // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + trait Foo { fn foo(&self) -> String; } diff --git a/src/test/run-pass/bitv-perf-test.rs b/src/test/run-pass/bitv-perf-test.rs index c5f69f249db..325f6dec76f 100644 --- a/src/test/run-pass/bitv-perf-test.rs +++ b/src/test/run-pass/bitv-perf-test.rs @@ -9,6 +9,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + extern crate collections; use std::collections::Bitv; diff --git a/src/test/run-pass/borrowck-borrow-from-expr-block.rs b/src/test/run-pass/borrowck-borrow-from-expr-block.rs index 038f9e5c9ab..9fcd87418be 100644 --- a/src/test/run-pass/borrowck-borrow-from-expr-block.rs +++ b/src/test/run-pass/borrowck-borrow-from-expr-block.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] fn borrow<F>(x: &int, f: F) where F: FnOnce(&int) { f(x) diff --git a/src/test/run-pass/borrowck-field-sensitivity.rs b/src/test/run-pass/borrowck-field-sensitivity.rs index 33be47e504b..89d80190042 100644 --- a/src/test/run-pass/borrowck-field-sensitivity.rs +++ b/src/test/run-pass/borrowck-field-sensitivity.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + struct A { a: int, b: Box<int> } struct B { a: Box<int>, b: Box<int> } diff --git a/src/test/run-pass/borrowck-macro-interaction-issue-6304.rs b/src/test/run-pass/borrowck-macro-interaction-issue-6304.rs index 28db3953a00..49483e40096 100644 --- a/src/test/run-pass/borrowck-macro-interaction-issue-6304.rs +++ b/src/test/run-pass/borrowck-macro-interaction-issue-6304.rs @@ -11,6 +11,7 @@ // Check that we do not ICE when compiling this // macro, which reuses the expression `$id` +#![feature(box_syntax)] struct Foo { a: int diff --git a/src/test/run-pass/borrowck-move-by-capture-ok.rs b/src/test/run-pass/borrowck-move-by-capture-ok.rs index a6b142bb126..773780ffb09 100644 --- a/src/test/run-pass/borrowck-move-by-capture-ok.rs +++ b/src/test/run-pass/borrowck-move-by-capture-ok.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] #![feature(unboxed_closures)] pub fn main() { diff --git a/src/test/run-pass/borrowck-mut-uniq.rs b/src/test/run-pass/borrowck-mut-uniq.rs index c586ff2c93a..4416c57e345 100644 --- a/src/test/run-pass/borrowck-mut-uniq.rs +++ b/src/test/run-pass/borrowck-mut-uniq.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + use std::mem::swap; #[derive(Show)] diff --git a/src/test/run-pass/borrowck-use-mut-borrow.rs b/src/test/run-pass/borrowck-use-mut-borrow.rs index cbfdd5961ff..7be12ff3cc9 100644 --- a/src/test/run-pass/borrowck-use-mut-borrow.rs +++ b/src/test/run-pass/borrowck-use-mut-borrow.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + struct A { a: int, b: Box<int> } fn field_copy_after_field_borrow() { diff --git a/src/test/compile-fail/syntax-extension-bytes-non-literal.rs b/src/test/run-pass/box-new.rs index 3a2e104818f..168218e1b1e 100644 --- a/src/test/compile-fail/syntax-extension-bytes-non-literal.rs +++ b/src/test/run-pass/box-new.rs @@ -1,4 +1,4 @@ -// Copyright 2013 The Rust Project Developers. See the COPYRIGHT +// 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. // @@ -9,6 +9,5 @@ // except according to those terms. fn main() { - let vec = bytes!(foo); //~ ERROR non-literal in bytes! - //~^ WARN `bytes!` is deprecated + let _a = Box::new(1); } diff --git a/src/test/run-pass/cancel-clean-via-immediate-rvalue-ref.rs b/src/test/run-pass/cancel-clean-via-immediate-rvalue-ref.rs index d326c20707d..631133cc7ff 100644 --- a/src/test/run-pass/cancel-clean-via-immediate-rvalue-ref.rs +++ b/src/test/run-pass/cancel-clean-via-immediate-rvalue-ref.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] fn foo(x: &mut Box<u8>) { *x = box 5; diff --git a/src/test/run-pass/capturing-logging.rs b/src/test/run-pass/capturing-logging.rs index e3e00410507..00673bee8b4 100644 --- a/src/test/run-pass/capturing-logging.rs +++ b/src/test/run-pass/capturing-logging.rs @@ -11,6 +11,9 @@ // ignore-android (FIXME #11419) // exec-env:RUST_LOG=info +#![allow(unknown_features)] +#![feature(box_syntax)] + #[macro_use] extern crate log; diff --git a/src/test/run-pass/cci_borrow.rs b/src/test/run-pass/cci_borrow.rs index 262c19174b1..ef5ee5aa3b4 100644 --- a/src/test/run-pass/cci_borrow.rs +++ b/src/test/run-pass/cci_borrow.rs @@ -10,6 +10,8 @@ // aux-build:cci_borrow_lib.rs +#![allow(unknown_features)] +#![feature(box_syntax)] extern crate cci_borrow_lib; use cci_borrow_lib::foo; diff --git a/src/test/run-pass/cfg_attr.rs b/src/test/run-pass/cfg_attr.rs index 15d3f4a04d5..7e508d91c87 100644 --- a/src/test/run-pass/cfg_attr.rs +++ b/src/test/run-pass/cfg_attr.rs @@ -14,37 +14,37 @@ use std::fmt::Show; struct NotShowable; -#[cfg_attr(set1, deriving(Show))] +#[cfg_attr(set1, derive(Show))] struct Set1; -#[cfg_attr(notset, deriving(Show))] +#[cfg_attr(notset, derive(Show))] struct Notset(NotShowable); -#[cfg_attr(not(notset), deriving(Show))] +#[cfg_attr(not(notset), derive(Show))] struct NotNotset; -#[cfg_attr(not(set1), deriving(Show))] +#[cfg_attr(not(set1), derive(Show))] struct NotSet1(NotShowable); -#[cfg_attr(all(set1, set2), deriving(Show))] +#[cfg_attr(all(set1, set2), derive(Show))] struct AllSet1Set2; -#[cfg_attr(all(set1, notset), deriving(Show))] +#[cfg_attr(all(set1, notset), derive(Show))] struct AllSet1Notset(NotShowable); -#[cfg_attr(any(set1, notset), deriving(Show))] +#[cfg_attr(any(set1, notset), derive(Show))] struct AnySet1Notset; -#[cfg_attr(any(notset, notset2), deriving(Show))] +#[cfg_attr(any(notset, notset2), derive(Show))] struct AnyNotsetNotset2(NotShowable); -#[cfg_attr(all(not(notset), any(set1, notset)), deriving(Show))] +#[cfg_attr(all(not(notset), any(set1, notset)), derive(Show))] struct Complex; -#[cfg_attr(any(notset, not(any(set1, notset))), deriving(Show))] +#[cfg_attr(any(notset, not(any(set1, notset))), derive(Show))] struct ComplexNot(NotShowable); -#[cfg_attr(any(target_endian = "little", target_endian = "big"), deriving(Show))] +#[cfg_attr(any(target_endian = "little", target_endian = "big"), derive(Show))] struct KeyValue; fn is_show<T: Show>() {} diff --git a/src/test/run-pass/class-cast-to-trait-cross-crate-2.rs b/src/test/run-pass/class-cast-to-trait-cross-crate-2.rs index a041bbfe8ad..e6cae99067e 100644 --- a/src/test/run-pass/class-cast-to-trait-cross-crate-2.rs +++ b/src/test/run-pass/class-cast-to-trait-cross-crate-2.rs @@ -9,6 +9,10 @@ // except according to those terms. // aux-build:cci_class_cast.rs + +#![allow(unknown_features)] +#![feature(box_syntax)] + extern crate cci_class_cast; use std::string::ToString; diff --git a/src/test/run-pass/class-separate-impl.rs b/src/test/run-pass/class-separate-impl.rs index 9c7913dc0b0..c2fa98a66df 100644 --- a/src/test/run-pass/class-separate-impl.rs +++ b/src/test/run-pass/class-separate-impl.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + use std::fmt; struct cat { diff --git a/src/test/run-pass/cleanup-arm-conditional.rs b/src/test/run-pass/cleanup-arm-conditional.rs index 65ad68ba702..0d155ae085c 100644 --- a/src/test/run-pass/cleanup-arm-conditional.rs +++ b/src/test/run-pass/cleanup-arm-conditional.rs @@ -21,6 +21,9 @@ // Test that cleanup scope for temporaries created in a match // arm is confined to the match arm itself. +#![allow(unknown_features)] +#![feature(box_syntax)] + use std::os; struct Test { x: int } diff --git a/src/test/run-pass/cleanup-rvalue-during-if-and-while.rs b/src/test/run-pass/cleanup-rvalue-during-if-and-while.rs index 89b00102081..83f93cb81a1 100644 --- a/src/test/run-pass/cleanup-rvalue-during-if-and-while.rs +++ b/src/test/run-pass/cleanup-rvalue-during-if-and-while.rs @@ -12,6 +12,8 @@ // This test verifies that temporaries created for `while`'s and `if` // conditions are dropped after the condition is evaluated. +#![allow(unknown_features)] +#![feature(box_syntax)] struct Temporary; diff --git a/src/test/run-pass/cleanup-rvalue-scopes.rs b/src/test/run-pass/cleanup-rvalue-scopes.rs index 59763e417a2..bbfe0e6a18d 100644 --- a/src/test/run-pass/cleanup-rvalue-scopes.rs +++ b/src/test/run-pass/cleanup-rvalue-scopes.rs @@ -12,6 +12,8 @@ // statement or end of block, as appropriate given the temporary // lifetime rules. +#![feature(box_syntax)] + use std::ops::Drop; static mut FLAGS: u64 = 0; diff --git a/src/test/run-pass/cleanup-rvalue-temp-during-incomplete-alloc.rs b/src/test/run-pass/cleanup-rvalue-temp-during-incomplete-alloc.rs index 526819940d0..04ab0d881a8 100644 --- a/src/test/run-pass/cleanup-rvalue-temp-during-incomplete-alloc.rs +++ b/src/test/run-pass/cleanup-rvalue-temp-during-incomplete-alloc.rs @@ -24,6 +24,9 @@ // It's unclear how likely such a bug is to recur, but it seems like a // scenario worth testing. +#![allow(unknown_features)] +#![feature(box_syntax)] + use std::thread::Thread; enum Conzabble { diff --git a/src/test/run-pass/clone-with-exterior.rs b/src/test/run-pass/clone-with-exterior.rs index cb495859708..8eeae7a28ac 100644 --- a/src/test/run-pass/clone-with-exterior.rs +++ b/src/test/run-pass/clone-with-exterior.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + use std::thread::Thread; struct Pair { diff --git a/src/test/run-pass/close-over-big-then-small-data.rs b/src/test/run-pass/close-over-big-then-small-data.rs index 375767c8f51..99fdc346026 100644 --- a/src/test/run-pass/close-over-big-then-small-data.rs +++ b/src/test/run-pass/close-over-big-then-small-data.rs @@ -12,6 +12,9 @@ // storing closure data (as we used to do), the u64 would // overwrite the u16. +#![allow(unknown_features)] +#![feature(box_syntax)] + struct Pair<A,B> { a: A, b: B } diff --git a/src/test/run-pass/coerce-expect-unsized.rs b/src/test/run-pass/coerce-expect-unsized.rs index 09f230792a9..3964d54f860 100644 --- a/src/test/run-pass/coerce-expect-unsized.rs +++ b/src/test/run-pass/coerce-expect-unsized.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + use std::fmt::Show; // Check that coercions apply at the pointer level and don't cause diff --git a/src/test/run-pass/coerce-match-calls.rs b/src/test/run-pass/coerce-match-calls.rs new file mode 100644 index 00000000000..0ff28b471a3 --- /dev/null +++ b/src/test/run-pass/coerce-match-calls.rs @@ -0,0 +1,23 @@ +// 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 coercions are propagated through match and if expressions. + +use std::boxed::Box; + +pub fn main() { + let _: Box<[int]> = if true { Box::new([1i, 2, 3]) } else { Box::new([1i]) }; + + let _: Box<[int]> = match true { true => Box::new([1i, 2, 3]), false => Box::new([1i]) }; + + // Check we don't get over-keen at propagating coercions in the case of casts. + let x = if true { 42 } else { 42u8 } as u16; + let x = match true { true => 42, false => 42u8 } as u16; +} diff --git a/src/test/run-pass/coerce-match.rs b/src/test/run-pass/coerce-match.rs index d67664bb1be..0992ee97d06 100644 --- a/src/test/run-pass/coerce-match.rs +++ b/src/test/run-pass/coerce-match.rs @@ -10,6 +10,9 @@ // Check that coercions are propagated through match and if expressions. +#![allow(unknown_features)] +#![feature(box_syntax)] + pub fn main() { let _: Box<[int]> = if true { box [1i, 2, 3] } else { box [1i] }; diff --git a/src/test/run-pass/const-bound.rs b/src/test/run-pass/const-bound.rs index e24bc1dbff9..3a6973fe61c 100644 --- a/src/test/run-pass/const-bound.rs +++ b/src/test/run-pass/const-bound.rs @@ -11,6 +11,8 @@ // Make sure const bounds work on things, and test that a few types // are const. +#![allow(unknown_features)] +#![feature(box_syntax)] fn foo<T: Sync>(x: T) -> T { x } diff --git a/src/test/run-pass/crate-method-reexport-grrrrrrr.rs b/src/test/run-pass/crate-method-reexport-grrrrrrr.rs index 0088a36eda9..1a3e87b55b6 100644 --- a/src/test/run-pass/crate-method-reexport-grrrrrrr.rs +++ b/src/test/run-pass/crate-method-reexport-grrrrrrr.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] // This is a regression test that the metadata for the // name_pool::methods impl in the other crate is reachable from this diff --git a/src/test/run-pass/deref-lval.rs b/src/test/run-pass/deref-lval.rs index d9b0940f80b..ead0683b870 100644 --- a/src/test/run-pass/deref-lval.rs +++ b/src/test/run-pass/deref-lval.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] use std::cell::Cell; diff --git a/src/test/run-pass/deref.rs b/src/test/run-pass/deref.rs index 117b133a113..b4ee0246d87 100644 --- a/src/test/run-pass/deref.rs +++ b/src/test/run-pass/deref.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] pub fn main() { let x: Box<int> = box 10; diff --git a/src/test/run-pass/deriving-default-box.rs b/src/test/run-pass/deriving-default-box.rs index aea6ebd2597..b00ceb6ed22 100644 --- a/src/test/run-pass/deriving-default-box.rs +++ b/src/test/run-pass/deriving-default-box.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + use std::default::Default; #[derive(Default)] diff --git a/src/test/run-pass/deriving-encodable-decodable-box.rs b/src/test/run-pass/deriving-encodable-decodable-box.rs index b7be14321fd..1a204fa3e20 100644 --- a/src/test/run-pass/deriving-encodable-decodable-box.rs +++ b/src/test/run-pass/deriving-encodable-decodable-box.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] #![feature(old_orphan_check)] extern crate serialize; diff --git a/src/test/run-pass/deriving-eq-ord-boxed-slice.rs b/src/test/run-pass/deriving-eq-ord-boxed-slice.rs index 6701a321339..3b89c943edb 100644 --- a/src/test/run-pass/deriving-eq-ord-boxed-slice.rs +++ b/src/test/run-pass/deriving-eq-ord-boxed-slice.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + #[derive(PartialEq, PartialOrd, Eq, Ord)] struct Foo(Box<[u8]>); diff --git a/src/test/run-pass/deriving-hash.rs b/src/test/run-pass/deriving-hash.rs index ddad703d7df..02ab7e5db5b 100644 --- a/src/test/run-pass/deriving-hash.rs +++ b/src/test/run-pass/deriving-hash.rs @@ -8,9 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. - -use std::hash; -use std::hash::Hash; +use std::hash::{Hash, SipHasher}; #[derive(Hash)] struct Person { @@ -19,6 +17,10 @@ struct Person { phone: uint, } +fn hash<T: Hash<SipHasher>>(t: &T) -> u64 { + std::hash::hash::<T, SipHasher>(t) +} + fn main() { let person1 = Person { id: 5, @@ -30,6 +32,6 @@ fn main() { name: "Bob".to_string(), phone: 555_666_7777 }; - assert!(hash::hash(&person1) == hash::hash(&person1)); - assert!(hash::hash(&person1) != hash::hash(&person2)); + assert!(hash(&person1) == hash(&person1)); + assert!(hash(&person1) != hash(&person2)); } diff --git a/src/test/run-pass/deriving-meta-multiple.rs b/src/test/run-pass/deriving-meta-multiple.rs index c435a1f344d..f45dce9da63 100644 --- a/src/test/run-pass/deriving-meta-multiple.rs +++ b/src/test/run-pass/deriving-meta-multiple.rs @@ -9,7 +9,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::hash::hash; +use std::hash::{Hash, SipHasher}; // testing multiple separate deriving attributes #[derive(PartialEq)] @@ -20,6 +20,8 @@ struct Foo { baz: int } +fn hash<T: Hash<SipHasher>>(_t: &T) {} + pub fn main() { let a = Foo {bar: 4, baz: -3}; diff --git a/src/test/run-pass/deriving-meta.rs b/src/test/run-pass/deriving-meta.rs index 54dc2b97b77..d6a2fad08ed 100644 --- a/src/test/run-pass/deriving-meta.rs +++ b/src/test/run-pass/deriving-meta.rs @@ -9,7 +9,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::hash::hash; +use std::hash::{Hash, SipHasher}; #[derive(PartialEq, Clone, Hash)] struct Foo { @@ -17,6 +17,8 @@ struct Foo { baz: int } +fn hash<T: Hash<SipHasher>>(_t: &T) {} + pub fn main() { let a = Foo {bar: 4, baz: -3}; diff --git a/src/test/run-pass/drop-on-empty-block-exit.rs b/src/test/run-pass/drop-on-empty-block-exit.rs index e3927bd5367..f875d0644a0 100644 --- a/src/test/run-pass/drop-on-empty-block-exit.rs +++ b/src/test/run-pass/drop-on-empty-block-exit.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] enum t { foo(Box<int>), } diff --git a/src/test/run-pass/drop-struct-as-object.rs b/src/test/run-pass/drop-struct-as-object.rs index 6d7715ed9a5..7a3b6df539f 100644 --- a/src/test/run-pass/drop-struct-as-object.rs +++ b/src/test/run-pass/drop-struct-as-object.rs @@ -11,6 +11,9 @@ // Test that destructor on a struct runs successfully after the struct // is boxed and converted to an object. +#![allow(unknown_features)] +#![feature(box_syntax)] + static mut value: uint = 0; struct Cat { diff --git a/src/test/run-pass/drop-trait-enum.rs b/src/test/run-pass/drop-trait-enum.rs index f1cc4fb1724..9bfb3572ab5 100644 --- a/src/test/run-pass/drop-trait-enum.rs +++ b/src/test/run-pass/drop-trait-enum.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + use std::thread::Thread; use std::sync::mpsc::{channel, Sender}; @@ -36,13 +39,13 @@ enum Foo { impl Drop for Foo { fn drop(&mut self) { match self { - &Foo::SimpleVariant(ref mut sender) => { + &mut Foo::SimpleVariant(ref mut sender) => { sender.send(Message::DestructorRan).unwrap(); } - &Foo::NestedVariant(_, _, ref mut sender) => { + &mut Foo::NestedVariant(_, _, ref mut sender) => { sender.send(Message::DestructorRan).unwrap(); } - &Foo::FailingVariant { .. } => { + &mut Foo::FailingVariant { .. } => { panic!("Failed"); } } @@ -66,7 +69,7 @@ pub fn main() { assert_eq!(receiver.recv().ok(), None); let (sender, receiver) = channel(); - let _t = Thread::spawn(move|| { + let _t = Thread::scoped(move|| { let v = Foo::FailingVariant { on_drop: SendOnDrop { sender: sender } }; }); assert_eq!(receiver.recv().unwrap(), Message::Dropped); @@ -74,7 +77,7 @@ pub fn main() { let (sender, receiver) = channel(); let _t = { - Thread::spawn(move|| { + Thread::scoped(move|| { let mut v = Foo::NestedVariant(box 42u, SendOnDrop { sender: sender.clone() }, sender.clone()); diff --git a/src/test/run-pass/dst-deref-mut.rs b/src/test/run-pass/dst-deref-mut.rs index 0a12df53de2..909f7f4897a 100644 --- a/src/test/run-pass/dst-deref-mut.rs +++ b/src/test/run-pass/dst-deref-mut.rs @@ -10,6 +10,9 @@ // Test that a custom deref with a fat pointer return type does not ICE +#![allow(unknown_features)] +#![feature(box_syntax)] + use std::ops::{Deref, DerefMut}; pub struct Arr { diff --git a/src/test/run-pass/dst-deref.rs b/src/test/run-pass/dst-deref.rs index 8ef8f1a868d..ad4456b5b59 100644 --- a/src/test/run-pass/dst-deref.rs +++ b/src/test/run-pass/dst-deref.rs @@ -10,6 +10,9 @@ // Test that a custom deref with a fat pointer return type does not ICE +#![allow(unknown_features)] +#![feature(box_syntax)] + use std::ops::Deref; pub struct Arr { diff --git a/src/test/run-pass/dst-struct.rs b/src/test/run-pass/dst-struct.rs index 9c0e5a6f5c8..b2092e745a1 100644 --- a/src/test/run-pass/dst-struct.rs +++ b/src/test/run-pass/dst-struct.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + struct Fat<T: ?Sized> { f1: int, f2: &'static str, diff --git a/src/test/run-pass/dst-trait.rs b/src/test/run-pass/dst-trait.rs index 0b50609fddf..627d197879d 100644 --- a/src/test/run-pass/dst-trait.rs +++ b/src/test/run-pass/dst-trait.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + struct Fat<T: ?Sized> { f1: int, f2: &'static str, diff --git a/src/test/run-pass/empty-allocation-non-null.rs b/src/test/run-pass/empty-allocation-non-null.rs index 56eb340ef59..269e0ee6ce4 100644 --- a/src/test/run-pass/empty-allocation-non-null.rs +++ b/src/test/run-pass/empty-allocation-non-null.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + pub fn main() { assert!(Some(box() ()).is_some()); diff --git a/src/test/run-pass/empty-allocation-rvalue-non-null.rs b/src/test/run-pass/empty-allocation-rvalue-non-null.rs index 96c5f81558e..e95d58c706b 100644 --- a/src/test/run-pass/empty-allocation-rvalue-non-null.rs +++ b/src/test/run-pass/empty-allocation-rvalue-non-null.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + pub fn main() { let x = *box() (); } diff --git a/src/test/run-pass/enum-nullable-simplifycfg-misopt.rs b/src/test/run-pass/enum-nullable-simplifycfg-misopt.rs index 7d856fd5656..81713657202 100644 --- a/src/test/run-pass/enum-nullable-simplifycfg-misopt.rs +++ b/src/test/run-pass/enum-nullable-simplifycfg-misopt.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] /*! * This is a regression test for a bug in LLVM, fixed in upstream r179587, diff --git a/src/test/run-pass/evec-slice.rs b/src/test/run-pass/evec-slice.rs index ab6576b9b42..734ac306653 100644 --- a/src/test/run-pass/evec-slice.rs +++ b/src/test/run-pass/evec-slice.rs @@ -22,7 +22,7 @@ pub fn main() { let c : &[int] = &[2,2,2,2,3]; let cc : &[int] = &[2,2,2,2,2,2]; - println!("{}", a); + println!("{:?}", a); assert!(a < b); assert!(a <= b); @@ -30,7 +30,7 @@ pub fn main() { assert!(b >= a); assert!(b > a); - println!("{}", b); + println!("{:?}", b); assert!(b < c); assert!(b <= c); @@ -44,7 +44,7 @@ pub fn main() { assert!(c >= a); assert!(c > a); - println!("{}", c); + println!("{:?}", c); assert!(a < cc); assert!(a <= cc); @@ -52,5 +52,5 @@ pub fn main() { assert!(cc >= a); assert!(cc > a); - println!("{}", cc); + println!("{:?}", cc); } diff --git a/src/test/run-pass/explicit-self-generic.rs b/src/test/run-pass/explicit-self-generic.rs index 87f1adba8dd..a2aaaa235e4 100644 --- a/src/test/run-pass/explicit-self-generic.rs +++ b/src/test/run-pass/explicit-self-generic.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + struct LM { resize_at: uint, size: uint } impl Copy for LM {} diff --git a/src/test/run-pass/explicit-self-objects-uniq.rs b/src/test/run-pass/explicit-self-objects-uniq.rs index e566f218aa8..501ba01b4ce 100644 --- a/src/test/run-pass/explicit-self-objects-uniq.rs +++ b/src/test/run-pass/explicit-self-objects-uniq.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] trait Foo { fn f(self: Box<Self>); diff --git a/src/test/run-pass/explicit-self.rs b/src/test/run-pass/explicit-self.rs index 8a67e40844a..e5d8ec3f8ad 100644 --- a/src/test/run-pass/explicit-self.rs +++ b/src/test/run-pass/explicit-self.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + static tau: f64 = 2.0*3.14159265358979323; struct Point {x: f64, y: f64} diff --git a/src/test/run-pass/expr-block-generic-unique1.rs b/src/test/run-pass/expr-block-generic-unique1.rs index 5c1039fe433..1654c87c6a4 100644 --- a/src/test/run-pass/expr-block-generic-unique1.rs +++ b/src/test/run-pass/expr-block-generic-unique1.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + fn test_generic<T, F>(expected: Box<T>, eq: F) where T: Clone, F: FnOnce(Box<T>, Box<T>) -> bool { let actual: Box<T> = { expected.clone() }; assert!(eq(expected, actual)); diff --git a/src/test/run-pass/expr-block-generic-unique2.rs b/src/test/run-pass/expr-block-generic-unique2.rs index 3d736cca6d5..e41ce37cc3a 100644 --- a/src/test/run-pass/expr-block-generic-unique2.rs +++ b/src/test/run-pass/expr-block-generic-unique2.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + fn test_generic<T, F>(expected: T, eq: F) where T: Clone, F: FnOnce(T, T) -> bool { let actual: T = { expected.clone() }; assert!(eq(expected, actual)); diff --git a/src/test/run-pass/expr-block-unique.rs b/src/test/run-pass/expr-block-unique.rs index 0dff989002f..d934ce677d1 100644 --- a/src/test/run-pass/expr-block-unique.rs +++ b/src/test/run-pass/expr-block-unique.rs @@ -9,6 +9,7 @@ // except according to those terms. - +#![allow(unknown_features)] +#![feature(box_syntax)] pub fn main() { let x = { box 100i }; assert!((*x == 100)); } diff --git a/src/test/run-pass/expr-if-unique.rs b/src/test/run-pass/expr-if-unique.rs index b1fdf51d9b1..5294d05401c 100644 --- a/src/test/run-pass/expr-if-unique.rs +++ b/src/test/run-pass/expr-if-unique.rs @@ -9,7 +9,8 @@ // except according to those terms. - +#![allow(unknown_features)] +#![feature(box_syntax)] // Tests for if as expressions returning boxed types diff --git a/src/test/run-pass/expr-match-generic-unique1.rs b/src/test/run-pass/expr-match-generic-unique1.rs index 5fc9a502ca8..9de1379f480 100644 --- a/src/test/run-pass/expr-match-generic-unique1.rs +++ b/src/test/run-pass/expr-match-generic-unique1.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + fn test_generic<T: Clone, F>(expected: Box<T>, eq: F) where F: FnOnce(Box<T>, Box<T>) -> bool { let actual: Box<T> = match true { true => { expected.clone() }, diff --git a/src/test/run-pass/expr-match-generic-unique2.rs b/src/test/run-pass/expr-match-generic-unique2.rs index e608f9c46c7..489cd8437d2 100644 --- a/src/test/run-pass/expr-match-generic-unique2.rs +++ b/src/test/run-pass/expr-match-generic-unique2.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + fn test_generic<T: Clone, F>(expected: T, eq: F) where F: FnOnce(T, T) -> bool { let actual: T = match true { true => expected.clone(), diff --git a/src/test/run-pass/expr-match-unique.rs b/src/test/run-pass/expr-match-unique.rs index 83f2ada02b0..7958f4927da 100644 --- a/src/test/run-pass/expr-match-unique.rs +++ b/src/test/run-pass/expr-match-unique.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] // Tests for match as expressions resulting in boxed types fn test_box() { diff --git a/src/test/run-pass/ext-expand-inner-exprs.rs b/src/test/run-pass/ext-expand-inner-exprs.rs index 1c96cbd9314..d204f808e44 100644 --- a/src/test/run-pass/ext-expand-inner-exprs.rs +++ b/src/test/run-pass/ext-expand-inner-exprs.rs @@ -8,8 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -static FOO : &'static [u8] = bytes!(concat!(concat!("hel", "lo"), "world")); +static FOO : &'static str = concat!(concat!("hel", "lo"), "world"); pub fn main() { - assert_eq!(FOO, "helloworld".as_bytes()); + assert_eq!(FOO, "helloworld"); } diff --git a/src/test/run-pass/extern-stress.rs b/src/test/run-pass/extern-stress.rs index bb9e9407382..c3e04177cce 100644 --- a/src/test/run-pass/extern-stress.rs +++ b/src/test/run-pass/extern-stress.rs @@ -42,7 +42,7 @@ fn count(n: libc::uintptr_t) -> libc::uintptr_t { pub fn main() { range(0u, 100).map(|_| { - Thread::spawn(move|| { + Thread::scoped(move|| { assert_eq!(count(5), 16); }) }).collect::<Vec<_>>(); diff --git a/src/test/run-pass/extern-yield.rs b/src/test/run-pass/extern-yield.rs index 46829e9ba6e..f5e91b9de67 100644 --- a/src/test/run-pass/extern-yield.rs +++ b/src/test/run-pass/extern-yield.rs @@ -39,7 +39,7 @@ fn count(n: libc::uintptr_t) -> libc::uintptr_t { pub fn main() { range(0, 10u).map(|i| { - Thread::spawn(move|| { + Thread::scoped(move|| { let result = count(5); println!("result = {}", result); assert_eq!(result, 16); diff --git a/src/test/run-pass/fsu-moves-and-copies.rs b/src/test/run-pass/fsu-moves-and-copies.rs index a08cd33362f..0f8d7c24360 100644 --- a/src/test/run-pass/fsu-moves-and-copies.rs +++ b/src/test/run-pass/fsu-moves-and-copies.rs @@ -11,6 +11,9 @@ // Issue 4691: Ensure that functional-struct-updates operates // correctly and moves rather than copy when appropriate. +#![allow(unknown_features)] +#![feature(box_syntax)] + use std::marker::NoCopy as NP; struct ncint { np: NP, v: int } diff --git a/src/test/run-pass/func-arg-incomplete-pattern.rs b/src/test/run-pass/func-arg-incomplete-pattern.rs index 6d06c12c450..b23d8db3cfd 100644 --- a/src/test/run-pass/func-arg-incomplete-pattern.rs +++ b/src/test/run-pass/func-arg-incomplete-pattern.rs @@ -11,6 +11,8 @@ // Test that we do not leak when the arg pattern must drop part of the // argument (in this case, the `y` field). +#![allow(unknown_features)] +#![feature(box_syntax)] struct Foo { x: Box<uint>, diff --git a/src/test/run-pass/func-arg-ref-pattern.rs b/src/test/run-pass/func-arg-ref-pattern.rs index 5eeace65054..9e94bca96f7 100644 --- a/src/test/run-pass/func-arg-ref-pattern.rs +++ b/src/test/run-pass/func-arg-ref-pattern.rs @@ -14,6 +14,8 @@ // boxes. Make sure that we don't free the box as we match the // pattern. +#![allow(unknown_features)] +#![feature(box_syntax)] fn getaddr(box ref x: Box<uint>) -> *const uint { let addr: *const uint = &*x; diff --git a/src/test/run-pass/generic-alias-unique.rs b/src/test/run-pass/generic-alias-unique.rs index 8b5dfb6cf75..34b7f15e4c6 100644 --- a/src/test/run-pass/generic-alias-unique.rs +++ b/src/test/run-pass/generic-alias-unique.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + fn id<T:Send>(t: T) -> T { return t; } pub fn main() { diff --git a/src/test/run-pass/generic-exterior-unique.rs b/src/test/run-pass/generic-exterior-unique.rs index 0746c994c2a..a2f7bdfd817 100644 --- a/src/test/run-pass/generic-exterior-unique.rs +++ b/src/test/run-pass/generic-exterior-unique.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] struct Recbox<T> {x: Box<T>} diff --git a/src/test/run-pass/generic-fn-unique.rs b/src/test/run-pass/generic-fn-unique.rs index e1a8ad7c20a..be83cb04f2c 100644 --- a/src/test/run-pass/generic-fn-unique.rs +++ b/src/test/run-pass/generic-fn-unique.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + fn f<T>(x: Box<T>) -> Box<T> { return x; } pub fn main() { let x = f(box 3i); println!("{}", *x); } diff --git a/src/test/run-pass/generic-object.rs b/src/test/run-pass/generic-object.rs index d0a5af8e2ce..986b35cbecf 100644 --- a/src/test/run-pass/generic-object.rs +++ b/src/test/run-pass/generic-object.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] trait Foo<T> { fn get(&self) -> T; diff --git a/src/test/run-pass/generic-recursive-tag.rs b/src/test/run-pass/generic-recursive-tag.rs index b738b527122..845375d9b84 100644 --- a/src/test/run-pass/generic-recursive-tag.rs +++ b/src/test/run-pass/generic-recursive-tag.rs @@ -10,6 +10,8 @@ // ignore-pretty FIXME(#14193) +#![allow(unknown_features)] +#![feature(box_syntax)] enum list<T> { cons(Box<T>, Box<list<T>>), nil, } diff --git a/src/test/run-pass/generic-tag.rs b/src/test/run-pass/generic-tag.rs index 250c5bb66af..b0d4944ba54 100644 --- a/src/test/run-pass/generic-tag.rs +++ b/src/test/run-pass/generic-tag.rs @@ -10,6 +10,8 @@ #![allow(dead_assignment)] #![allow(unused_variable)] +#![allow(unknown_features)] +#![feature(box_syntax)] enum option<T> { some(Box<T>), none, } diff --git a/src/test/run-pass/generic-unique.rs b/src/test/run-pass/generic-unique.rs index 4821b9354bf..1d39c47417c 100644 --- a/src/test/run-pass/generic-unique.rs +++ b/src/test/run-pass/generic-unique.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] struct Triple<T> { x: T, y: T, z: T } diff --git a/src/test/run-pass/hashmap-memory.rs b/src/test/run-pass/hashmap-memory.rs index f83698edc90..0e82ad43782 100644 --- a/src/test/run-pass/hashmap-memory.rs +++ b/src/test/run-pass/hashmap-memory.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] #![feature(unboxed_closures)] /** diff --git a/src/test/run-pass/hrtb-precedence-of-plus.rs b/src/test/run-pass/hrtb-precedence-of-plus.rs index 9a43b5b711e..1d1e744ef08 100644 --- a/src/test/run-pass/hrtb-precedence-of-plus.rs +++ b/src/test/run-pass/hrtb-precedence-of-plus.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] #![feature(unboxed_closures)] // Test that `Fn(int) -> int + 'static` parses as `(Fn(int) -> int) + diff --git a/src/test/run-pass/huge-largest-array.rs b/src/test/run-pass/huge-largest-array.rs index e24731546ed..e1b0c115365 100644 --- a/src/test/run-pass/huge-largest-array.rs +++ b/src/test/run-pass/huge-largest-array.rs @@ -10,12 +10,12 @@ use std::mem::size_of; -#[cfg(target_word_size = "32")] +#[cfg(any(all(stage0, target_word_size = "32"), all(not(stage0), target_pointer_width = "32")))] pub fn main() { assert_eq!(size_of::<[u8; (1 << 31) - 1]>(), (1 << 31) - 1); } -#[cfg(target_word_size = "64")] +#[cfg(any(all(stage0, target_word_size = "64"), all(not(stage0), target_pointer_width = "64")))] pub fn main() { assert_eq!(size_of::<[u8; (1 << 47) - 1]>(), (1 << 47) - 1); } diff --git a/src/test/run-pass/ifmt.rs b/src/test/run-pass/ifmt.rs index 8b0d7c18fb1..dbc23a63bba 100644 --- a/src/test/run-pass/ifmt.rs +++ b/src/test/run-pass/ifmt.rs @@ -13,6 +13,8 @@ #![deny(warnings)] #![allow(unused_must_use)] +#![allow(unknown_features)] +#![feature(box_syntax)] use std::fmt; @@ -183,7 +185,7 @@ fn test_write() { // can do with them just yet (to test the output) fn test_print() { print!("hi"); - print!("{}", vec!(0u8)); + print!("{:?}", vec!(0u8)); println!("hello"); println!("this is a {}", "test"); println!("{foo}", foo="bar"); diff --git a/src/test/run-pass/init-res-into-things.rs b/src/test/run-pass/init-res-into-things.rs index ee82a99a808..eeae3f35cfc 100644 --- a/src/test/run-pass/init-res-into-things.rs +++ b/src/test/run-pass/init-res-into-things.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] #![feature(unsafe_destructor)] use std::cell::Cell; diff --git a/src/test/run-pass/intrinsic-atomics.rs b/src/test/run-pass/intrinsic-atomics.rs index 3b81943000b..0644fbbc99f 100644 --- a/src/test/run-pass/intrinsic-atomics.rs +++ b/src/test/run-pass/intrinsic-atomics.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] #![feature(intrinsics)] mod rusti { diff --git a/src/test/run-pass/intrinsic-move-val.rs b/src/test/run-pass/intrinsic-move-val.rs index f1bbf353f71..fb04f67e380 100644 --- a/src/test/run-pass/intrinsic-move-val.rs +++ b/src/test/run-pass/intrinsic-move-val.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] #![feature(intrinsics)] use std::mem::transmute; diff --git a/src/test/run-pass/issue-10682.rs b/src/test/run-pass/issue-10682.rs index fd0ad1ef47e..883e52b61d0 100644 --- a/src/test/run-pass/issue-10682.rs +++ b/src/test/run-pass/issue-10682.rs @@ -11,6 +11,9 @@ // Regression test for issue #10682 // Nested `proc` usage can't use outer owned data +#![allow(unknown_features)] +#![feature(box_syntax)] + fn work(_: Box<int>) {} fn foo<F:FnOnce()>(_: F) {} diff --git a/src/test/run-pass/issue-10767.rs b/src/test/run-pass/issue-10767.rs index d2895024187..c717053cffc 100644 --- a/src/test/run-pass/issue-10767.rs +++ b/src/test/run-pass/issue-10767.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] pub fn main() { fn f() { diff --git a/src/test/run-pass/issue-10802.rs b/src/test/run-pass/issue-10802.rs index ab080834ac9..de2b4c51e52 100644 --- a/src/test/run-pass/issue-10802.rs +++ b/src/test/run-pass/issue-10802.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + struct DroppableStruct; enum DroppableEnum { DroppableVariant1, DroppableVariant2 diff --git a/src/test/run-pass/issue-11205.rs b/src/test/run-pass/issue-11205.rs index 549a70f19e3..194208620a8 100644 --- a/src/test/run-pass/issue-11205.rs +++ b/src/test/run-pass/issue-11205.rs @@ -9,6 +9,8 @@ // except according to those terms. #![allow(dead_code)] +#![allow(unknown_features)] +#![feature(box_syntax)] trait Foo {} impl Foo for int {} diff --git a/src/test/run-pass/issue-11552.rs b/src/test/run-pass/issue-11552.rs index 92862961aca..f47f1e06011 100644 --- a/src/test/run-pass/issue-11552.rs +++ b/src/test/run-pass/issue-11552.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] #[derive(Clone)] enum Noun diff --git a/src/test/run-pass/issue-11677.rs b/src/test/run-pass/issue-11677.rs index 14c1b1b06ea..6fa45058694 100644 --- a/src/test/run-pass/issue-11677.rs +++ b/src/test/run-pass/issue-11677.rs @@ -9,6 +9,8 @@ // except according to those terms. #![allow(dead_code)] +#![allow(unknown_features)] +#![feature(box_syntax)] // this code used to cause an ICE diff --git a/src/test/run-pass/issue-12744.rs b/src/test/run-pass/issue-12744.rs index a91dbd2b716..ec929a9c792 100644 --- a/src/test/run-pass/issue-12744.rs +++ b/src/test/run-pass/issue-12744.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + fn main() { fn test() -> Box<std::any::Any + 'static> { box 1i } println!("{:?}", test()) diff --git a/src/test/run-pass/issue-13323.rs b/src/test/run-pass/issue-13323.rs index b7cd8a90112..75d3c6f334d 100644 --- a/src/test/run-pass/issue-13323.rs +++ b/src/test/run-pass/issue-13323.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + struct StrWrap { s: String } diff --git a/src/test/run-pass/issue-13808.rs b/src/test/run-pass/issue-13808.rs index c0652b946db..3c5ece87b73 100644 --- a/src/test/run-pass/issue-13808.rs +++ b/src/test/run-pass/issue-13808.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + struct Foo<'a> { listener: Box<FnMut() + 'a>, } diff --git a/src/test/run-pass/issue-14399.rs b/src/test/run-pass/issue-14399.rs index bb0fe6a87ab..7e533c2cf86 100644 --- a/src/test/run-pass/issue-14399.rs +++ b/src/test/run-pass/issue-14399.rs @@ -13,6 +13,9 @@ // value was coerced to a trait object. (v.clone() returns Box<B1> // which is coerced to Box<A>). +#![allow(unknown_features)] +#![feature(box_syntax)] + #[derive(Clone)] struct B1; diff --git a/src/test/run-pass/issue-14589.rs b/src/test/run-pass/issue-14589.rs index afc2fc6cf64..d9763baa826 100644 --- a/src/test/run-pass/issue-14589.rs +++ b/src/test/run-pass/issue-14589.rs @@ -11,6 +11,9 @@ // All 3 expressions should work in that the argument gets // coerced to a trait object +#![allow(unknown_features)] +#![feature(box_syntax)] + fn main() { send::<Box<Foo>>(box Output(0)); Test::<Box<Foo>>::foo(box Output(0)); diff --git a/src/test/run-pass/issue-14919.rs b/src/test/run-pass/issue-14919.rs index 21bda93ecec..4d05b98147b 100644 --- a/src/test/run-pass/issue-14919.rs +++ b/src/test/run-pass/issue-14919.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + trait Matcher { fn next_match(&mut self) -> Option<(uint, uint)>; } diff --git a/src/test/run-pass/issue-15571.rs b/src/test/run-pass/issue-15571.rs index 03d18cf8c98..6b273b5786a 100644 --- a/src/test/run-pass/issue-15571.rs +++ b/src/test/run-pass/issue-15571.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + fn match_on_local() { let mut foo = Some(box 5i); match foo { diff --git a/src/test/run-pass/issue-15730.rs b/src/test/run-pass/issue-15730.rs index 4e1aa454a88..72daa0cba41 100644 --- a/src/test/run-pass/issue-15730.rs +++ b/src/test/run-pass/issue-15730.rs @@ -8,8 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![feature(slicing_syntax)] - fn main() { let mut array = [1, 2, 3]; let pie_slice = &array[1..2]; diff --git a/src/test/run-pass/issue-15763.rs b/src/test/run-pass/issue-15763.rs index 48fdcb09080..283ea25b6fe 100644 --- a/src/test/run-pass/issue-15763.rs +++ b/src/test/run-pass/issue-15763.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] #[derive(PartialEq, Show)] struct Bar { diff --git a/src/test/run-pass/issue-16668.rs b/src/test/run-pass/issue-16668.rs index 1febf337429..75b1e11ddc1 100644 --- a/src/test/run-pass/issue-16668.rs +++ b/src/test/run-pass/issue-16668.rs @@ -10,6 +10,8 @@ // ignore-pretty +#![allow(unknown_features)] +#![feature(box_syntax)] #![feature(unboxed_closures)] struct Parser<'a, I, O> { diff --git a/src/test/run-pass/issue-16739.rs b/src/test/run-pass/issue-16739.rs index 552ce565f6b..cb6f068cf45 100644 --- a/src/test/run-pass/issue-16739.rs +++ b/src/test/run-pass/issue-16739.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] #![feature(unboxed_closures)] // Test that unboxing shim for calling rust-call ABI methods through a diff --git a/src/test/run-pass/issue-16774.rs b/src/test/run-pass/issue-16774.rs index 6ef4f868d21..175e2188811 100644 --- a/src/test/run-pass/issue-16774.rs +++ b/src/test/run-pass/issue-16774.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] #![feature(unboxed_closures)] use std::ops::{Deref, DerefMut}; @@ -36,7 +38,7 @@ impl Deref for X { impl DerefMut for X { fn deref_mut(&mut self) -> &mut int { - let &X(box ref mut x) = self; + let &mut X(box ref mut x) = self; x } } diff --git a/src/test/run-pass/issue-17322.rs b/src/test/run-pass/issue-17322.rs index c5784154a2e..b50bf442b5d 100644 --- a/src/test/run-pass/issue-17322.rs +++ b/src/test/run-pass/issue-17322.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + use std::io; fn f(wr: &mut Writer) { diff --git a/src/test/run-pass/issue-17503.rs b/src/test/run-pass/issue-17503.rs index 8acda175006..65bf088786e 100644 --- a/src/test/run-pass/issue-17503.rs +++ b/src/test/run-pass/issue-17503.rs @@ -8,14 +8,12 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![feature(slicing_syntax)] - fn main() { let s: &[int] = &[0, 1, 2, 3, 4]; let ss: &&[int] = &s; let sss: &&&[int] = &ss; - println!("{}", &s[0..3]); - println!("{}", &ss[3..]); - println!("{}", &sss[2..4]); + println!("{:?}", &s[0..3]); + println!("{:?}", &ss[3..]); + println!("{:?}", &sss[2..4]); } diff --git a/src/test/run-pass/issue-17734.rs b/src/test/run-pass/issue-17734.rs index f68ab01ea9b..e58fbe0b4c2 100644 --- a/src/test/run-pass/issue-17734.rs +++ b/src/test/run-pass/issue-17734.rs @@ -10,6 +10,9 @@ // Test that generating drop glue for Box<str> doesn't ICE +#![allow(unknown_features)] +#![feature(box_syntax)] + fn f(s: Box<str>) -> Box<str> { s } diff --git a/src/test/run-pass/issue-18425.rs b/src/test/run-pass/issue-18425.rs index f61530c7418..6d223923ac1 100644 --- a/src/test/run-pass/issue-18425.rs +++ b/src/test/run-pass/issue-18425.rs @@ -11,6 +11,9 @@ // Check that trans doesn't ICE when translating an array repeat // expression with a count of 1 and a non-Copy element type. +#![allow(unknown_features)] +#![feature(box_syntax)] + fn main() { let _ = [box 1u; 1]; } diff --git a/src/test/run-pass/issue-20644.rs b/src/test/run-pass/issue-20644.rs index 4a57ed56594..f74b09a3d24 100644 --- a/src/test/run-pass/issue-20644.rs +++ b/src/test/run-pass/issue-20644.rs @@ -11,7 +11,6 @@ // A reduced version of the rustbook ice. The problem this encountered // had to do with trans ignoring binders. -#![feature(slicing_syntax)] #![feature(associated_types)] #![feature(macro_rules)] diff --git a/src/test/run-pass/issue-2288.rs b/src/test/run-pass/issue-2288.rs index 1f371f0a1c2..7baead6929b 100644 --- a/src/test/run-pass/issue-2288.rs +++ b/src/test/run-pass/issue-2288.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] trait clam<A> { fn chowder(&self, y: A); diff --git a/src/test/run-pass/issue-2633-2.rs b/src/test/run-pass/issue-2633-2.rs index e2a03c696f2..c146f8a7a9a 100644 --- a/src/test/run-pass/issue-2633-2.rs +++ b/src/test/run-pass/issue-2633-2.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + fn a_val(x: Box<int>, y: Box<int>) -> int { *x + *y diff --git a/src/test/run-pass/issue-2708.rs b/src/test/run-pass/issue-2708.rs index 3ac4b874f3a..1f072af0f5a 100644 --- a/src/test/run-pass/issue-2708.rs +++ b/src/test/run-pass/issue-2708.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] struct Font { fontbuf: uint, diff --git a/src/test/run-pass/issue-2718.rs b/src/test/run-pass/issue-2718.rs index 3ca3e0592e7..6f5f46edc01 100644 --- a/src/test/run-pass/issue-2718.rs +++ b/src/test/run-pass/issue-2718.rs @@ -11,6 +11,8 @@ // // ignore-lexer-test FIXME #15883 +#![allow(unknown_features)] +#![feature(box_syntax)] #![feature(unsafe_destructor)] pub type Task = int; diff --git a/src/test/run-pass/issue-2734.rs b/src/test/run-pass/issue-2734.rs index 9eec2d048d4..3e4cffe5dfa 100644 --- a/src/test/run-pass/issue-2734.rs +++ b/src/test/run-pass/issue-2734.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] trait hax { } impl<A> hax for A { } diff --git a/src/test/run-pass/issue-2735.rs b/src/test/run-pass/issue-2735.rs index 74b64bb87cf..cb376d0e439 100644 --- a/src/test/run-pass/issue-2735.rs +++ b/src/test/run-pass/issue-2735.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] trait hax { } impl<A> hax for A { } diff --git a/src/test/run-pass/issue-2935.rs b/src/test/run-pass/issue-2935.rs index cdc41e892f9..295fd538de6 100644 --- a/src/test/run-pass/issue-2935.rs +++ b/src/test/run-pass/issue-2935.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] //type t = { a: int }; // type t = { a: bool }; diff --git a/src/test/run-pass/issue-3012-2.rs b/src/test/run-pass/issue-3012-2.rs index aa2ce824822..de2d4374d78 100644 --- a/src/test/run-pass/issue-3012-2.rs +++ b/src/test/run-pass/issue-3012-2.rs @@ -10,6 +10,8 @@ // aux-build:issue-3012-1.rs +#![allow(unknown_features)] +#![feature(box_syntax)] extern crate socketlib; extern crate libc; diff --git a/src/test/run-pass/issue-3026.rs b/src/test/run-pass/issue-3026.rs index b30c0a117a8..cd71bfce274 100644 --- a/src/test/run-pass/issue-3026.rs +++ b/src/test/run-pass/issue-3026.rs @@ -9,6 +9,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + extern crate collections; use std::collections::HashMap; diff --git a/src/test/run-pass/issue-3052.rs b/src/test/run-pass/issue-3052.rs index 72cf2219bb6..c08bdf54408 100644 --- a/src/test/run-pass/issue-3052.rs +++ b/src/test/run-pass/issue-3052.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] type Connection = Box<FnMut(Vec<u8>) + 'static>; diff --git a/src/test/run-pass/issue-3121.rs b/src/test/run-pass/issue-3121.rs index 9e9d611f1a3..c789921f622 100644 --- a/src/test/run-pass/issue-3121.rs +++ b/src/test/run-pass/issue-3121.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] enum side { mayo, catsup, vinegar } enum order { hamburger, fries(side), shake } diff --git a/src/test/run-pass/issue-3290.rs b/src/test/run-pass/issue-3290.rs index 139d984b507..a72b272abaa 100644 --- a/src/test/run-pass/issue-3290.rs +++ b/src/test/run-pass/issue-3290.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + pub fn main() { let mut x = box 3i; x = x; diff --git a/src/test/run-pass/issue-3424.rs b/src/test/run-pass/issue-3424.rs index 528870d0334..6647fbe2238 100644 --- a/src/test/run-pass/issue-3424.rs +++ b/src/test/run-pass/issue-3424.rs @@ -11,6 +11,8 @@ // rustc --test ignores2.rs && ./ignores2 +#![allow(unknown_features)] +#![feature(box_syntax)] #![feature(unboxed_closures)] use std::path::{Path}; diff --git a/src/test/run-pass/issue-3447.rs b/src/test/run-pass/issue-3447.rs index 4ebf981e4ee..12c2155dd57 100644 --- a/src/test/run-pass/issue-3447.rs +++ b/src/test/run-pass/issue-3447.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] use std::cell::RefCell; diff --git a/src/test/run-pass/issue-3609.rs b/src/test/run-pass/issue-3609.rs index c3cfaf22dee..56eb7486c92 100644 --- a/src/test/run-pass/issue-3609.rs +++ b/src/test/run-pass/issue-3609.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + use std::thread::Thread; use std::sync::mpsc::Sender; use std::thunk::Invoke; diff --git a/src/test/run-pass/issue-3794.rs b/src/test/run-pass/issue-3794.rs index 926b53cf92c..91c938981c1 100644 --- a/src/test/run-pass/issue-3794.rs +++ b/src/test/run-pass/issue-3794.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + trait T { fn print(&self); } diff --git a/src/test/run-pass/issue-3878.rs b/src/test/run-pass/issue-3878.rs index 063b2d70301..5434e44c173 100644 --- a/src/test/run-pass/issue-3878.rs +++ b/src/test/run-pass/issue-3878.rs @@ -9,6 +9,8 @@ // except according to those terms. #![allow(path_statement)] +#![allow(unknown_features)] +#![feature(box_syntax)] pub fn main() { let y = box 1i; diff --git a/src/test/run-pass/issue-3888-2.rs b/src/test/run-pass/issue-3888-2.rs index 5ed9729c142..bf3d0b786af 100644 --- a/src/test/run-pass/issue-3888-2.rs +++ b/src/test/run-pass/issue-3888-2.rs @@ -8,8 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![feature(slicing_syntax)] - fn vec_peek<'r, T>(v: &'r [T]) -> &'r [T] { &v[1..5] } diff --git a/src/test/run-pass/issue-4464.rs b/src/test/run-pass/issue-4464.rs index 2581069d29b..33a5c7a167f 100644 --- a/src/test/run-pass/issue-4464.rs +++ b/src/test/run-pass/issue-4464.rs @@ -8,8 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![feature(slicing_syntax)] - fn broken(v: &[u8], i: uint, j: uint) -> &[u8] { &v[i..j] } pub fn main() {} diff --git a/src/test/run-pass/issue-4735.rs b/src/test/run-pass/issue-4735.rs index 7730d75a3a9..bf422bd0405 100644 --- a/src/test/run-pass/issue-4735.rs +++ b/src/test/run-pass/issue-4735.rs @@ -10,6 +10,9 @@ // ignore-fast doesn't like extern crate +#![allow(unknown_features)] +#![feature(box_syntax)] + extern crate libc; use std::mem::transmute; diff --git a/src/test/run-pass/issue-4759.rs b/src/test/run-pass/issue-4759.rs index 4b5c3566965..2245e80971a 100644 --- a/src/test/run-pass/issue-4759.rs +++ b/src/test/run-pass/issue-4759.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] struct T { a: Box<int> } diff --git a/src/test/run-pass/issue-5192.rs b/src/test/run-pass/issue-5192.rs index 3b1a8c4a190..bb79cd4d046 100644 --- a/src/test/run-pass/issue-5192.rs +++ b/src/test/run-pass/issue-5192.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] pub trait EventLoop { } diff --git a/src/test/run-pass/issue-5666.rs b/src/test/run-pass/issue-5666.rs index 222e1d54a5d..e53f4c86923 100644 --- a/src/test/run-pass/issue-5666.rs +++ b/src/test/run-pass/issue-5666.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] struct Dog { name : String diff --git a/src/test/run-pass/issue-5688.rs b/src/test/run-pass/issue-5688.rs index 7c8940aafbf..cfe9c8f994c 100644 --- a/src/test/run-pass/issue-5688.rs +++ b/src/test/run-pass/issue-5688.rs @@ -25,6 +25,6 @@ static V: &'static [X] = &[X { vec: &[1, 2, 3] }]; pub fn main() { for &v in V.iter() { - println!("{}", v.vec); + println!("{:?}", v.vec); } } diff --git a/src/test/run-pass/issue-5718.rs b/src/test/run-pass/issue-5718.rs index 589ccefd9ea..36aa8a9cbca 100644 --- a/src/test/run-pass/issue-5718.rs +++ b/src/test/run-pass/issue-5718.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + struct Element; macro_rules! foo { diff --git a/src/test/run-pass/issue-5884.rs b/src/test/run-pass/issue-5884.rs index 4010c31eed5..6502c66d858 100644 --- a/src/test/run-pass/issue-5884.rs +++ b/src/test/run-pass/issue-5884.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] pub struct Foo { a: int, diff --git a/src/test/run-pass/issue-6117.rs b/src/test/run-pass/issue-6117.rs index e979bc86171..85de03dfe34 100644 --- a/src/test/run-pass/issue-6117.rs +++ b/src/test/run-pass/issue-6117.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] enum Either<T, U> { Left(T), Right(U) } diff --git a/src/test/run-pass/issue-6128.rs b/src/test/run-pass/issue-6128.rs index 4b31f393309..d96862b588f 100644 --- a/src/test/run-pass/issue-6128.rs +++ b/src/test/run-pass/issue-6128.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + extern crate collections; use std::collections::HashMap; diff --git a/src/test/run-pass/issue-6318.rs b/src/test/run-pass/issue-6318.rs index 2b474b8cfbb..b9f1a8bda7b 100644 --- a/src/test/run-pass/issue-6318.rs +++ b/src/test/run-pass/issue-6318.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] pub enum Thing { A(Box<Foo+'static>) diff --git a/src/test/run-pass/issue-6557.rs b/src/test/run-pass/issue-6557.rs index 7061a17dcdd..3163f139328 100644 --- a/src/test/run-pass/issue-6557.rs +++ b/src/test/run-pass/issue-6557.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] fn foo(box (_x, _y): Box<(int, int)>) {} diff --git a/src/test/run-pass/issue-7673-cast-generically-implemented-trait.rs b/src/test/run-pass/issue-7673-cast-generically-implemented-trait.rs index a08bdb09d3d..b6dfbb1ca42 100644 --- a/src/test/run-pass/issue-7673-cast-generically-implemented-trait.rs +++ b/src/test/run-pass/issue-7673-cast-generically-implemented-trait.rs @@ -14,6 +14,8 @@ */ +#![allow(unknown_features)] +#![feature(box_syntax)] pub fn main() {} diff --git a/src/test/run-pass/issue-8498.rs b/src/test/run-pass/issue-8498.rs index e4f4db6ea63..2a2ca4f0712 100644 --- a/src/test/run-pass/issue-8498.rs +++ b/src/test/run-pass/issue-8498.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + pub fn main() { match &[(box 5i,box 7i)] { ps => { diff --git a/src/test/run-pass/issue-8898.rs b/src/test/run-pass/issue-8898.rs index 0ca63d52bd8..42739628eed 100644 --- a/src/test/run-pass/issue-8898.rs +++ b/src/test/run-pass/issue-8898.rs @@ -8,8 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![feature(slicing_syntax)] - fn assert_repr_eq<T: std::fmt::Show>(obj : T, expected : String) { assert_eq!(expected, format!("{:?}", obj)); } diff --git a/src/test/run-pass/issue-9129.rs b/src/test/run-pass/issue-9129.rs index 5d5240272e5..2ef1c1d264a 100644 --- a/src/test/run-pass/issue-9129.rs +++ b/src/test/run-pass/issue-9129.rs @@ -10,6 +10,8 @@ // ignore-pretty +#![allow(unknown_features)] +#![feature(box_syntax)] pub trait bomb { fn boom(&self, Ident); } pub struct S; diff --git a/src/test/run-pass/issue-9382.rs b/src/test/run-pass/issue-9382.rs index 369f93222e1..07212237305 100644 --- a/src/test/run-pass/issue-9382.rs +++ b/src/test/run-pass/issue-9382.rs @@ -9,6 +9,8 @@ // except according to those terms. #![allow(unnecessary_allocation)] +#![allow(unknown_features)] +#![feature(box_syntax)] // Tests for a previous bug that occurred due to an interaction // between struct field initialization and the auto-coercion diff --git a/src/test/run-pass/issue-9396.rs b/src/test/run-pass/issue-9396.rs index 34bb50c5cf6..73355d15a27 100644 --- a/src/test/run-pass/issue-9396.rs +++ b/src/test/run-pass/issue-9396.rs @@ -15,7 +15,7 @@ use std::time::Duration; pub fn main() { let (tx, rx) = channel(); - let _t = Thread::spawn(move||{ + let _t = Thread::scoped(move||{ let mut timer = Timer::new().unwrap(); timer.sleep(Duration::milliseconds(10)); tx.send(()).unwrap(); diff --git a/src/test/run-pass/kindck-owned-trait-contains-1.rs b/src/test/run-pass/kindck-owned-trait-contains-1.rs index fbd6c92a020..999fb2c4b69 100644 --- a/src/test/run-pass/kindck-owned-trait-contains-1.rs +++ b/src/test/run-pass/kindck-owned-trait-contains-1.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] trait repeat<A> { fn get(&self) -> A; } diff --git a/src/test/run-pass/last-use-in-cap-clause.rs b/src/test/run-pass/last-use-in-cap-clause.rs index 6615bb6368f..9be9f098264 100644 --- a/src/test/run-pass/last-use-in-cap-clause.rs +++ b/src/test/run-pass/last-use-in-cap-clause.rs @@ -10,6 +10,8 @@ // Make sure #1399 stays fixed +#![allow(unknown_features)] +#![feature(box_syntax)] #![feature(unboxed_closures)] struct A { a: Box<int> } diff --git a/src/test/run-pass/last-use-is-capture.rs b/src/test/run-pass/last-use-is-capture.rs index 206d4db3db4..4a7e844268f 100644 --- a/src/test/run-pass/last-use-is-capture.rs +++ b/src/test/run-pass/last-use-is-capture.rs @@ -10,6 +10,9 @@ // Make sure #1399 stays fixed +#![allow(unknown_features)] +#![feature(box_syntax)] + struct A { a: Box<int> } pub fn main() { diff --git a/src/test/run-pass/leak-unique-as-tydesc.rs b/src/test/run-pass/leak-unique-as-tydesc.rs index b109e94b74f..65808de3cf4 100644 --- a/src/test/run-pass/leak-unique-as-tydesc.rs +++ b/src/test/run-pass/leak-unique-as-tydesc.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] fn leaky<T>(_t: T) { } diff --git a/src/test/run-pass/let-assignability.rs b/src/test/run-pass/let-assignability.rs index 6bea1aebc45..9ac016d534f 100644 --- a/src/test/run-pass/let-assignability.rs +++ b/src/test/run-pass/let-assignability.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + fn f() { let a = box 1; let b: &int = &*a; diff --git a/src/test/run-pass/list.rs b/src/test/run-pass/list.rs index 9b20398038d..e55c1b36f3e 100644 --- a/src/test/run-pass/list.rs +++ b/src/test/run-pass/list.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] enum list { cons(int, Box<list>), nil, } diff --git a/src/test/run-pass/match-implicit-copy-unique.rs b/src/test/run-pass/match-implicit-copy-unique.rs index 0e7c959d58c..6883187c402 100644 --- a/src/test/run-pass/match-implicit-copy-unique.rs +++ b/src/test/run-pass/match-implicit-copy-unique.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] struct Pair { a: Box<int>, b: Box<int> } diff --git a/src/test/run-pass/match-unique-bind.rs b/src/test/run-pass/match-unique-bind.rs index 5c834a06a74..ebe01a1d1f2 100644 --- a/src/test/run-pass/match-unique-bind.rs +++ b/src/test/run-pass/match-unique-bind.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + pub fn main() { match box 100i { box x => { diff --git a/src/test/run-pass/match-value-binding-in-guard-3291.rs b/src/test/run-pass/match-value-binding-in-guard-3291.rs index 0e7e9be6765..beb125492b2 100644 --- a/src/test/run-pass/match-value-binding-in-guard-3291.rs +++ b/src/test/run-pass/match-value-binding-in-guard-3291.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] fn foo(x: Option<Box<int>>, b: bool) -> int { match x { diff --git a/src/test/run-pass/method-projection.rs b/src/test/run-pass/method-projection.rs new file mode 100644 index 00000000000..6f72a163981 --- /dev/null +++ b/src/test/run-pass/method-projection.rs @@ -0,0 +1,78 @@ +// Copyright 2014 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// Test that we can use method notation to call methods based on a +// projection bound from a trait. Issue #20469. + +/////////////////////////////////////////////////////////////////////////// + +trait MakeString { + fn make_string(&self) -> String; +} + +impl MakeString for int { + fn make_string(&self) -> String { + format!("{}", *self) + } +} + +impl MakeString for uint { + fn make_string(&self) -> String { + format!("{}", *self) + } +} + +/////////////////////////////////////////////////////////////////////////// + +trait Foo { + type F: MakeString; + + fn get(&self) -> &Self::F; +} + +fn foo<F:Foo>(f: &F) -> String { + f.get().make_string() +} + +/////////////////////////////////////////////////////////////////////////// + +struct SomeStruct { + field: int, +} + +impl Foo for SomeStruct { + type F = int; + + fn get(&self) -> &int { + &self.field + } +} + +/////////////////////////////////////////////////////////////////////////// + +struct SomeOtherStruct { + field: uint, +} + +impl Foo for SomeOtherStruct { + type F = uint; + + fn get(&self) -> &uint { + &self.field + } +} + +fn main() { + let x = SomeStruct { field: 22 }; + assert_eq!(foo(&x), format!("22")); + + let x = SomeOtherStruct { field: 44 }; + assert_eq!(foo(&x), format!("44")); +} diff --git a/src/test/run-pass/method-self-arg-aux1.rs b/src/test/run-pass/method-self-arg-aux1.rs index d4a0d514a7d..e9a1e19d4bf 100644 --- a/src/test/run-pass/method-self-arg-aux1.rs +++ b/src/test/run-pass/method-self-arg-aux1.rs @@ -10,6 +10,9 @@ // Test method calls with self as an argument (cross-crate) +#![allow(unknown_features)] +#![feature(box_syntax)] + // aux-build:method_self_arg1.rs extern crate method_self_arg1; use method_self_arg1::Foo; diff --git a/src/test/run-pass/method-self-arg-aux2.rs b/src/test/run-pass/method-self-arg-aux2.rs index b94f1ae6ba6..7fa810ce154 100644 --- a/src/test/run-pass/method-self-arg-aux2.rs +++ b/src/test/run-pass/method-self-arg-aux2.rs @@ -10,6 +10,9 @@ // Test method calls with self as an argument (cross-crate) +#![allow(unknown_features)] +#![feature(box_syntax)] + // aux-build:method_self_arg2.rs extern crate method_self_arg2; use method_self_arg2::{Foo, Bar}; diff --git a/src/test/run-pass/method-self-arg-trait.rs b/src/test/run-pass/method-self-arg-trait.rs index 29d100beb06..39018a87394 100644 --- a/src/test/run-pass/method-self-arg-trait.rs +++ b/src/test/run-pass/method-self-arg-trait.rs @@ -10,6 +10,9 @@ // Test method calls with self as an argument +#![allow(unknown_features)] +#![feature(box_syntax)] + static mut COUNT: u64 = 1; struct Foo; diff --git a/src/test/run-pass/method-self-arg.rs b/src/test/run-pass/method-self-arg.rs index 788a25efcf9..ae15bc60746 100644 --- a/src/test/run-pass/method-self-arg.rs +++ b/src/test/run-pass/method-self-arg.rs @@ -10,6 +10,9 @@ // Test method calls with self as an argument +#![allow(unknown_features)] +#![feature(box_syntax)] + static mut COUNT: uint = 1; struct Foo; diff --git a/src/test/run-pass/method-two-trait-defer-resolution-2.rs b/src/test/run-pass/method-two-trait-defer-resolution-2.rs index cae783e7ea8..b18c29dc3c1 100644 --- a/src/test/run-pass/method-two-trait-defer-resolution-2.rs +++ b/src/test/run-pass/method-two-trait-defer-resolution-2.rs @@ -16,6 +16,9 @@ // version will run (note that the `push` occurs after the call to // `foo()`). +#![allow(unknown_features)] +#![feature(box_syntax)] + trait Foo { fn foo(&self) -> int; } diff --git a/src/test/run-pass/move-1-unique.rs b/src/test/run-pass/move-1-unique.rs index 2da6076d138..018cd440cad 100644 --- a/src/test/run-pass/move-1-unique.rs +++ b/src/test/run-pass/move-1-unique.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] #[derive(Clone)] struct Triple { diff --git a/src/test/run-pass/move-2-unique.rs b/src/test/run-pass/move-2-unique.rs index 65d8281407c..50187ef8baa 100644 --- a/src/test/run-pass/move-2-unique.rs +++ b/src/test/run-pass/move-2-unique.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] struct X { x: int, y: int, z: int } diff --git a/src/test/run-pass/move-2.rs b/src/test/run-pass/move-2.rs index 04540c2f35b..6561a9b2d5b 100644 --- a/src/test/run-pass/move-2.rs +++ b/src/test/run-pass/move-2.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] struct X { x: int, y: int, z: int } diff --git a/src/test/run-pass/move-3-unique.rs b/src/test/run-pass/move-3-unique.rs index 2820e0d7120..a10e3f9f5b0 100644 --- a/src/test/run-pass/move-3-unique.rs +++ b/src/test/run-pass/move-3-unique.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] #[derive(Clone)] struct Triple { diff --git a/src/test/run-pass/move-4-unique.rs b/src/test/run-pass/move-4-unique.rs index 286781a4822..9e5eeef7552 100644 --- a/src/test/run-pass/move-4-unique.rs +++ b/src/test/run-pass/move-4-unique.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] struct Triple {a: int, b: int, c: int} diff --git a/src/test/run-pass/move-4.rs b/src/test/run-pass/move-4.rs index 5e5d01ae6ee..c902677c645 100644 --- a/src/test/run-pass/move-4.rs +++ b/src/test/run-pass/move-4.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] struct Triple { a: int, b: int, c: int } diff --git a/src/test/run-pass/move-arg-2-unique.rs b/src/test/run-pass/move-arg-2-unique.rs index 29fd070fc19..e496e9e2105 100644 --- a/src/test/run-pass/move-arg-2-unique.rs +++ b/src/test/run-pass/move-arg-2-unique.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] fn test(foo: Box<Vec<int>> ) { assert!(((*foo)[0] == 10)); } diff --git a/src/test/run-pass/move-arg-2.rs b/src/test/run-pass/move-arg-2.rs index 0f3d0baecbe..fdb6799b90f 100644 --- a/src/test/run-pass/move-arg-2.rs +++ b/src/test/run-pass/move-arg-2.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] fn test(foo: Box<Vec<int>>) { assert!(((*foo)[0] == 10)); } diff --git a/src/test/run-pass/mut-function-arguments.rs b/src/test/run-pass/mut-function-arguments.rs index f8072851913..388b814b2af 100644 --- a/src/test/run-pass/mut-function-arguments.rs +++ b/src/test/run-pass/mut-function-arguments.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] fn f(mut y: Box<int>) { *y = 5; diff --git a/src/test/run-pass/new-box-syntax.rs b/src/test/run-pass/new-box-syntax.rs index 991d0ecdc87..4ea51b3b409 100644 --- a/src/test/run-pass/new-box-syntax.rs +++ b/src/test/run-pass/new-box-syntax.rs @@ -11,6 +11,9 @@ /* Any copyright is dedicated to the Public Domain. * http://creativecommons.org/publicdomain/zero/1.0/ */ +#![allow(unknown_features)] +#![feature(box_syntax)] + // Tests that the new `box` syntax works with unique pointers. use std::boxed::{Box, HEAP}; diff --git a/src/test/run-pass/new-box.rs b/src/test/run-pass/new-box.rs index 8531fd5f975..1f2207ad873 100644 --- a/src/test/run-pass/new-box.rs +++ b/src/test/run-pass/new-box.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] fn f(x: Box<int>) { let y: &int = &*x; diff --git a/src/test/run-pass/newlambdas-ret-infer.rs b/src/test/run-pass/newlambdas-ret-infer.rs index d74f1349506..130cdc85b01 100644 --- a/src/test/run-pass/newlambdas-ret-infer.rs +++ b/src/test/run-pass/newlambdas-ret-infer.rs @@ -11,6 +11,9 @@ // Test that the lambda kind is inferred correctly as a return // expression +#![allow(unknown_features)] +#![feature(box_syntax)] + fn unique() -> Box<FnMut()+'static> { return box || (); } pub fn main() { diff --git a/src/test/run-pass/newlambdas-ret-infer2.rs b/src/test/run-pass/newlambdas-ret-infer2.rs index 43a6ac296e9..0952bedd6e3 100644 --- a/src/test/run-pass/newlambdas-ret-infer2.rs +++ b/src/test/run-pass/newlambdas-ret-infer2.rs @@ -11,6 +11,9 @@ // Test that the lambda kind is inferred correctly as a return // expression +#![allow(unknown_features)] +#![feature(box_syntax)] + fn unique() -> Box<FnMut()+'static> { box || () } pub fn main() { diff --git a/src/test/run-pass/nullable-pointer-iotareduction.rs b/src/test/run-pass/nullable-pointer-iotareduction.rs index 0293c4e36ac..bb62b1599a4 100644 --- a/src/test/run-pass/nullable-pointer-iotareduction.rs +++ b/src/test/run-pass/nullable-pointer-iotareduction.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + use std::{option, mem}; // Iota-reduction is a rule in the Calculus of (Co-)Inductive Constructions, diff --git a/src/test/run-pass/object-one-type-two-traits.rs b/src/test/run-pass/object-one-type-two-traits.rs index 4964b3f6728..ebdf3c08a22 100644 --- a/src/test/run-pass/object-one-type-two-traits.rs +++ b/src/test/run-pass/object-one-type-two-traits.rs @@ -11,6 +11,9 @@ // Testing creating two vtables with the same self type, but different // traits. +#![allow(unknown_features)] +#![feature(box_syntax)] + use std::any::Any; trait Wrap { diff --git a/src/test/run-pass/objects-owned-object-borrowed-method-headerless.rs b/src/test/run-pass/objects-owned-object-borrowed-method-headerless.rs index ab3d39e2733..cd97c34f8c6 100644 --- a/src/test/run-pass/objects-owned-object-borrowed-method-headerless.rs +++ b/src/test/run-pass/objects-owned-object-borrowed-method-headerless.rs @@ -12,6 +12,9 @@ // closed over do not contain managed values, and thus the boxes do // not have headers. +#![allow(unknown_features)] +#![feature(box_syntax)] + trait FooTrait { fn foo(&self) -> uint; diff --git a/src/test/run-pass/objects-owned-object-owned-method.rs b/src/test/run-pass/objects-owned-object-owned-method.rs index 14ddc5d660f..d355999c506 100644 --- a/src/test/run-pass/objects-owned-object-owned-method.rs +++ b/src/test/run-pass/objects-owned-object-owned-method.rs @@ -12,6 +12,8 @@ // closed over contain managed values. This implies that the boxes // will have headers that must be skipped over. +#![allow(unknown_features)] +#![feature(box_syntax)] trait FooTrait { fn foo(self: Box<Self>) -> uint; diff --git a/src/test/run-pass/output-slot-variants.rs b/src/test/run-pass/output-slot-variants.rs index 8a10cc8c1ef..fb87cd5eb69 100644 --- a/src/test/run-pass/output-slot-variants.rs +++ b/src/test/run-pass/output-slot-variants.rs @@ -10,6 +10,8 @@ #![allow(dead_assignment)] #![allow(unused_variable)] +#![allow(unknown_features)] +#![feature(box_syntax)] struct A { a: int, b: int } struct Abox { a: Box<int>, b: Box<int> } diff --git a/src/test/run-pass/overloaded-autoderef.rs b/src/test/run-pass/overloaded-autoderef.rs index 949a7b158d4..5831d500b83 100644 --- a/src/test/run-pass/overloaded-autoderef.rs +++ b/src/test/run-pass/overloaded-autoderef.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + use std::cell::RefCell; use std::rc::Rc; use std::num::ToPrimitive; diff --git a/src/test/run-pass/overloaded-deref.rs b/src/test/run-pass/overloaded-deref.rs index 1251394a549..a2cc7b7dfea 100644 --- a/src/test/run-pass/overloaded-deref.rs +++ b/src/test/run-pass/overloaded-deref.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + use std::cell::RefCell; use std::rc::Rc; use std::string::String; diff --git a/src/test/run-pass/overloaded-index-autoderef.rs b/src/test/run-pass/overloaded-index-autoderef.rs index bc67c0afc7b..637d2c94694 100644 --- a/src/test/run-pass/overloaded-index-autoderef.rs +++ b/src/test/run-pass/overloaded-index-autoderef.rs @@ -10,6 +10,9 @@ // Test overloaded indexing combined with autoderef. +#![allow(unknown_features)] +#![feature(box_syntax)] + use std::ops::{Index, IndexMut}; struct Foo { diff --git a/src/test/run-pass/owned-implies-static.rs b/src/test/run-pass/owned-implies-static.rs index 498b81d307e..e784318fc76 100644 --- a/src/test/run-pass/owned-implies-static.rs +++ b/src/test/run-pass/owned-implies-static.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + fn f<T: 'static>(_x: T) {} pub fn main() { diff --git a/src/test/run-pass/pure-sum.rs b/src/test/run-pass/pure-sum.rs index 3b2897cf3a6..7fbdd2f219e 100644 --- a/src/test/run-pass/pure-sum.rs +++ b/src/test/run-pass/pure-sum.rs @@ -10,6 +10,8 @@ // Check that functions can modify local state. +#![allow(unknown_features)] +#![feature(box_syntax)] fn sums_to(v: Vec<int> , sum: int) -> bool { let mut i = 0u; diff --git a/src/test/run-pass/range.rs b/src/test/run-pass/range.rs index 43b6d4b3109..90e87168990 100644 --- a/src/test/run-pass/range.rs +++ b/src/test/run-pass/range.rs @@ -10,8 +10,6 @@ // Test range syntax. -#![feature(slicing_syntax)] - fn foo() -> int { 42 } pub fn main() { diff --git a/src/test/run-pass/ranges-precedence.rs b/src/test/run-pass/ranges-precedence.rs new file mode 100644 index 00000000000..f678eed8775 --- /dev/null +++ b/src/test/run-pass/ranges-precedence.rs @@ -0,0 +1,52 @@ +// 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. + +// Test that the precedence of ranges is correct + +#![feature(slicing_syntax)] + +struct Foo { + foo: uint, +} + +impl Foo { + fn bar(&self) -> uint { 5 } +} + +fn main() { + let x = 1+3..4+5; + assert!(x == (4..9)); + + let x = 1..4+5; + assert!(x == (1..9)); + + let x = 1+3..4; + assert!(x == (4..4)); + + let a = Foo { foo: 3 }; + let x = a.foo..a.bar(); + assert!(x == (3..5)); + + let x = 1+3..; + assert!(x == (4..)); + let x = ..1+3; + assert!(x == (..4)); + + let a = &[0i32, 1, 2, 3, 4, 5, 6]; + let x = &a[1+1..2+2]; + assert!(x == &a[2..4]); + let x = &a[..1+2]; + assert!(x == &a[..3]); + let x = &a[1+2..]; + assert!(x == &a[3..]); + + for _i in 2+4..10-3 {} +} + diff --git a/src/test/run-pass/rcvr-borrowed-to-region.rs b/src/test/run-pass/rcvr-borrowed-to-region.rs index 8ad2dbc1acb..84a230fd576 100644 --- a/src/test/run-pass/rcvr-borrowed-to-region.rs +++ b/src/test/run-pass/rcvr-borrowed-to-region.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] trait get { fn get(self) -> int; diff --git a/src/test/run-pass/regions-borrow-at.rs b/src/test/run-pass/regions-borrow-at.rs index 9a758c5d8ad..ba86e3f7b57 100644 --- a/src/test/run-pass/regions-borrow-at.rs +++ b/src/test/run-pass/regions-borrow-at.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] fn foo(x: &uint) -> uint { *x diff --git a/src/test/run-pass/regions-borrow-uniq.rs b/src/test/run-pass/regions-borrow-uniq.rs index 36f7d88f7d7..30a22512d2a 100644 --- a/src/test/run-pass/regions-borrow-uniq.rs +++ b/src/test/run-pass/regions-borrow-uniq.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + fn foo(x: &uint) -> uint { *x } diff --git a/src/test/run-pass/regions-close-over-type-parameter-successfully.rs b/src/test/run-pass/regions-close-over-type-parameter-successfully.rs index 5dba80ad38a..3922cb1219c 100644 --- a/src/test/run-pass/regions-close-over-type-parameter-successfully.rs +++ b/src/test/run-pass/regions-close-over-type-parameter-successfully.rs @@ -11,6 +11,9 @@ // A test where we (successfully) close over a reference into // an object. +#![allow(unknown_features)] +#![feature(box_syntax)] + trait SomeTrait { fn get(&self) -> int; } impl<'a> SomeTrait for &'a int { diff --git a/src/test/run-pass/regions-copy-closure.rs b/src/test/run-pass/regions-copy-closure.rs index a7724e68310..0152793d96c 100644 --- a/src/test/run-pass/regions-copy-closure.rs +++ b/src/test/run-pass/regions-copy-closure.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] #![feature(unboxed_closures)] struct closure_box<'a> { diff --git a/src/test/run-pass/regions-dependent-addr-of.rs b/src/test/run-pass/regions-dependent-addr-of.rs index 41396ef01be..e38a472fa4c 100644 --- a/src/test/run-pass/regions-dependent-addr-of.rs +++ b/src/test/run-pass/regions-dependent-addr-of.rs @@ -11,6 +11,8 @@ // Test lifetimes are linked properly when we create dependent region pointers. // Issue #3148. +#![allow(unknown_features)] +#![feature(box_syntax)] struct A { value: B diff --git a/src/test/run-pass/regions-early-bound-trait-param.rs b/src/test/run-pass/regions-early-bound-trait-param.rs index 907f610ff25..3267ff2c7e0 100644 --- a/src/test/run-pass/regions-early-bound-trait-param.rs +++ b/src/test/run-pass/regions-early-bound-trait-param.rs @@ -11,6 +11,8 @@ // Tests that you can use an early-bound lifetime parameter as // on of the generic parameters in a trait. +#![allow(unknown_features)] +#![feature(box_syntax)] trait Trait<'a> { fn long(&'a self) -> int; diff --git a/src/test/run-pass/regions-escape-into-other-fn.rs b/src/test/run-pass/regions-escape-into-other-fn.rs index 5b0b7cc5b4e..9637c43170f 100644 --- a/src/test/run-pass/regions-escape-into-other-fn.rs +++ b/src/test/run-pass/regions-escape-into-other-fn.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] fn foo(x: &uint) -> &uint { x } fn bar(x: &uint) -> uint { *x } diff --git a/src/test/run-pass/regions-fn-subtyping.rs b/src/test/run-pass/regions-fn-subtyping.rs index e9f774150dc..faa9b37bdcc 100644 --- a/src/test/run-pass/regions-fn-subtyping.rs +++ b/src/test/run-pass/regions-fn-subtyping.rs @@ -12,6 +12,8 @@ #![allow(dead_assignment)] #![allow(unused_variable)] +#![allow(unknown_features)] +#![feature(box_syntax)] // Should pass region checking. fn ok(f: Box<FnMut(&uint)>) { diff --git a/src/test/run-pass/regions-infer-borrow-scope-within-loop-ok.rs b/src/test/run-pass/regions-infer-borrow-scope-within-loop-ok.rs index 1ecaf41702e..f397b5124ca 100644 --- a/src/test/run-pass/regions-infer-borrow-scope-within-loop-ok.rs +++ b/src/test/run-pass/regions-infer-borrow-scope-within-loop-ok.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + fn borrow<T>(x: &T) -> &T {x} pub fn main() { diff --git a/src/test/run-pass/regions-infer-borrow-scope.rs b/src/test/run-pass/regions-infer-borrow-scope.rs index d3dbca53f60..708d031a68a 100644 --- a/src/test/run-pass/regions-infer-borrow-scope.rs +++ b/src/test/run-pass/regions-infer-borrow-scope.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] struct Point {x: int, y: int} diff --git a/src/test/run-pass/regions-lifetime-nonfree-late-bound.rs b/src/test/run-pass/regions-lifetime-nonfree-late-bound.rs index c796566b79d..c4852c9162c 100644 --- a/src/test/run-pass/regions-lifetime-nonfree-late-bound.rs +++ b/src/test/run-pass/regions-lifetime-nonfree-late-bound.rs @@ -22,6 +22,9 @@ // doing region-folding, when really all clients of the region-folding // case only want to see FREE lifetime variables, not bound ones. +#![allow(unknown_features)] +#![feature(box_syntax)] + pub fn main() { fn explicit() { fn test<F>(_x: Option<Box<F>>) where F: FnMut(Box<for<'a> FnMut(&'a int)>) {} diff --git a/src/test/run-pass/regions-relate-bound-regions-on-closures-to-inference-variables.rs b/src/test/run-pass/regions-relate-bound-regions-on-closures-to-inference-variables.rs index 6eb98104616..e779e002b29 100644 --- a/src/test/run-pass/regions-relate-bound-regions-on-closures-to-inference-variables.rs +++ b/src/test/run-pass/regions-relate-bound-regions-on-closures-to-inference-variables.rs @@ -17,6 +17,9 @@ // changes were caught. However, those uses in the compiler could // easily get changed or refactored away in the future. +#![allow(unknown_features)] +#![feature(box_syntax)] + struct Ctxt<'tcx> { x: &'tcx Vec<int> } diff --git a/src/test/run-pass/regions-static-closure.rs b/src/test/run-pass/regions-static-closure.rs index 0f36dc04575..abd5789bb1f 100644 --- a/src/test/run-pass/regions-static-closure.rs +++ b/src/test/run-pass/regions-static-closure.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] #![feature(unboxed_closures)] struct closure_box<'a> { diff --git a/src/test/run-pass/repeated-vector-syntax.rs b/src/test/run-pass/repeated-vector-syntax.rs index e854a732632..d1d37ea5bb0 100644 --- a/src/test/run-pass/repeated-vector-syntax.rs +++ b/src/test/run-pass/repeated-vector-syntax.rs @@ -8,16 +8,14 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![feature(slicing_syntax)] - pub fn main() { let x = [ [true]; 512 ]; let y = [ 0i; 1 ]; print!("["); for xi in x.iter() { - print!("{}, ", &xi[]); + print!("{:?}, ", &xi[]); } println!("]"); - println!("{}", &y[]); + println!("{:?}", &y[]); } diff --git a/src/test/run-pass/rust-log-filter.rs b/src/test/run-pass/rust-log-filter.rs index 95f90ebbf8e..28d47f7aa9b 100644 --- a/src/test/run-pass/rust-log-filter.rs +++ b/src/test/run-pass/rust-log-filter.rs @@ -10,6 +10,9 @@ // exec-env:RUST_LOG=rust-log-filter/f.o +#![allow(unknown_features)] +#![feature(box_syntax)] + #[macro_use] extern crate log; diff --git a/src/test/run-pass/self-impl.rs b/src/test/run-pass/self-impl.rs index 74416b96e93..40a4dc52a70 100644 --- a/src/test/run-pass/self-impl.rs +++ b/src/test/run-pass/self-impl.rs @@ -10,6 +10,9 @@ // Test that we can use `Self` types in impls in the expected way. +#![allow(unknown_features)] +#![feature(box_syntax)] + struct Foo; // Test uses on inherent impl. diff --git a/src/test/run-pass/self-in-mut-slot-default-method.rs b/src/test/run-pass/self-in-mut-slot-default-method.rs index bced8012b68..e934498ea05 100644 --- a/src/test/run-pass/self-in-mut-slot-default-method.rs +++ b/src/test/run-pass/self-in-mut-slot-default-method.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] struct X { a: int diff --git a/src/test/run-pass/self-re-assign.rs b/src/test/run-pass/self-re-assign.rs index 75fb98f8e24..3092898d986 100644 --- a/src/test/run-pass/self-re-assign.rs +++ b/src/test/run-pass/self-re-assign.rs @@ -11,6 +11,9 @@ // Ensure assigning an owned or managed variable to itself works. In particular, // that we do not glue_drop before we glue_take (#3290). +#![allow(unknown_features)] +#![feature(box_syntax)] + use std::rc::Rc; pub fn main() { diff --git a/src/test/run-pass/sendfn-spawn-with-fn-arg.rs b/src/test/run-pass/sendfn-spawn-with-fn-arg.rs index a6e4716c3b8..89624c3ac16 100644 --- a/src/test/run-pass/sendfn-spawn-with-fn-arg.rs +++ b/src/test/run-pass/sendfn-spawn-with-fn-arg.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + use std::thread::Thread; pub fn main() { test05(); } diff --git a/src/test/run-pass/show-boxed-slice.rs b/src/test/run-pass/show-boxed-slice.rs index e0d005a485b..fc0b501e9c5 100644 --- a/src/test/run-pass/show-boxed-slice.rs +++ b/src/test/run-pass/show-boxed-slice.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + #[derive(Show)] struct Foo(Box<[u8]>); diff --git a/src/test/run-pass/simd-size-align.rs b/src/test/run-pass/simd-size-align.rs new file mode 100644 index 00000000000..582810f0def --- /dev/null +++ b/src/test/run-pass/simd-size-align.rs @@ -0,0 +1,70 @@ +// 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(simd)] +#![allow(non_camel_case_types)] + +use std::mem; + +/// `T` should satisfy `size_of T (mod min_align_of T) === 0` to be stored at `Vec<T>` properly +/// Please consult the issue #20460 +fn check<T>() { + assert_eq!(mem::size_of::<T>() % mem::min_align_of::<T>(), 0) +} + +fn main() { + check::<u8x2>(); + check::<u8x3>(); + check::<u8x4>(); + check::<u8x5>(); + check::<u8x6>(); + check::<u8x7>(); + check::<u8x8>(); + + check::<i16x2>(); + check::<i16x3>(); + check::<i16x4>(); + check::<i16x5>(); + check::<i16x6>(); + check::<i16x7>(); + check::<i16x8>(); + + check::<f32x2>(); + check::<f32x3>(); + check::<f32x4>(); + check::<f32x5>(); + check::<f32x6>(); + check::<f32x7>(); + check::<f32x8>(); +} + +#[simd] struct u8x2(u8, u8); +#[simd] struct u8x3(u8, u8, u8); +#[simd] struct u8x4(u8, u8, u8, u8); +#[simd] struct u8x5(u8, u8, u8, u8, u8); +#[simd] struct u8x6(u8, u8, u8, u8, u8, u8); +#[simd] struct u8x7(u8, u8, u8, u8, u8, u8, u8); +#[simd] struct u8x8(u8, u8, u8, u8, u8, u8, u8, u8); + +#[simd] struct i16x2(i16, i16); +#[simd] struct i16x3(i16, i16, i16); +#[simd] struct i16x4(i16, i16, i16, i16); +#[simd] struct i16x5(i16, i16, i16, i16, i16); +#[simd] struct i16x6(i16, i16, i16, i16, i16, i16); +#[simd] struct i16x7(i16, i16, i16, i16, i16, i16, i16); +#[simd] struct i16x8(i16, i16, i16, i16, i16, i16, i16, i16); + +#[simd] struct f32x2(f32, f32); +#[simd] struct f32x3(f32, f32, f32); +#[simd] struct f32x4(f32, f32, f32, f32); +#[simd] struct f32x5(f32, f32, f32, f32, f32); +#[simd] struct f32x6(f32, f32, f32, f32, f32, f32); +#[simd] struct f32x7(f32, f32, f32, f32, f32, f32, f32); +#[simd] struct f32x8(f32, f32, f32, f32, f32, f32, f32, f32); diff --git a/src/test/run-pass/slice-2.rs b/src/test/run-pass/slice-2.rs index 05f318b53c2..8f031d2e97e 100644 --- a/src/test/run-pass/slice-2.rs +++ b/src/test/run-pass/slice-2.rs @@ -10,8 +10,6 @@ // Test slicing expressions on slices and Vecs. -#![feature(slicing_syntax)] - fn main() { let x: &[int] = &[1, 2, 3, 4, 5]; let cmp: &[int] = &[1, 2, 3, 4, 5]; diff --git a/src/test/run-pass/slice-panic-1.rs b/src/test/run-pass/slice-panic-1.rs index 8b9a3f10a60..b2e3d83ca9b 100644 --- a/src/test/run-pass/slice-panic-1.rs +++ b/src/test/run-pass/slice-panic-1.rs @@ -10,8 +10,6 @@ // Test that if a slicing expr[..] fails, the correct cleanups happen. -#![feature(slicing_syntax)] - use std::thread::Thread; struct Foo; diff --git a/src/test/run-pass/slice-panic-2.rs b/src/test/run-pass/slice-panic-2.rs index 94a0530bffb..dea45e63ab0 100644 --- a/src/test/run-pass/slice-panic-2.rs +++ b/src/test/run-pass/slice-panic-2.rs @@ -10,8 +10,6 @@ // Test that if a slicing expr[..] fails, the correct cleanups happen. -#![feature(slicing_syntax)] - use std::thread::Thread; struct Foo; diff --git a/src/test/run-pass/slice.rs b/src/test/run-pass/slice.rs index fca7daeb07d..9cb7cfd7fe9 100644 --- a/src/test/run-pass/slice.rs +++ b/src/test/run-pass/slice.rs @@ -10,11 +10,10 @@ // Test slicing sugar. -#![feature(slicing_syntax)] #![feature(associated_types)] extern crate core; -use core::ops::{Index, Range, RangeTo, RangeFrom, FullRange}; +use core::ops::{Index, IndexMut, Range, RangeTo, RangeFrom, FullRange}; static mut COUNT: uint = 0; diff --git a/src/test/run-pass/syntax-extension-bytes.rs b/src/test/run-pass/syntax-extension-bytes.rs deleted file mode 100644 index 1f92677fb6f..00000000000 --- a/src/test/run-pass/syntax-extension-bytes.rs +++ /dev/null @@ -1,28 +0,0 @@ -// Copyright 2013 The Rust Project Developers. See the COPYRIGHT -// file at the top-level directory of this distribution and at -// http://rust-lang.org/COPYRIGHT. -// -// Licensed under the Apache License, Version 2.0 <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. - -static static_vec: &'static [u8] = bytes!("abc", 0xFF, '!'); - -pub fn main() { - let vec: &'static [u8] = bytes!("abc"); - let expected: &[u8] = &[97_u8, 98_u8, 99_u8]; - assert_eq!(vec, expected); - - let vec: &'static [u8] = bytes!("null", 0); - let expected: &[u8] = &[110_u8, 117_u8, 108_u8, 108_u8, 0_u8]; - assert_eq!(vec, expected); - - let vec: &'static [u8] = bytes!(' ', " ", 32, 32u8); - let expected: &[u8] = &[32_u8, 32_u8, 32_u8, 32_u8]; - assert_eq!(vec, expected); - - let expected: &[u8] = &[97_u8, 98_u8, 99_u8, 255_u8, 33_u8]; - assert_eq!(static_vec, expected); -} diff --git a/src/test/run-pass/task-spawn-move-and-copy.rs b/src/test/run-pass/task-spawn-move-and-copy.rs index b2bcf395783..ca2a8cf5506 100644 --- a/src/test/run-pass/task-spawn-move-and-copy.rs +++ b/src/test/run-pass/task-spawn-move-and-copy.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + use std::thread::Thread; use std::sync::mpsc::channel; diff --git a/src/test/run-pass/task-stderr.rs b/src/test/run-pass/task-stderr.rs index 7ff5960375c..5e6247bac93 100644 --- a/src/test/run-pass/task-stderr.rs +++ b/src/test/run-pass/task-stderr.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + use std::sync::mpsc::channel; use std::io::{ChanReader, ChanWriter}; use std::thread; diff --git a/src/test/run-pass/tcp-accept-stress.rs b/src/test/run-pass/tcp-accept-stress.rs index cd3cb872fd3..cad71732034 100644 --- a/src/test/run-pass/tcp-accept-stress.rs +++ b/src/test/run-pass/tcp-accept-stress.rs @@ -34,11 +34,11 @@ fn test() { let (srv_tx, srv_rx) = channel(); let (cli_tx, cli_rx) = channel(); - for _ in range(0, N) { + let _t = range(0, N).map(|_| { let a = a.clone(); let cnt = cnt.clone(); let srv_tx = srv_tx.clone(); - Thread::spawn(move|| { + Thread::scoped(move|| { let mut a = a; loop { match a.accept() { @@ -52,18 +52,18 @@ fn test() { } } srv_tx.send(()); - }); - } + }) + }).collect::<Vec<_>>(); - for _ in range(0, N) { + let _t = range(0, N).map(|_| { let cli_tx = cli_tx.clone(); - Thread::spawn(move|| { + Thread::scoped(move|| { for _ in range(0, M) { let _s = TcpStream::connect(addr).unwrap(); } cli_tx.send(()); - }); - } + }) + }).collect::<Vec<_>>(); drop((cli_tx, srv_tx)); // wait for senders diff --git a/src/test/run-pass/threads.rs b/src/test/run-pass/threads.rs index c47ca0db2a1..abc2938df00 100644 --- a/src/test/run-pass/threads.rs +++ b/src/test/run-pass/threads.rs @@ -13,7 +13,7 @@ use std::thread::Thread; pub fn main() { let mut i = 10; while i > 0 { - Thread::spawn({let i = i; move|| child(i)}); + Thread::scoped({let i = i; move|| child(i)}); i = i - 1; } println!("main thread exiting"); diff --git a/src/test/run-pass/trait-bounds-in-arc.rs b/src/test/run-pass/trait-bounds-in-arc.rs index bc397bb6319..0089646d0a1 100644 --- a/src/test/run-pass/trait-bounds-in-arc.rs +++ b/src/test/run-pass/trait-bounds-in-arc.rs @@ -13,6 +13,8 @@ // ignore-pretty +#![allow(unknown_features)] +#![feature(box_syntax)] #![feature(unboxed_closures)] use std::sync::Arc; diff --git a/src/test/run-pass/trait-coercion-generic.rs b/src/test/run-pass/trait-coercion-generic.rs index 7d924f977cb..22db6c64770 100644 --- a/src/test/run-pass/trait-coercion-generic.rs +++ b/src/test/run-pass/trait-coercion-generic.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] trait Trait<T> { fn f(&self, x: T); diff --git a/src/test/run-pass/trait-coercion.rs b/src/test/run-pass/trait-coercion.rs index 37d69ddfe07..0d4a05bed7f 100644 --- a/src/test/run-pass/trait-coercion.rs +++ b/src/test/run-pass/trait-coercion.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + use std::io; trait Trait { diff --git a/src/test/run-pass/trait-contravariant-self.rs b/src/test/run-pass/trait-contravariant-self.rs index e06e01b9e05..19d76b88901 100644 --- a/src/test/run-pass/trait-contravariant-self.rs +++ b/src/test/run-pass/trait-contravariant-self.rs @@ -22,6 +22,9 @@ // 4. `Bar for Box<Foo> <: Bar for Box<Foo:Send>` because // `Box<Foo:Send> <: Box<Foo>`. +#![allow(unknown_features)] +#![feature(box_syntax)] + trait Foo { } struct SFoo; impl Foo for SFoo { } diff --git a/src/test/run-pass/trait-object-generics.rs b/src/test/run-pass/trait-object-generics.rs index 81aa5daaf91..76352c799a0 100644 --- a/src/test/run-pass/trait-object-generics.rs +++ b/src/test/run-pass/trait-object-generics.rs @@ -10,6 +10,8 @@ // test for #8664 +#![allow(unknown_features)] +#![feature(box_syntax)] pub trait Trait2<A> { fn doit(&self); diff --git a/src/test/run-pass/traits-conditional-dispatch.rs b/src/test/run-pass/traits-conditional-dispatch.rs index a94f73c2b6d..7e2b7ae0663 100644 --- a/src/test/run-pass/traits-conditional-dispatch.rs +++ b/src/test/run-pass/traits-conditional-dispatch.rs @@ -12,6 +12,9 @@ // blanket impl for T:Copy coexists with an impl for Box<T>, because // Box does not impl Copy. +#![allow(unknown_features)] +#![feature(box_syntax)] + trait Get { fn get(&self) -> Self; } diff --git a/src/test/run-pass/type-param-constraints.rs b/src/test/run-pass/type-param-constraints.rs index 7265ddf6615..3fcb04d6848 100644 --- a/src/test/run-pass/type-param-constraints.rs +++ b/src/test/run-pass/type-param-constraints.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] fn p_foo<T>(_pinned: T) { } fn s_foo<T>(_shared: T) { } diff --git a/src/test/run-pass/typeclasses-eq-example-static.rs b/src/test/run-pass/typeclasses-eq-example-static.rs index 63a59b6f750..20a28c5a9ea 100644 --- a/src/test/run-pass/typeclasses-eq-example-static.rs +++ b/src/test/run-pass/typeclasses-eq-example-static.rs @@ -9,6 +9,9 @@ // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + // Example from lkuper's intern talk, August 2012 -- now with static // methods! use Color::{cyan, magenta, yellow, black}; diff --git a/src/test/run-pass/typeclasses-eq-example.rs b/src/test/run-pass/typeclasses-eq-example.rs index 431a9383b3b..aa290edd863 100644 --- a/src/test/run-pass/typeclasses-eq-example.rs +++ b/src/test/run-pass/typeclasses-eq-example.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] // Example from lkuper's intern talk, August 2012. use Color::{cyan, magenta, yellow, black}; diff --git a/src/test/run-pass/typeid-intrinsic.rs b/src/test/run-pass/typeid-intrinsic.rs index bba043ea8f8..e346c4ff349 100644 --- a/src/test/run-pass/typeid-intrinsic.rs +++ b/src/test/run-pass/typeid-intrinsic.rs @@ -14,7 +14,7 @@ extern crate "typeid-intrinsic" as other1; extern crate "typeid-intrinsic2" as other2; -use std::hash; +use std::hash::{self, SipHasher}; use std::intrinsics; use std::intrinsics::TypeId; @@ -70,5 +70,6 @@ pub fn main() { // check it has a hash let (a, b) = (TypeId::of::<uint>(), TypeId::of::<uint>()); - assert_eq!(hash::hash(&a), hash::hash(&b)); + assert_eq!(hash::hash::<TypeId, SipHasher>(&a), + hash::hash::<TypeId, SipHasher>(&b)); } diff --git a/src/test/run-pass/ufcs-explicit-self.rs b/src/test/run-pass/ufcs-explicit-self.rs index b6b9fb67f90..968f3511247 100644 --- a/src/test/run-pass/ufcs-explicit-self.rs +++ b/src/test/run-pass/ufcs-explicit-self.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + struct Foo { f: int, } diff --git a/src/test/run-pass/unboxed-closures-boxed.rs b/src/test/run-pass/unboxed-closures-boxed.rs index 60e59400e1a..dc35d5bf2ca 100644 --- a/src/test/run-pass/unboxed-closures-boxed.rs +++ b/src/test/run-pass/unboxed-closures-boxed.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] #![feature(unboxed_closures)] use std::ops::FnMut; diff --git a/src/test/run-pass/unboxed-closures-call-sugar-object-autoderef.rs b/src/test/run-pass/unboxed-closures-call-sugar-object-autoderef.rs index 8909f4e261f..da647e90c00 100644 --- a/src/test/run-pass/unboxed-closures-call-sugar-object-autoderef.rs +++ b/src/test/run-pass/unboxed-closures-call-sugar-object-autoderef.rs @@ -10,6 +10,8 @@ // Test that the call operator autoderefs when calling to an object type. +#![allow(unknown_features)] +#![feature(box_syntax)] #![feature(unboxed_closures)] use std::ops::FnMut; diff --git a/src/test/run-pass/unboxed-closures-call-sugar-object.rs b/src/test/run-pass/unboxed-closures-call-sugar-object.rs index 2dec53cc13a..8ee3c96f580 100644 --- a/src/test/run-pass/unboxed-closures-call-sugar-object.rs +++ b/src/test/run-pass/unboxed-closures-call-sugar-object.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] #![feature(unboxed_closures)] use std::ops::FnMut; diff --git a/src/test/run-pass/unboxed-closures-monomorphization.rs b/src/test/run-pass/unboxed-closures-monomorphization.rs index 52855f82673..6701f879e4f 100644 --- a/src/test/run-pass/unboxed-closures-monomorphization.rs +++ b/src/test/run-pass/unboxed-closures-monomorphization.rs @@ -11,6 +11,8 @@ // Test that unboxed closures in contexts with free type parameters // monomorphize correctly (issue #16791) +#![allow(unknown_features)] +#![feature(box_syntax)] #![feature(unboxed_closures)] fn main(){ diff --git a/src/test/run-pass/unboxed-closures-prelude.rs b/src/test/run-pass/unboxed-closures-prelude.rs index d1bd7e908c8..915715727e8 100644 --- a/src/test/run-pass/unboxed-closures-prelude.rs +++ b/src/test/run-pass/unboxed-closures-prelude.rs @@ -10,6 +10,8 @@ // Tests that the reexports of `FnOnce` et al from the prelude work. +#![allow(unknown_features)] +#![feature(box_syntax)] #![feature(unboxed_closures)] fn main() { diff --git a/src/test/run-pass/uniq-self-in-mut-slot.rs b/src/test/run-pass/uniq-self-in-mut-slot.rs index 4d7830e1cdc..b7980ed9021 100644 --- a/src/test/run-pass/uniq-self-in-mut-slot.rs +++ b/src/test/run-pass/uniq-self-in-mut-slot.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] struct X { a: int diff --git a/src/test/run-pass/unique-assign-copy.rs b/src/test/run-pass/unique-assign-copy.rs index fb5f6e4a8aa..9e3d9544d42 100644 --- a/src/test/run-pass/unique-assign-copy.rs +++ b/src/test/run-pass/unique-assign-copy.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + pub fn main() { let mut i = box 1i; // Should be a copy diff --git a/src/test/run-pass/unique-assign-drop.rs b/src/test/run-pass/unique-assign-drop.rs index 505e9b46e03..81c4b6ab7e5 100644 --- a/src/test/run-pass/unique-assign-drop.rs +++ b/src/test/run-pass/unique-assign-drop.rs @@ -9,6 +9,8 @@ // except according to those terms. #![allow(dead_assignment)] +#![allow(unknown_features)] +#![feature(box_syntax)] pub fn main() { let i = box 1i; diff --git a/src/test/run-pass/unique-assign-generic.rs b/src/test/run-pass/unique-assign-generic.rs index 493ec8ddc20..7c9bbd64171 100644 --- a/src/test/run-pass/unique-assign-generic.rs +++ b/src/test/run-pass/unique-assign-generic.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + fn f<T>(t: T) -> T { let t1 = t; diff --git a/src/test/run-pass/unique-assign.rs b/src/test/run-pass/unique-assign.rs index 64d65a7b2e5..199657fd995 100644 --- a/src/test/run-pass/unique-assign.rs +++ b/src/test/run-pass/unique-assign.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + pub fn main() { let mut i; i = box 1i; diff --git a/src/test/run-pass/unique-autoderef-field.rs b/src/test/run-pass/unique-autoderef-field.rs index 67f96decaa9..aab7f4108fb 100644 --- a/src/test/run-pass/unique-autoderef-field.rs +++ b/src/test/run-pass/unique-autoderef-field.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + struct J { j: int } pub fn main() { diff --git a/src/test/run-pass/unique-autoderef-index.rs b/src/test/run-pass/unique-autoderef-index.rs index f9bd5114e7d..1c7b4c534ed 100644 --- a/src/test/run-pass/unique-autoderef-index.rs +++ b/src/test/run-pass/unique-autoderef-index.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] pub fn main() { let i = box vec!(100i); diff --git a/src/test/run-pass/unique-cmp.rs b/src/test/run-pass/unique-cmp.rs index 38be635d837..dba4d8db849 100644 --- a/src/test/run-pass/unique-cmp.rs +++ b/src/test/run-pass/unique-cmp.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + pub fn main() { let i = box 100i; assert!(i == box 100i); diff --git a/src/test/run-pass/unique-containing-tag.rs b/src/test/run-pass/unique-containing-tag.rs index ccb21b605c1..e4099c94c2f 100644 --- a/src/test/run-pass/unique-containing-tag.rs +++ b/src/test/run-pass/unique-containing-tag.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + pub fn main() { enum t { t1(int), t2(int), } diff --git a/src/test/run-pass/unique-create.rs b/src/test/run-pass/unique-create.rs index acd405e2659..cec74d251b3 100644 --- a/src/test/run-pass/unique-create.rs +++ b/src/test/run-pass/unique-create.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + pub fn main() { box 100i; } diff --git a/src/test/run-pass/unique-decl-init-copy.rs b/src/test/run-pass/unique-decl-init-copy.rs index ddc2bb6c30f..d0ad03b773c 100644 --- a/src/test/run-pass/unique-decl-init-copy.rs +++ b/src/test/run-pass/unique-decl-init-copy.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + pub fn main() { let mut i = box 1i; // Should be a copy diff --git a/src/test/run-pass/unique-decl-init.rs b/src/test/run-pass/unique-decl-init.rs index 1d98cfb6b4b..d7c19eb6358 100644 --- a/src/test/run-pass/unique-decl-init.rs +++ b/src/test/run-pass/unique-decl-init.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + pub fn main() { let i = box 1i; let j = i; diff --git a/src/test/run-pass/unique-decl-move.rs b/src/test/run-pass/unique-decl-move.rs index e2e7b2ec771..0acdc8f3b80 100644 --- a/src/test/run-pass/unique-decl-move.rs +++ b/src/test/run-pass/unique-decl-move.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + pub fn main() { let i = box 100i; let j = i; diff --git a/src/test/run-pass/unique-deref.rs b/src/test/run-pass/unique-deref.rs index 37ca58913ab..752ea830aa5 100644 --- a/src/test/run-pass/unique-deref.rs +++ b/src/test/run-pass/unique-deref.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + pub fn main() { let i = box 100i; assert_eq!(*i, 100); diff --git a/src/test/run-pass/unique-destructure.rs b/src/test/run-pass/unique-destructure.rs index 0b3041f2249..3213146cbf4 100644 --- a/src/test/run-pass/unique-destructure.rs +++ b/src/test/run-pass/unique-destructure.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + struct Foo { a: int, b: int } pub fn main() { diff --git a/src/test/run-pass/unique-drop-complex.rs b/src/test/run-pass/unique-drop-complex.rs index a4b6ff5accf..ec2c9f8c666 100644 --- a/src/test/run-pass/unique-drop-complex.rs +++ b/src/test/run-pass/unique-drop-complex.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + pub fn main() { let _x = box vec!(0i,0,0,0,0); } diff --git a/src/test/run-pass/unique-fn-arg-move.rs b/src/test/run-pass/unique-fn-arg-move.rs index 68290d85d0e..0e47d39e55f 100644 --- a/src/test/run-pass/unique-fn-arg-move.rs +++ b/src/test/run-pass/unique-fn-arg-move.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + fn f(i: Box<int>) { assert_eq!(*i, 100); } diff --git a/src/test/run-pass/unique-fn-arg-mut.rs b/src/test/run-pass/unique-fn-arg-mut.rs index ccf6a4fd7ae..e1d148cc9a5 100644 --- a/src/test/run-pass/unique-fn-arg-mut.rs +++ b/src/test/run-pass/unique-fn-arg-mut.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] fn f(i: &mut Box<int>) { *i = box 200; diff --git a/src/test/run-pass/unique-fn-arg.rs b/src/test/run-pass/unique-fn-arg.rs index 6769011cffe..301994a74a8 100644 --- a/src/test/run-pass/unique-fn-arg.rs +++ b/src/test/run-pass/unique-fn-arg.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] fn f(i: Box<int>) { assert_eq!(*i, 100); diff --git a/src/test/run-pass/unique-fn-ret.rs b/src/test/run-pass/unique-fn-ret.rs index 8493652cf8a..de2c265089b 100644 --- a/src/test/run-pass/unique-fn-ret.rs +++ b/src/test/run-pass/unique-fn-ret.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] fn f() -> Box<int> { box 100 diff --git a/src/test/run-pass/unique-in-tag.rs b/src/test/run-pass/unique-in-tag.rs index ffff9b98f54..4f02018346b 100644 --- a/src/test/run-pass/unique-in-tag.rs +++ b/src/test/run-pass/unique-in-tag.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + fn test1() { enum bar { u(Box<int>), w(int), } diff --git a/src/test/run-pass/unique-in-vec-copy.rs b/src/test/run-pass/unique-in-vec-copy.rs index 577a8f1430b..4620815e74e 100644 --- a/src/test/run-pass/unique-in-vec-copy.rs +++ b/src/test/run-pass/unique-in-vec-copy.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] pub fn main() { let mut a = vec!(box 10i); diff --git a/src/test/run-pass/unique-in-vec.rs b/src/test/run-pass/unique-in-vec.rs index 0f8527664b9..389ca2c18b1 100644 --- a/src/test/run-pass/unique-in-vec.rs +++ b/src/test/run-pass/unique-in-vec.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + pub fn main() { let vect = vec!(box 100i); assert!(vect[0] == box 100); diff --git a/src/test/run-pass/unique-init.rs b/src/test/run-pass/unique-init.rs index 6e58ec23a3b..b36d08364a2 100644 --- a/src/test/run-pass/unique-init.rs +++ b/src/test/run-pass/unique-init.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + pub fn main() { let _i = box 100i; } diff --git a/src/test/run-pass/unique-kinds.rs b/src/test/run-pass/unique-kinds.rs index d3f4a8b1090..56f7a3f7990 100644 --- a/src/test/run-pass/unique-kinds.rs +++ b/src/test/run-pass/unique-kinds.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + use std::cmp::PartialEq; fn sendable() { diff --git a/src/test/run-pass/unique-log.rs b/src/test/run-pass/unique-log.rs index bae87230ba0..05579796dab 100644 --- a/src/test/run-pass/unique-log.rs +++ b/src/test/run-pass/unique-log.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + pub fn main() { let i = box 100i; println!("{}", i); diff --git a/src/test/run-pass/unique-match-discrim.rs b/src/test/run-pass/unique-match-discrim.rs index 68b46db3a94..a1502c2eb8c 100644 --- a/src/test/run-pass/unique-match-discrim.rs +++ b/src/test/run-pass/unique-match-discrim.rs @@ -10,6 +10,9 @@ // Issue #961 +#![allow(unknown_features)] +#![feature(box_syntax)] + fn altsimple() { match box true { _ => { } diff --git a/src/test/run-pass/unique-move-drop.rs b/src/test/run-pass/unique-move-drop.rs index 1b6ef92865c..1388c6c5d2b 100644 --- a/src/test/run-pass/unique-move-drop.rs +++ b/src/test/run-pass/unique-move-drop.rs @@ -9,6 +9,8 @@ // except according to those terms. #![allow(unused_variable)] +#![allow(unknown_features)] +#![feature(box_syntax)] pub fn main() { let i = box 100i; diff --git a/src/test/run-pass/unique-move-temp.rs b/src/test/run-pass/unique-move-temp.rs index 1902fabe639..af82d3e14ea 100644 --- a/src/test/run-pass/unique-move-temp.rs +++ b/src/test/run-pass/unique-move-temp.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + pub fn main() { let mut i; i = box 100i; diff --git a/src/test/run-pass/unique-move.rs b/src/test/run-pass/unique-move.rs index 398db63ce08..791c4799bf0 100644 --- a/src/test/run-pass/unique-move.rs +++ b/src/test/run-pass/unique-move.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + pub fn main() { let i = box 100i; let mut j; diff --git a/src/test/run-pass/unique-mutable.rs b/src/test/run-pass/unique-mutable.rs index eebb1705590..c4f860d930b 100644 --- a/src/test/run-pass/unique-mutable.rs +++ b/src/test/run-pass/unique-mutable.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + pub fn main() { let mut i = box 0i; *i = 1; diff --git a/src/test/run-pass/unique-object-move.rs b/src/test/run-pass/unique-object-move.rs index 6d0432faf55..cec523a0671 100644 --- a/src/test/run-pass/unique-object-move.rs +++ b/src/test/run-pass/unique-object-move.rs @@ -10,6 +10,8 @@ // Issue #5192 +#![allow(unknown_features)] +#![feature(box_syntax)] pub trait EventLoop { } diff --git a/src/test/run-pass/unique-pat-2.rs b/src/test/run-pass/unique-pat-2.rs index bf99f06f58a..eab775fc1db 100644 --- a/src/test/run-pass/unique-pat-2.rs +++ b/src/test/run-pass/unique-pat-2.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] struct Foo {a: int, b: uint} diff --git a/src/test/run-pass/unique-pat-3.rs b/src/test/run-pass/unique-pat-3.rs index 559d8f8cb3c..42a4b1a9c0c 100644 --- a/src/test/run-pass/unique-pat-3.rs +++ b/src/test/run-pass/unique-pat-3.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + enum bar { u(Box<int>), w(int), } pub fn main() { diff --git a/src/test/run-pass/unique-pat.rs b/src/test/run-pass/unique-pat.rs index a0eee7e3cb6..ee975b9c81a 100644 --- a/src/test/run-pass/unique-pat.rs +++ b/src/test/run-pass/unique-pat.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + fn simple() { match box true { box true => { } diff --git a/src/test/run-pass/unique-rec.rs b/src/test/run-pass/unique-rec.rs index ff7f009990d..756911d29fc 100644 --- a/src/test/run-pass/unique-rec.rs +++ b/src/test/run-pass/unique-rec.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + struct X { x: int } pub fn main() { diff --git a/src/test/run-pass/unique-send-2.rs b/src/test/run-pass/unique-send-2.rs index bb3019ede4b..90f4b2e6344 100644 --- a/src/test/run-pass/unique-send-2.rs +++ b/src/test/run-pass/unique-send-2.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + use std::sync::mpsc::{channel, Sender}; use std::thread::Thread; @@ -19,13 +22,13 @@ pub fn main() { let (tx, rx) = channel(); let n = 100u; let mut expected = 0u; - for i in range(0u, n) { + let _t = range(0u, n).map(|i| { + expected += i; let tx = tx.clone(); - Thread::spawn(move|| { + Thread::scoped(move|| { child(&tx, i) - }); - expected += i; - } + }) + }).collect::<Vec<_>>(); let mut actual = 0u; for _ in range(0u, n) { diff --git a/src/test/run-pass/unique-send.rs b/src/test/run-pass/unique-send.rs index afafb204c1c..13728585455 100644 --- a/src/test/run-pass/unique-send.rs +++ b/src/test/run-pass/unique-send.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + use std::sync::mpsc::channel; pub fn main() { diff --git a/src/test/run-pass/unique-swap.rs b/src/test/run-pass/unique-swap.rs index d467d042e4e..cd3b59a69ba 100644 --- a/src/test/run-pass/unique-swap.rs +++ b/src/test/run-pass/unique-swap.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + use std::mem::swap; pub fn main() { diff --git a/src/test/run-pass/unsized2.rs b/src/test/run-pass/unsized2.rs index c7e8b2a05ec..285100dd719 100644 --- a/src/test/run-pass/unsized2.rs +++ b/src/test/run-pass/unsized2.rs @@ -10,6 +10,9 @@ // // ignore-lexer-test FIXME #15879 +#![allow(unknown_features)] +#![feature(box_syntax)] + // Test sized-ness checking in substitution. // Unbounded. diff --git a/src/test/run-pass/unsized3.rs b/src/test/run-pass/unsized3.rs index 271f5817c9e..983152cd056 100644 --- a/src/test/run-pass/unsized3.rs +++ b/src/test/run-pass/unsized3.rs @@ -10,6 +10,9 @@ // Test structs with always-unsized fields. +#![allow(unknown_features)] +#![feature(box_syntax)] + use std::mem; use std::raw; diff --git a/src/test/run-pass/unused-move-capture.rs b/src/test/run-pass/unused-move-capture.rs index bd20a174d1e..27945f46920 100644 --- a/src/test/run-pass/unused-move-capture.rs +++ b/src/test/run-pass/unused-move-capture.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + pub fn main() { let _x = box 1i; let lam_move = |&:| {}; diff --git a/src/test/run-pass/unused-move.rs b/src/test/run-pass/unused-move.rs index 883ec44bf2e..22201c7d83f 100644 --- a/src/test/run-pass/unused-move.rs +++ b/src/test/run-pass/unused-move.rs @@ -13,6 +13,8 @@ // Abstract: zero-fill to block after drop #![allow(path_statement)] +#![allow(unknown_features)] +#![feature(box_syntax)] pub fn main() { diff --git a/src/test/run-pass/unwind-resource.rs b/src/test/run-pass/unwind-resource.rs index 3f59b2c6c76..159bac10183 100644 --- a/src/test/run-pass/unwind-resource.rs +++ b/src/test/run-pass/unwind-resource.rs @@ -37,7 +37,7 @@ fn f(tx: Sender<bool>) { pub fn main() { let (tx, rx) = channel(); - let _t = Thread::spawn(move|| f(tx.clone())); + let _t = Thread::scoped(move|| f(tx.clone())); println!("hiiiiiiiii"); assert!(rx.recv().unwrap()); } diff --git a/src/test/run-pass/unwind-unique.rs b/src/test/run-pass/unwind-unique.rs index 554a08ea644..371fd677bd9 100644 --- a/src/test/run-pass/unwind-unique.rs +++ b/src/test/run-pass/unwind-unique.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + use std::thread::Thread; fn f() { diff --git a/src/test/run-pass/vec-dst.rs b/src/test/run-pass/vec-dst.rs index 4a36231e72b..40073c2b742 100644 --- a/src/test/run-pass/vec-dst.rs +++ b/src/test/run-pass/vec-dst.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(unknown_features)] +#![feature(box_syntax)] + pub fn main() { // Tests for indexing into box/& [T; n] let x: [int; 3] = [1, 2, 3]; diff --git a/src/test/run-pass/vec-fixed-length.rs b/src/test/run-pass/vec-fixed-length.rs index 20e1becd008..101999bbe08 100644 --- a/src/test/run-pass/vec-fixed-length.rs +++ b/src/test/run-pass/vec-fixed-length.rs @@ -21,7 +21,7 @@ pub fn main() { // FIXME #10183 // FIXME #18069 - //if cfg!(target_word_size = "64") { + //if cfg!(target_pointer_width = "64") { // assert_eq!(size_of::<[u8; (1 << 32)]>(), (1u << 32)); //} } diff --git a/src/test/run-pass/vec-to_str.rs b/src/test/run-pass/vec-to_str.rs index 52e0ba89479..97c12d0954e 100644 --- a/src/test/run-pass/vec-to_str.rs +++ b/src/test/run-pass/vec-to_str.rs @@ -9,11 +9,11 @@ // except according to those terms. pub fn main() { - assert_eq!((vec!(0i, 1)).to_string(), "[0, 1]".to_string()); + assert_eq!(format!("{:?}", vec!(0i, 1)), "[0i, 1i]".to_string()); let foo = vec!(3i, 4); let bar: &[int] = &[4, 5]; - assert_eq!(foo.to_string(), "[3, 4]".to_string()); - assert_eq!(bar.to_string(), "[4, 5]".to_string()); + assert_eq!(format!("{:?}", foo), "[3i, 4i]"); + assert_eq!(format!("{:?}", bar), "[4i, 5i]"); } diff --git a/src/test/run-pass/vector-no-ann-2.rs b/src/test/run-pass/vector-no-ann-2.rs index ba66a448c25..6391893b9a4 100644 --- a/src/test/run-pass/vector-no-ann-2.rs +++ b/src/test/run-pass/vector-no-ann-2.rs @@ -8,6 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. - +#![allow(unknown_features)] +#![feature(box_syntax)] pub fn main() { let _quux: Box<Vec<uint>> = box Vec::new(); } |