diff options
| author | bors <bors@rust-lang.org> | 2015-01-08 18:40:04 +0000 |
|---|---|---|
| committer | bors <bors@rust-lang.org> | 2015-01-08 18:40:04 +0000 |
| commit | 00b112c45a604fa6f4b59af2a40c9deeadfdb7c6 (patch) | |
| tree | b7ebe956eeb308942c79bb1cd8ca1c4fc016fe83 /src | |
| parent | a8a210b57ef6b2f5f66b8798c80acfde70c9d2e7 (diff) | |
| parent | 7541f82faba6b2839b5e640605d7caab6cc6ec4f (diff) | |
| download | rust-00b112c45a604fa6f4b59af2a40c9deeadfdb7c6.tar.gz rust-00b112c45a604fa6f4b59af2a40c9deeadfdb7c6.zip | |
auto merge of #20760 : alexcrichton/rust/rollup, r=alexcrichton
Diffstat (limited to 'src')
995 files changed, 9089 insertions, 9367 deletions
diff --git a/src/compiletest/compiletest.rs b/src/compiletest/compiletest.rs index 9a5665e6839..802fb05796d 100644 --- a/src/compiletest/compiletest.rs +++ b/src/compiletest/compiletest.rs @@ -12,6 +12,7 @@ #![allow(unknown_features)] #![feature(slicing_syntax, unboxed_closures)] #![feature(box_syntax)] +#![feature(int_uint)] #![deny(warnings)] diff --git a/src/doc/guide-container.md b/src/doc/guide-container.md deleted file mode 100644 index e9bda17f4bc..00000000000 --- a/src/doc/guide-container.md +++ /dev/null @@ -1,6 +0,0 @@ -% The Rust Containers and Iterators Guide - -This guide has been removed, with no direct replacement. - -You may enjoy reading the [iterator](std/iter/index.html) and -[collections](std/collections/index.html) documentation. diff --git a/src/doc/guide-strings.md b/src/doc/guide-strings.md deleted file mode 100644 index 43cc8483bce..00000000000 --- a/src/doc/guide-strings.md +++ /dev/null @@ -1,308 +0,0 @@ -% The Guide to Rust Strings - -Strings are an important concept to master in any programming language. If you -come from a managed language background, you may be surprised at the complexity -of string handling in a systems programming language. Efficient access and -allocation of memory for a dynamically sized structure involves a lot of -details. Luckily, Rust has lots of tools to help us here. - -A **string** is a sequence of unicode scalar values encoded as a stream of -UTF-8 bytes. All strings are guaranteed to be validly-encoded UTF-8 sequences. -Additionally, strings are not null-terminated and can contain null bytes. - -Rust has two main types of strings: `&str` and `String`. - -# &str - -The first kind is a `&str`. This is pronounced a 'string slice'. -String literals are of the type `&str`: - -```{rust} -let string = "Hello there."; -``` - -Like any Rust type, string slices have an associated lifetime. A string literal -is a `&'static str`. A string slice can be written without an explicit -lifetime in many cases, such as in function arguments. In these cases the -lifetime will be inferred: - -```{rust} -fn takes_slice(slice: &str) { - println!("Got: {}", slice); -} -``` - -Like vector slices, string slices are simply a pointer plus a length. This -means that they're a 'view' into an already-allocated string, such as a -`&'static str` or a `String`. - -# String - -A `String` is a heap-allocated string. This string is growable, and is also -guaranteed to be UTF-8. - -```{rust} -let mut s = "Hello".to_string(); -println!("{}", s); - -s.push_str(", world."); -println!("{}", s); -``` - -You can coerce a `String` into a `&str` with the `as_slice()` method: - -```{rust} -fn takes_slice(slice: &str) { - println!("Got: {}", slice); -} - -fn main() { - let s = "Hello".to_string(); - takes_slice(s.as_slice()); -} -``` - -You can also get a `&str` from a stack-allocated array of bytes: - -```{rust} -use std::str; - -let x: &[u8] = &[b'a', b'b']; -let stack_str: &str = str::from_utf8(x).unwrap(); -``` - -# Best Practices - -## `String` vs. `&str` - -In general, you should prefer `String` when you need ownership, and `&str` when -you just need to borrow a string. This is very similar to using `Vec<T>` vs. `&[T]`, -and `T` vs `&T` in general. - -This means starting off with this: - -```{rust,ignore} -fn foo(s: &str) { -``` - -and only moving to this: - -```{rust,ignore} -fn foo(s: String) { -``` - -If you have good reason. It's not polite to hold on to ownership you don't -need, and it can make your lifetimes more complex. - -## Generic functions - -To write a function that's generic over types of strings, use `&str`. - -```{rust} -fn some_string_length(x: &str) -> uint { - x.len() -} - -fn main() { - let s = "Hello, world"; - - println!("{}", some_string_length(s)); - - let s = "Hello, world".to_string(); - - println!("{}", some_string_length(s.as_slice())); -} -``` - -Both of these lines will print `12`. - -## Comparisons - -To compare a String to a constant string, prefer `as_slice()`... - -```{rust} -fn compare(x: String) { - if x.as_slice() == "Hello" { - println!("yes"); - } -} -``` - -... over `to_string()`: - -```{rust} -fn compare(x: String) { - if x == "Hello".to_string() { - println!("yes"); - } -} -``` - -Converting a `String` to a `&str` is cheap, but converting the `&str` to a -`String` involves an allocation. - -## Indexing strings - -You may be tempted to try to access a certain character of a `String`, like -this: - -```{rust,ignore} -let s = "hello".to_string(); - -println!("{}", s[0]); -``` - -This does not compile. This is on purpose. In the world of UTF-8, direct -indexing is basically never what you want to do. The reason is that each -character can be a variable number of bytes. This means that you have to iterate -through the characters anyway, which is an O(n) operation. - -There's 3 basic levels of unicode (and its encodings): - -- code units, the underlying data type used to store everything -- code points/unicode scalar values (char) -- graphemes (visible characters) - -Rust provides iterators for each of these situations: - -- `.bytes()` will iterate over the underlying bytes -- `.chars()` will iterate over the code points -- `.graphemes()` will iterate over each grapheme - -Usually, the `graphemes()` method on `&str` is what you want: - -```{rust} -let s = "u͔n͈̰̎i̙̮͚̦c͚̉o̼̩̰͗d͔̆̓ͥé"; - -for l in s.graphemes(true) { - println!("{}", l); -} -``` - -This prints: - -```{text} -u͔ -n͈̰̎ -i̙̮͚̦ -c͚̉ -o̼̩̰͗ -d͔̆̓ͥ -é -``` - -Note that `l` has the type `&str` here, since a single grapheme can consist of -multiple codepoints, so a `char` wouldn't be appropriate. - -This will print out each visible character in turn, as you'd expect: first "u͔", then -"n͈̰̎", etc. If you wanted each individual codepoint of each grapheme, you can use `.chars()`: - -```{rust} -let s = "u͔n͈̰̎i̙̮͚̦c͚̉o̼̩̰͗d͔̆̓ͥé"; - -for l in s.chars() { - println!("{}", l); -} -``` - -This prints: - -```{text} -u -͔ -n -̎ -͈ -̰ -i -̙ -̮ -͚ -̦ -c -̉ -͚ -o -͗ -̼ -̩ -̰ -d -̆ -̓ -ͥ -͔ -e -́ -``` - -You can see how some of them are combining characters, and therefore the output -looks a bit odd. - -If you want the individual byte representation of each codepoint, you can use -`.bytes()`: - -```{rust} -let s = "u͔n͈̰̎i̙̮͚̦c͚̉o̼̩̰͗d͔̆̓ͥé"; - -for l in s.bytes() { - println!("{}", l); -} -``` - -This will print: - -```{text} -117 -205 -148 -110 -204 -142 -205 -136 -204 -176 -105 -204 -153 -204 -174 -205 -154 -204 -166 -99 -204 -137 -205 -154 -111 -205 -151 -204 -188 -204 -169 -204 -176 -100 -204 -134 -205 -131 -205 -165 -205 -148 -101 -204 -129 -``` - -Many more bytes than graphemes! - -# Other Documentation - -* [the `&str` API documentation](std/str/index.html) -* [the `String` API documentation](std/string/index.html) diff --git a/src/doc/guide.md b/src/doc/guide.md deleted file mode 100644 index 5ab3063033f..00000000000 --- a/src/doc/guide.md +++ /dev/null @@ -1,5520 +0,0 @@ -% The Rust Guide - -Hey there! Welcome to the Rust guide. This is the place to be if you'd like to -learn how to program in Rust. Rust is a systems programming language with a -focus on "high-level, bare-metal programming": the lowest level control a -programming language can give you, but with zero-cost, higher level -abstractions, because people aren't computers. We really think Rust is -something special, and we hope you do too. - -To show you how to get going with Rust, we're going to write the traditional -"Hello, World!" program. Next, we'll introduce you to a tool that's useful for -writing real-world Rust programs and libraries: "Cargo." After that, we'll talk -about the basics of Rust, write a little program to try them out, and then learn -more advanced things. - -Sound good? Let's go! - -# Installing Rust - -The first step to using Rust is to install it! There are a number of ways to -install Rust, but the easiest is to use the `rustup` script. If you're on -Linux or a Mac, all you need to do is this (note that you don't need to type -in the `$`s, they just indicate the start of each command): - -```bash -$ curl -L https://static.rust-lang.org/rustup.sh | sudo sh -``` - -If you're concerned about the [potential insecurity](http://curlpipesh.tumblr.com/) of using `curl | sudo sh`, -please keep reading and see our disclaimer below. And feel free to use a two-step version of the installation and examine our installation script: - -```bash -$ curl -L https://static.rust-lang.org/rustup.sh -O -$ sudo sh rustup.sh -``` - -If you're on Windows, please download either the [32-bit -installer](https://static.rust-lang.org/dist/rust-nightly-i686-pc-windows-gnu.exe) -or the [64-bit -installer](https://static.rust-lang.org/dist/rust-nightly-x86_64-pc-windows-gnu.exe) -and run it. - -If you decide you don't want Rust anymore, we'll be a bit sad, but that's okay. -Not every programming language is great for everyone. Just pass an argument to -the script: - -```bash -$ curl -s https://static.rust-lang.org/rustup.sh | sudo sh -s -- --uninstall -``` - -If you used the Windows installer, just re-run the `.exe` and it will give you -an uninstall option. - -You can re-run this script any time you want to update Rust. Which, at this -point, is often. Rust is still pre-1.0, and so people assume that you're using -a very recent Rust. - -This brings me to one other point: some people, and somewhat rightfully so, get -very upset when we tell you to `curl | sudo sh`. And they should be! Basically, -when you do this, you are trusting that the good people who maintain Rust -aren't going to hack your computer and do bad things. That's a good instinct! -If you're one of those people, please check out the documentation on [building -Rust from Source](https://github.com/rust-lang/rust#building-from-source), or -[the official binary downloads](http://www.rust-lang.org/install.html). And we -promise that this method will not be the way to install Rust forever: it's just -the easiest way to keep people updated while Rust is in its alpha state. - -Oh, we should also mention the officially supported platforms: - -* Windows (7, 8, Server 2008 R2) -* Linux (2.6.18 or later, various distributions), x86 and x86-64 -* OSX 10.7 (Lion) or greater, x86 and x86-64 - -We extensively test Rust on these platforms, and a few others, too, like -Android. But these are the ones most likely to work, as they have the most -testing. - -Finally, a comment about Windows. Rust considers Windows to be a first-class -platform upon release, but if we're honest, the Windows experience isn't as -integrated as the Linux/OS X experience is. We're working on it! If anything -does not work, it is a bug. Please let us know if that happens. Each and every -commit is tested against Windows just like any other platform. - -If you've got Rust installed, you can open up a shell, and type this: - -```bash -$ rustc --version -``` - -You should see some output that looks something like this: - -```bash -rustc 1.0.0-nightly (f11f3e7ba 2015-01-04 20:02:14 +0000) -``` - -If you did, Rust has been installed successfully! Congrats! - -If not, there are a number of places where you can get help. The easiest is -[the #rust IRC channel on irc.mozilla.org](irc://irc.mozilla.org/#rust), which -you can access through -[Mibbit](http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust). Click -that link, and you'll be chatting with other Rustaceans (a silly nickname we -call ourselves), and we can help you out. Other great resources include [our -forum](http://discuss.rust-lang.org/), [the /r/rust -subreddit](http://www.reddit.com/r/rust), and [Stack -Overflow](http://stackoverflow.com/questions/tagged/rust). - -# Hello, world! - -Now that you have Rust installed, let's write your first Rust program. It's -traditional to make your first program in any new language one that prints the -text "Hello, world!" to the screen. The nice thing about starting with such a -simple program is that you can verify that your compiler isn't just installed, -but also working properly. And printing information to the screen is a pretty -common thing to do. - -The first thing that we need to do is make a file to put our code in. I like -to make a `projects` directory in my home directory, and keep all my projects -there. Rust does not care where your code lives. - -This actually leads to one other concern we should address: this guide will -assume that you have basic familiarity with the command line. Rust does not -require that you know a whole ton about the command line, but until the -language is in a more finished state, IDE support is spotty. Rust makes no -specific demands on your editing tooling, or where your code lives. - -With that said, let's make a directory in our projects directory. - -```{bash} -$ mkdir ~/projects -$ cd ~/projects -$ mkdir hello_world -$ cd hello_world -``` - -If you're on Windows and not using PowerShell, the `~` may not work. Consult -the documentation for your shell for more details. - -Let's make a new source file next. I'm going to use the syntax `editor -filename` to represent editing a file in these examples, but you should use -whatever method you want. We'll call our file `main.rs`: - -```{bash} -$ editor main.rs -``` - -Rust files always end in a `.rs` extension. If you're using more than one word -in your filename, use an underscore. `hello_world.rs` rather than -`helloworld.rs`. - -Now that you've got your file open, type this in: - -```{rust} -fn main() { - println!("Hello, world!"); -} -``` - -Save the file, and then type this into your terminal window: - -```{bash} -$ rustc main.rs -$ ./main # or main.exe on Windows -Hello, world! -``` - -You can also run these examples on [play.rust-lang.org](http://play.rust-lang.org/) by clicking on the arrow that appears in the upper right of the example when you mouse over the code. - -Success! Let's go over what just happened in detail. - -```{rust} -fn main() { - -} -``` - -These lines define a **function** in Rust. The `main` function is special: -it's the beginning of every Rust program. The first line says "I'm declaring a -function named `main`, which takes no arguments and returns nothing." If there -were arguments, they would go inside the parentheses (`(` and `)`), and because -we aren't returning anything from this function, we've dropped that notation -entirely. We'll get to it later. - -You'll also note that the function is wrapped in curly braces (`{` and `}`). -Rust requires these around all function bodies. It is also considered good -style to put the opening curly brace on the same line as the function -declaration, with one space in between. - -Next up is this line: - -```{rust} - println!("Hello, world!"); -``` - -This line does all of the work in our little program. There are a number of -details that are important here. The first is that it's indented with four -spaces, not tabs. Please configure your editor of choice to insert four spaces -with the tab key. We provide some [sample configurations for various -editors](https://github.com/rust-lang/rust/tree/master/src/etc). - -The second point is the `println!()` part. This is calling a Rust **macro**, -which is how metaprogramming is done in Rust. If it were a function instead, it -would look like this: `println()`. For our purposes, we don't need to worry -about this difference. Just know that sometimes, you'll see a `!`, and that -means that you're calling a macro instead of a normal function. Rust implements -`println!` as a macro rather than a function for good reasons, but that's a -very advanced topic. You'll learn more when we talk about macros later. One -last thing to mention: Rust's macros are significantly different from C macros, -if you've used those. Don't be scared of using macros. We'll get to the details -eventually, you'll just have to trust us for now. - -Next, `"Hello, world!"` is a **string**. Strings are a surprisingly complicated -topic in a systems programming language, and this is a **statically allocated** -string. We will talk more about different kinds of allocation later. We pass -this string as an argument to `println!`, which prints the string to the -screen. Easy enough! - -Finally, the line ends with a semicolon (`;`). Rust is an **expression -oriented** language, which means that most things are expressions. The `;` is -used to indicate that this expression is over, and the next one is ready to -begin. Most lines of Rust code end with a `;`. We will cover this in-depth -later in the guide. - -Finally, actually **compiling** and **running** our program. We can compile -with our compiler, `rustc`, by passing it the name of our source file: - -```{bash} -$ rustc main.rs -``` - -This is similar to `gcc` or `clang`, if you come from a C or C++ background. Rust -will output a binary executable. You can see it with `ls`: - -```{bash} -$ ls -main main.rs -``` - -Or on Windows: - -```{bash} -$ dir -main.exe main.rs -``` - -There are now two files: our source code, with the `.rs` extension, and the -executable (`main.exe` on Windows, `main` everywhere else) - -```{bash} -$ ./main # or main.exe on Windows -``` - -This prints out our `Hello, world!` text to our terminal. - -If you come from a dynamically typed language like Ruby, Python, or JavaScript, -you may not be used to these two steps being separate. Rust is an -**ahead-of-time compiled language**, which means that you can compile a -program, give it to someone else, and they don't need to have Rust installed. -If you give someone a `.rb` or `.py` or `.js` file, they need to have -Ruby/Python/JavaScript installed, but you just need one command to both compile -and run your program. Everything is a tradeoff in language design, and Rust has -made its choice. - -Congratulations! You have officially written a Rust program. That makes you a -Rust programmer! Welcome. - -Next, I'd like to introduce you to another tool, Cargo, which is used to write -real-world Rust programs. Just using `rustc` is nice for simple things, but as -your project grows, you'll want something to help you manage all of the options -that it has, and to make it easy to share your code with other people and -projects. - -# Hello, Cargo! - -[Cargo](http://crates.io) is a tool that Rustaceans use to help manage their -Rust projects. Cargo is currently in an alpha state, just like Rust, and so it -is still a work in progress. However, it is already good enough to use for many -Rust projects, and so it is assumed that Rust projects will use Cargo from the -beginning. - -Cargo manages three things: building your code, downloading the dependencies -your code needs, and building the dependencies your code needs. At first, your -program doesn't have any dependencies, so we'll only be using the first part of -its functionality. Eventually, we'll add more. Since we started off by using -Cargo, it'll be easy to add later. - -If you installed Rust via the official installers you will also have -Cargo. If you installed Rust some other way, you may want to [check -the Cargo -README](https://github.com/rust-lang/cargo#installing-cargo-from-nightlies) -for specific instructions about installing it. - -Let's convert Hello World to Cargo. - -To Cargo-ify our project, we need to do two things: Make a `Cargo.toml` -configuration file, and put our source file in the right place. Let's -do that part first: - -```{bash} -$ mkdir src -$ mv main.rs src/main.rs -``` - -Cargo expects your source files to live inside a `src` directory. That leaves -the top level for other things, like READMEs, license information, and anything -not related to your code. Cargo helps us keep our projects nice and tidy. A -place for everything, and everything in its place. - -Next, our configuration file: - -```{bash} -$ editor Cargo.toml -``` - -Make sure to get this name right: you need the capital `C`! - -Put this inside: - -```toml -[package] - -name = "hello_world" -version = "0.0.1" -authors = [ "Your name <you@example.com>" ] - -[[bin]] - -name = "hello_world" -``` - -This file is in the [TOML](https://github.com/toml-lang/toml) format. Let's let -it explain itself to you: - -> TOML aims to be a minimal configuration file format that's easy to read due -> to obvious semantics. TOML is designed to map unambiguously to a hash table. -> TOML should be easy to parse into data structures in a wide variety of -> languages. - -TOML is very similar to INI, but with some extra goodies. - -Anyway, there are two **table**s in this file: `package` and `bin`. The first -tells Cargo metadata about your package. The second tells Cargo that we're -interested in building a binary, not a library (though we could do both!), as -well as what it is named. - -Once you have this file in place, we should be ready to build! Try this: - -```{bash} -$ cargo build - Compiling hello_world v0.0.1 (file:///home/yourname/projects/hello_world) -$ ./target/hello_world -Hello, world! -``` - -Bam! We build our project with `cargo build`, and run it with -`./target/hello_world`. This hasn't bought us a whole lot over our simple use -of `rustc`, but think about the future: when our project has more than one -file, we would need to call `rustc` more than once, and pass it a bunch of options to -tell it to build everything together. With Cargo, as our project grows, we can -just `cargo build` and it'll work the right way. - -You'll also notice that Cargo has created a new file: `Cargo.lock`. - -```toml -[root] -name = "hello_world" -version = "0.0.1" -``` - -This file is used by Cargo to keep track of dependencies in your application. -Right now, we don't have any, so it's a bit sparse. You won't ever need -to touch this file yourself, just let Cargo handle it. - -That's it! We've successfully built `hello_world` with Cargo. Even though our -program is simple, it's using much of the real tooling that you'll use for the -rest of your Rust career. - -Now that you've got the tools down, let's actually learn more about the Rust -language itself. These are the basics that will serve you well through the rest -of your time with Rust. - -# Variable bindings - -The first thing we'll learn about are 'variable bindings.' They look like this: - -```{rust} -fn main() { - let x = 5; -} -``` - -Putting `fn main() {` in each example is a bit tedious, so we'll leave that out -in the future. If you're following along, make sure to edit your `main()` -function, rather than leaving it off. Otherwise, you'll get an error. - -In many languages, this is called a 'variable.' But Rust's variable bindings -have a few tricks up their sleeves. Rust has a very powerful feature called -'pattern matching' that we'll get into detail with later, but the left -hand side of a `let` expression is a full pattern, not just a variable name. -This means we can do things like: - -```{rust} -let (x, y) = (1, 2); -``` - -After this expression is evaluated, `x` will be one, and `y` will be two. -Patterns are really powerful, but this is about all we can do with them so far. -So let's just keep this in the back of our minds as we go forward. - -Rust is a statically typed language, which means that we specify our types up -front. So why does our first example compile? Well, Rust has this thing called -"type inference." If it can figure out what the type of something is, Rust -doesn't require you to actually type it out. - -We can add the type if we want to, though. Types come after a colon (`:`): - -```{rust} -let x: i32 = 5; -``` - -If I asked you to read this out loud to the rest of the class, you'd say "`x` -is a binding with the type `i32` and the value `five`." - -In future examples, we may annotate the type in a comment. The examples will -look like this: - -```{rust} -fn main() { - let x = 5; // x: i32 -} -``` - -Note the similarities between this annotation and the syntax you use with `let`. -Including these kinds of comments is not idiomatic Rust, but we'll occasionally -include them to help you understand what the types that Rust infers are. - -By default, bindings are **immutable**. This code will not compile: - -```{ignore} -let x = 5; -x = 10; -``` - -It will give you this error: - -```text -error: re-assignment of immutable variable `x` - x = 10; - ^~~~~~~ -``` - -If you want a binding to be mutable, you can use `mut`: - -```{rust} -let mut x = 5; // mut x: i32 -x = 10; -``` - -There is no single reason that bindings are immutable by default, but we can -think about it through one of Rust's primary focuses: safety. If you forget to -say `mut`, the compiler will catch it, and let you know that you have mutated -something you may not have intended to mutate. If bindings were mutable by -default, the compiler would not be able to tell you this. If you _did_ intend -mutation, then the solution is quite easy: add `mut`. - -There are other good reasons to avoid mutable state when possible, but they're -out of the scope of this guide. In general, you can often avoid explicit -mutation, and so it is preferable in Rust. That said, sometimes, mutation is -what you need, so it's not verboten. - -Let's get back to bindings. Rust variable bindings have one more aspect that -differs from other languages: bindings are required to be initialized with a -value before you're allowed to use them. If we try... - -```{ignore} -let x; -``` - -...we'll get an error: - -```text -src/main.rs:2:9: 2:10 error: cannot determine a type for this local variable: unconstrained type -src/main.rs:2 let x; - ^ -``` - -Giving it a type will compile, though: - -```{rust} -let x: i32; -``` - -Let's try it out. Change your `src/main.rs` file to look like this: - -```{rust} -fn main() { - let x: i32; - - println!("Hello world!"); -} -``` - -You can use `cargo build` on the command line to build it. You'll get a warning, -but it will still print "Hello, world!": - -```text - Compiling hello_world v0.0.1 (file:///home/you/projects/hello_world) -src/main.rs:2:9: 2:10 warning: unused variable: `x`, #[warn(unused_variable)] on by default -src/main.rs:2 let x: i32; - ^ -``` - -Rust warns us that we never use the variable binding, but since we never use it, -no harm, no foul. Things change if we try to actually use this `x`, however. Let's -do that. Change your program to look like this: - -```{rust,ignore} -fn main() { - let x: i32; - - println!("The value of x is: {}", x); -} -``` - -And try to build it. You'll get an error: - -```{bash} -$ cargo build - Compiling hello_world v0.0.1 (file:///home/you/projects/hello_world) -src/main.rs:4:39: 4:40 error: use of possibly uninitialized variable: `x` -src/main.rs:4 println!("The value of x is: {}", x); - ^ -note: in expansion of format_args! -<std macros>:2:23: 2:77 note: expansion site -<std macros>:1:1: 3:2 note: in expansion of println! -src/main.rs:4:5: 4:42 note: expansion site -error: aborting due to previous error -Could not compile `hello_world`. -``` - -Rust will not let us use a value that has not been initialized. Next, let's -talk about this stuff we've added to `println!`. - -If you include two curly braces (`{}`, some call them moustaches...) in your -string to print, Rust will interpret this as a request to interpolate some sort -of value. **String interpolation** is a computer science term that means "stick -in the middle of a string." We add a comma, and then `x`, to indicate that we -want `x` to be the value we're interpolating. The comma is used to separate -arguments we pass to functions and macros, if you're passing more than one. - -When you just use the curly braces, Rust will attempt to display the -value in a meaningful way by checking out its type. If you want to specify the -format in a more detailed manner, there are a [wide number of options -available](std/fmt/index.html). For now, we'll just stick to the default: -integers aren't very complicated to print. - -# `if` - -Rust's take on `if` is not particularly complex, but it's much more like the -`if` you'll find in a dynamically typed language than in a more traditional -systems language. So let's talk about it, to make sure you grasp the nuances. - -`if` is a specific form of a more general concept, the 'branch.' The name comes -from a branch in a tree: a decision point, where depending on a choice, -multiple paths can be taken. - -In the case of `if`, there is one choice that leads down two paths: - -```rust -let x = 5; - -if x == 5 { - println!("x is five!"); -} -``` - -If we changed the value of `x` to something else, this line would not print. -More specifically, if the expression after the `if` evaluates to `true`, then -the block is executed. If it's `false`, then it is not. - -If you want something to happen in the `false` case, use an `else`: - -```{rust} -let x = 5; - -if x == 5 { - println!("x is five!"); -} else { - println!("x is not five :("); -} -``` - -This is all pretty standard. However, you can also do this: - - -```{rust} -let x = 5; - -let y = if x == 5 { - 10 -} else { - 15 -}; // y: i32 -``` - -Which we can (and probably should) write like this: - -```{rust} -let x = 5; - -let y = if x == 5 { 10 } else { 15 }; // y: i32 -``` - -This reveals two interesting things about Rust: it is an expression-based -language, and semicolons are different from semicolons in other 'curly brace -and semicolon'-based languages. These two things are related. - -## Expressions vs. Statements - -Rust is primarily an expression based language. There are only two kinds of -statements, and everything else is an expression. - -So what's the difference? Expressions return a value, and statements do not. -In many languages, `if` is a statement, and therefore, `let x = if ...` would -make no sense. But in Rust, `if` is an expression, which means that it returns -a value. We can then use this value to initialize the binding. - -Speaking of which, bindings are a kind of the first of Rust's two statements. -The proper name is a **declaration statement**. So far, `let` is the only kind -of declaration statement we've seen. Let's talk about that some more. - -In some languages, variable bindings can be written as expressions, not just -statements. Like Ruby: - -```{ruby} -x = y = 5 -``` - -In Rust, however, using `let` to introduce a binding is _not_ an expression. The -following will produce a compile-time error: - -```{ignore} -let x = (let y = 5); // expected identifier, found keyword `let` -``` - -The compiler is telling us here that it was expecting to see the beginning of -an expression, and a `let` can only begin a statement, not an expression. - -Note that assigning to an already-bound variable (e.g. `y = 5`) is still an -expression, although its value is not particularly useful. Unlike C, where an -assignment evaluates to the assigned value (e.g. `5` in the previous example), -in Rust the value of an assignment is the unit type `()` (which we'll cover later). - -The second kind of statement in Rust is the **expression statement**. Its -purpose is to turn any expression into a statement. In practical terms, Rust's -grammar expects statements to follow other statements. This means that you use -semicolons to separate expressions from each other. This means that Rust -looks a lot like most other languages that require you to use semicolons -at the end of every line, and you will see semicolons at the end of almost -every line of Rust code you see. - -What is this exception that makes us say 'almost?' You saw it already, in this -code: - -```{rust} -let x = 5; - -let y: i32 = if x == 5 { 10 } else { 15 }; -``` - -Note that I've added the type annotation to `y`, to specify explicitly that I -want `y` to be an integer. - -This is not the same as this, which won't compile: - -```{ignore} -let x = 5; - -let y: i32 = if x == 5 { 10; } else { 15; }; -``` - -Note the semicolons after the 10 and 15. Rust will give us the following error: - -```text -error: mismatched types: expected `i32` but found `()` (expected i32 but found ()) -``` - -We expected an integer, but we got `()`. `()` is pronounced 'unit', and is a -special type in Rust's type system. In Rust, `()` is _not_ a valid value for a -variable of type `i32`. It's only a valid value for variables of the type `()`, -which aren't very useful. Remember how we said statements don't return a value? -Well, that's the purpose of unit in this case. The semicolon turns any -expression into a statement by throwing away its value and returning unit -instead. - -There's one more time in which you won't see a semicolon at the end of a line -of Rust code. For that, we'll need our next concept: functions. - -# Functions - -You've already seen one function so far, the `main` function: - -```{rust} -fn main() { -} -``` - -This is the simplest possible function declaration. As we mentioned before, -`fn` says 'this is a function,' followed by the name, some parentheses because -this function takes no arguments, and then some curly braces to indicate the -body. Here's a function named `foo`: - -```{rust} -fn foo() { -} -``` - -So, what about taking arguments? Here's a function that prints a number: - -```{rust} -fn print_number(x: i32) { - println!("x is: {}", x); -} -``` - -Here's a complete program that uses `print_number`: - -```{rust} -fn main() { - print_number(5); -} - -fn print_number(x: i32) { - println!("x is: {}", x); -} -``` - -As you can see, function arguments work very similar to `let` declarations: -you add a type to the argument name, after a colon. - -Here's a complete program that adds two numbers together and prints them: - -```{rust} -fn main() { - print_sum(5, 6); -} - -fn print_sum(x: i32, y: i32) { - println!("sum is: {}", x + y); -} -``` - -You separate arguments with a comma, both when you call the function, as well -as when you declare it. - -Unlike `let`, you _must_ declare the types of function arguments. This does -not work: - -```{ignore} -fn print_number(x, y) { - println!("x is: {}", x + y); -} -``` - -You get this error: - -```text -hello.rs:5:18: 5:19 error: expected `:` but found `,` -hello.rs:5 fn print_number(x, y) { -``` - -This is a deliberate design decision. While full-program inference is possible, -languages which have it, like Haskell, often suggest that documenting your -types explicitly is a best-practice. We agree that forcing functions to declare -types while allowing for inference inside of function bodies is a wonderful -sweet spot between full inference and no inference. - -What about returning a value? Here's a function that adds one to an integer: - -```{rust} -fn add_one(x: i32) -> i32 { - x + 1 -} -``` - -Rust functions return exactly one value, and you declare the type after an -'arrow', which is a dash (`-`) followed by a greater-than sign (`>`). - -You'll note the lack of a semicolon here. If we added it in: - -```{ignore} -fn add_one(x: i32) -> i32 { - x + 1; -} -``` - -We would get an error: - -```text -error: not all control paths return a value -fn add_one(x: i32) -> i32 { - x + 1; -} - -help: consider removing this semicolon: - x + 1; - ^ -``` - -Remember our earlier discussions about semicolons and `()`? Our function claims -to return an `i32`, but with a semicolon, it would return `()` instead. Rust -realizes this probably isn't what we want, and suggests removing the semicolon. - -This is very much like our `if` statement before: the result of the block -(`{}`) is the value of the expression. Other expression-oriented languages, -such as Ruby, work like this, but it's a bit unusual in the systems programming -world. When people first learn about this, they usually assume that it -introduces bugs. But because Rust's type system is so strong, and because unit -is its own unique type, we have never seen an issue where adding or removing a -semicolon in a return position would cause a bug. - -But what about early returns? Rust does have a keyword for that, `return`: - -```{rust} -fn foo(x: i32) -> i32 { - if x < 5 { return x; } - - x + 1 -} -``` - -Using a `return` as the last line of a function works, but is considered poor -style: - -```{rust} -fn foo(x: i32) -> i32 { - if x < 5 { return x; } - - return x + 1; -} -``` - -There are some additional ways to define functions, but they involve features -that we haven't learned about yet, so let's just leave it at that for now. - - -# Comments - -Now that we have some functions, it's a good idea to learn about comments. -Comments are notes that you leave to other programmers to help explain things -about your code. The compiler mostly ignores them. - -Rust has two kinds of comments that you should care about: **line comment**s -and **doc comment**s. - -```{rust} -// Line comments are anything after '//' and extend to the end of the line. - -let x = 5; // this is also a line comment. - -// If you have a long explanation for something, you can put line comments next -// to each other. Put a space between the // and your comment so that it's -// more readable. -``` - -The other kind of comment is a doc comment. Doc comments use `///` instead of -`//`, and support Markdown notation inside: - -```{rust} -/// `hello` is a function that prints a greeting that is personalized based on -/// the name given. -/// -/// # Arguments -/// -/// * `name` - The name of the person you'd like to greet. -/// -/// # Example -/// -/// ```rust -/// let name = "Steve"; -/// hello(name); // prints "Hello, Steve!" -/// ``` -fn hello(name: &str) { - println!("Hello, {}!", name); -} -``` - -When writing doc comments, adding sections for any arguments, return values, -and providing some examples of usage is very, very helpful. - -You can use the [`rustdoc`](rustdoc.html) tool to generate HTML documentation -from these doc comments. - -# Compound Data Types - -Rust, like many programming languages, has a number of different data types -that are built-in. You've already done some simple work with integers and -strings, but next, let's talk about some more complicated ways of storing data. - -## Tuples - -The first compound data type we're going to talk about are called **tuple**s. -Tuples are an ordered list of a fixed size. Like this: - -```rust -let x = (1, "hello"); -``` - -The parentheses and commas form this two-length tuple. Here's the same code, but -with the type annotated: - -```rust -let x: (i32, &str) = (1, "hello"); -``` - -As you can see, the type of a tuple looks just like the tuple, but with each -position having a type name rather than the value. Careful readers will also -note that tuples are heterogeneous: we have an `i32` and a `&str` in this tuple. -You haven't seen `&str` as a type before, and we'll discuss the details of -strings later. In systems programming languages, strings are a bit more complex -than in other languages. For now, just read `&str` as "a string slice," and -we'll learn more soon. - -You can access the fields in a tuple through a **destructuring let**. Here's -an example: - -```rust -let (x, y, z) = (1, 2, 3); - -println!("x is {}", x); -``` - -Remember before when I said the left-hand side of a `let` statement was more -powerful than just assigning a binding? Here we are. We can put a pattern on -the left-hand side of the `let`, and if it matches up to the right-hand side, -we can assign multiple bindings at once. In this case, `let` 'destructures,' -or 'breaks up,' the tuple, and assigns the bits to three bindings. - -This pattern is very powerful, and we'll see it repeated more later. - -There are also a few things you can do with a tuple as a whole, without -destructuring. You can assign one tuple into another, if they have the same -arity and contained types. - -```rust -let mut x = (1, 2); // x: (i32, i32) -let y = (2, 3); // y: (i32, i32) - -x = y; -``` - -You can also check for equality with `==`. Again, this will only compile if the -tuples have the same type. - -```rust -let x = (1, 2, 3); -let y = (2, 2, 4); - -if x == y { - println!("yes"); -} else { - println!("no"); -} -``` - -This will print `no`, because some of the values aren't equal. - -One other use of tuples is to return multiple values from a function: - -```rust -fn next_two(x: i32) -> (i32, i32) { (x + 1, x + 2) } - -fn main() { - let (x, y) = next_two(5); - println!("x, y = {}, {}", x, y); -} -``` - -Even though Rust functions can only return one value, a tuple _is_ one value, -that happens to be made up of more than one value. You can also see in this example how you -can destructure a pattern returned by a function, as well. - -Tuples are a very simple data structure, and so are not often what you want. -Let's move on to their bigger sibling, structs. - -## Structs - -A struct is another form of a 'record type,' just like a tuple. There's a -difference: structs give each element that they contain a name, called a -'field' or a 'member.' Check it out: - -```rust -struct Point { - x: i32, - y: i32, -} - -fn main() { - let origin = Point { x: 0, y: 0 }; // origin: Point - - println!("The origin is at ({}, {})", origin.x, origin.y); -} -``` - -There's a lot going on here, so let's break it down. We declare a struct with -the `struct` keyword, and then with a name. By convention, structs begin with a -capital letter and are also camel cased: `PointInSpace`, not `Point_In_Space`. - -We can create an instance of our struct via `let`, as usual, but we use a `key: -value` style syntax to set each field. The order doesn't need to be the same as -in the original declaration. - -Finally, because fields have names, we can access the field through dot -notation: `origin.x`. - -The values in structs are immutable by default, like other bindings in Rust. -Use `mut` to make them mutable: - -```{rust} -struct Point { - x: i32, - y: i32, -} - -fn main() { - let mut point = Point { x: 0, y: 0 }; - - point.x = 5; - - println!("The point is at ({}, {})", point.x, point.y); -} -``` - -This will print `The point is at (5, 0)`. - -## Tuple Structs and Newtypes - -Rust has another data type that's like a hybrid between a tuple and a struct, -called a **tuple struct**. Tuple structs do have a name, but their fields -don't: - - -```{rust} -struct Color(i32, i32, i32); -struct Point(i32, i32, i32); -``` - -These two will not be equal, even if they have the same values: - -```{rust} -# struct Color(i32, i32, i32); -# struct Point(i32, i32, i32); -let black = Color(0, 0, 0); -let origin = Point(0, 0, 0); -``` - -It is almost always better to use a struct than a tuple struct. We would write -`Color` and `Point` like this instead: - -```{rust} -struct Color { - red: i32, - blue: i32, - green: i32, -} - -struct Point { - x: i32, - y: i32, - z: i32, -} -``` - -Now, we have actual names, rather than positions. Good names are important, -and with a struct, we have actual names. - -There _is_ one case when a tuple struct is very useful, though, and that's a -tuple struct with only one element. We call this a 'newtype,' because it lets -you create a new type that's a synonym for another one: - -```{rust} -struct Inches(i32); - -let length = Inches(10); - -let Inches(integer_length) = length; -println!("length is {} inches", integer_length); -``` - -As you can see here, you can extract the inner integer type through a -destructuring `let`. - -## Enums - -Finally, Rust has a "sum type", an **enum**. Enums are an incredibly useful -feature of Rust, and are used throughout the standard library. This is an enum -that is provided by the Rust standard library: - -```{rust} -enum Ordering { - Less, - Equal, - Greater, -} -``` - -An `Ordering` can only be _one_ of `Less`, `Equal`, or `Greater` at any given -time. - -Because `Ordering` is provided by the standard library, we can use the `use` -keyword to use it in our code. We'll learn more about `use` later, but it's -used to bring names into scope. - -Here's an example of how to use `Ordering`: - -```{rust} -use std::cmp::Ordering; - -fn cmp(a: i32, b: i32) -> Ordering { - if a < b { Ordering::Less } - else if a > b { Ordering::Greater } - else { Ordering::Equal } -} - -fn main() { - let x = 5; - let y = 10; - - let ordering = cmp(x, y); // ordering: Ordering - - if ordering == Ordering::Less { - println!("less"); - } else if ordering == Ordering::Greater { - println!("greater"); - } else if ordering == Ordering::Equal { - println!("equal"); - } -} -``` - -There's a symbol here we haven't seen before: the double colon (`::`). -This is used to indicate a namespace. In this case, `Ordering` lives in -the `cmp` submodule of the `std` module. We'll talk more about modules -later in the guide. For now, all you need to know is that you can `use` -things from the standard library if you need them. - -Okay, let's talk about the actual code in the example. `cmp` is a function that -compares two things, and returns an `Ordering`. We return either -`Ordering::Less`, `Ordering::Greater`, or `Ordering::Equal`, depending on if -the two values are greater, less, or equal. Note that each variant of the -`enum` is namespaced under the `enum` itself: it's `Ordering::Greater` not -`Greater`. - -The `ordering` variable has the type `Ordering`, and so contains one of the -three values. We can then do a bunch of `if`/`else` comparisons to check which -one it is. However, repeated `if`/`else` comparisons get quite tedious. Rust -has a feature that not only makes them nicer to read, but also makes sure that -you never miss a case. Before we get to that, though, let's talk about another -kind of enum: one with values. - -This enum has two variants, one of which has a value: - -```{rust} -enum OptionalInt { - Value(i32), - Missing, -} -``` - -This enum represents an `i32` that we may or may not have. In the `Missing` -case, we have no value, but in the `Value` case, we do. This enum is specific -to `i32`s, though. We can make it usable by any type, but we haven't quite -gotten there yet! - -You can also have any number of values in an enum: - -```{rust} -enum OptionalColor { - Color(i32, i32, i32), - Missing, -} -``` - -And you can also have something like this: - -```{rust} -enum StringResult { - StringOK(String), - ErrorReason(String), -} -``` -Where a `StringResult` is either a `StringResult::StringOK`, with the result of -a computation, or an `StringResult::ErrorReason` with a `String` explaining -what caused the computation to fail. These kinds of `enum`s are actually very -useful and are even part of the standard library. - -Here is an example of using our `StringResult`: - -```rust -enum StringResult { - StringOK(String), - ErrorReason(String), -} - -fn respond(greeting: &str) -> StringResult { - if greeting == "Hello" { - StringResult::StringOK("Good morning!".to_string()) - } else { - StringResult::ErrorReason("I didn't understand you!".to_string()) - } -} -``` - -That's a lot of typing! We can use the `use` keyword to make it shorter: - -```rust -use StringResult::StringOK; -use StringResult::ErrorReason; - -enum StringResult { - StringOK(String), - ErrorReason(String), -} - -# fn main() {} - -fn respond(greeting: &str) -> StringResult { - if greeting == "Hello" { - StringOK("Good morning!".to_string()) - } else { - ErrorReason("I didn't understand you!".to_string()) - } -} -``` - -`use` declarations must come before anything else, which looks a little strange in this example, -since we `use` the variants before we define them. Anyway, in the body of `respond`, we can just -say `StringOK` now, rather than the full `StringResult::StringOK`. Importing variants can be -convenient, but can also cause name conflicts, so do this with caution. It's considered good style -to rarely import variants for this reason. - -As you can see, `enum`s with values are quite a powerful tool for data representation, -and can be even more useful when they're generic across types. Before we get to generics, -though, let's talk about how to use them with pattern matching, a tool that will -let us deconstruct this sum type (the type theory term for enums) in a very elegant -way and avoid all these messy `if`/`else`s. - -# Match - -Often, a simple `if`/`else` isn't enough, because you have more than two -possible options. Also, `else` conditions can get incredibly complicated, so -what's the solution? - -Rust has a keyword, `match`, that allows you to replace complicated `if`/`else` -groupings with something more powerful. Check it out: - -```{rust} -let x = 5; - -match x { - 1 => println!("one"), - 2 => println!("two"), - 3 => println!("three"), - 4 => println!("four"), - 5 => println!("five"), - _ => println!("something else"), -} -``` - -`match` takes an expression and then branches based on its value. Each 'arm' of -the branch is of the form `val => expression`. When the value matches, that arm's -expression will be evaluated. It's called `match` because of the term 'pattern -matching', which `match` is an implementation of. - -So what's the big advantage here? Well, there are a few. First of all, `match` -enforces 'exhaustiveness checking'. Do you see that last arm, the one with the -underscore (`_`)? If we remove that arm, Rust will give us an error: - -```text -error: non-exhaustive patterns: `_` not covered -``` - -In other words, Rust is trying to tell us we forgot a value. Because `x` is an -integer, Rust knows that it can have a number of different values – for example, -`6`. Without the `_`, however, there is no arm that could match, and so Rust refuses -to compile. `_` acts like a 'catch-all arm'. If none of the other arms match, -the arm with `_` will, and since we have this catch-all arm, we now have an arm -for every possible value of `x`, and so our program will compile successfully. - -`match` statements also destructure enums, as well. Remember this code from the -section on enums? - -```{rust} -use std::cmp::Ordering; - -fn cmp(a: i32, b: i32) -> Ordering { - if a < b { Ordering::Less } - else if a > b { Ordering::Greater } - else { Ordering::Equal } -} - -fn main() { - let x = 5; - let y = 10; - - let ordering = cmp(x, y); - - if ordering == Ordering::Less { - println!("less"); - } else if ordering == Ordering::Greater { - println!("greater"); - } else if ordering == Ordering::Equal { - println!("equal"); - } -} -``` - -We can re-write this as a `match`: - -```{rust} -use std::cmp::Ordering; - -fn cmp(a: i32, b: i32) -> Ordering { - if a < b { Ordering::Less } - else if a > b { Ordering::Greater } - else { Ordering::Equal } -} - -fn main() { - let x = 5; - let y = 10; - - match cmp(x, y) { - Ordering::Less => println!("less"), - Ordering::Greater => println!("greater"), - Ordering::Equal => println!("equal"), - } -} -``` - -This version has way less noise, and it also checks exhaustively to make sure -that we have covered all possible variants of `Ordering`. With our `if`/`else` -version, if we had forgotten the `Greater` case, for example, our program would -have happily compiled. If we forget in the `match`, it will not. Rust helps us -make sure to cover all of our bases. - -`match` expressions also allow us to get the values contained in an `enum` -(also known as destructuring) as follows: - -```{rust} -enum OptionalInt { - Value(i32), - Missing, -} - -fn main() { - let x = OptionalInt::Value(5); - let y = OptionalInt::Missing; - - match x { - OptionalInt::Value(n) => println!("x is {}", n), - OptionalInt::Missing => println!("x is missing!"), - } - - match y { - OptionalInt::Value(n) => println!("y is {}", n), - OptionalInt::Missing => println!("y is missing!"), - } -} -``` - -That is how you can get and use the values contained in `enum`s. -It can also allow us to handle errors or unexpected computations; for example, a -function that is not guaranteed to be able to compute a result (an `i32` here) -could return an `OptionalInt`, and we would handle that value with a `match`. -As you can see, `enum` and `match` used together are quite useful! - -`match` is also an expression, which means we can use it on the right-hand -side of a `let` binding or directly where an expression is used. We could -also implement the previous example like this: - -```{rust} -use std::cmp::Ordering; - -fn cmp(a: i32, b: i32) -> Ordering { - if a < b { Ordering::Less } - else if a > b { Ordering::Greater } - else { Ordering::Equal } -} - -fn main() { - let x = 5; - let y = 10; - - println!("{}", match cmp(x, y) { - Ordering::Less => "less", - Ordering::Greater => "greater", - Ordering::Equal => "equal", - }); -} -``` - -Sometimes, it's a nice pattern. - -# Looping - -Looping is the last basic construct that we haven't learned yet in Rust. Rust has -two main looping constructs: `for` and `while`. - -## `for` - -The `for` loop is used to loop a particular number of times. Rust's `for` loops -work a bit differently than in other systems languages, however. Rust's `for` -loop doesn't look like this "C-style" `for` loop: - -```{c} -for (x = 0; x < 10; x++) { - printf( "%d\n", x ); -} -``` - -Instead, it looks like this: - -```{rust} -for x in range(0, 10) { - println!("{}", x); // x: i32 -} -``` - -In slightly more abstract terms, - -```{ignore} -for var in expression { - code -} -``` - -The expression is an iterator, which we will discuss in more depth later in the -guide. The iterator gives back a series of elements. Each element is one -iteration of the loop. That value is then bound to the name `var`, which is -valid for the loop body. Once the body is over, the next value is fetched from -the iterator, and we loop another time. When there are no more values, the -`for` loop is over. - -In our example, `range` is a function that takes a start and an end position, -and gives an iterator over those values. The upper bound is exclusive, though, -so our loop will print `0` through `9`, not `10`. - -Rust does not have the "C-style" `for` loop on purpose. Manually controlling -each element of the loop is complicated and error prone, even for experienced C -developers. - -We'll talk more about `for` when we cover **iterator**s, later in the Guide. - -## `while` - -The other kind of looping construct in Rust is the `while` loop. It looks like -this: - -```{rust} -let mut x = 5u; // mut x: uint -let mut done = false; // mut done: bool - -while !done { - x += x - 3; - println!("{}", x); - if x % 5 == 0 { done = true; } -} -``` - -`while` loops are the correct choice when you're not sure how many times -you need to loop. - -If you need an infinite loop, you may be tempted to write this: - -```{rust,ignore} -while true { -``` - -However, Rust has a dedicated keyword, `loop`, to handle this case: - -```{rust,ignore} -loop { -``` - -Rust's control-flow analysis treats this construct differently than a -`while true`, since we know that it will always loop. The details of what -that _means_ aren't super important to understand at this stage, but in -general, the more information we can give to the compiler, the better it -can do with safety and code generation, so you should always prefer -`loop` when you plan to loop infinitely. - -## Ending iteration early - -Let's take a look at that `while` loop we had earlier: - -```{rust} -let mut x = 5u; -let mut done = false; - -while !done { - x += x - 3; - println!("{}", x); - if x % 5 == 0 { done = true; } -} -``` - -We had to keep a dedicated `mut` boolean variable binding, `done`, to know -when we should exit out of the loop. Rust has two keywords to help us with -modifying iteration: `break` and `continue`. - -In this case, we can write the loop in a better way with `break`: - -```{rust} -let mut x = 5u; - -loop { - x += x - 3; - println!("{}", x); - if x % 5 == 0 { break; } -} -``` - -We now loop forever with `loop` and use `break` to break out early. - -`continue` is similar, but instead of ending the loop, goes to the next -iteration. This will only print the odd numbers: - -```{rust} -for x in range(0, 10) { - if x % 2 == 0 { continue; } - - println!("{}", x); -} -``` - -Both `continue` and `break` are valid in both kinds of loops. - -# Strings - -Strings are an important concept for any programmer to master. Rust's string -handling system is a bit different from other languages, due to its systems -focus. Any time you have a data structure of variable size, things can get -tricky, and strings are a re-sizable data structure. That being said, Rust's -strings also work differently than in some other systems languages, such as C. - -Let's dig into the details. A **string** is a sequence of Unicode scalar values -encoded as a stream of UTF-8 bytes. All strings are guaranteed to be -validly encoded UTF-8 sequences. Additionally, strings are not null-terminated -and can contain null bytes. - -Rust has two main types of strings: `&str` and `String`. - -The first kind is a `&str`. This is pronounced a 'string slice.' String literals -are of the type `&str`: - -```{rust} -let string = "Hello there."; // string: &str -``` - -This string is statically allocated, meaning that it's saved inside our -compiled program, and exists for the entire duration it runs. The `string` -binding is a reference to this statically allocated string. String slices -have a fixed size, and cannot be mutated. - -A `String`, on the other hand, is an in-memory string. This string is -growable, and is also guaranteed to be UTF-8. - -```{rust} -let mut s = "Hello".to_string(); // mut s: String -println!("{}", s); - -s.push_str(", world."); -println!("{}", s); -``` - -You can get a `&str` view into a `String` with the `as_slice()` method: - -```{rust} -fn takes_slice(slice: &str) { - println!("Got: {}", slice); -} - -fn main() { - let s = "Hello".to_string(); - takes_slice(s.as_slice()); -} -``` - -To compare a String to a constant string, prefer `as_slice()`... - -```{rust} -fn compare(string: String) { - if string.as_slice() == "Hello" { - println!("yes"); - } -} -``` - -... over `to_string()`: - -```{rust} -fn compare(string: String) { - if string == "Hello".to_string() { - println!("yes"); - } -} -``` - -Viewing a `String` as a `&str` is cheap, but converting the `&str` to a -`String` involves allocating memory. No reason to do that unless you have to! - -That's the basics of strings in Rust! They're probably a bit more complicated -than you are used to, if you come from a scripting language, but when the -low-level details matter, they really matter. Just remember that `String`s -allocate memory and control their data, while `&str`s are a reference to -another string, and you'll be all set. - -# Arrays, Vectors, and Slices - -Like many programming languages, Rust has list types to represent a sequence of -things. The most basic is the **array**, a fixed-size list of elements of the -same type. By default, arrays are immutable. - -```{rust} -let a = [1, 2, 3]; // a: [i32; 3] -let mut m = [1, 2, 3]; // mut m: [i32; 3] -``` - -There's a shorthand for initializing each element of an array to the same -value. In this example, each element of `a` will be initialized to `0`: - -```{rust} -let a = [0; 20]; // a: [i32; 20] -``` - -Arrays have type `[T; N]`. We'll talk about this `T` notation later, when we -cover generics. - -You can get the number of elements in an array `a` with `a.len()`, and use -`a.iter()` to iterate over them with a for loop. This code will print each -number in order: - -```{rust} -let a = [1, 2, 3]; - -println!("a has {} elements", a.len()); -for e in a.iter() { - println!("{}", e); -} -``` - -You can access a particular element of an array with **subscript notation**: - -```{rust} -let names = ["Graydon", "Brian", "Niko"]; // names: [&str; 3] - -println!("The second name is: {}", names[1]); -``` - -Subscripts start at zero, like in most programming languages, so the first name -is `names[0]` and the second name is `names[1]`. The above example prints -`The second name is: Brian`. If you try to use a subscript that is not in the -array, you will get an error: array access is bounds-checked at run-time. Such -errant access is the source of many bugs in other systems programming -languages. - -A **vector** is a dynamic or "growable" array, implemented as the standard -library type [`Vec<T>`](std/vec/) (we'll talk about what the `<T>` means -later). Vectors are to arrays what `String` is to `&str`. You can create them -with the `vec!` macro: - -```{rust} -let v = vec![1, 2, 3]; // v: Vec<i32> -``` - -(Notice that unlike the `println!` macro we've used in the past, we use square -brackets `[]` with `vec!`. Rust allows you to use either in either situation, -this is just convention.) - -You can get the length of, iterate over, and subscript vectors just like -arrays. In addition, (mutable) vectors can grow automatically: - -```{rust} -let mut nums = vec![1, 2, 3]; // mut nums: Vec<i32> - -nums.push(4); - -println!("The length of nums is now {}", nums.len()); // Prints 4 -``` - -Vectors have many more useful methods. - -A **slice** is a reference to (or "view" into) an array. They are useful for -allowing safe, efficient access to a portion of an array without copying. For -example, you might want to reference just one line of a file read into memory. -By nature, a slice is not created directly, but from an existing variable. -Slices have a length, can be mutable or not, and in many ways behave like -arrays: - -```{rust} -let a = [0, 1, 2, 3, 4]; -let middle = a.slice(1, 4); // A slice of a: just the elements [1,2,3] - -for e in middle.iter() { - println!("{}", e); // Prints 1, 2, 3 -} -``` - -You can also take a slice of a vector, `String`, or `&str`, because they are -backed by arrays. Slices have type `&[T]`, which we'll talk about when we cover -generics. - -We have now learned all of the most basic Rust concepts. We're ready to start -building our guessing game, we just need to know one last thing: how to get -input from the keyboard. You can't have a guessing game without the ability to -guess! - -# Standard Input - -Getting input from the keyboard is pretty easy, but uses some things -we haven't seen before. Here's a simple program that reads some input, -and then prints it back out: - -```{rust,ignore} -fn main() { - println!("Type something!"); - - let input = std::io::stdin().read_line().ok().expect("Failed to read line"); - - println!("{}", input); -} -``` - -Let's go over these chunks, one by one: - -```{rust,ignore} -std::io::stdin(); -``` - -This calls a function, `stdin()`, that lives inside the `std::io` module. As -you can imagine, everything in `std` is provided by Rust, the 'standard -library.' We'll talk more about the module system later. - -Since writing the fully qualified name all the time is annoying, we can use -the `use` statement to import it in: - -```{rust} -use std::io::stdin; - -stdin(); -``` - -However, it's considered better practice to not import individual functions, but -to import the module, and only use one level of qualification: - -```{rust} -use std::io; - -io::stdin(); -``` - -Let's update our example to use this style: - -```{rust,ignore} -use std::io; - -fn main() { - println!("Type something!"); - - let input = io::stdin().read_line().ok().expect("Failed to read line"); - - println!("{}", input); -} -``` - -Next up: - -```{rust,ignore} -.read_line() -``` - -The `read_line()` method can be called on the result of `stdin()` to return -a full line of input. Nice and easy. - -```{rust,ignore} -.ok().expect("Failed to read line"); -``` - -Do you remember this code? - -```{rust} -enum OptionalInt { - Value(i32), - Missing, -} - -fn main() { - let x = OptionalInt::Value(5); - let y = OptionalInt::Missing; - - match x { - OptionalInt::Value(n) => println!("x is {}", n), - OptionalInt::Missing => println!("x is missing!"), - } - - match y { - OptionalInt::Value(n) => println!("y is {}", n), - OptionalInt::Missing => println!("y is missing!"), - } -} -``` - -We had to match each time to see if we had a value or not. In this case, -though, we _know_ that `x` has a `Value`, but `match` forces us to handle -the `missing` case. This is what we want 99% of the time, but sometimes, we -know better than the compiler. - -Likewise, `read_line()` does not return a line of input. It _might_ return a -line of input, though it might also fail to do so. This could happen if our program -isn't running in a terminal, but as part of a cron job, or some other context -where there's no standard input. Because of this, `read_line` returns a type -very similar to our `OptionalInt`: an `IoResult<T>`. We haven't talked about -`IoResult<T>` yet because it is the **generic** form of our `OptionalInt`. -Until then, you can think of it as being the same thing, just for any type – -not just `i32`s. - -Rust provides a method on these `IoResult<T>`s called `ok()`, which does the -same thing as our `match` statement but assumes that we have a valid value. -We then call `expect()` on the result, which will terminate our program if we -don't have a valid value. In this case, if we can't get input, our program -doesn't work, so we're okay with that. In most cases, we would want to handle -the error case explicitly. `expect()` allows us to give an error message if -this crash happens. - -We will cover the exact details of how all of this works later in the Guide. -For now, this gives you enough of a basic understanding to work with. - -Back to the code we were working on! Here's a refresher: - -```{rust,ignore} -use std::io; - -fn main() { - println!("Type something!"); - - let input = io::stdin().read_line().ok().expect("Failed to read line"); - - println!("{}", input); -} -``` - -With long lines like this, Rust gives you some flexibility with the whitespace. -We _could_ write the example like this: - -```{rust,ignore} -use std::io; - -fn main() { - println!("Type something!"); - - // here, we'll show the types at each step - - let input = io::stdin() // std::io::stdio::StdinReader - .read_line() // IoResult<String> - .ok() // Option<String> - .expect("Failed to read line"); // String - - println!("{}", input); -} -``` - -Sometimes, this makes things more readable – sometimes, less. Use your judgement -here. - -That's all you need to get basic input from the standard input! It's not too -complicated, but there are a number of small parts. - -# Guessing Game - -Okay! We've got the basics of Rust down. Let's write a bigger program. - -For our first project, we'll implement a classic beginner programming problem: -the guessing game. Here's how it works: Our program will generate a random -integer between one and a hundred. It will then prompt us to enter a guess. -Upon entering our guess, it will tell us if we're too low or too high. Once we -guess correctly, it will congratulate us. Sound good? - -## Set up - -Let's set up a new project. Go to your projects directory. Remember how we -had to create our directory structure and a `Cargo.toml` for `hello_world`? Cargo -has a command that does that for us. Let's give it a shot: - -```{bash} -$ cd ~/projects -$ cargo new guessing_game --bin -$ cd guessing_game -``` - -We pass the name of our project to `cargo new`, and then the `--bin` flag, -since we're making a binary, rather than a library. - -Check out the generated `Cargo.toml`: - -```toml -[package] - -name = "guessing_game" -version = "0.0.1" -authors = ["Your Name <you@example.com>"] -``` - -Cargo gets this information from your environment. If it's not correct, go ahead -and fix that. - -Finally, Cargo generated a "Hello, world!" for us. Check out `src/main.rs`: - -```{rust} -fn main() { - println!("Hello, world!") -} -``` - -Let's try compiling what Cargo gave us: - -```{bash} -$ cargo build - Compiling guessing_game v0.0.1 (file:///home/you/projects/guessing_game) -``` - -Excellent! Open up your `src/main.rs` again. We'll be writing all of -our code in this file. We'll talk about multiple-file projects later on in the -guide. - -Before we move on, let me show you one more Cargo command: `run`. `cargo run` -is kind of like `cargo build`, but it also then runs the produced executable. -Try it out: - -```bash -$ cargo run - Compiling guessing_game v0.0.1 (file:///home/you/projects/guessing_game) - Running `target/guessing_game` -Hello, world! -``` - -Great! The `run` command comes in handy when you need to rapidly iterate on a project. -Our game is just such a project, we need to quickly test each iteration before moving on to the next one. - -## Processing a Guess - -Let's get to it! The first thing we need to do for our guessing game is -allow our player to input a guess. Put this in your `src/main.rs`: - -```{rust,no_run} -use std::io; - -fn main() { - println!("Guess the number!"); - - println!("Please input your guess."); - - let input = io::stdin().read_line() - .ok() - .expect("Failed to read line"); - - println!("You guessed: {}", input); -} -``` - -You've seen this code before, when we talked about standard input. We -import the `std::io` module with `use`, and then our `main` function contains -our program's logic. We print a little message announcing the game, ask the -user to input a guess, get their input, and then print it out. - -Because we talked about this in the section on standard I/O, I won't go into -more details here. If you need a refresher, go re-read that section. - -## Generating a secret number - -Next, we need to generate a secret number. To do that, we need to use Rust's -random number generation, which we haven't talked about yet. Rust includes a -bunch of interesting functions in its standard library. If you need a bit of -code, it's possible that it's already been written for you! In this case, -we do know that Rust has random number generation, but we don't know how to -use it. - -Enter the docs. Rust has a page specifically to document the standard library. -You can find that page [here](std/index.html). There's a lot of information on -that page, but the best part is the search bar. Right up at the top, there's -a box that you can enter in a search term. The search is pretty primitive -right now, but is getting better all the time. If you type 'random' in that -box, the page will update to [this one](std/index.html?search=random). The very -first result is a link to [`std::rand::random`](std/rand/fn.random.html). If we -click on that result, we'll be taken to its documentation page. - -This page shows us a few things: the type signature of the function, some -explanatory text, and then an example. Let's try to modify our code to add in the -`random` function and see what happens: - -```{rust,ignore} -use std::io; -use std::rand; - -fn main() { - println!("Guess the number!"); - - let secret_number = (rand::random() % 100) + 1; // secret_number: i32 - - println!("The secret number is: {}", secret_number); - - println!("Please input your guess."); - - let input = io::stdin().read_line() - .ok() - .expect("Failed to read line"); - - - println!("You guessed: {}", input); -} -``` - -The first thing we changed was to `use std::rand`, as the docs -explained. We then added in a `let` expression to create a variable binding -named `secret_number`, and we printed out its result. - -Also, you may wonder why we are using `%` on the result of `rand::random()`. -This operator is called 'modulo', and it returns the remainder of a division. -By taking the modulo of the result of `rand::random()`, we're limiting the -values to be between 0 and 99. Then, we add one to the result, making it from 1 -to 100. Using modulo can give you a very, very small bias in the result, but -for this example, it is not important. - -Let's try to compile this using `cargo build`: - -```bash -$ cargo build - Compiling guessing_game v0.0.1 (file:///home/you/projects/guessing_game) -src/main.rs:7:26: 7:34 error: the type of this value must be known in this context -src/main.rs:7 let secret_number = (rand::random() % 100) + 1; - ^~~~~~~~ -error: aborting due to previous error -``` - -It didn't work! Rust says "the type of this value must be known in this -context." What's up with that? Well, as it turns out, `rand::random()` can -generate many kinds of random values, not just integers. And in this case, Rust -isn't sure what kind of value `random()` should generate. So we have to help -it. With number literals, we can just add an `i32` onto the end to tell Rust they're -integers, but that does not work with functions. There's a different syntax, -and it looks like this: - -```{rust,ignore} -rand::random::<i32>(); -``` - -This says "please give me a random `i32` value." We can change our code to use -this hint: - -```{rust,no_run} -use std::io; -use std::rand; - -fn main() { - println!("Guess the number!"); - - let secret_number = (rand::random::<i32>() % 100) + 1; - - println!("The secret number is: {}", secret_number); - - println!("Please input your guess."); - - let input = io::stdin().read_line() - .ok() - .expect("Failed to read line"); - - - println!("You guessed: {}", input); -} -``` - -Try running our new program a few times: - -```bash -$ cargo run - Compiling guessing_game v0.0.1 (file:///home/you/projects/guessing_game) - Running `target/guessing_game` -Guess the number! -The secret number is: 7 -Please input your guess. -4 -You guessed: 4 -$ ./target/guessing_game -Guess the number! -The secret number is: 83 -Please input your guess. -5 -You guessed: 5 -$ ./target/guessing_game -Guess the number! -The secret number is: -29 -Please input your guess. -42 -You guessed: 42 -``` - -Wait. Negative 29? We wanted a number between one and a hundred! We have two -options here: we can either ask `random()` to generate an unsigned integer, which -can only be positive, or we can use the `abs()` function. Let's go with the -unsigned integer approach. If we want a random positive number, we should ask for -a random positive number. Our code looks like this now: - -```{rust,no_run} -use std::io; -use std::rand; - -fn main() { - println!("Guess the number!"); - - let secret_number = (rand::random::<uint>() % 100u) + 1u; - - println!("The secret number is: {}", secret_number); - - println!("Please input your guess."); - - let input = io::stdin().read_line() - .ok() - .expect("Failed to read line"); - - - println!("You guessed: {}", input); -} -``` - -And trying it out: - -```bash -$ cargo run - Compiling guessing_game v0.0.1 (file:///home/you/projects/guessing_game) - Running `target/guessing_game` -Guess the number! -The secret number is: 57 -Please input your guess. -3 -You guessed: 3 -``` - -Great! Next up: let's compare our guess to the secret guess. - -## Comparing guesses - -If you remember, earlier in the guide, we made a `cmp` function that compared -two numbers. Let's add that in, along with a `match` statement to compare our -guess to the secret number: - -```{rust,ignore} -use std::io; -use std::rand; -use std::cmp::Ordering; - -fn main() { - println!("Guess the number!"); - - let secret_number = (rand::random::<uint>() % 100u) + 1u; - - println!("The secret number is: {}", secret_number); - - println!("Please input your guess."); - - let input = io::stdin().read_line() - .ok() - .expect("Failed to read line"); - - - println!("You guessed: {}", input); - - match cmp(input, secret_number) { - Ordering::Less => println!("Too small!"), - Ordering::Greater => println!("Too big!"), - Ordering::Equal => println!("You win!"), - } -} - -fn cmp(a: i32, b: i32) -> Ordering { - if a < b { Ordering::Less } - else if a > b { Ordering::Greater } - else { Ordering::Equal } -} -``` - -If we try to compile, we'll get some errors: - -```bash -$ cargo build - Compiling guessing_game v0.0.1 (file:///home/you/projects/guessing_game) -src/main.rs:20:15: 20:20 error: mismatched types: expected `i32` but found `collections::string::String` (expected i32 but found struct collections::string::String) -src/main.rs:20 match cmp(input, secret_number) { - ^~~~~ -src/main.rs:20:22: 20:35 error: mismatched types: expected `i32` but found `uint` (expected i32 but found uint) -src/main.rs:20 match cmp(input, secret_number) { - ^~~~~~~~~~~~~ -error: aborting due to 2 previous errors -``` - -This often happens when writing Rust programs, and is one of Rust's greatest -strengths. You try out some code, see if it compiles, and Rust tells you that -you've done something wrong. In this case, our `cmp` function works on integers, -but we've given it unsigned integers. In this case, the fix is easy, because -we wrote the `cmp` function! Let's change it to take `uint`s: - -```{rust,ignore} -use std::io; -use std::rand; -use std::cmp::Ordering; - -fn main() { - println!("Guess the number!"); - - let secret_number = (rand::random::<uint>() % 100u) + 1u; - - println!("The secret number is: {}", secret_number); - - println!("Please input your guess."); - - let input = io::stdin().read_line() - .ok() - .expect("Failed to read line"); - - - println!("You guessed: {}", input); - - match cmp(input, secret_number) { - Ordering::Less => println!("Too small!"), - Ordering::Greater => println!("Too big!"), - Ordering::Equal => println!("You win!"), - } -} - -fn cmp(a: uint, b: uint) -> Ordering { - if a < b { Ordering::Less } - else if a > b { Ordering::Greater } - else { Ordering::Equal } -} -``` - -And try compiling again: - -```bash -$ cargo build - Compiling guessing_game v0.0.1 (file:///home/you/projects/guessing_game) -src/main.rs:20:15: 20:20 error: mismatched types: expected `uint` but found `collections::string::String` (expected uint but found struct collections::string::String) -src/main.rs:20 match cmp(input, secret_number) { - ^~~~~ -error: aborting due to previous error -``` - -This error is similar to the last one: we expected to get a `uint`, but we got -a `String` instead! That's because our `input` variable is coming from the -standard input, and you can guess anything. Try it: - -```bash -$ ./target/guessing_game -Guess the number! -The secret number is: 73 -Please input your guess. -hello -You guessed: hello -``` - -Oops! Also, you'll note that we just ran our program even though it didn't compile. -This works because the older version we did successfully compile was still lying -around. Gotta be careful! - -Anyway, we have a `String`, but we need a `uint`. What to do? Well, there's -a function for that: - -```{rust,ignore} -let input = io::stdin().read_line() - .ok() - .expect("Failed to read line"); -let input_num: Option<uint> = input.parse(); -``` - -The `parse` function takes in a `&str` value and converts it into something. -We tell it what kind of something with a type hint. Remember our type hint with -`random()`? It looked like this: - -```{rust,ignore} -rand::random::<uint>(); -``` - -There's an alternate way of providing a hint too, and that's declaring the type -in a `let`: - -```{rust,ignore} -let x: uint = rand::random(); -``` - -In this case, we say `x` is a `uint` explicitly, so Rust is able to properly -tell `random()` what to generate. In a similar fashion, both of these work: - -```{rust,ignore} -let input_num = "5".parse::<uint>(); // input_num: Option<uint> -let input_num: Option<uint> = "5".parse(); // input_num: Option<uint> -``` - -Anyway, with us now converting our input to a number, our code looks like this: - -```{rust,ignore} -use std::io; -use std::rand; -use std::cmp::Ordering; - -fn main() { - println!("Guess the number!"); - - let secret_number = (rand::random::<uint>() % 100u) + 1u; - - println!("The secret number is: {}", secret_number); - - println!("Please input your guess."); - - let input = io::stdin().read_line() - .ok() - .expect("Failed to read line"); - let input_num: Option<uint> = input.parse(); - - println!("You guessed: {}", input_num); - - match cmp(input_num, secret_number) { - Ordering::Less => println!("Too small!"), - Ordering::Greater => println!("Too big!"), - Ordering::Equal => println!("You win!"), - } -} - -fn cmp(a: uint, b: uint) -> Ordering { - if a < b { Ordering::Less } - else if a > b { Ordering::Greater } - else { Ordering::Equal } -} -``` - -Let's try it out! - -```bash -$ cargo build - Compiling guessing_game v0.0.1 (file:///home/you/projects/guessing_game) -src/main.rs:22:15: 22:24 error: mismatched types: expected `uint` but found `core::option::Option<uint>` (expected uint but found enum core::option::Option) -src/main.rs:22 match cmp(input_num, secret_number) { - ^~~~~~~~~ -error: aborting due to previous error -``` - -Oh yeah! Our `input_num` has the type `Option<uint>`, rather than `uint`. We -need to unwrap the Option. If you remember from before, `match` is a great way -to do that. Try this code: - -```{rust,no_run} -use std::io; -use std::rand; -use std::cmp::Ordering; - -fn main() { - println!("Guess the number!"); - - let secret_number = (rand::random::<uint>() % 100u) + 1u; - - println!("The secret number is: {}", secret_number); - - println!("Please input your guess."); - - let input = io::stdin().read_line() - .ok() - .expect("Failed to read line"); - let input_num: Option<uint> = input.parse(); - - let num = match input_num { - Some(num) => num, - None => { - println!("Please input a number!"); - return; - } - }; - - - println!("You guessed: {}", num); - - match cmp(num, secret_number) { - Ordering::Less => println!("Too small!"), - Ordering::Greater => println!("Too big!"), - Ordering::Equal => println!("You win!"), - } -} - -fn cmp(a: uint, b: uint) -> Ordering { - if a < b { Ordering::Less } - else if a > b { Ordering::Greater } - else { Ordering::Equal } -} -``` - -We use a `match` to either give us the `uint` inside of the `Option`, or else -print an error message and return. Let's give this a shot: - -```bash -$ cargo run - Compiling guessing_game v0.0.1 (file:///home/you/projects/guessing_game) - Running `target/guessing_game` -Guess the number! -The secret number is: 17 -Please input your guess. -5 -Please input a number! -``` - -Uh, what? But we did! - -... actually, we didn't. See, when you get a line of input from `stdin()`, -you get all the input. Including the `\n` character from you pressing Enter. -Therefore, `parse()` sees the string `"5\n"` and says "nope, that's not a -number; there's non-number stuff in there!" Luckily for us, `&str`s have an easy -method we can use defined on them: `trim()`. One small modification, and our -code looks like this: - -```{rust,no_run} -use std::io; -use std::rand; -use std::cmp::Ordering; - -fn main() { - println!("Guess the number!"); - - let secret_number = (rand::random::<uint>() % 100u) + 1u; - - println!("The secret number is: {}", secret_number); - - println!("Please input your guess."); - - let input = io::stdin().read_line() - .ok() - .expect("Failed to read line"); - let input_num: Option<uint> = input.trim().parse(); - - let num = match input_num { - Some(num) => num, - None => { - println!("Please input a number!"); - return; - } - }; - - - println!("You guessed: {}", num); - - match cmp(num, secret_number) { - Ordering::Less => println!("Too small!"), - Ordering::Greater => println!("Too big!"), - Ordering::Equal => println!("You win!"), - } -} - -fn cmp(a: uint, b: uint) -> Ordering { - if a < b { Ordering::Less } - else if a > b { Ordering::Greater } - else { Ordering::Equal } -} -``` - -Let's try it! - -```bash -$ cargo run - Compiling guessing_game v0.0.1 (file:///home/you/projects/guessing_game) - Running `target/guessing_game` -Guess the number! -The secret number is: 58 -Please input your guess. - 76 -You guessed: 76 -Too big! -``` - -Nice! You can see I even added spaces before my guess, and it still figured -out that I guessed 76. Run the program a few times, and verify that guessing -the number works, as well as guessing a number too small. - -The Rust compiler helped us out quite a bit there! This technique is called -"lean on the compiler", and it's often useful when working on some code. Let -the error messages help guide you towards the correct types. - -Now we've got most of the game working, but we can only make one guess. Let's -change that by adding loops! - -## Looping - -As we already discussed, the `loop` keyword gives us an infinite loop. -Let's add that in: - -```{rust,no_run} -use std::io; -use std::rand; -use std::cmp::Ordering; - -fn main() { - println!("Guess the number!"); - - let secret_number = (rand::random::<uint>() % 100u) + 1u; - - println!("The secret number is: {}", secret_number); - - loop { - - println!("Please input your guess."); - - let input = io::stdin().read_line() - .ok() - .expect("Failed to read line"); - let input_num: Option<uint> = input.trim().parse(); - - let num = match input_num { - Some(num) => num, - None => { - println!("Please input a number!"); - return; - } - }; - - - println!("You guessed: {}", num); - - match cmp(num, secret_number) { - Ordering::Less => println!("Too small!"), - Ordering::Greater => println!("Too big!"), - Ordering::Equal => println!("You win!"), - } - } -} - -fn cmp(a: uint, b: uint) -> Ordering { - if a < b { Ordering::Less } - else if a > b { Ordering::Greater } - else { Ordering::Equal } -} -``` - -And try it out. But wait, didn't we just add an infinite loop? Yup. Remember -that `return`? If we give a non-number answer, we'll `return` and quit. Observe: - -```bash -$ cargo run - Compiling guessing_game v0.0.1 (file:///home/you/projects/guessing_game) - Running `target/guessing_game` -Guess the number! -The secret number is: 59 -Please input your guess. -45 -You guessed: 45 -Too small! -Please input your guess. -60 -You guessed: 60 -Too big! -Please input your guess. -59 -You guessed: 59 -You win! -Please input your guess. -quit -Please input a number! -``` - -Ha! `quit` actually quits. As does any other non-number input. Well, this is -suboptimal to say the least. First, let's actually quit when you win the game: - -```{rust,no_run} -use std::io; -use std::rand; -use std::cmp::Ordering; - -fn main() { - println!("Guess the number!"); - - let secret_number = (rand::random::<uint>() % 100u) + 1u; - - println!("The secret number is: {}", secret_number); - - loop { - - println!("Please input your guess."); - - let input = io::stdin().read_line() - .ok() - .expect("Failed to read line"); - let input_num: Option<uint> = input.trim().parse(); - - let num = match input_num { - Some(num) => num, - None => { - println!("Please input a number!"); - return; - } - }; - - - println!("You guessed: {}", num); - - match cmp(num, secret_number) { - Ordering::Less => println!("Too small!"), - Ordering::Greater => println!("Too big!"), - Ordering::Equal => { - println!("You win!"); - return; - }, - } - } -} - -fn cmp(a: uint, b: uint) -> Ordering { - if a < b { Ordering::Less } - else if a > b { Ordering::Greater } - else { Ordering::Equal } -} -``` - -By adding the `return` line after the `You win!`, we'll exit the program when -we win. We have just one more tweak to make: when someone inputs a non-number, -we don't want to quit, we just want to ignore it. Change that `return` to -`continue`: - - -```{rust,no_run} -use std::io; -use std::rand; -use std::cmp::Ordering; - -fn main() { - println!("Guess the number!"); - - let secret_number = (rand::random::<uint>() % 100u) + 1u; - - println!("The secret number is: {}", secret_number); - - loop { - - println!("Please input your guess."); - - let input = io::stdin().read_line() - .ok() - .expect("Failed to read line"); - let input_num: Option<uint> = input.trim().parse(); - - let num = match input_num { - Some(num) => num, - None => { - println!("Please input a number!"); - continue; - } - }; - - - println!("You guessed: {}", num); - - match cmp(num, secret_number) { - Ordering::Less => println!("Too small!"), - Ordering::Greater => println!("Too big!"), - Ordering::Equal => { - println!("You win!"); - return; - }, - } - } -} - -fn cmp(a: uint, b: uint) -> Ordering { - if a < b { Ordering::Less } - else if a > b { Ordering::Greater } - else { Ordering::Equal } -} -``` - -Now we should be good! Let's try: - -```bash -$ cargo run - Compiling guessing_game v0.0.1 (file:///home/you/projects/guessing_game) - Running `target/guessing_game` -Guess the number! -The secret number is: 61 -Please input your guess. -10 -You guessed: 10 -Too small! -Please input your guess. -99 -You guessed: 99 -Too big! -Please input your guess. -foo -Please input a number! -Please input your guess. -61 -You guessed: 61 -You win! -``` - -Awesome! With one tiny last tweak, we have finished the guessing game. Can you -think of what it is? That's right, we don't want to print out the secret number. -It was good for testing, but it kind of ruins the game. Here's our final source: - -```{rust,no_run} -use std::io; -use std::rand; -use std::cmp::Ordering; - -fn main() { - println!("Guess the number!"); - - let secret_number = (rand::random::<uint>() % 100u) + 1u; - - loop { - - println!("Please input your guess."); - - let input = io::stdin().read_line() - .ok() - .expect("Failed to read line"); - let input_num: Option<uint> = input.trim().parse(); - - let num = match input_num { - Some(num) => num, - None => { - println!("Please input a number!"); - continue; - } - }; - - - println!("You guessed: {}", num); - - match cmp(num, secret_number) { - Ordering::Less => println!("Too small!"), - Ordering::Greater => println!("Too big!"), - Ordering::Equal => { - println!("You win!"); - return; - }, - } - } -} - -fn cmp(a: uint, b: uint) -> Ordering { - if a < b { Ordering::Less } - else if a > b { Ordering::Greater } - else { Ordering::Equal } -} -``` - -## Complete! - -At this point, you have successfully built the Guessing Game! Congratulations! - -You've now learned the basic syntax of Rust. All of this is relatively close to -various other programming languages you have used in the past. These -fundamental syntactical and semantic elements will form the foundation for the -rest of your Rust education. - -Now that you're an expert at the basics, it's time to learn about some of -Rust's more unique features. - -# Crates and Modules - -Rust features a strong module system, but it works a bit differently than in -other programming languages. Rust's module system has two main components: -**crate**s and **module**s. - -A crate is Rust's unit of independent compilation. Rust always compiles one -crate at a time, producing either a library or an executable. However, executables -usually depend on libraries, and many libraries depend on other libraries as well. -To support this, crates can depend on other crates. - -Each crate contains a hierarchy of modules. This tree starts off with a single -module, called the **crate root**. Within the crate root, we can declare other -modules, which can contain other modules, as deeply as you'd like. - -Note that we haven't mentioned anything about files yet. Rust does not impose a -particular relationship between your filesystem structure and your module -structure. That said, there is a conventional approach to how Rust looks for -modules on the file system, but it's also overridable. - -Enough talk, let's build something! Let's make a new project called `modules`. - -```{bash,ignore} -$ cd ~/projects -$ cargo new modules --bin -$ cd modules -``` - -Let's double check our work by compiling: - -```{bash} -$ cargo run - Compiling modules v0.0.1 (file:///home/you/projects/modules) - Running `target/modules` -Hello, world! -``` - -Excellent! We already have a single crate here: our `src/main.rs` is a crate. -Everything in that file is in the crate root. A crate that generates an executable -defines a `main` function inside its root, as we've done here. - -Let's define a new module inside our crate. Edit `src/main.rs` to look like this: - -``` -fn main() { - println!("Hello, world!") -} - -mod hello { - fn print_hello() { - println!("Hello, world!") - } -} -``` - -We now have a module named `hello` inside of our crate root. Modules use -`snake_case` naming, like functions and variable bindings. - -Inside the `hello` module, we've defined a `print_hello` function. This will -also print out our "hello world" message. Modules allow you to split up your -program into nice neat boxes of functionality, grouping common things together, -and keeping different things apart. It's kinda like having a set of shelves: -a place for everything and everything in its place. - -To call our `print_hello` function, we use the double colon (`::`): - -```{rust,ignore} -hello::print_hello(); -``` - -You've seen this before, with `io::stdin()` and `rand::random()`. Now you know -how to make your own. However, crates and modules have rules about -**visibility**, which controls who exactly may use the functions defined in a -given module. By default, everything in a module is private, which means that -it can only be used by other functions in the same module. This will not -compile: - -```{rust,ignore} -fn main() { - hello::print_hello(); -} - -mod hello { - fn print_hello() { - println!("Hello, world!") - } -} -``` - -It gives an error: - -```bash - Compiling modules v0.0.1 (file:///home/you/projects/modules) -src/main.rs:2:5: 2:23 error: function `print_hello` is private -src/main.rs:2 hello::print_hello(); - ^~~~~~~~~~~~~~~~~~ -``` - -To make it public, we use the `pub` keyword: - -```{rust} -fn main() { - hello::print_hello(); -} - -mod hello { - pub fn print_hello() { - println!("Hello, world!") - } -} -``` - -Usage of the `pub` keyword is sometimes called 'exporting', because -we're making the function available for other modules. This will work: - -```bash -$ cargo run - Compiling modules v0.0.1 (file:///home/you/projects/modules) - Running `target/modules` -Hello, world! -``` - -Nice! There are more things we can do with modules, including moving them into -their own files. This is enough detail for now. - -# Testing - -Traditionally, testing has not been a strong suit of most systems programming -languages. Rust, however, has very basic testing built into the language -itself. While automated testing cannot prove that your code is bug-free, it is -useful for verifying that certain behaviors work as intended. - -Here's a very basic test: - -```{rust} -#[test] -fn is_one_equal_to_one() { - assert_eq!(1, 1); -} -``` - -You may notice something new: that `#[test]`. Before we get into the mechanics -of testing, let's talk about attributes. - -## Attributes - -Rust's testing system uses **attribute**s to mark which functions are tests. -Attributes can be placed on any Rust **item**. Remember how most things in -Rust are an expression, but `let` is not? Item declarations are also not -expressions. Here's a list of things that qualify as an item: - -* functions -* modules -* type definitions -* structures -* enumerations -* static items -* traits -* implementations - -You haven't learned about all of these things yet, but that's the list. As -you can see, functions are at the top of it. - -Attributes can appear in three ways: - -1. A single identifier, the attribute name. `#[test]` is an example of this. -2. An identifier followed by an equals sign (`=`) and a literal. `#[cfg=test]` - is an example of this. -3. An identifier followed by a parenthesized list of sub-attribute arguments. - `#[cfg(unix, target_word_size = "32")]` is an example of this, where one of - the sub-arguments is of the second kind. - -There are a number of different kinds of attributes, enough that we won't go -over them all here. Before we talk about the testing-specific attributes, I -want to call out one of the most important kinds of attributes: stability -markers. - -## Stability attributes - -Rust provides six attributes to indicate the stability level of various -parts of your library. The six levels are: - -* deprecated: This item should no longer be used. No guarantee of backwards - compatibility. -* experimental: This item was only recently introduced or is otherwise in a - state of flux. It may change significantly, or even be removed. No guarantee - of backwards-compatibility. -* unstable: This item is still under development and requires more testing to - be considered stable. No guarantee of backwards-compatibility. -* stable: This item is considered stable, and will not change significantly. - Guarantee of backwards-compatibility. -* frozen: This item is very stable, and is unlikely to change. Guarantee of - backwards-compatibility. -* locked: This item will never change unless a serious bug is found. Guarantee - of backwards-compatibility. - -All of Rust's standard library uses these attribute markers to communicate -their relative stability, and you should use them in your code, as well. -There's an associated attribute, `warn`, that allows you to warn when you -import an item marked with certain levels: deprecated, experimental and -unstable. For now, only deprecated warns by default, but this will change once -the standard library has been stabilized. - -You can use the `warn` attribute like this: - -```{rust,ignore} -#![warn(unstable)] -``` - -And later, when you import a crate: - -```{rust,ignore} -extern crate some_crate; -``` - -You'll get a warning if you use something marked unstable. - -You may have noticed an exclamation point in the `warn` attribute declaration. -The `!` in this attribute means that this attribute applies to the enclosing -item, rather than to the item that follows the attribute. This `warn` -attribute declaration applies to the enclosing crate itself, rather than -to whatever item statement follows it: - -```{rust,ignore} -// applies to the crate we're in -#![warn(unstable)] - -extern crate some_crate; - -// applies to the following `fn`. -#[test] -fn a_test() { - // ... -} -``` - -## Writing tests - -Let's write a very simple crate in a test-driven manner. You know the drill by -now: make a new project: - -```{bash,ignore} -$ cd ~/projects -$ cargo new testing --bin -$ cd testing -``` - -And try it out: - -```bash -$ cargo run - Compiling testing v0.0.1 (file:///home/you/projects/testing) - Running `target/testing` -Hello, world! -``` - -Great. Rust's infrastructure supports tests in two sorts of places, and they're -for two kinds of tests: you include **unit test**s inside of the crate itself, -and you place **integration test**s inside a `tests` directory. "Unit tests" -are small tests that test one focused unit; "integration tests" test multiple -units in integration. That being said, this is a social convention – they're no -different in syntax. Let's make a `tests` directory: - -```{bash,ignore} -$ mkdir tests -``` - -Next, let's create an integration test in `tests/lib.rs`: - -```{rust,no_run} -#[test] -fn foo() { - assert!(false); -} -``` - -It doesn't matter what you name your test functions, though it's nice if -you give them descriptive names. You'll see why in a moment. We then use a -macro, `assert!`, to assert that something is true. In this case, we're giving -it `false`, so this test should fail. Let's try it! - -```bash -$ cargo test - Compiling testing v0.0.1 (file:///home/you/projects/testing) -/home/you/projects/testing/src/main.rs:1:1: 3:2 warning: function is never used: `main`, #[warn(dead_code)] on by default -/home/you/projects/testing/src/main.rs:1 fn main() { -/home/you/projects/testing/src/main.rs:2 println!("Hello, world!") -/home/you/projects/testing/src/main.rs:3 } - Running target/lib-654ce120f310a3a5 - -running 1 test -test foo ... FAILED - -failures: - ----- foo stdout ---- - thread 'foo' failed at 'assertion failed: false', /home/you/projects/testing/tests/lib.rs:3 - - - -failures: - foo - -test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured - -thread '<main>' failed at 'Some tests failed', /home/you/src/rust/src/libtest/lib.rs:243 -``` - -Lots of output! Let's break this down: - -```bash -$ cargo test - Compiling testing v0.0.1 (file:///home/you/projects/testing) -``` - -You can run all of your tests with `cargo test`. This runs both your tests in -`tests`, as well as the tests you put inside of your crate. - -```text -/home/you/projects/testing/src/main.rs:1:1: 3:2 warning: function is never used: `main`, #[warn(dead_code)] on by default -/home/you/projects/testing/src/main.rs:1 fn main() { -/home/you/projects/testing/src/main.rs:2 println!("Hello, world!") -/home/you/projects/testing/src/main.rs:3 } -``` - -Rust has a **lint** called 'warn on dead code' used by default. A lint is a -bit of code that checks your code, and can tell you things about it. In this -case, Rust is warning us that we've written some code that's never used: our -`main` function. Of course, since we're running tests, we don't use `main`. -We'll turn this lint off for just this function soon. For now, just ignore this -output. - -```text - Running target/lib-654ce120f310a3a5 - -running 1 test -test foo ... FAILED -``` - -Now we're getting somewhere. Remember when we talked about naming our tests -with good names? This is why. Here, it says 'test foo' because we called our -test 'foo'. If we had given it a good name, it'd be more clear which test -failed, especially as we accumulate more tests. - -```text -failures: - ----- foo stdout ---- - thread 'foo' failed at 'assertion failed: false', /home/you/projects/testing/tests/lib.rs:3 - - - -failures: - foo - -test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured - -thread '<main>' failed at 'Some tests failed', /home/you/src/rust/src/libtest/lib.rs:243 -``` - -After all the tests run, Rust will show us any output from our failed tests. -In this instance, Rust tells us that our assertion failed, with false. This was -what we expected. - -Whew! Let's fix our test: - -```{rust} -#[test] -fn foo() { - assert!(true); -} -``` - -And then try to run our tests again: - -```bash -$ cargo test - Compiling testing v0.0.1 (file:///home/you/projects/testing) - Running target/lib-654ce120f310a3a5 - -running 1 test -test foo ... ok - -test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured - - Running target/testing-6d7518593c7c3ee5 - -running 0 tests - -test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured -``` - -Nice! Our test passes, as we expected. Note how we didn't get the -`main` warning this time? This is because `src/main.rs` didn't -need recompiling, but we'll get that warning again if we -change (and recompile) that file. Let's get rid of that -warning; change your `src/main.rs` to look like this: - -```{rust} -#[cfg(not(test))] -fn main() { - println!("Hello, world!") -} -``` - -This attribute combines two things: `cfg` and `not`. The `cfg` attribute allows -you to conditionally compile code based on something. The following item will -only be compiled if the configuration says it's true. And when Cargo compiles -our tests, it sets things up so that `cfg(test)` is true. But we want to only -include `main` when it's _not_ true. So we use `not` to negate things: -`cfg(not(test))` will only compile our code when the `cfg(test)` is false. - -With this attribute, we won't get the warning (even -though `src/main.rs` gets recompiled this time): - -```bash -$ cargo test - Compiling testing v0.0.1 (file:///home/you/projects/testing) - Running target/lib-654ce120f310a3a5 - -running 1 test -test foo ... ok - -test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured - - Running target/testing-6d7518593c7c3ee5 - -running 0 tests - -test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured -``` - -Nice. Okay, let's write a real test now. Change your `tests/lib.rs` -to look like this: - -```{rust,ignore} -#[test] -fn math_checks_out() { - let result = add_three_times_four(5); - - assert_eq!(32, result); -} -``` - -And try to run the test: - -```bash -$ cargo test - Compiling testing v0.0.1 (file:///home/you/projects/testing) -/home/you/projects/testing/tests/lib.rs:3:18: 3:38 error: unresolved name `add_three_times_four`. -/home/you/projects/testing/tests/lib.rs:3 let result = add_three_times_four(5); - ^~~~~~~~~~~~~~~~~~~~ -error: aborting due to previous error -Build failed, waiting for other jobs to finish... -Could not compile `testing`. - -To learn more, run the command again with `--verbose`. -``` - -Rust can't find this function. That makes sense, as we didn't write it yet! - -In order to share this code with our tests, we'll need to make a library crate. -This is also just good software design: as we mentioned before, it's a good idea -to put most of your functionality into a library crate, and have your executable -crate use that library. This allows for code reuse. - -To do that, we'll need to make a new module. Make a new file, `src/lib.rs`, -and put this in it: - -```{rust} -# fn main() {} -pub fn add_three_times_four(x: i32) -> i32 { - (x + 3) * 4 -} -``` - -We're calling this file `lib.rs`, because Cargo uses that filename as the crate -root by convention. - -We'll then need to use this crate in our `src/main.rs`: - -```{rust,ignore} -extern crate testing; - -#[cfg(not(test))] -fn main() { - println!("Hello, world!") -} -``` - -Finally, let's import this function in our `tests/lib.rs`: - -```{rust,ignore} -extern crate testing; -use testing::add_three_times_four; - -#[test] -fn math_checks_out() { - let result = add_three_times_four(5); - - assert_eq!(32, result); -} -``` - -Let's give it a run: - -```bash -$ cargo test - Compiling testing v0.0.1 (file:///home/you/projects/testing) - Running target/lib-654ce120f310a3a5 - -running 1 test -test math_checks_out ... ok - -test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured - - Running target/testing-6d7518593c7c3ee5 - -running 0 tests - -test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured - - Running target/testing-8a94b31f7fd2e8fe - -running 0 tests - -test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured - - Doc-tests testing - -running 0 tests - -test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured -``` - -Great! One test passed. We've got an integration test showing that our public -method works, but maybe we want to test some of the internal logic as well. -While this function is simple, if it were more complicated, you can imagine -we'd need more tests. Let's break it up into two helper functions and write -some unit tests to test those. - -Change your `src/lib.rs` to look like this: - -```{rust,ignore} -pub fn add_three_times_four(x: i32) -> i32 { - times_four(add_three(x)) -} - -fn add_three(x: i32) -> i32 { x + 3 } - -fn times_four(x: i32) -> i32 { x * 4 } -``` - -If you run `cargo test`, you should get the same output: - -```bash -$ cargo test - Compiling testing v0.0.1 (file:///home/you/projects/testing) - Running target/lib-654ce120f310a3a5 - -running 1 test -test math_checks_out ... ok - -test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured - - Running target/testing-6d7518593c7c3ee5 - -running 0 tests - -test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured - - Running target/testing-8a94b31f7fd2e8fe - -running 0 tests - -test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured - - Doc-tests testing - -running 0 tests - -test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured -``` - -If we tried to write a test for these two new functions, it wouldn't -work. For example: - -```{rust,ignore} -extern crate testing; -use testing::add_three_times_four; -use testing::add_three; - -#[test] -fn math_checks_out() { - let result = add_three_times_four(5); - - assert_eq!(32, result); -} - -#[test] -fn test_add_three() { - let result = add_three(5); - - assert_eq!(8, result); -} -``` - -We'd get this error: - -```text - Compiling testing v0.0.1 (file:///home/you/projects/testing) -/home/you/projects/testing/tests/lib.rs:3:5: 3:24 error: function `add_three` is private -/home/you/projects/testing/tests/lib.rs:3 use testing::add_three; - ^~~~~~~~~~~~~~~~~~~ -``` - -Right. It's private. So external, integration tests won't work. We need a -unit test. Open up your `src/lib.rs` and add this: - -```{rust,ignore} -pub fn add_three_times_four(x: i32) -> i32 { - times_four(add_three(x)) -} - -fn add_three(x: i32) -> i32 { x + 3 } - -fn times_four(x: i32) -> i32 { x * 4 } - -#[cfg(test)] -mod test { - use super::add_three; - use super::times_four; - - #[test] - fn test_add_three() { - let result = add_three(5); - - assert_eq!(8, result); - } - - #[test] - fn test_times_four() { - let result = times_four(5); - - assert_eq!(20, result); - } -} -``` - -Let's give it a shot: - -```bash -$ cargo test - Compiling testing v0.0.1 (file:///home/you/projects/testing) - Running target/lib-654ce120f310a3a5 - -running 1 test -test math_checks_out ... ok - -test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured - - Running target/testing-6d7518593c7c3ee5 - -running 0 tests - -test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured - - Running target/testing-8a94b31f7fd2e8fe - -running 2 tests -test test::test_times_four ... ok -test test::test_add_three ... ok - -test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured - - Doc-tests testing - -running 0 tests - -test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured -``` - -Cool! We now have two tests of our internal functions. You'll note that there -are three sets of output now: one for `src/main.rs`, one for `src/lib.rs`, and -one for `tests/lib.rs`. There's one interesting thing that we haven't talked -about yet, and that's these lines: - -```{rust,ignore} -use super::add_three; -use super::times_four; -``` - -Because we've made a nested module, we can import functions from the parent -module by using `super`. Sub-modules are allowed to 'see' private functions in -the parent. - -We've now covered the basics of testing. Rust's tools are primitive, but they -work well in the simple cases. There are some Rustaceans working on building -more complicated frameworks on top of all of this, but they're just starting -out. - -# Pointers - -In systems programming, pointers are an incredibly important topic. Rust has a -very rich set of pointers, and they operate differently than in many other -languages. They are important enough that we have a specific [Pointer -Guide](guide-pointers.html) that goes into pointers in much detail. In fact, -while you're currently reading this guide, which covers the language in broad -overview, there are a number of other guides that put a specific topic under a -microscope. You can find the list of guides on the [documentation index -page](index.html#guides). - -In this section, we'll assume that you're familiar with pointers as a general -concept. If you aren't, please read the [introduction to -pointers](guide-pointers.html#an-introduction) section of the Pointer Guide, -and then come back here. We'll wait. - -Got the gist? Great. Let's talk about pointers in Rust. - -## References - -The most primitive form of pointer in Rust is called a **reference**. -References are created using the ampersand (`&`). Here's a simple -reference: - -```{rust} -let x = 5; -let y = &x; -``` - -`y` is a reference to `x`. To dereference (get the value being referred to -rather than the reference itself) `y`, we use the asterisk (`*`): - -```{rust} -let x = 5; -let y = &x; - -assert_eq!(5, *y); -``` - -Like any `let` binding, references are immutable by default. - -You can declare that functions take a reference: - -```{rust} -fn add_one(x: &i32) -> i32 { *x + 1 } - -fn main() { - assert_eq!(6, add_one(&5)); -} -``` - -As you can see, we can make a reference from a literal by applying `&` as well. -Of course, in this simple function, there's not a lot of reason to take `x` by -reference. It's just an example of the syntax. - -Because references are immutable, you can have multiple references that -**alias** (point to the same place): - -```{rust} -let x = 5; -let y = &x; -let z = &x; -``` - -We can make a mutable reference by using `&mut` instead of `&`: - -```{rust} -let mut x = 5; -let y = &mut x; -``` - -Note that `x` must also be mutable. If it isn't, like this: - -```{rust,ignore} -let x = 5; -let y = &mut x; -``` - -Rust will complain: - -```text -error: cannot borrow immutable local variable `x` as mutable - let y = &mut x; - ^ -``` - -We don't want a mutable reference to immutable data! This error message uses a -term we haven't talked about yet, 'borrow'. We'll get to that in just a moment. - -This simple example actually illustrates a lot of Rust's power: Rust has -prevented us, at compile time, from breaking our own rules. Because Rust's -references check these kinds of rules entirely at compile time, there's no -runtime overhead for this safety. At runtime, these are the same as a raw -machine pointer, like in C or C++. We've just double-checked ahead of time -that we haven't done anything dangerous. - -Rust will also prevent us from creating two mutable references that alias. -This won't work: - -```{rust,ignore} -let mut x = 5; -let y = &mut x; -let z = &mut x; -``` - -It gives us this error: - -```text -error: cannot borrow `x` as mutable more than once at a time - let z = &mut x; - ^ -note: previous borrow of `x` occurs here; the mutable borrow prevents subsequent moves, borrows, or modification of `x` until the borrow ends - let y = &mut x; - ^ -note: previous borrow ends here - fn main() { - let mut x = 5; - let y = &mut x; - let z = &mut x; - } - ^ -``` - -This is a big error message. Let's dig into it for a moment. There are three -parts: the error and two notes. The error says what we expected, we cannot have -two mutable pointers that point to the same memory. - -The two notes give some extra context. Rust's error messages often contain this -kind of extra information when the error is complex. Rust is telling us two -things: first, that the reason we cannot **borrow** `x` as `z` is that we -previously borrowed `x` as `y`. The second note shows where `y`'s borrowing -ends. - -Wait, borrowing? - -In order to truly understand this error, we have to learn a few new concepts: -**ownership**, **borrowing**, and **lifetimes**. - -## Ownership, borrowing, and lifetimes - -Whenever a resource of some kind is created, something must be responsible -for destroying that resource as well. Given that we're discussing pointers -right now, let's discuss this in the context of memory allocation, though -it applies to other resources as well. - -When you allocate heap memory, you need a mechanism to free that memory. Many -languages use a garbage collector to handle deallocation. This is a valid, -time-tested strategy, but it's not without its drawbacks: it adds overhead, and -can lead to unpredictable pauses in execution. Because the programmer does not -have to think as much about deallocation, allocation becomes something -commonplace, leading to more memory usage. And if you need precise control -over when something is deallocated, leaving it up to your runtime can make this -difficult. - -Rust chooses a different path, and that path is called **ownership**. Any -binding that creates a resource is the **owner** of that resource. - -Being an owner affords you some privileges: - -1. You control when that resource is deallocated. -2. You may lend that resource, immutably, to as many borrowers as you'd like. -3. You may lend that resource, mutably, to a single borrower. - -But it also comes with some restrictions: - -1. If someone is borrowing your resource (either mutably or immutably), you may - not mutate the resource or mutably lend it to someone. -2. If someone is mutably borrowing your resource, you may not lend it out at - all (mutably or immutably) or access it in any way. - -What's up with all this 'lending' and 'borrowing'? When you allocate memory, -you get a pointer to that memory. This pointer allows you to manipulate said -memory. If you are the owner of a pointer, then you may allow another -binding to temporarily borrow that pointer, and then they can manipulate the -memory. The length of time that the borrower is borrowing the pointer -from you is called a **lifetime**. - -If two distinct bindings share a pointer, and the memory that pointer points to -is immutable, then there are no problems. But if it's mutable, the result of -changing it can vary unpredictably depending on who happens to access it first, -which is called a **race condition**. To avoid this, if someone wants to mutate -something that they've borrowed from you, you must not have lent out that -pointer to anyone else. - -Rust has a sophisticated system called the **borrow checker** to make sure that -everyone plays by these rules. At compile time, it verifies that none of these -rules are broken. If our program compiles successfully, Rust can guarantee it -is free of data races and other memory errors, and there is no runtime overhead -for any of this. The borrow checker works only at compile time. If the borrow -checker did find a problem, it will report an error and your program will -refuse to compile. - -That's a lot to take in. It's also one of the _most_ important concepts in -all of Rust. Let's see this syntax in action: - -```{rust} -{ - let x = 5; // x is the owner of this integer, which is memory on the stack. - - // other code here... - -} // privilege 1: when x goes out of scope, this memory is deallocated - -/// this function borrows an integer. It's given back automatically when the -/// function returns. -fn foo(x: &i32) -> &i32 { x } - -{ - // x is the owner of the integer, which is memory on the stack. - let x = 5; - - // privilege 2: you may lend that resource to as many borrowers as you like - let y = &x; - let z = &x; - - foo(&x); // functions can borrow too! - - let a = &x; // we can do this alllllll day! -} - -{ - // x is the owner of this integer, which is memory on the stack. - let mut x = 5; - - // privilege 3: you may lend that resource to a single borrower, mutably - let y = &mut x; -} -``` - -If you are a borrower, you get a few privileges as well, but must also obey a -restriction: - -1. If the borrow is immutable, you may read the data the pointer points to. -2. If the borrow is mutable, you may read and write the data the pointer points to. -3. You may lend the pointer to someone else, **BUT** -4. When you do so, they must return it before you can give your own borrow back. - -This last requirement can seem odd, but it also makes sense. If you have to -return something, and you've lent it to someone, they need to give it back to -you for you to give it back! If we didn't, then the owner could deallocate -the memory, and the person we've loaned it out to would have a pointer to -invalid memory. This is called a 'dangling pointer'. - -Let's re-examine the error that led us to talk about all of this, which was a -violation of the restrictions placed on owners who lend something out mutably. -The code: - -```{rust,ignore} -let mut x = 5; -let y = &mut x; -let z = &mut x; -``` - -The error: - -```text -error: cannot borrow `x` as mutable more than once at a time - let z = &mut x; - ^ -note: previous borrow of `x` occurs here; the mutable borrow prevents subsequent moves, borrows, or modification of `x` until the borrow ends - let y = &mut x; - ^ -note: previous borrow ends here - fn main() { - let mut x = 5; - let y = &mut x; - let z = &mut x; - } - ^ -``` - -This error comes in three parts. Let's go over each in turn. - -```text -error: cannot borrow `x` as mutable more than once at a time - let z = &mut x; - ^ -``` - -This error states the restriction: you cannot lend out something mutable more -than once at the same time. The borrow checker knows the rules! - -```text -note: previous borrow of `x` occurs here; the mutable borrow prevents subsequent moves, borrows, or modification of `x` until the borrow ends - let y = &mut x; - ^ -``` - -Some compiler errors come with notes to help you fix the error. This error comes -with two notes, and this is the first. This note informs us of exactly where -the first mutable borrow occurred. The error showed us the second. So now we -see both parts of the problem. It also alludes to rule #3, by reminding us that -we can't change `x` until the borrow is over. - -```text -note: previous borrow ends here - fn main() { - let mut x = 5; - let y = &mut x; - let z = &mut x; - } - ^ -``` - -Here's the second note, which lets us know where the first borrow would be over. -This is useful, because if we wait to try to borrow `x` after this borrow is -over, then everything will work. - -For more advanced patterns, please consult the [Ownership -Guide](guide-ownership.html). You'll also learn what this type signature with -the `'a` syntax is: - -```{rust,ignore} -pub fn as_maybe_owned(&self) -> MaybeOwned<'a> { ... } -``` - -## Boxes - -Most of the types we've seen so far have a fixed size or number of components. -The compiler needs this fact to lay out values in memory. However, some data -structures, such as a linked list, do not have a fixed size. You might think to -implement a linked list with an enum that's either a `Node` or the end of the -list (`Nil`), like this: - -```{rust,ignore} -enum List { // error: illegal recursive enum type - Node(u32, List), - Nil -} -``` - -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::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::new(List::Node(1, Box::new(List::Nil)))); -} -``` - -A box dynamically allocates memory to hold its contents. The great thing about -Rust is that that memory is *automatically*, *efficiently*, and *predictably* -deallocated when you're done with the box. - -A box is a pointer type, and you access what's inside using the `*` operator, -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::new(5); - println!("{}", *x); // Prints 5 -} -``` - -The great thing about boxes is that we don't have to manually free this -allocation! Instead, when `x` reaches the end of its lifetime – in this case, -when it goes out of scope at the end of the block – Rust `free`s `x`. This -isn't because Rust has a garbage collector (it doesn't). Instead, by tracking -the ownership and lifetime of a variable (with a little help from you, the -programmer), the compiler knows precisely when it is no longer used. - -The Rust code above will do the same thing as the following C code: - -```{c,ignore} -{ - i32 *x = (i32 *)malloc(sizeof(i32)); - if (!x) abort(); - *x = 5; - printf("%d\n", *x); - free(x); -} -``` - -We get the benefits of manual memory management, while ensuring we don't -introduce any bugs. We can't forget to `free` our memory. - -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} -# 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 -``` - -This gives us this error: - -```text -error: cannot use `*x` because it was mutably borrowed - *x; - ^~ -note: borrow of `x` occurs here - let y = &mut x; - ^ -``` - -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} -# use std::boxed::Box; -let mut x = Box::new(5); - -{ - let y = &mut x; -} // y goes out of scope at the end of the block - -*x; -``` - -Boxes are simple and efficient pointers to dynamically allocated values with a -single owner. They are useful for tree-like structures where the lifetime of a -child depends solely on the lifetime of its (single) parent. If you need a -value that must persist as long as any of several referrers, read on. - -## Rc and Arc - -Sometimes you need a variable that is referenced from multiple places -(immutably!), lasting as long as any of those places, and disappearing when it -is no longer referenced. For instance, in a graph-like data structure, a node -might be referenced from all of its neighbors. In this case, it is not possible -for the compiler to determine ahead of time when the value can be freed – it -needs a little run-time support. - -Rust's **Rc** type provides shared ownership of a dynamically allocated value -that is automatically freed at the end of its last owner's lifetime. (`Rc` -stands for 'reference counted', referring to the way these library types are -implemented.) This provides more flexibility than single-owner boxes, but has -some runtime overhead. - -To create an `Rc` value, use `Rc::new()`. To create a second owner, use the -`.clone()` method: - -```{rust} -use std::rc::Rc; - -let x = Rc::new(5); -let y = x.clone(); - -println!("{} {}", *x, *y); // Prints 5 5 -``` - -The `Rc` will live as long as any of its owners are alive. After that, the -memory will be `free`d. - -**Arc** is an 'atomically reference counted' value, identical to `Rc` except -that ownership can be safely shared among multiple threads. Why two types? -`Arc` has more overhead, so if you're not in a multi-threaded scenario, you -don't have to pay the price. - -If you use `Rc` or `Arc`, you have to be careful about introducing cycles. If -you have two `Rc`s that point to each other, they will happily keep each other -alive forever, creating a memory leak. To learn more, check out [the section on -`Rc` and `Arc` in the pointers guide](guide-pointers.html#rc-and-arc). - -# Patterns - -We've made use of patterns a few times in the guide: first with `let` bindings, -then with `match` statements. Let's go on a whirlwind tour of all of the things -patterns can do! - -A quick refresher: you can match against literals directly, and `_` acts as an -'any' case: - -```{rust} -let x = 1; - -match x { - 1 => println!("one"), - 2 => println!("two"), - 3 => println!("three"), - _ => println!("anything"), -} -``` - -You can match multiple patterns with `|`: - -```{rust} -let x = 1; - -match x { - 1 | 2 => println!("one or two"), - 3 => println!("three"), - _ => println!("anything"), -} -``` - -You can match a range of values with `...`: - -```{rust} -let x = 1; - -match x { - 1 ... 5 => println!("one through five"), - _ => println!("anything"), -} -``` - -Ranges are mostly used with integers and single characters. - -If you're matching multiple things, via a `|` or a `...`, you can bind -the value to a name with `@`: - -```{rust} -let x = 1; - -match x { - e @ 1 ... 5 => println!("got a range element {}", e), - _ => println!("anything"), -} -``` - -If you're matching on an enum which has variants, you can use `..` to -ignore the value and type in the variant: - -```{rust} -enum OptionalInt { - Value(i32), - Missing, -} - -let x = OptionalInt::Value(5); - -match x { - OptionalInt::Value(..) => println!("Got an i32!"), - OptionalInt::Missing => println!("No such luck."), -} -``` - -You can introduce **match guards** with `if`: - -```{rust} -enum OptionalInt { - Value(i32), - Missing, -} - -let x = OptionalInt::Value(5); - -match x { - OptionalInt::Value(i) if i > 5 => println!("Got an i32 bigger than five!"), - OptionalInt::Value(..) => println!("Got an i32!"), - OptionalInt::Missing => println!("No such luck."), -} -``` - -If you're matching on a pointer, you can use the same syntax as you declared it -with. First, `&`: - -```{rust} -let x = &5; - -match x { - &val => println!("Got a value: {}", val), -} -``` - -Here, the `val` inside the `match` has type `i32`. In other words, the left-hand -side of the pattern destructures the value. If we have `&5`, then in `&val`, `val` -would be `5`. - -If you want to get a reference, use the `ref` keyword: - -```{rust} -let x = 5; - -match x { - ref r => println!("Got a reference to {}", r), -} -``` - -Here, the `r` inside the `match` has the type `&i32`. In other words, the `ref` -keyword _creates_ a reference, for use in the pattern. If you need a mutable -reference, `ref mut` will work in the same way: - -```{rust} -let mut x = 5; - -match x { - ref mut mr => println!("Got a mutable reference to {}", mr), -} -``` - -If you have a struct, you can destructure it inside of a pattern: - -```{rust} -# #![allow(non_shorthand_field_patterns)] -struct Point { - x: i32, - y: i32, -} - -let origin = Point { x: 0, y: 0 }; - -match origin { - Point { x: x, y: y } => println!("({},{})", x, y), -} -``` - -If we only care about some of the values, we don't have to give them all names: - -```{rust} -# #![allow(non_shorthand_field_patterns)] -struct Point { - x: i32, - y: i32, -} - -let origin = Point { x: 0, y: 0 }; - -match origin { - Point { x: x, .. } => println!("x is {}", x), -} -``` - -You can do this kind of match on any member, not just the first: - -```{rust} -# #![allow(non_shorthand_field_patterns)] -struct Point { - x: i32, - y: i32, -} - -let origin = Point { x: 0, y: 0 }; - -match origin { - Point { y: y, .. } => println!("y is {}", y), -} -``` - -If you want to match against a slice or array, you can use `[]`: - -```{rust} -fn main() { - let v = vec!["match_this", "1"]; - - match v.as_slice() { - ["match_this", second] => println!("The second element is {}", second), - _ => {}, - } -} -``` - -Whew! That's a lot of different ways to match things, and they can all be -mixed and matched, depending on what you're doing: - -```{rust,ignore} -match x { - Foo { x: Some(ref name), y: None } => ... -} -``` - -Patterns are very powerful. Make good use of them. - -# Method Syntax - -Functions are great, but if you want to call a bunch of them on some data, it -can be awkward. Consider this code: - -```{rust,ignore} -baz(bar(foo(x))); -``` - -We would read this left-to right, and so we see 'baz bar foo.' But this isn't the -order that the functions would get called in, that's inside-out: 'foo bar baz.' -Wouldn't it be nice if we could do this instead? - -```{rust,ignore} -x.foo().bar().baz(); -``` - -Luckily, as you may have guessed with the leading question, you can! Rust provides -the ability to use this **method call syntax** via the `impl` keyword. - -Here's how it works: - -```{rust} -struct Circle { - x: f64, - y: f64, - radius: f64, -} - -impl Circle { - fn area(&self) -> f64 { - std::f64::consts::PI * (self.radius * self.radius) - } -} - -fn main() { - let c = Circle { x: 0.0, y: 0.0, radius: 2.0 }; - println!("{}", c.area()); -} -``` - -This will print `12.566371`. - -We've made a struct that represents a circle. We then write an `impl` block, -and inside it, define a method, `area`. Methods take a special first -parameter, `&self`. There are three variants: `self`, `&self`, and `&mut self`. -You can think of this first parameter as being the `x` in `x.foo()`. The three -variants correspond to the three kinds of things `x` could be: `self` if it's -just a value on the stack, `&self` if it's a reference, and `&mut self` if it's -a mutable reference. We should default to using `&self`, as it's the most -common. - -Finally, as you may remember, the value of the area of a circle is `π*r²`. -Because we took the `&self` parameter to `area`, we can use it just like any -other parameter. Because we know it's a `Circle`, we can access the `radius` -just like we would with any other struct. An import of π and some -multiplications later, and we have our area. - -You can also define methods that do not take a `self` parameter. Here's a -pattern that's very common in Rust code: - -```{rust} -# #![allow(non_shorthand_field_patterns)] -struct Circle { - x: f64, - y: f64, - radius: f64, -} - -impl Circle { - fn new(x: f64, y: f64, radius: f64) -> Circle { - Circle { - x: x, - y: y, - radius: radius, - } - } -} - -fn main() { - let c = Circle::new(0.0, 0.0, 2.0); -} -``` - -This **static method** builds a new `Circle` for us. Note that static methods -are called with the `Struct::method()` syntax, rather than the `ref.method()` -syntax. - -# Closures - -So far, we've made lots of functions in Rust, but we've given them all names. -Rust also allows us to create anonymous functions. Rust's anonymous -functions are called **closure**s. By themselves, closures aren't all that -interesting, but when you combine them with functions that take closures as -arguments, really powerful things are possible. - -Let's make a closure: - -```{rust} -let add_one = |&: x| { 1 + x }; - -println!("The sum of 5 plus 1 is {}.", add_one(5)); -``` - -We create a closure using the `|...| { ... }` syntax, and then we create a -binding so we can use it later. Note that we call the function using the -binding name and two parentheses, just like we would for a named function. - -Let's compare syntax. The two are pretty close: - -```{rust} -let add_one = |&: x: i32| -> i32 { 1 + x }; -fn add_one (x: i32) -> i32 { 1 + x } -``` - -As you may have noticed, closures infer their argument and return types, so you -don't need to declare one. This is different from named functions, which -default to returning unit (`()`). - -There's one big difference between a closure and named functions, and it's in -the name: a closure "closes over its environment." What does that mean? It means -this: - -```{rust} -fn main() { - let x: i32 = 5; - - let printer = |&:| { println!("x is: {}", x); }; - - printer(); // prints "x is: 5" -} -``` - -The `||` syntax means this is an anonymous closure that takes no arguments. -Without it, we'd just have a block of code in `{}`s. - -In other words, a closure has access to variables in the scope where it's -defined. The closure borrows any variables it uses, so this will error: - -```{rust,ignore} -fn main() { - let mut x = 5; - - let printer = |&:| { println!("x is: {}", x); }; - - x = 6; // error: cannot assign to `x` because it is borrowed -} -``` - -## Moving closures - -Rust has a second type of closure, called a **moving closure**. Moving -closures are indicated using the `move` keyword (e.g., `move || x * -x`). The difference between a moving closure and an ordinary closure -is that a moving closure always takes ownership of all variables that -it uses. Ordinary closures, in contrast, just create a reference into -the enclosing stack frame. Moving closures are most useful with Rust's -concurrency features, and so we'll just leave it at this for -now. We'll talk about them more in the "Threads" section of the guide. - -## Accepting closures as arguments - -Closures are most useful as an argument to another function. Here's an example: - -```{rust} -fn twice<F: Fn(i32) -> i32>(x: i32, f: F) -> i32 { - f(x) + f(x) -} - -fn main() { - let square = |&: x: i32| { x * x }; - - twice(5, square); // evaluates to 50 -} -``` - -Let's break the example down, starting with `main`: - -```{rust} -let square = |&: x: i32| { x * x }; -``` - -We've seen this before. We make a closure that takes an integer, and returns -its square. - -```{rust} -# fn twice<F: Fn(i32) -> i32>(x: i32, f: F) -> i32 { f(x) + f(x) } -# let square = |&: x: i32| { x * x }; -twice(5, square); // evaluates to 50 -``` - -This line is more interesting. Here, we call our function, `twice`, and we pass -it two arguments: an integer, `5`, and our closure, `square`. This is just like -passing any other two variable bindings to a function, but if you've never -worked with closures before, it can seem a little complex. Just think: "I'm -passing two variables: one is an i32, and one is a function." - -Next, let's look at how `twice` is defined: - -```{rust,ignore} -fn twice(x: i32, f: |i32| -> i32) -> i32 { -``` - -`twice` takes two arguments, `x` and `f`. That's why we called it with two -arguments. `x` is an `i32`, we've done that a ton of times. `f` is a function, -though, and that function takes an `i32` and returns an `i32`. Notice -how the `|i32| -> i32` syntax looks a lot like our definition of `square` -above, if we added the return type in: - -```{rust} -let square = |&: x: i32| -> i32 { x * x }; -// |i32| -> i32 -``` - -This function takes an `i32` and returns an `i32`. - -This is the most complicated function signature we've seen yet! Give it a read -a few times until you can see how it works. It takes a teeny bit of practice, and -then it's easy. - -Finally, `twice` returns an `i32` as well. - -Okay, let's look at the body of `twice`: - -```{rust} -fn twice<F: Fn(i32) -> i32>(x: i32, f: F) -> i32 { - f(x) + f(x) -} -``` - -Since our closure is named `f`, we can call it just like we called our closures -before, and we pass in our `x` argument to each one, hence the name `twice`. - -If you do the math, `(5 * 5) + (5 * 5) == 50`, so that's the output we get. - -Play around with this concept until you're comfortable with it. Rust's standard -library uses lots of closures where appropriate, so you'll be using -this technique a lot. - -If we didn't want to give `square` a name, we could just define it inline. -This example is the same as the previous one: - -```{rust} -fn twice<F: Fn(i32) -> i32>(x: i32, f: F) -> i32 { - f(x) + f(x) -} - -fn main() { - twice(5, |x: i32| { x * x }); // evaluates to 50 -} -``` - -A named function's name can be used wherever you'd use a closure. Another -way of writing the previous example: - -```{rust} -fn twice<F: Fn(i32) -> i32>(x: i32, f: F) -> i32 { - f(x) + f(x) -} - -fn square(x: i32) -> i32 { x * x } - -fn main() { - twice(5, square); // evaluates to 50 -} -``` - -Doing this is not particularly common, but it's useful every once in a while. - -That's all you need to get the hang of closures! Closures are a little bit -strange at first, but once you're used to them, you'll miss them -in other languages. Passing functions to other functions is -incredibly powerful, as you will see in the following chapter about iterators. - -# Iterators - -Let's talk about loops. - -Remember Rust's `for` loop? Here's an example: - -```{rust} -for x in range(0, 10) { - println!("{}", x); -} -``` - -Now that you know more Rust, we can talk in detail about how this works. The -`range` function returns an **iterator**. An iterator is something that we can -call the `.next()` method on repeatedly, and it gives us a sequence of things. - -Like this: - -```{rust} -let mut range = range(0, 10); - -loop { - match range.next() { - Some(x) => { - println!("{}", x); - }, - None => { break } - } -} -``` - -We make a mutable binding to the return value of `range`, which is our iterator. -We then `loop`, with an inner `match`. This `match` is used on the result of -`range.next()`, which gives us a reference to the next value of the iterator. -`next` returns an `Option<i32>`, in this case, which will be `Some(i32)` when -we have a value and `None` once we run out. If we get `Some(i32)`, we print it -out, and if we get `None`, we `break` out of the loop. - -This code sample is basically the same as our `for` loop version. The `for` -loop is just a handy way to write this `loop`/`match`/`break` construct. - -`for` loops aren't the only thing that uses iterators, however. Writing your -own iterator involves implementing the `Iterator` trait. While doing that is -outside of the scope of this guide, Rust provides a number of useful iterators -to accomplish various tasks. Before we talk about those, we should talk about a -Rust anti-pattern. And that's `range`. - -Yes, we just talked about how `range` is cool. But `range` is also very -primitive. For example, if you needed to iterate over the contents of -a vector, you may be tempted to write this: - -```{rust} -let nums = vec![1, 2, 3]; - -for i in range(0u, nums.len()) { - println!("{}", nums[i]); -} -``` - -This is strictly worse than using an actual iterator. The `.iter()` method on -vectors returns an iterator that iterates through a reference to each element -of the vector in turn. So write this: - -```{rust} -let nums = vec![1, 2, 3]; - -for num in nums.iter() { - println!("{}", num); -} -``` - -There are two reasons for this. First, this more directly expresses what we -mean. We iterate through the entire vector, rather than iterating through -indexes, and then indexing the vector. Second, this version is more efficient: -the first version will have extra bounds checking because it used indexing, -`nums[i]`. But since we yield a reference to each element of the vector in turn -with the iterator, there's no bounds checking in the second example. This is -very common with iterators: we can ignore unnecessary bounds checks, but still -know that we're safe. - -There's another detail here that's not 100% clear because of how `println!` -works. `num` is actually of type `&i32`. That is, it's a reference to an `i32`, -not an `i32` itself. `println!` handles the dereferencing for us, so we don't -see it. This code works fine too: - -```{rust} -let nums = vec![1, 2, 3]; - -for num in nums.iter() { - println!("{}", *num); -} -``` - -Now we're explicitly dereferencing `num`. Why does `iter()` give us references? -Well, if it gave us the data itself, we would have to be its owner, which would -involve making a copy of the data and giving us the copy. With references, -we're just borrowing a reference to the data, and so it's just passing -a reference, without needing to do the copy. - -So, now that we've established that `range` is often not what you want, let's -talk about what you do want instead. - -There are three broad classes of things that are relevant here: iterators, -**iterator adapters**, and **consumers**. Here's some definitions: - -* 'iterators' give you a sequence of values. -* 'iterator adapters' operate on an iterator, producing a new iterator with a - different output sequence. -* 'consumers' operate on an iterator, producing some final set of values. - -Let's talk about consumers first, since you've already seen an iterator, -`range`. - -## Consumers - -A 'consumer' operates on an iterator, returning some kind of value or values. -The most common consumer is `collect()`. This code doesn't quite compile, -but it shows the intention: - -```{rust,ignore} -let one_to_one_hundred = range(1, 101).collect(); -``` - -As you can see, we call `collect()` on our iterator. `collect()` takes -as many values as the iterator will give it, and returns a collection -of the results. So why won't this compile? Rust can't determine what -type of things you want to collect, and so you need to let it know. -Here's the version that does compile: - -```{rust} -let one_to_one_hundred = range(1, 101).collect::<Vec<i32>>(); -``` - -If you remember, the `::<>` syntax allows us to give a type hint, -and so we tell it that we want a vector of integers. - -`collect()` is the most common consumer, but there are others too. `find()` -is one: - -```{rust} -let greater_than_forty_two = range(0, 100) - .find(|x| *x > 42); - -match greater_than_forty_two { - Some(_) => println!("We got some numbers!"), - None => println!("No numbers found :("), -} -``` - -`find` takes a closure, and works on a reference to each element of an -iterator. This closure returns `true` if the element is the element we're -looking for, and `false` otherwise. Because we might not find a matching -element, `find` returns an `Option` rather than the element itself. - -Another important consumer is `fold`. Here's what it looks like: - -```{rust} -let sum = range(1, 4) - .fold(0, |sum, x| sum + x); -``` - -`fold()` is a consumer that looks like this: -`fold(base, |accumulator, element| ...)`. It takes two arguments: the first -is an element called the "base". The second is a closure that itself takes two -arguments: the first is called the "accumulator," and the second is an -"element." Upon each iteration, the closure is called, and the result is the -value of the accumulator on the next iteration. On the first iteration, the -base is the value of the accumulator. - -Okay, that's a bit confusing. Let's examine the values of all of these things -in this iterator: - -| base | accumulator | element | closure result | -|------|-------------|---------|----------------| -| 0 | 0 | 1 | 1 | -| 0 | 1 | 2 | 3 | -| 0 | 3 | 3 | 6 | - -We called `fold()` with these arguments: - -```{rust} -# range(1, 4) -.fold(0, |sum, x| sum + x); -``` - -So, `0` is our base, `sum` is our accumulator, and `x` is our element. On the -first iteration, we set `sum` to `0`, and `x` is the first element of `nums`, -`1`. We then add `sum` and `x`, which gives us `0 + 1 = 1`. On the second -iteration, that value becomes our accumulator, `sum`, and the element is -the second element of the array, `2`. `1 + 2 = 3`, and so that becomes -the value of the accumulator for the last iteration. On that iteration, -`x` is the last element, `3`, and `3 + 3 = 6`, which is our final -result for our sum. `1 + 2 + 3 = 6`, and that's the result we got. - -Whew. `fold` can be a bit strange the first few times you see it, but once it -clicks, you can use it all over the place. Any time you have a list of things, -and you want a single result, `fold` is appropriate. - -Consumers are important due to one additional property of iterators we haven't -talked about yet: laziness. Let's talk some more about iterators, and you'll -see why consumers matter. - -## Iterators - -As we've said before, an iterator is something that we can call the -`.next()` method on repeatedly, and it gives us a sequence of things. -Because you need to call the method, this means that iterators -are **lazy** and don't need to generate all of the values upfront. -This code, for example, does not actually generate the numbers -`1-100`, and just creates a value that represents the sequence: - -```{rust} -let nums = range(1, 100); -``` - -Since we didn't do anything with the range, it didn't generate the sequence. -Let's add the consumer: - -```{rust} -let nums = range(1, 100).collect::<Vec<i32>>(); -``` - -Now, `collect()` will require that `range()` give it some numbers, and so -it will do the work of generating the sequence. - -`range` is one of two basic iterators that you'll see. The other is `iter()`, -which you've used before. `iter()` can turn a vector into a simple iterator -that gives you each element in turn: - -```{rust} -let nums = [1, 2, 3]; - -for num in nums.iter() { - println!("{}", num); -} -``` - -These two basic iterators should serve you well. There are some more -advanced iterators, including ones that are infinite. Like `count`: - -```{rust} -std::iter::count(1, 5); -``` - -This iterator counts up from one, adding five each time. It will give -you a new integer every time, forever (well, technically, until it reaches the -maximum number representable by an `i32`). But since iterators are lazy, -that's okay! You probably don't want to use `collect()` on it, though... - -That's enough about iterators. Iterator adapters are the last concept -we need to talk about with regards to iterators. Let's get to it! - -## Iterator adapters - -"Iterator adapters" take an iterator and modify it somehow, producing -a new iterator. The simplest one is called `map`: - -```{rust,ignore} -range(1, 100).map(|x| x + 1); -``` - -`map` is called upon another iterator, and produces a new iterator where each -element reference has the closure it's been given as an argument called on it. -So this would give us the numbers from `2-100`. Well, almost! If you -compile the example, you'll get a warning: - -```text -warning: unused result which must be used: iterator adaptors are lazy and - do nothing unless consumed, #[warn(unused_must_use)] on by default - range(1, 100).map(|x| x + 1); - ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -``` - -Laziness strikes again! That closure will never execute. This example -doesn't print any numbers: - -```{rust,ignore} -range(1, 100).map(|x| println!("{}", x)); -``` - -If you are trying to execute a closure on an iterator for its side effects, -just use `for` instead. - -There are tons of interesting iterator adapters. `take(n)` will return an -iterator over the next `n` elements of the original iterator, note that this -has no side effect on the original iterator. Let's try it out with our infinite -iterator from before, `count()`: - -```{rust} -for i in std::iter::count(1, 5).take(5) { - println!("{}", i); -} -``` - -This will print - -```text -1 -6 -11 -16 -21 -``` - -`filter()` is an adapter that takes a closure as an argument. This closure -returns `true` or `false`. The new iterator `filter()` produces -only the elements that that closure returns `true` for: - -```{rust} -for i in range(1, 100).filter(|&x| x % 2 == 0) { - println!("{}", i); -} -``` - -This will print all of the even numbers between one and a hundred. -(Note that because `filter` doesn't consume the elements that are -being iterated over, it is passed a reference to each element, and -thus the filter predicate uses the `&x` pattern to extract the integer -itself.) - -You can chain all three things together: start with an iterator, adapt it -a few times, and then consume the result. Check it out: - -```{rust} -range(1, 1000) - .filter(|&x| x % 2 == 0) - .filter(|&x| x % 3 == 0) - .take(5) - .collect::<Vec<i32>>(); -``` - -This will give you a vector containing `6`, `12`, `18`, `24`, and `30`. - -This is just a small taste of what iterators, iterator adapters, and consumers -can help you with. There are a number of really useful iterators, and you can -write your own as well. Iterators provide a safe, efficient way to manipulate -all kinds of lists. They're a little unusual at first, but if you play with -them, you'll get hooked. For a full list of the different iterators and -consumers, check out the [iterator module documentation](std/iter/index.html). - -# Generics - -Sometimes, when writing a function or data type, we may want it to work for -multiple types of arguments. For example, remember our `OptionalInt` type? - -```{rust} -enum OptionalInt { - Value(i32), - Missing, -} -``` - -If we wanted to also have an `OptionalFloat64`, we would need a new enum: - -```{rust} -enum OptionalFloat64 { - Valuef64(f64), - Missingf64, -} -``` - -Such repetition is unfortunate. Luckily, Rust has a feature that gives us a -better way: **generics**. Generics are called **parametric polymorphism** in -type theory, which means that they are types or functions that have multiple -forms over a given parameter ("parametric"). - -Let's see how generics help us escape `OptionalInt`. `Option` is already -provided in Rust's standard library and looks like this: - -```rust -enum Option<T> { - Some(T), - None, -} -``` - -The `<T>` part, which you've seen a few times before, indicates that this is a -generic data type. `T` is called a **type parameter**. When we create instances -of `Option`, we need to provide a concrete type in place of the type -parameter. For example, if we wanted something like our `OptionalInt`, we would -need to instantiate an `Option<i32>`. Inside the declaration of our enum, -wherever we see a `T`, we replace it with the type specified (or inferred by the -compiler). - -```{rust} -let x: Option<i32> = Some(5); -``` - -In this particular `Option`, `T` has the value of `i32`. On the right-hand side -of the binding, we do make a `Some(T)`, where `T` is `5`. Since that's an -`i32`, the two sides match, and Rust is happy. If they didn't match, we'd get an -error: - -```{rust,ignore} -let x: Option<f64> = Some(5); -// error: mismatched types: expected `core::option::Option<f64>`, -// found `core::option::Option<i32>` (expected f64, found i32) -``` - -That doesn't mean we can't make `Option<T>`s that hold an `f64`! They just have to -match up: - -```{rust} -let x: Option<i32> = Some(5); -let y: Option<f64> = Some(5.0f64); -``` - -Generics don't have to only be generic over one type. Consider Rust's built-in -`Result<T, E>` type: - -```{rust} -enum Result<T, E> { - Ok(T), - Err(E), -} -``` - -This type is generic over _two_ types: `T` and `E`. By the way, the capital letters -can be any letter you'd like. We could define `Result<T, E>` as: - -```{rust} -enum Result<H, N> { - Ok(H), - Err(N), -} -``` - -Convention says that the first generic parameter should be `T`, for "type," and -that we use `E` for "error." - -The `Result<T, E>` type is intended to be used to return the result of a -computation and to have the ability to return an error if it didn't work -out. Here's an example: - -```{rust} -let x: Result<f64, String> = Ok(2.3f64); -let y: Result<f64, String> = Err("There was an error.".to_string()); -``` - -This particular `Result` will return an `f64` upon success and a `String` if -there's a failure. Let's write a function that uses `Result<T, E>`: - -```{rust} -fn inverse(x: f64) -> Result<f64, String> { - if x == 0.0f64 { return Err("x cannot be zero!".to_string()); } - - Ok(1.0f64 / x) -} -``` - -We want to indicate that `inverse(0.0f64)` is undefined or is an erroneous usage -of the function, so we check to make sure that we weren't passed zero. If we -were, we return an `Err` with a message. If it's okay, we return an `Ok` with -the answer. - -Why does this matter? Well, remember how `match` does exhaustive matches? -Here's how this function gets used: - -```{rust} -# fn inverse(x: f64) -> Result<f64, String> { -# if x == 0.0f64 { return Err("x cannot be zero!".to_string()); } -# Ok(1.0f64 / x) -# } -let x = inverse(25.0f64); - -match x { - Ok(x) => println!("The inverse of 25 is {}", x), - Err(msg) => println!("Error: {}", msg), -} -``` - -The `match` enforces that we handle the `Err` case. In addition, because the -answer is wrapped up in an `Ok`, we can't just use the result without doing -the match: - -```{rust,ignore} -let x = inverse(25.0f64); -println!("{}", x + 2.0f64); // error: binary operation `+` cannot be applied - // to type `core::result::Result<f64,collections::string::String>` -``` - -This function is great, but there's one other problem: it only works for 64 bit -floating point values. If we wanted to handle 32 bit floating point values we'd -have to write this: - -```{rust} -fn inverse32(x: f32) -> Result<f32, String> { - if x == 0.0f32 { return Err("x cannot be zero!".to_string()); } - - Ok(1.0f32 / x) -} -``` - -What we need is a **generic function**. We can do that with Rust! However, it -won't _quite_ work yet. We need to talk about syntax. A first attempt at a -generic version of `inverse` might look something like this: - -```{rust,ignore} -fn inverse<T>(x: T) -> Result<T, String> { - if x == 0.0 { return Err("x cannot be zero!".to_string()); } - - Ok(1.0 / x) -} -``` - -Just like how we had `Option<T>`, we use a similar syntax for `inverse<T>`. We -can then use `T` inside the rest of the signature: `x` has type `T`, and half of -the `Result` has type `T`. However, if we try to compile that example, we'll get -some errors: - -```text -error: binary operation `==` cannot be applied to type `T` - if x == 0.0 { return Err("x cannot be zero!".to_string()); } - ^~~~~~~~ -error: mismatched types: expected `_`, found `T` (expected floating-point variable, found type parameter) - Ok(1.0 / x) - ^ -error: mismatched types: expected `core::result::Result<T, collections::string::String>`, found `core::result::Result<_, _>` (expected type parameter, found floating-point variable) - Ok(1.0 / x) - ^~~~~~~~~~~ -``` - -The problem is that `T` is unconstrained: it can be _any_ type. It could be a -`String`, and the expression `1.0 / x` has no meaning if `x` is a `String`. It -may be a type that doesn't implement `==`, and the first line would be -wrong. What do we do? - -To fix this example, we need to learn about another Rust feature: **traits**. - -# Traits - -Our discussion of **traits** begins with the `impl` keyword. We used it before -to specify methods. - -```{rust} -struct Circle { - x: f64, - y: f64, - radius: f64, -} - -impl Circle { - fn area(&self) -> f64 { - std::f64::consts::PI * (self.radius * self.radius) - } -} -``` - -We define a trait in terms of its methods. We then `impl` a trait `for` a type -(or many types). - -```{rust} -struct Circle { - x: f64, - y: f64, - radius: f64, -} - -trait HasArea { - fn area(&self) -> f64; -} - -impl HasArea for Circle { - fn area(&self) -> f64 { - std::f64::consts::PI * (self.radius * self.radius) - } -} -``` - -The `trait` block defines only type signatures. When we `impl` a trait, we use -`impl Trait for Item`, rather than just `impl Item`. - -The first of the three errors we got with our generic `inverse` function was -this: - -```text -error: binary operation `==` cannot be applied to type `T` -``` - -We can use traits to constrain generic type parameters. Consider this function, -which does not compile, and gives us a similar error: - -```{rust,ignore} -fn print_area<T>(shape: T) { - println!("This shape has an area of {}", shape.area()); -} -``` - -Rust complains: - -```text -error: type `T` does not implement any method in scope named `area` -``` - -Because `T` can be any type, we can't be sure that it implements the `area` -method. But we can add a **trait constraint** to our generic `T`, ensuring that -we can only compile the function if it's called with types which `impl` the -`HasArea` trait: - -```{rust} -# trait HasArea { -# fn area(&self) -> f64; -# } -fn print_area<T: HasArea>(shape: T) { - println!("This shape has an area of {}", shape.area()); -} -``` - -The syntax `<T: HasArea>` means "any type that implements the HasArea trait." -Because traits define method signatures, we can be sure that any type which -implements `HasArea` will have an `area` method. - -Here's an extended example of how this works: - -```{rust} -trait HasArea { - fn area(&self) -> f64; -} - -struct Circle { - x: f64, - y: f64, - radius: f64, -} - -impl HasArea for Circle { - fn area(&self) -> f64 { - std::f64::consts::PI * (self.radius * self.radius) - } -} - -struct Square { - x: f64, - y: f64, - side: f64, -} - -impl HasArea for Square { - fn area(&self) -> f64 { - self.side * self.side - } -} - -fn print_area<T: HasArea>(shape: T) { - println!("This shape has an area of {}", shape.area()); -} - -fn main() { - let c = Circle { - x: 0.0f64, - y: 0.0f64, - radius: 1.0f64, - }; - - let s = Square { - x: 0.0f64, - y: 0.0f64, - side: 1.0f64, - }; - - print_area(c); - print_area(s); -} -``` - -This program outputs: - -```text -This shape has an area of 3.141593 -This shape has an area of 1 -``` - -As you can see, `print_area` is now generic, but also ensures that we -have passed in the correct types. If we pass in an incorrect type: - -```{rust,ignore} -print_area(5); -``` - -We get a compile-time error: - -```text -error: failed to find an implementation of trait main::HasArea for i32 -``` - -So far, we've only added trait implementations to structs, but you can -implement a trait for any type. So technically, we _could_ implement -`HasArea` for `i32`: - -```{rust} -trait HasArea { - fn area(&self) -> f64; -} - -impl HasArea for i32 { - fn area(&self) -> f64 { - println!("this is silly"); - - *self as f64 - } -} - -5.area(); -``` - -It is considered poor style to implement methods on such primitive types, even -though it is possible. - -## Scoped Method Resolution and Orphan `impl`s - -There are two restrictions for implementing traits that prevent this from -getting out of hand. - -1. **Scope-based Method Resolution**: Traits must be `use`d in any scope where - you wish to use the trait's methods -2. **No Orphan `impl`s**: Either the trait or the type you're writing the `impl` - for must be inside your crate. - -If we organize our crate differently by using modules, we'll need to ensure both -of the conditions are satisfied. Don't worry, you can lean on the compiler since -it won't let you get away with violating them. - -```{rust} -use shapes::HasArea; // satisfies #1 - -mod shapes { - use std::f64::consts; - - pub trait HasArea { - fn area(&self) -> f64; - } - - pub struct Circle { - pub x: f64, - pub y: f64, - pub radius: f64, - } - - impl HasArea for Circle { - fn area(&self) -> f64 { - consts::PI * (self.radius * self.radius) - } - } -} - -fn main() { - // use shapes::HasArea; // This would satisfy #1, too - let c = shapes::Circle { - x: 0.0f64, - y: 0.0f64, - radius: 1.0f64, - }; - - println!("{}", c.area()); -} -``` - -Requiring us to `use` traits whose methods we want means that even if someone -does something bad like add methods to `i32`, it won't affect us, unless you -`use` that trait. - -The second condition allows us to `impl` built-in `trait`s for types we define, -or allows us to `impl` our own `trait`s for built-in types, but restricts us -from mixing and matching third party or built-in `impl`s with third party or -built-in types. - -We could `impl` the `HasArea` trait for `i32`, because `HasArea` is in our -crate. But if we tried to implement `Float`, a standard library `trait`, for -`i32`, we could not, because neither the `trait` nor the `type` are in our -crate. - -## Monomorphization - -One last thing about generics and traits: the compiler performs -**monomorphization** on generic functions so they are statically dispatched. To -see what that means, let's take a look at `print_area` again: - -```{rust,ignore} -fn print_area<T: HasArea>(shape: T) { - println!("This shape has an area of {}", shape.area()); -} - -fn main() { - let c = Circle { ... }; - - let s = Square { ... }; - - print_area(c); - print_area(s); -} -``` - -Because we have called `print_area` with two different types in place of its -type paramater `T`, Rust will generate two versions of the function with the -appropriate concrete types, replacing the call sites with calls to the concrete -implementations. In other words, the compiler will actually compile something -more like this: - -```{rust,ignore} -fn __print_area_circle(shape: Circle) { - println!("This shape has an area of {}", shape.area()); -} - -fn __print_area_square(shape: Square) { - println!("This shape has an area of {}", shape.area()); -} - -fn main() { - let c = Circle { ... }; - - let s = Square { ... }; - - __print_area_circle(c); - __print_area_square(s); -} -``` - -These names are for illustration; the compiler will generate its own cryptic -names for internal uses. The point is that there is no runtime overhead of -deciding which version to call. The function to be called is determined -statically, at compile time. Thus, generic functions are **statically -dispatched**. The downside is that we have two similar functions, so our binary -is larger. - -# Threads - -Concurrency and parallelism are topics that are of increasing interest to a -broad subsection of software developers. Modern computers are often multi-core, -to the point that even embedded devices like cell phones have more than one -processor. Rust's semantics lend themselves very nicely to solving a number of -issues that programmers have with concurrency. Many concurrency errors that are -runtime errors in other languages are compile-time errors in Rust. - -Rust's concurrency primitive is called a **thread**. It's worth noting that -threads are implemented as a library, and not part of the language. This means -that in the future, other concurrency libraries can be written for Rust to help -in specific scenarios. Here's an example of creating a thread: - -```{rust,ignore} -spawn(move || { - println!("Hello from a thread!"); -}); -``` - -The `spawn` function takes a closure as an argument, and runs that -closure in a new thread. Typically, you will want to use a moving -closure, so that the closure takes ownership of any variables that it -touches. This implies that those variables are not usable from the -parent thread after the child thread is spawned: - -```{rust,ignore} -let mut x = vec![1, 2, 3]; - -spawn(move || { - println!("The value of x[0] is: {}", x[0]); -}); - -println!("The value of x[0] is: {}", x[0]); // error: use of moved value: `x` -``` - -`x` is now owned by the closure, and so we can't use it anymore. Many -other languages would let us do this, but it's not safe to do -so. Rust's borrow checker catches the error. - -If threads were only able to capture these values, they wouldn't be very useful. -Luckily, threads can communicate with each other through **channel**s. Channels -work like this: - -```{rust,ignore} -let (tx, rx) = channel(); - -spawn(move || { - tx.send("Hello from a thread!".to_string()); -}); - -let message = rx.recv(); -println!("{}", message); -``` - -The `channel()` function returns two endpoints: a `Receiver<T>` and a -`Sender<T>`. You can use the `.send()` method on the `Sender<T>` end, and -receive the message on the `Receiver<T>` side with the `recv()` method. This -method blocks until it gets a message. There's a similar method, `.try_recv()`, -which returns an `Result<T, TryRecvError>` and does not block. - -If you want to send messages to the thread as well, create two channels! - -```{rust,ignore} -let (tx1, rx1) = channel(); -let (tx2, rx2) = channel(); - -spawn(move || { - tx1.send("Hello from a thread!".to_string()); - let message = rx2.recv(); - println!("{}", message); -}); - -let message = rx1.recv(); -println!("{}", message); - -tx2.send("Goodbye from main!".to_string()); -``` - -The closure has one sending end and one receiving end, and the main thread has -one of each as well. Now they can talk back and forth in whatever way they -wish. - -Notice as well that because `Sender` and `Receiver` are generic, while you can -pass any kind of information through the channel, the ends are strongly typed. -If you try to pass a string, and then an integer, Rust will complain. - -## Futures - -With these basic primitives, many different concurrency patterns can be -developed. Rust includes some of these types in its standard library. For -example, if you wish to compute some value in the background, `Future` is -a useful thing to use: - -```{rust} -# #![allow(deprecated)] -use std::sync::Future; - -let mut delayed_value = Future::spawn(move || { - // just return anything for examples' sake - - 12345 -}); -println!("value = {}", delayed_value.get()); -``` - -Calling `Future::spawn` works just like `spawn()`: it takes a -closure. In this case, though, you don't need to mess with the -channel: just have the closure return the value. - -`Future::spawn` will return a value which we can bind with `let`. It needs -to be mutable, because once the value is computed, it saves a copy of the -value, and if it were immutable, it couldn't update itself. - -The future will go on processing in the background, and when we need -the final value, we can call `get()` on it. This will block until the -result is done, but if it's finished computing in the background, -we'll just get the value immediately. - -## Success and failure - -Threads don't always succeed, they can also panic. A thread that wishes to panic -can call the `panic!` macro, passing a message: - -```{rust,ignore} -spawn(move || { - panic!("Nope."); -}); -``` - -If a thread panics, it is not possible for it to recover. However, it can -notify other thread that it has panicked. We can do this with `thread::try`: - -```{rust,ignore} -use std::thread; -use std::rand; - -let result = thread::try(move || { - if rand::random() { - println!("OK"); - } else { - panic!("oops!"); - } -}); -``` - -This thread will randomly panic or succeed. `thread::try` returns a `Result` -type, so we can handle the response like any other computation that may -fail. - -# Macros - -One of Rust's most advanced features is its system of **macro**s. While -functions allow you to provide abstractions over values and operations, macros -allow you to provide abstractions over syntax. Do you wish Rust had the ability -to do something that it can't currently do? You may be able to write a macro -to extend Rust's capabilities. - -You've already used one macro extensively: `println!`. When we invoke -a Rust macro, we need to use the exclamation mark (`!`). There are two reasons -why this is so: the first is that it makes it clear when you're using a -macro. The second is that macros allow for flexible syntax, and so Rust must -be able to tell where a macro starts and ends. The `!(...)` helps with this. - -Let's talk some more about `println!`. We could have implemented `println!` as -a function, but it would be worse. Why? Well, what macros allow you to do -is write code that generates more code. So when we call `println!` like this: - -```{rust} -let x = 5; -println!("x is: {}", x); -``` - -The `println!` macro does a few things: - -1. It parses the string to find any `{}`s. -2. It checks that the number of `{}`s matches the number of other arguments. -3. It generates a bunch of Rust code, taking this in mind. - -What this means is that you get type checking at compile time, because -Rust will generate code that takes all of the types into account. If -`println!` was a function, it could still do this type checking, but it -would happen at run time rather than compile time. - -We can check this out using a special flag to `rustc`. Put this code in a file -called `print.rs`: - -```{rust} -fn main() { - let x = 5; - println!("x is: {}", x); -} -``` - -You can have the macros expanded like this: `rustc --pretty=expanded print.rs`, which will -give us this huge result: - -```{rust,ignore} -#![feature(phase)] -#![no_std] -#![feature(globs)] -#[phase(plugin, link)] -extern crate "std" as std; -extern crate "native" as rt; -#[prelude_import] -use std::prelude::*; -fn main() { - let x = 5; - match (&x,) { - (__arg0,) => { - #[inline] - #[allow(dead_code)] - static __STATIC_FMTSTR: [&'static str, ..1u] = ["x is: "]; - let __args_vec = - &[::std::fmt::argument(::std::fmt::secret_show, __arg0)]; - let __args = - unsafe { - ::std::fmt::Arguments::new(__STATIC_FMTSTR, __args_vec) - }; - ::std::io::stdio::println_args(&__args) - } - }; -} -``` - -Whew! This isn't too terrible. You can see that we still `let x = 5`, -but then things get a little bit hairy. Three more bindings get set: a -static format string, an argument vector, and the arguments. We then -invoke the `println_args` function with the generated arguments. - -This is the code that Rust actually compiles. You can see all of the extra -information that's here. We get all of the type safety and options that it -provides, but at compile time, and without needing to type all of this out. -This is how macros are powerful: without them you would need to type all of -this by hand to get a type-checked `println`. - -For more on macros, please consult [the Macros Guide](guide-macros.html). -Macros are a very advanced and still slightly experimental feature, but they don't -require a deep understanding to be called, since they look just like functions. The -Guide can help you if you want to write your own. - -# Unsafe - -Finally, there's one more Rust concept that you should be aware of: `unsafe`. -There are two circumstances where Rust's safety provisions don't work well. -The first is when interfacing with C code, and the second is when building -certain kinds of abstractions. - -Rust has support for [FFI](http://en.wikipedia.org/wiki/Foreign_function_interface) -(which you can read about in the [FFI Guide](guide-ffi.html)), but can't guarantee -that the C code will be safe. Therefore, Rust marks such functions with the `unsafe` -keyword, which indicates that the function may not behave properly. - -Second, if you'd like to create some sort of shared-memory data structure, Rust -won't allow it, because memory must be owned by a single owner. However, if -you're planning on making access to that shared memory safe – such as with a -mutex – _you_ know that it's safe, but Rust can't know. Writing an `unsafe` -block allows you to ask the compiler to trust you. In this case, the _internal_ -implementation of the mutex is considered unsafe, but the _external_ interface -we present is safe. This allows it to be effectively used in normal Rust, while -being able to implement functionality that the compiler can't double check for -us. - -Doesn't an escape hatch undermine the safety of the entire system? Well, if -Rust code segfaults, it _must_ be because of unsafe code somewhere. By -annotating exactly where that is, you have a significantly smaller area to -search. - -We haven't even talked about any examples here, and that's because I want to -emphasize that you should not be writing unsafe code unless you know exactly -what you're doing. The vast majority of Rust developers will only interact with -it when doing FFI, and advanced library authors may use it to build certain -kinds of abstraction. - -# Conclusion - -We covered a lot of ground here. When you've mastered everything in this Guide, -you will have a firm grasp of basic Rust development. There's a whole lot more -out there, we've just covered the surface. There's tons of topics that you can -dig deeper into, and we've built specialized guides for many of them. To learn -more, dig into the [full documentation index](index.html). - -Happy hacking! diff --git a/src/doc/index.md b/src/doc/index.md index 7f22c1eeb85..25dcc10d893 100644 --- a/src/doc/index.md +++ b/src/doc/index.md @@ -9,10 +9,11 @@ If you haven't seen Rust at all yet, the first thing you should read is the [30 minute intro](intro.html). It will give you an overview of the basic ideas of Rust at a high level. -Once you know you really want to learn Rust, the next step is reading [the -guide](guide.html). It is a lengthy explanation of Rust, its syntax, and its -concepts. Upon completing the guide, you'll be an intermediate Rust developer, -and will have a good grasp of the fundamental ideas behind Rust. +Once you know you really want to learn Rust, the next step is reading [The +Rust Programming Language](book/index.html). It is a lengthy explanation of +Rust, its syntax, and its concepts. Upon completing the book, you'll be an +intermediate Rust developer, and will have a good grasp of the fundamental +ideas behind Rust. # Community & Getting Help @@ -48,24 +49,6 @@ development of Rust itself is discussed. Rust does not have an exact specification, but an effort to describe as much of the language in as much detail as possible is in [the reference](reference.html). -# Guides - -Rust Guides are in-depth looks at a particular topic that's relevant to Rust -development. If you're trying to figure out how to do something, there may be -a guide that can help you out: - -* [Ownership](guide-ownership.html) -* [Strings](guide-strings.html) -* [Pointers](guide-pointers.html) -* [Crates and modules](guide-crates.html) -* [Threads and Communication](guide-tasks.html) -* [Error Handling](guide-error-handling.html) -* [Foreign Function Interface](guide-ffi.html) -* [Writing Unsafe and Low-Level Code](guide-unsafe.html) -* [Macros](guide-macros.html) -* [Testing](guide-testing.html) -* [Compiler Plugins](guide-plugin.html) - # Tools Rust's still a young language, so there isn't a ton of tooling yet, but the diff --git a/src/doc/intro.md b/src/doc/intro.md index ffe33f41bc7..cb28586d103 100644 --- a/src/doc/intro.md +++ b/src/doc/intro.md @@ -7,8 +7,8 @@ This introduction will give you a rough idea of what Rust is like, eliding many details. It does not require prior experience with systems programming, but you may find the syntax easier if you've used a 'curly brace' programming language before, like C or JavaScript. The concepts are more important than the syntax, -so don't worry if you don't get every last detail: you can read [the -Guide](guide.html) to get a more complete explanation. +so don't worry if you don't get every last detail: you can read [The +Rust Programming Language](book/index.html) to get a more complete explanation. Because this is about high-level concepts, you don't need to actually install Rust to follow along. If you'd like to anyway, check out [the @@ -587,5 +587,6 @@ the type system helps you find bugs, how Rust can help you write correct concurrent code, and how you don't have to pay a speed cost for much of this safety. -To continue your Rustic education, read [the guide](guide.html) for a more -in-depth exploration of Rust's syntax and concepts. +To continue your Rustic education, read [The Rust Programming +Language](book/index.html) for a more in-depth exploration of Rust's syntax and +concepts. diff --git a/src/doc/reference.md b/src/doc/reference.md index 804b6b9f63c..2486466c869 100644 --- a/src/doc/reference.md +++ b/src/doc/reference.md @@ -14,7 +14,7 @@ provides three kinds of material: influenced the design. This document does not serve as an introduction to the language. Background -familiarity with the language is assumed. A separate [guide] is available to +familiarity with the language is assumed. A separate [book] is available to help acquire such background familiarity. This document also does not serve as a reference to the [standard] library @@ -23,7 +23,7 @@ separately by extracting documentation attributes from their source code. Many of the features that one might expect to be language features are library features in Rust, so what you're looking for may be there, not here. -[guide]: guide.html +[book]: book/index.html [standard]: std/index.html # Notation @@ -647,10 +647,10 @@ All of the above extensions are expressions with values. Users of `rustc` can define new syntax extensions in two ways: -* [Compiler plugins](guide-plugin.html#syntax-extensions) can include arbitrary +* [Compiler plugins](book/syntax-extensions.html) can include arbitrary Rust code that manipulates syntax trees at compile time. -* [Macros](guide-macros.html) define new syntax in a higher-level, +* [Macros](book/macros.html) define new syntax in a higher-level, declarative way. ## Macros @@ -2076,7 +2076,7 @@ On `struct`s: list of names `#[macro_use(foo, bar)]` restricts the import to just those macros named. The `extern crate` must appear at the crate root, not inside `mod`, which ensures proper function of the [`$crate` macro - variable](guide-macros.html#the-variable-$crate). + variable](book/macros.html#the-variable-$crate). - `macro_reexport` on an `extern crate` — re-export the named macros. @@ -2090,8 +2090,9 @@ On `struct`s: - `no_link` on an `extern crate` — even if we load this crate for macros or compiler plugins, don't link it into the output. -See the [macros guide](guide-macros.html#scoping-and-macro-import/export) for -more information on macro scope. +See the [macros section of the +book](book/macros.html#scoping-and-macro-import/export) for more information on +macro scope. ### Miscellaneous attributes @@ -2193,7 +2194,7 @@ For any lint check `C`: The lint checks supported by the compiler can be found via `rustc -W help`, along with their default settings. [Compiler -plugins](guide-plugin.html#lint-plugins) can provide additional lint checks. +plugins](book/plugin.html#lint-plugins) can provide additional lint checks. ```{.ignore} mod m1 { @@ -4227,7 +4228,7 @@ communication facilities. The Rust compiler supports various methods to link crates together both statically and dynamically. This section will explore the various methods to link Rust crates together, and more information about native libraries can be -found in the [ffi guide][ffi]. +found in the [ffi section of the book][ffi]. In one session of compilation, the compiler can generate multiple artifacts through the usage of either command line flags or the `crate_type` attribute. @@ -4359,5 +4360,5 @@ that have since been removed): * [Unicode Annex #31](http://www.unicode.org/reports/tr31/): identifier and pattern syntax -[ffi]: guide-ffi.html -[plugin]: guide-plugin.html +[ffi]: book/ffi.html +[plugin]: book/plugin.html diff --git a/src/doc/trpl/README.md b/src/doc/trpl/README.md new file mode 100644 index 00000000000..0202e873b36 --- /dev/null +++ b/src/doc/trpl/README.md @@ -0,0 +1,35 @@ +% The Rust Programming Language + +Welcome! This book will teach you about [the Rust Programming +Language](http://www.rust-lang.org/). Rust is a modern systems programming +language focusing on safety and speed. It accomplishes these goals by being +memory safe without using garbage collection. + +"The Rust Programming Language" is split into three sections, which you can +navigate through the menu on the left. + +## Basics + +This section is a linear introduction to the basic syntax and semantics of +Rust. It has individual sections on each part of Rust's syntax, and cumulates +in a small project: a guessing game. + +After reading "Basics," you will have a good foundation to learn more about +Rust, and can write very simple programs. + +## Intermediate + +This section contains individual chapters, which are self-contained. They focus +on specific topics, and can be read in any order. + +After reading "Intermediate," you will have a solid understanding of Rust, +and will be able to understand most Rust code and write more complex programs. + +## Advanced + +In a similar fashion to "Intermediate," this setion is full of individual, +deep-dive chapters, which stand alone and can be read in any order. These +chapters focus on the most complex features, as well as some things that +are only available in upcoming versions of Rust. + +After reading "Advanced," you'll be a Rust expert! diff --git a/src/doc/trpl/SUMMARY.md b/src/doc/trpl/SUMMARY.md new file mode 100644 index 00000000000..1a61c6d216b --- /dev/null +++ b/src/doc/trpl/SUMMARY.md @@ -0,0 +1,36 @@ +# Summary + +* [I: The Basics](basic.md) + * [Installing Rust](installing-rust.md) + * [Hello, world!](hello-world.md) + * [Hello, Cargo!](hello-cargo.md) + * [Variable Bindings](variable-bindings.md) + * [If](if.md) + * [Functions](functions.md) + * [Comments](comments.md) + * [Compound Data Types](compound-data-types.md) + * [Match](match.md) + * [Looping](looping.md) + * [Strings](strings.md) + * [Arrays, Vectors, and Slices](arrays-vectors-and-slices.md) + * [Standard Input](standard-input.md) + * [Guessing Game](guessing-game.md) +* [II: Intermediate Rust](intermediate.md) + * [Crates and Modules](crates-and-modules.md) + * [Testing](testing.md) + * [Pointers](pointers.md) + * [Ownership](ownership.md) + * [Patterns](patterns.md) + * [Method Syntax](method-syntax.md) + * [Closures](closures.md) + * [Iterators](iterators.md) + * [Generics](generics.md) + * [Traits](traits.md) + * [Tasks](tasks.md) + * [Error Handling](error-handling.md) +* [III: Advanced Topics](advanced.md) + * [FFI](ffi.md) + * [Unsafe Code](unsafe.md) + * [Macros](macros.md) + * [Compiler Plugins](plugins.md) +* [Conclusion](conclusion.md) diff --git a/src/doc/trpl/advanced.md b/src/doc/trpl/advanced.md new file mode 100644 index 00000000000..138db523b9a --- /dev/null +++ b/src/doc/trpl/advanced.md @@ -0,0 +1,8 @@ +% Advanced + +In a similar fashion to "Intermediate," this setion is full of individual, +deep-dive chapters, which stand alone and can be read in any order. These +chapters focus on the most complex features, as well as some things that +are only available in upcoming versions of Rust. + +After reading "Advanced," you'll be a Rust expert! diff --git a/src/doc/trpl/arrays-vectors-and-slices.md b/src/doc/trpl/arrays-vectors-and-slices.md new file mode 100644 index 00000000000..24d60dd2e4e --- /dev/null +++ b/src/doc/trpl/arrays-vectors-and-slices.md @@ -0,0 +1,99 @@ +% Arrays, Vectors, and Slices + +Like many programming languages, Rust has list types to represent a sequence of +things. The most basic is the **array**, a fixed-size list of elements of the +same type. By default, arrays are immutable. + +```{rust} +let a = [1, 2, 3]; // a: [i32; 3] +let mut m = [1, 2, 3]; // mut m: [i32; 3] +``` + +There's a shorthand for initializing each element of an array to the same +value. In this example, each element of `a` will be initialized to `0`: + +```{rust} +let a = [0; 20]; // a: [i32; 20] +``` + +Arrays have type `[T; N]`. We'll talk about this `T` notation later, when we +cover generics. + +You can get the number of elements in an array `a` with `a.len()`, and use +`a.iter()` to iterate over them with a for loop. This code will print each +number in order: + +```{rust} +let a = [1, 2, 3]; + +println!("a has {} elements", a.len()); +for e in a.iter() { + println!("{}", e); +} +``` + +You can access a particular element of an array with **subscript notation**: + +```{rust} +let names = ["Graydon", "Brian", "Niko"]; // names: [&str; 3] + +println!("The second name is: {}", names[1]); +``` + +Subscripts start at zero, like in most programming languages, so the first name +is `names[0]` and the second name is `names[1]`. The above example prints +`The second name is: Brian`. If you try to use a subscript that is not in the +array, you will get an error: array access is bounds-checked at run-time. Such +errant access is the source of many bugs in other systems programming +languages. + +A **vector** is a dynamic or "growable" array, implemented as the standard +library type [`Vec<T>`](../std/vec/) (we'll talk about what the `<T>` means +later). Vectors are to arrays what `String` is to `&str`. You can create them +with the `vec!` macro: + +```{rust} +let v = vec![1, 2, 3]; // v: Vec<i32> +``` + +(Notice that unlike the `println!` macro we've used in the past, we use square +brackets `[]` with `vec!`. Rust allows you to use either in either situation, +this is just convention.) + +You can get the length of, iterate over, and subscript vectors just like +arrays. In addition, (mutable) vectors can grow automatically: + +```{rust} +let mut nums = vec![1, 2, 3]; // mut nums: Vec<i32> + +nums.push(4); + +println!("The length of nums is now {}", nums.len()); // Prints 4 +``` + +Vectors have many more useful methods. + +A **slice** is a reference to (or "view" into) an array. They are useful for +allowing safe, efficient access to a portion of an array without copying. For +example, you might want to reference just one line of a file read into memory. +By nature, a slice is not created directly, but from an existing variable. +Slices have a length, can be mutable or not, and in many ways behave like +arrays: + +```{rust} +let a = [0, 1, 2, 3, 4]; +let middle = a.slice(1, 4); // A slice of a: just the elements [1,2,3] + +for e in middle.iter() { + println!("{}", e); // Prints 1, 2, 3 +} +``` + +You can also take a slice of a vector, `String`, or `&str`, because they are +backed by arrays. Slices have type `&[T]`, which we'll talk about when we cover +generics. + +We have now learned all of the most basic Rust concepts. We're ready to start +building our guessing game, we just need to know one last thing: how to get +input from the keyboard. You can't have a guessing game without the ability to +guess! diff --git a/src/doc/trpl/basic.md b/src/doc/trpl/basic.md new file mode 100644 index 00000000000..087121d0e7d --- /dev/null +++ b/src/doc/trpl/basic.md @@ -0,0 +1,8 @@ +% Basics + +This section is a linear introduction to the basic syntax and semantics of +Rust. It has individual sections on each part of Rust's syntax, and cumulates +in a small project: a guessing game. + +After reading "Basics," you will have a good foundation to learn more about +Rust, and can write very simple programs. diff --git a/src/doc/trpl/closures.md b/src/doc/trpl/closures.md new file mode 100644 index 00000000000..6413b90ee71 --- /dev/null +++ b/src/doc/trpl/closures.md @@ -0,0 +1,185 @@ +% Closures + +So far, we've made lots of functions in Rust, but we've given them all names. +Rust also allows us to create anonymous functions. Rust's anonymous +functions are called **closure**s. By themselves, closures aren't all that +interesting, but when you combine them with functions that take closures as +arguments, really powerful things are possible. + +Let's make a closure: + +```{rust} +let add_one = |&: x| { 1 + x }; + +println!("The sum of 5 plus 1 is {}.", add_one(5)); +``` + +We create a closure using the `|...| { ... }` syntax, and then we create a +binding so we can use it later. Note that we call the function using the +binding name and two parentheses, just like we would for a named function. + +Let's compare syntax. The two are pretty close: + +```{rust} +let add_one = |&: x: i32| -> i32 { 1 + x }; +fn add_one (x: i32) -> i32 { 1 + x } +``` + +As you may have noticed, closures infer their argument and return types, so you +don't need to declare one. This is different from named functions, which +default to returning unit (`()`). + +There's one big difference between a closure and named functions, and it's in +the name: a closure "closes over its environment." What does that mean? It means +this: + +```{rust} +fn main() { + let x: i32 = 5; + + let printer = |&:| { println!("x is: {}", x); }; + + printer(); // prints "x is: 5" +} +``` + +The `||` syntax means this is an anonymous closure that takes no arguments. +Without it, we'd just have a block of code in `{}`s. + +In other words, a closure has access to variables in the scope where it's +defined. The closure borrows any variables it uses, so this will error: + +```{rust,ignore} +fn main() { + let mut x = 5; + + let printer = |&:| { println!("x is: {}", x); }; + + x = 6; // error: cannot assign to `x` because it is borrowed +} +``` + +## Moving closures + +Rust has a second type of closure, called a **moving closure**. Moving +closures are indicated using the `move` keyword (e.g., `move || x * +x`). The difference between a moving closure and an ordinary closure +is that a moving closure always takes ownership of all variables that +it uses. Ordinary closures, in contrast, just create a reference into +the enclosing stack frame. Moving closures are most useful with Rust's +concurrency features, and so we'll just leave it at this for +now. We'll talk about them more in the "Threads" section of the guide. + +## Accepting closures as arguments + +Closures are most useful as an argument to another function. Here's an example: + +```{rust} +fn twice<F: Fn(i32) -> i32>(x: i32, f: F) -> i32 { + f(x) + f(x) +} + +fn main() { + let square = |&: x: i32| { x * x }; + + twice(5, square); // evaluates to 50 +} +``` + +Let's break the example down, starting with `main`: + +```{rust} +let square = |&: x: i32| { x * x }; +``` + +We've seen this before. We make a closure that takes an integer, and returns +its square. + +```{rust} +# fn twice<F: Fn(i32) -> i32>(x: i32, f: F) -> i32 { f(x) + f(x) } +# let square = |&: x: i32| { x * x }; +twice(5, square); // evaluates to 50 +``` + +This line is more interesting. Here, we call our function, `twice`, and we pass +it two arguments: an integer, `5`, and our closure, `square`. This is just like +passing any other two variable bindings to a function, but if you've never +worked with closures before, it can seem a little complex. Just think: "I'm +passing two variables: one is an i32, and one is a function." + +Next, let's look at how `twice` is defined: + +```{rust,ignore} +fn twice(x: i32, f: |i32| -> i32) -> i32 { +``` + +`twice` takes two arguments, `x` and `f`. That's why we called it with two +arguments. `x` is an `i32`, we've done that a ton of times. `f` is a function, +though, and that function takes an `i32` and returns an `i32`. Notice +how the `|i32| -> i32` syntax looks a lot like our definition of `square` +above, if we added the return type in: + +```{rust} +let square = |&: x: i32| -> i32 { x * x }; +// |i32| -> i32 +``` + +This function takes an `i32` and returns an `i32`. + +This is the most complicated function signature we've seen yet! Give it a read +a few times until you can see how it works. It takes a teeny bit of practice, and +then it's easy. + +Finally, `twice` returns an `i32` as well. + +Okay, let's look at the body of `twice`: + +```{rust} +fn twice<F: Fn(i32) -> i32>(x: i32, f: F) -> i32 { + f(x) + f(x) +} +``` + +Since our closure is named `f`, we can call it just like we called our closures +before, and we pass in our `x` argument to each one, hence the name `twice`. + +If you do the math, `(5 * 5) + (5 * 5) == 50`, so that's the output we get. + +Play around with this concept until you're comfortable with it. Rust's standard +library uses lots of closures where appropriate, so you'll be using +this technique a lot. + +If we didn't want to give `square` a name, we could just define it inline. +This example is the same as the previous one: + +```{rust} +fn twice<F: Fn(i32) -> i32>(x: i32, f: F) -> i32 { + f(x) + f(x) +} + +fn main() { + twice(5, |x: i32| { x * x }); // evaluates to 50 +} +``` + +A named function's name can be used wherever you'd use a closure. Another +way of writing the previous example: + +```{rust} +fn twice<F: Fn(i32) -> i32>(x: i32, f: F) -> i32 { + f(x) + f(x) +} + +fn square(x: i32) -> i32 { x * x } + +fn main() { + twice(5, square); // evaluates to 50 +} +``` + +Doing this is not particularly common, but it's useful every once in a while. + +That's all you need to get the hang of closures! Closures are a little bit +strange at first, but once you're used to them, you'll miss them +in other languages. Passing functions to other functions is +incredibly powerful, as you will see in the following chapter about iterators. diff --git a/src/doc/trpl/comments.md b/src/doc/trpl/comments.md new file mode 100644 index 00000000000..f02c1ad9a18 --- /dev/null +++ b/src/doc/trpl/comments.md @@ -0,0 +1,46 @@ +% Comments + +Now that we have some functions, it's a good idea to learn about comments. +Comments are notes that you leave to other programmers to help explain things +about your code. The compiler mostly ignores them. + +Rust has two kinds of comments that you should care about: **line comment**s +and **doc comment**s. + +```{rust} +// Line comments are anything after '//' and extend to the end of the line. + +let x = 5; // this is also a line comment. + +// If you have a long explanation for something, you can put line comments next +// to each other. Put a space between the // and your comment so that it's +// more readable. +``` + +The other kind of comment is a doc comment. Doc comments use `///` instead of +`//`, and support Markdown notation inside: + +```{rust} +/// `hello` is a function that prints a greeting that is personalized based on +/// the name given. +/// +/// # Arguments +/// +/// * `name` - The name of the person you'd like to greet. +/// +/// # Example +/// +/// ```rust +/// let name = "Steve"; +/// hello(name); // prints "Hello, Steve!" +/// ``` +fn hello(name: &str) { + println!("Hello, {}!", name); +} +``` + +When writing doc comments, adding sections for any arguments, return values, +and providing some examples of usage is very, very helpful. + +You can use the [`rustdoc`](../rustdoc.html) tool to generate HTML documentation +from these doc comments. diff --git a/src/doc/trpl/compound-data-types.md b/src/doc/trpl/compound-data-types.md new file mode 100644 index 00000000000..b80d248bc41 --- /dev/null +++ b/src/doc/trpl/compound-data-types.md @@ -0,0 +1,353 @@ +% Compound Data Types + +Rust, like many programming languages, has a number of different data types +that are built-in. You've already done some simple work with integers and +strings, but next, let's talk about some more complicated ways of storing data. + +## Tuples + +The first compound data type we're going to talk about are called **tuple**s. +Tuples are an ordered list of a fixed size. Like this: + +```rust +let x = (1, "hello"); +``` + +The parentheses and commas form this two-length tuple. Here's the same code, but +with the type annotated: + +```rust +let x: (i32, &str) = (1, "hello"); +``` + +As you can see, the type of a tuple looks just like the tuple, but with each +position having a type name rather than the value. Careful readers will also +note that tuples are heterogeneous: we have an `i32` and a `&str` in this tuple. +You haven't seen `&str` as a type before, and we'll discuss the details of +strings later. In systems programming languages, strings are a bit more complex +than in other languages. For now, just read `&str` as "a string slice," and +we'll learn more soon. + +You can access the fields in a tuple through a **destructuring let**. Here's +an example: + +```rust +let (x, y, z) = (1, 2, 3); + +println!("x is {}", x); +``` + +Remember before when I said the left-hand side of a `let` statement was more +powerful than just assigning a binding? Here we are. We can put a pattern on +the left-hand side of the `let`, and if it matches up to the right-hand side, +we can assign multiple bindings at once. In this case, `let` 'destructures,' +or 'breaks up,' the tuple, and assigns the bits to three bindings. + +This pattern is very powerful, and we'll see it repeated more later. + +There are also a few things you can do with a tuple as a whole, without +destructuring. You can assign one tuple into another, if they have the same +arity and contained types. + +```rust +let mut x = (1, 2); // x: (i32, i32) +let y = (2, 3); // y: (i32, i32) + +x = y; +``` + +You can also check for equality with `==`. Again, this will only compile if the +tuples have the same type. + +```rust +let x = (1, 2, 3); +let y = (2, 2, 4); + +if x == y { + println!("yes"); +} else { + println!("no"); +} +``` + +This will print `no`, because some of the values aren't equal. + +One other use of tuples is to return multiple values from a function: + +```rust +fn next_two(x: i32) -> (i32, i32) { (x + 1, x + 2) } + +fn main() { + let (x, y) = next_two(5); + println!("x, y = {}, {}", x, y); +} +``` + +Even though Rust functions can only return one value, a tuple _is_ one value, +that happens to be made up of more than one value. You can also see in this example how you +can destructure a pattern returned by a function, as well. + +Tuples are a very simple data structure, and so are not often what you want. +Let's move on to their bigger sibling, structs. + +## Structs + +A struct is another form of a 'record type,' just like a tuple. There's a +difference: structs give each element that they contain a name, called a +'field' or a 'member.' Check it out: + +```rust +struct Point { + x: i32, + y: i32, +} + +fn main() { + let origin = Point { x: 0, y: 0 }; // origin: Point + + println!("The origin is at ({}, {})", origin.x, origin.y); +} +``` + +There's a lot going on here, so let's break it down. We declare a struct with +the `struct` keyword, and then with a name. By convention, structs begin with a +capital letter and are also camel cased: `PointInSpace`, not `Point_In_Space`. + +We can create an instance of our struct via `let`, as usual, but we use a `key: +value` style syntax to set each field. The order doesn't need to be the same as +in the original declaration. + +Finally, because fields have names, we can access the field through dot +notation: `origin.x`. + +The values in structs are immutable by default, like other bindings in Rust. +Use `mut` to make them mutable: + +```{rust} +struct Point { + x: i32, + y: i32, +} + +fn main() { + let mut point = Point { x: 0, y: 0 }; + + point.x = 5; + + println!("The point is at ({}, {})", point.x, point.y); +} +``` + +This will print `The point is at (5, 0)`. + +## Tuple Structs and Newtypes + +Rust has another data type that's like a hybrid between a tuple and a struct, +called a **tuple struct**. Tuple structs do have a name, but their fields +don't: + + +```{rust} +struct Color(i32, i32, i32); +struct Point(i32, i32, i32); +``` + +These two will not be equal, even if they have the same values: + +```{rust} +# struct Color(i32, i32, i32); +# struct Point(i32, i32, i32); +let black = Color(0, 0, 0); +let origin = Point(0, 0, 0); +``` + +It is almost always better to use a struct than a tuple struct. We would write +`Color` and `Point` like this instead: + +```{rust} +struct Color { + red: i32, + blue: i32, + green: i32, +} + +struct Point { + x: i32, + y: i32, + z: i32, +} +``` + +Now, we have actual names, rather than positions. Good names are important, +and with a struct, we have actual names. + +There _is_ one case when a tuple struct is very useful, though, and that's a +tuple struct with only one element. We call this a 'newtype,' because it lets +you create a new type that's a synonym for another one: + +```{rust} +struct Inches(i32); + +let length = Inches(10); + +let Inches(integer_length) = length; +println!("length is {} inches", integer_length); +``` + +As you can see here, you can extract the inner integer type through a +destructuring `let`. + +## Enums + +Finally, Rust has a "sum type", an **enum**. Enums are an incredibly useful +feature of Rust, and are used throughout the standard library. This is an enum +that is provided by the Rust standard library: + +```{rust} +enum Ordering { + Less, + Equal, + Greater, +} +``` + +An `Ordering` can only be _one_ of `Less`, `Equal`, or `Greater` at any given +time. + +Because `Ordering` is provided by the standard library, we can use the `use` +keyword to use it in our code. We'll learn more about `use` later, but it's +used to bring names into scope. + +Here's an example of how to use `Ordering`: + +```{rust} +use std::cmp::Ordering; + +fn cmp(a: i32, b: i32) -> Ordering { + if a < b { Ordering::Less } + else if a > b { Ordering::Greater } + else { Ordering::Equal } +} + +fn main() { + let x = 5; + let y = 10; + + let ordering = cmp(x, y); // ordering: Ordering + + if ordering == Ordering::Less { + println!("less"); + } else if ordering == Ordering::Greater { + println!("greater"); + } else if ordering == Ordering::Equal { + println!("equal"); + } +} +``` + +There's a symbol here we haven't seen before: the double colon (`::`). +This is used to indicate a namespace. In this case, `Ordering` lives in +the `cmp` submodule of the `std` module. We'll talk more about modules +later in the guide. For now, all you need to know is that you can `use` +things from the standard library if you need them. + +Okay, let's talk about the actual code in the example. `cmp` is a function that +compares two things, and returns an `Ordering`. We return either +`Ordering::Less`, `Ordering::Greater`, or `Ordering::Equal`, depending on if +the two values are greater, less, or equal. Note that each variant of the +`enum` is namespaced under the `enum` itself: it's `Ordering::Greater` not +`Greater`. + +The `ordering` variable has the type `Ordering`, and so contains one of the +three values. We can then do a bunch of `if`/`else` comparisons to check which +one it is. However, repeated `if`/`else` comparisons get quite tedious. Rust +has a feature that not only makes them nicer to read, but also makes sure that +you never miss a case. Before we get to that, though, let's talk about another +kind of enum: one with values. + +This enum has two variants, one of which has a value: + +```{rust} +enum OptionalInt { + Value(i32), + Missing, +} +``` + +This enum represents an `i32` that we may or may not have. In the `Missing` +case, we have no value, but in the `Value` case, we do. This enum is specific +to `i32`s, though. We can make it usable by any type, but we haven't quite +gotten there yet! + +You can also have any number of values in an enum: + +```{rust} +enum OptionalColor { + Color(i32, i32, i32), + Missing, +} +``` + +And you can also have something like this: + +```{rust} +enum StringResult { + StringOK(String), + ErrorReason(String), +} +``` +Where a `StringResult` is either a `StringResult::StringOK`, with the result of +a computation, or an `StringResult::ErrorReason` with a `String` explaining +what caused the computation to fail. These kinds of `enum`s are actually very +useful and are even part of the standard library. + +Here is an example of using our `StringResult`: + +```rust +enum StringResult { + StringOK(String), + ErrorReason(String), +} + +fn respond(greeting: &str) -> StringResult { + if greeting == "Hello" { + StringResult::StringOK("Good morning!".to_string()) + } else { + StringResult::ErrorReason("I didn't understand you!".to_string()) + } +} +``` + +That's a lot of typing! We can use the `use` keyword to make it shorter: + +```rust +use StringResult::StringOK; +use StringResult::ErrorReason; + +enum StringResult { + StringOK(String), + ErrorReason(String), +} + +# fn main() {} + +fn respond(greeting: &str) -> StringResult { + if greeting == "Hello" { + StringOK("Good morning!".to_string()) + } else { + ErrorReason("I didn't understand you!".to_string()) + } +} +``` + +`use` declarations must come before anything else, which looks a little strange in this example, +since we `use` the variants before we define them. Anyway, in the body of `respond`, we can just +say `StringOK` now, rather than the full `StringResult::StringOK`. Importing variants can be +convenient, but can also cause name conflicts, so do this with caution. It's considered good style +to rarely import variants for this reason. + +As you can see, `enum`s with values are quite a powerful tool for data representation, +and can be even more useful when they're generic across types. Before we get to generics, +though, let's talk about how to use them with pattern matching, a tool that will +let us deconstruct this sum type (the type theory term for enums) in a very elegant +way and avoid all these messy `if`/`else`s. diff --git a/src/doc/trpl/conclusion.md b/src/doc/trpl/conclusion.md new file mode 100644 index 00000000000..0472787e948 --- /dev/null +++ b/src/doc/trpl/conclusion.md @@ -0,0 +1,10 @@ +% Conclusion + +We covered a lot of ground here. When you've mastered everything in this Guide, +you will have a firm grasp of basic Rust development. There's a whole lot more +out there, we've just covered the surface. There's tons of topics that you can +dig deeper into, and we've built specialized guides for many of them. To learn +more, dig into the [full documentation +index](index.html). + +Happy hacking! diff --git a/src/doc/guide-crates.md b/src/doc/trpl/crates-and-modules.md index ba825c2c9a8..ba825c2c9a8 100644 --- a/src/doc/guide-crates.md +++ b/src/doc/trpl/crates-and-modules.md diff --git a/src/doc/guide-error-handling.md b/src/doc/trpl/error-handling.md index 98b46511f04..98b46511f04 100644 --- a/src/doc/guide-error-handling.md +++ b/src/doc/trpl/error-handling.md diff --git a/src/doc/guide-ffi.md b/src/doc/trpl/ffi.md index 1f12c05f37e..1f12c05f37e 100644 --- a/src/doc/guide-ffi.md +++ b/src/doc/trpl/ffi.md diff --git a/src/doc/trpl/functions.md b/src/doc/trpl/functions.md new file mode 100644 index 00000000000..e3827d962c3 --- /dev/null +++ b/src/doc/trpl/functions.md @@ -0,0 +1,146 @@ +% Functions + +You've already seen one function so far, the `main` function: + +```{rust} +fn main() { +} +``` + +This is the simplest possible function declaration. As we mentioned before, +`fn` says 'this is a function,' followed by the name, some parentheses because +this function takes no arguments, and then some curly braces to indicate the +body. Here's a function named `foo`: + +```{rust} +fn foo() { +} +``` + +So, what about taking arguments? Here's a function that prints a number: + +```{rust} +fn print_number(x: i32) { + println!("x is: {}", x); +} +``` + +Here's a complete program that uses `print_number`: + +```{rust} +fn main() { + print_number(5); +} + +fn print_number(x: i32) { + println!("x is: {}", x); +} +``` + +As you can see, function arguments work very similar to `let` declarations: +you add a type to the argument name, after a colon. + +Here's a complete program that adds two numbers together and prints them: + +```{rust} +fn main() { + print_sum(5, 6); +} + +fn print_sum(x: i32, y: i32) { + println!("sum is: {}", x + y); +} +``` + +You separate arguments with a comma, both when you call the function, as well +as when you declare it. + +Unlike `let`, you _must_ declare the types of function arguments. This does +not work: + +```{ignore} +fn print_number(x, y) { + println!("x is: {}", x + y); +} +``` + +You get this error: + +```text +hello.rs:5:18: 5:19 error: expected `:` but found `,` +hello.rs:5 fn print_number(x, y) { +``` + +This is a deliberate design decision. While full-program inference is possible, +languages which have it, like Haskell, often suggest that documenting your +types explicitly is a best-practice. We agree that forcing functions to declare +types while allowing for inference inside of function bodies is a wonderful +sweet spot between full inference and no inference. + +What about returning a value? Here's a function that adds one to an integer: + +```{rust} +fn add_one(x: i32) -> i32 { + x + 1 +} +``` + +Rust functions return exactly one value, and you declare the type after an +'arrow', which is a dash (`-`) followed by a greater-than sign (`>`). + +You'll note the lack of a semicolon here. If we added it in: + +```{ignore} +fn add_one(x: i32) -> i32 { + x + 1; +} +``` + +We would get an error: + +```text +error: not all control paths return a value +fn add_one(x: i32) -> i32 { + x + 1; +} + +help: consider removing this semicolon: + x + 1; + ^ +``` + +Remember our earlier discussions about semicolons and `()`? Our function claims +to return an `i32`, but with a semicolon, it would return `()` instead. Rust +realizes this probably isn't what we want, and suggests removing the semicolon. + +This is very much like our `if` statement before: the result of the block +(`{}`) is the value of the expression. Other expression-oriented languages, +such as Ruby, work like this, but it's a bit unusual in the systems programming +world. When people first learn about this, they usually assume that it +introduces bugs. But because Rust's type system is so strong, and because unit +is its own unique type, we have never seen an issue where adding or removing a +semicolon in a return position would cause a bug. + +But what about early returns? Rust does have a keyword for that, `return`: + +```{rust} +fn foo(x: i32) -> i32 { + if x < 5 { return x; } + + x + 1 +} +``` + +Using a `return` as the last line of a function works, but is considered poor +style: + +```{rust} +fn foo(x: i32) -> i32 { + if x < 5 { return x; } + + return x + 1; +} +``` + +There are some additional ways to define functions, but they involve features +that we haven't learned about yet, so let's just leave it at that for now. diff --git a/src/doc/trpl/generics.md b/src/doc/trpl/generics.md new file mode 100644 index 00000000000..137b66ea15a --- /dev/null +++ b/src/doc/trpl/generics.md @@ -0,0 +1,177 @@ +% Generics + +Sometimes, when writing a function or data type, we may want it to work for +multiple types of arguments. For example, remember our `OptionalInt` type? + +```{rust} +enum OptionalInt { + Value(int), + Missing, +} +``` + +If we wanted to also have an `OptionalFloat64`, we would need a new enum: + +```{rust} +enum OptionalFloat64 { + Valuef64(f64), + Missingf64, +} +``` + +This is really unfortunate. Luckily, Rust has a feature that gives us a better +way: generics. Generics are called **parametric polymorphism** in type theory, +which means that they are types or functions that have multiple forms ("poly" +is multiple, "morph" is form) over a given parameter ("parametric"). + +Anyway, enough with type theory declarations, let's check out the generic form +of `OptionalInt`. It is actually provided by Rust itself, and looks like this: + +```rust +enum Option<T> { + Some(T), + None, +} +``` + +The `<T>` part, which you've seen a few times before, indicates that this is +a generic data type. Inside the declaration of our enum, wherever we see a `T`, +we substitute that type for the same type used in the generic. Here's an +example of using `Option<T>`, with some extra type annotations: + +```{rust} +let x: Option<int> = Some(5i); +``` + +In the type declaration, we say `Option<int>`. Note how similar this looks to +`Option<T>`. So, in this particular `Option`, `T` has the value of `int`. On +the right-hand side of the binding, we do make a `Some(T)`, where `T` is `5i`. +Since that's an `int`, the two sides match, and Rust is happy. If they didn't +match, we'd get an error: + +```{rust,ignore} +let x: Option<f64> = Some(5i); +// error: mismatched types: expected `core::option::Option<f64>` +// but found `core::option::Option<int>` (expected f64 but found int) +``` + +That doesn't mean we can't make `Option<T>`s that hold an `f64`! They just have to +match up: + +```{rust} +let x: Option<int> = Some(5i); +let y: Option<f64> = Some(5.0f64); +``` + +This is just fine. One definition, multiple uses. + +Generics don't have to only be generic over one type. Consider Rust's built-in +`Result<T, E>` type: + +```{rust} +enum Result<T, E> { + Ok(T), + Err(E), +} +``` + +This type is generic over _two_ types: `T` and `E`. By the way, the capital letters +can be any letter you'd like. We could define `Result<T, E>` as: + +```{rust} +enum Result<H, N> { + Ok(H), + Err(N), +} +``` + +if we wanted to. Convention says that the first generic parameter should be +`T`, for 'type,' and that we use `E` for 'error.' Rust doesn't care, however. + +The `Result<T, E>` type is intended to +be used to return the result of a computation, and to have the ability to +return an error if it didn't work out. Here's an example: + +```{rust} +let x: Result<f64, String> = Ok(2.3f64); +let y: Result<f64, String> = Err("There was an error.".to_string()); +``` + +This particular Result will return an `f64` if there's a success, and a +`String` if there's a failure. Let's write a function that uses `Result<T, E>`: + +```{rust} +fn inverse(x: f64) -> Result<f64, String> { + if x == 0.0f64 { return Err("x cannot be zero!".to_string()); } + + Ok(1.0f64 / x) +} +``` + +We don't want to take the inverse of zero, so we check to make sure that we +weren't passed zero. If we were, then we return an `Err`, with a message. If +it's okay, we return an `Ok`, with the answer. + +Why does this matter? Well, remember how `match` does exhaustive matches? +Here's how this function gets used: + +```{rust} +# fn inverse(x: f64) -> Result<f64, String> { +# if x == 0.0f64 { return Err("x cannot be zero!".to_string()); } +# Ok(1.0f64 / x) +# } +let x = inverse(25.0f64); + +match x { + Ok(x) => println!("The inverse of 25 is {}", x), + Err(msg) => println!("Error: {}", msg), +} +``` + +The `match` enforces that we handle the `Err` case. In addition, because the +answer is wrapped up in an `Ok`, we can't just use the result without doing +the match: + +```{rust,ignore} +let x = inverse(25.0f64); +println!("{}", x + 2.0f64); // error: binary operation `+` cannot be applied + // to type `core::result::Result<f64,collections::string::String>` +``` + +This function is great, but there's one other problem: it only works for 64 bit +floating point values. What if we wanted to handle 32 bit floating point as +well? We'd have to write this: + +```{rust} +fn inverse32(x: f32) -> Result<f32, String> { + if x == 0.0f32 { return Err("x cannot be zero!".to_string()); } + + Ok(1.0f32 / x) +} +``` + +Bummer. What we need is a **generic function**. Luckily, we can write one! +However, it won't _quite_ work yet. Before we get into that, let's talk syntax. +A generic version of `inverse` would look something like this: + +```{rust,ignore} +fn inverse<T>(x: T) -> Result<T, String> { + if x == 0.0 { return Err("x cannot be zero!".to_string()); } + + Ok(1.0 / x) +} +``` + +Just like how we had `Option<T>`, we use a similar syntax for `inverse<T>`. +We can then use `T` inside the rest of the signature: `x` has type `T`, and half +of the `Result` has type `T`. However, if we try to compile that example, we'll get +an error: + +```text +error: binary operation `==` cannot be applied to type `T` +``` + +Because `T` can be _any_ type, it may be a type that doesn't implement `==`, +and therefore, the first line would be wrong. What do we do? + +To fix this example, we need to learn about another Rust feature: traits. diff --git a/src/doc/trpl/guessing-game.md b/src/doc/trpl/guessing-game.md new file mode 100644 index 00000000000..2847964f15f --- /dev/null +++ b/src/doc/trpl/guessing-game.md @@ -0,0 +1,891 @@ +% Guessing Game + +Okay! We've got the basics of Rust down. Let's write a bigger program. + +For our first project, we'll implement a classic beginner programming problem: +the guessing game. Here's how it works: Our program will generate a random +integer between one and a hundred. It will then prompt us to enter a guess. +Upon entering our guess, it will tell us if we're too low or too high. Once we +guess correctly, it will congratulate us. Sound good? + +## Set up + +Let's set up a new project. Go to your projects directory. Remember how we +had to create our directory structure and a `Cargo.toml` for `hello_world`? Cargo +has a command that does that for us. Let's give it a shot: + +```{bash} +$ cd ~/projects +$ cargo new guessing_game --bin +$ cd guessing_game +``` + +We pass the name of our project to `cargo new`, and then the `--bin` flag, +since we're making a binary, rather than a library. + +Check out the generated `Cargo.toml`: + +```toml +[package] + +name = "guessing_game" +version = "0.0.1" +authors = ["Your Name <you@example.com>"] +``` + +Cargo gets this information from your environment. If it's not correct, go ahead +and fix that. + +Finally, Cargo generated a "Hello, world!" for us. Check out `src/main.rs`: + +```{rust} +fn main() { + println!("Hello, world!") +} +``` + +Let's try compiling what Cargo gave us: + +```{bash} +$ cargo build + Compiling guessing_game v0.0.1 (file:///home/you/projects/guessing_game) +``` + +Excellent! Open up your `src/main.rs` again. We'll be writing all of +our code in this file. We'll talk about multiple-file projects later on in the +guide. + +Before we move on, let me show you one more Cargo command: `run`. `cargo run` +is kind of like `cargo build`, but it also then runs the produced executable. +Try it out: + +```bash +$ cargo run + Compiling guessing_game v0.0.1 (file:///home/you/projects/guessing_game) + Running `target/guessing_game` +Hello, world! +``` + +Great! The `run` command comes in handy when you need to rapidly iterate on a project. +Our game is just such a project, we need to quickly test each iteration before moving on to the next one. + +## Processing a Guess + +Let's get to it! The first thing we need to do for our guessing game is +allow our player to input a guess. Put this in your `src/main.rs`: + +```{rust,no_run} +use std::io; + +fn main() { + println!("Guess the number!"); + + println!("Please input your guess."); + + let input = io::stdin().read_line() + .ok() + .expect("Failed to read line"); + + println!("You guessed: {}", input); +} +``` + +You've seen this code before, when we talked about standard input. We +import the `std::io` module with `use`, and then our `main` function contains +our program's logic. We print a little message announcing the game, ask the +user to input a guess, get their input, and then print it out. + +Because we talked about this in the section on standard I/O, I won't go into +more details here. If you need a refresher, go re-read that section. + +## Generating a secret number + +Next, we need to generate a secret number. To do that, we need to use Rust's +random number generation, which we haven't talked about yet. Rust includes a +bunch of interesting functions in its standard library. If you need a bit of +code, it's possible that it's already been written for you! In this case, +we do know that Rust has random number generation, but we don't know how to +use it. + +Enter the docs. Rust has a page specifically to document the standard library. +You can find that page [here](../std/index.html). There's a lot of information on +that page, but the best part is the search bar. Right up at the top, there's +a box that you can enter in a search term. The search is pretty primitive +right now, but is getting better all the time. If you type 'random' in that +box, the page will update to [this one](../std/index.html?search=random). The very +first result is a link to [`std::rand::random`](../std/rand/fn.random.html). If we +click on that result, we'll be taken to its documentation page. + +This page shows us a few things: the type signature of the function, some +explanatory text, and then an example. Let's try to modify our code to add in the +`random` function and see what happens: + +```{rust,ignore} +use std::io; +use std::rand; + +fn main() { + println!("Guess the number!"); + + let secret_number = (rand::random() % 100) + 1; // secret_number: i32 + + println!("The secret number is: {}", secret_number); + + println!("Please input your guess."); + + let input = io::stdin().read_line() + .ok() + .expect("Failed to read line"); + + + println!("You guessed: {}", input); +} +``` + +The first thing we changed was to `use std::rand`, as the docs +explained. We then added in a `let` expression to create a variable binding +named `secret_number`, and we printed out its result. + +Also, you may wonder why we are using `%` on the result of `rand::random()`. +This operator is called 'modulo', and it returns the remainder of a division. +By taking the modulo of the result of `rand::random()`, we're limiting the +values to be between 0 and 99. Then, we add one to the result, making it from 1 +to 100. Using modulo can give you a very, very small bias in the result, but +for this example, it is not important. + +Let's try to compile this using `cargo build`: + +```bash +$ cargo build + Compiling guessing_game v0.0.1 (file:///home/you/projects/guessing_game) +src/main.rs:7:26: 7:34 error: the type of this value must be known in this context +src/main.rs:7 let secret_number = (rand::random() % 100) + 1; + ^~~~~~~~ +error: aborting due to previous error +``` + +It didn't work! Rust says "the type of this value must be known in this +context." What's up with that? Well, as it turns out, `rand::random()` can +generate many kinds of random values, not just integers. And in this case, Rust +isn't sure what kind of value `random()` should generate. So we have to help +it. With number literals, we can just add an `i32` onto the end to tell Rust they're +integers, but that does not work with functions. There's a different syntax, +and it looks like this: + +```{rust,ignore} +rand::random::<i32>(); +``` + +This says "please give me a random `i32` value." We can change our code to use +this hint: + +```{rust,no_run} +use std::io; +use std::rand; + +fn main() { + println!("Guess the number!"); + + let secret_number = (rand::random::<i32>() % 100) + 1; + + println!("The secret number is: {}", secret_number); + + println!("Please input your guess."); + + let input = io::stdin().read_line() + .ok() + .expect("Failed to read line"); + + + println!("You guessed: {}", input); +} +``` + +Try running our new program a few times: + +```bash +$ cargo run + Compiling guessing_game v0.0.1 (file:///home/you/projects/guessing_game) + Running `target/guessing_game` +Guess the number! +The secret number is: 7 +Please input your guess. +4 +You guessed: 4 +$ ./target/guessing_game +Guess the number! +The secret number is: 83 +Please input your guess. +5 +You guessed: 5 +$ ./target/guessing_game +Guess the number! +The secret number is: -29 +Please input your guess. +42 +You guessed: 42 +``` + +Wait. Negative 29? We wanted a number between one and a hundred! We have two +options here: we can either ask `random()` to generate an unsigned integer, which +can only be positive, or we can use the `abs()` function. Let's go with the +unsigned integer approach. If we want a random positive number, we should ask for +a random positive number. Our code looks like this now: + +```{rust,no_run} +use std::io; +use std::rand; + +fn main() { + println!("Guess the number!"); + + let secret_number = (rand::random::<uint>() % 100u) + 1u; + + println!("The secret number is: {}", secret_number); + + println!("Please input your guess."); + + let input = io::stdin().read_line() + .ok() + .expect("Failed to read line"); + + + println!("You guessed: {}", input); +} +``` + +And trying it out: + +```bash +$ cargo run + Compiling guessing_game v0.0.1 (file:///home/you/projects/guessing_game) + Running `target/guessing_game` +Guess the number! +The secret number is: 57 +Please input your guess. +3 +You guessed: 3 +``` + +Great! Next up: let's compare our guess to the secret guess. + +## Comparing guesses + +If you remember, earlier in the guide, we made a `cmp` function that compared +two numbers. Let's add that in, along with a `match` statement to compare our +guess to the secret number: + +```{rust,ignore} +use std::io; +use std::rand; +use std::cmp::Ordering; + +fn main() { + println!("Guess the number!"); + + let secret_number = (rand::random::<uint>() % 100u) + 1u; + + println!("The secret number is: {}", secret_number); + + println!("Please input your guess."); + + let input = io::stdin().read_line() + .ok() + .expect("Failed to read line"); + + + println!("You guessed: {}", input); + + match cmp(input, secret_number) { + Ordering::Less => println!("Too small!"), + Ordering::Greater => println!("Too big!"), + Ordering::Equal => println!("You win!"), + } +} + +fn cmp(a: i32, b: i32) -> Ordering { + if a < b { Ordering::Less } + else if a > b { Ordering::Greater } + else { Ordering::Equal } +} +``` + +If we try to compile, we'll get some errors: + +```bash +$ cargo build + Compiling guessing_game v0.0.1 (file:///home/you/projects/guessing_game) +src/main.rs:20:15: 20:20 error: mismatched types: expected `i32` but found `collections::string::String` (expected i32 but found struct collections::string::String) +src/main.rs:20 match cmp(input, secret_number) { + ^~~~~ +src/main.rs:20:22: 20:35 error: mismatched types: expected `i32` but found `uint` (expected i32 but found uint) +src/main.rs:20 match cmp(input, secret_number) { + ^~~~~~~~~~~~~ +error: aborting due to 2 previous errors +``` + +This often happens when writing Rust programs, and is one of Rust's greatest +strengths. You try out some code, see if it compiles, and Rust tells you that +you've done something wrong. In this case, our `cmp` function works on integers, +but we've given it unsigned integers. In this case, the fix is easy, because +we wrote the `cmp` function! Let's change it to take `uint`s: + +```{rust,ignore} +use std::io; +use std::rand; +use std::cmp::Ordering; + +fn main() { + println!("Guess the number!"); + + let secret_number = (rand::random::<uint>() % 100u) + 1u; + + println!("The secret number is: {}", secret_number); + + println!("Please input your guess."); + + let input = io::stdin().read_line() + .ok() + .expect("Failed to read line"); + + + println!("You guessed: {}", input); + + match cmp(input, secret_number) { + Ordering::Less => println!("Too small!"), + Ordering::Greater => println!("Too big!"), + Ordering::Equal => println!("You win!"), + } +} + +fn cmp(a: uint, b: uint) -> Ordering { + if a < b { Ordering::Less } + else if a > b { Ordering::Greater } + else { Ordering::Equal } +} +``` + +And try compiling again: + +```bash +$ cargo build + Compiling guessing_game v0.0.1 (file:///home/you/projects/guessing_game) +src/main.rs:20:15: 20:20 error: mismatched types: expected `uint` but found `collections::string::String` (expected uint but found struct collections::string::String) +src/main.rs:20 match cmp(input, secret_number) { + ^~~~~ +error: aborting due to previous error +``` + +This error is similar to the last one: we expected to get a `uint`, but we got +a `String` instead! That's because our `input` variable is coming from the +standard input, and you can guess anything. Try it: + +```bash +$ ./target/guessing_game +Guess the number! +The secret number is: 73 +Please input your guess. +hello +You guessed: hello +``` + +Oops! Also, you'll note that we just ran our program even though it didn't compile. +This works because the older version we did successfully compile was still lying +around. Gotta be careful! + +Anyway, we have a `String`, but we need a `uint`. What to do? Well, there's +a function for that: + +```{rust,ignore} +let input = io::stdin().read_line() + .ok() + .expect("Failed to read line"); +let input_num: Option<uint> = input.parse(); +``` + +The `parse` function takes in a `&str` value and converts it into something. +We tell it what kind of something with a type hint. Remember our type hint with +`random()`? It looked like this: + +```{rust,ignore} +rand::random::<uint>(); +``` + +There's an alternate way of providing a hint too, and that's declaring the type +in a `let`: + +```{rust,ignore} +let x: uint = rand::random(); +``` + +In this case, we say `x` is a `uint` explicitly, so Rust is able to properly +tell `random()` what to generate. In a similar fashion, both of these work: + +```{rust,ignore} +let input_num = "5".parse::<uint>(); // input_num: Option<uint> +let input_num: Option<uint> = "5".parse(); // input_num: Option<uint> +``` + +Anyway, with us now converting our input to a number, our code looks like this: + +```{rust,ignore} +use std::io; +use std::rand; +use std::cmp::Ordering; + +fn main() { + println!("Guess the number!"); + + let secret_number = (rand::random::<uint>() % 100u) + 1u; + + println!("The secret number is: {}", secret_number); + + println!("Please input your guess."); + + let input = io::stdin().read_line() + .ok() + .expect("Failed to read line"); + let input_num: Option<uint> = input.parse(); + + println!("You guessed: {}", input_num); + + match cmp(input_num, secret_number) { + Ordering::Less => println!("Too small!"), + Ordering::Greater => println!("Too big!"), + Ordering::Equal => println!("You win!"), + } +} + +fn cmp(a: uint, b: uint) -> Ordering { + if a < b { Ordering::Less } + else if a > b { Ordering::Greater } + else { Ordering::Equal } +} +``` + +Let's try it out! + +```bash +$ cargo build + Compiling guessing_game v0.0.1 (file:///home/you/projects/guessing_game) +src/main.rs:22:15: 22:24 error: mismatched types: expected `uint` but found `core::option::Option<uint>` (expected uint but found enum core::option::Option) +src/main.rs:22 match cmp(input_num, secret_number) { + ^~~~~~~~~ +error: aborting due to previous error +``` + +Oh yeah! Our `input_num` has the type `Option<uint>`, rather than `uint`. We +need to unwrap the Option. If you remember from before, `match` is a great way +to do that. Try this code: + +```{rust,no_run} +use std::io; +use std::rand; +use std::cmp::Ordering; + +fn main() { + println!("Guess the number!"); + + let secret_number = (rand::random::<uint>() % 100u) + 1u; + + println!("The secret number is: {}", secret_number); + + println!("Please input your guess."); + + let input = io::stdin().read_line() + .ok() + .expect("Failed to read line"); + let input_num: Option<uint> = input.parse(); + + let num = match input_num { + Some(num) => num, + None => { + println!("Please input a number!"); + return; + } + }; + + + println!("You guessed: {}", num); + + match cmp(num, secret_number) { + Ordering::Less => println!("Too small!"), + Ordering::Greater => println!("Too big!"), + Ordering::Equal => println!("You win!"), + } +} + +fn cmp(a: uint, b: uint) -> Ordering { + if a < b { Ordering::Less } + else if a > b { Ordering::Greater } + else { Ordering::Equal } +} +``` + +We use a `match` to either give us the `uint` inside of the `Option`, or else +print an error message and return. Let's give this a shot: + +```bash +$ cargo run + Compiling guessing_game v0.0.1 (file:///home/you/projects/guessing_game) + Running `target/guessing_game` +Guess the number! +The secret number is: 17 +Please input your guess. +5 +Please input a number! +``` + +Uh, what? But we did! + +... actually, we didn't. See, when you get a line of input from `stdin()`, +you get all the input. Including the `\n` character from you pressing Enter. +Therefore, `parse()` sees the string `"5\n"` and says "nope, that's not a +number; there's non-number stuff in there!" Luckily for us, `&str`s have an easy +method we can use defined on them: `trim()`. One small modification, and our +code looks like this: + +```{rust,no_run} +use std::io; +use std::rand; +use std::cmp::Ordering; + +fn main() { + println!("Guess the number!"); + + let secret_number = (rand::random::<uint>() % 100u) + 1u; + + println!("The secret number is: {}", secret_number); + + println!("Please input your guess."); + + let input = io::stdin().read_line() + .ok() + .expect("Failed to read line"); + let input_num: Option<uint> = input.trim().parse(); + + let num = match input_num { + Some(num) => num, + None => { + println!("Please input a number!"); + return; + } + }; + + + println!("You guessed: {}", num); + + match cmp(num, secret_number) { + Ordering::Less => println!("Too small!"), + Ordering::Greater => println!("Too big!"), + Ordering::Equal => println!("You win!"), + } +} + +fn cmp(a: uint, b: uint) -> Ordering { + if a < b { Ordering::Less } + else if a > b { Ordering::Greater } + else { Ordering::Equal } +} +``` + +Let's try it! + +```bash +$ cargo run + Compiling guessing_game v0.0.1 (file:///home/you/projects/guessing_game) + Running `target/guessing_game` +Guess the number! +The secret number is: 58 +Please input your guess. + 76 +You guessed: 76 +Too big! +``` + +Nice! You can see I even added spaces before my guess, and it still figured +out that I guessed 76. Run the program a few times, and verify that guessing +the number works, as well as guessing a number too small. + +The Rust compiler helped us out quite a bit there! This technique is called +"lean on the compiler", and it's often useful when working on some code. Let +the error messages help guide you towards the correct types. + +Now we've got most of the game working, but we can only make one guess. Let's +change that by adding loops! + +## Looping + +As we already discussed, the `loop` keyword gives us an infinite loop. +Let's add that in: + +```{rust,no_run} +use std::io; +use std::rand; +use std::cmp::Ordering; + +fn main() { + println!("Guess the number!"); + + let secret_number = (rand::random::<uint>() % 100u) + 1u; + + println!("The secret number is: {}", secret_number); + + loop { + + println!("Please input your guess."); + + let input = io::stdin().read_line() + .ok() + .expect("Failed to read line"); + let input_num: Option<uint> = input.trim().parse(); + + let num = match input_num { + Some(num) => num, + None => { + println!("Please input a number!"); + return; + } + }; + + + println!("You guessed: {}", num); + + match cmp(num, secret_number) { + Ordering::Less => println!("Too small!"), + Ordering::Greater => println!("Too big!"), + Ordering::Equal => println!("You win!"), + } + } +} + +fn cmp(a: uint, b: uint) -> Ordering { + if a < b { Ordering::Less } + else if a > b { Ordering::Greater } + else { Ordering::Equal } +} +``` + +And try it out. But wait, didn't we just add an infinite loop? Yup. Remember +that `return`? If we give a non-number answer, we'll `return` and quit. Observe: + +```bash +$ cargo run + Compiling guessing_game v0.0.1 (file:///home/you/projects/guessing_game) + Running `target/guessing_game` +Guess the number! +The secret number is: 59 +Please input your guess. +45 +You guessed: 45 +Too small! +Please input your guess. +60 +You guessed: 60 +Too big! +Please input your guess. +59 +You guessed: 59 +You win! +Please input your guess. +quit +Please input a number! +``` + +Ha! `quit` actually quits. As does any other non-number input. Well, this is +suboptimal to say the least. First, let's actually quit when you win the game: + +```{rust,no_run} +use std::io; +use std::rand; +use std::cmp::Ordering; + +fn main() { + println!("Guess the number!"); + + let secret_number = (rand::random::<uint>() % 100u) + 1u; + + println!("The secret number is: {}", secret_number); + + loop { + + println!("Please input your guess."); + + let input = io::stdin().read_line() + .ok() + .expect("Failed to read line"); + let input_num: Option<uint> = input.trim().parse(); + + let num = match input_num { + Some(num) => num, + None => { + println!("Please input a number!"); + return; + } + }; + + + println!("You guessed: {}", num); + + match cmp(num, secret_number) { + Ordering::Less => println!("Too small!"), + Ordering::Greater => println!("Too big!"), + Ordering::Equal => { + println!("You win!"); + return; + }, + } + } +} + +fn cmp(a: uint, b: uint) -> Ordering { + if a < b { Ordering::Less } + else if a > b { Ordering::Greater } + else { Ordering::Equal } +} +``` + +By adding the `return` line after the `You win!`, we'll exit the program when +we win. We have just one more tweak to make: when someone inputs a non-number, +we don't want to quit, we just want to ignore it. Change that `return` to +`continue`: + + +```{rust,no_run} +use std::io; +use std::rand; +use std::cmp::Ordering; + +fn main() { + println!("Guess the number!"); + + let secret_number = (rand::random::<uint>() % 100u) + 1u; + + println!("The secret number is: {}", secret_number); + + loop { + + println!("Please input your guess."); + + let input = io::stdin().read_line() + .ok() + .expect("Failed to read line"); + let input_num: Option<uint> = input.trim().parse(); + + let num = match input_num { + Some(num) => num, + None => { + println!("Please input a number!"); + continue; + } + }; + + + println!("You guessed: {}", num); + + match cmp(num, secret_number) { + Ordering::Less => println!("Too small!"), + Ordering::Greater => println!("Too big!"), + Ordering::Equal => { + println!("You win!"); + return; + }, + } + } +} + +fn cmp(a: uint, b: uint) -> Ordering { + if a < b { Ordering::Less } + else if a > b { Ordering::Greater } + else { Ordering::Equal } +} +``` + +Now we should be good! Let's try: + +```bash +$ cargo run + Compiling guessing_game v0.0.1 (file:///home/you/projects/guessing_game) + Running `target/guessing_game` +Guess the number! +The secret number is: 61 +Please input your guess. +10 +You guessed: 10 +Too small! +Please input your guess. +99 +You guessed: 99 +Too big! +Please input your guess. +foo +Please input a number! +Please input your guess. +61 +You guessed: 61 +You win! +``` + +Awesome! With one tiny last tweak, we have finished the guessing game. Can you +think of what it is? That's right, we don't want to print out the secret number. +It was good for testing, but it kind of ruins the game. Here's our final source: + +```{rust,no_run} +use std::io; +use std::rand; +use std::cmp::Ordering; + +fn main() { + println!("Guess the number!"); + + let secret_number = (rand::random::<uint>() % 100u) + 1u; + + loop { + + println!("Please input your guess."); + + let input = io::stdin().read_line() + .ok() + .expect("Failed to read line"); + let input_num: Option<uint> = input.trim().parse(); + + let num = match input_num { + Some(num) => num, + None => { + println!("Please input a number!"); + continue; + } + }; + + + println!("You guessed: {}", num); + + match cmp(num, secret_number) { + Ordering::Less => println!("Too small!"), + Ordering::Greater => println!("Too big!"), + Ordering::Equal => { + println!("You win!"); + return; + }, + } + } +} + +fn cmp(a: uint, b: uint) -> Ordering { + if a < b { Ordering::Less } + else if a > b { Ordering::Greater } + else { Ordering::Equal } +} +``` + +## Complete! + +At this point, you have successfully built the Guessing Game! Congratulations! + +You've now learned the basic syntax of Rust. All of this is relatively close to +various other programming languages you have used in the past. These +fundamental syntactical and semantic elements will form the foundation for the +rest of your Rust education. + +Now that you're an expert at the basics, it's time to learn about some of +Rust's more unique features. diff --git a/src/doc/trpl/hello-cargo.md b/src/doc/trpl/hello-cargo.md new file mode 100644 index 00000000000..d8acd95b59d --- /dev/null +++ b/src/doc/trpl/hello-cargo.md @@ -0,0 +1,108 @@ +% Hello, Cargo! + +[Cargo](http://crates.io) is a tool that Rustaceans use to help manage their +Rust projects. Cargo is currently in an alpha state, just like Rust, and so it +is still a work in progress. However, it is already good enough to use for many +Rust projects, and so it is assumed that Rust projects will use Cargo from the +beginning. + +Cargo manages three things: building your code, downloading the dependencies +your code needs, and building the dependencies your code needs. At first, your +program doesn't have any dependencies, so we'll only be using the first part of +its functionality. Eventually, we'll add more. Since we started off by using +Cargo, it'll be easy to add later. + +If you installed Rust via the official installers you will also have +Cargo. If you installed Rust some other way, you may want to [check +the Cargo +README](https://github.com/rust-lang/cargo#installing-cargo-from-nightlies) +for specific instructions about installing it. + +Let's convert Hello World to Cargo. + +To Cargo-ify our project, we need to do two things: Make a `Cargo.toml` +configuration file, and put our source file in the right place. Let's +do that part first: + +```{bash} +$ mkdir src +$ mv main.rs src/main.rs +``` + +Cargo expects your source files to live inside a `src` directory. That leaves +the top level for other things, like READMEs, license information, and anything +not related to your code. Cargo helps us keep our projects nice and tidy. A +place for everything, and everything in its place. + +Next, our configuration file: + +```{bash} +$ editor Cargo.toml +``` + +Make sure to get this name right: you need the capital `C`! + +Put this inside: + +```toml +[package] + +name = "hello_world" +version = "0.0.1" +authors = [ "Your name <you@example.com>" ] + +[[bin]] + +name = "hello_world" +``` + +This file is in the [TOML](https://github.com/toml-lang/toml) format. Let's let +it explain itself to you: + +> TOML aims to be a minimal configuration file format that's easy to read due +> to obvious semantics. TOML is designed to map unambiguously to a hash table. +> TOML should be easy to parse into data structures in a wide variety of +> languages. + +TOML is very similar to INI, but with some extra goodies. + +Anyway, there are two **table**s in this file: `package` and `bin`. The first +tells Cargo metadata about your package. The second tells Cargo that we're +interested in building a binary, not a library (though we could do both!), as +well as what it is named. + +Once you have this file in place, we should be ready to build! Try this: + +```{bash} +$ cargo build + Compiling hello_world v0.0.1 (file:///home/yourname/projects/hello_world) +$ ./target/hello_world +Hello, world! +``` + +Bam! We build our project with `cargo build`, and run it with +`./target/hello_world`. This hasn't bought us a whole lot over our simple use +of `rustc`, but think about the future: when our project has more than one +file, we would need to call `rustc` more than once, and pass it a bunch of options to +tell it to build everything together. With Cargo, as our project grows, we can +just `cargo build` and it'll work the right way. + +You'll also notice that Cargo has created a new file: `Cargo.lock`. + +```toml +[root] +name = "hello_world" +version = "0.0.1" +``` + +This file is used by Cargo to keep track of dependencies in your application. +Right now, we don't have any, so it's a bit sparse. You won't ever need +to touch this file yourself, just let Cargo handle it. + +That's it! We've successfully built `hello_world` with Cargo. Even though our +program is simple, it's using much of the real tooling that you'll use for the +rest of your Rust career. + +Now that you've got the tools down, let's actually learn more about the Rust +language itself. These are the basics that will serve you well through the rest +of your time with Rust. diff --git a/src/doc/trpl/hello-world.md b/src/doc/trpl/hello-world.md new file mode 100644 index 00000000000..f9cc1ebf0bf --- /dev/null +++ b/src/doc/trpl/hello-world.md @@ -0,0 +1,164 @@ +% Hello, world! + +Now that you have Rust installed, let's write your first Rust program. It's +traditional to make your first program in any new language one that prints the +text "Hello, world!" to the screen. The nice thing about starting with such a +simple program is that you can verify that your compiler isn't just installed, +but also working properly. And printing information to the screen is a pretty +common thing to do. + +The first thing that we need to do is make a file to put our code in. I like +to make a `projects` directory in my home directory, and keep all my projects +there. Rust does not care where your code lives. + +This actually leads to one other concern we should address: this guide will +assume that you have basic familiarity with the command line. Rust does not +require that you know a whole ton about the command line, but until the +language is in a more finished state, IDE support is spotty. Rust makes no +specific demands on your editing tooling, or where your code lives. + +With that said, let's make a directory in our projects directory. + +```{bash} +$ mkdir ~/projects +$ cd ~/projects +$ mkdir hello_world +$ cd hello_world +``` + +If you're on Windows and not using PowerShell, the `~` may not work. Consult +the documentation for your shell for more details. + +Let's make a new source file next. I'm going to use the syntax `editor +filename` to represent editing a file in these examples, but you should use +whatever method you want. We'll call our file `main.rs`: + +```{bash} +$ editor main.rs +``` + +Rust files always end in a `.rs` extension. If you're using more than one word +in your filename, use an underscore. `hello_world.rs` rather than +`helloworld.rs`. + +Now that you've got your file open, type this in: + +```{rust} +fn main() { + println!("Hello, world!"); +} +``` + +Save the file, and then type this into your terminal window: + +```{bash} +$ rustc main.rs +$ ./main # or main.exe on Windows +Hello, world! +``` + +You can also run these examples on [play.rust-lang.org](http://play.rust-lang.org/) by clicking on the arrow that appears in the upper right of the example when you mouse over the code. + +Success! Let's go over what just happened in detail. + +```{rust} +fn main() { + +} +``` + +These lines define a **function** in Rust. The `main` function is special: +it's the beginning of every Rust program. The first line says "I'm declaring a +function named `main`, which takes no arguments and returns nothing." If there +were arguments, they would go inside the parentheses (`(` and `)`), and because +we aren't returning anything from this function, we've dropped that notation +entirely. We'll get to it later. + +You'll also note that the function is wrapped in curly braces (`{` and `}`). +Rust requires these around all function bodies. It is also considered good +style to put the opening curly brace on the same line as the function +declaration, with one space in between. + +Next up is this line: + +```{rust} + println!("Hello, world!"); +``` + +This line does all of the work in our little program. There are a number of +details that are important here. The first is that it's indented with four +spaces, not tabs. Please configure your editor of choice to insert four spaces +with the tab key. We provide some [sample configurations for various +editors](https://github.com/rust-lang/rust/tree/master/src/etc). + +The second point is the `println!()` part. This is calling a Rust **macro**, +which is how metaprogramming is done in Rust. If it were a function instead, it +would look like this: `println()`. For our purposes, we don't need to worry +about this difference. Just know that sometimes, you'll see a `!`, and that +means that you're calling a macro instead of a normal function. Rust implements +`println!` as a macro rather than a function for good reasons, but that's a +very advanced topic. You'll learn more when we talk about macros later. One +last thing to mention: Rust's macros are significantly different from C macros, +if you've used those. Don't be scared of using macros. We'll get to the details +eventually, you'll just have to trust us for now. + +Next, `"Hello, world!"` is a **string**. Strings are a surprisingly complicated +topic in a systems programming language, and this is a **statically allocated** +string. We will talk more about different kinds of allocation later. We pass +this string as an argument to `println!`, which prints the string to the +screen. Easy enough! + +Finally, the line ends with a semicolon (`;`). Rust is an **expression +oriented** language, which means that most things are expressions. The `;` is +used to indicate that this expression is over, and the next one is ready to +begin. Most lines of Rust code end with a `;`. We will cover this in-depth +later in the guide. + +Finally, actually **compiling** and **running** our program. We can compile +with our compiler, `rustc`, by passing it the name of our source file: + +```{bash} +$ rustc main.rs +``` + +This is similar to `gcc` or `clang`, if you come from a C or C++ background. Rust +will output a binary executable. You can see it with `ls`: + +```{bash} +$ ls +main main.rs +``` + +Or on Windows: + +```{bash} +$ dir +main.exe main.rs +``` + +There are now two files: our source code, with the `.rs` extension, and the +executable (`main.exe` on Windows, `main` everywhere else) + +```{bash} +$ ./main # or main.exe on Windows +``` + +This prints out our `Hello, world!` text to our terminal. + +If you come from a dynamically typed language like Ruby, Python, or JavaScript, +you may not be used to these two steps being separate. Rust is an +**ahead-of-time compiled language**, which means that you can compile a +program, give it to someone else, and they don't need to have Rust installed. +If you give someone a `.rb` or `.py` or `.js` file, they need to have +Ruby/Python/JavaScript installed, but you just need one command to both compile +and run your program. Everything is a tradeoff in language design, and Rust has +made its choice. + +Congratulations! You have officially written a Rust program. That makes you a +Rust programmer! Welcome. + +Next, I'd like to introduce you to another tool, Cargo, which is used to write +real-world Rust programs. Just using `rustc` is nice for simple things, but as +your project grows, you'll want something to help you manage all of the options +that it has, and to make it easy to share your code with other people and +projects. diff --git a/src/doc/trpl/if.md b/src/doc/trpl/if.md new file mode 100644 index 00000000000..6f81a27b2b7 --- /dev/null +++ b/src/doc/trpl/if.md @@ -0,0 +1,141 @@ +% `if` + +Rust's take on `if` is not particularly complex, but it's much more like the +`if` you'll find in a dynamically typed language than in a more traditional +systems language. So let's talk about it, to make sure you grasp the nuances. + +`if` is a specific form of a more general concept, the 'branch.' The name comes +from a branch in a tree: a decision point, where depending on a choice, +multiple paths can be taken. + +In the case of `if`, there is one choice that leads down two paths: + +```rust +let x = 5; + +if x == 5 { + println!("x is five!"); +} +``` + +If we changed the value of `x` to something else, this line would not print. +More specifically, if the expression after the `if` evaluates to `true`, then +the block is executed. If it's `false`, then it is not. + +If you want something to happen in the `false` case, use an `else`: + +```{rust} +let x = 5; + +if x == 5 { + println!("x is five!"); +} else { + println!("x is not five :("); +} +``` + +This is all pretty standard. However, you can also do this: + + +```{rust} +let x = 5; + +let y = if x == 5 { + 10 +} else { + 15 +}; // y: i32 +``` + +Which we can (and probably should) write like this: + +```{rust} +let x = 5; + +let y = if x == 5 { 10 } else { 15 }; // y: i32 +``` + +This reveals two interesting things about Rust: it is an expression-based +language, and semicolons are different from semicolons in other 'curly brace +and semicolon'-based languages. These two things are related. + +## Expressions vs. Statements + +Rust is primarily an expression based language. There are only two kinds of +statements, and everything else is an expression. + +So what's the difference? Expressions return a value, and statements do not. +In many languages, `if` is a statement, and therefore, `let x = if ...` would +make no sense. But in Rust, `if` is an expression, which means that it returns +a value. We can then use this value to initialize the binding. + +Speaking of which, bindings are a kind of the first of Rust's two statements. +The proper name is a **declaration statement**. So far, `let` is the only kind +of declaration statement we've seen. Let's talk about that some more. + +In some languages, variable bindings can be written as expressions, not just +statements. Like Ruby: + +```{ruby} +x = y = 5 +``` + +In Rust, however, using `let` to introduce a binding is _not_ an expression. The +following will produce a compile-time error: + +```{ignore} +let x = (let y = 5); // expected identifier, found keyword `let` +``` + +The compiler is telling us here that it was expecting to see the beginning of +an expression, and a `let` can only begin a statement, not an expression. + +Note that assigning to an already-bound variable (e.g. `y = 5`) is still an +expression, although its value is not particularly useful. Unlike C, where an +assignment evaluates to the assigned value (e.g. `5` in the previous example), +in Rust the value of an assignment is the unit type `()` (which we'll cover later). + +The second kind of statement in Rust is the **expression statement**. Its +purpose is to turn any expression into a statement. In practical terms, Rust's +grammar expects statements to follow other statements. This means that you use +semicolons to separate expressions from each other. This means that Rust +looks a lot like most other languages that require you to use semicolons +at the end of every line, and you will see semicolons at the end of almost +every line of Rust code you see. + +What is this exception that makes us say 'almost?' You saw it already, in this +code: + +```{rust} +let x = 5; + +let y: i32 = if x == 5 { 10 } else { 15 }; +``` + +Note that I've added the type annotation to `y`, to specify explicitly that I +want `y` to be an integer. + +This is not the same as this, which won't compile: + +```{ignore} +let x = 5; + +let y: i32 = if x == 5 { 10; } else { 15; }; +``` + +Note the semicolons after the 10 and 15. Rust will give us the following error: + +```text +error: mismatched types: expected `i32` but found `()` (expected i32 but found ()) +``` + +We expected an integer, but we got `()`. `()` is pronounced 'unit', and is a +special type in Rust's type system. In Rust, `()` is _not_ a valid value for a +variable of type `i32`. It's only a valid value for variables of the type `()`, +which aren't very useful. Remember how we said statements don't return a value? +Well, that's the purpose of unit in this case. The semicolon turns any +expression into a statement by throwing away its value and returning unit +instead. + +There's one more time in which you won't see a semicolon at the end of a line +of Rust code. For that, we'll need our next concept: functions. diff --git a/src/doc/trpl/installing-rust.md b/src/doc/trpl/installing-rust.md new file mode 100644 index 00000000000..5893b51a420 --- /dev/null +++ b/src/doc/trpl/installing-rust.md @@ -0,0 +1,89 @@ +% Installing Rust + +The first step to using Rust is to install it! There are a number of ways to +install Rust, but the easiest is to use the `rustup` script. If you're on +Linux or a Mac, all you need to do is this (note that you don't need to type +in the `$`s, they just indicate the start of each command): + +```bash +$ curl -L https://static.rust-lang.org/rustup.sh | sudo sh +``` + +If you're concerned about the [potential insecurity](http://curlpipesh.tumblr.com/) of using `curl | sudo sh`, +please keep reading and see our disclaimer below. And feel free to use a two-step version of the installation and examine our installation script: + +```bash +$ curl -L https://static.rust-lang.org/rustup.sh -O +$ sudo sh rustup.sh +``` + +If you're on Windows, please download either the [32-bit +installer](https://static.rust-lang.org/dist/rust-nightly-i686-pc-windows-gnu.exe) +or the [64-bit +installer](https://static.rust-lang.org/dist/rust-nightly-x86_64-pc-windows-gnu.exe) +and run it. + +If you decide you don't want Rust anymore, we'll be a bit sad, but that's okay. +Not every programming language is great for everyone. Just pass an argument to +the script: + +```bash +$ curl -s https://static.rust-lang.org/rustup.sh | sudo sh -s -- --uninstall +``` + +If you used the Windows installer, just re-run the `.exe` and it will give you +an uninstall option. + +You can re-run this script any time you want to update Rust. Which, at this +point, is often. Rust is still pre-1.0, and so people assume that you're using +a very recent Rust. + +This brings me to one other point: some people, and somewhat rightfully so, get +very upset when we tell you to `curl | sudo sh`. And they should be! Basically, +when you do this, you are trusting that the good people who maintain Rust +aren't going to hack your computer and do bad things. That's a good instinct! +If you're one of those people, please check out the documentation on [building +Rust from Source](https://github.com/rust-lang/rust#building-from-source), or +[the official binary downloads](http://www.rust-lang.org/install.html). And we +promise that this method will not be the way to install Rust forever: it's just +the easiest way to keep people updated while Rust is in its alpha state. + +Oh, we should also mention the officially supported platforms: + +* Windows (7, 8, Server 2008 R2) +* Linux (2.6.18 or later, various distributions), x86 and x86-64 +* OSX 10.7 (Lion) or greater, x86 and x86-64 + +We extensively test Rust on these platforms, and a few others, too, like +Android. But these are the ones most likely to work, as they have the most +testing. + +Finally, a comment about Windows. Rust considers Windows to be a first-class +platform upon release, but if we're honest, the Windows experience isn't as +integrated as the Linux/OS X experience is. We're working on it! If anything +does not work, it is a bug. Please let us know if that happens. Each and every +commit is tested against Windows just like any other platform. + +If you've got Rust installed, you can open up a shell, and type this: + +```bash +$ rustc --version +``` + +You should see some output that looks something like this: + +```bash +rustc 1.0.0-nightly (f11f3e7ba 2015-01-04 20:02:14 +0000) +``` + +If you did, Rust has been installed successfully! Congrats! + +If not, there are a number of places where you can get help. The easiest is +[the #rust IRC channel on irc.mozilla.org](irc://irc.mozilla.org/#rust), which +you can access through +[Mibbit](http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust). Click +that link, and you'll be chatting with other Rustaceans (a silly nickname we +call ourselves), and we can help you out. Other great resources include [our +forum](http://discuss.rust-lang.org/), [the /r/rust +subreddit](http://www.reddit.com/r/rust), and [Stack +Overflow](http://stackoverflow.com/questions/tagged/rust). diff --git a/src/doc/trpl/intermediate.md b/src/doc/trpl/intermediate.md new file mode 100644 index 00000000000..73370a32231 --- /dev/null +++ b/src/doc/trpl/intermediate.md @@ -0,0 +1,7 @@ +% Intermediate + +This section contains individual chapters, which are self-contained. They focus +on specific topics, and can be read in any order. + +After reading "Intermediate," you will have a solid understanding of Rust, +and will be able to understand most Rust code and write more complex programs. diff --git a/src/doc/trpl/iterators.md b/src/doc/trpl/iterators.md new file mode 100644 index 00000000000..a773b7329db --- /dev/null +++ b/src/doc/trpl/iterators.md @@ -0,0 +1,339 @@ +% Iterators + +Let's talk about loops. + +Remember Rust's `for` loop? Here's an example: + +```{rust} +for x in range(0i, 10i) { + println!("{}", x); +} +``` + +Now that you know more Rust, we can talk in detail about how this works. The +`range` function returns an **iterator**. An iterator is something that we can +call the `.next()` method on repeatedly, and it gives us a sequence of things. + +Like this: + +```{rust} +let mut range = range(0i, 10i); + +loop { + match range.next() { + Some(x) => { + println!("{}", x); + }, + None => { break } + } +} +``` + +We make a mutable binding to the return value of `range`, which is our iterator. +We then `loop`, with an inner `match`. This `match` is used on the result of +`range.next()`, which gives us a reference to the next value of the iterator. +`next` returns an `Option<int>`, in this case, which will be `Some(int)` when +we have a value and `None` once we run out. If we get `Some(int)`, we print it +out, and if we get `None`, we `break` out of the loop. + +This code sample is basically the same as our `for` loop version. The `for` +loop is just a handy way to write this `loop`/`match`/`break` construct. + +`for` loops aren't the only thing that uses iterators, however. Writing your +own iterator involves implementing the `Iterator` trait. While doing that is +outside of the scope of this guide, Rust provides a number of useful iterators +to accomplish various tasks. Before we talk about those, we should talk about a +Rust anti-pattern. And that's `range`. + +Yes, we just talked about how `range` is cool. But `range` is also very +primitive. For example, if you needed to iterate over the contents of +a vector, you may be tempted to write this: + +```{rust} +let nums = vec![1i, 2i, 3i]; + +for i in range(0u, nums.len()) { + println!("{}", nums[i]); +} +``` + +This is strictly worse than using an actual iterator. The `.iter()` method on +vectors returns an iterator which iterates through a reference to each element +of the vector in turn. So write this: + +```{rust} +let nums = vec![1i, 2i, 3i]; + +for num in nums.iter() { + println!("{}", num); +} +``` + +There are two reasons for this. First, this more directly expresses what we +mean. We iterate through the entire vector, rather than iterating through +indexes, and then indexing the vector. Second, this version is more efficient: +the first version will have extra bounds checking because it used indexing, +`nums[i]`. But since we yield a reference to each element of the vector in turn +with the iterator, there's no bounds checking in the second example. This is +very common with iterators: we can ignore unnecessary bounds checks, but still +know that we're safe. + +There's another detail here that's not 100% clear because of how `println!` +works. `num` is actually of type `&int`. That is, it's a reference to an `int`, +not an `int` itself. `println!` handles the dereferencing for us, so we don't +see it. This code works fine too: + +```{rust} +let nums = vec![1i, 2i, 3i]; + +for num in nums.iter() { + println!("{}", *num); +} +``` + +Now we're explicitly dereferencing `num`. Why does `iter()` give us references? +Well, if it gave us the data itself, we would have to be its owner, which would +involve making a copy of the data and giving us the copy. With references, +we're just borrowing a reference to the data, and so it's just passing +a reference, without needing to do the copy. + +So, now that we've established that `range` is often not what you want, let's +talk about what you do want instead. + +There are three broad classes of things that are relevant here: iterators, +**iterator adapters**, and **consumers**. Here's some definitions: + +* 'iterators' give you a sequence of values. +* 'iterator adapters' operate on an iterator, producing a new iterator with a + different output sequence. +* 'consumers' operate on an iterator, producing some final set of values. + +Let's talk about consumers first, since you've already seen an iterator, +`range`. + +## Consumers + +A 'consumer' operates on an iterator, returning some kind of value or values. +The most common consumer is `collect()`. This code doesn't quite compile, +but it shows the intention: + +```{rust,ignore} +let one_to_one_hundred = range(1i, 101i).collect(); +``` + +As you can see, we call `collect()` on our iterator. `collect()` takes +as many values as the iterator will give it, and returns a collection +of the results. So why won't this compile? Rust can't determine what +type of things you want to collect, and so you need to let it know. +Here's the version that does compile: + +```{rust} +let one_to_one_hundred = range(1i, 101i).collect::<Vec<int>>(); +``` + +If you remember, the `::<>` syntax allows us to give a type hint, +and so we tell it that we want a vector of integers. + +`collect()` is the most common consumer, but there are others too. `find()` +is one: + +```{rust} +let greater_than_forty_two = range(0i, 100i) + .find(|x| *x > 42); + +match greater_than_forty_two { + Some(_) => println!("We got some numbers!"), + None => println!("No numbers found :("), +} +``` + +`find` takes a closure, and works on a reference to each element of an +iterator. This closure returns `true` if the element is the element we're +looking for, and `false` otherwise. Because we might not find a matching +element, `find` returns an `Option` rather than the element itself. + +Another important consumer is `fold`. Here's what it looks like: + +```{rust} +let sum = range(1i, 4i) + .fold(0i, |sum, x| sum + x); +``` + +`fold()` is a consumer that looks like this: +`fold(base, |accumulator, element| ...)`. It takes two arguments: the first +is an element called the "base". The second is a closure that itself takes two +arguments: the first is called the "accumulator," and the second is an +"element." Upon each iteration, the closure is called, and the result is the +value of the accumulator on the next iteration. On the first iteration, the +base is the value of the accumulator. + +Okay, that's a bit confusing. Let's examine the values of all of these things +in this iterator: + +| base | accumulator | element | closure result | +|------|-------------|---------|----------------| +| 0i | 0i | 1i | 1i | +| 0i | 1i | 2i | 3i | +| 0i | 3i | 3i | 6i | + +We called `fold()` with these arguments: + +```{rust} +# range(1i, 4i) +.fold(0i, |sum, x| sum + x); +``` + +So, `0i` is our base, `sum` is our accumulator, and `x` is our element. On the +first iteration, we set `sum` to `0i`, and `x` is the first element of `nums`, +`1i`. We then add `sum` and `x`, which gives us `0i + 1i = 1i`. On the second +iteration, that value becomes our accumulator, `sum`, and the element is +the second element of the array, `2i`. `1i + 2i = 3i`, and so that becomes +the value of the accumulator for the last iteration. On that iteration, +`x` is the last element, `3i`, and `3i + 3i = 6i`, which is our final +result for our sum. `1 + 2 + 3 = 6`, and that's the result we got. + +Whew. `fold` can be a bit strange the first few times you see it, but once it +clicks, you can use it all over the place. Any time you have a list of things, +and you want a single result, `fold` is appropriate. + +Consumers are important due to one additional property of iterators we haven't +talked about yet: laziness. Let's talk some more about iterators, and you'll +see why consumers matter. + +## Iterators + +As we've said before, an iterator is something that we can call the +`.next()` method on repeatedly, and it gives us a sequence of things. +Because you need to call the method, this means that iterators +are **lazy** and don't need to generate all of the values upfront. +This code, for example, does not actually generate the numbers +`1-100`, and just creates a value that represents the sequence: + +```{rust} +let nums = range(1i, 100i); +``` + +Since we didn't do anything with the range, it didn't generate the sequence. +Let's add the consumer: + +```{rust} +let nums = range(1i, 100i).collect::<Vec<int>>(); +``` + +Now, `collect()` will require that `range()` give it some numbers, and so +it will do the work of generating the sequence. + +`range` is one of two basic iterators that you'll see. The other is `iter()`, +which you've used before. `iter()` can turn a vector into a simple iterator +that gives you each element in turn: + +```{rust} +let nums = [1i, 2i, 3i]; + +for num in nums.iter() { + println!("{}", num); +} +``` + +These two basic iterators should serve you well. There are some more +advanced iterators, including ones that are infinite. Like `count`: + +```{rust} +std::iter::count(1i, 5i); +``` + +This iterator counts up from one, adding five each time. It will give +you a new integer every time, forever (well, technically, until it reaches the +maximum number representable by an `int`). But since iterators are lazy, +that's okay! You probably don't want to use `collect()` on it, though... + +That's enough about iterators. Iterator adapters are the last concept +we need to talk about with regards to iterators. Let's get to it! + +## Iterator adapters + +"Iterator adapters" take an iterator and modify it somehow, producing +a new iterator. The simplest one is called `map`: + +```{rust,ignore} +range(1i, 100i).map(|x| x + 1i); +``` + +`map` is called upon another iterator, and produces a new iterator where each +element reference has the closure it's been given as an argument called on it. +So this would give us the numbers from `2-100`. Well, almost! If you +compile the example, you'll get a warning: + +```{notrust,ignore} +warning: unused result which must be used: iterator adaptors are lazy and + do nothing unless consumed, #[warn(unused_must_use)] on by default + range(1i, 100i).map(|x| x + 1i); + ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +``` + +Laziness strikes again! That closure will never execute. This example +doesn't print any numbers: + +```{rust,ignore} +range(1i, 100i).map(|x| println!("{}", x)); +``` + +If you are trying to execute a closure on an iterator for its side effects, +just use `for` instead. + +There are tons of interesting iterator adapters. `take(n)` will return an +iterator over the next `n` elements of the original iterator, note that this +has no side effect on the original iterator. Let's try it out with our infinite +iterator from before, `count()`: + +```{rust} +for i in std::iter::count(1i, 5i).take(5) { + println!("{}", i); +} +``` + +This will print + +```{notrust,ignore} +1 +6 +11 +16 +21 +``` + +`filter()` is an adapter that takes a closure as an argument. This closure +returns `true` or `false`. The new iterator `filter()` produces +only the elements that that closure returns `true` for: + +```{rust} +for i in range(1i, 100i).filter(|&x| x % 2 == 0) { + println!("{}", i); +} +``` + +This will print all of the even numbers between one and a hundred. +(Note that because `filter` doesn't consume the elements that are +being iterated over, it is passed a reference to each element, and +thus the filter predicate uses the `&x` pattern to extract the integer +itself.) + +You can chain all three things together: start with an iterator, adapt it +a few times, and then consume the result. Check it out: + +```{rust} +range(1i, 1000i) + .filter(|&x| x % 2 == 0) + .filter(|&x| x % 3 == 0) + .take(5) + .collect::<Vec<int>>(); +``` + +This will give you a vector containing `6`, `12`, `18`, `24`, and `30`. + +This is just a small taste of what iterators, iterator adapters, and consumers +can help you with. There are a number of really useful iterators, and you can +write your own as well. Iterators provide a safe, efficient way to manipulate +all kinds of lists. They're a little unusual at first, but if you play with +them, you'll get hooked. For a full list of the different iterators and +consumers, check out the [iterator module documentation](../std/iter/index.html). diff --git a/src/doc/trpl/looping.md b/src/doc/trpl/looping.md new file mode 100644 index 00000000000..80926c99e87 --- /dev/null +++ b/src/doc/trpl/looping.md @@ -0,0 +1,133 @@ +% Looping + +Looping is the last basic construct that we haven't learned yet in Rust. Rust has +two main looping constructs: `for` and `while`. + +## `for` + +The `for` loop is used to loop a particular number of times. Rust's `for` loops +work a bit differently than in other systems languages, however. Rust's `for` +loop doesn't look like this "C-style" `for` loop: + +```{c} +for (x = 0; x < 10; x++) { + printf( "%d\n", x ); +} +``` + +Instead, it looks like this: + +```{rust} +for x in range(0, 10) { + println!("{}", x); // x: i32 +} +``` + +In slightly more abstract terms, + +```{ignore} +for var in expression { + code +} +``` + +The expression is an iterator, which we will discuss in more depth later in the +guide. The iterator gives back a series of elements. Each element is one +iteration of the loop. That value is then bound to the name `var`, which is +valid for the loop body. Once the body is over, the next value is fetched from +the iterator, and we loop another time. When there are no more values, the +`for` loop is over. + +In our example, `range` is a function that takes a start and an end position, +and gives an iterator over those values. The upper bound is exclusive, though, +so our loop will print `0` through `9`, not `10`. + +Rust does not have the "C-style" `for` loop on purpose. Manually controlling +each element of the loop is complicated and error prone, even for experienced C +developers. + +We'll talk more about `for` when we cover **iterator**s, later in the Guide. + +## `while` + +The other kind of looping construct in Rust is the `while` loop. It looks like +this: + +```{rust} +let mut x = 5u; // mut x: uint +let mut done = false; // mut done: bool + +while !done { + x += x - 3; + println!("{}", x); + if x % 5 == 0 { done = true; } +} +``` + +`while` loops are the correct choice when you're not sure how many times +you need to loop. + +If you need an infinite loop, you may be tempted to write this: + +```{rust,ignore} +while true { +``` + +However, Rust has a dedicated keyword, `loop`, to handle this case: + +```{rust,ignore} +loop { +``` + +Rust's control-flow analysis treats this construct differently than a +`while true`, since we know that it will always loop. The details of what +that _means_ aren't super important to understand at this stage, but in +general, the more information we can give to the compiler, the better it +can do with safety and code generation, so you should always prefer +`loop` when you plan to loop infinitely. + +## Ending iteration early + +Let's take a look at that `while` loop we had earlier: + +```{rust} +let mut x = 5u; +let mut done = false; + +while !done { + x += x - 3; + println!("{}", x); + if x % 5 == 0 { done = true; } +} +``` + +We had to keep a dedicated `mut` boolean variable binding, `done`, to know +when we should exit out of the loop. Rust has two keywords to help us with +modifying iteration: `break` and `continue`. + +In this case, we can write the loop in a better way with `break`: + +```{rust} +let mut x = 5u; + +loop { + x += x - 3; + println!("{}", x); + if x % 5 == 0 { break; } +} +``` + +We now loop forever with `loop` and use `break` to break out early. + +`continue` is similar, but instead of ending the loop, goes to the next +iteration. This will only print the odd numbers: + +```{rust} +for x in range(0, 10) { + if x % 2 == 0 { continue; } + + println!("{}", x); +} +``` + +Both `continue` and `break` are valid in both kinds of loops. diff --git a/src/doc/guide-macros.md b/src/doc/trpl/macros.md index 95f5305775e..c694806b4ba 100644 --- a/src/doc/guide-macros.md +++ b/src/doc/trpl/macros.md @@ -507,7 +507,7 @@ When this library is loaded with `#[use_macros] extern crate`, only `m2` will be imported. The Rust Reference has a [listing of macro-related -attributes](reference.html#macro--and-plugin-related-attributes). +attributes](../reference.html#macro--and-plugin-related-attributes). # The variable `$crate` @@ -567,7 +567,7 @@ intermediate states out, and passing the flag `--pretty expanded` as a command-line argument to the compiler will show the result of expansion. If Rust's macro system can't do what you need, you may want to write a -[compiler plugin](guide-plugin.html) instead. Compared to `macro_rules!` +[compiler plugin](plugin.html) instead. Compared to `macro_rules!` macros, this is significantly more work, the interfaces are much less stable, and the warnings about debugging apply ten-fold. In exchange you get the flexibility of running arbitrary Rust code within the compiler. Syntax diff --git a/src/doc/trpl/match.md b/src/doc/trpl/match.md new file mode 100644 index 00000000000..c120142cf5c --- /dev/null +++ b/src/doc/trpl/match.md @@ -0,0 +1,156 @@ +% Match + +Often, a simple `if`/`else` isn't enough, because you have more than two +possible options. Also, `else` conditions can get incredibly complicated, so +what's the solution? + +Rust has a keyword, `match`, that allows you to replace complicated `if`/`else` +groupings with something more powerful. Check it out: + +```{rust} +let x = 5; + +match x { + 1 => println!("one"), + 2 => println!("two"), + 3 => println!("three"), + 4 => println!("four"), + 5 => println!("five"), + _ => println!("something else"), +} +``` + +`match` takes an expression and then branches based on its value. Each 'arm' of +the branch is of the form `val => expression`. When the value matches, that arm's +expression will be evaluated. It's called `match` because of the term 'pattern +matching', which `match` is an implementation of. + +So what's the big advantage here? Well, there are a few. First of all, `match` +enforces 'exhaustiveness checking'. Do you see that last arm, the one with the +underscore (`_`)? If we remove that arm, Rust will give us an error: + +```text +error: non-exhaustive patterns: `_` not covered +``` + +In other words, Rust is trying to tell us we forgot a value. Because `x` is an +integer, Rust knows that it can have a number of different values – for example, +`6`. Without the `_`, however, there is no arm that could match, and so Rust refuses +to compile. `_` acts like a 'catch-all arm'. If none of the other arms match, +the arm with `_` will, and since we have this catch-all arm, we now have an arm +for every possible value of `x`, and so our program will compile successfully. + +`match` statements also destructure enums, as well. Remember this code from the +section on enums? + +```{rust} +use std::cmp::Ordering; + +fn cmp(a: i32, b: i32) -> Ordering { + if a < b { Ordering::Less } + else if a > b { Ordering::Greater } + else { Ordering::Equal } +} + +fn main() { + let x = 5; + let y = 10; + + let ordering = cmp(x, y); + + if ordering == Ordering::Less { + println!("less"); + } else if ordering == Ordering::Greater { + println!("greater"); + } else if ordering == Ordering::Equal { + println!("equal"); + } +} +``` + +We can re-write this as a `match`: + +```{rust} +use std::cmp::Ordering; + +fn cmp(a: i32, b: i32) -> Ordering { + if a < b { Ordering::Less } + else if a > b { Ordering::Greater } + else { Ordering::Equal } +} + +fn main() { + let x = 5; + let y = 10; + + match cmp(x, y) { + Ordering::Less => println!("less"), + Ordering::Greater => println!("greater"), + Ordering::Equal => println!("equal"), + } +} +``` + +This version has way less noise, and it also checks exhaustively to make sure +that we have covered all possible variants of `Ordering`. With our `if`/`else` +version, if we had forgotten the `Greater` case, for example, our program would +have happily compiled. If we forget in the `match`, it will not. Rust helps us +make sure to cover all of our bases. + +`match` expressions also allow us to get the values contained in an `enum` +(also known as destructuring) as follows: + +```{rust} +enum OptionalInt { + Value(i32), + Missing, +} + +fn main() { + let x = OptionalInt::Value(5); + let y = OptionalInt::Missing; + + match x { + OptionalInt::Value(n) => println!("x is {}", n), + OptionalInt::Missing => println!("x is missing!"), + } + + match y { + OptionalInt::Value(n) => println!("y is {}", n), + OptionalInt::Missing => println!("y is missing!"), + } +} +``` + +That is how you can get and use the values contained in `enum`s. +It can also allow us to handle errors or unexpected computations; for example, a +function that is not guaranteed to be able to compute a result (an `i32` here) +could return an `OptionalInt`, and we would handle that value with a `match`. +As you can see, `enum` and `match` used together are quite useful! + +`match` is also an expression, which means we can use it on the right-hand +side of a `let` binding or directly where an expression is used. We could +also implement the previous example like this: + +```{rust} +use std::cmp::Ordering; + +fn cmp(a: i32, b: i32) -> Ordering { + if a < b { Ordering::Less } + else if a > b { Ordering::Greater } + else { Ordering::Equal } +} + +fn main() { + let x = 5; + let y = 10; + + println!("{}", match cmp(x, y) { + Ordering::Less => "less", + Ordering::Greater => "greater", + Ordering::Equal => "equal", + }); +} +``` + +Sometimes, it's a nice pattern. diff --git a/src/doc/trpl/method-syntax.md b/src/doc/trpl/method-syntax.md new file mode 100644 index 00000000000..54e9cdf5191 --- /dev/null +++ b/src/doc/trpl/method-syntax.md @@ -0,0 +1,88 @@ +% Method Syntax + +Functions are great, but if you want to call a bunch of them on some data, it +can be awkward. Consider this code: + +```{rust,ignore} +baz(bar(foo(x))); +``` + +We would read this left-to right, and so we see 'baz bar foo.' But this isn't the +order that the functions would get called in, that's inside-out: 'foo bar baz.' +Wouldn't it be nice if we could do this instead? + +```{rust,ignore} +x.foo().bar().baz(); +``` + +Luckily, as you may have guessed with the leading question, you can! Rust provides +the ability to use this **method call syntax** via the `impl` keyword. + +Here's how it works: + +```{rust} +struct Circle { + x: f64, + y: f64, + radius: f64, +} + +impl Circle { + fn area(&self) -> f64 { + std::f64::consts::PI * (self.radius * self.radius) + } +} + +fn main() { + let c = Circle { x: 0.0, y: 0.0, radius: 2.0 }; + println!("{}", c.area()); +} +``` + +This will print `12.566371`. + +We've made a struct that represents a circle. We then write an `impl` block, +and inside it, define a method, `area`. Methods take a special first +parameter, `&self`. There are three variants: `self`, `&self`, and `&mut self`. +You can think of this first parameter as being the `x` in `x.foo()`. The three +variants correspond to the three kinds of thing `x` could be: `self` if it's +just a value on the stack, `&self` if it's a reference, and `&mut self` if it's +a mutable reference. We should default to using `&self`, as it's the most +common. + +Finally, as you may remember, the value of the area of a circle is `π*r²`. +Because we took the `&self` parameter to `area`, we can use it just like any +other parameter. Because we know it's a `Circle`, we can access the `radius` +just like we would with any other struct. An import of π and some +multiplications later, and we have our area. + +You can also define methods that do not take a `self` parameter. Here's a +pattern that's very common in Rust code: + +```{rust} +# #![allow(non_shorthand_field_patterns)] +struct Circle { + x: f64, + y: f64, + radius: f64, +} + +impl Circle { + fn new(x: f64, y: f64, radius: f64) -> Circle { + Circle { + x: x, + y: y, + radius: radius, + } + } +} + +fn main() { + let c = Circle::new(0.0, 0.0, 2.0); +} +``` + +This **static method** builds a new `Circle` for us. Note that static methods +are called with the `Struct::method()` syntax, rather than the `ref.method()` +syntax. + diff --git a/src/doc/guide-ownership.md b/src/doc/trpl/ownership.md index 3db4da73f93..3db4da73f93 100644 --- a/src/doc/guide-ownership.md +++ b/src/doc/trpl/ownership.md diff --git a/src/doc/trpl/patterns.md b/src/doc/trpl/patterns.md new file mode 100644 index 00000000000..282703c4387 --- /dev/null +++ b/src/doc/trpl/patterns.md @@ -0,0 +1,199 @@ +% Patterns + +We've made use of patterns a few times in the guide: first with `let` bindings, +then with `match` statements. Let's go on a whirlwind tour of all of the things +patterns can do! + +A quick refresher: you can match against literals directly, and `_` acts as an +'any' case: + +```{rust} +let x = 1i; + +match x { + 1 => println!("one"), + 2 => println!("two"), + 3 => println!("three"), + _ => println!("anything"), +} +``` + +You can match multiple patterns with `|`: + +```{rust} +let x = 1i; + +match x { + 1 | 2 => println!("one or two"), + 3 => println!("three"), + _ => println!("anything"), +} +``` + +You can match a range of values with `...`: + +```{rust} +let x = 1i; + +match x { + 1 ... 5 => println!("one through five"), + _ => println!("anything"), +} +``` + +Ranges are mostly used with integers and single characters. + +If you're matching multiple things, via a `|` or a `...`, you can bind +the value to a name with `@`: + +```{rust} +let x = 1i; + +match x { + e @ 1 ... 5 => println!("got a range element {}", e), + _ => println!("anything"), +} +``` + +If you're matching on an enum which has variants, you can use `..` to +ignore the value and type in the variant: + +```{rust} +enum OptionalInt { + Value(int), + Missing, +} + +let x = OptionalInt::Value(5i); + +match x { + OptionalInt::Value(..) => println!("Got an int!"), + OptionalInt::Missing => println!("No such luck."), +} +``` + +You can introduce **match guards** with `if`: + +```{rust} +enum OptionalInt { + Value(int), + Missing, +} + +let x = OptionalInt::Value(5i); + +match x { + OptionalInt::Value(i) if i > 5 => println!("Got an int bigger than five!"), + OptionalInt::Value(..) => println!("Got an int!"), + OptionalInt::Missing => println!("No such luck."), +} +``` + +If you're matching on a pointer, you can use the same syntax as you declared it +with. First, `&`: + +```{rust} +let x = &5i; + +match x { + &val => println!("Got a value: {}", val), +} +``` + +Here, the `val` inside the `match` has type `int`. In other words, the left-hand +side of the pattern destructures the value. If we have `&5i`, then in `&val`, `val` +would be `5i`. + +If you want to get a reference, use the `ref` keyword: + +```{rust} +let x = 5i; + +match x { + ref r => println!("Got a reference to {}", r), +} +``` + +Here, the `r` inside the `match` has the type `&int`. In other words, the `ref` +keyword _creates_ a reference, for use in the pattern. If you need a mutable +reference, `ref mut` will work in the same way: + +```{rust} +let mut x = 5i; + +match x { + ref mut mr => println!("Got a mutable reference to {}", mr), +} +``` + +If you have a struct, you can destructure it inside of a pattern: + +```{rust} +# #![allow(non_shorthand_field_patterns)] +struct Point { + x: int, + y: int, +} + +let origin = Point { x: 0i, y: 0i }; + +match origin { + Point { x: x, y: y } => println!("({},{})", x, y), +} +``` + +If we only care about some of the values, we don't have to give them all names: + +```{rust} +# #![allow(non_shorthand_field_patterns)] +struct Point { + x: int, + y: int, +} + +let origin = Point { x: 0i, y: 0i }; + +match origin { + Point { x: x, .. } => println!("x is {}", x), +} +``` + +You can do this kind of match on any member, not just the first: + +```{rust} +# #![allow(non_shorthand_field_patterns)] +struct Point { + x: int, + y: int, +} + +let origin = Point { x: 0i, y: 0i }; + +match origin { + Point { y: y, .. } => println!("y is {}", y), +} +``` + +If you want to match against a slice or array, you can use `[]`: + +```{rust} +fn main() { + let v = vec!["match_this", "1"]; + + match v.as_slice() { + ["match_this", second] => println!("The second element is {}", second), + _ => {}, + } +} +``` + +Whew! That's a lot of different ways to match things, and they can all be +mixed and matched, depending on what you're doing: + +```{rust,ignore} +match x { + Foo { x: Some(ref name), y: None } => ... +} +``` + +Patterns are very powerful. Make good use of them. diff --git a/src/doc/guide-plugin.md b/src/doc/trpl/plugins.md index 025f0cced63..2a0710d018c 100644 --- a/src/doc/guide-plugin.md +++ b/src/doc/trpl/plugins.md @@ -5,20 +5,20 @@ <p> <b>Warning:</b> Plugins are an advanced, unstable feature! For many details, the only available documentation is the <a -href="syntax/index.html"><code>libsyntax</code></a> and <a -href="rustc/index.html"><code>librustc</code></a> API docs, or even the source +href="../syntax/index.html"><code>libsyntax</code></a> and <a +href="../rustc/index.html"><code>librustc</code></a> API docs, or even the source code itself. These internal compiler APIs are also subject to change at any time. </p> <p> For defining new syntax it is often much easier to use Rust's <a -href="guide-macros.html">built-in macro system</a>. +href="macros.html">built-in macro system</a>. </p> <p style="margin-bottom: 0"> The code in this document uses language features not covered in the Rust -Guide. See the <a href="reference.html">Reference Manual</a> for more +Guide. See the <a href="../reference.html">Reference Manual</a> for more information. </p> @@ -32,19 +32,19 @@ extend the compiler's behavior with new syntax extensions, lint checks, etc. A plugin is a dynamic library crate with a designated "registrar" function that registers extensions with `rustc`. Other crates can use these extensions by loading the plugin crate with `#[plugin] extern crate`. See the -[`rustc::plugin`](rustc/plugin/index.html) documentation for more about the +[`rustc::plugin`](../rustc/plugin/index.html) documentation for more about the mechanics of defining and loading a plugin. Arguments passed as `#[plugin=...]` or `#[plugin(...)]` are not interpreted by rustc itself. They are provided to the plugin through the `Registry`'s [`args` -method](rustc/plugin/registry/struct.Registry.html#method.args). +method](../rustc/plugin/registry/struct.Registry.html#method.args). # Syntax extensions Plugins can extend Rust's syntax in various ways. One kind of syntax extension is the procedural macro. These are invoked the same way as [ordinary -macros](guide-macros.html), but the expansion is performed by arbitrary Rust -code that manipulates [syntax trees](syntax/ast/index.html) at +macros](macros.html), but the expansion is performed by arbitrary Rust +code that manipulates [syntax trees](../syntax/ast/index.html) at compile time. Let's write a plugin @@ -126,14 +126,13 @@ The advantages over a simple `fn(&str) -> uint` are: a way to define new literal syntax for any data type. In addition to procedural macros, you can define new -[`deriving`](reference.html#deriving)-like attributes and other kinds of +[`deriving`](../reference.html#deriving)-like attributes and other kinds of extensions. See -[`Registry::register_syntax_extension`](rustc/plugin/registry/struct.Registry.html#method.register_syntax_extension) +[`Registry::register_syntax_extension`](../rustc/plugin/registry/struct.Registry.html#method.register_syntax_extension) and the [`SyntaxExtension` enum](http://doc.rust-lang.org/syntax/ext/base/enum.SyntaxExtension.html). For a more involved macro example, see -[`src/libregex_macros/lib.rs`](https://github.com/rust-lang/rust/blob/master/src/libregex_macros/lib.rs) -in the Rust distribution. +[`regex_macros`](https://github.com/rust-lang/regex/blob/master/regex_macros/src/lib.rs). ## Tips and tricks @@ -147,7 +146,7 @@ variables of the same name (but different syntax contexts) are in play in the same scope. In this case `--pretty expanded,hygiene` will tell you about the syntax contexts. -You can use [`syntax::parse`](syntax/parse/index.html) to turn token trees into +You can use [`syntax::parse`](../syntax/parse/index.html) to turn token trees into higher-level syntax elements like expressions: ```ignore @@ -163,23 +162,23 @@ Looking through [`libsyntax` parser code](https://github.com/rust-lang/rust/blob/master/src/libsyntax/parse/parser.rs) will give you a feel for how the parsing infrastructure works. -Keep the [`Span`s](syntax/codemap/struct.Span.html) of +Keep the [`Span`s](../syntax/codemap/struct.Span.html) of everything you parse, for better error reporting. You can wrap -[`Spanned`](syntax/codemap/struct.Spanned.html) around +[`Spanned`](../syntax/codemap/struct.Spanned.html) around your custom data structures. Calling -[`ExtCtxt::span_fatal`](syntax/ext/base/struct.ExtCtxt.html#method.span_fatal) +[`ExtCtxt::span_fatal`](../syntax/ext/base/struct.ExtCtxt.html#method.span_fatal) will immediately abort compilation. It's better to instead call -[`ExtCtxt::span_err`](syntax/ext/base/struct.ExtCtxt.html#method.span_err) +[`ExtCtxt::span_err`](../syntax/ext/base/struct.ExtCtxt.html#method.span_err) and return -[`DummyResult`](syntax/ext/base/struct.DummyResult.html), +[`DummyResult`](../syntax/ext/base/struct.DummyResult.html), so that the compiler can continue and find further errors. The example above produced an integer literal using -[`AstBuilder::expr_uint`](syntax/ext/build/trait.AstBuilder.html#tymethod.expr_uint). +[`AstBuilder::expr_uint`](../syntax/ext/build/trait.AstBuilder.html#tymethod.expr_uint). As an alternative to the `AstBuilder` trait, `libsyntax` provides a set of -[quasiquote macros](syntax/ext/quote/index.html). They are undocumented and +[quasiquote macros](../syntax/ext/quote/index.html). They are undocumented and very rough around the edges. However, the implementation may be a good starting point for an improved quasiquote as an ordinary plugin library. @@ -187,7 +186,7 @@ starting point for an improved quasiquote as an ordinary plugin library. # Lint plugins Plugins can extend [Rust's lint -infrastructure](reference.html#lint-check-attributes) with additional checks for +infrastructure](../reference.html#lint-check-attributes) with additional checks for code style, safety, etc. You can see [`src/test/auxiliary/lint_plugin_test.rs`](https://github.com/rust-lang/rust/blob/master/src/test/auxiliary/lint_plugin_test.rs) for a full example, the core of which is reproduced here: @@ -236,11 +235,11 @@ foo.rs:4 fn lintme() { } The components of a lint plugin are: * one or more `declare_lint!` invocations, which define static - [`Lint`](rustc/lint/struct.Lint.html) structs; + [`Lint`](../rustc/lint/struct.Lint.html) structs; * a struct holding any state needed by the lint pass (here, none); -* a [`LintPass`](rustc/lint/trait.LintPass.html) +* a [`LintPass`](../rustc/lint/trait.LintPass.html) implementation defining how to check each syntax element. A single `LintPass` may call `span_lint` for several different `Lint`s, but should register them all through the `get_lints` method. @@ -252,7 +251,7 @@ mostly use the same infrastructure as lint plugins, and provide examples of how to access type information. Lints defined by plugins are controlled by the usual [attributes and compiler -flags](reference.html#lint-check-attributes), e.g. `#[allow(test_lint)]` or +flags](../reference.html#lint-check-attributes), e.g. `#[allow(test_lint)]` or `-A test-lint`. These identifiers are derived from the first argument to `declare_lint!`, with appropriate case and punctuation conversion. diff --git a/src/doc/guide-pointers.md b/src/doc/trpl/pointers.md index 4c35fae3ecc..ad80d2812d0 100644 --- a/src/doc/guide-pointers.md +++ b/src/doc/trpl/pointers.md @@ -409,7 +409,7 @@ test.rs:4 let y = &x; As you might guess, this kind of analysis is complex for a human, and therefore hard for a computer, too! There is an entire [guide devoted to references, ownership, -and lifetimes](guide-ownership.html) that goes into this topic in +and lifetimes](ownership.html) that goes into this topic in great detail, so if you want the full details, check that out. ## Best practices @@ -542,7 +542,7 @@ with some improvements: 4. Rust enforces that no other writeable pointers alias to this heap memory, which means writing to an invalid pointer is not possible. -See the section on references or the [ownership guide](guide-ownership.html) +See the section on references or the [ownership guide](ownership.html) for more detail on how lifetimes work. Using boxes and references together is very common. For example: @@ -780,6 +780,6 @@ Here's a quick rundown of Rust's pointer types: # Related resources -* [API documentation for Box](std/boxed/index.html) -* [Ownership guide](guide-ownership.html) +* [API documentation for Box](../std/boxed/index.html) +* [Ownership guide](ownership.html) * [Cyclone paper on regions](http://www.cs.umd.edu/projects/cyclone/papers/cyclone-regions.pdf), which inspired Rust's lifetime system diff --git a/src/doc/trpl/rust-book.css b/src/doc/trpl/rust-book.css new file mode 100644 index 00000000000..3d08de40f55 --- /dev/null +++ b/src/doc/trpl/rust-book.css @@ -0,0 +1,59 @@ + +@import url("//static.rust-lang.org/doc/master/rust.css"); + +body { + max-width:none; +} + +#toc { + position: absolute; + left: 0px; + top: 0px; + bottom: 0px; + width: 250px; + overflow-y: auto; + border-right: 1px solid rgba(0, 0, 0, 0.07); + padding: 10px 10px; + font-size: 16px; + background: none repeat scroll 0% 0% #FFF; + box-sizing: border-box; +} + +#page-wrapper { + position: absolute; + overflow-y: auto; + left: 260px; + right: 0px; + top: 0px; + bottom: 0px; + box-sizing: border-box; + background: none repeat scroll 0% 0% #FFF; +} + +#page { + margin-left: auto; + margin-right:auto; + width: 750px; +} + +.chapter { + list-style: none outside none; + padding-left: 0px; + line-height: 30px; +} + +.section { + list-style: none outside none; + padding-left: 20px; + line-height: 30px; +} + +.section li { + text-overflow: ellipsis; + overflow: hidden; + white-space: nowrap; +} + +.chapter li a { + color: #000000; +} diff --git a/src/doc/trpl/standard-input.md b/src/doc/trpl/standard-input.md new file mode 100644 index 00000000000..2d31f06ebaa --- /dev/null +++ b/src/doc/trpl/standard-input.md @@ -0,0 +1,159 @@ +% Standard Input + +Getting input from the keyboard is pretty easy, but uses some things +we haven't seen before. Here's a simple program that reads some input, +and then prints it back out: + +```{rust,ignore} +fn main() { + println!("Type something!"); + + let input = std::io::stdin().read_line().ok().expect("Failed to read line"); + + println!("{}", input); +} +``` + +Let's go over these chunks, one by one: + +```{rust,ignore} +std::io::stdin(); +``` + +This calls a function, `stdin()`, that lives inside the `std::io` module. As +you can imagine, everything in `std` is provided by Rust, the 'standard +library.' We'll talk more about the module system later. + +Since writing the fully qualified name all the time is annoying, we can use +the `use` statement to import it in: + +```{rust} +use std::io::stdin; + +stdin(); +``` + +However, it's considered better practice to not import individual functions, but +to import the module, and only use one level of qualification: + +```{rust} +use std::io; + +io::stdin(); +``` + +Let's update our example to use this style: + +```{rust,ignore} +use std::io; + +fn main() { + println!("Type something!"); + + let input = io::stdin().read_line().ok().expect("Failed to read line"); + + println!("{}", input); +} +``` + +Next up: + +```{rust,ignore} +.read_line() +``` + +The `read_line()` method can be called on the result of `stdin()` to return +a full line of input. Nice and easy. + +```{rust,ignore} +.ok().expect("Failed to read line"); +``` + +Do you remember this code? + +```{rust} +enum OptionalInt { + Value(i32), + Missing, +} + +fn main() { + let x = OptionalInt::Value(5); + let y = OptionalInt::Missing; + + match x { + OptionalInt::Value(n) => println!("x is {}", n), + OptionalInt::Missing => println!("x is missing!"), + } + + match y { + OptionalInt::Value(n) => println!("y is {}", n), + OptionalInt::Missing => println!("y is missing!"), + } +} +``` + +We had to match each time to see if we had a value or not. In this case, +though, we _know_ that `x` has a `Value`, but `match` forces us to handle +the `missing` case. This is what we want 99% of the time, but sometimes, we +know better than the compiler. + +Likewise, `read_line()` does not return a line of input. It _might_ return a +line of input, though it might also fail to do so. This could happen if our program +isn't running in a terminal, but as part of a cron job, or some other context +where there's no standard input. Because of this, `read_line` returns a type +very similar to our `OptionalInt`: an `IoResult<T>`. We haven't talked about +`IoResult<T>` yet because it is the **generic** form of our `OptionalInt`. +Until then, you can think of it as being the same thing, just for any type – +not just `i32`s. + +Rust provides a method on these `IoResult<T>`s called `ok()`, which does the +same thing as our `match` statement but assumes that we have a valid value. +We then call `expect()` on the result, which will terminate our program if we +don't have a valid value. In this case, if we can't get input, our program +doesn't work, so we're okay with that. In most cases, we would want to handle +the error case explicitly. `expect()` allows us to give an error message if +this crash happens. + +We will cover the exact details of how all of this works later in the Guide. +For now, this gives you enough of a basic understanding to work with. + +Back to the code we were working on! Here's a refresher: + +```{rust,ignore} +use std::io; + +fn main() { + println!("Type something!"); + + let input = io::stdin().read_line().ok().expect("Failed to read line"); + + println!("{}", input); +} +``` + +With long lines like this, Rust gives you some flexibility with the whitespace. +We _could_ write the example like this: + +```{rust,ignore} +use std::io; + +fn main() { + println!("Type something!"); + + // here, we'll show the types at each step + + let input = io::stdin() // std::io::stdio::StdinReader + .read_line() // IoResult<String> + .ok() // Option<String> + .expect("Failed to read line"); // String + + println!("{}", input); +} +``` + +Sometimes, this makes things more readable – sometimes, less. Use your judgement +here. + +That's all you need to get basic input from the standard input! It's not too +complicated, but there are a number of small parts. diff --git a/src/doc/trpl/strings.md b/src/doc/trpl/strings.md new file mode 100644 index 00000000000..a40e748dae7 --- /dev/null +++ b/src/doc/trpl/strings.md @@ -0,0 +1,79 @@ +% Strings + +Strings are an important concept for any programmer to master. Rust's string +handling system is a bit different from other languages, due to its systems +focus. Any time you have a data structure of variable size, things can get +tricky, and strings are a re-sizable data structure. That being said, Rust's +strings also work differently than in some other systems languages, such as C. + +Let's dig into the details. A **string** is a sequence of Unicode scalar values +encoded as a stream of UTF-8 bytes. All strings are guaranteed to be +validly encoded UTF-8 sequences. Additionally, strings are not null-terminated +and can contain null bytes. + +Rust has two main types of strings: `&str` and `String`. + +The first kind is a `&str`. This is pronounced a 'string slice.' String literals +are of the type `&str`: + +```{rust} +let string = "Hello there."; // string: &str +``` + +This string is statically allocated, meaning that it's saved inside our +compiled program, and exists for the entire duration it runs. The `string` +binding is a reference to this statically allocated string. String slices +have a fixed size, and cannot be mutated. + +A `String`, on the other hand, is an in-memory string. This string is +growable, and is also guaranteed to be UTF-8. + +```{rust} +let mut s = "Hello".to_string(); // mut s: String +println!("{}", s); + +s.push_str(", world."); +println!("{}", s); +``` + +You can get a `&str` view into a `String` with the `as_slice()` method: + +```{rust} +fn takes_slice(slice: &str) { + println!("Got: {}", slice); +} + +fn main() { + let s = "Hello".to_string(); + takes_slice(s.as_slice()); +} +``` + +To compare a String to a constant string, prefer `as_slice()`... + +```{rust} +fn compare(string: String) { + if string.as_slice() == "Hello" { + println!("yes"); + } +} +``` + +... over `to_string()`: + +```{rust} +fn compare(string: String) { + if string == "Hello".to_string() { + println!("yes"); + } +} +``` + +Viewing a `String` as a `&str` is cheap, but converting the `&str` to a +`String` involves allocating memory. No reason to do that unless you have to! + +That's the basics of strings in Rust! They're probably a bit more complicated +than you are used to, if you come from a scripting language, but when the +low-level details matter, they really matter. Just remember that `String`s +allocate memory and control their data, while `&str`s are a reference to +another string, and you'll be all set. diff --git a/src/doc/guide-tasks.md b/src/doc/trpl/tasks.md index 8eb13187e58..8e9f40b0f4e 100644 --- a/src/doc/guide-tasks.md +++ b/src/doc/trpl/tasks.md @@ -369,7 +369,7 @@ Unlike `spawn`, the function spawned using `try` may return a value, which child thread terminates successfully, `try` will return an `Ok` result; if the child thread panics, `try` will return an `Error` result. -[`Result`]: std/result/index.html +[`Result`]: ../std/result/index.html > *Note:* A panicked thread does not currently produce a useful error > value (`try` always returns `Err(())`). In the diff --git a/src/doc/guide-testing.md b/src/doc/trpl/testing.md index 4c3d93bdfbe..4c3d93bdfbe 100644 --- a/src/doc/guide-testing.md +++ b/src/doc/trpl/testing.md diff --git a/src/doc/trpl/traits.md b/src/doc/trpl/traits.md new file mode 100644 index 00000000000..04c644da2ab --- /dev/null +++ b/src/doc/trpl/traits.md @@ -0,0 +1,317 @@ +% Traits + +Do you remember the `impl` keyword, used to call a function with method +syntax? + +```{rust} +struct Circle { + x: f64, + y: f64, + radius: f64, +} + +impl Circle { + fn area(&self) -> f64 { + std::f64::consts::PI * (self.radius * self.radius) + } +} +``` + +Traits are similar, except that we define a trait with just the method +signature, then implement the trait for that struct. Like this: + +```{rust} +struct Circle { + x: f64, + y: f64, + radius: f64, +} + +trait HasArea { + fn area(&self) -> f64; +} + +impl HasArea for Circle { + fn area(&self) -> f64 { + std::f64::consts::PI * (self.radius * self.radius) + } +} +``` + +As you can see, the `trait` block looks very similar to the `impl` block, +but we don't define a body, just a type signature. When we `impl` a trait, +we use `impl Trait for Item`, rather than just `impl Item`. + +So what's the big deal? Remember the error we were getting with our generic +`inverse` function? + +```text +error: binary operation `==` cannot be applied to type `T` +``` + +We can use traits to constrain our generics. Consider this function, which +does not compile, and gives us a similar error: + +```{rust,ignore} +fn print_area<T>(shape: T) { + println!("This shape has an area of {}", shape.area()); +} +``` + +Rust complains: + +```text +error: type `T` does not implement any method in scope named `area` +``` + +Because `T` can be any type, we can't be sure that it implements the `area` +method. But we can add a **trait constraint** to our generic `T`, ensuring +that it does: + +```{rust} +# trait HasArea { +# fn area(&self) -> f64; +# } +fn print_area<T: HasArea>(shape: T) { + println!("This shape has an area of {}", shape.area()); +} +``` + +The syntax `<T: HasArea>` means `any type that implements the HasArea trait`. +Because traits define function type signatures, we can be sure that any type +which implements `HasArea` will have an `.area()` method. + +Here's an extended example of how this works: + +```{rust} +trait HasArea { + fn area(&self) -> f64; +} + +struct Circle { + x: f64, + y: f64, + radius: f64, +} + +impl HasArea for Circle { + fn area(&self) -> f64 { + std::f64::consts::PI * (self.radius * self.radius) + } +} + +struct Square { + x: f64, + y: f64, + side: f64, +} + +impl HasArea for Square { + fn area(&self) -> f64 { + self.side * self.side + } +} + +fn print_area<T: HasArea>(shape: T) { + println!("This shape has an area of {}", shape.area()); +} + +fn main() { + let c = Circle { + x: 0.0f64, + y: 0.0f64, + radius: 1.0f64, + }; + + let s = Square { + x: 0.0f64, + y: 0.0f64, + side: 1.0f64, + }; + + print_area(c); + print_area(s); +} +``` + +This program outputs: + +```text +This shape has an area of 3.141593 +This shape has an area of 1 +``` + +As you can see, `print_area` is now generic, but also ensures that we +have passed in the correct types. If we pass in an incorrect type: + +```{rust,ignore} +print_area(5i); +``` + +We get a compile-time error: + +```text +error: failed to find an implementation of trait main::HasArea for int +``` + +So far, we've only added trait implementations to structs, but you can +implement a trait for any type. So technically, we _could_ implement +`HasArea` for `int`: + +```{rust} +trait HasArea { + fn area(&self) -> f64; +} + +impl HasArea for int { + fn area(&self) -> f64 { + println!("this is silly"); + + *self as f64 + } +} + +5i.area(); +``` + +It is considered poor style to implement methods on such primitive types, even +though it is possible. + +This may seem like the Wild West, but there are two other restrictions around +implementing traits that prevent this from getting out of hand. First, traits +must be `use`d in any scope where you wish to use the trait's method. So for +example, this does not work: + +```{rust,ignore} +mod shapes { + use std::f64::consts; + + trait HasArea { + fn area(&self) -> f64; + } + + struct Circle { + x: f64, + y: f64, + radius: f64, + } + + impl HasArea for Circle { + fn area(&self) -> f64 { + consts::PI * (self.radius * self.radius) + } + } +} + +fn main() { + let c = shapes::Circle { + x: 0.0f64, + y: 0.0f64, + radius: 1.0f64, + }; + + println!("{}", c.area()); +} +``` + +Now that we've moved the structs and traits into their own module, we get an +error: + +```text +error: type `shapes::Circle` does not implement any method in scope named `area` +``` + +If we add a `use` line right above `main` and make the right things public, +everything is fine: + +```{rust} +use shapes::HasArea; + +mod shapes { + use std::f64::consts; + + pub trait HasArea { + fn area(&self) -> f64; + } + + pub struct Circle { + pub x: f64, + pub y: f64, + pub radius: f64, + } + + impl HasArea for Circle { + fn area(&self) -> f64 { + consts::PI * (self.radius * self.radius) + } + } +} + + +fn main() { + let c = shapes::Circle { + x: 0.0f64, + y: 0.0f64, + radius: 1.0f64, + }; + + println!("{}", c.area()); +} +``` + +This means that even if someone does something bad like add methods to `int`, +it won't affect you, unless you `use` that trait. + +There's one more restriction on implementing traits. Either the trait or the +type you're writing the `impl` for must be inside your crate. So, we could +implement the `HasArea` type for `int`, because `HasArea` is in our crate. But +if we tried to implement `Float`, a trait provided by Rust, for `int`, we could +not, because both the trait and the type aren't in our crate. + +One last thing about traits: generic functions with a trait bound use +**monomorphization** ("mono": one, "morph": form), so they are statically +dispatched. What's that mean? Well, let's take a look at `print_area` again: + +```{rust,ignore} +fn print_area<T: HasArea>(shape: T) { + println!("This shape has an area of {}", shape.area()); +} + +fn main() { + let c = Circle { ... }; + + let s = Square { ... }; + + print_area(c); + print_area(s); +} +``` + +When we use this trait with `Circle` and `Square`, Rust ends up generating +two different functions with the concrete type, and replacing the call sites with +calls to the concrete implementations. In other words, you get something like +this: + +```{rust,ignore} +fn __print_area_circle(shape: Circle) { + println!("This shape has an area of {}", shape.area()); +} + +fn __print_area_square(shape: Square) { + println!("This shape has an area of {}", shape.area()); +} + +fn main() { + let c = Circle { ... }; + + let s = Square { ... }; + + __print_area_circle(c); + __print_area_square(s); +} +``` + +The names don't actually change to this, it's just for illustration. But +as you can see, there's no overhead of deciding which version to call here, +hence 'statically dispatched.' The downside is that we have two copies of +the same function, so our binary is a little bit larger. diff --git a/src/doc/guide-unsafe.md b/src/doc/trpl/unsafe.md index 25ca07ad74f..3e0a1ef1345 100644 --- a/src/doc/guide-unsafe.md +++ b/src/doc/trpl/unsafe.md @@ -12,7 +12,7 @@ block which allows the programmer to dodge some of the compiler's checks and do a wide range of operations, such as: - dereferencing [raw pointers](#raw-pointers) -- calling a function via FFI ([covered by the FFI guide](guide-ffi.html)) +- calling a function via FFI ([covered by the FFI guide](ffi.html)) - casting between types bitwise (`transmute`, aka "reinterpret cast") - [inline assembly](#inline-assembly) @@ -37,7 +37,7 @@ build safe interfaces. ## References One of Rust's biggest features is memory safety. This is achieved in -part via [the ownership system](guide-ownership.html), which is how the +part via [the ownership system](ownership.html), which is how the compiler can guarantee that every `&` reference is always valid, and, for example, never pointing to freed memory. @@ -504,7 +504,7 @@ shouldn't get triggered. The second of these three functions, `eh_personality`, is used by the failure mechanisms of the compiler. This is often mapped to GCC's personality function (see the -[libstd implementation](std/rt/unwind/index.html) for more +[libstd implementation](../std/rt/unwind/index.html) for more information), but crates which do not trigger a panic can be assured that this function is never called. The final function, `panic_fmt`, is also used by the failure mechanisms of the compiler. @@ -517,7 +517,7 @@ also used by the failure mechanisms of the compiler. With the above techniques, we've got a bare-metal executable running some Rust code. There is a good deal of functionality provided by the standard library, however, that is necessary to be productive in Rust. If the standard library is -not sufficient, then [libcore](core/index.html) is designed to be used +not sufficient, then [libcore](../core/index.html) is designed to be used instead. The core library has very few dependencies and is much more portable than the diff --git a/src/doc/trpl/variable-bindings.md b/src/doc/trpl/variable-bindings.md new file mode 100644 index 00000000000..4e2e7bd2fe2 --- /dev/null +++ b/src/doc/trpl/variable-bindings.md @@ -0,0 +1,174 @@ +% Variable bindings + +The first thing we'll learn about are 'variable bindings.' They look like this: + +```{rust} +fn main() { + let x = 5; +} +``` + +Putting `fn main() {` in each example is a bit tedious, so we'll leave that out +in the future. If you're following along, make sure to edit your `main()` +function, rather than leaving it off. Otherwise, you'll get an error. + +In many languages, this is called a 'variable.' But Rust's variable bindings +have a few tricks up their sleeves. Rust has a very powerful feature called +'pattern matching' that we'll get into detail with later, but the left +hand side of a `let` expression is a full pattern, not just a variable name. +This means we can do things like: + +```{rust} +let (x, y) = (1, 2); +``` + +After this expression is evaluated, `x` will be one, and `y` will be two. +Patterns are really powerful, but this is about all we can do with them so far. +So let's just keep this in the back of our minds as we go forward. + +Rust is a statically typed language, which means that we specify our types up +front. So why does our first example compile? Well, Rust has this thing called +"type inference." If it can figure out what the type of something is, Rust +doesn't require you to actually type it out. + +We can add the type if we want to, though. Types come after a colon (`:`): + +```{rust} +let x: i32 = 5; +``` + +If I asked you to read this out loud to the rest of the class, you'd say "`x` +is a binding with the type `i32` and the value `five`." + +In future examples, we may annotate the type in a comment. The examples will +look like this: + +```{rust} +fn main() { + let x = 5; // x: i32 +} +``` + +Note the similarities between this annotation and the syntax you use with `let`. +Including these kinds of comments is not idiomatic Rust, but we'll occasionally +include them to help you understand what the types that Rust infers are. + +By default, bindings are **immutable**. This code will not compile: + +```{ignore} +let x = 5; +x = 10; +``` + +It will give you this error: + +```text +error: re-assignment of immutable variable `x` + x = 10; + ^~~~~~~ +``` + +If you want a binding to be mutable, you can use `mut`: + +```{rust} +let mut x = 5; // mut x: i32 +x = 10; +``` + +There is no single reason that bindings are immutable by default, but we can +think about it through one of Rust's primary focuses: safety. If you forget to +say `mut`, the compiler will catch it, and let you know that you have mutated +something you may not have intended to mutate. If bindings were mutable by +default, the compiler would not be able to tell you this. If you _did_ intend +mutation, then the solution is quite easy: add `mut`. + +There are other good reasons to avoid mutable state when possible, but they're +out of the scope of this guide. In general, you can often avoid explicit +mutation, and so it is preferable in Rust. That said, sometimes, mutation is +what you need, so it's not verboten. + +Let's get back to bindings. Rust variable bindings have one more aspect that +differs from other languages: bindings are required to be initialized with a +value before you're allowed to use them. If we try... + +```{ignore} +let x; +``` + +...we'll get an error: + +```text +src/main.rs:2:9: 2:10 error: cannot determine a type for this local variable: unconstrained type +src/main.rs:2 let x; + ^ +``` + +Giving it a type will compile, though: + +```{rust} +let x: i32; +``` + +Let's try it out. Change your `src/main.rs` file to look like this: + +```{rust} +fn main() { + let x: i32; + + println!("Hello world!"); +} +``` + +You can use `cargo build` on the command line to build it. You'll get a warning, +but it will still print "Hello, world!": + +```text + Compiling hello_world v0.0.1 (file:///home/you/projects/hello_world) +src/main.rs:2:9: 2:10 warning: unused variable: `x`, #[warn(unused_variable)] on by default +src/main.rs:2 let x: i32; + ^ +``` + +Rust warns us that we never use the variable binding, but since we never use it, +no harm, no foul. Things change if we try to actually use this `x`, however. Let's +do that. Change your program to look like this: + +```{rust,ignore} +fn main() { + let x: i32; + + println!("The value of x is: {}", x); +} +``` + +And try to build it. You'll get an error: + +```{bash} +$ cargo build + Compiling hello_world v0.0.1 (file:///home/you/projects/hello_world) +src/main.rs:4:39: 4:40 error: use of possibly uninitialized variable: `x` +src/main.rs:4 println!("The value of x is: {}", x); + ^ +note: in expansion of format_args! +<std macros>:2:23: 2:77 note: expansion site +<std macros>:1:1: 3:2 note: in expansion of println! +src/main.rs:4:5: 4:42 note: expansion site +error: aborting due to previous error +Could not compile `hello_world`. +``` + +Rust will not let us use a value that has not been initialized. Next, let's +talk about this stuff we've added to `println!`. + +If you include two curly braces (`{}`, some call them moustaches...) in your +string to print, Rust will interpret this as a request to interpolate some sort +of value. **String interpolation** is a computer science term that means "stick +in the middle of a string." We add a comma, and then `x`, to indicate that we +want `x` to be the value we're interpolating. The comma is used to separate +arguments we pass to functions and macros, if you're passing more than one. + +When you just use the curly braces, Rust will attempt to display the +value in a meaningful way by checking out its type. If you want to specify the +format in a more detailed manner, there are a [wide number of options +available](../std/fmt/index.html). For now, we'll just stick to the default: +integers aren't very complicated to print. diff --git a/src/liballoc/arc.rs b/src/liballoc/arc.rs index 48136bc1d96..290dd21d666 100644 --- a/src/liballoc/arc.rs +++ b/src/liballoc/arc.rs @@ -126,7 +126,7 @@ unsafe impl<T: Sync + Send> Sync for Arc<T> { } /// Weak pointers will not keep the data inside of the `Arc` alive, and can be used to break cycles /// between `Arc` pointers. #[unsafe_no_drop_flag] -#[experimental = "Weak pointers may not belong in this module."] +#[unstable = "Weak pointers may not belong in this module."] pub struct Weak<T> { // FIXME #12808: strange name to try to avoid interfering with // field accesses of the contained type via Deref @@ -179,7 +179,7 @@ impl<T> Arc<T> { /// /// let weak_five = five.downgrade(); /// ``` - #[experimental = "Weak pointers may not belong in this module."] + #[unstable = "Weak pointers may not belong in this module."] pub fn downgrade(&self) -> Weak<T> { // See the clone() impl for why this is relaxed self.inner().weak.fetch_add(1, Relaxed); @@ -200,12 +200,12 @@ impl<T> Arc<T> { /// Get the number of weak references to this value. #[inline] -#[experimental] +#[unstable] pub fn weak_count<T>(this: &Arc<T>) -> uint { this.inner().weak.load(SeqCst) - 1 } /// Get the number of strong references to this value. #[inline] -#[experimental] +#[unstable] pub fn strong_count<T>(this: &Arc<T>) -> uint { this.inner().strong.load(SeqCst) } #[stable] @@ -271,7 +271,7 @@ impl<T: Send + Sync + Clone> Arc<T> { /// let mut_five = five.make_unique(); /// ``` #[inline] - #[experimental] + #[unstable] pub fn make_unique(&mut self) -> &mut T { // Note that we hold a strong reference, which also counts as a weak reference, so we only // clone if there is an additional reference of either kind. @@ -355,7 +355,7 @@ impl<T: Sync + Send> Drop for Arc<T> { } } -#[experimental = "Weak pointers may not belong in this module."] +#[unstable = "Weak pointers may not belong in this module."] impl<T: Sync + Send> Weak<T> { /// Upgrades a weak reference to a strong reference. /// @@ -393,7 +393,7 @@ impl<T: Sync + Send> Weak<T> { } } -#[experimental = "Weak pointers may not belong in this module."] +#[unstable = "Weak pointers may not belong in this module."] impl<T: Sync + Send> Clone for Weak<T> { /// Makes a clone of the `Weak<T>`. /// @@ -604,7 +604,7 @@ impl<H: Hasher, T: Hash<H>> Hash<H> for Arc<T> { } #[cfg(test)] -#[allow(experimental)] +#[allow(unstable)] mod tests { use std::clone::Clone; use std::sync::mpsc::channel; diff --git a/src/liballoc/boxed.rs b/src/liballoc/boxed.rs index 97b198164eb..458eb3dce57 100644 --- a/src/liballoc/boxed.rs +++ b/src/liballoc/boxed.rs @@ -44,7 +44,7 @@ use core::ops::{Deref, DerefMut}; /// } /// ``` #[lang = "exchange_heap"] -#[experimental = "may be renamed; uncertain about custom allocator design"] +#[unstable = "may be renamed; uncertain about custom allocator design"] pub static HEAP: () = (); /// A type that represents a uniquely-owned value. diff --git a/src/liballoc/lib.rs b/src/liballoc/lib.rs index 0bb8ba669ec..4a85637625a 100644 --- a/src/liballoc/lib.rs +++ b/src/liballoc/lib.rs @@ -57,7 +57,7 @@ //! default global allocator. It is not compatible with the libc allocator API. #![crate_name = "alloc"] -#![experimental] +#![unstable] #![staged_api] #![crate_type = "rlib"] #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png", @@ -68,6 +68,7 @@ #![allow(unknown_features)] #![feature(lang_items, unsafe_destructor)] #![feature(box_syntax)] +#![allow(unknown_features)] #![feature(int_uint)] #[macro_use] extern crate core; diff --git a/src/liballoc/rc.rs b/src/liballoc/rc.rs index 27b3f03002f..f42c6dbdc15 100644 --- a/src/liballoc/rc.rs +++ b/src/liballoc/rc.rs @@ -221,7 +221,7 @@ impl<T> Rc<T> { /// /// let weak_five = five.downgrade(); /// ``` - #[experimental = "Weak pointers may not belong in this module"] + #[unstable = "Weak pointers may not belong in this module"] pub fn downgrade(&self) -> Weak<T> { self.inc_weak(); Weak { @@ -234,12 +234,12 @@ impl<T> Rc<T> { /// Get the number of weak references to this value. #[inline] -#[experimental] +#[unstable] pub fn weak_count<T>(this: &Rc<T>) -> uint { this.weak() - 1 } /// Get the number of strong references to this value. #[inline] -#[experimental] +#[unstable] pub fn strong_count<T>(this: &Rc<T>) -> uint { this.strong() } /// Returns true if there are no other `Rc` or `Weak<T>` values that share the same inner value. @@ -255,7 +255,7 @@ pub fn strong_count<T>(this: &Rc<T>) -> uint { this.strong() } /// rc::is_unique(&five); /// ``` #[inline] -#[experimental] +#[unstable] pub fn is_unique<T>(rc: &Rc<T>) -> bool { weak_count(rc) == 0 && strong_count(rc) == 1 } @@ -277,7 +277,7 @@ pub fn is_unique<T>(rc: &Rc<T>) -> bool { /// assert_eq!(rc::try_unwrap(x), Err(Rc::new(4u))); /// ``` #[inline] -#[experimental] +#[unstable] pub fn try_unwrap<T>(rc: Rc<T>) -> Result<T, Rc<T>> { if is_unique(&rc) { unsafe { @@ -311,7 +311,7 @@ pub fn try_unwrap<T>(rc: Rc<T>) -> Result<T, Rc<T>> { /// assert!(rc::get_mut(&mut x).is_none()); /// ``` #[inline] -#[experimental] +#[unstable] pub fn get_mut<'a, T>(rc: &'a mut Rc<T>) -> Option<&'a mut T> { if is_unique(rc) { let inner = unsafe { &mut **rc._ptr }; @@ -337,7 +337,7 @@ impl<T: Clone> Rc<T> { /// let mut_five = five.make_unique(); /// ``` #[inline] - #[experimental] + #[unstable] pub fn make_unique(&mut self) -> &mut T { if !is_unique(self) { *self = Rc::new((**self).clone()) @@ -615,7 +615,7 @@ impl<S: hash::Hasher, T: Hash<S>> Hash<S> for Rc<T> { } } -#[experimental = "Show is experimental."] +#[unstable = "Show is experimental."] impl<T: fmt::Show> fmt::Show for Rc<T> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "Rc({:?})", **self) @@ -635,7 +635,7 @@ impl<T: fmt::String> fmt::String for Rc<T> { /// /// See the [module level documentation](../index.html) for more. #[unsafe_no_drop_flag] -#[experimental = "Weak pointers may not belong in this module."] +#[unstable = "Weak pointers may not belong in this module."] pub struct Weak<T> { // FIXME #12808: strange names to try to avoid interfering with // field accesses of the contained type via Deref @@ -644,7 +644,7 @@ pub struct Weak<T> { _noshare: marker::NoSync } -#[experimental = "Weak pointers may not belong in this module."] +#[unstable = "Weak pointers may not belong in this module."] impl<T> Weak<T> { /// Upgrades a weak reference to a strong reference. /// @@ -717,7 +717,7 @@ impl<T> Drop for Weak<T> { } } -#[experimental = "Weak pointers may not belong in this module."] +#[unstable = "Weak pointers may not belong in this module."] impl<T> Clone for Weak<T> { /// Makes a clone of the `Weak<T>`. /// @@ -739,7 +739,7 @@ impl<T> Clone for Weak<T> { } } -#[experimental = "Show is experimental."] +#[unstable = "Show is experimental."] impl<T: fmt::Show> fmt::Show for Weak<T> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "(Weak)") @@ -780,7 +780,7 @@ impl<T> RcBoxPtr<T> for Weak<T> { } #[cfg(test)] -#[allow(experimental)] +#[allow(unstable)] mod tests { use super::{Rc, Weak, weak_count, strong_count}; use std::cell::RefCell; diff --git a/src/libarena/lib.rs b/src/libarena/lib.rs index f208ff9dc05..e3d075c0f39 100644 --- a/src/libarena/lib.rs +++ b/src/libarena/lib.rs @@ -20,7 +20,7 @@ //! more complex, slower arena which can hold objects of any type. #![crate_name = "arena"] -#![experimental] +#![unstable] #![staged_api] #![crate_type = "rlib"] #![crate_type = "dylib"] @@ -32,6 +32,7 @@ #![feature(unsafe_destructor)] #![feature(unboxed_closures)] #![feature(box_syntax)] +#![allow(unknown_features)] #![feature(int_uint)] #![allow(missing_docs)] extern crate alloc; diff --git a/src/libcollections/lib.rs b/src/libcollections/lib.rs index 7692c1558a7..54ab26c4f77 100644 --- a/src/libcollections/lib.rs +++ b/src/libcollections/lib.rs @@ -14,7 +14,7 @@ #![crate_name = "collections"] -#![experimental] +#![unstable] #![staged_api] #![crate_type = "rlib"] #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png", @@ -27,6 +27,7 @@ #![feature(box_syntax)] #![feature(unboxed_closures)] #![feature(old_impl_check)] +#![allow(unknown_features)] #![feature(int_uint)] #![no_std] #[macro_use] diff --git a/src/libcollections/slice.rs b/src/libcollections/slice.rs index cb3fbd461cd..9a1f22ef7a6 100644 --- a/src/libcollections/slice.rs +++ b/src/libcollections/slice.rs @@ -166,7 +166,7 @@ pub trait SliceExt { /// assert_eq!(num_moved, 3); /// assert!(a == [6i, 7, 8, 4, 5]); /// ``` - #[experimental = "uncertain about this API approach"] + #[unstable = "uncertain about this API approach"] fn move_from(&mut self, src: Vec<Self::Item>, start: uint, end: uint) -> uint; /// Returns a subslice spanning the interval [`start`, `end`). @@ -175,7 +175,7 @@ pub trait SliceExt { /// original slice (i.e. when `end > self.len()`) or when `start > end`. /// /// Slicing with `start` equal to `end` yields an empty slice. - #[experimental = "will be replaced by slice syntax"] + #[unstable = "will be replaced by slice syntax"] fn slice(&self, start: uint, end: uint) -> &[Self::Item]; /// Returns a subslice from `start` to the end of the slice. @@ -183,7 +183,7 @@ pub trait SliceExt { /// Panics when `start` is strictly greater than the length of the original slice. /// /// Slicing from `self.len()` yields an empty slice. - #[experimental = "will be replaced by slice syntax"] + #[unstable = "will be replaced by slice syntax"] fn slice_from(&self, start: uint) -> &[Self::Item]; /// Returns a subslice from the start of the slice to `end`. @@ -191,7 +191,7 @@ pub trait SliceExt { /// Panics when `end` is strictly greater than the length of the original slice. /// /// Slicing to `0` yields an empty slice. - #[experimental = "will be replaced by slice syntax"] + #[unstable = "will be replaced by slice syntax"] fn slice_to(&self, end: uint) -> &[Self::Item]; /// Divides one slice into two at an index. @@ -284,11 +284,11 @@ pub trait SliceExt { fn first(&self) -> Option<&Self::Item>; /// Returns all but the first element of a slice. - #[experimental = "likely to be renamed"] + #[unstable = "likely to be renamed"] fn tail(&self) -> &[Self::Item]; /// Returns all but the last element of a slice. - #[experimental = "likely to be renamed"] + #[unstable = "likely to be renamed"] fn init(&self) -> &[Self::Item]; /// Returns the last element of a slice, or `None` if it is empty. @@ -384,7 +384,7 @@ pub trait SliceExt { /// original slice (i.e. when `end > self.len()`) or when `start > end`. /// /// Slicing with `start` equal to `end` yields an empty slice. - #[experimental = "will be replaced by slice syntax"] + #[unstable = "will be replaced by slice syntax"] fn slice_mut(&mut self, start: uint, end: uint) -> &mut [Self::Item]; /// Returns a mutable subslice from `start` to the end of the slice. @@ -392,7 +392,7 @@ pub trait SliceExt { /// Panics when `start` is strictly greater than the length of the original slice. /// /// Slicing from `self.len()` yields an empty slice. - #[experimental = "will be replaced by slice syntax"] + #[unstable = "will be replaced by slice syntax"] fn slice_from_mut(&mut self, start: uint) -> &mut [Self::Item]; /// Returns a mutable subslice from the start of the slice to `end`. @@ -400,7 +400,7 @@ pub trait SliceExt { /// Panics when `end` is strictly greater than the length of the original slice. /// /// Slicing to `0` yields an empty slice. - #[experimental = "will be replaced by slice syntax"] + #[unstable = "will be replaced by slice syntax"] fn slice_to_mut(&mut self, end: uint) -> &mut [Self::Item]; /// Returns an iterator that allows modifying each value @@ -412,11 +412,11 @@ pub trait SliceExt { fn first_mut(&mut self) -> Option<&mut Self::Item>; /// Returns all but the first element of a mutable slice - #[experimental = "likely to be renamed or removed"] + #[unstable = "likely to be renamed or removed"] fn tail_mut(&mut self) -> &mut [Self::Item]; /// Returns all but the last element of a mutable slice - #[experimental = "likely to be renamed or removed"] + #[unstable = "likely to be renamed or removed"] fn init_mut(&mut self) -> &mut [Self::Item]; /// Returns a mutable pointer to the last item in the slice. @@ -588,7 +588,7 @@ pub trait SliceExt { /// assert!(dst.clone_from_slice(&src2) == 3); /// assert!(dst == [3i, 4, 5]); /// ``` - #[experimental] + #[unstable] fn clone_from_slice(&mut self, &[Self::Item]) -> uint where Self::Item: Clone; /// Sorts the slice, in place. @@ -677,11 +677,11 @@ pub trait SliceExt { fn prev_permutation(&mut self) -> bool where Self::Item: Ord; /// Find the first index containing a matching value. - #[experimental] + #[unstable] fn position_elem(&self, t: &Self::Item) -> Option<uint> where Self::Item: PartialEq; /// Find the last index containing a matching value. - #[experimental] + #[unstable] fn rposition_elem(&self, t: &Self::Item) -> Option<uint> where Self::Item: PartialEq; /// Return true if the slice contains an element with the given value. @@ -697,7 +697,7 @@ pub trait SliceExt { fn ends_with(&self, needle: &[Self::Item]) -> bool where Self::Item: PartialEq; /// Convert `self` into a vector without clones or allocation. - #[experimental] + #[unstable] fn into_vec(self: Box<Self>) -> Vec<Self::Item>; } @@ -1034,7 +1034,7 @@ impl<T: Clone, V: AsSlice<T>> SliceConcatExt<T, Vec<T>> for [V] { /// /// The last generated swap is always (0, 1), and it returns the /// sequence to its initial order. -#[experimental] +#[unstable] #[derive(Clone)] pub struct ElementSwaps { sdir: Vec<SizeDirection>, @@ -1046,7 +1046,7 @@ pub struct ElementSwaps { impl ElementSwaps { /// Creates an `ElementSwaps` iterator for a sequence of `length` elements. - #[experimental] + #[unstable] pub fn new(length: uint) -> ElementSwaps { // Initialize `sdir` with a direction that position should move in // (all negative at the beginning) and the `size` of the diff --git a/src/libcollections/string.rs b/src/libcollections/string.rs index 317f03e1b7d..5991fc832e9 100644 --- a/src/libcollections/string.rs +++ b/src/libcollections/string.rs @@ -92,7 +92,7 @@ impl String { /// assert_eq!(s.as_slice(), "hello"); /// ``` #[inline] - #[experimental = "needs investigation to see if to_string() can match perf"] + #[unstable = "needs investigation to see if to_string() can match perf"] pub fn from_str(string: &str) -> String { String { vec: ::slice::SliceExt::to_vec(string.as_bytes()) } } @@ -719,7 +719,7 @@ impl<'a> FromIterator<&'a str> for String { } } -#[experimental = "waiting on Extend stabilization"] +#[unstable = "waiting on Extend stabilization"] impl Extend<char> for String { fn extend<I:Iterator<Item=char>>(&mut self, mut iterator: I) { let (lower_bound, _) = iterator.size_hint(); @@ -730,7 +730,7 @@ impl Extend<char> for String { } } -#[experimental = "waiting on Extend stabilization"] +#[unstable = "waiting on Extend stabilization"] impl<'a> Extend<&'a str> for String { fn extend<I: Iterator<Item=&'a str>>(&mut self, mut iterator: I) { // A guess that at least one byte per iterator element will be needed. @@ -790,7 +790,7 @@ impl<'a, 'b> PartialEq<CowString<'a>> for &'b str { fn ne(&self, other: &CowString<'a>) -> bool { PartialEq::ne(&**self, &**other) } } -#[experimental = "waiting on Str stabilization"] +#[unstable = "waiting on Str stabilization"] impl Str for String { #[inline] #[stable] @@ -814,14 +814,14 @@ impl fmt::String for String { } } -#[experimental = "waiting on fmt stabilization"] +#[unstable = "waiting on fmt stabilization"] impl fmt::Show for String { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::Show::fmt(&**self, f) } } -#[experimental = "waiting on Hash stabilization"] +#[unstable = "waiting on Hash stabilization"] #[cfg(stage0)] impl<H: hash::Writer> hash::Hash<H> for String { #[inline] @@ -829,7 +829,7 @@ impl<H: hash::Writer> hash::Hash<H> for String { (**self).hash(hasher) } } -#[experimental = "waiting on Hash stabilization"] +#[unstable = "waiting on Hash stabilization"] #[cfg(not(stage0))] impl<H: hash::Writer + hash::Hasher> hash::Hash<H> for String { #[inline] @@ -887,7 +887,7 @@ impl ops::Deref for String { } /// Wrapper type providing a `&String` reference via `Deref`. -#[experimental] +#[unstable] pub struct DerefString<'a> { x: DerefVec<'a, u8> } @@ -914,7 +914,7 @@ impl<'a> Deref for DerefString<'a> { /// let string = as_string("foo").clone(); /// string_consumer(string); /// ``` -#[experimental] +#[unstable] pub fn as_string<'a>(x: &'a str) -> DerefString<'a> { DerefString { x: as_vec(x.as_bytes()) } } diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs index 69a3947df2b..47afc78bc12 100644 --- a/src/libcollections/vec.rs +++ b/src/libcollections/vec.rs @@ -376,7 +376,7 @@ impl<T> Vec<T> { /// Note that this will drop any excess capacity. Calling this and /// converting back to a vector with `into_vec()` is equivalent to calling /// `shrink_to_fit()`. - #[experimental] + #[unstable] pub fn into_boxed_slice(mut self) -> Box<[T]> { self.shrink_to_fit(); unsafe { @@ -777,7 +777,7 @@ impl<T> Vec<T> { /// let newtyped_bytes = bytes.map_in_place(|x| Newtype(x)); /// assert_eq!(newtyped_bytes.as_slice(), [Newtype(0x11), Newtype(0x22)].as_slice()); /// ``` - #[experimental = "API may change to provide stronger guarantees"] + #[unstable = "API may change to provide stronger guarantees"] pub fn map_in_place<U, F>(self, mut f: F) -> Vec<U> where F: FnMut(T) -> U { // FIXME: Assert statically that the types `T` and `U` have the same // size. @@ -995,7 +995,7 @@ impl<T: Clone> Vec<T> { /// assert_eq!(vec, vec![1, 2, 3, 4]); /// ``` #[inline] - #[experimental = "likely to be replaced by a more optimized extend"] + #[unstable = "likely to be replaced by a more optimized extend"] pub fn push_all(&mut self, other: &[T]) { self.reserve(other.len()); @@ -1200,7 +1200,7 @@ impl<S: hash::Writer + hash::Hasher, T: Hash<S>> Hash<S> for Vec<T> { } } -#[experimental = "waiting on Index stability"] +#[unstable = "waiting on Index stability"] impl<T> Index<uint> for Vec<T> { type Output = T; @@ -1304,7 +1304,7 @@ impl<T> FromIterator<T> for Vec<T> { } } -#[experimental = "waiting on Extend stability"] +#[unstable = "waiting on Extend stability"] impl<T> Extend<T> for Vec<T> { #[inline] fn extend<I: Iterator<Item=T>>(&mut self, mut iterator: I) { @@ -1457,7 +1457,7 @@ impl<T> Default for Vec<T> { } } -#[experimental = "waiting on Show stability"] +#[unstable = "waiting on Show stability"] impl<T: fmt::Show> fmt::Show for Vec<T> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::Show::fmt(self.as_slice(), f) @@ -1475,7 +1475,7 @@ impl<'a> fmt::Writer for Vec<u8> { // Clone-on-write //////////////////////////////////////////////////////////////////////////////// -#[experimental = "unclear how valuable this alias is"] +#[unstable = "unclear how valuable this alias is"] /// A clone-on-write vector pub type CowVec<'a, T> = Cow<'a, Vec<T>, [T]>; @@ -1693,13 +1693,13 @@ impl<'a, T> Drop for Drain<'a, T> { //////////////////////////////////////////////////////////////////////////////// /// Wrapper type providing a `&Vec<T>` reference via `Deref`. -#[experimental] +#[unstable] pub struct DerefVec<'a, T> { x: Vec<T>, l: ContravariantLifetime<'a> } -#[experimental] +#[unstable] impl<'a, T> Deref for DerefVec<'a, T> { type Target = Vec<T>; @@ -1719,7 +1719,7 @@ impl<'a, T> Drop for DerefVec<'a, T> { } /// Convert a slice to a wrapper type providing a `&Vec<T>` reference. -#[experimental] +#[unstable] pub fn as_vec<'a, T>(x: &'a [T]) -> DerefVec<'a, T> { unsafe { DerefVec { diff --git a/src/libcore/any.rs b/src/libcore/any.rs index 25007bfde93..797687a9ad9 100644 --- a/src/libcore/any.rs +++ b/src/libcore/any.rs @@ -89,7 +89,7 @@ use intrinsics::TypeId; #[stable] pub trait Any: 'static { /// Get the `TypeId` of `self` - #[experimental = "this method will likely be replaced by an associated static"] + #[unstable = "this method will likely be replaced by an associated static"] fn get_type_id(&self) -> TypeId; } diff --git a/src/libcore/array.rs b/src/libcore/array.rs index 0cea0b3d88e..c07fac108d6 100644 --- a/src/libcore/array.rs +++ b/src/libcore/array.rs @@ -12,7 +12,7 @@ //! up to a certain length. Eventually we should able to generalize //! to all lengths. -#![experimental] // not yet reviewed +#![unstable] // not yet reviewed use clone::Clone; use cmp::{PartialEq, Eq, PartialOrd, Ord, Ordering}; diff --git a/src/libcore/cell.rs b/src/libcore/cell.rs index 674364269f1..6db01b7cb7a 100644 --- a/src/libcore/cell.rs +++ b/src/libcore/cell.rs @@ -202,7 +202,7 @@ impl<T:Copy> Cell<T> { /// /// This function is `unsafe` because `UnsafeCell`'s field is public. #[inline] - #[experimental] + #[unstable] pub unsafe fn as_unsafe_cell<'a>(&'a self) -> &'a UnsafeCell<T> { &self.value } @@ -332,7 +332,7 @@ impl<T> RefCell<T> { /// /// This function is `unsafe` because `UnsafeCell`'s field is public. #[inline] - #[experimental] + #[unstable] pub unsafe fn as_unsafe_cell<'a>(&'a self) -> &'a UnsafeCell<T> { &self.value } @@ -424,7 +424,7 @@ impl<'b, T> Deref for Ref<'b, T> { /// /// A `Clone` implementation would interfere with the widespread /// use of `r.borrow().clone()` to clone the contents of a `RefCell`. -#[experimental = "likely to be moved to a method, pending language changes"] +#[unstable = "likely to be moved to a method, pending language changes"] pub fn clone_ref<'b, T:Clone>(orig: &Ref<'b, T>) -> Ref<'b, T> { Ref { _value: orig._value, diff --git a/src/libcore/clone.rs b/src/libcore/clone.rs index 3149247a83a..ffa6d085543 100644 --- a/src/libcore/clone.rs +++ b/src/libcore/clone.rs @@ -81,7 +81,7 @@ clone_impl! { char } macro_rules! extern_fn_clone { ($($A:ident),*) => ( - #[experimental = "this may not be sufficient for fns with region parameters"] + #[unstable = "this may not be sufficient for fns with region parameters"] impl<$($A,)* ReturnType> Clone for extern "Rust" fn($($A),*) -> ReturnType { /// Return a copy of a function pointer #[inline] diff --git a/src/libcore/cmp.rs b/src/libcore/cmp.rs index c3dfd5f5159..c1f1997df74 100644 --- a/src/libcore/cmp.rs +++ b/src/libcore/cmp.rs @@ -290,7 +290,7 @@ pub fn max<T: Ord>(v1: T, v2: T) -> T { /// /// Returns the first argument if the comparison determines them to be equal. #[inline] -#[experimental] +#[unstable] pub fn partial_min<T: PartialOrd>(v1: T, v2: T) -> Option<T> { match v1.partial_cmp(&v2) { Some(Less) | Some(Equal) => Some(v1), @@ -303,7 +303,7 @@ pub fn partial_min<T: PartialOrd>(v1: T, v2: T) -> Option<T> { /// /// Returns the first argument if the comparison determines them to be equal. #[inline] -#[experimental] +#[unstable] pub fn partial_max<T: PartialOrd>(v1: T, v2: T) -> Option<T> { match v1.partial_cmp(&v2) { Some(Less) => Some(v2), diff --git a/src/libcore/finally.rs b/src/libcore/finally.rs index 2b48b2bf81a..a21ec892dd7 100644 --- a/src/libcore/finally.rs +++ b/src/libcore/finally.rs @@ -32,7 +32,7 @@ //! # } //! ``` -#![experimental] +#![unstable] use ops::{Drop, FnMut, FnOnce}; diff --git a/src/libcore/fmt/mod.rs b/src/libcore/fmt/mod.rs index 1d3767c9e33..67d5482898e 100644 --- a/src/libcore/fmt/mod.rs +++ b/src/libcore/fmt/mod.rs @@ -36,7 +36,7 @@ mod num; mod float; pub mod rt; -#[experimental = "core and I/O reconciliation may alter this definition"] +#[unstable = "core and I/O reconciliation may alter this definition"] /// The type returned by formatter methods. pub type Result = result::Result<(), Error>; @@ -45,7 +45,7 @@ pub type Result = result::Result<(), Error>; /// This type does not support transmission of an error other than that an error /// occurred. Any extra information must be arranged to be transmitted through /// some other means. -#[experimental = "core and I/O reconciliation may alter this definition"] +#[unstable = "core and I/O reconciliation may alter this definition"] #[derive(Copy)] pub struct Error; @@ -58,7 +58,7 @@ pub struct Error; /// This trait should generally not be implemented by consumers of the standard /// library. The `write!` macro accepts an instance of `io::Writer`, and the /// `io::Writer` trait is favored over implementing this trait. -#[experimental = "waiting for core and I/O reconciliation"] +#[unstable = "waiting for core and I/O reconciliation"] pub trait Writer { /// Writes a slice of bytes into this writer, returning whether the write /// succeeded. @@ -123,7 +123,7 @@ enum Void {} /// family of functions. It contains a function to format the given value. At /// compile time it is ensured that the function and the value have the correct /// types, and then this struct is used to canonicalize arguments to one type. -#[experimental = "implementation detail of the `format_args!` macro"] +#[unstable = "implementation detail of the `format_args!` macro"] #[derive(Copy)] pub struct Argument<'a> { value: &'a Void, @@ -162,7 +162,7 @@ impl<'a> Arguments<'a> { /// When using the format_args!() macro, this function is used to generate the /// Arguments structure. #[doc(hidden)] #[inline] - #[experimental = "implementation detail of the `format_args!` macro"] + #[unstable = "implementation detail of the `format_args!` macro"] pub fn new(pieces: &'a [&'a str], args: &'a [Argument<'a>]) -> Arguments<'a> { Arguments { @@ -179,7 +179,7 @@ impl<'a> Arguments<'a> { /// created with `argumentuint`. However, failing to do so doesn't cause /// unsafety, but will ignore invalid . #[doc(hidden)] #[inline] - #[experimental = "implementation detail of the `format_args!` macro"] + #[unstable = "implementation detail of the `format_args!` macro"] pub fn with_placeholders(pieces: &'a [&'a str], fmt: &'a [rt::Argument<'a>], args: &'a [Argument<'a>]) -> Arguments<'a> { @@ -301,7 +301,7 @@ pub trait UpperExp { /// /// * output - the buffer to write output to /// * args - the precompiled arguments generated by `format_args!` -#[experimental = "libcore and I/O have yet to be reconciled, and this is an \ +#[unstable = "libcore and I/O have yet to be reconciled, and this is an \ implementation detail which should not otherwise be exported"] pub fn write(output: &mut Writer, args: Arguments) -> Result { let mut formatter = Formatter { @@ -563,7 +563,7 @@ impl<'a> Formatter<'a> { } /// Flags for formatting (packed version of rt::Flag) - #[experimental = "return type may change and method was just created"] + #[unstable = "return type may change and method was just created"] pub fn flags(&self) -> uint { self.flags } /// Character used as 'fill' whenever there is alignment @@ -592,7 +592,7 @@ impl Show for Error { /// This is a function which calls are emitted to by the compiler itself to /// create the Argument structures that are passed into the `format` function. #[doc(hidden)] #[inline] -#[experimental = "implementation detail of the `format_args!` macro"] +#[unstable = "implementation detail of the `format_args!` macro"] pub fn argument<'a, T>(f: fn(&T, &mut Formatter) -> Result, t: &'a T) -> Argument<'a> { Argument::new(t, f) @@ -601,7 +601,7 @@ pub fn argument<'a, T>(f: fn(&T, &mut Formatter) -> Result, /// When the compiler determines that the type of an argument *must* be a uint /// (such as for width and precision), then it invokes this method. #[doc(hidden)] #[inline] -#[experimental = "implementation detail of the `format_args!` macro"] +#[unstable = "implementation detail of the `format_args!` macro"] pub fn argumentuint<'a>(s: &'a uint) -> Argument<'a> { Argument::from_uint(s) } diff --git a/src/libcore/fmt/rt.rs b/src/libcore/fmt/rt.rs index 6dbda3d8445..8d8e8c4b703 100644 --- a/src/libcore/fmt/rt.rs +++ b/src/libcore/fmt/rt.rs @@ -14,7 +14,7 @@ //! These definitions are similar to their `ct` equivalents, but differ in that //! these can be statically allocated and are slightly optimized for the runtime -#![experimental = "implementation detail of the `format_args!` macro"] +#![unstable = "implementation detail of the `format_args!` macro"] pub use self::Alignment::*; pub use self::Count::*; diff --git a/src/libcore/intrinsics.rs b/src/libcore/intrinsics.rs index c8b3616a404..5924d515dda 100644 --- a/src/libcore/intrinsics.rs +++ b/src/libcore/intrinsics.rs @@ -39,7 +39,7 @@ //! guaranteed to happen in order. This is the standard mode for working //! with atomic types and is equivalent to Java's `volatile`. -#![experimental] +#![unstable] #![allow(missing_docs)] #[cfg(not(stage0))] @@ -333,7 +333,7 @@ extern "rust-intrinsic" { /// Invokes memset on the specified pointer, setting `count * size_of::<T>()` /// bytes of memory starting at `dst` to `c`. - #[experimental = "uncertain about naming and semantics"] + #[unstable = "uncertain about naming and semantics"] pub fn set_memory<T>(dst: *mut T, val: u8, count: uint); /// Equivalent to the appropriate `llvm.memcpy.p0i8.0i8.*` intrinsic, with diff --git a/src/libcore/iter.rs b/src/libcore/iter.rs index 273a51665ce..d4aa4c99a76 100644 --- a/src/libcore/iter.rs +++ b/src/libcore/iter.rs @@ -942,7 +942,7 @@ pub trait IteratorExt: Iterator + Sized { } /// Use an iterator to reverse a container in place. - #[experimental = "uncertain about placement or widespread use"] + #[unstable = "uncertain about placement or widespread use"] fn reverse_in_place<'a, T: 'a>(&mut self) where Self: Iterator<Item=&'a mut T> + DoubleEndedIterator { @@ -974,7 +974,7 @@ pub trait DoubleEndedIterator: Iterator { /// Calling `next()` or `next_back()` on a `RandomAccessIterator` /// reduces the indexable range accordingly. That is, `it.idx(1)` will become `it.idx(0)` /// after `it.next()` is called. -#[experimental = "not widely used, may be better decomposed into Index and ExactSizeIterator"] +#[unstable = "not widely used, may be better decomposed into Index and ExactSizeIterator"] pub trait RandomAccessIterator: Iterator { /// Return the number of indexable elements. At most `std::uint::MAX` /// elements are indexable, even if the iterator represents a longer range. @@ -1049,7 +1049,7 @@ impl<I> DoubleEndedIterator for Rev<I> where I: DoubleEndedIterator { fn next_back(&mut self) -> Option<<I as Iterator>::Item> { self.iter.next() } } -#[experimental = "trait is experimental"] +#[unstable = "trait is experimental"] impl<I> RandomAccessIterator for Rev<I> where I: DoubleEndedIterator + RandomAccessIterator { #[inline] fn indexable(&self) -> uint { self.iter.indexable() } @@ -1084,7 +1084,7 @@ impl<'a, I> DoubleEndedIterator for ByRef<'a, I> where I: 'a + DoubleEndedIterat } /// A trait for iterators over elements which can be added together -#[experimental = "needs to be re-evaluated as part of numerics reform"] +#[unstable = "needs to be re-evaluated as part of numerics reform"] pub trait AdditiveIterator<A> { /// Iterates over the entire iterator, summing up all the elements /// @@ -1102,7 +1102,7 @@ pub trait AdditiveIterator<A> { macro_rules! impl_additive { ($A:ty, $init:expr) => { - #[experimental = "trait is experimental"] + #[unstable = "trait is experimental"] impl<T: Iterator<Item=$A>> AdditiveIterator<$A> for T { #[inline] fn sum(self) -> $A { @@ -1125,7 +1125,7 @@ impl_additive! { f32, 0.0 } impl_additive! { f64, 0.0 } /// A trait for iterators over elements which can be multiplied together. -#[experimental = "needs to be re-evaluated as part of numerics reform"] +#[unstable = "needs to be re-evaluated as part of numerics reform"] pub trait MultiplicativeIterator<A> { /// Iterates over the entire iterator, multiplying all the elements /// @@ -1146,7 +1146,7 @@ pub trait MultiplicativeIterator<A> { macro_rules! impl_multiplicative { ($A:ty, $init:expr) => { - #[experimental = "trait is experimental"] + #[unstable = "trait is experimental"] impl<T: Iterator<Item=$A>> MultiplicativeIterator<$A> for T { #[inline] fn product(self) -> $A { @@ -1287,7 +1287,7 @@ impl<I> Iterator for Cycle<I> where I: Clone + Iterator { } } -#[experimental = "trait is experimental"] +#[unstable = "trait is experimental"] impl<I> RandomAccessIterator for Cycle<I> where I: Clone + RandomAccessIterator, { @@ -1372,7 +1372,7 @@ impl<T, A, B> DoubleEndedIterator for Chain<A, B> where } } -#[experimental = "trait is experimental"] +#[unstable = "trait is experimental"] impl<T, A, B> RandomAccessIterator for Chain<A, B> where A: RandomAccessIterator<Item=T>, B: RandomAccessIterator<Item=T>, @@ -1464,7 +1464,7 @@ impl<T, U, A, B> DoubleEndedIterator for Zip<A, B> where } } -#[experimental = "trait is experimental"] +#[unstable = "trait is experimental"] impl<T, U, A, B> RandomAccessIterator for Zip<A, B> where A: RandomAccessIterator<Item=T>, B: RandomAccessIterator<Item=U>, @@ -1546,7 +1546,7 @@ impl<A, B, I, F> DoubleEndedIterator for Map<A, B, I, F> where } } -#[experimental = "trait is experimental"] +#[unstable = "trait is experimental"] impl<A, B, I, F> RandomAccessIterator for Map<A, B, I, F> where I: RandomAccessIterator<Item=A>, F: FnMut(A) -> B, @@ -1735,7 +1735,7 @@ impl<I> DoubleEndedIterator for Enumerate<I> where } } -#[experimental = "trait is experimental"] +#[unstable = "trait is experimental"] impl<I> RandomAccessIterator for Enumerate<I> where I: RandomAccessIterator { #[inline] fn indexable(&self) -> uint { @@ -1961,7 +1961,7 @@ impl<I> Iterator for Skip<I> where I: Iterator { } } -#[experimental = "trait is experimental"] +#[unstable = "trait is experimental"] impl<I> RandomAccessIterator for Skip<I> where I: RandomAccessIterator{ #[inline] fn indexable(&self) -> uint { @@ -2016,7 +2016,7 @@ impl<I> Iterator for Take<I> where I: Iterator{ } } -#[experimental = "trait is experimental"] +#[unstable = "trait is experimental"] impl<I> RandomAccessIterator for Take<I> where I: RandomAccessIterator{ #[inline] fn indexable(&self) -> uint { @@ -2229,7 +2229,7 @@ impl<I> DoubleEndedIterator for Fuse<I> where I: DoubleEndedIterator { } // Allow RandomAccessIterators to be fused without affecting random-access behavior -#[experimental = "trait is experimental"] +#[unstable = "trait is experimental"] impl<I> RandomAccessIterator for Fuse<I> where I: RandomAccessIterator { #[inline] fn indexable(&self) -> uint { @@ -2246,7 +2246,7 @@ impl<I> Fuse<I> { /// Resets the fuse such that the next call to .next() or .next_back() will /// call the underlying iterator again even if it previously returned None. #[inline] - #[experimental = "seems marginal"] + #[unstable = "seems marginal"] pub fn reset_fuse(&mut self) { self.done = false } @@ -2315,7 +2315,7 @@ impl<A, I, F> DoubleEndedIterator for Inspect<A, I, F> where } } -#[experimental = "trait is experimental"] +#[unstable = "trait is experimental"] impl<A, I, F> RandomAccessIterator for Inspect<A, I, F> where I: RandomAccessIterator<Item=A>, F: FnMut(&A), @@ -2364,7 +2364,7 @@ impl<A, I, F> RandomAccessIterator for Inspect<A, I, F> where /// println!("{}", i); /// } /// ``` -#[experimental] +#[unstable] pub struct Unfold<A, St, F> where F: FnMut(&mut St) -> Option<A> { f: F, /// Internal state that will be passed to the closure on the next iteration @@ -2385,7 +2385,7 @@ impl<A, St, F> Clone for Unfold<A, St, F> where } } -#[experimental] +#[unstable] impl<A, St, F> Unfold<A, St, F> where F: FnMut(&mut St) -> Option<A> { /// Creates a new iterator with the specified closure as the "iterator /// function" and an initial state to eventually pass to the closure @@ -2778,7 +2778,7 @@ impl<A: Clone> DoubleEndedIterator for Repeat<A> { fn next_back(&mut self) -> Option<A> { self.idx(0) } } -#[experimental = "trait is experimental"] +#[unstable = "trait is experimental"] impl<A: Clone> RandomAccessIterator for Repeat<A> { #[inline] fn indexable(&self) -> uint { uint::MAX } @@ -2790,12 +2790,12 @@ type IterateState<T, F> = (F, Option<T>, bool); /// An iterator that repeatedly applies a given function, starting /// from a given seed value. -#[experimental] +#[unstable] pub type Iterate<T, F> = Unfold<T, IterateState<T, F>, fn(&mut IterateState<T, F>) -> Option<T>>; /// Create a new iterator that produces an infinite sequence of /// repeated applications of the given function `f`. -#[experimental] +#[unstable] pub fn iterate<T, F>(seed: T, f: F) -> Iterate<T, F> where T: Clone, F: FnMut(T) -> T, diff --git a/src/libcore/lib.rs b/src/libcore/lib.rs index af5aba53bf4..28f8cf588be 100644 --- a/src/libcore/lib.rs +++ b/src/libcore/lib.rs @@ -48,7 +48,7 @@ // separate crate, libcoretest, to avoid bizarre issues. #![crate_name = "core"] -#![experimental] +#![unstable] #![staged_api] #![crate_type = "rlib"] #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png", @@ -59,9 +59,10 @@ #![no_std] #![allow(unknown_features, raw_pointer_derive)] #![cfg_attr(stage0, allow(unused_attributes))] -#![feature(intrinsics, lang_items)] +#![allow(unknown_features)] #![feature(intrinsics, lang_items)] #![feature(simd, unsafe_destructor, slicing_syntax)] #![feature(unboxed_closures)] +#![allow(unknown_features)] #![feature(int_uint)] #![deny(missing_docs)] #[macro_use] diff --git a/src/libcore/macros.rs b/src/libcore/macros.rs index bfe88fff22f..f6415518864 100644 --- a/src/libcore/macros.rs +++ b/src/libcore/macros.rs @@ -15,7 +15,7 @@ macro_rules! panic { panic!("explicit panic") ); ($msg:expr) => ({ - static _MSG_FILE_LINE: (&'static str, &'static str, uint) = ($msg, file!(), line!()); + static _MSG_FILE_LINE: (&'static str, &'static str, usize) = ($msg, file!(), line!()); ::core::panicking::panic(&_MSG_FILE_LINE) }); ($fmt:expr, $($arg:tt)*) => ({ @@ -23,7 +23,7 @@ macro_rules! panic { // 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!()); + static _FILE_LINE: (&'static str, usize) = (file!(), line!()); ::core::panicking::panic_fmt(format_args!($fmt, $($arg)*), &_FILE_LINE) }); } diff --git a/src/libcore/nonzero.rs b/src/libcore/nonzero.rs index 087404da624..abaf2529323 100644 --- a/src/libcore/nonzero.rs +++ b/src/libcore/nonzero.rs @@ -32,7 +32,7 @@ unsafe impl Zeroable for u64 {} /// NULL or 0 that might allow certain optimizations. #[lang="non_zero"] #[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Show)] -#[experimental] +#[unstable] pub struct NonZero<T: Zeroable>(T); impl<T: Zeroable> NonZero<T> { diff --git a/src/libcore/num/mod.rs b/src/libcore/num/mod.rs index 91fed8a31bd..57415f4331d 100644 --- a/src/libcore/num/mod.rs +++ b/src/libcore/num/mod.rs @@ -726,7 +726,7 @@ impl UnsignedInt for u32 {} impl UnsignedInt for u64 {} /// A generic trait for converting a value to a number. -#[experimental = "trait is likely to be removed"] +#[unstable = "trait is likely to be removed"] pub trait ToPrimitive { /// Converts the value of `self` to an `int`. #[inline] @@ -991,7 +991,7 @@ impl_to_primitive_float! { f32 } impl_to_primitive_float! { f64 } /// A generic trait for converting a number to a value. -#[experimental = "trait is likely to be removed"] +#[unstable = "trait is likely to be removed"] pub trait FromPrimitive : ::marker::Sized { /// Convert an `int` to return an optional value of this type. If the /// value cannot be represented by this value, the `None` is returned. @@ -1073,73 +1073,73 @@ pub trait FromPrimitive : ::marker::Sized { } /// A utility function that just calls `FromPrimitive::from_int`. -#[experimental = "likely to be removed"] +#[unstable = "likely to be removed"] pub fn from_int<A: FromPrimitive>(n: int) -> Option<A> { FromPrimitive::from_int(n) } /// A utility function that just calls `FromPrimitive::from_i8`. -#[experimental = "likely to be removed"] +#[unstable = "likely to be removed"] pub fn from_i8<A: FromPrimitive>(n: i8) -> Option<A> { FromPrimitive::from_i8(n) } /// A utility function that just calls `FromPrimitive::from_i16`. -#[experimental = "likely to be removed"] +#[unstable = "likely to be removed"] pub fn from_i16<A: FromPrimitive>(n: i16) -> Option<A> { FromPrimitive::from_i16(n) } /// A utility function that just calls `FromPrimitive::from_i32`. -#[experimental = "likely to be removed"] +#[unstable = "likely to be removed"] pub fn from_i32<A: FromPrimitive>(n: i32) -> Option<A> { FromPrimitive::from_i32(n) } /// A utility function that just calls `FromPrimitive::from_i64`. -#[experimental = "likely to be removed"] +#[unstable = "likely to be removed"] pub fn from_i64<A: FromPrimitive>(n: i64) -> Option<A> { FromPrimitive::from_i64(n) } /// A utility function that just calls `FromPrimitive::from_uint`. -#[experimental = "likely to be removed"] +#[unstable = "likely to be removed"] pub fn from_uint<A: FromPrimitive>(n: uint) -> Option<A> { FromPrimitive::from_uint(n) } /// A utility function that just calls `FromPrimitive::from_u8`. -#[experimental = "likely to be removed"] +#[unstable = "likely to be removed"] pub fn from_u8<A: FromPrimitive>(n: u8) -> Option<A> { FromPrimitive::from_u8(n) } /// A utility function that just calls `FromPrimitive::from_u16`. -#[experimental = "likely to be removed"] +#[unstable = "likely to be removed"] pub fn from_u16<A: FromPrimitive>(n: u16) -> Option<A> { FromPrimitive::from_u16(n) } /// A utility function that just calls `FromPrimitive::from_u32`. -#[experimental = "likely to be removed"] +#[unstable = "likely to be removed"] pub fn from_u32<A: FromPrimitive>(n: u32) -> Option<A> { FromPrimitive::from_u32(n) } /// A utility function that just calls `FromPrimitive::from_u64`. -#[experimental = "likely to be removed"] +#[unstable = "likely to be removed"] pub fn from_u64<A: FromPrimitive>(n: u64) -> Option<A> { FromPrimitive::from_u64(n) } /// A utility function that just calls `FromPrimitive::from_f32`. -#[experimental = "likely to be removed"] +#[unstable = "likely to be removed"] pub fn from_f32<A: FromPrimitive>(n: f32) -> Option<A> { FromPrimitive::from_f32(n) } /// A utility function that just calls `FromPrimitive::from_f64`. -#[experimental = "likely to be removed"] +#[unstable = "likely to be removed"] pub fn from_f64<A: FromPrimitive>(n: f64) -> Option<A> { FromPrimitive::from_f64(n) } @@ -1190,13 +1190,13 @@ impl_from_primitive! { f64, to_f64 } /// ``` /// #[inline] -#[experimental = "likely to be removed"] +#[unstable = "likely to be removed"] pub fn cast<T: NumCast,U: NumCast>(n: T) -> Option<U> { NumCast::from(n) } /// An interface for casting between machine scalars. -#[experimental = "trait is likely to be removed"] +#[unstable = "trait is likely to be removed"] pub trait NumCast: ToPrimitive { /// Creates a number from another value that can be converted into a primitive via the /// `ToPrimitive` trait. @@ -1394,20 +1394,20 @@ pub trait Float } /// A generic trait for converting a string with a radix (base) to a value -#[experimental = "might need to return Result"] +#[unstable = "might need to return Result"] pub trait FromStrRadix { fn from_str_radix(str: &str, radix: uint) -> Option<Self>; } /// A utility function that just calls FromStrRadix::from_str_radix. -#[experimental = "might need to return Result"] +#[unstable = "might need to return Result"] pub fn from_str_radix<T: FromStrRadix>(str: &str, radix: uint) -> Option<T> { FromStrRadix::from_str_radix(str, radix) } macro_rules! from_str_radix_float_impl { ($T:ty) => { - #[experimental = "might need to return Result"] + #[unstable = "might need to return Result"] impl FromStr for $T { /// Convert a string in base 10 to a float. /// Accepts an optional decimal exponent. @@ -1440,7 +1440,7 @@ macro_rules! from_str_radix_float_impl { } } - #[experimental = "might need to return Result"] + #[unstable = "might need to return Result"] impl FromStrRadix for $T { /// Convert a string in a given base to a float. /// @@ -1604,7 +1604,7 @@ from_str_radix_float_impl! { f64 } macro_rules! from_str_radix_int_impl { ($T:ty) => { - #[experimental = "might need to return Result"] + #[unstable = "might need to return Result"] impl FromStr for $T { #[inline] fn from_str(src: &str) -> Option<$T> { @@ -1612,7 +1612,7 @@ macro_rules! from_str_radix_int_impl { } } - #[experimental = "might need to return Result"] + #[unstable = "might need to return Result"] impl FromStrRadix for $T { fn from_str_radix(src: &str, radix: uint) -> Option<$T> { assert!(radix >= 2 && radix <= 36, diff --git a/src/libcore/option.rs b/src/libcore/option.rs index deee67b6d2f..41eecb4649d 100644 --- a/src/libcore/option.rs +++ b/src/libcore/option.rs @@ -477,7 +477,7 @@ impl<T> Option<T> { /// assert_eq!(x.ok_or(0i), Err(0i)); /// ``` #[inline] - #[experimental] + #[unstable] pub fn ok_or<E>(self, err: E) -> Result<T, E> { match self { Some(v) => Ok(v), @@ -498,7 +498,7 @@ impl<T> Option<T> { /// assert_eq!(x.ok_or_else(|| 0i), Err(0i)); /// ``` #[inline] - #[experimental] + #[unstable] pub fn ok_or_else<E, F: FnOnce() -> E>(self, err: F) -> Result<T, E> { match self { Some(v) => Ok(v), diff --git a/src/libcore/ptr.rs b/src/libcore/ptr.rs index a17cd410303..ab1e69f0060 100644 --- a/src/libcore/ptr.rs +++ b/src/libcore/ptr.rs @@ -106,7 +106,7 @@ pub use intrinsics::copy_nonoverlapping_memory; #[unstable] pub use intrinsics::copy_memory; -#[experimental = "uncertain about naming and semantics"] +#[unstable = "uncertain about naming and semantics"] pub use intrinsics::set_memory; diff --git a/src/libcore/raw.rs b/src/libcore/raw.rs index 1ad6d43f76f..13a387c7cb0 100644 --- a/src/libcore/raw.rs +++ b/src/libcore/raw.rs @@ -9,7 +9,7 @@ // except according to those terms. #![allow(missing_docs)] -#![experimental] +#![unstable] //! Contains struct definitions for the layout of compiler built-in types. //! diff --git a/src/libcore/result.rs b/src/libcore/result.rs index 7868ec67c8a..f7421203336 100644 --- a/src/libcore/result.rs +++ b/src/libcore/result.rs @@ -953,7 +953,7 @@ impl<A, E, V: FromIterator<A>> FromIterator<Result<A, E>> for Result<V, E> { /// If an `Err` is encountered, it is immediately returned. /// Otherwise, the folded value is returned. #[inline] -#[experimental] +#[unstable] pub fn fold<T, V, E, diff --git a/src/libcore/simd.rs b/src/libcore/simd.rs index 1f9aebb91be..b73910d7c06 100644 --- a/src/libcore/simd.rs +++ b/src/libcore/simd.rs @@ -19,7 +19,7 @@ //! provided beyond this module. //! //! ```rust -//! #[allow(experimental)]; +//! #[allow(unstable)]; //! //! fn main() { //! use std::simd::f32x4; @@ -37,7 +37,7 @@ #![allow(non_camel_case_types)] #![allow(missing_docs)] -#[experimental] +#[unstable] #[simd] #[derive(Copy, Show)] #[repr(C)] @@ -46,26 +46,26 @@ pub struct i8x16(pub i8, pub i8, pub i8, pub i8, pub i8, pub i8, pub i8, pub i8, pub i8, pub i8, pub i8, pub i8); -#[experimental] +#[unstable] #[simd] #[derive(Copy, Show)] #[repr(C)] pub struct i16x8(pub i16, pub i16, pub i16, pub i16, pub i16, pub i16, pub i16, pub i16); -#[experimental] +#[unstable] #[simd] #[derive(Copy, Show)] #[repr(C)] pub struct i32x4(pub i32, pub i32, pub i32, pub i32); -#[experimental] +#[unstable] #[simd] #[derive(Copy, Show)] #[repr(C)] pub struct i64x2(pub i64, pub i64); -#[experimental] +#[unstable] #[simd] #[derive(Copy, Show)] #[repr(C)] @@ -74,32 +74,32 @@ pub struct u8x16(pub u8, pub u8, pub u8, pub u8, pub u8, pub u8, pub u8, pub u8, pub u8, pub u8, pub u8, pub u8); -#[experimental] +#[unstable] #[simd] #[derive(Copy, Show)] #[repr(C)] pub struct u16x8(pub u16, pub u16, pub u16, pub u16, pub u16, pub u16, pub u16, pub u16); -#[experimental] +#[unstable] #[simd] #[derive(Copy, Show)] #[repr(C)] pub struct u32x4(pub u32, pub u32, pub u32, pub u32); -#[experimental] +#[unstable] #[simd] #[derive(Copy, Show)] #[repr(C)] pub struct u64x2(pub u64, pub u64); -#[experimental] +#[unstable] #[simd] #[derive(Copy, Show)] #[repr(C)] pub struct f32x4(pub f32, pub f32, pub f32, pub f32); -#[experimental] +#[unstable] #[simd] #[derive(Copy, Show)] #[repr(C)] diff --git a/src/libcore/slice.rs b/src/libcore/slice.rs index 6c62bfda1fe..7e47c5257a3 100644 --- a/src/libcore/slice.rs +++ b/src/libcore/slice.rs @@ -457,7 +457,7 @@ impl<T> SliceExt for [T] { self.binary_search_by(|p| p.cmp(x)) } - #[experimental] + #[unstable] fn next_permutation(&mut self) -> bool where T: Ord { // These cases only have 1 permutation each, so we can't do anything. if self.len() < 2 { return false; } @@ -488,7 +488,7 @@ impl<T> SliceExt for [T] { true } - #[experimental] + #[unstable] fn prev_permutation(&mut self) -> bool where T: Ord { // These cases only have 1 permutation each, so we can't do anything. if self.len() < 2 { return false; } @@ -630,25 +630,25 @@ impl<T> ops::IndexMut<ops::FullRange> for [T] { //////////////////////////////////////////////////////////////////////////////// /// Data that is viewable as a slice. -#[experimental = "will be replaced by slice syntax"] +#[unstable = "will be replaced by slice syntax"] pub trait AsSlice<T> { /// Work with `self` as a slice. fn as_slice<'a>(&'a self) -> &'a [T]; } -#[experimental = "trait is experimental"] +#[unstable = "trait is experimental"] impl<T> AsSlice<T> for [T] { #[inline(always)] fn as_slice<'a>(&'a self) -> &'a [T] { self } } -#[experimental = "trait is experimental"] +#[unstable = "trait is experimental"] impl<'a, T, U: ?Sized + AsSlice<T>> AsSlice<T> for &'a U { #[inline(always)] fn as_slice(&self) -> &[T] { AsSlice::as_slice(*self) } } -#[experimental = "trait is experimental"] +#[unstable = "trait is experimental"] impl<'a, T, U: ?Sized + AsSlice<T>> AsSlice<T> for &'a mut U { #[inline(always)] fn as_slice(&self) -> &[T] { AsSlice::as_slice(*self) } @@ -754,7 +754,7 @@ pub struct Iter<'a, T: 'a> { marker: marker::ContravariantLifetime<'a> } -#[experimental] +#[unstable] impl<'a, T> ops::Index<ops::Range<uint>> for Iter<'a, T> { type Output = [T]; #[inline] @@ -763,7 +763,7 @@ impl<'a, T> ops::Index<ops::Range<uint>> for Iter<'a, T> { } } -#[experimental] +#[unstable] impl<'a, T> ops::Index<ops::RangeTo<uint>> for Iter<'a, T> { type Output = [T]; #[inline] @@ -772,7 +772,7 @@ impl<'a, T> ops::Index<ops::RangeTo<uint>> for Iter<'a, T> { } } -#[experimental] +#[unstable] impl<'a, T> ops::Index<ops::RangeFrom<uint>> for Iter<'a, T> { type Output = [T]; #[inline] @@ -781,7 +781,7 @@ impl<'a, T> ops::Index<ops::RangeFrom<uint>> for Iter<'a, T> { } } -#[experimental] +#[unstable] impl<'a, T> ops::Index<ops::FullRange> for Iter<'a, T> { type Output = [T]; #[inline] @@ -795,7 +795,7 @@ impl<'a, T> Iter<'a, T> { /// /// This has the same lifetime as the original slice, and so the /// iterator can continue to be used while this exists. - #[experimental] + #[unstable] pub fn as_slice(&self) -> &'a [T] { make_slice!(T => &'a [T]: self.ptr, self.end) } @@ -813,7 +813,7 @@ impl<'a, T> Clone for Iter<'a, T> { fn clone(&self) -> Iter<'a, T> { *self } } -#[experimental = "trait is experimental"] +#[unstable = "trait is experimental"] impl<'a, T> RandomAccessIterator for Iter<'a, T> { #[inline] fn indexable(&self) -> uint { @@ -847,7 +847,7 @@ pub struct IterMut<'a, T: 'a> { } -#[experimental] +#[unstable] impl<'a, T> ops::Index<ops::Range<uint>> for IterMut<'a, T> { type Output = [T]; #[inline] @@ -855,7 +855,7 @@ impl<'a, T> ops::Index<ops::Range<uint>> for IterMut<'a, T> { self.index(&ops::FullRange).index(index) } } -#[experimental] +#[unstable] impl<'a, T> ops::Index<ops::RangeTo<uint>> for IterMut<'a, T> { type Output = [T]; #[inline] @@ -863,7 +863,7 @@ impl<'a, T> ops::Index<ops::RangeTo<uint>> for IterMut<'a, T> { self.index(&ops::FullRange).index(index) } } -#[experimental] +#[unstable] impl<'a, T> ops::Index<ops::RangeFrom<uint>> for IterMut<'a, T> { type Output = [T]; #[inline] @@ -871,7 +871,7 @@ impl<'a, T> ops::Index<ops::RangeFrom<uint>> for IterMut<'a, T> { self.index(&ops::FullRange).index(index) } } -#[experimental] +#[unstable] impl<'a, T> ops::Index<ops::FullRange> for IterMut<'a, T> { type Output = [T]; #[inline] @@ -880,7 +880,7 @@ impl<'a, T> ops::Index<ops::FullRange> for IterMut<'a, T> { } } -#[experimental] +#[unstable] impl<'a, T> ops::IndexMut<ops::Range<uint>> for IterMut<'a, T> { type Output = [T]; #[inline] @@ -888,7 +888,7 @@ impl<'a, T> ops::IndexMut<ops::Range<uint>> for IterMut<'a, T> { self.index_mut(&ops::FullRange).index_mut(index) } } -#[experimental] +#[unstable] impl<'a, T> ops::IndexMut<ops::RangeTo<uint>> for IterMut<'a, T> { type Output = [T]; #[inline] @@ -896,7 +896,7 @@ impl<'a, T> ops::IndexMut<ops::RangeTo<uint>> for IterMut<'a, T> { self.index_mut(&ops::FullRange).index_mut(index) } } -#[experimental] +#[unstable] impl<'a, T> ops::IndexMut<ops::RangeFrom<uint>> for IterMut<'a, T> { type Output = [T]; #[inline] @@ -904,7 +904,7 @@ impl<'a, T> ops::IndexMut<ops::RangeFrom<uint>> for IterMut<'a, T> { self.index_mut(&ops::FullRange).index_mut(index) } } -#[experimental] +#[unstable] impl<'a, T> ops::IndexMut<ops::FullRange> for IterMut<'a, T> { type Output = [T]; #[inline] @@ -921,7 +921,7 @@ impl<'a, T> IterMut<'a, T> { /// to consume the iterator. Consider using the `Slice` and /// `SliceMut` implementations for obtaining slices with more /// restricted lifetimes that do not consume the iterator. - #[experimental] + #[unstable] pub fn into_slice(self) -> &'a mut [T] { make_slice!(T => &'a mut [T]: self.ptr, self.end) } @@ -1269,7 +1269,7 @@ impl<'a, T> DoubleEndedIterator for Chunks<'a, T> { } } -#[experimental = "trait is experimental"] +#[unstable = "trait is experimental"] impl<'a, T> RandomAccessIterator for Chunks<'a, T> { #[inline] fn indexable(&self) -> uint { @@ -1417,7 +1417,7 @@ pub unsafe fn from_raw_mut_buf<'a, T>(p: &'a *mut T, len: uint) -> &'a mut [T] { // /// Operations on `[u8]`. -#[experimental = "needs review"] +#[unstable = "needs review"] pub mod bytes { use ptr; use slice::SliceExt; @@ -1430,7 +1430,7 @@ pub mod bytes { impl MutableByteVector for [u8] { #[inline] - #[allow(experimental)] + #[allow(unstable)] fn set_memory(&mut self, value: u8) { unsafe { ptr::set_memory(self.as_mut_ptr(), value, self.len()) }; } @@ -1506,7 +1506,7 @@ impl<T: PartialOrd> PartialOrd for [T] { } /// Extension methods for slices containing integers. -#[experimental] +#[unstable] pub trait IntSliceExt<U, S> { /// Converts the slice to an immutable slice of unsigned integers with the same width. fn as_unsigned<'a>(&'a self) -> &'a [U]; @@ -1521,7 +1521,7 @@ pub trait IntSliceExt<U, S> { macro_rules! impl_int_slice { ($u:ty, $s:ty, $t:ty) => { - #[experimental] + #[unstable] impl IntSliceExt<$u, $s> for [$t] { #[inline] fn as_unsigned(&self) -> &[$u] { unsafe { transmute(self) } } diff --git a/src/libcoretest/cell.rs b/src/libcoretest/cell.rs index 86f34ecd15e..a808593ffbd 100644 --- a/src/libcoretest/cell.rs +++ b/src/libcoretest/cell.rs @@ -114,7 +114,7 @@ fn discard_doesnt_unborrow() { } #[test] -#[allow(experimental)] +#[allow(unstable)] fn clone_ref_updates_flag() { let x = RefCell::new(0i); { diff --git a/src/libcoretest/lib.rs b/src/libcoretest/lib.rs index c12981b7d24..0d371dbe153 100644 --- a/src/libcoretest/lib.rs +++ b/src/libcoretest/lib.rs @@ -11,6 +11,7 @@ #![feature(unsafe_destructor, slicing_syntax)] #![feature(unboxed_closures)] #![feature(box_syntax)] +#![allow(unknown_features)] #![feature(int_uint)] extern crate core; extern crate test; diff --git a/src/libflate/lib.rs b/src/libflate/lib.rs index 1896bdd182a..fb6c98515f7 100644 --- a/src/libflate/lib.rs +++ b/src/libflate/lib.rs @@ -15,8 +15,9 @@ //! [mz]: https://code.google.com/p/miniz/ #![crate_name = "flate"] -#![experimental] +#![unstable] #![staged_api] +#![allow(unknown_features)] #![feature(int_uint)] #![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 02eea5d024c..70ad8d28d27 100644 --- a/src/libfmt_macros/lib.rs +++ b/src/libfmt_macros/lib.rs @@ -15,7 +15,7 @@ //! generated instead. #![crate_name = "fmt_macros"] -#![experimental] +#![unstable] #![staged_api] #![crate_type = "rlib"] #![crate_type = "dylib"] @@ -25,6 +25,7 @@ html_playground_url = "http://play.rust-lang.org/")] #![feature(slicing_syntax)] +#![allow(unknown_features)] #![feature(int_uint)] pub use self::Piece::*; pub use self::Position::*; diff --git a/src/libgetopts/lib.rs b/src/libgetopts/lib.rs index 1d6c99542b5..470ef6e7e57 100644 --- a/src/libgetopts/lib.rs +++ b/src/libgetopts/lib.rs @@ -78,7 +78,7 @@ //! ``` #![crate_name = "getopts"] -#![experimental = "use the crates.io `getopts` library instead"] +#![unstable = "use the crates.io `getopts` library instead"] #![staged_api] #![crate_type = "rlib"] #![crate_type = "dylib"] @@ -87,6 +87,7 @@ html_root_url = "http://doc.rust-lang.org/nightly/", html_playground_url = "http://play.rust-lang.org/")] #![feature(slicing_syntax)] +#![allow(unknown_features)] #![feature(int_uint)] #![deny(missing_docs)] #[cfg(test)] #[macro_use] extern crate log; diff --git a/src/libgraphviz/lib.rs b/src/libgraphviz/lib.rs index 9d2318e253e..b48fe2e4278 100644 --- a/src/libgraphviz/lib.rs +++ b/src/libgraphviz/lib.rs @@ -265,7 +265,7 @@ //! * [DOT language](http://www.graphviz.org/doc/info/lang.html) #![crate_name = "graphviz"] -#![experimental] +#![unstable] #![staged_api] #![crate_type = "rlib"] #![crate_type = "dylib"] @@ -273,6 +273,7 @@ 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(int_uint)] use self::LabelText::*; diff --git a/src/liblibc/lib.rs b/src/liblibc/lib.rs index c39fd074387..34964bbae51 100644 --- a/src/liblibc/lib.rs +++ b/src/liblibc/lib.rs @@ -10,8 +10,9 @@ #![crate_name = "libc"] #![crate_type = "rlib"] -#![cfg_attr(not(feature = "cargo-build"), experimental)] +#![cfg_attr(not(feature = "cargo-build"), unstable)] #![cfg_attr(not(feature = "cargo-build"), staged_api)] +#![allow(unknown_features)] #![feature(int_uint)] #![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", diff --git a/src/liblog/lib.rs b/src/liblog/lib.rs index 0d5f6b65827..a166dc369cb 100644 --- a/src/liblog/lib.rs +++ b/src/liblog/lib.rs @@ -156,7 +156,7 @@ //! if logging is disabled, none of the components of the log will be executed. #![crate_name = "log"] -#![experimental = "use the crates.io `log` library instead"] +#![unstable = "use the crates.io `log` library instead"] #![staged_api] #![crate_type = "rlib"] #![crate_type = "dylib"] @@ -168,6 +168,7 @@ #![allow(unknown_features)] #![feature(slicing_syntax)] #![feature(box_syntax)] +#![allow(unknown_features)] #![feature(int_uint)] #![deny(missing_docs)] extern crate regex; diff --git a/src/librand/distributions/mod.rs b/src/librand/distributions/mod.rs index 2fdba8a6c4f..e248de10df4 100644 --- a/src/librand/distributions/mod.rs +++ b/src/librand/distributions/mod.rs @@ -17,7 +17,7 @@ //! internally. The `IndependentSample` trait is for generating values //! that do not need to record state. -#![experimental] +#![unstable] use core::prelude::*; use core::num::{Float, Int}; diff --git a/src/librand/lib.rs b/src/librand/lib.rs index 497e339b316..4d605253ab0 100644 --- a/src/librand/lib.rs +++ b/src/librand/lib.rs @@ -22,9 +22,9 @@ 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(int_uint)] #![no_std] -#![experimental] +#![unstable] #![staged_api] #[macro_use] diff --git a/src/librbml/lib.rs b/src/librbml/lib.rs index da803aa5011..6a7062a419e 100644 --- a/src/librbml/lib.rs +++ b/src/librbml/lib.rs @@ -16,7 +16,7 @@ //! http://www.matroska.org/technical/specs/rfc/index.html #![crate_name = "rbml"] -#![experimental] +#![unstable] #![staged_api] #![crate_type = "rlib"] #![crate_type = "dylib"] @@ -26,6 +26,7 @@ html_playground_url = "http://play.rust-lang.org/")] #![allow(unknown_features)] #![feature(slicing_syntax)] +#![allow(unknown_features)] #![feature(int_uint)] extern crate serialize; #[macro_use] extern crate log; diff --git a/src/libregex/lib.rs b/src/libregex/lib.rs index d19ce3b460a..45f42336ceb 100644 --- a/src/libregex/lib.rs +++ b/src/libregex/lib.rs @@ -16,7 +16,7 @@ #![crate_name = "regex"] #![crate_type = "rlib"] #![crate_type = "dylib"] -#![experimental = "use the crates.io `regex` library instead"] +#![unstable = "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", @@ -26,6 +26,7 @@ #![allow(unknown_features)] #![feature(slicing_syntax)] #![feature(box_syntax)] +#![allow(unknown_features)] #![feature(int_uint)] #![deny(missing_docs)] #[cfg(test)] diff --git a/src/libregex/re.rs b/src/libregex/re.rs index 16dd32b6be2..abc51d62404 100644 --- a/src/libregex/re.rs +++ b/src/libregex/re.rs @@ -255,7 +255,7 @@ impl Regex { } #[doc(hidden)] - #[experimental] + #[unstable] pub fn names_iter<'a>(&'a self) -> NamesIter<'a> { match *self { Native(ref n) => NamesIterNative(n.names.iter()), @@ -410,7 +410,7 @@ pub struct Captures<'t> { } impl<'t> Captures<'t> { - #[allow(experimental)] + #[allow(unstable)] fn new(re: &Regex, search: &'t str, locs: CaptureLocs) -> Option<Captures<'t>> { if !has_match(&locs) { diff --git a/src/librustc/lib.rs b/src/librustc/lib.rs index e0143917a7c..fb7c5296d02 100644 --- a/src/librustc/lib.rs +++ b/src/librustc/lib.rs @@ -15,7 +15,7 @@ //! This API is completely unstable and subject to change. #![crate_name = "rustc"] -#![experimental] +#![unstable] #![staged_api] #![crate_type = "dylib"] #![crate_type = "rlib"] @@ -27,8 +27,8 @@ #![feature(quote)] #![feature(slicing_syntax, unsafe_destructor)] #![feature(box_syntax)] +#![allow(unknown_features)] #![feature(int_uint)] #![feature(rustc_diagnostic_macros)] -#![feature(old_impl_check)] extern crate arena; extern crate flate; diff --git a/src/librustc/lint/builtin.rs b/src/librustc/lint/builtin.rs index 7d893f3a106..620b8f277dd 100644 --- a/src/librustc/lint/builtin.rs +++ b/src/librustc/lint/builtin.rs @@ -216,7 +216,7 @@ impl LintPass for TypeLimits { match lit.node { ast::LitInt(v, ast::SignedIntLit(_, ast::Plus)) | ast::LitInt(v, ast::UnsuffixedIntLit(ast::Plus)) => { - let int_type = if t == ast::TyIs { + let int_type = if let ast::TyIs(_) = t { cx.sess().target.int_type } else { t }; let (min, max) = int_ty_range(int_type); @@ -233,7 +233,7 @@ impl LintPass for TypeLimits { }; }, ty::ty_uint(t) => { - let uint_type = if t == ast::TyUs { + let uint_type = if let ast::TyUs(_) = t { cx.sess().target.uint_type } else { t }; let (min, max) = uint_ty_range(uint_type); @@ -296,7 +296,7 @@ impl LintPass for TypeLimits { // warnings are consistent between 32- and 64-bit platforms fn int_ty_range(int_ty: ast::IntTy) -> (i64, i64) { match int_ty { - ast::TyIs=> (i64::MIN, i64::MAX), + ast::TyIs(_) => (i64::MIN, i64::MAX), ast::TyI8 => (i8::MIN as i64, i8::MAX as i64), ast::TyI16 => (i16::MIN as i64, i16::MAX as i64), ast::TyI32 => (i32::MIN as i64, i32::MAX as i64), @@ -306,7 +306,7 @@ impl LintPass for TypeLimits { fn uint_ty_range(uint_ty: ast::UintTy) -> (u64, u64) { match uint_ty { - ast::TyUs=> (u64::MIN, u64::MAX), + ast::TyUs(_) => (u64::MIN, u64::MAX), ast::TyU8 => (u8::MIN as u64, u8::MAX as u64), ast::TyU16 => (u16::MIN as u64, u16::MAX as u64), ast::TyU32 => (u32::MIN as u64, u32::MAX as u64), @@ -323,7 +323,7 @@ impl LintPass for TypeLimits { fn int_ty_bits(int_ty: ast::IntTy, target_int_ty: ast::IntTy) -> u64 { match int_ty { - ast::TyIs=> int_ty_bits(target_int_ty, target_int_ty), + ast::TyIs(_) => int_ty_bits(target_int_ty, target_int_ty), ast::TyI8 => i8::BITS as u64, ast::TyI16 => i16::BITS as u64, ast::TyI32 => i32::BITS as u64, @@ -333,7 +333,7 @@ impl LintPass for TypeLimits { fn uint_ty_bits(uint_ty: ast::UintTy, target_uint_ty: ast::UintTy) -> u64 { match uint_ty { - ast::TyUs=> uint_ty_bits(target_uint_ty, target_uint_ty), + ast::TyUs(_) => uint_ty_bits(target_uint_ty, target_uint_ty), ast::TyU8 => u8::BITS as u64, ast::TyU16 => u16::BITS as u64, ast::TyU32 => u32::BITS as u64, @@ -404,12 +404,12 @@ struct ImproperCTypesVisitor<'a, 'tcx: 'a> { impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> { fn check_def(&mut self, sp: Span, ty_id: ast::NodeId, path_id: ast::NodeId) { match self.cx.tcx.def_map.borrow()[path_id].clone() { - def::DefPrimTy(ast::TyInt(ast::TyIs)) => { + def::DefPrimTy(ast::TyInt(ast::TyIs(_))) => { self.cx.span_lint(IMPROPER_CTYPES, sp, "found rust type `isize` in foreign module, while \ libc::c_int or libc::c_long should be used"); } - def::DefPrimTy(ast::TyUint(ast::TyUs)) => { + def::DefPrimTy(ast::TyUint(ast::TyUs(_))) => { self.cx.span_lint(IMPROPER_CTYPES, sp, "found rust type `usize` in foreign module, while \ libc::c_uint or libc::c_ulong should be used"); @@ -1630,36 +1630,29 @@ declare_lint! { Warn, "detects use of #[deprecated] items" } -// FIXME #6875: Change to Warn after std library stabilization is complete -declare_lint! { - EXPERIMENTAL, - Allow, - "detects use of #[experimental] items" -} declare_lint! { UNSTABLE, - Allow, + Warn, "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 +/// Checks for use of items with `#[deprecated]`, `#[unstable]` and /// `#[unstable]` attributes, or no stability attribute. #[derive(Copy)] -pub struct Stability; +pub struct Stability { this_crate_staged: bool } impl Stability { + pub fn new() -> Stability { Stability { this_crate_staged: false } } + fn lint(&self, cx: &Context, id: ast::DefId, span: Span) { let ref stability = stability::lookup(cx.tcx, id); let cross_crate = !ast_util::is_local(id); + let staged = (!cross_crate && self.this_crate_staged) + || (cross_crate && stability::is_staged_api(cx.tcx, id)); + + if !staged { return } // stability attributes are promises made across crates; only // check DEPRECATED for crate-local usage. @@ -1668,21 +1661,12 @@ impl Stability { None if cross_crate => (UNSTABLE, "unmarked"), Some(attr::Stability { level: attr::Unstable, .. }) if cross_crate => (UNSTABLE, "unstable"), - Some(attr::Stability { level: attr::Experimental, .. }) if cross_crate => - (EXPERIMENTAL, "experimental"), Some(attr::Stability { level: attr::Deprecated, .. }) => (DEPRECATED, "deprecated"), _ => return }; 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); - } - } fn output(cx: &Context, span: Span, stability: &Option<attr::Stability>, lint: &'static Lint, label: &'static str) { @@ -1706,7 +1690,7 @@ impl Stability { impl LintPass for Stability { fn get_lints(&self) -> LintArray { - lint_array!(DEPRECATED, EXPERIMENTAL, UNSTABLE, STAGED_EXPERIMENTAL, STAGED_UNSTABLE) + lint_array!(DEPRECATED, UNSTABLE) } fn check_crate(&mut self, _: &Context, c: &ast::Crate) { @@ -1717,6 +1701,7 @@ impl LintPass for Stability { match attr.node.value.node { ast::MetaWord(_) => { attr::mark_used(attr); + self.this_crate_staged = true; } _ => (/*pass*/) } diff --git a/src/librustc/lint/context.rs b/src/librustc/lint/context.rs index db4d99fe494..95e1e8d44bf 100644 --- a/src/librustc/lint/context.rs +++ b/src/librustc/lint/context.rs @@ -209,7 +209,6 @@ impl LintStore { UnsafeBlocks, UnusedMut, UnusedAllocation, - Stability, MissingCopyImplementations, UnstableFeatures, ); @@ -218,6 +217,7 @@ impl LintStore { TypeLimits, RawPointerDerive, MissingDoc, + Stability, ); add_lint_group!(sess, "bad_style", @@ -308,18 +308,21 @@ impl LintStore { 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)), + Some(&Id(lint_id)) => if self.get_level_source(lint_id).0 != Forbid { + self.set_level(lint_id, (lvl, ReleaseChannel)) + }, + Some(&Renamed(_, lint_id)) => if self.get_level_source(lint_id).0 != Forbid { + 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)), + match self.by_name.get("unstable") { + Some(&Id(lint_id)) => if self.get_level_source(lint_id).0 != Forbid { + self.set_level(lint_id, (lvl, ReleaseChannel)) + }, + Some(&Renamed(_, lint_id)) => if self.get_level_source(lint_id).0 != Forbid { + self.set_level(lint_id, (lvl, ReleaseChannel)) + }, None => unreachable!() } } diff --git a/src/librustc/lint/mod.rs b/src/librustc/lint/mod.rs index 8a266a2530b..826a35e3bb5 100644 --- a/src/librustc/lint/mod.rs +++ b/src/librustc/lint/mod.rs @@ -40,7 +40,7 @@ use syntax::ast; pub use lint::context::{Context, LintStore, raw_emit_lint, check_crate, gather_attrs}; /// Specification of a single lint. -#[derive(Copy)] +#[derive(Copy, Show)] pub struct Lint { /// A string identifier for the lint. /// @@ -208,7 +208,7 @@ impl LintId { } /// Setting for how to handle a lint. -#[derive(Clone, Copy, PartialEq, PartialOrd, Eq, Ord)] +#[derive(Clone, Copy, PartialEq, PartialOrd, Eq, Ord, Show)] pub enum Level { Allow, Warn, Deny, Forbid } diff --git a/src/librustc/metadata/tyencode.rs b/src/librustc/metadata/tyencode.rs index c019d129218..bdd08ad6c49 100644 --- a/src/librustc/metadata/tyencode.rs +++ b/src/librustc/metadata/tyencode.rs @@ -61,7 +61,7 @@ pub fn enc_ty<'a, 'tcx>(w: &mut SeekableMemWriter, cx: &ctxt<'a, 'tcx>, t: Ty<'t ty::ty_char => mywrite!(w, "c"), ty::ty_int(t) => { match t { - ast::TyIs => mywrite!(w, "is"), + ast::TyIs(_) => mywrite!(w, "is"), ast::TyI8 => mywrite!(w, "MB"), ast::TyI16 => mywrite!(w, "MW"), ast::TyI32 => mywrite!(w, "ML"), @@ -70,7 +70,7 @@ pub fn enc_ty<'a, 'tcx>(w: &mut SeekableMemWriter, cx: &ctxt<'a, 'tcx>, t: Ty<'t } ty::ty_uint(t) => { match t { - ast::TyUs => mywrite!(w, "us"), + ast::TyUs(_) => mywrite!(w, "us"), ast::TyU8 => mywrite!(w, "Mb"), ast::TyU16 => mywrite!(w, "Mw"), ast::TyU32 => mywrite!(w, "Ml"), diff --git a/src/librustc/middle/const_eval.rs b/src/librustc/middle/const_eval.rs index 04d4b41b21a..52352e920ce 100644 --- a/src/librustc/middle/const_eval.rs +++ b/src/librustc/middle/const_eval.rs @@ -528,12 +528,12 @@ pub fn eval_const_expr_partial(tcx: &ty::ctxt, e: &Expr) -> Result<const_val, St eval_const_expr_partial(tcx, &**base) .and_then(|val| define_casts!(val, { - ty::ty_int(ast::TyIs) => (int, const_int, i64), + ty::ty_int(ast::TyIs(_)) => (int, const_int, i64), ty::ty_int(ast::TyI8) => (i8, const_int, i64), ty::ty_int(ast::TyI16) => (i16, const_int, i64), ty::ty_int(ast::TyI32) => (i32, const_int, i64), ty::ty_int(ast::TyI64) => (i64, const_int, i64), - ty::ty_uint(ast::TyUs) => (uint, const_uint, u64), + ty::ty_uint(ast::TyUs(_)) => (uint, const_uint, u64), ty::ty_uint(ast::TyU8) => (u8, const_uint, u64), ty::ty_uint(ast::TyU16) => (u16, const_uint, u64), ty::ty_uint(ast::TyU32) => (u32, const_uint, u64), diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs index fb9a16f86e5..51ec7528432 100644 --- a/src/librustc/middle/mem_categorization.rs +++ b/src/librustc/middle/mem_categorization.rs @@ -75,7 +75,7 @@ use middle::def; use middle::region; use middle::ty::{self, Ty}; use util::nodemap::{NodeMap}; -use util::ppaux::{Repr}; +use util::ppaux::{Repr, UserString}; use syntax::ast::{MutImmutable, MutMutable}; use syntax::ast; @@ -113,10 +113,17 @@ pub struct Upvar { // different kinds of pointers: #[derive(Clone, Copy, PartialEq, Eq, Hash, Show)] pub enum PointerKind { + /// `Box<T>` Unique, + + /// `&T` BorrowedPtr(ty::BorrowKind, ty::Region), - Implicit(ty::BorrowKind, ty::Region), // Implicit deref of a borrowed ptr. - UnsafePtr(ast::Mutability) + + /// `*T` + UnsafePtr(ast::Mutability), + + /// Implicit deref of the `&T` that results from an overloaded index `[]`. + Implicit(ty::BorrowKind, ty::Region), } // We use the term "interior" to mean "something reachable from the @@ -453,7 +460,7 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> { autoderefs, cmt.repr(self.tcx())); for deref in range(1u, autoderefs + 1) { - cmt = try!(self.cat_deref(expr, cmt, deref, false)); + cmt = try!(self.cat_deref(expr, cmt, deref)); } return Ok(cmt); } @@ -465,7 +472,7 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> { match expr.node { ast::ExprUnary(ast::UnDeref, ref e_base) => { let base_cmt = try!(self.cat_expr(&**e_base)); - self.cat_deref(expr, base_cmt, 0, false) + self.cat_deref(expr, base_cmt, 0) } ast::ExprField(ref base, f_name) => { @@ -489,10 +496,23 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> { // If this is an index implemented by a method call, then it // will include an implicit deref of the result. let ret_ty = self.overloaded_method_return_ty(method_ty); - self.cat_deref(expr, - self.cat_rvalue_node(expr.id(), - expr.span(), - ret_ty), 1, true) + + // The index method always returns an `&T`, so + // dereference it to find the result type. + let elem_ty = match ret_ty.sty { + ty::ty_rptr(_, mt) => mt.ty, + _ => { + debug!("cat_expr_unadjusted: return type of overloaded index is {}?", + ret_ty.repr(self.tcx())); + return Err(()); + } + }; + + // The call to index() returns a `&T` value, which + // is an rvalue. That is what we will be + // dereferencing. + let base_cmt = self.cat_rvalue_node(expr.id(), expr.span(), ret_ty); + self.cat_deref_common(expr, base_cmt, 1, elem_ty, true) } None => { self.cat_index(expr, try!(self.cat_expr(&**base))) @@ -837,8 +857,7 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> { fn cat_deref<N:ast_node>(&self, node: &N, base_cmt: cmt<'tcx>, - deref_cnt: uint, - implicit: bool) + deref_cnt: uint) -> McResult<cmt<'tcx>> { let adjustment = match self.typer.adjustments().borrow().get(&node.id()) { Some(adj) if ty::adjust_is_object(adj) => ty::AutoObject, @@ -866,7 +885,8 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> { }; let base_cmt_ty = base_cmt.ty; match ty::deref(base_cmt_ty, true) { - Some(mt) => self.cat_deref_common(node, base_cmt, deref_cnt, mt.ty, implicit), + Some(mt) => self.cat_deref_common(node, base_cmt, deref_cnt, mt.ty, + /* implicit: */ false), None => { debug!("Explicit deref of non-derefable type: {}", base_cmt_ty.repr(self.tcx())); @@ -1236,7 +1256,7 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> { // box p1, &p1, &mut p1. we can ignore the mutability of // PatRegion since that information is already contained // in the type. - let subcmt = try!(self.cat_deref(pat, cmt, 0, false)); + let subcmt = try!(self.cat_deref(pat, cmt, 0)); try!(self.cat_pattern_(subcmt, &**subpat, op)); } @@ -1392,22 +1412,6 @@ impl<'tcx> cmt_<'tcx> { pub fn descriptive_string(&self, tcx: &ty::ctxt) -> String { - fn upvar_to_string(upvar: &Upvar, is_copy: bool) -> String { - if upvar.is_unboxed { - let kind = match upvar.kind { - ty::FnUnboxedClosureKind => "Fn", - ty::FnMutUnboxedClosureKind => "FnMut", - ty::FnOnceUnboxedClosureKind => "FnOnce" - }; - format!("captured outer variable in an `{}` closure", kind) - } else { - (match (upvar.kind, is_copy) { - (ty::FnOnceUnboxedClosureKind, true) => "captured outer variable in a proc", - _ => "captured outer variable" - }).to_string() - } - } - match self.cat { cat_static_item => { "static item".to_string() @@ -1427,16 +1431,23 @@ impl<'tcx> cmt_<'tcx> { let upvar = self.upvar(); match upvar.as_ref().map(|i| &i.cat) { Some(&cat_upvar(ref var)) => { - upvar_to_string(var, false) + var.user_string(tcx) } Some(_) => unreachable!(), None => { match pk { Implicit(..) => { - "dereference (dereference is implicit, due to indexing)".to_string() + format!("indexed content") + } + Unique => { + format!("`Box` content") + } + UnsafePtr(..) => { + format!("dereference of unsafe pointer") + } + BorrowedPtr(..) => { + format!("borrowed content") } - Unique => format!("dereference of `{}`", ptr_sigil(pk)), - _ => format!("dereference of `{}`-pointer", ptr_sigil(pk)) } } } @@ -1447,14 +1458,12 @@ impl<'tcx> cmt_<'tcx> { cat_interior(_, InteriorField(PositionalField(_))) => { "anonymous field".to_string() } - cat_interior(_, InteriorElement(VecElement)) => { - "vec content".to_string() - } + cat_interior(_, InteriorElement(VecElement)) | cat_interior(_, InteriorElement(OtherElement)) => { "indexed content".to_string() } cat_upvar(ref var) => { - upvar_to_string(var, true) + var.user_string(tcx) } cat_downcast(ref cmt, _) => { cmt.descriptive_string(tcx) @@ -1483,7 +1492,7 @@ impl<'tcx> Repr<'tcx> for categorization<'tcx> { format!("{:?}", *self) } cat_deref(ref cmt, derefs, ptr) => { - format!("{}-{}{}->", cmt.cat.repr(tcx), ptr_sigil(ptr), derefs) + format!("{}-{}{}->", cmt.cat.repr(tcx), ptr.repr(tcx), derefs) } cat_interior(ref cmt, interior) => { format!("{}.{}", cmt.cat.repr(tcx), interior.repr(tcx)) @@ -1504,7 +1513,32 @@ pub fn ptr_sigil(ptr: PointerKind) -> &'static str { Implicit(ty::MutBorrow, _) => "&mut", BorrowedPtr(ty::UniqueImmBorrow, _) | Implicit(ty::UniqueImmBorrow, _) => "&unique", - UnsafePtr(_) => "*" + UnsafePtr(_) => "*", + } +} + +impl<'tcx> Repr<'tcx> for PointerKind { + fn repr(&self, tcx: &ty::ctxt<'tcx>) -> String { + match *self { + Unique => { + format!("Box") + } + BorrowedPtr(ty::ImmBorrow, ref r) | + Implicit(ty::ImmBorrow, ref r) => { + format!("&{}", r.repr(tcx)) + } + BorrowedPtr(ty::MutBorrow, ref r) | + Implicit(ty::MutBorrow, ref r) => { + format!("&{} mut", r.repr(tcx)) + } + BorrowedPtr(ty::UniqueImmBorrow, ref r) | + Implicit(ty::UniqueImmBorrow, ref r) => { + format!("&{} uniq", r.repr(tcx)) + } + UnsafePtr(_) => { + format!("*") + } + } } } @@ -1531,3 +1565,27 @@ fn element_kind(t: Ty) -> ElementKind { _ => OtherElement } } + +impl<'tcx> Repr<'tcx> for ty::UnboxedClosureKind { + fn repr(&self, _: &ty::ctxt) -> String { + format!("Upvar({:?})", self) + } +} + +impl<'tcx> Repr<'tcx> for Upvar { + fn repr(&self, tcx: &ty::ctxt) -> String { + format!("Upvar({})", self.kind.repr(tcx)) + } +} + +impl<'tcx> UserString<'tcx> for Upvar { + fn user_string(&self, _: &ty::ctxt) -> String { + let kind = match self.kind { + ty::FnUnboxedClosureKind => "Fn", + ty::FnMutUnboxedClosureKind => "FnMut", + ty::FnOnceUnboxedClosureKind => "FnOnce", + }; + format!("captured outer variable in an `{}` closure", kind) + } +} + diff --git a/src/librustc/middle/subst.rs b/src/librustc/middle/subst.rs index 5fbae6c359d..9ac6b8a86b6 100644 --- a/src/librustc/middle/subst.rs +++ b/src/librustc/middle/subst.rs @@ -313,6 +313,17 @@ impl<T> VecPerParamSpace<T> { self.content.insert(limit, value); } + /// Appends `values` to the vector associated with `space`. + /// + /// Unlike the `extend` method in `Vec`, this should not be assumed + /// to be a cheap operation (even when amortized over many calls). + pub fn extend<I:Iterator<Item=T>>(&mut self, space: ParamSpace, mut values: I) { + // This could be made more efficient, obviously. + for item in values { + self.push(space, item); + } + } + pub fn pop(&mut self, space: ParamSpace) -> Option<T> { let (start, limit) = self.limits(space); if start == limit { diff --git a/src/librustc/middle/traits/coherence.rs b/src/librustc/middle/traits/coherence.rs index 489731e7554..b6d45ab89e7 100644 --- a/src/librustc/middle/traits/coherence.rs +++ b/src/librustc/middle/traits/coherence.rs @@ -12,6 +12,7 @@ use super::SelectionContext; use super::{Obligation, ObligationCause}; +use super::project; use super::util; use middle::subst::{Subst}; @@ -34,22 +35,28 @@ pub fn impl_can_satisfy(infcx: &InferCtxt, impl1_def_id.repr(infcx.tcx), impl2_def_id.repr(infcx.tcx)); + let param_env = ty::empty_parameter_environment(infcx.tcx); + let mut selcx = SelectionContext::intercrate(infcx, ¶m_env); + let cause = ObligationCause::dummy(); + // `impl1` provides an implementation of `Foo<X,Y> for Z`. let impl1_substs = util::fresh_substs_for_impl(infcx, DUMMY_SP, impl1_def_id); let impl1_trait_ref = (*ty::impl_trait_ref(infcx.tcx, impl1_def_id).unwrap()).subst(infcx.tcx, &impl1_substs); + let impl1_trait_ref = + project::normalize(&mut selcx, cause.clone(), &impl1_trait_ref); // Determine whether `impl2` can provide an implementation for those // same types. - let param_env = ty::empty_parameter_environment(infcx.tcx); - let mut selcx = SelectionContext::intercrate(infcx, ¶m_env); - let obligation = Obligation::new(ObligationCause::dummy(), + let obligation = Obligation::new(cause, ty::Binder(ty::TraitPredicate { - trait_ref: Rc::new(impl1_trait_ref), + trait_ref: Rc::new(impl1_trait_ref.value), })); debug!("impl_can_satisfy(obligation={})", obligation.repr(infcx.tcx)); - selcx.evaluate_impl(impl2_def_id, &obligation) + selcx.evaluate_impl(impl2_def_id, &obligation) && + impl1_trait_ref.obligations.iter().all( + |o| selcx.evaluate_obligation(o)) } #[allow(missing_copy_implementations)] diff --git a/src/librustc/middle/traits/project.rs b/src/librustc/middle/traits/project.rs index aaf5df4ce4a..95a938328cf 100644 --- a/src/librustc/middle/traits/project.rs +++ b/src/librustc/middle/traits/project.rs @@ -206,6 +206,7 @@ impl<'a,'b,'tcx> TypeFolder<'tcx> for AssociatedTypeNormalizer<'a,'b,'tcx> { // normalize it when we instantiate those bound regions (which // should occur eventually). + let ty = ty_fold::super_fold_ty(self, ty); match ty.sty { ty::ty_projection(ref data) if !data.has_escaping_regions() => { // (*) @@ -229,8 +230,9 @@ impl<'a,'b,'tcx> TypeFolder<'tcx> for AssociatedTypeNormalizer<'a,'b,'tcx> { self.obligations.extend(obligations.into_iter()); ty } + _ => { - ty_fold::super_fold_ty(self, ty) + ty } } } @@ -243,6 +245,12 @@ pub struct Normalized<'tcx,T> { pub type NormalizedTy<'tcx> = Normalized<'tcx, Ty<'tcx>>; +impl<'tcx,T> Normalized<'tcx,T> { + pub fn with<U>(self, value: U) -> Normalized<'tcx,U> { + Normalized { value: value, obligations: self.obligations } + } +} + pub fn normalize_projection_type<'a,'b,'tcx>( selcx: &'a mut SelectionContext<'b,'tcx>, projection_ty: ty::ProjectionTy<'tcx>, diff --git a/src/librustc/middle/traits/select.rs b/src/librustc/middle/traits/select.rs index f42f43d2576..d6302976b9f 100644 --- a/src/librustc/middle/traits/select.rs +++ b/src/librustc/middle/traits/select.rs @@ -19,6 +19,7 @@ use self::EvaluationResult::*; use super::{DerivedObligationCause}; use super::{project}; +use super::project::Normalized; use super::{PredicateObligation, Obligation, TraitObligation, ObligationCause}; use super::{ObligationCauseCode, BuiltinDerivedObligation}; use super::{SelectionError, Unimplemented, Overflow, OutputTypeParameterMismatch}; @@ -713,12 +714,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { debug!("obligation self ty is {}", obligation.predicate.0.self_ty().repr(self.tcx())); - // If the user has asked for the older, compatibility - // behavior, ignore user-defined impls here. This will - // go away by the time 1.0 is released. - if !self.tcx().sess.features.borrow().opt_out_copy { - try!(self.assemble_candidates_from_impls(obligation, &mut candidates.vec)); - } + try!(self.assemble_candidates_from_impls(obligation, &mut candidates.vec)); try!(self.assemble_builtin_bound_candidates(ty::BoundCopy, stack, @@ -1160,7 +1156,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { let impl_trait_ref = ty::impl_trait_ref(self.tcx(), impl_def_id).unwrap(); let impl_trait_ref = - impl_trait_ref.subst(self.tcx(), &impl_substs); + impl_trait_ref.subst(self.tcx(), &impl_substs.value); let poly_impl_trait_ref = ty::Binder(impl_trait_ref); let origin = @@ -1505,21 +1501,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { } ty::BoundCopy => { - // This is an Opt-In Built-In Trait. So, unless - // the user is asking for the old behavior, we - // don't supply any form of builtin impl. - if !this.tcx().sess.features.borrow().opt_out_copy { - return Ok(ParameterBuiltin) - } else { - // Older, backwards compatibility behavior: - if - Some(def_id) == tcx.lang_items.no_copy_bound() || - Some(def_id) == tcx.lang_items.managed_bound() || - ty::has_dtor(tcx, def_id) - { - return Err(Unimplemented); - } - } + return Ok(ParameterBuiltin) } ty::BoundSync => { @@ -1731,7 +1713,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { let substs = self.rematch_impl(impl_def_id, obligation, snapshot, &skol_map, skol_obligation_trait_ref.trait_ref); - debug!("confirm_impl_candidate substs={:?}", substs); + debug!("confirm_impl_candidate substs={}", substs.repr(self.tcx())); Ok(self.vtable_impl(impl_def_id, substs, obligation.cause.clone(), obligation.recursion_depth + 1, skol_map, snapshot)) }) @@ -1739,7 +1721,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { fn vtable_impl(&mut self, impl_def_id: ast::DefId, - substs: Substs<'tcx>, + substs: Normalized<'tcx, Substs<'tcx>>, cause: ObligationCause<'tcx>, recursion_depth: uint, skol_map: infer::SkolemizationMap, @@ -1752,21 +1734,23 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { recursion_depth, skol_map.repr(self.tcx())); - let impl_predicates = - self.impl_predicates(cause, + let mut impl_obligations = + self.impl_obligations(cause, recursion_depth, impl_def_id, - &substs, + &substs.value, skol_map, snapshot); - debug!("vtable_impl: impl_def_id={} impl_predicates={}", + debug!("vtable_impl: impl_def_id={} impl_obligations={}", impl_def_id.repr(self.tcx()), - impl_predicates.repr(self.tcx())); + impl_obligations.repr(self.tcx())); + + impl_obligations.extend(TypeSpace, substs.obligations.into_iter()); VtableImplData { impl_def_id: impl_def_id, - substs: substs, - nested: impl_predicates } + substs: substs.value, + nested: impl_obligations } } fn confirm_object_candidate(&mut self, @@ -1950,7 +1934,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { snapshot: &infer::CombinedSnapshot, skol_map: &infer::SkolemizationMap, skol_obligation_trait_ref: Rc<ty::TraitRef<'tcx>>) - -> Substs<'tcx> + -> Normalized<'tcx, Substs<'tcx>> { match self.match_impl(impl_def_id, obligation, snapshot, skol_map, skol_obligation_trait_ref) { @@ -1972,7 +1956,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { snapshot: &infer::CombinedSnapshot, skol_map: &infer::SkolemizationMap, skol_obligation_trait_ref: Rc<ty::TraitRef<'tcx>>) - -> Result<Substs<'tcx>, ()> + -> Result<Normalized<'tcx, Substs<'tcx>>, ()> { let impl_trait_ref = ty::impl_trait_ref(self.tcx(), impl_def_id).unwrap(); @@ -1990,6 +1974,12 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { let impl_trait_ref = impl_trait_ref.subst(self.tcx(), &impl_substs); + let impl_trait_ref = + project::normalize_with_depth(self, + obligation.cause.clone(), + obligation.recursion_depth + 1, + &impl_trait_ref); + debug!("match_impl(impl_def_id={}, obligation={}, \ impl_trait_ref={}, skol_obligation_trait_ref={})", impl_def_id.repr(self.tcx()), @@ -2000,7 +1990,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { let origin = infer::RelateOutputImplTypes(obligation.cause.span); match self.infcx.sub_trait_refs(false, origin, - impl_trait_ref, + impl_trait_ref.value.clone(), skol_obligation_trait_ref) { Ok(()) => { } Err(e) => { @@ -2020,7 +2010,8 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { } debug!("match_impl: success impl_substs={}", impl_substs.repr(self.tcx())); - Ok(impl_substs) + Ok(Normalized { value: impl_substs, + obligations: impl_trait_ref.obligations }) } fn fast_reject_trait_refs(&mut self, @@ -2161,14 +2152,14 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { } } - fn impl_predicates(&mut self, - cause: ObligationCause<'tcx>, - recursion_depth: uint, - impl_def_id: ast::DefId, - impl_substs: &Substs<'tcx>, - skol_map: infer::SkolemizationMap, - snapshot: &infer::CombinedSnapshot) - -> VecPerParamSpace<PredicateObligation<'tcx>> + fn impl_obligations(&mut self, + cause: ObligationCause<'tcx>, + recursion_depth: uint, + impl_def_id: ast::DefId, + impl_substs: &Substs<'tcx>, + skol_map: infer::SkolemizationMap, + snapshot: &infer::CombinedSnapshot) + -> VecPerParamSpace<PredicateObligation<'tcx>> { let impl_generics = ty::lookup_item_type(self.tcx(), impl_def_id).generics; let bounds = impl_generics.to_bounds(self.tcx(), impl_substs); @@ -2181,9 +2172,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { cause, recursion_depth, &normalized_bounds.value); - for obligation in normalized_bounds.obligations.into_iter() { - impl_obligations.push(TypeSpace, obligation); - } + impl_obligations.extend(TypeSpace, normalized_bounds.obligations.into_iter()); impl_obligations } diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index 64f0bcb1c88..ef86e67de16 100644 --- a/src/librustc/middle/ty.rs +++ b/src/librustc/middle/ty.rs @@ -2341,12 +2341,12 @@ impl<'tcx> CommonTypes<'tcx> { bool: intern_ty(arena, interner, ty_bool), char: intern_ty(arena, interner, ty_char), err: intern_ty(arena, interner, ty_err), - int: intern_ty(arena, interner, ty_int(ast::TyIs)), + int: intern_ty(arena, interner, ty_int(ast::TyIs(false))), i8: intern_ty(arena, interner, ty_int(ast::TyI8)), i16: intern_ty(arena, interner, ty_int(ast::TyI16)), i32: intern_ty(arena, interner, ty_int(ast::TyI32)), i64: intern_ty(arena, interner, ty_int(ast::TyI64)), - uint: intern_ty(arena, interner, ty_uint(ast::TyUs)), + uint: intern_ty(arena, interner, ty_uint(ast::TyUs(false))), u8: intern_ty(arena, interner, ty_uint(ast::TyU8)), u16: intern_ty(arena, interner, ty_uint(ast::TyU16)), u32: intern_ty(arena, interner, ty_uint(ast::TyU32)), @@ -2692,7 +2692,7 @@ impl FlagComputation { pub fn mk_mach_int<'tcx>(tcx: &ctxt<'tcx>, tm: ast::IntTy) -> Ty<'tcx> { match tm { - ast::TyIs => tcx.types.int, + ast::TyIs(_) => tcx.types.int, ast::TyI8 => tcx.types.i8, ast::TyI16 => tcx.types.i16, ast::TyI32 => tcx.types.i32, @@ -2702,7 +2702,7 @@ pub fn mk_mach_int<'tcx>(tcx: &ctxt<'tcx>, tm: ast::IntTy) -> Ty<'tcx> { pub fn mk_mach_uint<'tcx>(tcx: &ctxt<'tcx>, tm: ast::UintTy) -> Ty<'tcx> { match tm { - ast::TyUs => tcx.types.uint, + ast::TyUs(_) => tcx.types.uint, ast::TyU8 => tcx.types.u8, ast::TyU16 => tcx.types.u16, ast::TyU32 => tcx.types.u32, @@ -3363,7 +3363,7 @@ pub fn type_contents<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> TypeContents { let result = match ty.sty { // uint and int are ffi-unsafe - ty_uint(ast::TyUs) | ty_int(ast::TyIs) => { + ty_uint(ast::TyUs(_)) | ty_int(ast::TyIs(_)) => { TC::ReachesFfiUnsafe } @@ -3937,7 +3937,7 @@ pub fn type_is_fresh(ty: Ty) -> bool { pub fn type_is_uint(ty: Ty) -> bool { match ty.sty { - ty_infer(IntVar(_)) | ty_uint(ast::TyUs) => true, + ty_infer(IntVar(_)) | ty_uint(ast::TyUs(_)) => true, _ => false } } @@ -3983,7 +3983,7 @@ pub fn type_is_signed(ty: Ty) -> bool { pub fn type_is_machine(ty: Ty) -> bool { match ty.sty { - ty_int(ast::TyIs) | ty_uint(ast::TyUs) => false, + ty_int(ast::TyIs(_)) | ty_uint(ast::TyUs(_)) => false, ty_int(..) | ty_uint(..) | ty_float(..) => true, _ => false } diff --git a/src/librustc_back/lib.rs b/src/librustc_back/lib.rs index fcd20158c0a..d29a47b65b0 100644 --- a/src/librustc_back/lib.rs +++ b/src/librustc_back/lib.rs @@ -22,7 +22,7 @@ //! build speedups. #![crate_name = "rustc_back"] -#![experimental] +#![unstable] #![staged_api] #![crate_type = "dylib"] #![crate_type = "rlib"] @@ -31,6 +31,7 @@ html_root_url = "http://doc.rust-lang.org/nightly/")] #![allow(unknown_features)] #![feature(slicing_syntax, box_syntax)] +#![allow(unknown_features)] #![feature(int_uint)] extern crate syntax; extern crate serialize; diff --git a/src/librustc_borrowck/borrowck/gather_loans/move_error.rs b/src/librustc_borrowck/borrowck/gather_loans/move_error.rs index a7771fefec4..28d02161eeb 100644 --- a/src/librustc_borrowck/borrowck/gather_loans/move_error.rs +++ b/src/librustc_borrowck/borrowck/gather_loans/move_error.rs @@ -115,29 +115,31 @@ fn report_cannot_move_out_of<'a, 'tcx>(bccx: &BorrowckCtxt<'a, 'tcx>, match move_from.cat { mc::cat_deref(_, _, mc::BorrowedPtr(..)) | mc::cat_deref(_, _, mc::Implicit(..)) | - mc::cat_deref(_, _, mc::UnsafePtr(..)) | mc::cat_static_item => { - bccx.span_err( - move_from.span, - &format!("cannot move out of {}", - bccx.cmt_to_string(&*move_from))[]); + bccx.span_err(move_from.span, + &format!("cannot move out of {}", + move_from.descriptive_string(bccx.tcx))[]); } mc::cat_downcast(ref b, _) | mc::cat_interior(ref b, _) => { match b.ty.sty { - ty::ty_struct(did, _) - | ty::ty_enum(did, _) if ty::has_dtor(bccx.tcx, did) => { + ty::ty_struct(did, _) | + ty::ty_enum(did, _) if ty::has_dtor(bccx.tcx, did) => { bccx.span_err( move_from.span, &format!("cannot move out of type `{}`, \ which defines the `Drop` trait", b.ty.user_string(bccx.tcx))[]); }, - _ => panic!("this path should not cause illegal move") + _ => { + bccx.span_bug(move_from.span, "this path should not cause illegal move") + } } } - _ => panic!("this path should not cause illegal move") + _ => { + bccx.span_bug(move_from.span, "this path should not cause illegal move") + } } } diff --git a/src/librustc_borrowck/borrowck/mod.rs b/src/librustc_borrowck/borrowck/mod.rs index e734e8fb6ff..b87fed1601c 100644 --- a/src/librustc_borrowck/borrowck/mod.rs +++ b/src/librustc_borrowck/borrowck/mod.rs @@ -681,6 +681,10 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> { self.tcx.sess.span_err(s, m); } + pub fn span_bug(&self, s: Span, m: &str) { + self.tcx.sess.span_bug(s, m); + } + pub fn span_note(&self, s: Span, m: &str) { self.tcx.sess.span_note(s, m); } diff --git a/src/librustc_borrowck/lib.rs b/src/librustc_borrowck/lib.rs index 452eaaaa52d..eedad75c89f 100644 --- a/src/librustc_borrowck/lib.rs +++ b/src/librustc_borrowck/lib.rs @@ -9,7 +9,7 @@ // except according to those terms. #![crate_name = "rustc_borrowck"] -#![experimental] +#![unstable] #![staged_api] #![crate_type = "dylib"] #![crate_type = "rlib"] @@ -21,6 +21,7 @@ #![feature(quote)] #![feature(slicing_syntax, unsafe_destructor)] #![feature(rustc_diagnostic_macros)] +#![allow(unknown_features)] #![feature(int_uint)] #![allow(non_camel_case_types)] #[macro_use] extern crate log; diff --git a/src/librustc_driver/lib.rs b/src/librustc_driver/lib.rs index da2ec948cc9..9122a34a793 100644 --- a/src/librustc_driver/lib.rs +++ b/src/librustc_driver/lib.rs @@ -15,7 +15,7 @@ //! This API is completely unstable and subject to change. #![crate_name = "rustc_driver"] -#![experimental] +#![unstable] #![staged_api] #![crate_type = "dylib"] #![crate_type = "rlib"] @@ -28,6 +28,7 @@ #![feature(slicing_syntax, unsafe_destructor)] #![feature(box_syntax)] #![feature(rustc_diagnostic_macros)] +#![allow(unknown_features)] #![feature(int_uint)] extern crate arena; extern crate flate; diff --git a/src/librustc_llvm/lib.rs b/src/librustc_llvm/lib.rs index 4a281c413d6..a4f9b1f98d4 100644 --- a/src/librustc_llvm/lib.rs +++ b/src/librustc_llvm/lib.rs @@ -14,7 +14,7 @@ #![allow(dead_code)] #![crate_name = "rustc_llvm"] -#![experimental] +#![unstable] #![staged_api] #![crate_type = "dylib"] #![crate_type = "rlib"] @@ -25,6 +25,7 @@ #![allow(unknown_features)] #![feature(link_args)] #![feature(box_syntax)] +#![allow(unknown_features)] #![feature(int_uint)] extern crate libc; diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs index a1ae96490ca..ea6ecfbb92b 100644 --- a/src/librustc_resolve/lib.rs +++ b/src/librustc_resolve/lib.rs @@ -9,7 +9,7 @@ // except according to those terms. #![crate_name = "rustc_resolve"] -#![experimental] +#![unstable] #![staged_api] #![crate_type = "dylib"] #![crate_type = "rlib"] @@ -19,6 +19,7 @@ #![feature(slicing_syntax)] #![feature(rustc_diagnostic_macros)] +#![allow(unknown_features)] #![feature(int_uint)] #[macro_use] extern crate log; #[macro_use] extern crate syntax; @@ -819,15 +820,15 @@ impl PrimitiveTypeTable { table.intern("char", TyChar); table.intern("f32", TyFloat(TyF32)); table.intern("f64", TyFloat(TyF64)); - table.intern("int", TyInt(TyIs)); - table.intern("isize", TyInt(TyIs)); + table.intern("int", TyInt(TyIs(true))); + table.intern("isize", TyInt(TyIs(false))); table.intern("i8", TyInt(TyI8)); table.intern("i16", TyInt(TyI16)); table.intern("i32", TyInt(TyI32)); table.intern("i64", TyInt(TyI64)); table.intern("str", TyStr); - table.intern("uint", TyUint(TyUs)); - table.intern("usize", TyUint(TyUs)); + table.intern("uint", TyUint(TyUs(true))); + table.intern("usize", TyUint(TyUs(false))); table.intern("u8", TyUint(TyU8)); table.intern("u16", TyUint(TyU16)); table.intern("u32", TyUint(TyU32)); diff --git a/src/librustc_trans/back/lto.rs b/src/librustc_trans/back/lto.rs index e457de6bc77..b6a6b526fac 100644 --- a/src/librustc_trans/back/lto.rs +++ b/src/librustc_trans/back/lto.rs @@ -142,7 +142,7 @@ pub fn run(sess: &session::Session, llmod: ModuleRef, let cstrs: Vec<CString> = reachable.iter().map(|s| { CString::from_slice(s.as_bytes()) }).collect(); - let arr: Vec<*const i8> = cstrs.iter().map(|c| c.as_ptr()).collect(); + let arr: Vec<*const libc::c_char> = cstrs.iter().map(|c| c.as_ptr()).collect(); let ptr = arr.as_ptr(); unsafe { llvm::LLVMRustRunRestrictionPass(llmod, diff --git a/src/librustc_trans/lib.rs b/src/librustc_trans/lib.rs index 5da51697d2f..4859598e63c 100644 --- a/src/librustc_trans/lib.rs +++ b/src/librustc_trans/lib.rs @@ -15,7 +15,7 @@ //! This API is completely unstable and subject to change. #![crate_name = "rustc_trans"] -#![experimental] +#![unstable] #![staged_api] #![crate_type = "dylib"] #![crate_type = "rlib"] @@ -28,6 +28,7 @@ #![feature(slicing_syntax, unsafe_destructor)] #![feature(box_syntax)] #![feature(rustc_diagnostic_macros)] +#![allow(unknown_features)] #![feature(int_uint)] extern crate arena; extern crate flate; diff --git a/src/librustc_trans/trans/base.rs b/src/librustc_trans/trans/base.rs index 74071a1de4c..88ce36a710a 100644 --- a/src/librustc_trans/trans/base.rs +++ b/src/librustc_trans/trans/base.rs @@ -917,8 +917,8 @@ pub fn fail_if_zero_or_overflows<'blk, 'tcx>( ty::ty_int(t) => { let llty = Type::int_from_ty(cx.ccx(), t); let min = match t { - ast::TyIs if llty == Type::i32(cx.ccx()) => i32::MIN as u64, - ast::TyIs => i64::MIN as u64, + ast::TyIs(_) if llty == Type::i32(cx.ccx()) => i32::MIN as u64, + ast::TyIs(_) => i64::MIN as u64, ast::TyI8 => i8::MIN as u64, ast::TyI16 => i16::MIN as u64, ast::TyI32 => i32::MIN as u64, diff --git a/src/librustc_trans/trans/common.rs b/src/librustc_trans/trans/common.rs index ab5b563b99c..3afd33d324d 100644 --- a/src/librustc_trans/trans/common.rs +++ b/src/librustc_trans/trans/common.rs @@ -124,144 +124,144 @@ pub fn type_is_sized<'tcx>(tcx: &ty::ctxt<'tcx>, ty: Ty<'tcx>) -> bool { } pub fn lltype_is_sized<'tcx>(cx: &ty::ctxt<'tcx>, ty: Ty<'tcx>) -> bool { -match ty.sty { - ty::ty_open(_) => true, - _ => type_is_sized(cx, ty), -} + match ty.sty { + ty::ty_open(_) => true, + _ => type_is_sized(cx, ty), + } } pub fn type_is_fat_ptr<'tcx>(cx: &ty::ctxt<'tcx>, ty: Ty<'tcx>) -> bool { -match ty.sty { - ty::ty_ptr(ty::mt{ty, ..}) | - ty::ty_rptr(_, ty::mt{ty, ..}) | - ty::ty_uniq(ty) => { - !type_is_sized(cx, ty) - } - _ => { - false + match ty.sty { + ty::ty_ptr(ty::mt{ty, ..}) | + ty::ty_rptr(_, ty::mt{ty, ..}) | + ty::ty_uniq(ty) => { + !type_is_sized(cx, ty) + } + _ => { + false + } } } -} // Return the smallest part of `ty` which is unsized. Fails if `ty` is sized. // 'Smallest' here means component of the static representation of the type; not // the size of an object at runtime. pub fn unsized_part_of_type<'tcx>(cx: &ty::ctxt<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> { -match ty.sty { - ty::ty_str | ty::ty_trait(..) | ty::ty_vec(..) => ty, - ty::ty_struct(def_id, substs) => { - let unsized_fields: Vec<_> = - ty::struct_fields(cx, def_id, substs) - .iter() - .map(|f| f.mt.ty) - .filter(|ty| !type_is_sized(cx, *ty)) - .collect(); - - // Exactly one of the fields must be unsized. - assert!(unsized_fields.len() == 1); - - unsized_part_of_type(cx, unsized_fields[0]) - } - _ => { - assert!(type_is_sized(cx, ty), - "unsized_part_of_type failed even though ty is unsized"); - panic!("called unsized_part_of_type with sized ty"); + match ty.sty { + ty::ty_str | ty::ty_trait(..) | ty::ty_vec(..) => ty, + ty::ty_struct(def_id, substs) => { + let unsized_fields: Vec<_> = + ty::struct_fields(cx, def_id, substs) + .iter() + .map(|f| f.mt.ty) + .filter(|ty| !type_is_sized(cx, *ty)) + .collect(); + + // Exactly one of the fields must be unsized. + assert!(unsized_fields.len() == 1); + + unsized_part_of_type(cx, unsized_fields[0]) + } + _ => { + assert!(type_is_sized(cx, ty), + "unsized_part_of_type failed even though ty is unsized"); + panic!("called unsized_part_of_type with sized ty"); + } } } -} // Some things don't need cleanups during unwinding because the // task can free them all at once later. Currently only things // that only contain scalars and shared boxes can avoid unwind // cleanups. pub fn type_needs_unwind_cleanup<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, ty: Ty<'tcx>) -> bool { -return memoized(ccx.needs_unwind_cleanup_cache(), ty, |ty| { - type_needs_unwind_cleanup_(ccx.tcx(), ty, &mut FnvHashSet::new()) -}); - -fn type_needs_unwind_cleanup_<'tcx>(tcx: &ty::ctxt<'tcx>, - ty: Ty<'tcx>, - tycache: &mut FnvHashSet<Ty<'tcx>>) - -> bool -{ - // Prevent infinite recursion - if !tycache.insert(ty) { - return false; - } - - let mut needs_unwind_cleanup = false; - ty::maybe_walk_ty(ty, |ty| { - needs_unwind_cleanup |= match ty.sty { - ty::ty_bool | ty::ty_int(_) | ty::ty_uint(_) | - ty::ty_float(_) | ty::ty_tup(_) | ty::ty_ptr(_) => false, + return memoized(ccx.needs_unwind_cleanup_cache(), ty, |ty| { + type_needs_unwind_cleanup_(ccx.tcx(), ty, &mut FnvHashSet::new()) + }); - ty::ty_enum(did, substs) => - ty::enum_variants(tcx, did).iter().any(|v| - v.args.iter().any(|&aty| { - let t = aty.subst(tcx, substs); - type_needs_unwind_cleanup_(tcx, t, tycache) - }) - ), + fn type_needs_unwind_cleanup_<'tcx>(tcx: &ty::ctxt<'tcx>, + ty: Ty<'tcx>, + tycache: &mut FnvHashSet<Ty<'tcx>>) + -> bool + { + // Prevent infinite recursion + if !tycache.insert(ty) { + return false; + } - _ => true - }; - !needs_unwind_cleanup - }); - needs_unwind_cleanup -} + let mut needs_unwind_cleanup = false; + ty::maybe_walk_ty(ty, |ty| { + needs_unwind_cleanup |= match ty.sty { + ty::ty_bool | ty::ty_int(_) | ty::ty_uint(_) | + ty::ty_float(_) | ty::ty_tup(_) | ty::ty_ptr(_) => false, + + ty::ty_enum(did, substs) => + ty::enum_variants(tcx, did).iter().any(|v| + v.args.iter().any(|&aty| { + let t = aty.subst(tcx, substs); + type_needs_unwind_cleanup_(tcx, t, tycache) + }) + ), + + _ => true + }; + !needs_unwind_cleanup + }); + needs_unwind_cleanup + } } pub fn type_needs_drop<'tcx>(cx: &ty::ctxt<'tcx>, ty: Ty<'tcx>) -> bool { -ty::type_contents(cx, ty).needs_drop(cx) + ty::type_contents(cx, ty).needs_drop(cx) } fn type_is_newtype_immediate<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, ty: Ty<'tcx>) -> bool { -match ty.sty { - ty::ty_struct(def_id, substs) => { - let fields = ty::struct_fields(ccx.tcx(), def_id, substs); - fields.len() == 1 && - fields[0].name == - token::special_idents::unnamed_field.name && - type_is_immediate(ccx, fields[0].mt.ty) + match ty.sty { + ty::ty_struct(def_id, substs) => { + let fields = ty::struct_fields(ccx.tcx(), def_id, substs); + fields.len() == 1 && + fields[0].name == + token::special_idents::unnamed_field.name && + type_is_immediate(ccx, fields[0].mt.ty) + } + _ => false } - _ => false -} } pub fn type_is_immediate<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, ty: Ty<'tcx>) -> bool { -use trans::machine::llsize_of_alloc; -use trans::type_of::sizing_type_of; - -let tcx = ccx.tcx(); -let simple = ty::type_is_scalar(ty) || - ty::type_is_unique(ty) || ty::type_is_region_ptr(ty) || - type_is_newtype_immediate(ccx, ty) || - ty::type_is_simd(tcx, ty); -if simple && !type_is_fat_ptr(tcx, ty) { - return true; -} -if !type_is_sized(tcx, ty) { - return false; -} -match ty.sty { - ty::ty_struct(..) | ty::ty_enum(..) | ty::ty_tup(..) | - ty::ty_unboxed_closure(..) => { - let llty = sizing_type_of(ccx, ty); - llsize_of_alloc(ccx, llty) <= llsize_of_alloc(ccx, ccx.int_type()) + use trans::machine::llsize_of_alloc; + use trans::type_of::sizing_type_of; + + let tcx = ccx.tcx(); + let simple = ty::type_is_scalar(ty) || + ty::type_is_unique(ty) || ty::type_is_region_ptr(ty) || + type_is_newtype_immediate(ccx, ty) || + ty::type_is_simd(tcx, ty); + if simple && !type_is_fat_ptr(tcx, ty) { + return true; + } + if !type_is_sized(tcx, ty) { + return false; + } + match ty.sty { + ty::ty_struct(..) | ty::ty_enum(..) | ty::ty_tup(..) | + ty::ty_unboxed_closure(..) => { + let llty = sizing_type_of(ccx, ty); + llsize_of_alloc(ccx, llty) <= llsize_of_alloc(ccx, ccx.int_type()) + } + _ => type_is_zero_size(ccx, ty) } - _ => type_is_zero_size(ccx, ty) -} } /// Identify types which have size zero at runtime. pub fn type_is_zero_size<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, ty: Ty<'tcx>) -> bool { -use trans::machine::llsize_of_alloc; -use trans::type_of::sizing_type_of; -let llty = sizing_type_of(ccx, ty); -llsize_of_alloc(ccx, llty) == 0 + use trans::machine::llsize_of_alloc; + use trans::type_of::sizing_type_of; + let llty = sizing_type_of(ccx, ty); + llsize_of_alloc(ccx, llty) == 0 } /// Identifies types which we declare to be equivalent to `void` in C for the purpose of function @@ -269,25 +269,25 @@ llsize_of_alloc(ccx, llty) == 0 /// zero-size, but not all zero-size types use a `void` return type (in order to aid with C ABI /// compatibility). pub fn return_type_is_void(ccx: &CrateContext, ty: Ty) -> bool { -ty::type_is_nil(ty) || ty::type_is_empty(ccx.tcx(), ty) + ty::type_is_nil(ty) || ty::type_is_empty(ccx.tcx(), ty) } /// Generates a unique symbol based off the name given. This is used to create /// unique symbols for things like closures. 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)[])) + 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)[])) } #[derive(Copy)] pub struct tydesc_info<'tcx> { -pub ty: Ty<'tcx>, -pub tydesc: ValueRef, -pub size: ValueRef, -pub align: ValueRef, -pub name: ValueRef, + pub ty: Ty<'tcx>, + pub tydesc: ValueRef, + pub size: ValueRef, + pub align: ValueRef, + pub name: ValueRef, } /* @@ -318,36 +318,36 @@ pub name: ValueRef, #[derive(Copy)] pub struct NodeInfo { -pub id: ast::NodeId, -pub span: Span, + pub id: ast::NodeId, + pub span: Span, } pub fn expr_info(expr: &ast::Expr) -> NodeInfo { -NodeInfo { id: expr.id, span: expr.span } + NodeInfo { id: expr.id, span: expr.span } } pub struct BuilderRef_res { -pub b: BuilderRef, + pub b: BuilderRef, } impl Drop for BuilderRef_res { -fn drop(&mut self) { - unsafe { - llvm::LLVMDisposeBuilder(self.b); + fn drop(&mut self) { + unsafe { + llvm::LLVMDisposeBuilder(self.b); + } } } -} pub fn BuilderRef_res(b: BuilderRef) -> BuilderRef_res { -BuilderRef_res { - b: b -} + BuilderRef_res { + b: b + } } pub type ExternMap = FnvHashMap<String, ValueRef>; pub fn validate_substs(substs: &Substs) { -assert!(substs.types.all(|t| !ty::type_needs_infer(*t))); + assert!(substs.types.all(|t| !ty::type_needs_infer(*t))); } // work around bizarre resolve errors @@ -357,183 +357,183 @@ type LvalueDatum<'tcx> = datum::Datum<'tcx, datum::Lvalue>; // Function context. Every LLVM function we create will have one of // these. pub struct FunctionContext<'a, 'tcx: 'a> { -// The ValueRef returned from a call to llvm::LLVMAddFunction; the -// address of the first instruction in the sequence of -// instructions for this function that will go in the .text -// section of the executable we're generating. -pub llfn: ValueRef, + // The ValueRef returned from a call to llvm::LLVMAddFunction; the + // address of the first instruction in the sequence of + // instructions for this function that will go in the .text + // section of the executable we're generating. + pub llfn: ValueRef, -// always an empty parameter-environment -pub param_env: ty::ParameterEnvironment<'a, 'tcx>, + // always an empty parameter-environment + pub param_env: ty::ParameterEnvironment<'a, 'tcx>, -// The environment argument in a closure. -pub llenv: Option<ValueRef>, + // The environment argument in a closure. + pub llenv: Option<ValueRef>, -// A pointer to where to store the return value. If the return type is -// immediate, this points to an alloca in the function. Otherwise, it's a -// pointer to the hidden first parameter of the function. After function -// construction, this should always be Some. -pub llretslotptr: Cell<Option<ValueRef>>, + // A pointer to where to store the return value. If the return type is + // immediate, this points to an alloca in the function. Otherwise, it's a + // pointer to the hidden first parameter of the function. After function + // construction, this should always be Some. + pub llretslotptr: Cell<Option<ValueRef>>, -// These pub elements: "hoisted basic blocks" containing -// administrative activities that have to happen in only one place in -// the function, due to LLVM's quirks. -// A marker for the place where we want to insert the function's static -// allocas, so that LLVM will coalesce them into a single alloca call. -pub alloca_insert_pt: Cell<Option<ValueRef>>, -pub llreturn: Cell<Option<BasicBlockRef>>, + // These pub elements: "hoisted basic blocks" containing + // administrative activities that have to happen in only one place in + // the function, due to LLVM's quirks. + // A marker for the place where we want to insert the function's static + // allocas, so that LLVM will coalesce them into a single alloca call. + pub alloca_insert_pt: Cell<Option<ValueRef>>, + pub llreturn: Cell<Option<BasicBlockRef>>, -// If the function has any nested return's, including something like: -// fn foo() -> Option<Foo> { Some(Foo { x: return None }) }, then -// we use a separate alloca for each return -pub needs_ret_allocas: bool, + // If the function has any nested return's, including something like: + // fn foo() -> Option<Foo> { Some(Foo { x: return None }) }, then + // we use a separate alloca for each return + pub needs_ret_allocas: bool, -// The a value alloca'd for calls to upcalls.rust_personality. Used when -// outputting the resume instruction. -pub personality: Cell<Option<ValueRef>>, + // The a value alloca'd for calls to upcalls.rust_personality. Used when + // outputting the resume instruction. + pub personality: Cell<Option<ValueRef>>, -// True if the caller expects this fn to use the out pointer to -// return. Either way, your code should write into the slot llretslotptr -// points to, but if this value is false, that slot will be a local alloca. -pub caller_expects_out_pointer: bool, + // True if the caller expects this fn to use the out pointer to + // return. Either way, your code should write into the slot llretslotptr + // points to, but if this value is false, that slot will be a local alloca. + pub caller_expects_out_pointer: bool, -// Maps the DefId's for local variables to the allocas created for -// them in llallocas. -pub lllocals: RefCell<NodeMap<LvalueDatum<'tcx>>>, + // Maps the DefId's for local variables to the allocas created for + // them in llallocas. + pub lllocals: RefCell<NodeMap<LvalueDatum<'tcx>>>, -// Same as above, but for closure upvars -pub llupvars: RefCell<NodeMap<ValueRef>>, + // Same as above, but for closure upvars + pub llupvars: RefCell<NodeMap<ValueRef>>, -// The NodeId of the function, or -1 if it doesn't correspond to -// a user-defined function. -pub id: ast::NodeId, + // The NodeId of the function, or -1 if it doesn't correspond to + // a user-defined function. + pub id: ast::NodeId, -// If this function is being monomorphized, this contains the type -// substitutions used. -pub param_substs: &'a Substs<'tcx>, + // If this function is being monomorphized, this contains the type + // substitutions used. + pub param_substs: &'a Substs<'tcx>, -// The source span and nesting context where this function comes from, for -// error reporting and symbol generation. -pub span: Option<Span>, + // The source span and nesting context where this function comes from, for + // error reporting and symbol generation. + pub span: Option<Span>, -// The arena that blocks are allocated from. -pub block_arena: &'a TypedArena<BlockS<'a, 'tcx>>, + // The arena that blocks are allocated from. + pub block_arena: &'a TypedArena<BlockS<'a, 'tcx>>, -// This function's enclosing crate context. -pub ccx: &'a CrateContext<'a, 'tcx>, + // This function's enclosing crate context. + pub ccx: &'a CrateContext<'a, 'tcx>, -// Used and maintained by the debuginfo module. -pub debug_context: debuginfo::FunctionDebugContext, + // Used and maintained by the debuginfo module. + pub debug_context: debuginfo::FunctionDebugContext, -// Cleanup scopes. -pub scopes: RefCell<Vec<cleanup::CleanupScope<'a, 'tcx>>>, + // Cleanup scopes. + pub scopes: RefCell<Vec<cleanup::CleanupScope<'a, 'tcx>>>, -pub cfg: Option<cfg::CFG>, + pub cfg: Option<cfg::CFG>, } impl<'a, 'tcx> FunctionContext<'a, 'tcx> { -pub fn arg_pos(&self, arg: uint) -> uint { - let arg = self.env_arg_pos() + arg; - if self.llenv.is_some() { - arg + 1 - } else { - arg + pub fn arg_pos(&self, arg: uint) -> uint { + let arg = self.env_arg_pos() + arg; + if self.llenv.is_some() { + arg + 1 + } else { + arg + } } -} -pub fn env_arg_pos(&self) -> uint { - if self.caller_expects_out_pointer { - 1u - } else { - 0u + pub fn env_arg_pos(&self) -> uint { + if self.caller_expects_out_pointer { + 1u + } else { + 0u + } } -} -pub fn cleanup(&self) { - unsafe { - llvm::LLVMInstructionEraseFromParent(self.alloca_insert_pt - .get() - .unwrap()); + pub fn cleanup(&self) { + unsafe { + llvm::LLVMInstructionEraseFromParent(self.alloca_insert_pt + .get() + .unwrap()); + } } -} -pub fn get_llreturn(&self) -> BasicBlockRef { - if self.llreturn.get().is_none() { + pub fn get_llreturn(&self) -> BasicBlockRef { + if self.llreturn.get().is_none() { - self.llreturn.set(Some(unsafe { - llvm::LLVMAppendBasicBlockInContext(self.ccx.llcx(), self.llfn, - "return\0".as_ptr() as *const _) - })) - } + self.llreturn.set(Some(unsafe { + llvm::LLVMAppendBasicBlockInContext(self.ccx.llcx(), self.llfn, + "return\0".as_ptr() as *const _) + })) + } - self.llreturn.get().unwrap() -} + self.llreturn.get().unwrap() + } -pub fn get_ret_slot(&self, bcx: Block<'a, 'tcx>, - output: ty::FnOutput<'tcx>, - name: &str) -> ValueRef { - if self.needs_ret_allocas { - base::alloca_no_lifetime(bcx, match output { - ty::FnConverging(output_type) => type_of::type_of(bcx.ccx(), output_type), - ty::FnDiverging => Type::void(bcx.ccx()) - }, name) - } else { - self.llretslotptr.get().unwrap() + pub fn get_ret_slot(&self, bcx: Block<'a, 'tcx>, + output: ty::FnOutput<'tcx>, + name: &str) -> ValueRef { + if self.needs_ret_allocas { + base::alloca_no_lifetime(bcx, match output { + ty::FnConverging(output_type) => type_of::type_of(bcx.ccx(), output_type), + ty::FnDiverging => Type::void(bcx.ccx()) + }, name) + } else { + self.llretslotptr.get().unwrap() + } } -} -pub fn new_block(&'a self, - is_lpad: bool, - name: &str, - opt_node_id: Option<ast::NodeId>) - -> Block<'a, 'tcx> { - unsafe { - let name = CString::from_slice(name.as_bytes()); - let llbb = llvm::LLVMAppendBasicBlockInContext(self.ccx.llcx(), - self.llfn, - name.as_ptr()); - BlockS::new(llbb, is_lpad, opt_node_id, self) + pub fn new_block(&'a self, + is_lpad: bool, + name: &str, + opt_node_id: Option<ast::NodeId>) + -> Block<'a, 'tcx> { + unsafe { + let name = CString::from_slice(name.as_bytes()); + let llbb = llvm::LLVMAppendBasicBlockInContext(self.ccx.llcx(), + self.llfn, + name.as_ptr()); + BlockS::new(llbb, is_lpad, opt_node_id, self) + } } -} -pub fn new_id_block(&'a self, - name: &str, - node_id: ast::NodeId) - -> Block<'a, 'tcx> { - self.new_block(false, name, Some(node_id)) -} + pub fn new_id_block(&'a self, + name: &str, + node_id: ast::NodeId) + -> Block<'a, 'tcx> { + self.new_block(false, name, Some(node_id)) + } -pub fn new_temp_block(&'a self, - name: &str) - -> Block<'a, 'tcx> { - self.new_block(false, name, None) -} + pub fn new_temp_block(&'a self, + name: &str) + -> Block<'a, 'tcx> { + self.new_block(false, name, None) + } -pub fn join_blocks(&'a self, - id: ast::NodeId, - in_cxs: &[Block<'a, 'tcx>]) - -> Block<'a, 'tcx> { - let out = self.new_id_block("join", id); - let mut reachable = false; - for bcx in in_cxs.iter() { - if !bcx.unreachable.get() { - build::Br(*bcx, out.llbb); - reachable = true; + pub fn join_blocks(&'a self, + id: ast::NodeId, + in_cxs: &[Block<'a, 'tcx>]) + -> Block<'a, 'tcx> { + let out = self.new_id_block("join", id); + let mut reachable = false; + for bcx in in_cxs.iter() { + if !bcx.unreachable.get() { + build::Br(*bcx, out.llbb); + reachable = true; + } } + if !reachable { + build::Unreachable(out); + } + return out; } - if !reachable { - build::Unreachable(out); - } - return out; -} -pub fn monomorphize<T>(&self, value: &T) -> T - where T : TypeFoldable<'tcx> + Repr<'tcx> + HasProjectionTypes + Clone -{ - monomorphize::apply_param_substs(self.ccx.tcx(), - self.param_substs, - value) -} + pub fn monomorphize<T>(&self, value: &T) -> T + where T : TypeFoldable<'tcx> + Repr<'tcx> + HasProjectionTypes + Clone + { + monomorphize::apply_param_substs(self.ccx.tcx(), + self.param_substs, + value) + } } // Basic block context. We create a block context for each basic block @@ -542,277 +542,277 @@ pub fn monomorphize<T>(&self, value: &T) -> T // with many basic blocks per function. All the basic blocks attached to a // function are organized as a directed graph. pub struct BlockS<'blk, 'tcx: 'blk> { -// The BasicBlockRef returned from a call to -// llvm::LLVMAppendBasicBlock(llfn, name), which adds a basic -// block to the function pointed to by llfn. We insert -// instructions into that block by way of this block context. -// The block pointing to this one in the function's digraph. -pub llbb: BasicBlockRef, -pub terminated: Cell<bool>, -pub unreachable: Cell<bool>, + // The BasicBlockRef returned from a call to + // llvm::LLVMAppendBasicBlock(llfn, name), which adds a basic + // block to the function pointed to by llfn. We insert + // instructions into that block by way of this block context. + // The block pointing to this one in the function's digraph. + pub llbb: BasicBlockRef, + pub terminated: Cell<bool>, + pub unreachable: Cell<bool>, -// Is this block part of a landing pad? -pub is_lpad: bool, + // Is this block part of a landing pad? + pub is_lpad: bool, -// AST node-id associated with this block, if any. Used for -// debugging purposes only. -pub opt_node_id: Option<ast::NodeId>, + // AST node-id associated with this block, if any. Used for + // debugging purposes only. + pub opt_node_id: Option<ast::NodeId>, -// The function context for the function to which this block is -// attached. -pub fcx: &'blk FunctionContext<'blk, 'tcx>, + // The function context for the function to which this block is + // attached. + pub fcx: &'blk FunctionContext<'blk, 'tcx>, } pub type Block<'blk, 'tcx> = &'blk BlockS<'blk, 'tcx>; impl<'blk, 'tcx> BlockS<'blk, 'tcx> { -pub fn new(llbb: BasicBlockRef, - is_lpad: bool, - opt_node_id: Option<ast::NodeId>, - fcx: &'blk FunctionContext<'blk, 'tcx>) - -> Block<'blk, 'tcx> { - fcx.block_arena.alloc(BlockS { - llbb: llbb, - terminated: Cell::new(false), - unreachable: Cell::new(false), - is_lpad: is_lpad, - opt_node_id: opt_node_id, - fcx: fcx - }) -} + pub fn new(llbb: BasicBlockRef, + is_lpad: bool, + opt_node_id: Option<ast::NodeId>, + fcx: &'blk FunctionContext<'blk, 'tcx>) + -> Block<'blk, 'tcx> { + fcx.block_arena.alloc(BlockS { + llbb: llbb, + terminated: Cell::new(false), + unreachable: Cell::new(false), + is_lpad: is_lpad, + opt_node_id: opt_node_id, + fcx: fcx + }) + } -pub fn ccx(&self) -> &'blk CrateContext<'blk, 'tcx> { - self.fcx.ccx -} -pub fn tcx(&self) -> &'blk ty::ctxt<'tcx> { - self.fcx.ccx.tcx() -} -pub fn sess(&self) -> &'blk Session { self.fcx.ccx.sess() } + pub fn ccx(&self) -> &'blk CrateContext<'blk, 'tcx> { + self.fcx.ccx + } + pub fn tcx(&self) -> &'blk ty::ctxt<'tcx> { + self.fcx.ccx.tcx() + } + pub fn sess(&self) -> &'blk Session { self.fcx.ccx.sess() } -pub fn ident(&self, ident: Ident) -> String { - token::get_ident(ident).get().to_string() -} + pub fn ident(&self, ident: Ident) -> String { + token::get_ident(ident).get().to_string() + } -pub fn node_id_to_string(&self, id: ast::NodeId) -> String { - self.tcx().map.node_to_string(id).to_string() -} + pub fn node_id_to_string(&self, id: ast::NodeId) -> String { + self.tcx().map.node_to_string(id).to_string() + } -pub fn expr_to_string(&self, e: &ast::Expr) -> String { - e.repr(self.tcx()) -} + pub fn expr_to_string(&self, e: &ast::Expr) -> String { + e.repr(self.tcx()) + } -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)[]); + 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)[]); + } } } -} -pub fn val_to_string(&self, val: ValueRef) -> String { - self.ccx().tn().val_to_string(val) -} + pub fn val_to_string(&self, val: ValueRef) -> String { + self.ccx().tn().val_to_string(val) + } -pub fn llty_str(&self, ty: Type) -> String { - self.ccx().tn().type_to_string(ty) -} + pub fn llty_str(&self, ty: Type) -> String { + self.ccx().tn().type_to_string(ty) + } -pub fn ty_to_string(&self, t: Ty<'tcx>) -> String { - t.repr(self.tcx()) -} + pub fn ty_to_string(&self, t: Ty<'tcx>) -> String { + t.repr(self.tcx()) + } -pub fn to_str(&self) -> String { - format!("[block {:p}]", self) -} + pub fn to_str(&self) -> String { + format!("[block {:p}]", self) + } -pub fn monomorphize<T>(&self, value: &T) -> T - where T : TypeFoldable<'tcx> + Repr<'tcx> + HasProjectionTypes + Clone -{ - monomorphize::apply_param_substs(self.tcx(), - self.fcx.param_substs, - value) -} + pub fn monomorphize<T>(&self, value: &T) -> T + where T : TypeFoldable<'tcx> + Repr<'tcx> + HasProjectionTypes + Clone + { + monomorphize::apply_param_substs(self.tcx(), + self.fcx.param_substs, + value) + } } impl<'blk, 'tcx> mc::Typer<'tcx> for BlockS<'blk, 'tcx> { -fn tcx<'a>(&'a self) -> &'a ty::ctxt<'tcx> { - self.tcx() -} + fn tcx<'a>(&'a self) -> &'a ty::ctxt<'tcx> { + self.tcx() + } -fn node_ty(&self, id: ast::NodeId) -> mc::McResult<Ty<'tcx>> { - Ok(node_id_type(self, id)) -} + fn node_ty(&self, id: ast::NodeId) -> mc::McResult<Ty<'tcx>> { + Ok(node_id_type(self, id)) + } -fn expr_ty_adjusted(&self, expr: &ast::Expr) -> mc::McResult<Ty<'tcx>> { - Ok(expr_ty_adjusted(self, expr)) -} + fn expr_ty_adjusted(&self, expr: &ast::Expr) -> mc::McResult<Ty<'tcx>> { + Ok(expr_ty_adjusted(self, expr)) + } -fn node_method_ty(&self, method_call: ty::MethodCall) -> Option<Ty<'tcx>> { - self.tcx() - .method_map - .borrow() - .get(&method_call) - .map(|method| monomorphize_type(self, method.ty)) -} + fn node_method_ty(&self, method_call: ty::MethodCall) -> Option<Ty<'tcx>> { + self.tcx() + .method_map + .borrow() + .get(&method_call) + .map(|method| monomorphize_type(self, method.ty)) + } -fn node_method_origin(&self, method_call: ty::MethodCall) - -> Option<ty::MethodOrigin<'tcx>> -{ - self.tcx() - .method_map - .borrow() - .get(&method_call) - .map(|method| method.origin.clone()) -} + fn node_method_origin(&self, method_call: ty::MethodCall) + -> Option<ty::MethodOrigin<'tcx>> + { + self.tcx() + .method_map + .borrow() + .get(&method_call) + .map(|method| method.origin.clone()) + } -fn adjustments<'a>(&'a self) -> &'a RefCell<NodeMap<ty::AutoAdjustment<'tcx>>> { - &self.tcx().adjustments -} + fn adjustments<'a>(&'a self) -> &'a RefCell<NodeMap<ty::AutoAdjustment<'tcx>>> { + &self.tcx().adjustments + } -fn is_method_call(&self, id: ast::NodeId) -> bool { - self.tcx().method_map.borrow().contains_key(&ty::MethodCall::expr(id)) -} + fn is_method_call(&self, id: ast::NodeId) -> bool { + self.tcx().method_map.borrow().contains_key(&ty::MethodCall::expr(id)) + } -fn temporary_scope(&self, rvalue_id: ast::NodeId) -> Option<region::CodeExtent> { - self.tcx().region_maps.temporary_scope(rvalue_id) -} + fn temporary_scope(&self, rvalue_id: ast::NodeId) -> Option<region::CodeExtent> { + self.tcx().region_maps.temporary_scope(rvalue_id) + } -fn upvar_borrow(&self, upvar_id: ty::UpvarId) -> Option<ty::UpvarBorrow> { - Some(self.tcx().upvar_borrow_map.borrow()[upvar_id].clone()) -} + fn upvar_borrow(&self, upvar_id: ty::UpvarId) -> Option<ty::UpvarBorrow> { + Some(self.tcx().upvar_borrow_map.borrow()[upvar_id].clone()) + } -fn capture_mode(&self, closure_expr_id: ast::NodeId) - -> ast::CaptureClause { - self.tcx().capture_modes.borrow()[closure_expr_id].clone() -} + fn capture_mode(&self, closure_expr_id: ast::NodeId) + -> ast::CaptureClause { + self.tcx().capture_modes.borrow()[closure_expr_id].clone() + } -fn type_moves_by_default(&self, span: Span, ty: Ty<'tcx>) -> bool { - self.fcx.param_env.type_moves_by_default(span, ty) -} + fn type_moves_by_default(&self, span: Span, ty: Ty<'tcx>) -> bool { + self.fcx.param_env.type_moves_by_default(span, ty) + } } impl<'blk, 'tcx> ty::UnboxedClosureTyper<'tcx> for BlockS<'blk, 'tcx> { -fn param_env<'a>(&'a self) -> &'a ty::ParameterEnvironment<'a, 'tcx> { - &self.fcx.param_env -} + fn param_env<'a>(&'a self) -> &'a ty::ParameterEnvironment<'a, 'tcx> { + &self.fcx.param_env + } -fn unboxed_closure_kind(&self, - def_id: ast::DefId) - -> ty::UnboxedClosureKind -{ - let typer = NormalizingUnboxedClosureTyper::new(self.tcx()); - typer.unboxed_closure_kind(def_id) -} + fn unboxed_closure_kind(&self, + def_id: ast::DefId) + -> ty::UnboxedClosureKind + { + let typer = NormalizingUnboxedClosureTyper::new(self.tcx()); + typer.unboxed_closure_kind(def_id) + } -fn unboxed_closure_type(&self, - def_id: ast::DefId, - substs: &subst::Substs<'tcx>) - -> ty::ClosureTy<'tcx> -{ - let typer = NormalizingUnboxedClosureTyper::new(self.tcx()); - typer.unboxed_closure_type(def_id, substs) -} + fn unboxed_closure_type(&self, + def_id: ast::DefId, + substs: &subst::Substs<'tcx>) + -> ty::ClosureTy<'tcx> + { + let typer = NormalizingUnboxedClosureTyper::new(self.tcx()); + typer.unboxed_closure_type(def_id, substs) + } -fn unboxed_closure_upvars(&self, - def_id: ast::DefId, - substs: &Substs<'tcx>) - -> Option<Vec<ty::UnboxedClosureUpvar<'tcx>>> -{ - let typer = NormalizingUnboxedClosureTyper::new(self.tcx()); - typer.unboxed_closure_upvars(def_id, substs) -} + fn unboxed_closure_upvars(&self, + def_id: ast::DefId, + substs: &Substs<'tcx>) + -> Option<Vec<ty::UnboxedClosureUpvar<'tcx>>> + { + let typer = NormalizingUnboxedClosureTyper::new(self.tcx()); + typer.unboxed_closure_upvars(def_id, substs) + } } pub struct Result<'blk, 'tcx: 'blk> { -pub bcx: Block<'blk, 'tcx>, -pub val: ValueRef + pub bcx: Block<'blk, 'tcx>, + pub val: ValueRef } impl<'b, 'tcx> Result<'b, 'tcx> { -pub fn new(bcx: Block<'b, 'tcx>, val: ValueRef) -> Result<'b, 'tcx> { - Result { - bcx: bcx, - val: val, + pub fn new(bcx: Block<'b, 'tcx>, val: ValueRef) -> Result<'b, 'tcx> { + Result { + bcx: bcx, + val: val, + } } } -} pub fn val_ty(v: ValueRef) -> Type { -unsafe { - Type::from_ref(llvm::LLVMTypeOf(v)) -} + unsafe { + Type::from_ref(llvm::LLVMTypeOf(v)) + } } // LLVM constant constructors. pub fn C_null(t: Type) -> ValueRef { -unsafe { - llvm::LLVMConstNull(t.to_ref()) -} + unsafe { + llvm::LLVMConstNull(t.to_ref()) + } } pub fn C_undef(t: Type) -> ValueRef { -unsafe { - llvm::LLVMGetUndef(t.to_ref()) -} + unsafe { + llvm::LLVMGetUndef(t.to_ref()) + } } pub fn C_integral(t: Type, u: u64, sign_extend: bool) -> ValueRef { -unsafe { - llvm::LLVMConstInt(t.to_ref(), u, sign_extend as Bool) -} + unsafe { + llvm::LLVMConstInt(t.to_ref(), u, sign_extend as Bool) + } } pub fn C_floating(s: &str, t: Type) -> ValueRef { -unsafe { - let s = CString::from_slice(s.as_bytes()); - llvm::LLVMConstRealOfString(t.to_ref(), s.as_ptr()) -} + unsafe { + let s = CString::from_slice(s.as_bytes()); + llvm::LLVMConstRealOfString(t.to_ref(), s.as_ptr()) + } } pub fn C_nil(ccx: &CrateContext) -> ValueRef { -C_struct(ccx, &[], false) + C_struct(ccx, &[], false) } pub fn C_bool(ccx: &CrateContext, val: bool) -> ValueRef { -C_integral(Type::i1(ccx), val as u64, false) + C_integral(Type::i1(ccx), val as u64, false) } pub fn C_i32(ccx: &CrateContext, i: i32) -> ValueRef { -C_integral(Type::i32(ccx), i as u64, true) + C_integral(Type::i32(ccx), i as u64, true) } pub fn C_i64(ccx: &CrateContext, i: i64) -> ValueRef { -C_integral(Type::i64(ccx), i as u64, true) + C_integral(Type::i64(ccx), i as u64, true) } pub fn C_u64(ccx: &CrateContext, i: u64) -> ValueRef { -C_integral(Type::i64(ccx), i, false) + C_integral(Type::i64(ccx), i, false) } pub fn C_int<I: AsI64>(ccx: &CrateContext, i: I) -> ValueRef { -let v = i.as_i64(); + let v = i.as_i64(); -match machine::llbitsize_of_real(ccx, ccx.int_type()) { - 32 => assert!(v < (1<<31) && v >= -(1<<31)), - 64 => {}, - n => panic!("unsupported target size: {}", n) -} + match machine::llbitsize_of_real(ccx, ccx.int_type()) { + 32 => assert!(v < (1<<31) && v >= -(1<<31)), + 64 => {}, + n => panic!("unsupported target size: {}", n) + } -C_integral(ccx.int_type(), v as u64, true) + C_integral(ccx.int_type(), v as u64, true) } pub fn C_uint<I: AsU64>(ccx: &CrateContext, i: I) -> ValueRef { -let v = i.as_u64(); + let v = i.as_u64(); -match machine::llbitsize_of_real(ccx, ccx.int_type()) { - 32 => assert!(v < (1<<32)), - 64 => {}, - n => panic!("unsupported target size: {}", n) -} + match machine::llbitsize_of_real(ccx, ccx.int_type()) { + 32 => assert!(v < (1<<32)), + 64 => {}, + n => panic!("unsupported target size: {}", n) + } -C_integral(ccx.int_type(), v, false) + C_integral(ccx.int_type(), v, false) } pub trait AsI64 { fn as_i64(self) -> i64; } @@ -829,157 +829,157 @@ impl AsU64 for u32 { fn as_u64(self) -> u64 { self as u64 }} impl AsU64 for uint { fn as_u64(self) -> u64 { self as u64 }} pub fn C_u8(ccx: &CrateContext, i: uint) -> ValueRef { -C_integral(Type::i8(ccx), i as u64, false) + C_integral(Type::i8(ccx), i as u64, false) } // This is a 'c-like' raw string, which differs from // our boxed-and-length-annotated strings. pub fn C_cstr(cx: &CrateContext, s: InternedString, null_terminated: bool) -> ValueRef { -unsafe { - match cx.const_cstr_cache().borrow().get(&s) { - Some(&llval) => return llval, - None => () - } + unsafe { + match cx.const_cstr_cache().borrow().get(&s) { + Some(&llval) => return llval, + None => () + } - let sc = llvm::LLVMConstStringInContext(cx.llcx(), - s.get().as_ptr() as *const c_char, - s.get().len() as c_uint, - !null_terminated as Bool); + let sc = llvm::LLVMConstStringInContext(cx.llcx(), + s.get().as_ptr() as *const c_char, + s.get().len() as c_uint, + !null_terminated as Bool); - let gsym = token::gensym("str"); - let buf = CString::from_vec(format!("str{}", gsym.uint()).into_bytes()); - let g = llvm::LLVMAddGlobal(cx.llmod(), val_ty(sc).to_ref(), buf.as_ptr()); - llvm::LLVMSetInitializer(g, sc); - llvm::LLVMSetGlobalConstant(g, True); - llvm::SetLinkage(g, llvm::InternalLinkage); + let gsym = token::gensym("str"); + let buf = CString::from_vec(format!("str{}", gsym.uint()).into_bytes()); + let g = llvm::LLVMAddGlobal(cx.llmod(), val_ty(sc).to_ref(), buf.as_ptr()); + llvm::LLVMSetInitializer(g, sc); + llvm::LLVMSetGlobalConstant(g, True); + llvm::SetLinkage(g, llvm::InternalLinkage); - cx.const_cstr_cache().borrow_mut().insert(s, g); - g -} + cx.const_cstr_cache().borrow_mut().insert(s, g); + g + } } // NB: Do not use `do_spill_noroot` to make this into a constant string, or // you will be kicked off fast isel. See issue #4352 for an example of this. pub fn C_str_slice(cx: &CrateContext, s: InternedString) -> ValueRef { -let len = s.get().len(); -let cs = consts::ptrcast(C_cstr(cx, s, false), Type::i8p(cx)); -C_named_struct(cx.tn().find_type("str_slice").unwrap(), &[cs, C_uint(cx, len)]) + let len = s.get().len(); + let cs = consts::ptrcast(C_cstr(cx, s, false), Type::i8p(cx)); + C_named_struct(cx.tn().find_type("str_slice").unwrap(), &[cs, C_uint(cx, len)]) } pub fn C_binary_slice(cx: &CrateContext, data: &[u8]) -> ValueRef { -unsafe { - let len = data.len(); - let lldata = C_bytes(cx, data); - - let gsym = token::gensym("binary"); - let name = format!("binary{}", gsym.uint()); - let name = CString::from_vec(name.into_bytes()); - let g = llvm::LLVMAddGlobal(cx.llmod(), val_ty(lldata).to_ref(), - name.as_ptr()); - llvm::LLVMSetInitializer(g, lldata); - llvm::LLVMSetGlobalConstant(g, True); - llvm::SetLinkage(g, llvm::InternalLinkage); - - let cs = consts::ptrcast(g, Type::i8p(cx)); - C_struct(cx, &[cs, C_uint(cx, len)], false) -} + unsafe { + let len = data.len(); + let lldata = C_bytes(cx, data); + + let gsym = token::gensym("binary"); + let name = format!("binary{}", gsym.uint()); + let name = CString::from_vec(name.into_bytes()); + let g = llvm::LLVMAddGlobal(cx.llmod(), val_ty(lldata).to_ref(), + name.as_ptr()); + llvm::LLVMSetInitializer(g, lldata); + llvm::LLVMSetGlobalConstant(g, True); + llvm::SetLinkage(g, llvm::InternalLinkage); + + let cs = consts::ptrcast(g, Type::i8p(cx)); + C_struct(cx, &[cs, C_uint(cx, len)], false) + } } pub fn C_struct(cx: &CrateContext, elts: &[ValueRef], packed: bool) -> ValueRef { -C_struct_in_context(cx.llcx(), elts, packed) + C_struct_in_context(cx.llcx(), elts, packed) } pub fn C_struct_in_context(llcx: ContextRef, elts: &[ValueRef], packed: bool) -> ValueRef { -unsafe { - llvm::LLVMConstStructInContext(llcx, - elts.as_ptr(), elts.len() as c_uint, - packed as Bool) -} + unsafe { + llvm::LLVMConstStructInContext(llcx, + elts.as_ptr(), elts.len() as c_uint, + packed as Bool) + } } pub fn C_named_struct(t: Type, elts: &[ValueRef]) -> ValueRef { -unsafe { - llvm::LLVMConstNamedStruct(t.to_ref(), elts.as_ptr(), elts.len() as c_uint) -} + unsafe { + llvm::LLVMConstNamedStruct(t.to_ref(), elts.as_ptr(), elts.len() as c_uint) + } } pub fn C_array(ty: Type, elts: &[ValueRef]) -> ValueRef { -unsafe { - return llvm::LLVMConstArray(ty.to_ref(), elts.as_ptr(), elts.len() as c_uint); -} + unsafe { + return llvm::LLVMConstArray(ty.to_ref(), elts.as_ptr(), elts.len() as c_uint); + } } pub fn C_bytes(cx: &CrateContext, bytes: &[u8]) -> ValueRef { -C_bytes_in_context(cx.llcx(), bytes) + C_bytes_in_context(cx.llcx(), bytes) } pub fn C_bytes_in_context(llcx: ContextRef, bytes: &[u8]) -> ValueRef { -unsafe { - let ptr = bytes.as_ptr() as *const c_char; - return llvm::LLVMConstStringInContext(llcx, ptr, bytes.len() as c_uint, True); -} + unsafe { + let ptr = bytes.as_ptr() as *const c_char; + return llvm::LLVMConstStringInContext(llcx, ptr, bytes.len() as c_uint, True); + } } pub fn const_get_elt(cx: &CrateContext, v: ValueRef, us: &[c_uint]) -> ValueRef { -unsafe { - let r = llvm::LLVMConstExtractValue(v, us.as_ptr(), us.len() as c_uint); + unsafe { + let r = llvm::LLVMConstExtractValue(v, us.as_ptr(), us.len() as c_uint); - debug!("const_get_elt(v={}, us={:?}, r={})", - cx.tn().val_to_string(v), us, cx.tn().val_to_string(r)); + debug!("const_get_elt(v={}, us={:?}, r={})", + cx.tn().val_to_string(v), us, cx.tn().val_to_string(r)); - return r; -} + return r; + } } pub fn is_const(v: ValueRef) -> bool { -unsafe { - llvm::LLVMIsConstant(v) == True -} + unsafe { + llvm::LLVMIsConstant(v) == True + } } pub fn const_to_int(v: ValueRef) -> i64 { -unsafe { - llvm::LLVMConstIntGetSExtValue(v) -} + unsafe { + llvm::LLVMConstIntGetSExtValue(v) + } } pub fn const_to_uint(v: ValueRef) -> u64 { -unsafe { - llvm::LLVMConstIntGetZExtValue(v) -} + unsafe { + llvm::LLVMConstIntGetZExtValue(v) + } } pub fn is_undef(val: ValueRef) -> bool { -unsafe { - llvm::LLVMIsUndef(val) != False -} + unsafe { + llvm::LLVMIsUndef(val) != False + } } #[allow(dead_code)] // potentially useful pub fn is_null(val: ValueRef) -> bool { -unsafe { - llvm::LLVMIsNull(val) != False -} + unsafe { + llvm::LLVMIsNull(val) != False + } } pub fn monomorphize_type<'blk, 'tcx>(bcx: &BlockS<'blk, 'tcx>, t: Ty<'tcx>) -> Ty<'tcx> { -bcx.fcx.monomorphize(&t) + bcx.fcx.monomorphize(&t) } pub fn node_id_type<'blk, 'tcx>(bcx: &BlockS<'blk, 'tcx>, id: ast::NodeId) -> Ty<'tcx> { -let tcx = bcx.tcx(); -let t = ty::node_id_to_type(tcx, id); -monomorphize_type(bcx, t) + let tcx = bcx.tcx(); + let t = ty::node_id_to_type(tcx, id); + monomorphize_type(bcx, t) } pub fn expr_ty<'blk, 'tcx>(bcx: &BlockS<'blk, 'tcx>, ex: &ast::Expr) -> Ty<'tcx> { -node_id_type(bcx, ex.id) + node_id_type(bcx, ex.id) } pub fn expr_ty_adjusted<'blk, 'tcx>(bcx: &BlockS<'blk, 'tcx>, ex: &ast::Expr) -> Ty<'tcx> { -monomorphize_type(bcx, ty::expr_ty_adjusted(bcx.tcx(), ex)) + monomorphize_type(bcx, ty::expr_ty_adjusted(bcx.tcx(), ex)) } /// Attempts to resolve an obligation. The result is a shallow vtable resolution -- meaning that we @@ -990,117 +990,117 @@ pub fn fulfill_obligation<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, trait_ref: ty::PolyTraitRef<'tcx>) -> traits::Vtable<'tcx, ()> { -let tcx = ccx.tcx(); - -// Remove any references to regions; this helps improve caching. -let trait_ref = erase_regions(tcx, &trait_ref); - -// First check the cache. -match ccx.trait_cache().borrow().get(&trait_ref) { - Some(vtable) => { - info!("Cache hit: {}", trait_ref.repr(ccx.tcx())); - return (*vtable).clone(); - } - None => { } -} - -debug!("trans fulfill_obligation: trait_ref={}", trait_ref.repr(ccx.tcx())); - -ty::populate_implementations_for_trait_if_necessary(tcx, trait_ref.def_id()); -let infcx = infer::new_infer_ctxt(tcx); - -// Do the initial selection for the obligation. This yields the -// shallow result we are looking for -- that is, what specific impl. -let typer = NormalizingUnboxedClosureTyper::new(tcx); -let mut selcx = traits::SelectionContext::new(&infcx, &typer); -let obligation = traits::Obligation::new(traits::ObligationCause::dummy(), - trait_ref.to_poly_trait_predicate()); -let selection = match selcx.select(&obligation) { - Ok(Some(selection)) => selection, - Ok(None) => { - // Ambiguity can happen when monomorphizing during trans - // expands to some humongo type that never occurred - // statically -- this humongo type can then overflow, - // leading to an ambiguous result. So report this as an - // overflow bug, since I believe this is the only case - // where ambiguity can result. - debug!("Encountered ambiguity selecting `{}` during trans, \ - presuming due to overflow", - trait_ref.repr(tcx)); - ccx.sess().span_fatal( - span, - "reached the recursion limit during monomorphization"); - } - Err(e) => { - tcx.sess.span_bug( - span, - &format!("Encountered error `{}` selecting `{}` during trans", - e.repr(tcx), - trait_ref.repr(tcx))[]) - } -}; - -// Currently, we use a fulfillment context to completely resolve -// all nested obligations. This is because they can inform the -// inference of the impl's type parameters. -let mut fulfill_cx = traits::FulfillmentContext::new(); -let vtable = selection.map_move_nested(|predicate| { - fulfill_cx.register_predicate_obligation(&infcx, predicate); -}); -let vtable = drain_fulfillment_cx(span, &infcx, &mut fulfill_cx, &vtable); - -info!("Cache miss: {}", trait_ref.repr(ccx.tcx())); -ccx.trait_cache().borrow_mut().insert(trait_ref, - vtable.clone()); - -vtable + let tcx = ccx.tcx(); + + // Remove any references to regions; this helps improve caching. + let trait_ref = erase_regions(tcx, &trait_ref); + + // First check the cache. + match ccx.trait_cache().borrow().get(&trait_ref) { + Some(vtable) => { + info!("Cache hit: {}", trait_ref.repr(ccx.tcx())); + return (*vtable).clone(); + } + None => { } + } + + debug!("trans fulfill_obligation: trait_ref={}", trait_ref.repr(ccx.tcx())); + + ty::populate_implementations_for_trait_if_necessary(tcx, trait_ref.def_id()); + let infcx = infer::new_infer_ctxt(tcx); + + // Do the initial selection for the obligation. This yields the + // shallow result we are looking for -- that is, what specific impl. + let typer = NormalizingUnboxedClosureTyper::new(tcx); + let mut selcx = traits::SelectionContext::new(&infcx, &typer); + let obligation = traits::Obligation::new(traits::ObligationCause::dummy(), + trait_ref.to_poly_trait_predicate()); + let selection = match selcx.select(&obligation) { + Ok(Some(selection)) => selection, + Ok(None) => { + // Ambiguity can happen when monomorphizing during trans + // expands to some humongo type that never occurred + // statically -- this humongo type can then overflow, + // leading to an ambiguous result. So report this as an + // overflow bug, since I believe this is the only case + // where ambiguity can result. + debug!("Encountered ambiguity selecting `{}` during trans, \ + presuming due to overflow", + trait_ref.repr(tcx)); + ccx.sess().span_fatal( + span, + "reached the recursion limit during monomorphization"); + } + Err(e) => { + tcx.sess.span_bug( + span, + &format!("Encountered error `{}` selecting `{}` during trans", + e.repr(tcx), + trait_ref.repr(tcx))[]) + } + }; + + // Currently, we use a fulfillment context to completely resolve + // all nested obligations. This is because they can inform the + // inference of the impl's type parameters. + let mut fulfill_cx = traits::FulfillmentContext::new(); + let vtable = selection.map_move_nested(|predicate| { + fulfill_cx.register_predicate_obligation(&infcx, predicate); + }); + let vtable = drain_fulfillment_cx(span, &infcx, &mut fulfill_cx, &vtable); + + info!("Cache miss: {}", trait_ref.repr(ccx.tcx())); + ccx.trait_cache().borrow_mut().insert(trait_ref, + vtable.clone()); + + vtable } pub struct NormalizingUnboxedClosureTyper<'a,'tcx:'a> { -param_env: ty::ParameterEnvironment<'a, 'tcx> + param_env: ty::ParameterEnvironment<'a, 'tcx> } impl<'a,'tcx> NormalizingUnboxedClosureTyper<'a,'tcx> { -pub fn new(tcx: &'a ty::ctxt<'tcx>) -> NormalizingUnboxedClosureTyper<'a,'tcx> { - // Parameter environment is used to give details about type parameters, - // but since we are in trans, everything is fully monomorphized. - NormalizingUnboxedClosureTyper { param_env: ty::empty_parameter_environment(tcx) } -} + pub fn new(tcx: &'a ty::ctxt<'tcx>) -> NormalizingUnboxedClosureTyper<'a,'tcx> { + // Parameter environment is used to give details about type parameters, + // but since we are in trans, everything is fully monomorphized. + NormalizingUnboxedClosureTyper { param_env: ty::empty_parameter_environment(tcx) } + } } impl<'a,'tcx> ty::UnboxedClosureTyper<'tcx> for NormalizingUnboxedClosureTyper<'a,'tcx> { -fn param_env<'b>(&'b self) -> &'b ty::ParameterEnvironment<'b,'tcx> { - &self.param_env -} + fn param_env<'b>(&'b self) -> &'b ty::ParameterEnvironment<'b,'tcx> { + &self.param_env + } -fn unboxed_closure_kind(&self, - def_id: ast::DefId) - -> ty::UnboxedClosureKind -{ - self.param_env.tcx.unboxed_closure_kind(def_id) -} + fn unboxed_closure_kind(&self, + def_id: ast::DefId) + -> ty::UnboxedClosureKind + { + self.param_env.tcx.unboxed_closure_kind(def_id) + } -fn unboxed_closure_type(&self, - def_id: ast::DefId, - substs: &subst::Substs<'tcx>) - -> ty::ClosureTy<'tcx> -{ - // the substitutions in `substs` are already monomorphized, - // but we still must normalize associated types - let closure_ty = self.param_env.tcx.unboxed_closure_type(def_id, substs); - monomorphize::normalize_associated_type(self.param_env.tcx, &closure_ty) -} + fn unboxed_closure_type(&self, + def_id: ast::DefId, + substs: &subst::Substs<'tcx>) + -> ty::ClosureTy<'tcx> + { + // the substitutions in `substs` are already monomorphized, + // but we still must normalize associated types + let closure_ty = self.param_env.tcx.unboxed_closure_type(def_id, substs); + monomorphize::normalize_associated_type(self.param_env.tcx, &closure_ty) + } -fn unboxed_closure_upvars(&self, - def_id: ast::DefId, - substs: &Substs<'tcx>) - -> Option<Vec<ty::UnboxedClosureUpvar<'tcx>>> -{ - // the substitutions in `substs` are already monomorphized, - // but we still must normalize associated types - let result = ty::unboxed_closure_upvars(&self.param_env, def_id, substs); - monomorphize::normalize_associated_type(self.param_env.tcx, &result) -} + fn unboxed_closure_upvars(&self, + def_id: ast::DefId, + substs: &Substs<'tcx>) + -> Option<Vec<ty::UnboxedClosureUpvar<'tcx>>> + { + // the substitutions in `substs` are already monomorphized, + // but we still must normalize associated types + let result = ty::unboxed_closure_upvars(&self.param_env, def_id, substs); + monomorphize::normalize_associated_type(self.param_env.tcx, &result) + } } pub fn drain_fulfillment_cx<'a,'tcx,T>(span: Span, @@ -1108,73 +1108,73 @@ pub fn drain_fulfillment_cx<'a,'tcx,T>(span: Span, fulfill_cx: &mut traits::FulfillmentContext<'tcx>, result: &T) -> T -where T : TypeFoldable<'tcx> + Repr<'tcx> + where T : TypeFoldable<'tcx> + Repr<'tcx> { -debug!("drain_fulfillment_cx(result={})", - result.repr(infcx.tcx)); - -// In principle, we only need to do this so long as `result` -// contains unbound type parameters. It could be a slight -// optimization to stop iterating early. -let typer = NormalizingUnboxedClosureTyper::new(infcx.tcx); -match fulfill_cx.select_all_or_error(infcx, &typer) { - Ok(()) => { } - Err(errors) => { - if errors.iter().all(|e| e.is_overflow()) { - // See Ok(None) case above. - infcx.tcx.sess.span_fatal( - span, - "reached the recursion limit during monomorphization"); - } else { - infcx.tcx.sess.span_bug( - span, - &format!("Encountered errors `{}` fulfilling during trans", - errors.repr(infcx.tcx))[]); + debug!("drain_fulfillment_cx(result={})", + result.repr(infcx.tcx)); + + // In principle, we only need to do this so long as `result` + // contains unbound type parameters. It could be a slight + // optimization to stop iterating early. + let typer = NormalizingUnboxedClosureTyper::new(infcx.tcx); + match fulfill_cx.select_all_or_error(infcx, &typer) { + Ok(()) => { } + Err(errors) => { + if errors.iter().all(|e| e.is_overflow()) { + // See Ok(None) case above. + infcx.tcx.sess.span_fatal( + span, + "reached the recursion limit during monomorphization"); + } else { + infcx.tcx.sess.span_bug( + span, + &format!("Encountered errors `{}` fulfilling during trans", + errors.repr(infcx.tcx))[]); + } } } -} -// Use freshen to simultaneously replace all type variables with -// their bindings and replace all regions with 'static. This is -// sort of overkill because we do not expect there to be any -// unbound type variables, hence no `TyFresh` types should ever be -// inserted. -result.fold_with(&mut infcx.freshener()) + // Use freshen to simultaneously replace all type variables with + // their bindings and replace all regions with 'static. This is + // sort of overkill because we do not expect there to be any + // unbound type variables, hence no `TyFresh` types should ever be + // inserted. + result.fold_with(&mut infcx.freshener()) } // Key used to lookup values supplied for type parameters in an expr. #[derive(Copy, PartialEq, Show)] pub enum ExprOrMethodCall { -// Type parameters for a path like `None::<int>` -ExprId(ast::NodeId), + // Type parameters for a path like `None::<int>` + ExprId(ast::NodeId), -// Type parameters for a method call like `a.foo::<int>()` -MethodCallKey(ty::MethodCall) + // Type parameters for a method call like `a.foo::<int>()` + MethodCallKey(ty::MethodCall) } pub fn node_id_substs<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, node: ExprOrMethodCall, param_substs: &subst::Substs<'tcx>) -> subst::Substs<'tcx> { -let tcx = ccx.tcx(); + let tcx = ccx.tcx(); -let substs = match node { - ExprId(id) => { - ty::node_id_item_substs(tcx, id).substs - } - MethodCallKey(method_call) => { - (*tcx.method_map.borrow())[method_call].substs.clone() - } -}; + let substs = match node { + ExprId(id) => { + ty::node_id_item_substs(tcx, id).substs + } + MethodCallKey(method_call) => { + (*tcx.method_map.borrow())[method_call].substs.clone() + } + }; -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))[]); - } + 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))[]); + } - monomorphize::apply_param_substs(tcx, - param_substs, - &substs.erase_regions()) + monomorphize::apply_param_substs(tcx, + param_substs, + &substs.erase_regions()) } pub fn langcall(bcx: Block, diff --git a/src/librustc_trans/trans/debuginfo.rs b/src/librustc_trans/trans/debuginfo.rs index 3a6f4b47e4e..2f58baab7fc 100644 --- a/src/librustc_trans/trans/debuginfo.rs +++ b/src/librustc_trans/trans/debuginfo.rs @@ -1804,14 +1804,14 @@ fn basic_type_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, ty::ty_bool => ("bool".to_string(), DW_ATE_boolean), ty::ty_char => ("char".to_string(), DW_ATE_unsigned_char), ty::ty_int(int_ty) => match int_ty { - ast::TyIs => ("isize".to_string(), DW_ATE_signed), + ast::TyIs(_) => ("isize".to_string(), DW_ATE_signed), ast::TyI8 => ("i8".to_string(), DW_ATE_signed), ast::TyI16 => ("i16".to_string(), DW_ATE_signed), ast::TyI32 => ("i32".to_string(), DW_ATE_signed), ast::TyI64 => ("i64".to_string(), DW_ATE_signed) }, ty::ty_uint(uint_ty) => match uint_ty { - ast::TyUs => ("usize".to_string(), DW_ATE_unsigned), + ast::TyUs(_) => ("usize".to_string(), DW_ATE_unsigned), ast::TyU8 => ("u8".to_string(), DW_ATE_unsigned), ast::TyU16 => ("u16".to_string(), DW_ATE_unsigned), ast::TyU32 => ("u32".to_string(), DW_ATE_unsigned), @@ -3739,12 +3739,12 @@ fn push_debuginfo_type_name<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, ty::ty_bool => output.push_str("bool"), ty::ty_char => output.push_str("char"), ty::ty_str => output.push_str("str"), - ty::ty_int(ast::TyIs) => output.push_str("isize"), + ty::ty_int(ast::TyIs(_)) => output.push_str("isize"), ty::ty_int(ast::TyI8) => output.push_str("i8"), ty::ty_int(ast::TyI16) => output.push_str("i16"), ty::ty_int(ast::TyI32) => output.push_str("i32"), ty::ty_int(ast::TyI64) => output.push_str("i64"), - ty::ty_uint(ast::TyUs) => output.push_str("usize"), + ty::ty_uint(ast::TyUs(_)) => output.push_str("usize"), ty::ty_uint(ast::TyU8) => output.push_str("u8"), ty::ty_uint(ast::TyU16) => output.push_str("u16"), ty::ty_uint(ast::TyU32) => output.push_str("u32"), diff --git a/src/librustc_trans/trans/type_.rs b/src/librustc_trans/trans/type_.rs index e2ed275d4c0..71a7789eb39 100644 --- a/src/librustc_trans/trans/type_.rs +++ b/src/librustc_trans/trans/type_.rs @@ -112,7 +112,7 @@ impl Type { pub fn int_from_ty(ccx: &CrateContext, t: ast::IntTy) -> Type { match t { - ast::TyIs => ccx.int_type(), + ast::TyIs(_) => ccx.int_type(), ast::TyI8 => Type::i8(ccx), ast::TyI16 => Type::i16(ccx), ast::TyI32 => Type::i32(ccx), @@ -122,7 +122,7 @@ impl Type { pub fn uint_from_ty(ccx: &CrateContext, t: ast::UintTy) -> Type { match t { - ast::TyUs => ccx.int_type(), + ast::TyUs(_) => ccx.int_type(), ast::TyU8 => Type::i8(ccx), ast::TyU16 => Type::i16(ccx), ast::TyU32 => Type::i32(ccx), diff --git a/src/librustc_trans/trans/type_of.rs b/src/librustc_trans/trans/type_of.rs index 034a1ee8be5..99330797422 100644 --- a/src/librustc_trans/trans/type_of.rs +++ b/src/librustc_trans/trans/type_of.rs @@ -263,7 +263,7 @@ pub fn type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> Type { } match unsized_part_of_type(cx.tcx(), t).sty { - ty::ty_str | ty::ty_vec(..) => Type::uint_from_ty(cx, ast::TyUs), + ty::ty_str | ty::ty_vec(..) => Type::uint_from_ty(cx, ast::TyUs(false)), ty::ty_trait(_) => Type::vtable_ptr(cx), _ => panic!("Unexpected type returned from unsized_part_of_type : {}", t.repr(cx.tcx())) diff --git a/src/librustc_typeck/check/callee.rs b/src/librustc_typeck/check/callee.rs index dff216ac293..19a88dfc553 100644 --- a/src/librustc_typeck/check/callee.rs +++ b/src/librustc_typeck/check/callee.rs @@ -73,7 +73,7 @@ pub fn check_call<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, autoderef(fcx, callee_expr.span, original_callee_ty, - Some(callee_expr.id), + Some(callee_expr), LvaluePreference::NoPreference, |adj_ty, idx| { let autoderefref = ty::AutoDerefRef { autoderefs: idx, autoref: None }; diff --git a/src/librustc_typeck/check/method/confirm.rs b/src/librustc_typeck/check/method/confirm.rs index 7e72f300f41..79460774859 100644 --- a/src/librustc_typeck/check/method/confirm.rs +++ b/src/librustc_typeck/check/method/confirm.rs @@ -143,7 +143,7 @@ impl<'a,'tcx> ConfirmContext<'a,'tcx> { // time writing the results into the various tables. let (autoderefd_ty, n, result) = check::autoderef( - self.fcx, self.span, unadjusted_self_ty, Some(self.self_expr.id), NoPreference, + self.fcx, self.span, unadjusted_self_ty, Some(self.self_expr), NoPreference, |_, n| if n == auto_deref_ref.autoderefs { Some(()) } else { None }); assert_eq!(n, auto_deref_ref.autoderefs); assert_eq!(result, Some(())); @@ -492,7 +492,7 @@ impl<'a,'tcx> ConfirmContext<'a,'tcx> { exprs.repr(self.tcx())); // Fix up autoderefs and derefs. - for (i, expr) in exprs.iter().rev().enumerate() { + for (i, &expr) in exprs.iter().rev().enumerate() { // Count autoderefs. let autoderef_count = match self.fcx .inh @@ -512,8 +512,8 @@ impl<'a,'tcx> ConfirmContext<'a,'tcx> { if autoderef_count > 0 { check::autoderef(self.fcx, expr.span, - self.fcx.expr_ty(*expr), - Some(expr.id), + self.fcx.expr_ty(expr), + Some(expr), PreferMutLvalue, |_, autoderefs| { if autoderefs == autoderef_count + 1 { @@ -567,7 +567,7 @@ impl<'a,'tcx> ConfirmContext<'a,'tcx> { let result = check::try_index_step( self.fcx, MethodCall::expr(expr.id), - *expr, + expr, &**base_expr, adjusted_base_ty, base_adjustment, @@ -577,7 +577,7 @@ impl<'a,'tcx> ConfirmContext<'a,'tcx> { if let Some((input_ty, return_ty)) = result { demand::suptype(self.fcx, index_expr.span, input_ty, index_expr_ty); - let expr_ty = self.fcx.expr_ty(&**expr); + let expr_ty = self.fcx.expr_ty(&*expr); demand::suptype(self.fcx, expr.span, expr_ty, return_ty); } } diff --git a/src/librustc_typeck/check/method/mod.rs b/src/librustc_typeck/check/method/mod.rs index bb000742def..0c53a16a811 100644 --- a/src/librustc_typeck/check/method/mod.rs +++ b/src/librustc_typeck/check/method/mod.rs @@ -102,9 +102,9 @@ pub fn lookup<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, Ok(confirm::confirm(fcx, span, self_expr, call_expr, self_ty, pick, supplied_method_types)) } -pub fn lookup_in_trait<'a, 'tcx>(fcx: &'a FnCtxt<'a, 'tcx>, +pub fn lookup_in_trait<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, span: Span, - self_expr: Option<&'a ast::Expr>, + self_expr: Option<&ast::Expr>, m_name: ast::Name, trait_def_id: DefId, self_ty: Ty<'tcx>, @@ -125,9 +125,9 @@ pub fn lookup_in_trait<'a, 'tcx>(fcx: &'a FnCtxt<'a, 'tcx>, /// method-lookup code. In particular, autoderef on index is basically identical to autoderef with /// normal probes, except that the test also looks for built-in indexing. Also, the second half of /// this method is basically the same as confirmation. -pub fn lookup_in_trait_adjusted<'a, 'tcx>(fcx: &'a FnCtxt<'a, 'tcx>, +pub fn lookup_in_trait_adjusted<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, span: Span, - self_expr: Option<&'a ast::Expr>, + self_expr: Option<&ast::Expr>, m_name: ast::Name, trait_def_id: DefId, autoderefref: ty::AutoDerefRef<'tcx>, diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index b98b327100c..1d184131ded 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -2268,12 +2268,17 @@ pub enum LvaluePreference { pub fn autoderef<'a, 'tcx, T, F>(fcx: &FnCtxt<'a, 'tcx>, sp: Span, base_ty: Ty<'tcx>, - expr_id: Option<ast::NodeId>, + opt_expr: Option<&ast::Expr>, mut lvalue_pref: LvaluePreference, mut should_stop: F) - -> (Ty<'tcx>, uint, Option<T>) where - F: FnMut(Ty<'tcx>, uint) -> Option<T>, + -> (Ty<'tcx>, uint, Option<T>) + where F: FnMut(Ty<'tcx>, uint) -> Option<T>, { + debug!("autoderef(base_ty={}, opt_expr={}, lvalue_pref={:?})", + base_ty.repr(fcx.tcx()), + opt_expr.repr(fcx.tcx()), + lvalue_pref); + let mut t = base_ty; for autoderefs in range(0, fcx.tcx().sess.recursion_limit.get()) { let resolved_t = structurally_resolved_type(fcx, sp, t); @@ -2291,7 +2296,19 @@ pub fn autoderef<'a, 'tcx, T, F>(fcx: &FnCtxt<'a, 'tcx>, let mt = match ty::deref(resolved_t, false) { Some(mt) => Some(mt), None => { - let method_call = expr_id.map(|id| MethodCall::autoderef(id, autoderefs)); + let method_call = opt_expr.map(|expr| MethodCall::autoderef(expr.id, autoderefs)); + + // Super subtle: it might seem as though we should + // pass `opt_expr` to `try_overloaded_deref`, so that + // the (implicit) autoref of using an overloaded deref + // would get added to the adjustment table. However we + // do not do that, because it's kind of a + // "meta-adjustment" -- instead, we just leave it + // unrecorded and know that there "will be" an + // autoref. regionck and other bits of the code base, + // when they encounter an overloaded autoderef, have + // to do some reconstructive surgery. This is a pretty + // complex mess that is begging for a proper MIR. try_overloaded_deref(fcx, sp, method_call, None, resolved_t, lvalue_pref) } }; @@ -2324,7 +2341,7 @@ fn try_overloaded_deref<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, // Try DerefMut first, if preferred. let method = match (lvalue_pref, fcx.tcx().lang_items.deref_mut_trait()) { (PreferMutLvalue, Some(trait_did)) => { - method::lookup_in_trait(fcx, span, base_expr.map(|x| &*x), + method::lookup_in_trait(fcx, span, base_expr, token::intern("deref_mut"), trait_did, base_ty, None) } @@ -2334,7 +2351,7 @@ fn try_overloaded_deref<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, // Otherwise, fall back to Deref. let method = match (method, fcx.tcx().lang_items.deref_trait()) { (None, Some(trait_did)) => { - method::lookup_in_trait(fcx, span, base_expr.map(|x| &*x), + method::lookup_in_trait(fcx, span, base_expr, token::intern("deref"), trait_did, base_ty, None) } @@ -2390,7 +2407,7 @@ fn autoderef_for_index<'a, 'tcx, T, F>(fcx: &FnCtxt<'a, 'tcx>, // consolidated. let (ty, autoderefs, final_mt) = - autoderef(fcx, base_expr.span, base_ty, Some(base_expr.id), lvalue_pref, |adj_ty, idx| { + autoderef(fcx, base_expr.span, base_ty, Some(base_expr), lvalue_pref, |adj_ty, idx| { let autoderefref = ty::AutoDerefRef { autoderefs: idx, autoref: None }; step(adj_ty, autoderefref) }); @@ -2442,7 +2459,7 @@ fn try_index_step<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, // First, try built-in indexing. match (ty::index(adjusted_ty), &index_ty.sty) { - (Some(ty), &ty::ty_uint(ast::TyUs)) | (Some(ty), &ty::ty_infer(ty::IntVar(_))) => { + (Some(ty), &ty::ty_uint(ast::TyUs(_))) | (Some(ty), &ty::ty_infer(ty::IntVar(_))) => { debug!("try_index_step: success, using built-in indexing"); fcx.write_adjustment(base_expr.id, base_expr.span, ty::AdjustDerefRef(adjustment)); return Some((tcx.types.uint, ty)); @@ -3208,8 +3225,24 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, if ty::type_is_integral(lhs_t) && ast_util::is_shift_binop(op) { // Shift is a special case: rhs must be uint, no matter what lhs is - check_expr_has_type(fcx, &**rhs, fcx.tcx().types.uint); - fcx.write_ty(expr.id, lhs_t); + check_expr(fcx, &**rhs); + let rhs_ty = fcx.expr_ty(&**rhs); + let rhs_ty = fcx.infcx().resolve_type_vars_if_possible(&rhs_ty); + if ty::type_is_integral(rhs_ty) { + fcx.write_ty(expr.id, lhs_t); + } else { + fcx.type_error_message( + expr.span, + |actual| { + format!( + "right-hand-side of a shift operation must have integral type, \ + not `{}`", + actual) + }, + rhs_ty, + None); + fcx.write_ty(expr.id, fcx.tcx().types.err); + } return; } @@ -3360,7 +3393,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, fcx.expr_ty(base)); // FIXME(eddyb) #12808 Integrate privacy into this auto-deref loop. let (_, autoderefs, field_ty) = - autoderef(fcx, expr.span, expr_t, Some(base.id), lvalue_pref, |base_t, _| { + autoderef(fcx, expr.span, expr_t, Some(base), lvalue_pref, |base_t, _| { match base_t.sty { ty::ty_struct(base_id, substs) => { debug!("struct named {}", ppaux::ty_to_string(tcx, base_t)); @@ -3421,7 +3454,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, let mut tuple_like = false; // FIXME(eddyb) #12808 Integrate privacy into this auto-deref loop. let (_, autoderefs, field_ty) = - autoderef(fcx, expr.span, expr_t, Some(base.id), lvalue_pref, |base_t, _| { + autoderef(fcx, expr.span, expr_t, Some(base), lvalue_pref, |base_t, _| { match base_t.sty { ty::ty_struct(base_id, substs) => { tuple_like = ty::is_tuple_struct(tcx, base_id); @@ -4770,7 +4803,7 @@ pub fn check_enum_variants(ccx: &CrateCtxt, ast::TyU16 => disr as u16 as Disr == disr, ast::TyU32 => disr as u32 as Disr == disr, ast::TyU64 => disr as u64 as Disr == disr, - ast::TyUs => uint_in_range(ccx, ccx.tcx.sess.target.uint_type, disr) + ast::TyUs(_) => uint_in_range(ccx, ccx.tcx.sess.target.uint_type, disr) } } fn int_in_range(ccx: &CrateCtxt, ty: ast::IntTy, disr: ty::Disr) -> bool { @@ -4779,7 +4812,7 @@ pub fn check_enum_variants(ccx: &CrateCtxt, ast::TyI16 => disr as i16 as Disr == disr, ast::TyI32 => disr as i32 as Disr == disr, ast::TyI64 => disr as i64 as Disr == disr, - ast::TyIs => int_in_range(ccx, ccx.tcx.sess.target.int_type, disr) + ast::TyIs(_) => int_in_range(ccx, ccx.tcx.sess.target.int_type, disr) } } match ty { diff --git a/src/librustc_typeck/check/regionck.rs b/src/librustc_typeck/check/regionck.rs index 112e0053642..3b5027dbb9e 100644 --- a/src/librustc_typeck/check/regionck.rs +++ b/src/librustc_typeck/check/regionck.rs @@ -936,29 +936,47 @@ fn constrain_call<'a, I: Iterator<Item=&'a ast::Expr>>(rcx: &mut Rcx, fn constrain_autoderefs<'a, 'tcx>(rcx: &mut Rcx<'a, 'tcx>, deref_expr: &ast::Expr, derefs: uint, - mut derefd_ty: Ty<'tcx>) { + mut derefd_ty: Ty<'tcx>) +{ + debug!("constrain_autoderefs(deref_expr={}, derefs={}, derefd_ty={})", + deref_expr.repr(rcx.tcx()), + derefs, + derefd_ty.repr(rcx.tcx())); + let r_deref_expr = ty::ReScope(CodeExtent::from_node_id(deref_expr.id)); for i in range(0u, derefs) { - debug!("constrain_autoderefs(deref_expr=?, derefd_ty={}, derefs={}/{}", - rcx.fcx.infcx().ty_to_string(derefd_ty), - i, derefs); - let method_call = MethodCall::autoderef(deref_expr.id, i); + debug!("constrain_autoderefs: method_call={:?} (of {:?} total)", method_call, derefs); + derefd_ty = match rcx.fcx.inh.method_map.borrow().get(&method_call) { Some(method) => { + debug!("constrain_autoderefs: #{} is overloaded, method={}", + i, method.repr(rcx.tcx())); + // Treat overloaded autoderefs as if an AutoRef adjustment // was applied on the base type, as that is always the case. let fn_sig = ty::ty_fn_sig(method.ty); - let self_ty = fn_sig.0.inputs[0]; + let fn_sig = // late-bound regions should have been instantiated + ty::assert_no_late_bound_regions(rcx.tcx(), fn_sig); + let self_ty = fn_sig.inputs[0]; let (m, r) = match self_ty.sty { ty::ty_rptr(r, ref m) => (m.mutbl, r), - _ => rcx.tcx().sess.span_bug(deref_expr.span, + _ => { + rcx.tcx().sess.span_bug( + deref_expr.span, &format!("bad overloaded deref type {}", - method.ty.repr(rcx.tcx()))[]) + method.ty.repr(rcx.tcx()))[]) + } }; + + debug!("constrain_autoderefs: receiver r={:?} m={:?}", + r.repr(rcx.tcx()), m); + { let mc = mc::MemCategorizationContext::new(rcx.fcx); let self_cmt = ignore_err!(mc.cat_expr_autoderefd(deref_expr, i)); + debug!("constrain_autoderefs: self_cmt={:?}", + self_cmt.repr(rcx.tcx())); link_region(rcx, deref_expr.span, *r, ty::BorrowKind::from_mutbl(m), self_cmt); } @@ -966,7 +984,7 @@ fn constrain_autoderefs<'a, 'tcx>(rcx: &mut Rcx<'a, 'tcx>, // Specialized version of constrain_call. type_must_outlive(rcx, infer::CallRcvr(deref_expr.span), self_ty, r_deref_expr); - match fn_sig.0.output { + match fn_sig.output { ty::FnConverging(return_type) => { type_must_outlive(rcx, infer::CallReturn(deref_expr.span), return_type, r_deref_expr); @@ -1049,13 +1067,16 @@ fn type_of_node_must_outlive<'a, 'tcx>( /// Computes the guarantor for an expression `&base` and then ensures that the lifetime of the /// resulting pointer is linked to the lifetime of its guarantor (if any). fn link_addr_of(rcx: &mut Rcx, expr: &ast::Expr, - mutability: ast::Mutability, base: &ast::Expr) { - debug!("link_addr_of(base=?)"); + mutability: ast::Mutability, base: &ast::Expr) { + debug!("link_addr_of(expr={}, base={})", expr.repr(rcx.tcx()), base.repr(rcx.tcx())); let cmt = { let mc = mc::MemCategorizationContext::new(rcx.fcx); ignore_err!(mc.cat_expr(base)) }; + + debug!("link_addr_of: cmt={}", cmt.repr(rcx.tcx())); + link_region_from_node_type(rcx, expr.span, expr.id, mutability, cmt); } @@ -1182,6 +1203,9 @@ fn link_region_from_node_type<'a, 'tcx>(rcx: &Rcx<'a, 'tcx>, id: ast::NodeId, mutbl: ast::Mutability, cmt_borrowed: mc::cmt<'tcx>) { + debug!("link_region_from_node_type(id={:?}, mutbl={:?}, cmt_borrowed={})", + id, mutbl, cmt_borrowed.repr(rcx.tcx())); + let rptr_ty = rcx.resolve_node_type(id); if !ty::type_is_error(rptr_ty) { let tcx = rcx.fcx.ccx.tcx; diff --git a/src/librustc_typeck/check/wf.rs b/src/librustc_typeck/check/wf.rs index b17ecdaf59c..89de1ea80fc 100644 --- a/src/librustc_typeck/check/wf.rs +++ b/src/librustc_typeck/check/wf.rs @@ -235,9 +235,16 @@ impl<'ccx, 'tcx> CheckTypeWellFormedVisitor<'ccx, 'tcx> { // Find the supertrait bounds. This will add `int:Bar`. let poly_trait_ref = ty::Binder(trait_ref); let predicates = ty::predicates_for_trait_ref(fcx.tcx(), &poly_trait_ref); - for predicate in predicates.into_iter() { + let predicates = { + let selcx = &mut traits::SelectionContext::new(fcx.infcx(), fcx); + traits::normalize(selcx, cause.clone(), &predicates) + }; + for predicate in predicates.value.into_iter() { fcx.register_predicate(traits::Obligation::new(cause.clone(), predicate)); } + for obligation in predicates.obligations.into_iter() { + fcx.register_predicate(obligation); + } }); } } diff --git a/src/librustc_typeck/lib.rs b/src/librustc_typeck/lib.rs index 76ac4b2e8af..f15d53290e7 100644 --- a/src/librustc_typeck/lib.rs +++ b/src/librustc_typeck/lib.rs @@ -64,7 +64,7 @@ This API is completely unstable and subject to change. */ #![crate_name = "rustc_typeck"] -#![experimental] +#![unstable] #![staged_api] #![crate_type = "dylib"] #![crate_type = "rlib"] @@ -77,6 +77,7 @@ This API is completely unstable and subject to change. #![feature(slicing_syntax, unsafe_destructor)] #![feature(box_syntax)] #![feature(rustc_diagnostic_macros)] +#![allow(unknown_features)] #![feature(int_uint)] #![allow(non_camel_case_types)] #[macro_use] extern crate log; diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index fbb3c40ee99..a44c73e8c41 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -1389,12 +1389,12 @@ impl<'tcx> Clean<Type> for ty::Ty<'tcx> { match self.sty { ty::ty_bool => Primitive(Bool), ty::ty_char => Primitive(Char), - ty::ty_int(ast::TyIs) => Primitive(Isize), + ty::ty_int(ast::TyIs(_)) => Primitive(Isize), ty::ty_int(ast::TyI8) => Primitive(I8), ty::ty_int(ast::TyI16) => Primitive(I16), ty::ty_int(ast::TyI32) => Primitive(I32), ty::ty_int(ast::TyI64) => Primitive(I64), - ty::ty_uint(ast::TyUs) => Primitive(Usize), + ty::ty_uint(ast::TyUs(_)) => Primitive(Usize), ty::ty_uint(ast::TyU8) => Primitive(U8), ty::ty_uint(ast::TyU16) => Primitive(U16), ty::ty_uint(ast::TyU32) => Primitive(U32), @@ -2269,12 +2269,12 @@ fn resolve_type(cx: &DocContext, ast::TyStr => return Primitive(Str), ast::TyBool => return Primitive(Bool), ast::TyChar => return Primitive(Char), - ast::TyInt(ast::TyIs) => return Primitive(Isize), + ast::TyInt(ast::TyIs(_)) => return Primitive(Isize), ast::TyInt(ast::TyI8) => return Primitive(I8), ast::TyInt(ast::TyI16) => return Primitive(I16), ast::TyInt(ast::TyI32) => return Primitive(I32), ast::TyInt(ast::TyI64) => return Primitive(I64), - ast::TyUint(ast::TyUs) => return Primitive(Usize), + ast::TyUint(ast::TyUs(_)) => return Primitive(Usize), ast::TyUint(ast::TyU8) => return Primitive(U8), ast::TyUint(ast::TyU16) => return Primitive(U16), ast::TyUint(ast::TyU32) => return Primitive(U32), diff --git a/src/librustdoc/lib.rs b/src/librustdoc/lib.rs index 56f5c23f6f1..6d5df3d777d 100644 --- a/src/librustdoc/lib.rs +++ b/src/librustdoc/lib.rs @@ -9,7 +9,7 @@ // except according to those terms. #![crate_name = "rustdoc"] -#![experimental] +#![unstable] #![staged_api] #![crate_type = "dylib"] #![crate_type = "rlib"] @@ -19,6 +19,7 @@ html_playground_url = "http://play.rust-lang.org/")] #![feature(slicing_syntax)] #![feature(box_syntax)] +#![allow(unknown_features)] #![feature(int_uint)] extern crate arena; extern crate getopts; diff --git a/src/libserialize/lib.rs b/src/libserialize/lib.rs index b3c4cec2ef1..942a8cfa2c5 100644 --- a/src/libserialize/lib.rs +++ b/src/libserialize/lib.rs @@ -28,6 +28,7 @@ Core encoding and decoding interfaces. #![feature(box_syntax)] #![feature(old_impl_check)] #![feature(slicing_syntax)] +#![allow(unknown_features)] #![feature(int_uint)] // test harness access #[cfg(test)] extern crate test; diff --git a/src/libstd/ascii.rs b/src/libstd/ascii.rs index 671408acebf..77c2315194b 100644 --- a/src/libstd/ascii.rs +++ b/src/libstd/ascii.rs @@ -22,7 +22,7 @@ use string::String; use vec::Vec; /// Extension methods for ASCII-subset only operations on owned strings -#[experimental = "would prefer to do this in a more general way"] +#[unstable = "would prefer to do this in a more general way"] pub trait OwnedAsciiExt { /// Convert the string to ASCII upper case: /// ASCII letters 'a' to 'z' are mapped to 'A' to 'Z', @@ -36,7 +36,7 @@ pub trait OwnedAsciiExt { } /// Extension methods for ASCII-subset only operations on string slices -#[experimental = "would prefer to do this in a more general way"] +#[unstable = "would prefer to do this in a more general way"] pub trait AsciiExt<T = Self> { /// Check if within the ASCII range. fn is_ascii(&self) -> bool; @@ -57,7 +57,7 @@ pub trait AsciiExt<T = Self> { fn eq_ignore_ascii_case(&self, other: &Self) -> bool; } -#[experimental = "would prefer to do this in a more general way"] +#[unstable = "would prefer to do this in a more general way"] impl AsciiExt<String> for str { #[inline] fn is_ascii(&self) -> bool { @@ -82,7 +82,7 @@ impl AsciiExt<String> for str { } } -#[experimental = "would prefer to do this in a more general way"] +#[unstable = "would prefer to do this in a more general way"] impl OwnedAsciiExt for String { #[inline] fn into_ascii_uppercase(self) -> String { @@ -97,7 +97,7 @@ impl OwnedAsciiExt for String { } } -#[experimental = "would prefer to do this in a more general way"] +#[unstable = "would prefer to do this in a more general way"] impl AsciiExt<Vec<u8>> for [u8] { #[inline] fn is_ascii(&self) -> bool { @@ -123,7 +123,7 @@ impl AsciiExt<Vec<u8>> for [u8] { } } -#[experimental = "would prefer to do this in a more general way"] +#[unstable = "would prefer to do this in a more general way"] impl OwnedAsciiExt for Vec<u8> { #[inline] fn into_ascii_uppercase(mut self) -> Vec<u8> { @@ -142,7 +142,7 @@ impl OwnedAsciiExt for Vec<u8> { } } -#[experimental = "would prefer to do this in a more general way"] +#[unstable = "would prefer to do this in a more general way"] impl AsciiExt for u8 { #[inline] fn is_ascii(&self) -> bool { @@ -165,7 +165,7 @@ impl AsciiExt for u8 { } } -#[experimental = "would prefer to do this in a more general way"] +#[unstable = "would prefer to do this in a more general way"] impl AsciiExt for char { #[inline] fn is_ascii(&self) -> bool { diff --git a/src/libstd/bitflags.rs b/src/libstd/bitflags.rs index 8dc41368e7f..3a059766fef 100644 --- a/src/libstd/bitflags.rs +++ b/src/libstd/bitflags.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![experimental] +#![unstable] //! A typesafe bitmask flag generator. diff --git a/src/libstd/collections/hash/table.rs b/src/libstd/collections/hash/table.rs index e43cc053ba0..456f3763b39 100644 --- a/src/libstd/collections/hash/table.rs +++ b/src/libstd/collections/hash/table.rs @@ -632,7 +632,7 @@ impl<K, V> RawTable<K, V> { /// Creates a new raw table from a given capacity. All buckets are /// initially empty. - #[allow(experimental)] + #[allow(unstable)] pub fn new(capacity: uint) -> RawTable<K, V> { unsafe { let ret = RawTable::new_uninitialized(capacity); diff --git a/src/libstd/dynamic_lib.rs b/src/libstd/dynamic_lib.rs index 2d013a8a5b8..3eeb09b79da 100644 --- a/src/libstd/dynamic_lib.rs +++ b/src/libstd/dynamic_lib.rs @@ -12,7 +12,7 @@ //! //! A simple wrapper over the platform's dynamic library facilities -#![experimental] +#![unstable] #![allow(missing_docs)] use prelude::v1::*; diff --git a/src/libstd/failure.rs b/src/libstd/failure.rs index dbc88ddf0a0..54191cf2404 100644 --- a/src/libstd/failure.rs +++ b/src/libstd/failure.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![experimental] +#![unstable] use prelude::v1::*; diff --git a/src/libstd/fmt.rs b/src/libstd/fmt.rs index 96fff64d221..907925e93d3 100644 --- a/src/libstd/fmt.rs +++ b/src/libstd/fmt.rs @@ -410,7 +410,7 @@ //! them with the same character. For example, the `{` character is escaped with //! `{{` and the `}` character is escaped with `}}`. -#![experimental] +#![unstable] use string; @@ -439,7 +439,7 @@ pub use core::fmt::{argument, argumentuint}; /// let s = fmt::format(format_args!("Hello, {}!", "world")); /// assert_eq!(s, "Hello, world!".to_string()); /// ``` -#[experimental = "this is an implementation detail of format! and should not \ +#[unstable = "this is an implementation detail of format! and should not \ be called directly"] pub fn format(args: Arguments) -> string::String { let mut output = string::String::new(); diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs index 1c48b20c444..3968dda2a82 100644 --- a/src/libstd/io/mod.rs +++ b/src/libstd/io/mod.rs @@ -219,7 +219,7 @@ //! concerned with error handling; instead its caller is responsible for //! responding to errors that may occur while attempting to read the numbers. -#![experimental] +#![unstable] #![deny(unused_must_use)] pub use self::SeekStyle::*; diff --git a/src/libstd/io/net/pipe.rs b/src/libstd/io/net/pipe.rs index 29295b5751c..42d9fff6d15 100644 --- a/src/libstd/io/net/pipe.rs +++ b/src/libstd/io/net/pipe.rs @@ -68,7 +68,7 @@ impl UnixStream { /// /// If a `timeout` with zero or negative duration is specified then /// the function returns `Err`, with the error kind set to `TimedOut`. - #[experimental = "the timeout argument is likely to change types"] + #[unstable = "the timeout argument is likely to change types"] pub fn connect_timeout<P>(path: P, timeout: Duration) -> IoResult<UnixStream> where P: BytesContainer { @@ -107,7 +107,7 @@ impl UnixStream { /// Sets the read/write timeout for this socket. /// /// For more information, see `TcpStream::set_timeout` - #[experimental = "the timeout argument may change in type and value"] + #[unstable = "the timeout argument may change in type and value"] pub fn set_timeout(&mut self, timeout_ms: Option<u64>) { self.inner.set_timeout(timeout_ms) } @@ -115,7 +115,7 @@ impl UnixStream { /// Sets the read timeout for this socket. /// /// For more information, see `TcpStream::set_timeout` - #[experimental = "the timeout argument may change in type and value"] + #[unstable = "the timeout argument may change in type and value"] pub fn set_read_timeout(&mut self, timeout_ms: Option<u64>) { self.inner.set_read_timeout(timeout_ms) } @@ -123,7 +123,7 @@ impl UnixStream { /// Sets the write timeout for this socket. /// /// For more information, see `TcpStream::set_timeout` - #[experimental = "the timeout argument may change in type and value"] + #[unstable = "the timeout argument may change in type and value"] pub fn set_write_timeout(&mut self, timeout_ms: Option<u64>) { self.inner.set_write_timeout(timeout_ms) } @@ -219,7 +219,7 @@ impl UnixAcceptor { /// When using this method, it is likely necessary to reset the timeout as /// appropriate, the timeout specified is specific to this object, not /// specific to the next request. - #[experimental = "the name and arguments to this function are likely \ + #[unstable = "the name and arguments to this function are likely \ to change"] pub fn set_timeout(&mut self, timeout_ms: Option<u64>) { self.inner.set_timeout(timeout_ms) @@ -229,7 +229,7 @@ impl UnixAcceptor { /// /// This function has the same semantics as `TcpAcceptor::close_accept`, and /// more information can be found in that documentation. - #[experimental] + #[unstable] pub fn close_accept(&mut self) -> IoResult<()> { self.inner.close_accept() } diff --git a/src/libstd/io/net/tcp.rs b/src/libstd/io/net/tcp.rs index 7a376b50cd7..6a3f5fcb2c6 100644 --- a/src/libstd/io/net/tcp.rs +++ b/src/libstd/io/net/tcp.rs @@ -85,7 +85,7 @@ impl TcpStream { /// /// If a `timeout` with zero or negative duration is specified then /// the function returns `Err`, with the error kind set to `TimedOut`. - #[experimental = "the timeout argument may eventually change types"] + #[unstable = "the timeout argument may eventually change types"] pub fn connect_timeout<A: ToSocketAddr>(addr: A, timeout: Duration) -> IoResult<TcpStream> { if timeout <= Duration::milliseconds(0) { @@ -109,7 +109,7 @@ impl TcpStream { } /// Sets the nodelay flag on this connection to the boolean specified - #[experimental] + #[unstable] pub fn set_nodelay(&mut self, nodelay: bool) -> IoResult<()> { self.inner.set_nodelay(nodelay) } @@ -119,7 +119,7 @@ impl TcpStream { /// If the value specified is `None`, then the keepalive flag is cleared on /// this connection. Otherwise, the keepalive timeout will be set to the /// specified time, in seconds. - #[experimental] + #[unstable] pub fn set_keepalive(&mut self, delay_in_seconds: Option<uint>) -> IoResult<()> { self.inner.set_keepalive(delay_in_seconds) } @@ -187,7 +187,7 @@ impl TcpStream { /// /// For clarification on the semantics of interrupting a read and a write, /// take a look at `set_read_timeout` and `set_write_timeout`. - #[experimental = "the timeout argument may change in type and value"] + #[unstable = "the timeout argument may change in type and value"] pub fn set_timeout(&mut self, timeout_ms: Option<u64>) { self.inner.set_timeout(timeout_ms) } @@ -204,7 +204,7 @@ impl TcpStream { /// action is taken. Otherwise, the read operation will be scheduled to /// promptly return. If a timeout error is returned, then no data was read /// during the timeout period. - #[experimental = "the timeout argument may change in type and value"] + #[unstable = "the timeout argument may change in type and value"] pub fn set_read_timeout(&mut self, timeout_ms: Option<u64>) { self.inner.set_read_timeout(timeout_ms) } @@ -231,7 +231,7 @@ impl TcpStream { /// does not know how many bytes were written as part of the timeout /// operation. It may be the case that bytes continue to be written in an /// asynchronous fashion after the call to write returns. - #[experimental = "the timeout argument may change in type and value"] + #[unstable = "the timeout argument may change in type and value"] pub fn set_write_timeout(&mut self, timeout_ms: Option<u64>) { self.inner.set_write_timeout(timeout_ms) } @@ -374,7 +374,7 @@ impl TcpAcceptor { /// # Example /// /// ```no_run - /// # #![allow(experimental)] + /// # #![allow(unstable)] /// use std::io::TcpListener; /// use std::io::{Listener, Acceptor, TimedOut}; /// @@ -397,7 +397,7 @@ impl TcpAcceptor { /// a.set_timeout(None); /// let socket = a.accept(); /// ``` - #[experimental = "the type of the argument and name of this function are \ + #[unstable = "the type of the argument and name of this function are \ subject to change"] pub fn set_timeout(&mut self, ms: Option<u64>) { self.inner.set_timeout(ms); } @@ -418,7 +418,7 @@ impl TcpAcceptor { /// # Example /// /// ``` - /// # #![allow(experimental)] + /// # #![allow(unstable)] /// use std::io::{TcpListener, Listener, Acceptor, EndOfFile}; /// use std::thread::Thread; /// @@ -444,7 +444,7 @@ impl TcpAcceptor { /// // Signal our accept loop to exit /// assert!(a.close_accept().is_ok()); /// ``` - #[experimental] + #[unstable] pub fn close_accept(&mut self) -> IoResult<()> { self.inner.close_accept() } @@ -482,7 +482,7 @@ impl sys_common::AsInner<TcpAcceptorImp> for TcpAcceptor { } #[cfg(test)] -#[allow(experimental)] +#[allow(unstable)] mod test { use prelude::v1::*; diff --git a/src/libstd/io/net/udp.rs b/src/libstd/io/net/udp.rs index a4db0d4f5de..8cdad3f528a 100644 --- a/src/libstd/io/net/udp.rs +++ b/src/libstd/io/net/udp.rs @@ -92,13 +92,13 @@ impl UdpSocket { } /// Joins a multicast IP address (becomes a member of it) - #[experimental] + #[unstable] pub fn join_multicast(&mut self, multi: IpAddr) -> IoResult<()> { self.inner.join_multicast(multi) } /// Leaves a multicast IP address (drops membership from it) - #[experimental] + #[unstable] pub fn leave_multicast(&mut self, multi: IpAddr) -> IoResult<()> { self.inner.leave_multicast(multi) } @@ -106,25 +106,25 @@ impl UdpSocket { /// Set the multicast loop flag to the specified value /// /// This lets multicast packets loop back to local sockets (if enabled) - #[experimental] + #[unstable] pub fn set_multicast_loop(&mut self, on: bool) -> IoResult<()> { self.inner.set_multicast_loop(on) } /// Sets the multicast TTL - #[experimental] + #[unstable] pub fn set_multicast_ttl(&mut self, ttl: int) -> IoResult<()> { self.inner.multicast_time_to_live(ttl) } /// Sets this socket's TTL - #[experimental] + #[unstable] pub fn set_ttl(&mut self, ttl: int) -> IoResult<()> { self.inner.time_to_live(ttl) } /// Sets the broadcast flag on or off - #[experimental] + #[unstable] pub fn set_broadcast(&mut self, broadcast: bool) -> IoResult<()> { self.inner.set_broadcast(broadcast) } @@ -132,7 +132,7 @@ impl UdpSocket { /// Sets the read/write timeout for this socket. /// /// For more information, see `TcpStream::set_timeout` - #[experimental = "the timeout argument may change in type and value"] + #[unstable = "the timeout argument may change in type and value"] pub fn set_timeout(&mut self, timeout_ms: Option<u64>) { self.inner.set_timeout(timeout_ms) } @@ -140,7 +140,7 @@ impl UdpSocket { /// Sets the read timeout for this socket. /// /// For more information, see `TcpStream::set_timeout` - #[experimental = "the timeout argument may change in type and value"] + #[unstable = "the timeout argument may change in type and value"] pub fn set_read_timeout(&mut self, timeout_ms: Option<u64>) { self.inner.set_read_timeout(timeout_ms) } @@ -148,7 +148,7 @@ impl UdpSocket { /// Sets the write timeout for this socket. /// /// For more information, see `TcpStream::set_timeout` - #[experimental = "the timeout argument may change in type and value"] + #[unstable = "the timeout argument may change in type and value"] pub fn set_write_timeout(&mut self, timeout_ms: Option<u64>) { self.inner.set_write_timeout(timeout_ms) } @@ -176,7 +176,7 @@ impl sys_common::AsInner<UdpSocketImp> for UdpSocket { } #[cfg(test)] -#[allow(experimental)] +#[allow(unstable)] mod test { use prelude::v1::*; diff --git a/src/libstd/io/process.rs b/src/libstd/io/process.rs index f824d821601..a093e748d57 100644 --- a/src/libstd/io/process.rs +++ b/src/libstd/io/process.rs @@ -10,7 +10,7 @@ //! Bindings for executing child processes -#![allow(experimental)] +#![allow(unstable)] #![allow(non_upper_case_globals)] pub use self::StdioContainer::*; @@ -661,7 +661,7 @@ impl Process { /// # Example /// /// ```no_run - /// # #![allow(experimental)] + /// # #![allow(unstable)] /// use std::io::{Command, IoResult}; /// use std::io::process::ProcessExit; /// @@ -689,7 +689,7 @@ impl Process { /// p.wait() /// } /// ``` - #[experimental = "the type of the timeout is likely to change"] + #[unstable = "the type of the timeout is likely to change"] pub fn set_timeout(&mut self, timeout_ms: Option<u64>) { self.deadline = timeout_ms.map(|i| i + sys::timer::now()).unwrap_or(0); } diff --git a/src/libstd/lib.rs b/src/libstd/lib.rs index 71221a654e8..dc157c7d676 100644 --- a/src/libstd/lib.rs +++ b/src/libstd/lib.rs @@ -110,6 +110,7 @@ #![feature(slicing_syntax, unboxed_closures)] #![feature(box_syntax)] #![feature(old_impl_check)] +#![allow(unknown_features)] #![feature(int_uint)] // Don't link to std. We are std. #![no_std] diff --git a/src/libstd/macros.rs b/src/libstd/macros.rs index 0594b711ad6..626372db23b 100644 --- a/src/libstd/macros.rs +++ b/src/libstd/macros.rs @@ -14,7 +14,7 @@ //! library. Each macro is available for use when linking against the standard //! library. -#![experimental] +#![unstable] /// The entry point for panic of Rust tasks. /// @@ -44,7 +44,7 @@ macro_rules! panic { ($msg:expr) => ({ $crate::rt::begin_unwind($msg, { // static requires less code at runtime, more constant data - static _FILE_LINE: (&'static str, uint) = (file!(), line!()); + static _FILE_LINE: (&'static str, usize) = (file!(), line!()); &_FILE_LINE }) }); @@ -54,7 +54,7 @@ macro_rules! panic { // 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!()); + static _FILE_LINE: (&'static str, usize) = (file!(), line!()); &_FILE_LINE }) }); @@ -324,7 +324,7 @@ macro_rules! try { /// /// For more information about select, see the `std::sync::mpsc::Select` structure. #[macro_export] -#[experimental] +#[unstable] macro_rules! select { ( $($name:pat = $rx:ident.$meth:ident() => $code:expr),+ @@ -466,7 +466,7 @@ pub mod builtin { /// A macro which expands to the line number on which it was invoked. /// - /// The expanded expression has type `uint`, and the returned line is not + /// The expanded expression has type `usize`, and the returned line is not /// the invocation of the `line!()` macro itself, but rather the first macro /// invocation leading up to the invocation of the `line!()` macro. /// @@ -481,7 +481,7 @@ pub mod builtin { /// A macro which expands to the column number on which it was invoked. /// - /// The expanded expression has type `uint`, and the returned column is not + /// The expanded expression has type `usize`, and the returned column is not /// the invocation of the `column!()` macro itself, but rather the first macro /// invocation leading up to the invocation of the `column!()` macro. /// diff --git a/src/libstd/num/f32.rs b/src/libstd/num/f32.rs index 0a1c17fab47..adbce893887 100644 --- a/src/libstd/num/f32.rs +++ b/src/libstd/num/f32.rs @@ -366,7 +366,7 @@ impl Float for f32 { /// /// * num - The float value #[inline] -#[experimental = "may be removed or relocated"] +#[unstable = "may be removed or relocated"] pub fn to_string(num: f32) -> String { let (r, _) = strconv::float_to_str_common( num, 10u, true, SignNeg, DigAll, ExpNone, false); @@ -379,7 +379,7 @@ pub fn to_string(num: f32) -> String { /// /// * num - The float value #[inline] -#[experimental = "may be removed or relocated"] +#[unstable = "may be removed or relocated"] pub fn to_str_hex(num: f32) -> String { let (r, _) = strconv::float_to_str_common( num, 16u, true, SignNeg, DigAll, ExpNone, false); @@ -394,7 +394,7 @@ pub fn to_str_hex(num: f32) -> String { /// * num - The float value /// * radix - The base to use #[inline] -#[experimental = "may be removed or relocated"] +#[unstable = "may be removed or relocated"] pub fn to_str_radix_special(num: f32, rdx: uint) -> (String, bool) { strconv::float_to_str_common(num, rdx, true, SignNeg, DigAll, ExpNone, false) } @@ -407,7 +407,7 @@ pub fn to_str_radix_special(num: f32, rdx: uint) -> (String, bool) { /// * num - The float value /// * digits - The number of significant digits #[inline] -#[experimental = "may be removed or relocated"] +#[unstable = "may be removed or relocated"] pub fn to_str_exact(num: f32, dig: uint) -> String { let (r, _) = strconv::float_to_str_common( num, 10u, true, SignNeg, DigExact(dig), ExpNone, false); @@ -422,7 +422,7 @@ pub fn to_str_exact(num: f32, dig: uint) -> String { /// * num - The float value /// * digits - The number of significant digits #[inline] -#[experimental = "may be removed or relocated"] +#[unstable = "may be removed or relocated"] pub fn to_str_digits(num: f32, dig: uint) -> String { let (r, _) = strconv::float_to_str_common( num, 10u, true, SignNeg, DigMax(dig), ExpNone, false); @@ -438,7 +438,7 @@ pub fn to_str_digits(num: f32, dig: uint) -> String { /// * digits - The number of digits after the decimal point /// * upper - Use `E` instead of `e` for the exponent sign #[inline] -#[experimental = "may be removed or relocated"] +#[unstable = "may be removed or relocated"] pub fn to_str_exp_exact(num: f32, dig: uint, upper: bool) -> String { let (r, _) = strconv::float_to_str_common( num, 10u, true, SignNeg, DigExact(dig), ExpDec, upper); @@ -454,7 +454,7 @@ pub fn to_str_exp_exact(num: f32, dig: uint, upper: bool) -> String { /// * digits - The number of digits after the decimal point /// * upper - Use `E` instead of `e` for the exponent sign #[inline] -#[experimental = "may be removed or relocated"] +#[unstable = "may be removed or relocated"] pub fn to_str_exp_digits(num: f32, dig: uint, upper: bool) -> String { let (r, _) = strconv::float_to_str_common( num, 10u, true, SignNeg, DigMax(dig), ExpDec, upper); diff --git a/src/libstd/num/f64.rs b/src/libstd/num/f64.rs index 2806154a016..baff14125ee 100644 --- a/src/libstd/num/f64.rs +++ b/src/libstd/num/f64.rs @@ -375,7 +375,7 @@ impl Float for f64 { /// /// * num - The float value #[inline] -#[experimental = "may be removed or relocated"] +#[unstable = "may be removed or relocated"] pub fn to_string(num: f64) -> String { let (r, _) = strconv::float_to_str_common( num, 10u, true, SignNeg, DigAll, ExpNone, false); @@ -388,7 +388,7 @@ pub fn to_string(num: f64) -> String { /// /// * num - The float value #[inline] -#[experimental = "may be removed or relocated"] +#[unstable = "may be removed or relocated"] pub fn to_str_hex(num: f64) -> String { let (r, _) = strconv::float_to_str_common( num, 16u, true, SignNeg, DigAll, ExpNone, false); @@ -403,7 +403,7 @@ pub fn to_str_hex(num: f64) -> String { /// * num - The float value /// * radix - The base to use #[inline] -#[experimental = "may be removed or relocated"] +#[unstable = "may be removed or relocated"] pub fn to_str_radix_special(num: f64, rdx: uint) -> (String, bool) { strconv::float_to_str_common(num, rdx, true, SignNeg, DigAll, ExpNone, false) } @@ -416,7 +416,7 @@ pub fn to_str_radix_special(num: f64, rdx: uint) -> (String, bool) { /// * num - The float value /// * digits - The number of significant digits #[inline] -#[experimental = "may be removed or relocated"] +#[unstable = "may be removed or relocated"] pub fn to_str_exact(num: f64, dig: uint) -> String { let (r, _) = strconv::float_to_str_common( num, 10u, true, SignNeg, DigExact(dig), ExpNone, false); @@ -431,7 +431,7 @@ pub fn to_str_exact(num: f64, dig: uint) -> String { /// * num - The float value /// * digits - The number of significant digits #[inline] -#[experimental = "may be removed or relocated"] +#[unstable = "may be removed or relocated"] pub fn to_str_digits(num: f64, dig: uint) -> String { let (r, _) = strconv::float_to_str_common( num, 10u, true, SignNeg, DigMax(dig), ExpNone, false); @@ -447,7 +447,7 @@ pub fn to_str_digits(num: f64, dig: uint) -> String { /// * digits - The number of digits after the decimal point /// * upper - Use `E` instead of `e` for the exponent sign #[inline] -#[experimental = "may be removed or relocated"] +#[unstable = "may be removed or relocated"] pub fn to_str_exp_exact(num: f64, dig: uint, upper: bool) -> String { let (r, _) = strconv::float_to_str_common( num, 10u, true, SignNeg, DigExact(dig), ExpDec, upper); @@ -463,7 +463,7 @@ pub fn to_str_exp_exact(num: f64, dig: uint, upper: bool) -> String { /// * digits - The number of digits after the decimal point /// * upper - Use `E` instead of `e` for the exponent sign #[inline] -#[experimental = "may be removed or relocated"] +#[unstable = "may be removed or relocated"] pub fn to_str_exp_digits(num: f64, dig: uint, upper: bool) -> String { let (r, _) = strconv::float_to_str_common( num, 10u, true, SignNeg, DigMax(dig), ExpDec, upper); diff --git a/src/libstd/num/float_macros.rs b/src/libstd/num/float_macros.rs index 4c52f29b12d..ec168eaaa9d 100644 --- a/src/libstd/num/float_macros.rs +++ b/src/libstd/num/float_macros.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![experimental] +#![unstable] #![doc(hidden)] macro_rules! assert_approx_eq { diff --git a/src/libstd/num/int_macros.rs b/src/libstd/num/int_macros.rs index ebcb2086187..5bc54152874 100644 --- a/src/libstd/num/int_macros.rs +++ b/src/libstd/num/int_macros.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![experimental] +#![unstable] #![doc(hidden)] macro_rules! int_module { ($T:ty) => ( diff --git a/src/libstd/num/mod.rs b/src/libstd/num/mod.rs index 9c6911cf4d1..e804408b4d0 100644 --- a/src/libstd/num/mod.rs +++ b/src/libstd/num/mod.rs @@ -33,7 +33,7 @@ pub use core::num::{FpCategory}; use option::Option; -#[experimental = "may be removed or relocated"] +#[unstable = "may be removed or relocated"] pub mod strconv; /// Mathematical operations on primitive floating point numbers. diff --git a/src/libstd/num/uint_macros.rs b/src/libstd/num/uint_macros.rs index 4ce15491a0e..f480a3b420f 100644 --- a/src/libstd/num/uint_macros.rs +++ b/src/libstd/num/uint_macros.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![experimental] +#![unstable] #![doc(hidden)] #![allow(unsigned_negation)] diff --git a/src/libstd/os.rs b/src/libstd/os.rs index cef85c260a7..6e3949b9e22 100644 --- a/src/libstd/os.rs +++ b/src/libstd/os.rs @@ -22,7 +22,7 @@ //! so we will not _hide_ the facts of which OS the user is on -- they should be given the //! opportunity to write OS-ignorant code by default. -#![experimental] +#![unstable] #![allow(missing_docs)] #![allow(non_snake_case)] diff --git a/src/libstd/path/mod.rs b/src/libstd/path/mod.rs index b474ae4e371..1ec7b6b3edc 100644 --- a/src/libstd/path/mod.rs +++ b/src/libstd/path/mod.rs @@ -59,7 +59,7 @@ //! println!("path exists: {}", path.exists()); //! ``` -#![experimental] +#![unstable] use core::marker::Sized; use ffi::CString; diff --git a/src/libstd/rand/mod.rs b/src/libstd/rand/mod.rs index 3fa1efe1ccd..60d490982db 100644 --- a/src/libstd/rand/mod.rs +++ b/src/libstd/rand/mod.rs @@ -219,7 +219,7 @@ //! } //! ``` -#![experimental] +#![unstable] use cell::RefCell; use clone::Clone; diff --git a/src/libstd/rt/mod.rs b/src/libstd/rt/mod.rs index 5ef55f5b487..e3e4e132b81 100644 --- a/src/libstd/rt/mod.rs +++ b/src/libstd/rt/mod.rs @@ -16,7 +16,7 @@ //! and should be considered as private implementation details for the //! time being. -#![experimental] +#![unstable] // FIXME: this should not be here. #![allow(missing_docs)] diff --git a/src/libstd/rt/unwind.rs b/src/libstd/rt/unwind.rs index 03876189da9..4cd0b29688a 100644 --- a/src/libstd/rt/unwind.rs +++ b/src/libstd/rt/unwind.rs @@ -582,7 +582,7 @@ fn begin_unwind_inner(msg: Box<Any + Send>, file_line: &(&'static str, uint)) -> /// Only a limited number of callbacks can be registered, and this function /// returns whether the callback was successfully registered or not. It is not /// currently possible to unregister a callback once it has been registered. -#[experimental] +#[unstable] pub unsafe fn register(f: Callback) -> bool { match CALLBACK_CNT.fetch_add(1, Ordering::SeqCst) { // The invocation code has knowledge of this window where the count has diff --git a/src/libstd/rtdeps.rs b/src/libstd/rtdeps.rs index 862808a9e3d..f4fbd378899 100644 --- a/src/libstd/rtdeps.rs +++ b/src/libstd/rtdeps.rs @@ -12,7 +12,7 @@ //! the standard library This varies per-platform, but these libraries are //! necessary for running libstd. -#![experimental] +#![unstable] // All platforms need to link to rustrt #[cfg(not(test))] diff --git a/src/libstd/sync/mpsc/mpsc_queue.rs b/src/libstd/sync/mpsc/mpsc_queue.rs index f8eae1322bf..83de98fdbff 100644 --- a/src/libstd/sync/mpsc/mpsc_queue.rs +++ b/src/libstd/sync/mpsc/mpsc_queue.rs @@ -35,7 +35,7 @@ //! method, and see the method for more information about it. Due to this //! caveat, this queue may not be appropriate for all use-cases. -#![experimental] +#![unstable] // http://www.1024cores.net/home/lock-free-algorithms // /queues/non-intrusive-mpsc-node-based-queue diff --git a/src/libstd/sync/mpsc/select.rs b/src/libstd/sync/mpsc/select.rs index b7bb22b3ef3..0da458a51f1 100644 --- a/src/libstd/sync/mpsc/select.rs +++ b/src/libstd/sync/mpsc/select.rs @@ -46,7 +46,7 @@ //! ``` #![allow(dead_code)] -#![experimental = "This implementation, while likely sufficient, is unsafe and \ +#![unstable = "This implementation, while likely sufficient, is unsafe and \ likely to be error prone. At some point in the future this \ module will likely be replaced, and it is currently \ unknown how much API breakage that will cause. The ability \ diff --git a/src/libstd/sync/mpsc/spsc_queue.rs b/src/libstd/sync/mpsc/spsc_queue.rs index e8d6e380be5..46c69f6f547 100644 --- a/src/libstd/sync/mpsc/spsc_queue.rs +++ b/src/libstd/sync/mpsc/spsc_queue.rs @@ -33,7 +33,7 @@ //! concurrently between two tasks. This data structure is safe to use and //! enforces the semantics that there is one pusher and one popper. -#![experimental] +#![unstable] use core::prelude::*; diff --git a/src/libstd/sys/unix/ext.rs b/src/libstd/sys/unix/ext.rs index ae3c939bf78..0e4a9d1b307 100644 --- a/src/libstd/sys/unix/ext.rs +++ b/src/libstd/sys/unix/ext.rs @@ -29,7 +29,7 @@ //! } //! ``` -#![experimental] +#![unstable] use sys_common::AsInner; use libc; diff --git a/src/libstd/sys/windows/ext.rs b/src/libstd/sys/windows/ext.rs index 049aca3f590..87ff31ab73c 100644 --- a/src/libstd/sys/windows/ext.rs +++ b/src/libstd/sys/windows/ext.rs @@ -14,7 +14,7 @@ //! descriptors, and sockets, but its functionality will grow over //! time. -#![experimental] +#![unstable] use sys_common::AsInner; use libc; diff --git a/src/libstd/thread.rs b/src/libstd/thread.rs index c103365745c..932556fe1a6 100644 --- a/src/libstd/thread.rs +++ b/src/libstd/thread.rs @@ -207,14 +207,14 @@ impl Builder { } /// Redirect thread-local stdout. - #[experimental = "Will likely go away after proc removal"] + #[unstable = "Will likely go away after proc removal"] pub fn stdout(mut self, stdout: Box<Writer + Send>) -> Builder { self.stdout = Some(stdout); self } /// Redirect thread-local stderr. - #[experimental = "Will likely go away after proc removal"] + #[unstable = "Will likely go away after proc removal"] pub fn stderr(mut self, stderr: Box<Writer + Send>) -> Builder { self.stderr = Some(stderr); self @@ -483,7 +483,7 @@ impl<'a, T: Send + 'a> JoinGuard<'a, T> { impl<T: Send> JoinGuard<'static, T> { /// Detaches the child thread, allowing it to outlive its parent. - #[experimental = "unsure whether this API imposes limitations elsewhere"] + #[unstable = "unsure whether this API imposes limitations elsewhere"] pub fn detach(mut self) { unsafe { imp::detach(self.native) }; self.joined = true; // avoid joining in the destructor diff --git a/src/libstd/time/duration.rs b/src/libstd/time/duration.rs index a651d927c14..162c3677168 100644 --- a/src/libstd/time/duration.rs +++ b/src/libstd/time/duration.rs @@ -10,7 +10,7 @@ //! Temporal quantification -#![experimental] +#![unstable] use {fmt, i64}; use ops::{Add, Sub, Mul, Div, Neg, FnOnce}; diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index 0a9e0aedd3d..630f7768885 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -1075,15 +1075,29 @@ pub struct Typedef { pub typ: P<Ty>, } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Copy)] +#[derive(Clone, Eq, RustcEncodable, RustcDecodable, Hash, Copy)] pub enum IntTy { - TyIs, + TyIs(bool /* is this deprecated `int`? */), TyI8, TyI16, TyI32, TyI64, } +impl PartialEq for IntTy { + fn eq(&self, other: &IntTy) -> bool { + match (*self, *other) { + // true/false need to compare the same, so this can't be derived + (TyIs(_), TyIs(_)) | + (TyI8, TyI8) | + (TyI16, TyI16) | + (TyI32, TyI32) | + (TyI64, TyI64) => true, + _ => false + } + } +} + impl fmt::Show for IntTy { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::String::fmt(self, f) @@ -1099,27 +1113,41 @@ impl fmt::String for IntTy { impl IntTy { pub fn suffix_len(&self) -> uint { match *self { - TyIs => 1, - TyI8 => 2, + TyIs(true) /* i */ => 1, + TyIs(false) /* is */ | TyI8 => 2, TyI16 | TyI32 | TyI64 => 3, } } } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Copy)] +#[derive(Clone, Eq, RustcEncodable, RustcDecodable, Hash, Copy)] pub enum UintTy { - TyUs, + TyUs(bool /* is this deprecated uint? */), TyU8, TyU16, TyU32, TyU64, } +impl PartialEq for UintTy { + fn eq(&self, other: &UintTy) -> bool { + match (*self, *other) { + // true/false need to compare the same, so this can't be derived + (TyUs(_), TyUs(_)) | + (TyU8, TyU8) | + (TyU16, TyU16) | + (TyU32, TyU32) | + (TyU64, TyU64) => true, + _ => false + } + } +} + impl UintTy { pub fn suffix_len(&self) -> uint { match *self { - TyUs => 1, - TyU8 => 2, + TyUs(true) /* u */ => 1, + TyUs(false) /* us */ | TyU8 => 2, TyU16 | TyU32 | TyU64 => 3, } } diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs index b4e917e28cb..bc7fbd46fd8 100644 --- a/src/libsyntax/ast_util.rs +++ b/src/libsyntax/ast_util.rs @@ -127,8 +127,10 @@ pub fn is_path(e: P<Expr>) -> bool { /// We want to avoid "45int" and "-3int" in favor of "45" and "-3" pub fn int_ty_to_string(t: IntTy, val: Option<i64>) -> String { let s = match t { - TyIs if val.is_some() => "is", - TyIs => "isize", + TyIs(true) if val.is_some() => "i", + TyIs(true) => "int", + TyIs(false) if val.is_some() => "is", + TyIs(false) => "isize", TyI8 => "i8", TyI16 => "i16", TyI32 => "i32", @@ -148,7 +150,7 @@ pub fn int_ty_max(t: IntTy) -> u64 { match t { TyI8 => 0x80u64, TyI16 => 0x8000u64, - TyIs | TyI32 => 0x80000000u64, // actually ni about TyIs + TyIs(_) | TyI32 => 0x80000000u64, // actually ni about TyIs TyI64 => 0x8000000000000000u64 } } @@ -157,8 +159,10 @@ pub fn int_ty_max(t: IntTy) -> u64 { /// We want to avoid "42uint" in favor of "42u" pub fn uint_ty_to_string(t: UintTy, val: Option<u64>) -> String { let s = match t { - TyUs if val.is_some() => "us", - TyUs => "usize", + TyUs(true) if val.is_some() => "u", + TyUs(true) => "uint", + TyUs(false) if val.is_some() => "us", + TyUs(false) => "usize", TyU8 => "u8", TyU16 => "u16", TyU32 => "u32", @@ -175,7 +179,7 @@ pub fn uint_ty_max(t: UintTy) -> u64 { match t { TyU8 => 0xffu64, TyU16 => 0xffffu64, - TyUs | TyU32 => 0xffffffffu64, // actually ni about TyUs + TyUs(_) | TyU32 => 0xffffffffu64, // actually ni about TyUs TyU64 => 0xffffffffffffffffu64 } } diff --git a/src/libsyntax/attr.rs b/src/libsyntax/attr.rs index 2cea55dfc55..6f57c06d33e 100644 --- a/src/libsyntax/attr.rs +++ b/src/libsyntax/attr.rs @@ -464,10 +464,10 @@ fn int_type_of_word(s: &str) -> Option<IntType> { "u32" => Some(UnsignedInt(ast::TyU32)), "i64" => Some(SignedInt(ast::TyI64)), "u64" => Some(UnsignedInt(ast::TyU64)), - "int" => Some(SignedInt(ast::TyIs)), - "uint" => Some(UnsignedInt(ast::TyUs)), - "isize" => Some(SignedInt(ast::TyIs)), - "usize" => Some(UnsignedInt(ast::TyUs)), + "int" => Some(SignedInt(ast::TyIs(true))), + "uint" => Some(UnsignedInt(ast::TyUs(true))), + "isize" => Some(SignedInt(ast::TyIs(false))), + "usize" => Some(UnsignedInt(ast::TyUs(false))), _ => None } } @@ -511,7 +511,7 @@ impl IntType { SignedInt(ast::TyI16) | UnsignedInt(ast::TyU16) | SignedInt(ast::TyI32) | UnsignedInt(ast::TyU32) | SignedInt(ast::TyI64) | UnsignedInt(ast::TyU64) => true, - SignedInt(ast::TyIs) | UnsignedInt(ast::TyUs) => false + SignedInt(ast::TyIs(_)) | UnsignedInt(ast::TyUs(_)) => false } } } diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs index 27523ea4535..c34142aec39 100644 --- a/src/libsyntax/ext/build.rs +++ b/src/libsyntax/ext/build.rs @@ -642,10 +642,11 @@ impl<'a> AstBuilder for ExtCtxt<'a> { self.expr(sp, ast::ExprLit(P(respan(sp, lit)))) } fn expr_uint(&self, span: Span, i: uint) -> P<ast::Expr> { - self.expr_lit(span, ast::LitInt(i as u64, ast::UnsignedIntLit(ast::TyUs))) + self.expr_lit(span, ast::LitInt(i as u64, ast::UnsignedIntLit(ast::TyUs(false)))) } fn expr_int(&self, sp: Span, i: int) -> P<ast::Expr> { - self.expr_lit(sp, ast::LitInt(i as u64, ast::SignedIntLit(ast::TyIs, ast::Sign::new(i)))) + self.expr_lit(sp, ast::LitInt(i as u64, ast::SignedIntLit(ast::TyIs(false), + ast::Sign::new(i)))) } fn expr_u8(&self, sp: Span, u: u8) -> P<ast::Expr> { self.expr_lit(sp, ast::LitInt(u as u64, ast::UnsignedIntLit(ast::TyU8))) diff --git a/src/libsyntax/ext/deriving/generic/mod.rs b/src/libsyntax/ext/deriving/generic/mod.rs index 47b29a4db3e..e6b6f7bbd49 100644 --- a/src/libsyntax/ext/deriving/generic/mod.rs +++ b/src/libsyntax/ext/deriving/generic/mod.rs @@ -1031,7 +1031,7 @@ impl<'a> MethodDef<'a> { let arms: Vec<ast::Arm> = variants.iter().enumerate() .map(|(index, variant)| { let pat = variant_to_pat(cx, sp, type_ident, &**variant); - let lit = ast::LitInt(index as u64, ast::UnsignedIntLit(ast::TyUs)); + let lit = ast::LitInt(index as u64, ast::UnsignedIntLit(ast::TyUs(false))); cx.arm(sp, vec![pat], cx.expr_lit(sp, lit)) }).collect(); diff --git a/src/libsyntax/ext/deriving/rand.rs b/src/libsyntax/ext/deriving/rand.rs index 5517019f804..1359cada673 100644 --- a/src/libsyntax/ext/deriving/rand.rs +++ b/src/libsyntax/ext/deriving/rand.rs @@ -98,13 +98,13 @@ fn rand_substructure(cx: &mut ExtCtxt, trait_span: Span, substr: &Substructure) rand_name, vec!(rng.clone())); - // need to specify the uint-ness of the random number - let uint_ty = cx.ty_ident(trait_span, cx.ident_of("uint")); + // need to specify the usize-ness of the random number + let usize_ty = cx.ty_ident(trait_span, cx.ident_of("usize")); let value_ident = cx.ident_of("__value"); let let_statement = cx.stmt_let_typed(trait_span, false, value_ident, - uint_ty, + usize_ty, rv_call); // rand() % variants.len() diff --git a/src/libsyntax/ext/quote.rs b/src/libsyntax/ext/quote.rs index 2dbf29c145c..c42b188302c 100644 --- a/src/libsyntax/ext/quote.rs +++ b/src/libsyntax/ext/quote.rs @@ -244,10 +244,10 @@ pub mod rt { } macro_rules! impl_to_source_int { - (signed, $t:ty, $tag:ident) => ( + (signed, $t:ty, $tag:expr) => ( impl ToSource for $t { fn to_source(&self) -> String { - let lit = ast::LitInt(*self as u64, ast::SignedIntLit(ast::$tag, + let lit = ast::LitInt(*self as u64, ast::SignedIntLit($tag, ast::Sign::new(*self))); pprust::lit_to_string(&dummy_spanned(lit)) } @@ -258,10 +258,10 @@ pub mod rt { } } ); - (unsigned, $t:ty, $tag:ident) => ( + (unsigned, $t:ty, $tag:expr) => ( impl ToSource for $t { fn to_source(&self) -> String { - let lit = ast::LitInt(*self as u64, ast::UnsignedIntLit(ast::$tag)); + let lit = ast::LitInt(*self as u64, ast::UnsignedIntLit($tag)); pprust::lit_to_string(&dummy_spanned(lit)) } } @@ -273,17 +273,17 @@ pub mod rt { ); } - impl_to_source_int! { signed, int, TyIs } - impl_to_source_int! { signed, i8, TyI8 } - impl_to_source_int! { signed, i16, TyI16 } - impl_to_source_int! { signed, i32, TyI32 } - impl_to_source_int! { signed, i64, TyI64 } + impl_to_source_int! { signed, int, ast::TyIs(false) } + impl_to_source_int! { signed, i8, ast::TyI8 } + impl_to_source_int! { signed, i16, ast::TyI16 } + impl_to_source_int! { signed, i32, ast::TyI32 } + impl_to_source_int! { signed, i64, ast::TyI64 } - impl_to_source_int! { unsigned, uint, TyUs } - impl_to_source_int! { unsigned, u8, TyU8 } - impl_to_source_int! { unsigned, u16, TyU16 } - impl_to_source_int! { unsigned, u32, TyU32 } - impl_to_source_int! { unsigned, u64, TyU64 } + impl_to_source_int! { unsigned, uint, ast::TyUs(false) } + impl_to_source_int! { unsigned, u8, ast::TyU8 } + impl_to_source_int! { unsigned, u16, ast::TyU16 } + impl_to_source_int! { unsigned, u32, ast::TyU32 } + impl_to_source_int! { unsigned, u64, ast::TyU64 } // Alas ... we write these out instead. All redundant. diff --git a/src/libsyntax/feature_gate.rs b/src/libsyntax/feature_gate.rs index 2cfcd38d48f..8175c0a9eec 100644 --- a/src/libsyntax/feature_gate.rs +++ b/src/libsyntax/feature_gate.rs @@ -82,7 +82,7 @@ static KNOWN_FEATURES: &'static [(&'static str, Status)] = &[ ("issue_5723_bootstrap", Accepted), // A way to temporarily opt out of opt in copy. This will *never* be accepted. - ("opt_out_copy", Deprecated), + ("opt_out_copy", Removed), // A way to temporarily opt out of the new orphan rules. This will *never* be accepted. ("old_orphan_check", Deprecated), @@ -93,6 +93,9 @@ static KNOWN_FEATURES: &'static [(&'static str, Status)] = &[ // OIBIT specific features ("optin_builtin_traits", Active), + // int and uint are now deprecated + ("int_uint", Active), + // These are used to test this portion of the compiler, they don't actually // mean anything ("test_accepted_feature", Accepted), @@ -123,7 +126,6 @@ pub struct Features { pub import_shadowing: bool, pub visible_private_types: bool, pub quote: bool, - pub opt_out_copy: bool, pub old_orphan_check: bool, } @@ -135,7 +137,6 @@ impl Features { import_shadowing: false, visible_private_types: false, quote: false, - opt_out_copy: false, old_orphan_check: false, } } @@ -157,6 +158,14 @@ impl<'a> Context<'a> { } } + fn warn_feature(&self, feature: &str, span: Span, explain: &str) { + if !self.has_feature(feature) { + self.span_handler.span_warn(span, explain); + self.span_handler.span_help(span, &format!("add #![feature({})] to the \ + crate attributes to silence this warning", + feature)[]); + } + } fn has_feature(&self, feature: &str) -> bool { self.features.iter().any(|&n| n == feature) } @@ -334,6 +343,31 @@ impl<'a, 'v> Visitor<'v> for PostExpansionVisitor<'a> { } fn visit_ty(&mut self, t: &ast::Ty) { + match t.node { + ast::TyPath(ref p, _) => { + match &*p.segments { + + [ast::PathSegment { identifier, .. }] => { + let name = token::get_ident(identifier); + let msg = if name == "int" { + Some("the `int` type is deprecated; \ + use `isize` or a fixed-sized integer") + } else if name == "uint" { + Some("the `uint` type is deprecated; \ + use `usize` or a fixed-sized integer") + } else { + None + }; + + if let Some(msg) = msg { + self.context.warn_feature("int_uint", t.span, msg) + } + } + _ => {} + } + } + _ => {} + } visit::walk_ty(self, t); } @@ -345,6 +379,25 @@ impl<'a, 'v> Visitor<'v> for PostExpansionVisitor<'a> { "box expression syntax is experimental in alpha release; \ you can call `Box::new` instead."); } + ast::ExprLit(ref lit) => { + match lit.node { + ast::LitInt(_, ty) => { + let msg = if let ast::SignedIntLit(ast::TyIs(true), _) = ty { + Some("the `i` suffix on integers is deprecated; use `is` \ + or one of the fixed-sized suffixes") + } else if let ast::UnsignedIntLit(ast::TyUs(true)) = ty { + Some("the `u` suffix on integers is deprecated; use `us` \ + or one of the fixed-sized suffixes") + } else { + None + }; + if let Some(msg) = msg { + self.context.warn_feature("int_uint", e.span, msg); + } + } + _ => {} + } + } _ => {} } visit::walk_expr(self, e); @@ -465,7 +518,6 @@ fn check_crate_inner<F>(cm: &CodeMap, span_handler: &SpanHandler, krate: &ast::C import_shadowing: cx.has_feature("import_shadowing"), visible_private_types: cx.has_feature("visible_private_types"), quote: cx.has_feature("quote"), - opt_out_copy: cx.has_feature("opt_out_copy"), old_orphan_check: cx.has_feature("old_orphan_check"), }, unknown_features) diff --git a/src/libsyntax/lib.rs b/src/libsyntax/lib.rs index 1efd6a87f86..9c947f422e9 100644 --- a/src/libsyntax/lib.rs +++ b/src/libsyntax/lib.rs @@ -15,7 +15,7 @@ //! This API is completely unstable and subject to change. #![crate_name = "syntax"] -#![experimental] +#![unstable] #![staged_api] #![crate_type = "dylib"] #![crate_type = "rlib"] @@ -27,6 +27,7 @@ #![feature(slicing_syntax)] #![feature(box_syntax)] #![feature(quote, unsafe_destructor)] +#![allow(unknown_features)] #![feature(int_uint)] extern crate arena; extern crate fmt_macros; diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs index c42a6beea2d..f1f547ba0c7 100644 --- a/src/libsyntax/parse/mod.rs +++ b/src/libsyntax/parse/mod.rs @@ -702,14 +702,14 @@ pub fn integer_lit(s: &str, suffix: Option<&str>, sd: &SpanHandler, sp: Span) -> if let Some(suf) = suffix { if suf.is_empty() { sd.span_bug(sp, "found empty literal suffix in Some")} ty = match suf { - "i" => ast::SignedIntLit(ast::TyIs, ast::Plus), - "is" => ast::SignedIntLit(ast::TyIs, ast::Plus), + "i" => ast::SignedIntLit(ast::TyIs(true), ast::Plus), + "is" => ast::SignedIntLit(ast::TyIs(false), ast::Plus), "i8" => ast::SignedIntLit(ast::TyI8, ast::Plus), "i16" => ast::SignedIntLit(ast::TyI16, ast::Plus), "i32" => ast::SignedIntLit(ast::TyI32, ast::Plus), "i64" => ast::SignedIntLit(ast::TyI64, ast::Plus), - "u" => ast::UnsignedIntLit(ast::TyUs), - "us" => ast::UnsignedIntLit(ast::TyUs), + "u" => ast::UnsignedIntLit(ast::TyUs(true)), + "us" => ast::UnsignedIntLit(ast::TyUs(false)), "u8" => ast::UnsignedIntLit(ast::TyU8), "u16" => ast::UnsignedIntLit(ast::TyU16), "u32" => ast::UnsignedIntLit(ast::TyU32), diff --git a/src/libterm/lib.rs b/src/libterm/lib.rs index b4f224cb4a7..2117b68c08e 100644 --- a/src/libterm/lib.rs +++ b/src/libterm/lib.rs @@ -39,7 +39,7 @@ //! [ti]: https://en.wikipedia.org/wiki/Terminfo #![crate_name = "term"] -#![experimental = "use the crates.io `term` library instead"] +#![unstable = "use the crates.io `term` library instead"] #![staged_api] #![crate_type = "rlib"] #![crate_type = "dylib"] @@ -51,6 +51,7 @@ #![allow(unknown_features)] #![feature(slicing_syntax)] #![feature(box_syntax)] +#![allow(unknown_features)] #![feature(int_uint)] #![deny(missing_docs)] #[macro_use] extern crate log; diff --git a/src/libtest/lib.rs b/src/libtest/lib.rs index d04308814f8..c4cb53d6cb7 100644 --- a/src/libtest/lib.rs +++ b/src/libtest/lib.rs @@ -24,7 +24,7 @@ // build off of. #![crate_name = "test"] -#![experimental] +#![unstable] #![staged_api] #![crate_type = "rlib"] #![crate_type = "dylib"] @@ -34,6 +34,7 @@ #![allow(unknown_features)] #![feature(asm, slicing_syntax)] #![feature(box_syntax)] +#![allow(unknown_features)] #![feature(int_uint)] extern crate getopts; extern crate regex; diff --git a/src/libunicode/lib.rs b/src/libunicode/lib.rs index 27255cc33ee..17607383bee 100644 --- a/src/libunicode/lib.rs +++ b/src/libunicode/lib.rs @@ -21,7 +21,7 @@ //! (yet) aim to provide a full set of Unicode tables. #![crate_name = "unicode"] -#![experimental] +#![unstable] #![staged_api] #![crate_type = "rlib"] #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png", @@ -30,6 +30,7 @@ html_playground_url = "http://play.rust-lang.org/")] #![no_std] #![feature(slicing_syntax)] +#![allow(unknown_features)] #![feature(int_uint)] extern crate core; diff --git a/src/libunicode/u_char.rs b/src/libunicode/u_char.rs index 5693c222de1..4142a62ba66 100644 --- a/src/libunicode/u_char.rs +++ b/src/libunicode/u_char.rs @@ -112,7 +112,7 @@ pub trait CharExt { /// 'XID_Start' is a Unicode Derived Property specified in /// [UAX #31](http://unicode.org/reports/tr31/#NFKC_Modifications), /// mostly similar to ID_Start but modified for closure under NFKx. - #[experimental = "mainly needed for compiler internals"] + #[unstable = "mainly needed for compiler internals"] fn is_xid_start(self) -> bool; /// Returns whether the specified `char` satisfies the 'XID_Continue' @@ -121,7 +121,7 @@ pub trait CharExt { /// 'XID_Continue' is a Unicode Derived Property specified in /// [UAX #31](http://unicode.org/reports/tr31/#NFKC_Modifications), /// mostly similar to 'ID_Continue' but modified for closure under NFKx. - #[experimental = "mainly needed for compiler internals"] + #[unstable = "mainly needed for compiler internals"] fn is_xid_continue(self) -> bool; /// Indicates whether a character is in lowercase. @@ -171,7 +171,7 @@ pub trait CharExt { /// /// Returns the lowercase equivalent of the character, or the character /// itself if no conversion is possible. - #[experimental = "pending case transformation decisions"] + #[unstable = "pending case transformation decisions"] fn to_lowercase(self) -> char; /// Converts a character to its uppercase equivalent. @@ -194,7 +194,7 @@ pub trait CharExt { /// [`SpecialCasing`.txt`]: ftp://ftp.unicode.org/Public/UNIDATA/SpecialCasing.txt /// /// [2]: http://www.unicode.org/versions/Unicode4.0.0/ch03.pdf#G33992 - #[experimental = "pending case transformation decisions"] + #[unstable = "pending case transformation decisions"] fn to_uppercase(self) -> char; /// Returns this character's displayed width in columns, or `None` if it is a @@ -206,7 +206,7 @@ pub trait CharExt { /// [Unicode Standard Annex #11](http://www.unicode.org/reports/tr11/) /// recommends that these characters be treated as 1 column (i.e., /// `is_cjk` = `false`) if the context cannot be reliably determined. - #[experimental = "needs expert opinion. is_cjk flag stands out as ugly"] + #[unstable = "needs expert opinion. is_cjk flag stands out as ugly"] fn width(self, is_cjk: bool) -> Option<uint>; } @@ -238,10 +238,10 @@ impl CharExt for char { } } - #[experimental = "mainly needed for compiler internals"] + #[unstable = "mainly needed for compiler internals"] fn is_xid_start(self) -> bool { derived_property::XID_Start(self) } - #[experimental = "mainly needed for compiler internals"] + #[unstable = "mainly needed for compiler internals"] fn is_xid_continue(self) -> bool { derived_property::XID_Continue(self) } #[stable] @@ -288,12 +288,12 @@ impl CharExt for char { } } - #[experimental = "pending case transformation decisions"] + #[unstable = "pending case transformation decisions"] fn to_lowercase(self) -> char { conversions::to_lower(self) } - #[experimental = "pending case transformation decisions"] + #[unstable = "pending case transformation decisions"] fn to_uppercase(self) -> char { conversions::to_upper(self) } - #[experimental = "needs expert opinion. is_cjk flag stands out as ugly"] + #[unstable = "needs expert opinion. is_cjk flag stands out as ugly"] fn width(self, is_cjk: bool) -> Option<uint> { charwidth::width(self, is_cjk) } } diff --git a/src/rustbook/book.rs b/src/rustbook/book.rs new file mode 100644 index 00000000000..1d16de2a2fe --- /dev/null +++ b/src/rustbook/book.rs @@ -0,0 +1,166 @@ +// 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. + +//! Basic data structures for representing a book. + +use std::io::BufferedReader; +use std::iter; +use std::iter::AdditiveIterator; +use regex::Regex; + +pub struct BookItem { + pub title: String, + pub path: Path, + pub path_to_root: Path, + pub children: Vec<BookItem>, +} + +pub struct Book { + pub chapters: Vec<BookItem>, +} + +/// A depth-first iterator over a book. +pub struct BookItems<'a> { + cur_items: &'a [BookItem], + cur_idx: usize, + stack: Vec<(&'a [BookItem], usize)>, +} + +impl<'a> Iterator for BookItems<'a> { + type Item = (String, &'a BookItem); + + fn next(&mut self) -> Option<(String, &'a BookItem)> { + loop { + if self.cur_idx >= self.cur_items.len() { + match self.stack.pop() { + None => return None, + Some((parent_items, parent_idx)) => { + self.cur_items = parent_items; + self.cur_idx = parent_idx + 1; + } + } + } else { + let cur = self.cur_items.get(self.cur_idx).unwrap(); + + let mut section = "".to_string(); + for &(_, idx) in self.stack.iter() { + section.push_str(&(idx + 1).to_string()[]); + section.push('.'); + } + section.push_str(&(self.cur_idx + 1).to_string()[]); + section.push('.'); + + self.stack.push((self.cur_items, self.cur_idx)); + self.cur_items = &cur.children[]; + self.cur_idx = 0; + return Some((section, cur)) + } + } + } +} + +impl Book { + pub fn iter(&self) -> BookItems { + BookItems { + cur_items: &self.chapters[], + cur_idx: 0, + stack: Vec::new(), + } + } +} + +/// Construct a book by parsing a summary (markdown table of contents). +pub fn parse_summary<R: Reader>(input: R, src: &Path) -> Result<Book, Vec<String>> { + fn collapse(stack: &mut Vec<BookItem>, + top_items: &mut Vec<BookItem>, + to_level: usize) { + loop { + if stack.len() < to_level { return } + if stack.len() == 1 { + top_items.push(stack.pop().unwrap()); + return; + } + + let tip = stack.pop().unwrap(); + let last = stack.len() - 1; + stack[last].children.push(tip); + } + } + + let regex = r"(?P<indent>[\t ]*)\*[:space:]*\[(?P<title>.*)\]\((?P<path>.*)\)"; + let item_re = Regex::new(regex).unwrap(); + let mut top_items = vec!(); + let mut stack = vec!(); + let mut errors = vec!(); + + // always include the introduction + top_items.push(BookItem { + title: "Introduction".to_string(), + path: Path::new("README.md"), + path_to_root: Path::new("."), + children: vec!(), + }); + + for line_result in BufferedReader::new(input).lines() { + let line = match line_result { + Ok(line) => line, + Err(err) => { + errors.push(err.desc.to_string()); // FIXME: include detail + return Err(errors); + } + }; + + item_re.captures(&line[]).map(|cap| { + let given_path = cap.name("path"); + let title = cap.name("title").unwrap().to_string(); + + let path_from_root = match src.join(given_path.unwrap()).path_relative_from(src) { + Some(p) => p, + None => { + errors.push(format!("Paths in SUMMARY.md must be relative, \ + but path '{}' for section '{}' is not.", + given_path.unwrap(), title)); + Path::new("") + } + }; + let path_to_root = Path::new(iter::repeat("../") + .take(path_from_root.components().count() - 1) + .collect::<String>()); + let item = BookItem { + title: title, + path: path_from_root, + path_to_root: path_to_root, + children: vec!(), + }; + let level = cap.name("indent").unwrap().chars().map(|c| { + match c { + ' ' => 1us, + '\t' => 4, + _ => unreachable!() + } + }).sum() / 4 + 1; + + if level > stack.len() + 1 { + // FIXME: better error message + errors.push(format!("Section '{}' is indented too many levels.", item.title)); + } else if level <= stack.len() { + collapse(&mut stack, &mut top_items, level); + } + stack.push(item) + }); + } + + if errors.is_empty() { + collapse(&mut stack, &mut top_items, 1); + Ok(Book { chapters: top_items }) + } else { + Err(errors) + } +} diff --git a/src/rustbook/build.rs b/src/rustbook/build.rs new file mode 100644 index 00000000000..1cb5e38e190 --- /dev/null +++ b/src/rustbook/build.rs @@ -0,0 +1,192 @@ +// 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. + +//! Implementation of the `build` subcommand, used to compile a book. + +use std::os; +use std::io; +use std::io::{fs, File, BufferedWriter, TempDir, IoResult}; + +use subcommand::Subcommand; +use term::Term; +use error::{Error, CliResult, CommandResult}; +use book; +use book::{Book, BookItem}; +use css; + +use regex::Regex; + +use rustdoc; + +struct Build; + +pub fn parse_cmd(name: &str) -> Option<Box<Subcommand>> { + if name == "build" { + Some(box Build as Box<Subcommand>) + } else { + None + } +} + +fn write_toc(book: &Book, path_to_root: &Path, out: &mut Writer) -> IoResult<()> { + fn walk_items(items: &[BookItem], + section: &str, + path_to_root: &Path, + out: &mut Writer) -> IoResult<()> { + for (i, item) in items.iter().enumerate() { + try!(walk_item(item, &format!("{}{}.", section, i + 1)[], path_to_root, out)); + } + Ok(()) + } + fn walk_item(item: &BookItem, + section: &str, + path_to_root: &Path, + out: &mut Writer) -> IoResult<()> { + try!(writeln!(out, "<li><a href='{}'><b>{}</b> {}</a>", + path_to_root.join(item.path.with_extension("html")).display(), + section, + item.title)); + if !item.children.is_empty() { + try!(writeln!(out, "<ul class='section'>")); + let _ = walk_items(&item.children[], section, path_to_root, out); + try!(writeln!(out, "</ul>")); + } + try!(writeln!(out, "</li>")); + + Ok(()) + } + + try!(writeln!(out, "<div id='toc'>")); + try!(writeln!(out, "<ul class='chapter'>")); + try!(walk_items(&book.chapters[], "", path_to_root, out)); + try!(writeln!(out, "</ul>")); + try!(writeln!(out, "</div>")); + + Ok(()) +} + +fn render(book: &Book, tgt: &Path) -> CliResult<()> { + let tmp = TempDir::new("rust-book") + .ok() + // FIXME: lift to Result instead + .expect("could not create temporary directory"); + + for (section, item) in book.iter() { + println!("{} {}", section, item.title); + + let out_path = tgt.join(item.path.dirname()); + + let regex = r"\[(?P<title>[^]]*)\]\((?P<url_stem>[^)]*)\.(?P<ext>md|markdown)\)"; + let md_urls = Regex::new(regex).unwrap(); + + let src; + if os::args().len() < 3 { + src = os::getcwd().unwrap().clone(); + } else { + src = Path::new(os::args()[2].clone()); + } + // preprocess the markdown, rerouting markdown references to html references + let markdown_data = try!(File::open(&src.join(&item.path)).read_to_string()); + let preprocessed_path = tmp.path().join(item.path.filename().unwrap()); + { + let urls = md_urls.replace_all(&markdown_data[], "[$title]($url_stem.html)"); + try!(File::create(&preprocessed_path) + .write_str(&urls[])); + } + + // write the prelude to a temporary HTML file for rustdoc inclusion + let prelude = tmp.path().join("prelude.html"); + { + let mut toc = BufferedWriter::new(try!(File::create(&prelude))); + let _ = write_toc(book, &item.path_to_root, &mut toc); + try!(writeln!(&mut toc, "<div id='page-wrapper'>")); + try!(writeln!(&mut toc, "<div id='page'>")); + } + + // write the postlude to a temporary HTML file for rustdoc inclusion + let postlude = tmp.path().join("postlude.html"); + { + let mut toc = BufferedWriter::new(try!(File::create(&postlude))); + try!(writeln!(&mut toc, "</div></div>")); + } + + try!(fs::mkdir_recursive(&out_path, io::USER_DIR)); + + let rustdoc_args: &[String] = &[ + "".to_string(), + preprocessed_path.display().to_string(), + format!("-o{}", out_path.display()), + format!("--html-before-content={}", prelude.display()), + format!("--html-after-content={}", postlude.display()), + format!("--markdown-css={}", item.path_to_root.join("rust-book.css").display()), + "--markdown-no-toc".to_string(), + ]; + let output_result = rustdoc::main_args(rustdoc_args); + if output_result != 0 { + let message = format!("Could not execute `rustdoc` with {:?}: {}", + rustdoc_args, output_result); + return Err(box message as Box<Error>); + } + } + + // create index.html from the root README + try!(fs::copy(&tgt.join("README.html"), &tgt.join("index.html"))); + Ok(()) +} + +impl Subcommand for Build { + fn parse_args(&mut self, _: &[String]) -> CliResult<()> { + Ok(()) + } + fn usage(&self) {} + fn execute(&mut self, term: &mut Term) -> CommandResult<()> { + let cwd = os::getcwd().unwrap(); + let src; + let tgt; + + if os::args().len() < 3 { + src = cwd.clone(); + } else { + src = Path::new(os::args()[2].clone()); + } + + if os::args().len() < 4 { + tgt = cwd.join("_book"); + } else { + tgt = Path::new(os::args()[3].clone()); + } + + let _ = fs::mkdir(&tgt, io::USER_DIR); // FIXME: handle errors + + // FIXME: handle errors + let _ = File::create(&tgt.join("rust-book.css")).write_str(css::STYLE); + + let summary = File::open(&src.join("SUMMARY.md")); + match book::parse_summary(summary, &src) { + Ok(book) => { + // execute rustdoc on the whole book + try!(render(&book, &tgt).map_err(|err| { + term.err(&format!("error: {}", err.description())[]); + err.detail().map(|detail| { + term.err(&format!("detail: {}", detail)[]); + }); + err + })) + } + Err(errors) => { + for err in errors.into_iter() { + term.err(&err[]); + } + } + } + + Ok(()) // lol + } +} diff --git a/src/rustbook/css.rs b/src/rustbook/css.rs new file mode 100644 index 00000000000..8eb66e71d3a --- /dev/null +++ b/src/rustbook/css.rs @@ -0,0 +1,72 @@ +// 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. + +// The rust-book CSS in string form. + +pub static STYLE: &'static str = r#" +@import url("//static.rust-lang.org/doc/master/rust.css"); + +body { + max-width:none; +} + +#toc { + position: absolute; + left: 0px; + top: 0px; + bottom: 0px; + width: 250px; + overflow-y: auto; + border-right: 1px solid rgba(0, 0, 0, 0.07); + padding: 10px 10px; + font-size: 16px; + background: none repeat scroll 0% 0% #FFF; + box-sizing: border-box; +} + +#page-wrapper { + position: absolute; + overflow-y: auto; + left: 260px; + right: 0px; + top: 0px; + bottom: 0px; + box-sizing: border-box; + background: none repeat scroll 0% 0% #FFF; +} + +#page { + margin-left: auto; + margin-right:auto; + width: 750px; +} + +.chapter { + list-style: none outside none; + padding-left: 0px; + line-height: 30px; +} + +.section { + list-style: none outside none; + padding-left: 20px; + line-height: 30px; +} + +.section li { + text-overflow: ellipsis; + overflow: hidden; + white-space: nowrap; +} + +.chapter li a { + color: #000000; +} +"#; diff --git a/src/rustbook/error.rs b/src/rustbook/error.rs new file mode 100644 index 00000000000..a5915ed4d73 --- /dev/null +++ b/src/rustbook/error.rs @@ -0,0 +1,82 @@ +// 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. + +//! Error handling utilities. WIP. + +use std::fmt; +use std::fmt::{Show, Formatter}; + +use std::io::IoError; + +pub type CliError = Box<Error + 'static>; +pub type CliResult<T> = Result<T, CliError>; + +pub type CommandError = Box<Error + 'static>; +pub type CommandResult<T> = Result<T, CommandError>; + +pub trait Error { + fn description(&self) -> &str; + + fn detail(&self) -> Option<&str> { None } + fn cause(&self) -> Option<&Error> { None } +} + +pub trait FromError<E> { + fn from_err(err: E) -> Self; +} + +impl Show for Box<Error + 'static> { + fn fmt(&self, f: &mut Formatter) -> fmt::Result { + write!(f, "{}", self.description()) + } +} + +impl<E: Error + 'static> FromError<E> for Box<Error + 'static> { + fn from_err(err: E) -> Box<Error + 'static> { + box err as Box<Error> + } +} + +impl<'a> Error for &'a str { + fn description<'b>(&'b self) -> &'b str { + *self + } +} + +impl Error for String { + fn description<'a>(&'a self) -> &'a str { + &self[] + } +} + +impl<'a> Error for Box<Error + 'a> { + fn description(&self) -> &str { (**self).description() } + fn detail(&self) -> Option<&str> { (**self).detail() } + fn cause(&self) -> Option<&Error> { (**self).cause() } +} + +impl FromError<()> for () { + fn from_err(_: ()) -> () { () } +} + +impl FromError<IoError> for IoError { + fn from_err(error: IoError) -> IoError { error } +} + +impl Error for IoError { + fn description(&self) -> &str { + self.desc + } + fn detail(&self) -> Option<&str> { + self.detail.as_ref().map(|s| &s[]) + } +} + +//fn iter_map_err<T, U, E, I: Iterator<Result<T,E>>>(iter: I, diff --git a/src/rustbook/help.rs b/src/rustbook/help.rs new file mode 100644 index 00000000000..7fd8214f731 --- /dev/null +++ b/src/rustbook/help.rs @@ -0,0 +1,46 @@ +// Copyright 2014 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +//! Implementation of the `help` subcommand. Currently just prints basic usage info. + +use subcommand::Subcommand; +use error::CliResult; +use error::CommandResult; +use term::Term; + +struct Help; + +pub fn parse_cmd(name: &str) -> Option<Box<Subcommand>> { + match name { + "help" | "--help" | "-h" | "-?" => Some(box Help as Box<Subcommand>), + _ => None + } +} + +impl Subcommand for Help { + fn parse_args(&mut self, _: &[String]) -> CliResult<()> { + Ok(()) + } + fn usage(&self) {} + fn execute(&mut self, _: &mut Term) -> CommandResult<()> { + usage(); + Ok(()) + } +} + +pub fn usage() { + println!("Usage: rust-book <command> [<args>]"); + println!(""); + println!("The <command> must be one of:"); + println!(" help Print this message."); + println!(" build Build the book in subdirectory _book"); + println!(" serve --NOT YET IMPLEMENTED--"); + println!(" test --NOT YET IMPLEMENTED--"); +} diff --git a/src/rustbook/main.rs b/src/rustbook/main.rs new file mode 100644 index 00000000000..acb4edb7a45 --- /dev/null +++ b/src/rustbook/main.rs @@ -0,0 +1,74 @@ +// Copyright 2014 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +#![feature(slicing_syntax, box_syntax)] + +extern crate regex; + +extern crate rustdoc; + +use std::os; +use subcommand::Subcommand; +use term::Term; + +macro_rules! try ( + ($expr:expr) => ({ + use error; + match $expr { + Ok(val) => val, + Err(err) => return Err(error::FromError::from_err(err)) + } + }) +); + +mod term; +mod error; +mod book; + +mod subcommand; +mod help; +mod build; +mod serve; +mod test; + +mod css; + +#[cfg(not(test))] // thanks #12327 +fn main() { + let mut term = Term::new(); + let cmd = os::args(); + + if cmd.len() < 1 { + help::usage() + } else { + match subcommand::parse_name(&cmd[1][]) { + Some(mut subcmd) => { + match subcmd.parse_args(cmd.tail()) { + Ok(_) => { + match subcmd.execute(&mut term) { + Ok(_) => (), + Err(_) => os::set_exit_status(-1), + } + } + Err(err) => { + println!("{}", err.description()); + println!(""); + subcmd.usage(); + } + } + } + None => { + println!("Unrecognized command '{}'.", cmd[1]); + println!(""); + help::usage(); + } + } + } +} diff --git a/src/rustbook/serve.rs b/src/rustbook/serve.rs new file mode 100644 index 00000000000..808527dcef9 --- /dev/null +++ b/src/rustbook/serve.rs @@ -0,0 +1,36 @@ +// Copyright 2014 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +//! Implementation of the `serve` subcommand. Just a stub for now. + +use subcommand::Subcommand; +use error::CliResult; +use error::CommandResult; +use term::Term; + +struct Serve; + +pub fn parse_cmd(name: &str) -> Option<Box<Subcommand>> { + if name == "serve" { + Some(box Serve as Box<Subcommand>) + } else { + None + } +} + +impl Subcommand for Serve { + fn parse_args(&mut self, _: &[String]) -> CliResult<()> { + Ok(()) + } + fn usage(&self) {} + fn execute(&mut self, _: &mut Term) -> CommandResult<()> { + Ok(()) + } +} diff --git a/src/rustbook/subcommand.rs b/src/rustbook/subcommand.rs new file mode 100644 index 00000000000..473739c919d --- /dev/null +++ b/src/rustbook/subcommand.rs @@ -0,0 +1,44 @@ +// 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. + +//! Common API for all rust-book subcommands. + +use error::CliResult; +use error::CommandResult; +use term::Term; + +use help; +use build; +use serve; +use test; + +pub trait Subcommand { + /// Mutate the subcommand by parsing its arguments. + /// + /// Returns `Err` on a parsing error. + fn parse_args(&mut self, args: &[String]) -> CliResult<()>; + /// Print the CLI usage information. + fn usage(&self); + /// Actually execute the subcommand. + fn execute(&mut self, term: &mut Term) -> CommandResult<()>; +} + +/// Create a Subcommand object based on its name. +pub fn parse_name(name: &str) -> Option<Box<Subcommand>> { + for parser in [ + help::parse_cmd as fn(&str) -> Option<Box<Subcommand>>, + build::parse_cmd as fn(&str) -> Option<Box<Subcommand>>, + serve::parse_cmd as fn(&str) -> Option<Box<Subcommand>>, + test::parse_cmd as fn(&str) -> Option<Box<Subcommand>>].iter() { + let parsed = (*parser)(name); + if parsed.is_some() { return parsed } + } + None +} diff --git a/src/rustbook/term.rs b/src/rustbook/term.rs new file mode 100644 index 00000000000..471e22ce7c1 --- /dev/null +++ b/src/rustbook/term.rs @@ -0,0 +1,33 @@ +// Copyright 2014 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +//! An abstraction of the terminal. Eventually, provide color and +//! verbosity support. For now, just a wrapper around stdout/stderr. + +use std::os; +use std::io::stdio; + +pub struct Term { + err: Box<Writer + 'static> +} + +impl Term { + pub fn new() -> Term { + Term { + err: box stdio::stderr() as Box<Writer>, + } + } + + pub fn err(&mut self, msg: &str) { + // swallow any errors + let _ = self.err.write_line(msg); + os::set_exit_status(101); + } +} diff --git a/src/rustbook/test.rs b/src/rustbook/test.rs new file mode 100644 index 00000000000..f2bf92585f7 --- /dev/null +++ b/src/rustbook/test.rs @@ -0,0 +1,75 @@ +// 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. + +//! Implementation of the `test` subcommand. Just a stub for now. + +use subcommand::Subcommand; +use error::CliResult; +use error::CommandResult; +use error::Error; +use term::Term; +use book; +use std::io::{Command, File}; +use std::os; + +struct Test; + +pub fn parse_cmd(name: &str) -> Option<Box<Subcommand>> { + if name == "test" { + Some(box Test as Box<Subcommand>) + } else { + None + } +} + +impl Subcommand for Test { + fn parse_args(&mut self, _: &[String]) -> CliResult<()> { + Ok(()) + } + fn usage(&self) {} + fn execute(&mut self, term: &mut Term) -> CommandResult<()> { + let cwd = os::getcwd().unwrap(); + let src = cwd.clone(); + + let summary = File::open(&src.join("SUMMARY.md")); + match book::parse_summary(summary, &src) { + Ok(book) => { + for (_, item) in book.iter() { + let output_result = Command::new("rustdoc") + .arg(&item.path) + .arg("--test") + .output(); + match output_result { + Ok(output) => { + if !output.status.success() { + term.err(&format!("{}\n{}", + String::from_utf8_lossy(&output.output[]), + String::from_utf8_lossy(&output.error[]))[]); + return Err(box "Some tests failed." as Box<Error>); + } + + } + Err(e) => { + let message = format!("Could not execute `rustdoc`: {}", e); + return Err(box message as Box<Error>); + } + } + } + } + Err(errors) => { + for err in errors.into_iter() { + term.err(&err[]); + } + return Err(box "There was an error." as Box<Error>); + } + } + Ok(()) // lol + } +} diff --git a/src/test/auxiliary/inherited_stability.rs b/src/test/auxiliary/inherited_stability.rs index 5691ce3bfa7..7a01ce3de0b 100644 --- a/src/test/auxiliary/inherited_stability.rs +++ b/src/test/auxiliary/inherited_stability.rs @@ -9,7 +9,8 @@ // except according to those terms. #![crate_name="inherited_stability"] #![crate_type = "lib"] -#![experimental] +#![unstable] +#![staged_api] pub fn experimental() {} @@ -26,7 +27,7 @@ pub mod stable_mod { #[unstable] pub mod unstable_mod { - #[experimental] + #[unstable] pub fn experimental() {} pub fn unstable() {} diff --git a/src/test/auxiliary/lint_output_format.rs b/src/test/auxiliary/lint_output_format.rs index 181b651ef52..adbb90fe6c8 100755 --- a/src/test/auxiliary/lint_output_format.rs +++ b/src/test/auxiliary/lint_output_format.rs @@ -10,13 +10,14 @@ #![crate_name="lint_output_format"] #![crate_type = "lib"] +#![staged_api] #[deprecated] pub fn foo() -> uint { 20 } -#[experimental] +#[unstable] pub fn bar() -> uint { 40 } diff --git a/src/test/auxiliary/lint_stability.rs b/src/test/auxiliary/lint_stability.rs index 708830d0259..73724713b21 100644 --- a/src/test/auxiliary/lint_stability.rs +++ b/src/test/auxiliary/lint_stability.rs @@ -9,15 +9,16 @@ // except according to those terms. #![crate_name="lint_stability"] #![crate_type = "lib"] +#![staged_api] #[deprecated] pub fn deprecated() {} #[deprecated="text"] pub fn deprecated_text() {} -#[experimental] +#[unstable] pub fn experimental() {} -#[experimental="text"] +#[unstable="text"] pub fn experimental_text() {} #[unstable] @@ -51,9 +52,9 @@ impl MethodTester { #[deprecated="text"] pub fn method_deprecated_text(&self) {} - #[experimental] + #[unstable] pub fn method_experimental(&self) {} - #[experimental="text"] + #[unstable="text"] pub fn method_experimental_text(&self) {} #[unstable] @@ -85,9 +86,9 @@ pub trait Trait { #[deprecated="text"] fn trait_deprecated_text(&self) {} - #[experimental] + #[unstable] fn trait_experimental(&self) {} - #[experimental="text"] + #[unstable="text"] fn trait_experimental_text(&self) {} #[unstable] @@ -115,12 +116,12 @@ pub trait Trait { impl Trait for MethodTester {} -#[experimental] +#[unstable] pub trait ExperimentalTrait {} #[deprecated] pub struct DeprecatedStruct { pub i: int } -#[experimental] +#[unstable] pub struct ExperimentalStruct { pub i: int } #[unstable] pub struct UnstableStruct { pub i: int } @@ -134,7 +135,7 @@ pub struct LockedStruct { pub i: int } #[deprecated] pub struct DeprecatedUnitStruct; -#[experimental] +#[unstable] pub struct ExperimentalUnitStruct; #[unstable] pub struct UnstableUnitStruct; @@ -149,7 +150,7 @@ pub struct LockedUnitStruct; pub enum Enum { #[deprecated] DeprecatedVariant, - #[experimental] + #[unstable] ExperimentalVariant, #[unstable] UnstableVariant, @@ -165,7 +166,7 @@ pub enum Enum { #[deprecated] pub struct DeprecatedTupleStruct(pub int); -#[experimental] +#[unstable] pub struct ExperimentalTupleStruct(pub int); #[unstable] pub struct UnstableTupleStruct(pub int); diff --git a/src/test/auxiliary/stability_cfg1.rs b/src/test/auxiliary/stability_cfg1.rs index 6b2e8e7758f..de806c65beb 100644 --- a/src/test/auxiliary/stability_cfg1.rs +++ b/src/test/auxiliary/stability_cfg1.rs @@ -10,3 +10,4 @@ #![cfg_attr(foo, experimental)] #![cfg_attr(not(foo), stable)] +#![staged_api] diff --git a/src/test/auxiliary/stability_cfg2.rs b/src/test/auxiliary/stability_cfg2.rs index 3387b319abf..842f35b08ae 100644 --- a/src/test/auxiliary/stability_cfg2.rs +++ b/src/test/auxiliary/stability_cfg2.rs @@ -10,6 +10,6 @@ // compile-flags:--cfg foo -#![cfg_attr(foo, experimental)] +#![cfg_attr(foo, unstable)] #![cfg_attr(not(foo), stable)] - +#![staged_api] diff --git a/src/test/bench/shootout-mandelbrot.rs b/src/test/bench/shootout-mandelbrot.rs index f6124c1271f..cf1264ff5d6 100644 --- a/src/test/bench/shootout-mandelbrot.rs +++ b/src/test/bench/shootout-mandelbrot.rs @@ -39,7 +39,7 @@ // OF THE POSSIBILITY OF SUCH DAMAGE. #![feature(simd)] -#![allow(experimental)] +#![allow(unstable)] // ignore-pretty very bad with line comments diff --git a/src/test/compile-fail-fulldeps/issue-18986.rs b/src/test/compile-fail-fulldeps/issue-18986.rs index 25d78c273e7..6845116e4a4 100644 --- a/src/test/compile-fail-fulldeps/issue-18986.rs +++ b/src/test/compile-fail-fulldeps/issue-18986.rs @@ -15,6 +15,6 @@ pub use use_from_trait_xc::Trait; fn main() { match () { - Trait { x: 42u } => () //~ ERROR use of trait `Trait` in a struct pattern + Trait { x: 42us } => () //~ ERROR use of trait `Trait` in a struct pattern } } diff --git a/src/test/compile-fail/access-mode-in-closures.rs b/src/test/compile-fail/access-mode-in-closures.rs index f15157d126e..bad192fc2cf 100644 --- a/src/test/compile-fail/access-mode-in-closures.rs +++ b/src/test/compile-fail/access-mode-in-closures.rs @@ -9,9 +9,9 @@ // except according to those terms. -struct sty(Vec<int> ); +struct sty(Vec<isize> ); -fn unpack<F>(_unpack: F) where F: FnOnce(&sty) -> Vec<int> {} +fn unpack<F>(_unpack: F) where F: FnOnce(&sty) -> Vec<isize> {} fn main() { let _foo = unpack(|s| { diff --git a/src/test/compile-fail/arg-count-mismatch.rs b/src/test/compile-fail/arg-count-mismatch.rs index 472c66d9aad..673314ec4c9 100644 --- a/src/test/compile-fail/arg-count-mismatch.rs +++ b/src/test/compile-fail/arg-count-mismatch.rs @@ -10,6 +10,6 @@ // error-pattern: parameters were supplied -fn f(x: int) { } +fn f(x: isize) { } fn main() { let i: (); i = f(); } diff --git a/src/test/compile-fail/arg-type-mismatch.rs b/src/test/compile-fail/arg-type-mismatch.rs index 06fcc40f2e4..1f657ca5832 100644 --- a/src/test/compile-fail/arg-type-mismatch.rs +++ b/src/test/compile-fail/arg-type-mismatch.rs @@ -11,6 +11,6 @@ // error-pattern: mismatched types -fn f(x: int) { } +fn f(x: isize) { } fn main() { let i: (); i = f(()); } diff --git a/src/test/compile-fail/array-old-syntax-1.rs b/src/test/compile-fail/array-old-syntax-1.rs index 3c01a7756a6..3b4810a86ab 100644 --- a/src/test/compile-fail/array-old-syntax-1.rs +++ b/src/test/compile-fail/array-old-syntax-1.rs @@ -11,5 +11,5 @@ // Test that the old fixed length array syntax is a parsing error. fn main() { - let _x: [int, ..3] = [0i, 1, 2]; //~ ERROR + let _x: [isize, ..3] = [0is, 1, 2]; //~ ERROR } diff --git a/src/test/compile-fail/array-old-syntax-2.rs b/src/test/compile-fail/array-old-syntax-2.rs index df2cc305ca8..c1b88290bc3 100644 --- a/src/test/compile-fail/array-old-syntax-2.rs +++ b/src/test/compile-fail/array-old-syntax-2.rs @@ -11,5 +11,5 @@ // Test that the old repeating array syntax gives an error. fn main() { - let _ = [0i, ..3]; //~ ERROR + let _ = [0is, ..3]; //~ ERROR } diff --git a/src/test/compile-fail/asm-in-bad-modifier.rs b/src/test/compile-fail/asm-in-bad-modifier.rs index bc240df9b3b..ffbb25e266a 100644 --- a/src/test/compile-fail/asm-in-bad-modifier.rs +++ b/src/test/compile-fail/asm-in-bad-modifier.rs @@ -10,18 +10,18 @@ #![feature(asm)] -fn foo(x: int) { println!("{}", x); } +fn foo(x: isize) { println!("{}", x); } #[cfg(any(target_arch = "x86", target_arch = "x86_64", target_arch = "arm", target_arch = "aarch64"))] pub fn main() { - let x: int; - let y: int; + let x: isize; + let y: isize; unsafe { - asm!("mov $1, $0" : "=r"(x) : "=r"(5u)); //~ ERROR input operand constraint contains '=' - asm!("mov $1, $0" : "=r"(y) : "+r"(5u)); //~ ERROR input operand constraint contains '+' + asm!("mov $1, $0" : "=r"(x) : "=r"(5us)); //~ ERROR input operand constraint contains '=' + asm!("mov $1, $0" : "=r"(y) : "+r"(5us)); //~ ERROR input operand constraint contains '+' } foo(x); foo(y); diff --git a/src/test/compile-fail/asm-misplaced-option.rs b/src/test/compile-fail/asm-misplaced-option.rs index b29899e1940..8bc6f206dec 100644 --- a/src/test/compile-fail/asm-misplaced-option.rs +++ b/src/test/compile-fail/asm-misplaced-option.rs @@ -18,17 +18,17 @@ target_arch = "x86_64"))] pub fn main() { // assignment not dead - let mut x: int = 0; + let mut x: isize = 0; unsafe { // extra colon - asm!("mov $1, $0" : "=r"(x) : "r"(5u), "0"(x) : : "cc"); + asm!("mov $1, $0" : "=r"(x) : "r"(5us), "0"(x) : : "cc"); //~^ WARNING unrecognized option } assert_eq!(x, 5); unsafe { // comma in place of a colon - asm!("add $2, $1; mov $1, $0" : "=r"(x) : "r"(x), "r"(8u) : "cc", "volatile"); + asm!("add $2, $1; mov $1, $0" : "=r"(x) : "r"(x), "r"(8us) : "cc", "volatile"); //~^ WARNING expected a clobber, found an option } assert_eq!(x, 13); diff --git a/src/test/compile-fail/asm-out-assign-imm.rs b/src/test/compile-fail/asm-out-assign-imm.rs index 387b4bec47e..9ad5d7e9f09 100644 --- a/src/test/compile-fail/asm-out-assign-imm.rs +++ b/src/test/compile-fail/asm-out-assign-imm.rs @@ -10,18 +10,18 @@ #![feature(asm)] -fn foo(x: int) { println!("{}", x); } +fn foo(x: isize) { println!("{}", x); } #[cfg(any(target_arch = "x86", target_arch = "x86_64", target_arch = "arm", target_arch = "aarch64"))] pub fn main() { - let x: int; + let x: isize; x = 1; //~ NOTE prior assignment occurs here foo(x); unsafe { - asm!("mov $1, $0" : "=r"(x) : "r"(5u)); //~ ERROR re-assignment of immutable variable `x` + asm!("mov $1, $0" : "=r"(x) : "r"(5us)); //~ ERROR re-assignment of immutable variable `x` } foo(x); } diff --git a/src/test/compile-fail/asm-out-no-modifier.rs b/src/test/compile-fail/asm-out-no-modifier.rs index 4690bdc40cb..b58d41e1d82 100644 --- a/src/test/compile-fail/asm-out-no-modifier.rs +++ b/src/test/compile-fail/asm-out-no-modifier.rs @@ -10,16 +10,16 @@ #![feature(asm)] -fn foo(x: int) { println!("{}", x); } +fn foo(x: isize) { println!("{}", x); } #[cfg(any(target_arch = "x86", target_arch = "x86_64", target_arch = "arm", target_arch = "aarch64"))] pub fn main() { - let x: int; + let x: isize; unsafe { - asm!("mov $1, $0" : "r"(x) : "r"(5u)); //~ ERROR output operand constraint lacks '=' + asm!("mov $1, $0" : "r"(x) : "r"(5us)); //~ ERROR output operand constraint lacks '=' } foo(x); } diff --git a/src/test/compile-fail/asm-out-read-uninit.rs b/src/test/compile-fail/asm-out-read-uninit.rs index 2577dcc3f99..5e71a2c731d 100644 --- a/src/test/compile-fail/asm-out-read-uninit.rs +++ b/src/test/compile-fail/asm-out-read-uninit.rs @@ -10,14 +10,14 @@ #![feature(asm)] -fn foo(x: int) { println!("{}", x); } +fn foo(x: isize) { println!("{}", x); } #[cfg(any(target_arch = "x86", target_arch = "x86_64", target_arch = "arm", target_arch = "aarch64"))] pub fn main() { - let x: int; + let x: isize; unsafe { asm!("mov $1, $0" : "=r"(x) : "r"(x)); //~ ERROR use of possibly uninitialized variable: `x` } diff --git a/src/test/compile-fail/assign-imm-local-twice.rs b/src/test/compile-fail/assign-imm-local-twice.rs index 77f47a028d6..540272a8e2c 100644 --- a/src/test/compile-fail/assign-imm-local-twice.rs +++ b/src/test/compile-fail/assign-imm-local-twice.rs @@ -9,7 +9,7 @@ // except according to those terms. fn test() { - let v: int; + let v: isize; v = 1; //~ NOTE prior assignment occurs here println!("v={}", v); v = 2; //~ ERROR re-assignment of immutable variable diff --git a/src/test/compile-fail/assign-to-method.rs b/src/test/compile-fail/assign-to-method.rs index f14668192f8..0694420e766 100644 --- a/src/test/compile-fail/assign-to-method.rs +++ b/src/test/compile-fail/assign-to-method.rs @@ -9,16 +9,16 @@ // except according to those terms. struct cat { - meows : uint, + meows : usize, - how_hungry : int, + how_hungry : isize, } impl cat { - pub fn speak(&self) { self.meows += 1u; } + pub fn speak(&self) { self.meows += 1us; } } -fn cat(in_x : uint, in_y : int) -> cat { +fn cat(in_x : usize, in_y : isize) -> cat { cat { meows: in_x, how_hungry: in_y @@ -26,6 +26,6 @@ fn cat(in_x : uint, in_y : int) -> cat { } fn main() { - let nyan : cat = cat(52u, 99); + let nyan : cat = cat(52us, 99); nyan.speak = |&:| println!("meow"); //~ ERROR attempted to take value of method } diff --git a/src/test/compile-fail/assoc-inherent.rs b/src/test/compile-fail/assoc-inherent.rs index 8025011bfa7..ba8e4a652d3 100644 --- a/src/test/compile-fail/assoc-inherent.rs +++ b/src/test/compile-fail/assoc-inherent.rs @@ -13,7 +13,7 @@ struct Foo; impl Foo { - type Bar = int; //~ERROR associated items are not allowed in inherent impls + type Bar = isize; //~ERROR associated items are not allowed in inherent impls } fn main() {} diff --git a/src/test/compile-fail/associated-types-bound-failure.rs b/src/test/compile-fail/associated-types-bound-failure.rs index 918826bb390..adccd73beae 100644 --- a/src/test/compile-fail/associated-types-bound-failure.rs +++ b/src/test/compile-fail/associated-types-bound-failure.rs @@ -11,7 +11,7 @@ // Test equality constraints on associated types in a where clause. pub trait ToInt { - fn to_int(&self) -> int; + fn to_int(&self) -> isize; } pub trait GetToInt @@ -21,13 +21,13 @@ pub trait GetToInt fn get(&self) -> <Self as GetToInt>::R; } -fn foo<G>(g: G) -> int +fn foo<G>(g: G) -> isize where G : GetToInt { ToInt::to_int(&g.get()) //~ ERROR not implemented } -fn bar<G : GetToInt>(g: G) -> int +fn bar<G : GetToInt>(g: G) -> isize where G::R : ToInt { ToInt::to_int(&g.get()) // OK diff --git a/src/test/compile-fail/associated-types-coherence-failure.rs b/src/test/compile-fail/associated-types-coherence-failure.rs new file mode 100644 index 00000000000..95a68dd6698 --- /dev/null +++ b/src/test/compile-fail/associated-types-coherence-failure.rs @@ -0,0 +1,59 @@ +// 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 coherence detects overlap when some of the types in the +// impls are projections of associated type. Issue #20624. + +use std::ops::Deref; + +pub struct Cow<'a, B: ?Sized>; + +/// Trait for moving into a `Cow` +pub trait IntoCow<'a, B: ?Sized> { + /// Moves `self` into `Cow` + fn into_cow(self) -> Cow<'a, B>; +} + +impl<'a, B: ?Sized> IntoCow<'a, B> for Cow<'a, B> where B: ToOwned { +//~^ ERROR E0119 + fn into_cow(self) -> Cow<'a, B> { + self + } +} + +impl<'a, B: ?Sized> IntoCow<'a, B> for <B as ToOwned>::Owned where B: ToOwned { +//~^ ERROR E0119 + fn into_cow(self) -> Cow<'a, B> { + Cow + } +} + +impl<'a, B: ?Sized> IntoCow<'a, B> for &'a B where B: ToOwned { + fn into_cow(self) -> Cow<'a, B> { + Cow + } +} + +impl ToOwned for u8 { + type Owned = &'static u8; + fn to_owned(&self) -> &'static u8 { panic!() } +} + +/// A generalization of Clone to borrowed data. +pub trait ToOwned { + type Owned; + + /// Create owned data from borrowed data, usually by copying. + fn to_owned(&self) -> Self::Owned; +} + + +fn main() {} + diff --git a/src/test/compile-fail/associated-types-eq-2.rs b/src/test/compile-fail/associated-types-eq-2.rs index e298d05d11d..755a9f2d73f 100644 --- a/src/test/compile-fail/associated-types-eq-2.rs +++ b/src/test/compile-fail/associated-types-eq-2.rs @@ -18,9 +18,9 @@ pub trait Foo { struct Bar; -impl Foo for int { - type A = uint; - fn boo(&self) -> uint { 42 } +impl Foo for isize { + type A = usize; + fn boo(&self) -> usize { 42 } } fn baz<I: Foo>(x: &<I as Foo<A=Bar>>::A) {} diff --git a/src/test/compile-fail/associated-types-eq-3.rs b/src/test/compile-fail/associated-types-eq-3.rs index b56f971db74..ed81c0fccbc 100644 --- a/src/test/compile-fail/associated-types-eq-3.rs +++ b/src/test/compile-fail/associated-types-eq-3.rs @@ -18,9 +18,9 @@ pub trait Foo { struct Bar; -impl Foo for int { - type A = uint; - fn boo(&self) -> uint { +impl Foo for isize { + type A = usize; + fn boo(&self) -> usize { 42 } } @@ -40,7 +40,7 @@ pub fn baz(x: &Foo<A=Bar>) { pub fn main() { - let a = 42i; + let a = 42is; foo1(a); //~ERROR expected usize, found struct Bar baz(&a); //~ERROR expected usize, found struct Bar } diff --git a/src/test/compile-fail/associated-types-eq-expr-path.rs b/src/test/compile-fail/associated-types-eq-expr-path.rs index ef56fdeb051..9baa7f1ad5a 100644 --- a/src/test/compile-fail/associated-types-eq-expr-path.rs +++ b/src/test/compile-fail/associated-types-eq-expr-path.rs @@ -12,15 +12,15 @@ trait Foo { type A; - fn bar() -> int; + fn bar() -> isize; } -impl Foo for int { - type A = uint; - fn bar() -> int { 42 } +impl Foo for isize { + type A = usize; + fn bar() -> isize { 42 } } pub fn main() { - let x: int = Foo::<A=uint>::bar(); + let x: isize = Foo::<A=usize>::bar(); //~^ERROR unexpected binding of associated item in expression path } diff --git a/src/test/compile-fail/associated-types-eq-hr.rs b/src/test/compile-fail/associated-types-eq-hr.rs index 2532977b1ca..d5678c155fd 100644 --- a/src/test/compile-fail/associated-types-eq-hr.rs +++ b/src/test/compile-fail/associated-types-eq-hr.rs @@ -17,43 +17,43 @@ pub trait TheTrait<T> { } struct IntStruct { - x: int + x: isize } -impl<'a> TheTrait<&'a int> for IntStruct { - type A = &'a int; +impl<'a> TheTrait<&'a isize> for IntStruct { + type A = &'a isize; - fn get(&self, t: &'a int) -> &'a int { + fn get(&self, t: &'a isize) -> &'a isize { t } } struct UintStruct { - x: int + x: isize } -impl<'a> TheTrait<&'a int> for UintStruct { - type A = &'a uint; +impl<'a> TheTrait<&'a isize> for UintStruct { + type A = &'a usize; - fn get(&self, t: &'a int) -> &'a uint { + fn get(&self, t: &'a isize) -> &'a usize { panic!() } } fn foo<T>() - where T : for<'x> TheTrait<&'x int, A = &'x int> + where T : for<'x> TheTrait<&'x isize, A = &'x isize> { // ok for IntStruct, but not UintStruct } fn bar<T>() - where T : for<'x> TheTrait<&'x int, A = &'x uint> + where T : for<'x> TheTrait<&'x isize, A = &'x usize> { // ok for UintStruct, but not IntStruct } fn baz<T>() - where T : for<'x,'y> TheTrait<&'x int, A = &'y int> + where T : for<'x,'y> TheTrait<&'x isize, A = &'y isize> { // not ok for either struct, due to the use of two lifetimes } diff --git a/src/test/compile-fail/associated-types-incomplete-object.rs b/src/test/compile-fail/associated-types-incomplete-object.rs index 371f97e867a..31492406fed 100644 --- a/src/test/compile-fail/associated-types-incomplete-object.rs +++ b/src/test/compile-fail/associated-types-incomplete-object.rs @@ -19,24 +19,24 @@ pub trait Foo { struct Bar; -impl Foo for int { - type A = uint; +impl Foo for isize { + type A = usize; type B = char; - fn boo(&self) -> uint { + fn boo(&self) -> usize { 42 } } pub fn main() { - let a = &42i as &Foo<A=uint, B=char>; + let a = &42is as &Foo<A=usize, B=char>; - let b = &42i as &Foo<A=uint>; + let b = &42is as &Foo<A=usize>; //~^ ERROR the value of the associated type `B` (from the trait `Foo`) must be specified - let c = &42i as &Foo<B=char>; + let c = &42is as &Foo<B=char>; //~^ ERROR the value of the associated type `A` (from the trait `Foo`) must be specified - let d = &42i as &Foo; + let d = &42is as &Foo; //~^ ERROR the value of the associated type `A` (from the trait `Foo`) must be specified //~| ERROR the value of the associated type `B` (from the trait `Foo`) must be specified } diff --git a/src/test/compile-fail/associated-types-invalid-trait-ref-issue-18865.rs b/src/test/compile-fail/associated-types-invalid-trait-ref-issue-18865.rs index 13f6dcc9fde..b6c4d59c848 100644 --- a/src/test/compile-fail/associated-types-invalid-trait-ref-issue-18865.rs +++ b/src/test/compile-fail/associated-types-invalid-trait-ref-issue-18865.rs @@ -16,7 +16,7 @@ trait Foo<T> { fn get_bar(&self) -> Self::Bar; } -fn f<T:Foo<int>>(t: &T) { +fn f<T:Foo<isize>>(t: &T) { let u: <T as Foo<usize>>::Bar = t.get_bar(); //~^ ERROR the trait `Foo<usize>` is not implemented for the type `T` } diff --git a/src/test/compile-fail/associated-types-issue-17359.rs b/src/test/compile-fail/associated-types-issue-17359.rs index 6c79105abee..fa09ae793bf 100644 --- a/src/test/compile-fail/associated-types-issue-17359.rs +++ b/src/test/compile-fail/associated-types-issue-17359.rs @@ -15,7 +15,7 @@ trait Trait { type Type; } -impl Trait for int {} //~ ERROR missing: `Type` +impl Trait for isize {} //~ ERROR missing: `Type` fn main() {} diff --git a/src/test/compile-fail/associated-types-no-suitable-bound.rs b/src/test/compile-fail/associated-types-no-suitable-bound.rs index 98f2355f9be..fd60896c298 100644 --- a/src/test/compile-fail/associated-types-no-suitable-bound.rs +++ b/src/test/compile-fail/associated-types-no-suitable-bound.rs @@ -14,7 +14,7 @@ trait Get { } struct Struct { - x: int, + x: isize, } impl Struct { diff --git a/src/test/compile-fail/associated-types-path-2.rs b/src/test/compile-fail/associated-types-path-2.rs index 9994a0c465f..74c8dffced5 100644 --- a/src/test/compile-fail/associated-types-path-2.rs +++ b/src/test/compile-fail/associated-types-path-2.rs @@ -14,8 +14,8 @@ pub trait Foo { type A; } -impl Foo for int { - type A = uint; +impl Foo for isize { + type A = usize; } pub fn f1<T: Foo>(a: T, x: T::A) {} @@ -45,7 +45,7 @@ pub fn f1_uint_int() { } pub fn f2_int() { - let _: int = f2(2is); + let _: isize = f2(2is); //~^ ERROR expected `isize`, found `usize` } diff --git a/src/test/compile-fail/associated-types-project-from-hrtb-explicit.rs b/src/test/compile-fail/associated-types-project-from-hrtb-explicit.rs index c5245840c42..917c03fbf4b 100644 --- a/src/test/compile-fail/associated-types-project-from-hrtb-explicit.rs +++ b/src/test/compile-fail/associated-types-project-from-hrtb-explicit.rs @@ -17,7 +17,7 @@ pub trait Foo<T> { fn get(&self, t: T) -> Self::A; } -fn foo2<I>(x: <I as for<'x> Foo<&'x int>>::A) +fn foo2<I>(x: <I as for<'x> Foo<&'x isize>>::A) //~^ ERROR expected identifier, found keyword `for` //~| ERROR expected one of `::` or `>` { diff --git a/src/test/compile-fail/associated-types-project-from-hrtb-in-fn-body.rs b/src/test/compile-fail/associated-types-project-from-hrtb-in-fn-body.rs index 1f1ab4ca4b6..285a77d6b65 100644 --- a/src/test/compile-fail/associated-types-project-from-hrtb-in-fn-body.rs +++ b/src/test/compile-fail/associated-types-project-from-hrtb-in-fn-body.rs @@ -17,15 +17,15 @@ pub trait Foo<T> { fn get(&self, t: T) -> Self::A; } -fn foo<'a, I : for<'x> Foo<&'x int>>( - x: <I as Foo<&'a int>>::A) +fn foo<'a, I : for<'x> Foo<&'x isize>>( + x: <I as Foo<&'a isize>>::A) { let y: I::A = x; } -fn bar<'a, 'b, I : for<'x> Foo<&'x int>>( - x: <I as Foo<&'a int>>::A, - y: <I as Foo<&'b int>>::A, +fn bar<'a, 'b, I : for<'x> Foo<&'x isize>>( + x: <I as Foo<&'a isize>>::A, + y: <I as Foo<&'b isize>>::A, cond: bool) { // x and y here have two distinct lifetimes: diff --git a/src/test/compile-fail/associated-types-project-from-hrtb-in-fn.rs b/src/test/compile-fail/associated-types-project-from-hrtb-in-fn.rs index 0920bfab32b..a79d5c4649a 100644 --- a/src/test/compile-fail/associated-types-project-from-hrtb-in-fn.rs +++ b/src/test/compile-fail/associated-types-project-from-hrtb-in-fn.rs @@ -17,7 +17,7 @@ pub trait Foo<T> { fn get(&self, t: T) -> Self::A; } -fn foo2<I : for<'x> Foo<&'x int>>( +fn foo2<I : for<'x> Foo<&'x isize>>( x: I::A) //~^ ERROR cannot extract an associated type from a higher-ranked trait bound in this context { @@ -28,15 +28,15 @@ fn foo2<I : for<'x> Foo<&'x int>>( // specifically for fn signatures. } -fn foo3<I : for<'x> Foo<&'x int>>( - x: <I as Foo<&int>>::A) +fn foo3<I : for<'x> Foo<&'x isize>>( + x: <I as Foo<&isize>>::A) { // OK, in this case we spelled out the precise regions involved, though we left one of // them anonymous. } -fn foo4<'a, I : for<'x> Foo<&'x int>>( - x: <I as Foo<&'a int>>::A) +fn foo4<'a, I : for<'x> Foo<&'x isize>>( + x: <I as Foo<&'a isize>>::A) { // OK, in this case we spelled out the precise regions involved. } diff --git a/src/test/compile-fail/associated-types-project-from-hrtb-in-struct.rs b/src/test/compile-fail/associated-types-project-from-hrtb-in-struct.rs index 0acb0f4853b..44ad0bb0113 100644 --- a/src/test/compile-fail/associated-types-project-from-hrtb-in-struct.rs +++ b/src/test/compile-fail/associated-types-project-from-hrtb-in-struct.rs @@ -17,18 +17,18 @@ pub trait Foo<T> { fn get(&self, t: T) -> Self::A; } -struct SomeStruct<I : for<'x> Foo<&'x int>> { +struct SomeStruct<I : for<'x> Foo<&'x isize>> { field: I::A //~^ ERROR cannot extract an associated type from a higher-ranked trait bound in this context } -struct AnotherStruct<I : for<'x> Foo<&'x int>> { - field: <I as Foo<&int>>::A +struct AnotherStruct<I : for<'x> Foo<&'x isize>> { + field: <I as Foo<&isize>>::A //~^ ERROR missing lifetime specifier } -struct YetAnotherStruct<'a, I : for<'x> Foo<&'x int>> { - field: <I as Foo<&'a int>>::A +struct YetAnotherStruct<'a, I : for<'x> Foo<&'x isize>> { + field: <I as Foo<&'a isize>>::A } pub fn main() {} diff --git a/src/test/compile-fail/associated-types-project-from-hrtb-in-trait-method.rs b/src/test/compile-fail/associated-types-project-from-hrtb-in-trait-method.rs index 21e92c53058..af46a1b42d0 100644 --- a/src/test/compile-fail/associated-types-project-from-hrtb-in-trait-method.rs +++ b/src/test/compile-fail/associated-types-project-from-hrtb-in-trait-method.rs @@ -17,17 +17,17 @@ pub trait Foo<T> { fn get(&self, t: T) -> Self::A; } -trait SomeTrait<I : for<'x> Foo<&'x int>> { +trait SomeTrait<I : for<'x> Foo<&'x isize>> { fn some_method(&self, arg: I::A); //~^ ERROR cannot extract an associated type from a higher-ranked trait bound in this context } -trait AnotherTrait<I : for<'x> Foo<&'x int>> { - fn some_method(&self, arg: <I as Foo<&int>>::A); +trait AnotherTrait<I : for<'x> Foo<&'x isize>> { + fn some_method(&self, arg: <I as Foo<&isize>>::A); } -trait YetAnotherTrait<I : for<'x> Foo<&'x int>> { - fn some_method<'a>(&self, arg: <I as Foo<&'a int>>::A); +trait YetAnotherTrait<I : for<'x> Foo<&'x isize>> { + fn some_method<'a>(&self, arg: <I as Foo<&'a isize>>::A); } pub fn main() {} diff --git a/src/test/compile-fail/associated-types-unconstrained.rs b/src/test/compile-fail/associated-types-unconstrained.rs index 96863466944..aecbf217a5b 100644 --- a/src/test/compile-fail/associated-types-unconstrained.rs +++ b/src/test/compile-fail/associated-types-unconstrained.rs @@ -12,15 +12,15 @@ trait Foo { type A; - fn bar() -> int; + fn bar() -> isize; } -impl Foo for int { - type A = uint; - fn bar() -> int { 42 } +impl Foo for isize { + type A = usize; + fn bar() -> isize { 42 } } pub fn main() { - let x: int = Foo::bar(); + let x: isize = Foo::bar(); //~^ ERROR type annotations required } diff --git a/src/test/compile-fail/auto-ref-slice-plus-ref.rs b/src/test/compile-fail/auto-ref-slice-plus-ref.rs index fb935cf1030..ad3f467a454 100644 --- a/src/test/compile-fail/auto-ref-slice-plus-ref.rs +++ b/src/test/compile-fail/auto-ref-slice-plus-ref.rs @@ -27,7 +27,7 @@ trait MyIter { fn test(&self); } -impl<'a> MyIter for &'a [int] { +impl<'a> MyIter for &'a [isize] { fn test_mut(&mut self) { } fn test(&self) { } } diff --git a/src/test/compile-fail/autoderef-full-lval.rs b/src/test/compile-fail/autoderef-full-lval.rs index fb58028658e..2c5749e0d5d 100644 --- a/src/test/compile-fail/autoderef-full-lval.rs +++ b/src/test/compile-fail/autoderef-full-lval.rs @@ -28,7 +28,7 @@ fn main() { assert_eq!(z, 21); let forty: fish = fish{a: box 40}; let two: fish = fish{a: box 2}; - let answer: int = forty.a + two.a; + let answer: isize = forty.a + two.a; //~^ ERROR binary operation `+` cannot be applied to type `Box<isize>` println!("{}", answer); assert_eq!(answer, 42); diff --git a/src/test/compile-fail/bad-bang-ann-3.rs b/src/test/compile-fail/bad-bang-ann-3.rs index d204c8c750a..e5dbdbd237d 100644 --- a/src/test/compile-fail/bad-bang-ann-3.rs +++ b/src/test/compile-fail/bad-bang-ann-3.rs @@ -10,8 +10,8 @@ // Tests that a function with a ! annotation always actually fails -fn bad_bang(i: uint) -> ! { - return 7u; //~ ERROR `return` in a function declared as diverging [E0166] +fn bad_bang(i: usize) -> ! { + return 7us; //~ ERROR `return` in a function declared as diverging [E0166] } -fn main() { bad_bang(5u); } +fn main() { bad_bang(5us); } diff --git a/src/test/compile-fail/bad-bang-ann.rs b/src/test/compile-fail/bad-bang-ann.rs index 7e8142dbb29..414421c8b77 100644 --- a/src/test/compile-fail/bad-bang-ann.rs +++ b/src/test/compile-fail/bad-bang-ann.rs @@ -10,8 +10,8 @@ // Tests that a function with a ! annotation always actually fails -fn bad_bang(i: uint) -> ! { //~ ERROR computation may converge in a function marked as diverging - if i < 0u { } else { panic!(); } +fn bad_bang(i: usize) -> ! { //~ ERROR computation may converge in a function marked as diverging + if i < 0us { } else { panic!(); } } -fn main() { bad_bang(5u); } +fn main() { bad_bang(5us); } diff --git a/src/test/compile-fail/bad-env-capture.rs b/src/test/compile-fail/bad-env-capture.rs index ac5a4c220a4..93866488732 100644 --- a/src/test/compile-fail/bad-env-capture.rs +++ b/src/test/compile-fail/bad-env-capture.rs @@ -10,7 +10,7 @@ // error-pattern: can't capture dynamic environment in a fn item; fn foo() { - let x: int; + let x: isize; fn bar() { log(debug, x); } } fn main() { foo(); } diff --git a/src/test/compile-fail/bad-env-capture2.rs b/src/test/compile-fail/bad-env-capture2.rs index c97069acd9a..39a6922cfd0 100644 --- a/src/test/compile-fail/bad-env-capture2.rs +++ b/src/test/compile-fail/bad-env-capture2.rs @@ -9,7 +9,7 @@ // except according to those terms. // error-pattern: can't capture dynamic environment in a fn item; -fn foo(x: int) { +fn foo(x: isize) { fn bar() { log(debug, x); } } fn main() { foo(2); } diff --git a/src/test/compile-fail/bad-env-capture3.rs b/src/test/compile-fail/bad-env-capture3.rs index e3a6ac2cdfc..8857b94ddce 100644 --- a/src/test/compile-fail/bad-env-capture3.rs +++ b/src/test/compile-fail/bad-env-capture3.rs @@ -9,7 +9,7 @@ // except according to those terms. // error-pattern: can't capture dynamic environment in a fn item; -fn foo(x: int) { +fn foo(x: isize) { fn mth() { fn bar() { log(debug, x); } } diff --git a/src/test/compile-fail/bad-main.rs b/src/test/compile-fail/bad-main.rs index da8596fa25b..321dca89891 100644 --- a/src/test/compile-fail/bad-main.rs +++ b/src/test/compile-fail/bad-main.rs @@ -8,4 +8,4 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -fn main(x: int) { } //~ ERROR: main function expects type +fn main(x: isize) { } //~ ERROR: main function expects type diff --git a/src/test/compile-fail/bad-match.rs b/src/test/compile-fail/bad-match.rs index 728b577df1d..33043ff5524 100644 --- a/src/test/compile-fail/bad-match.rs +++ b/src/test/compile-fail/bad-match.rs @@ -11,7 +11,7 @@ // error-pattern: expected fn main() { - let int x = 5; + let isize x = 5; match x; } diff --git a/src/test/compile-fail/bad-method-typaram-kind.rs b/src/test/compile-fail/bad-method-typaram-kind.rs index 349c33a30a5..8e5a6054b89 100644 --- a/src/test/compile-fail/bad-method-typaram-kind.rs +++ b/src/test/compile-fail/bad-method-typaram-kind.rs @@ -9,14 +9,14 @@ // except according to those terms. fn foo<T:'static>() { - 1u.bar::<T>(); //~ ERROR `core::marker::Send` is not implemented + 1us.bar::<T>(); //~ ERROR `core::marker::Send` is not implemented } trait bar { fn bar<T:Send>(&self); } -impl bar for uint { +impl bar for usize { fn bar<T:Send>(&self) { } } diff --git a/src/test/compile-fail/bad-mid-path-type-params.rs b/src/test/compile-fail/bad-mid-path-type-params.rs index 3a2a7558657..79fe4e7165e 100644 --- a/src/test/compile-fail/bad-mid-path-type-params.rs +++ b/src/test/compile-fail/bad-mid-path-type-params.rs @@ -33,11 +33,11 @@ trait Trait<T> { } struct S2 { - contents: int, + contents: isize, } -impl Trait<int> for S2 { - fn new<U>(x: int, _: U) -> S2 { +impl Trait<isize> for S2 { + fn new<U>(x: isize, _: U) -> S2 { S2 { contents: x, } @@ -45,16 +45,16 @@ impl Trait<int> for S2 { } fn foo<'a>() { - let _ = S::new::<int,f64>(1, 1.0); + let _ = S::new::<isize,f64>(1, 1.0); //~^ ERROR too many type parameters provided - let _ = S::<'a,int>::new::<f64>(1, 1.0); + let _ = S::<'a,isize>::new::<f64>(1, 1.0); //~^ ERROR too many lifetime parameters provided - let _: S2 = Trait::new::<int,f64>(1, 1.0); + let _: S2 = Trait::new::<isize,f64>(1, 1.0); //~^ ERROR too many type parameters provided - let _: S2 = Trait::<'a,int>::new::<f64>(1, 1.0); + let _: S2 = Trait::<'a,isize>::new::<f64>(1, 1.0); //~^ ERROR too many lifetime parameters provided } diff --git a/src/test/compile-fail/bad-name.rs b/src/test/compile-fail/bad-name.rs index e320d5918b6..b208c6f4244 100644 --- a/src/test/compile-fail/bad-name.rs +++ b/src/test/compile-fail/bad-name.rs @@ -11,5 +11,5 @@ // error-pattern: expected fn main() { - let x.y::<int>.z foo; + let x.y::<isize>.z foo; } diff --git a/src/test/compile-fail/bang-tailexpr.rs b/src/test/compile-fail/bang-tailexpr.rs index ec576ff4bd8..d17fa68b47c 100644 --- a/src/test/compile-fail/bang-tailexpr.rs +++ b/src/test/compile-fail/bang-tailexpr.rs @@ -9,6 +9,6 @@ // except according to those terms. fn f() -> ! { //~ ERROR computation may converge in a function marked as diverging - 3i + 3is } fn main() { } diff --git a/src/test/compile-fail/better-expected.rs b/src/test/compile-fail/better-expected.rs index 672d8a30fc5..0d84a5e7d02 100644 --- a/src/test/compile-fail/better-expected.rs +++ b/src/test/compile-fail/better-expected.rs @@ -9,5 +9,5 @@ // except according to those terms. fn main() { - let x: [int 3]; //~ ERROR expected one of `(`, `+`, `::`, `;`, or `]`, found `3` + let x: [isize 3]; //~ ERROR expected one of `(`, `+`, `::`, `;`, or `]`, found `3` } diff --git a/src/test/compile-fail/bind-struct-early-modifiers.rs b/src/test/compile-fail/bind-struct-early-modifiers.rs index 3671cf110d8..375f6c5d047 100644 --- a/src/test/compile-fail/bind-struct-early-modifiers.rs +++ b/src/test/compile-fail/bind-struct-early-modifiers.rs @@ -9,7 +9,7 @@ // except according to those terms. fn main() { - struct Foo { x: int } + struct Foo { x: isize } match (Foo { x: 10 }) { Foo { ref x: ref x } => {}, //~ ERROR unexpected `:` _ => {} diff --git a/src/test/compile-fail/binop-move-semantics.rs b/src/test/compile-fail/binop-move-semantics.rs index ffc38cc0a60..cff0064497a 100644 --- a/src/test/compile-fail/binop-move-semantics.rs +++ b/src/test/compile-fail/binop-move-semantics.rs @@ -37,9 +37,9 @@ fn illegal_dereference<T: Add<Output=()>>(mut x: T, y: T) { let m = &mut x; let n = &y; - *m //~ ERROR: cannot move out of dereference of `&mut`-pointer + *m //~ ERROR: cannot move out of borrowed content + - *n; //~ ERROR: cannot move out of dereference of `&`-pointer + *n; //~ ERROR: cannot move out of borrowed content } struct Foo; diff --git a/src/test/compile-fail/bogus-tag.rs b/src/test/compile-fail/bogus-tag.rs index cc0ed214103..704d856f106 100644 --- a/src/test/compile-fail/bogus-tag.rs +++ b/src/test/compile-fail/bogus-tag.rs @@ -11,7 +11,7 @@ // error-pattern: unresolved -enum color { rgb(int, int, int), rgba(int, int, int, int), } +enum color { rgb(isize, isize, isize), rgba(isize, isize, isize, isize), } fn main() { let red: color = rgb(255, 0, 0); diff --git a/src/test/compile-fail/borrow-immutable-upvar-mutation.rs b/src/test/compile-fail/borrow-immutable-upvar-mutation.rs index f748c400654..12555c55072 100644 --- a/src/test/compile-fail/borrow-immutable-upvar-mutation.rs +++ b/src/test/compile-fail/borrow-immutable-upvar-mutation.rs @@ -13,29 +13,29 @@ // Tests that we can't assign to or mutably borrow upvars from `Fn` // closures (issue #17780) -fn set(x: &mut uint) { *x = 5; } +fn set(x: &mut usize) { *x = 5; } fn main() { // By-ref captures { - let mut x = 0u; + let mut x = 0us; let _f = |&:| x = 42; //~ ERROR cannot assign - let mut y = 0u; + let mut y = 0us; let _g = |&:| set(&mut y); //~ ERROR cannot borrow - let mut z = 0u; + let mut z = 0us; let _h = |&mut:| { set(&mut z); |&:| z = 42; }; //~ ERROR cannot assign } // By-value captures { - let mut x = 0u; + let mut x = 0us; let _f = move |&:| x = 42; //~ ERROR cannot assign - let mut y = 0u; + let mut y = 0us; let _g = move |&:| set(&mut y); //~ ERROR cannot borrow - let mut z = 0u; + let mut z = 0us; let _h = move |&mut:| { set(&mut z); move |&:| z = 42; }; //~ ERROR cannot assign } } diff --git a/src/test/compile-fail/borrow-tuple-fields.rs b/src/test/compile-fail/borrow-tuple-fields.rs index 59ed0e5fa06..e6fe60a9004 100644 --- a/src/test/compile-fail/borrow-tuple-fields.rs +++ b/src/test/compile-fail/borrow-tuple-fields.rs @@ -11,33 +11,33 @@ #![allow(unknown_features)] #![feature(box_syntax)] -struct Foo(Box<int>, int); +struct Foo(Box<isize>, isize); -struct Bar(int, int); +struct Bar(isize, isize); fn main() { - let x = (box 1i, 2i); + let x = (box 1is, 2is); let r = &x.0; let y = x; //~ ERROR cannot move out of `x` because it is borrowed - let mut x = (1i, 2i); + let mut x = (1is, 2is); let a = &x.0; let b = &mut x.0; //~ ERROR cannot borrow `x.0` as mutable because it is also borrowed as - let mut x = (1i, 2i); + let mut x = (1is, 2is); let a = &mut x.0; let b = &mut x.0; //~ ERROR cannot borrow `x.0` as mutable more than once at a time - let x = Foo(box 1i, 2i); + let x = Foo(box 1is, 2is); let r = &x.0; let y = x; //~ ERROR cannot move out of `x` because it is borrowed - let mut x = Bar(1i, 2i); + let mut x = Bar(1is, 2is); let a = &x.0; let b = &mut x.0; //~ ERROR cannot borrow `x.0` as mutable because it is also borrowed as - let mut x = Bar(1i, 2i); + let mut x = Bar(1is, 2is); let a = &mut x.0; let b = &mut x.0; //~ ERROR cannot borrow `x.0` as mutable more than once at a time } diff --git a/src/test/compile-fail/borrowck-and-init.rs b/src/test/compile-fail/borrowck-and-init.rs index 0f07cab3acc..92f16d8ffce 100644 --- a/src/test/compile-fail/borrowck-and-init.rs +++ b/src/test/compile-fail/borrowck-and-init.rs @@ -9,7 +9,7 @@ // except according to those terms. fn main() { - let i: int; + let i: isize; println!("{}", false && { i = 5; true }); println!("{}", i); //~ ERROR use of possibly uninitialized variable: `i` diff --git a/src/test/compile-fail/borrowck-anon-fields-struct.rs b/src/test/compile-fail/borrowck-anon-fields-struct.rs index 514dd584c6a..5ee2b89dd98 100644 --- a/src/test/compile-fail/borrowck-anon-fields-struct.rs +++ b/src/test/compile-fail/borrowck-anon-fields-struct.rs @@ -11,7 +11,7 @@ // Tests that we are able to distinguish when loans borrow different // anonymous fields of a tuple vs the same anonymous field. -struct Y(uint, uint); +struct Y(usize, usize); fn distinct_variant() { let mut y = Y(1, 2); diff --git a/src/test/compile-fail/borrowck-anon-fields-tuple.rs b/src/test/compile-fail/borrowck-anon-fields-tuple.rs index 9a452ed18f6..88486756b66 100644 --- a/src/test/compile-fail/borrowck-anon-fields-tuple.rs +++ b/src/test/compile-fail/borrowck-anon-fields-tuple.rs @@ -12,7 +12,7 @@ // anonymous fields of a tuple vs the same anonymous field. fn distinct_variant() { - let mut y = (1i, 2i); + let mut y = (1is, 2is); let a = match y { (ref mut a, _) => a @@ -27,7 +27,7 @@ fn distinct_variant() { } fn same_variant() { - let mut y = (1i, 2i); + let mut y = (1is, 2is); let a = match y { (ref mut a, _) => a diff --git a/src/test/compile-fail/borrowck-anon-fields-variant.rs b/src/test/compile-fail/borrowck-anon-fields-variant.rs index 8b54f146d04..4e1b85283a6 100644 --- a/src/test/compile-fail/borrowck-anon-fields-variant.rs +++ b/src/test/compile-fail/borrowck-anon-fields-variant.rs @@ -12,7 +12,7 @@ // anonymous fields of an enum variant vs the same anonymous field. enum Foo { - X, Y(uint, uint) + X, Y(usize, usize) } fn distinct_variant() { diff --git a/src/test/compile-fail/borrowck-array-double-move.rs b/src/test/compile-fail/borrowck-array-double-move.rs index ef2c629acfe..ac9ddc2ce65 100644 --- a/src/test/compile-fail/borrowck-array-double-move.rs +++ b/src/test/compile-fail/borrowck-array-double-move.rs @@ -12,9 +12,9 @@ #![feature(box_syntax)] fn f() { - let mut a = [box 0i, box 1i]; + let mut a = [box 0is, box 1is]; drop(a[0]); - a[1] = box 2i; + a[1] = box 2is; drop(a[0]); //~ ERROR use of moved value: `a[..]` } diff --git a/src/test/compile-fail/borrowck-assign-comp-idx.rs b/src/test/compile-fail/borrowck-assign-comp-idx.rs index a6801a6a51a..3a2c6f03851 100644 --- a/src/test/compile-fail/borrowck-assign-comp-idx.rs +++ b/src/test/compile-fail/borrowck-assign-comp-idx.rs @@ -9,22 +9,22 @@ // except according to those terms. struct Point { - x: int, - y: int, + x: isize, + y: isize, } fn a() { let mut p = vec!(1); // Create an immutable pointer into p's contents: - let q: &int = &p[0]; + let q: &isize = &p[0]; p[0] = 5; //~ ERROR cannot borrow println!("{}", *q); } -fn borrow<F>(_x: &[int], _f: F) where F: FnOnce() {} +fn borrow<F>(_x: &[isize], _f: F) where F: FnOnce() {} fn b() { // here we alias the mutable vector into an imm slice and try to diff --git a/src/test/compile-fail/borrowck-assign-comp.rs b/src/test/compile-fail/borrowck-assign-comp.rs index ccd0542ca7f..802b83119b7 100644 --- a/src/test/compile-fail/borrowck-assign-comp.rs +++ b/src/test/compile-fail/borrowck-assign-comp.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -struct point { x: int, y: int } +struct point { x: isize, y: isize } fn a() { let mut p = point {x: 3, y: 4}; @@ -16,7 +16,7 @@ fn a() { // This assignment is illegal because the field x is not // inherently mutable; since `p` was made immutable, `p.x` is now - // immutable. Otherwise the type of &_q.x (&int) would be wrong. + // immutable. Otherwise the type of &_q.x (&isize) would be wrong. p.x = 5; //~ ERROR cannot assign to `p.x` q.x; } diff --git a/src/test/compile-fail/borrowck-assign-to-andmut-in-aliasable-loc.rs b/src/test/compile-fail/borrowck-assign-to-andmut-in-aliasable-loc.rs index 3fa840f6a4e..d66cdb99a74 100644 --- a/src/test/compile-fail/borrowck-assign-to-andmut-in-aliasable-loc.rs +++ b/src/test/compile-fail/borrowck-assign-to-andmut-in-aliasable-loc.rs @@ -12,7 +12,7 @@ // borrowed (but otherwise non-aliasable) location is illegal. struct S<'a> { - pointer: &'a mut int + pointer: &'a mut isize } fn a(s: &S) { diff --git a/src/test/compile-fail/borrowck-assign-to-andmut-in-borrowed-loc.rs b/src/test/compile-fail/borrowck-assign-to-andmut-in-borrowed-loc.rs index ccbbc2ea6c3..77aa57ef1b5 100644 --- a/src/test/compile-fail/borrowck-assign-to-andmut-in-borrowed-loc.rs +++ b/src/test/compile-fail/borrowck-assign-to-andmut-in-borrowed-loc.rs @@ -12,7 +12,7 @@ // borrowed (but otherwise non-aliasable) location is illegal. struct S<'a> { - pointer: &'a mut int + pointer: &'a mut isize } fn copy_borrowed_ptr<'a>(p: &'a mut S<'a>) -> S<'a> { diff --git a/src/test/compile-fail/borrowck-assign-to-constants.rs b/src/test/compile-fail/borrowck-assign-to-constants.rs index c0fb24c83e3..1b5b1899e0d 100644 --- a/src/test/compile-fail/borrowck-assign-to-constants.rs +++ b/src/test/compile-fail/borrowck-assign-to-constants.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -static foo: int = 5; +static foo: isize = 5; fn main() { // assigning to various global constants diff --git a/src/test/compile-fail/borrowck-auto-mut-ref-to-immut-var.rs b/src/test/compile-fail/borrowck-auto-mut-ref-to-immut-var.rs index dcfef4e1d9c..ea020dc0685 100644 --- a/src/test/compile-fail/borrowck-auto-mut-ref-to-immut-var.rs +++ b/src/test/compile-fail/borrowck-auto-mut-ref-to-immut-var.rs @@ -11,7 +11,7 @@ // Tests that auto-ref can't create mutable aliases to immutable memory. struct Foo { - x: int + x: isize } impl Foo { diff --git a/src/test/compile-fail/borrowck-autoref-3261.rs b/src/test/compile-fail/borrowck-autoref-3261.rs index 2804b8c48a7..d5f09305808 100644 --- a/src/test/compile-fail/borrowck-autoref-3261.rs +++ b/src/test/compile-fail/borrowck-autoref-3261.rs @@ -10,10 +10,10 @@ enum Either<T, U> { Left(T), Right(U) } -struct X(Either<(uint,uint), fn()>); +struct X(Either<(usize,usize), fn()>); impl X { - pub fn with<F>(&self, blk: F) where F: FnOnce(&Either<(uint, uint), fn()>) { + pub fn with<F>(&self, blk: F) where F: FnOnce(&Either<(usize, usize), fn()>) { let X(ref e) = *self; blk(e) } 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 5a7788ed855..4d1939be5b9 100644 --- a/src/test/compile-fail/borrowck-bad-nested-calls-free.rs +++ b/src/test/compile-fail/borrowck-bad-nested-calls-free.rs @@ -13,12 +13,12 @@ #![feature(box_syntax)] -fn rewrite(v: &mut Box<uint>) -> uint { +fn rewrite(v: &mut Box<usize>) -> usize { *v = box 22; **v } -fn add(v: &uint, w: uint) -> uint { +fn add(v: &usize, w: usize) -> usize { *v + w } 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 263b7f9576b..9eda3689334 100644 --- a/src/test/compile-fail/borrowck-bad-nested-calls-move.rs +++ b/src/test/compile-fail/borrowck-bad-nested-calls-move.rs @@ -13,12 +13,12 @@ #![feature(box_syntax)] -fn rewrite(v: &mut Box<uint>) -> uint { +fn rewrite(v: &mut Box<usize>) -> usize { *v = box 22; **v } -fn add(v: &uint, w: Box<uint>) -> uint { +fn add(v: &usize, w: Box<usize>) -> usize { *v + *w } diff --git a/src/test/compile-fail/borrowck-block-unint.rs b/src/test/compile-fail/borrowck-block-unint.rs index e519e57d178..a09ee439245 100644 --- a/src/test/compile-fail/borrowck-block-unint.rs +++ b/src/test/compile-fail/borrowck-block-unint.rs @@ -10,7 +10,7 @@ fn force<F>(f: F) where F: FnOnce() { f(); } fn main() { - let x: int; + let x: isize; force(|| { //~ ERROR capture of possibly uninitialized variable: `x` println!("{}", x); }); diff --git a/src/test/compile-fail/borrowck-borrow-from-owned-ptr.rs b/src/test/compile-fail/borrowck-borrow-from-owned-ptr.rs index d5998c8ca99..397c55a502a 100644 --- a/src/test/compile-fail/borrowck-borrow-from-owned-ptr.rs +++ b/src/test/compile-fail/borrowck-borrow-from-owned-ptr.rs @@ -17,8 +17,8 @@ struct Foo { impl Copy for Foo {} struct Bar { - int1: int, - int2: int, + int1: isize, + int2: isize, } impl Copy for Bar {} diff --git a/src/test/compile-fail/borrowck-borrow-from-stack-variable.rs b/src/test/compile-fail/borrowck-borrow-from-stack-variable.rs index d252d442297..ae4c09c59d7 100644 --- a/src/test/compile-fail/borrowck-borrow-from-stack-variable.rs +++ b/src/test/compile-fail/borrowck-borrow-from-stack-variable.rs @@ -16,8 +16,8 @@ struct Foo { impl Copy for Foo {} struct Bar { - int1: int, - int2: int, + int1: isize, + int2: isize, } impl Copy for Bar {} diff --git a/src/test/compile-fail/borrowck-borrow-from-temporary.rs b/src/test/compile-fail/borrowck-borrow-from-temporary.rs index 784bd1e8ae4..fbb3824cd40 100644 --- a/src/test/compile-fail/borrowck-borrow-from-temporary.rs +++ b/src/test/compile-fail/borrowck-borrow-from-temporary.rs @@ -11,9 +11,9 @@ // Test lifetimes are linked properly when we take reference // to interior. -struct Foo(int); +struct Foo(isize); -fn foo<'a>() -> &'a int { +fn foo<'a>() -> &'a isize { let &Foo(ref x) = &Foo(3); //~ ERROR borrowed value does not live long enough x } 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 84f4e4f8817..794e0fc6e3a 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 @@ -20,5 +20,5 @@ impl A { pub fn main() { let a = box A; a.foo(); - //~^ ERROR cannot borrow immutable dereference of `Box` `*a` as mutable + //~^ ERROR cannot borrow immutable `Box` content `*a` as mutable } diff --git a/src/test/compile-fail/borrowck-borrow-mut-base-ptr-in-aliasable-loc.rs b/src/test/compile-fail/borrowck-borrow-mut-base-ptr-in-aliasable-loc.rs index 7bee06b7804..9126058a4e6 100644 --- a/src/test/compile-fail/borrowck-borrow-mut-base-ptr-in-aliasable-loc.rs +++ b/src/test/compile-fail/borrowck-borrow-mut-base-ptr-in-aliasable-loc.rs @@ -13,20 +13,20 @@ // // Example from src/middle/borrowck/doc.rs -fn foo(t0: & &mut int) { +fn foo(t0: & &mut isize) { let t1 = t0; - let p: &int = &**t0; + let p: &isize = &**t0; **t1 = 22; //~ ERROR cannot assign } -fn foo3(t0: &mut &mut int) { +fn foo3(t0: &mut &mut isize) { let t1 = &mut *t0; - let p: &int = &**t0; //~ ERROR cannot borrow + let p: &isize = &**t0; //~ ERROR cannot borrow **t1 = 22; } -fn foo4(t0: & &mut int) { - let x: &mut int = &mut **t0; //~ ERROR cannot borrow +fn foo4(t0: & &mut isize) { + let x: &mut isize = &mut **t0; //~ ERROR cannot borrow *x += 1; } diff --git a/src/test/compile-fail/borrowck-borrow-overloaded-auto-deref-mut.rs b/src/test/compile-fail/borrowck-borrow-overloaded-auto-deref-mut.rs index 66bcfc23808..5db9ad2e3a4 100644 --- a/src/test/compile-fail/borrowck-borrow-overloaded-auto-deref-mut.rs +++ b/src/test/compile-fail/borrowck-borrow-overloaded-auto-deref-mut.rs @@ -32,25 +32,25 @@ impl<T> DerefMut for Own<T> { } struct Point { - x: int, - y: int + x: isize, + y: isize } impl Point { - fn get(&self) -> (int, int) { + fn get(&self) -> (isize, isize) { (self.x, self.y) } - fn set(&mut self, x: int, y: int) { + fn set(&mut self, x: isize, y: isize) { self.x = x; self.y = y; } - fn x_ref(&self) -> &int { + fn x_ref(&self) -> &isize { &self.x } - fn y_mut(&mut self) -> &mut int { + fn y_mut(&mut self) -> &mut isize { &mut self.y } } @@ -67,15 +67,15 @@ fn deref_mut_field2(mut x: Own<Point>) { let _i = &mut x.y; } -fn deref_extend_field(x: &Own<Point>) -> &int { +fn deref_extend_field(x: &Own<Point>) -> &isize { &x.y } -fn deref_extend_mut_field1(x: &Own<Point>) -> &mut int { +fn deref_extend_mut_field1(x: &Own<Point>) -> &mut isize { &mut x.y //~ ERROR cannot borrow } -fn deref_extend_mut_field2(x: &mut Own<Point>) -> &mut int { +fn deref_extend_mut_field2(x: &mut Own<Point>) -> &mut isize { &mut x.y } @@ -126,15 +126,15 @@ fn deref_mut_method2(mut x: Own<Point>) { x.set(0, 0); } -fn deref_extend_method(x: &Own<Point>) -> &int { +fn deref_extend_method(x: &Own<Point>) -> &isize { x.x_ref() } -fn deref_extend_mut_method1(x: &Own<Point>) -> &mut int { +fn deref_extend_mut_method1(x: &Own<Point>) -> &mut isize { x.y_mut() //~ ERROR cannot borrow } -fn deref_extend_mut_method2(x: &mut Own<Point>) -> &mut int { +fn deref_extend_mut_method2(x: &mut Own<Point>) -> &mut isize { x.y_mut() } diff --git a/src/test/compile-fail/borrowck-borrow-overloaded-auto-deref.rs b/src/test/compile-fail/borrowck-borrow-overloaded-auto-deref.rs index abab9e57ffe..75680de9c9e 100644 --- a/src/test/compile-fail/borrowck-borrow-overloaded-auto-deref.rs +++ b/src/test/compile-fail/borrowck-borrow-overloaded-auto-deref.rs @@ -26,25 +26,25 @@ impl<T> Deref for Rc<T> { } struct Point { - x: int, - y: int + x: isize, + y: isize } impl Point { - fn get(&self) -> (int, int) { + fn get(&self) -> (isize, isize) { (self.x, self.y) } - fn set(&mut self, x: int, y: int) { + fn set(&mut self, x: isize, y: isize) { self.x = x; self.y = y; } - fn x_ref(&self) -> &int { + fn x_ref(&self) -> &isize { &self.x } - fn y_mut(&mut self) -> &mut int { + fn y_mut(&mut self) -> &mut isize { &mut self.y } } @@ -61,15 +61,15 @@ fn deref_mut_field2(mut x: Rc<Point>) { let _i = &mut x.y; //~ ERROR cannot borrow } -fn deref_extend_field(x: &Rc<Point>) -> &int { +fn deref_extend_field(x: &Rc<Point>) -> &isize { &x.y } -fn deref_extend_mut_field1(x: &Rc<Point>) -> &mut int { +fn deref_extend_mut_field1(x: &Rc<Point>) -> &mut isize { &mut x.y //~ ERROR cannot borrow } -fn deref_extend_mut_field2(x: &mut Rc<Point>) -> &mut int { +fn deref_extend_mut_field2(x: &mut Rc<Point>) -> &mut isize { &mut x.y //~ ERROR cannot borrow } @@ -97,15 +97,15 @@ fn deref_mut_method2(mut x: Rc<Point>) { x.set(0, 0); //~ ERROR cannot borrow } -fn deref_extend_method(x: &Rc<Point>) -> &int { +fn deref_extend_method(x: &Rc<Point>) -> &isize { x.x_ref() } -fn deref_extend_mut_method1(x: &Rc<Point>) -> &mut int { +fn deref_extend_mut_method1(x: &Rc<Point>) -> &mut isize { x.y_mut() //~ ERROR cannot borrow } -fn deref_extend_mut_method2(x: &mut Rc<Point>) -> &mut int { +fn deref_extend_mut_method2(x: &mut Rc<Point>) -> &mut isize { x.y_mut() //~ ERROR cannot borrow } diff --git a/src/test/compile-fail/borrowck-borrow-overloaded-deref-mut.rs b/src/test/compile-fail/borrowck-borrow-overloaded-deref-mut.rs index dda7e4d1047..bfe53b739f4 100644 --- a/src/test/compile-fail/borrowck-borrow-overloaded-deref-mut.rs +++ b/src/test/compile-fail/borrowck-borrow-overloaded-deref-mut.rs @@ -31,39 +31,39 @@ impl<T> DerefMut for Own<T> { } } -fn deref_imm(x: Own<int>) { +fn deref_imm(x: Own<isize>) { let _i = &*x; } -fn deref_mut1(x: Own<int>) { +fn deref_mut1(x: Own<isize>) { let _i = &mut *x; //~ ERROR cannot borrow } -fn deref_mut2(mut x: Own<int>) { +fn deref_mut2(mut x: Own<isize>) { let _i = &mut *x; } -fn deref_extend<'a>(x: &'a Own<int>) -> &'a int { +fn deref_extend<'a>(x: &'a Own<isize>) -> &'a isize { &**x } -fn deref_extend_mut1<'a>(x: &'a Own<int>) -> &'a mut int { +fn deref_extend_mut1<'a>(x: &'a Own<isize>) -> &'a mut isize { &mut **x //~ ERROR cannot borrow } -fn deref_extend_mut2<'a>(x: &'a mut Own<int>) -> &'a mut int { +fn deref_extend_mut2<'a>(x: &'a mut Own<isize>) -> &'a mut isize { &mut **x } -fn assign1<'a>(x: Own<int>) { +fn assign1<'a>(x: Own<isize>) { *x = 3; //~ ERROR cannot borrow } -fn assign2<'a>(x: &'a Own<int>) { +fn assign2<'a>(x: &'a Own<isize>) { **x = 3; //~ ERROR cannot borrow } -fn assign3<'a>(x: &'a mut Own<int>) { +fn assign3<'a>(x: &'a mut Own<isize>) { **x = 3; } diff --git a/src/test/compile-fail/borrowck-borrow-overloaded-deref.rs b/src/test/compile-fail/borrowck-borrow-overloaded-deref.rs index 001a5232b12..153368f4894 100644 --- a/src/test/compile-fail/borrowck-borrow-overloaded-deref.rs +++ b/src/test/compile-fail/borrowck-borrow-overloaded-deref.rs @@ -25,39 +25,39 @@ impl<T> Deref for Rc<T> { } } -fn deref_imm(x: Rc<int>) { +fn deref_imm(x: Rc<isize>) { let _i = &*x; } -fn deref_mut1(x: Rc<int>) { +fn deref_mut1(x: Rc<isize>) { let _i = &mut *x; //~ ERROR cannot borrow } -fn deref_mut2(mut x: Rc<int>) { +fn deref_mut2(mut x: Rc<isize>) { let _i = &mut *x; //~ ERROR cannot borrow } -fn deref_extend<'a>(x: &'a Rc<int>) -> &'a int { +fn deref_extend<'a>(x: &'a Rc<isize>) -> &'a isize { &**x } -fn deref_extend_mut1<'a>(x: &'a Rc<int>) -> &'a mut int { +fn deref_extend_mut1<'a>(x: &'a Rc<isize>) -> &'a mut isize { &mut **x //~ ERROR cannot borrow } -fn deref_extend_mut2<'a>(x: &'a mut Rc<int>) -> &'a mut int { +fn deref_extend_mut2<'a>(x: &'a mut Rc<isize>) -> &'a mut isize { &mut **x //~ ERROR cannot borrow } -fn assign1<'a>(x: Rc<int>) { +fn assign1<'a>(x: Rc<isize>) { *x = 3; //~ ERROR cannot assign } -fn assign2<'a>(x: &'a Rc<int>) { +fn assign2<'a>(x: &'a Rc<isize>) { **x = 3; //~ ERROR cannot assign } -fn assign3<'a>(x: &'a mut Rc<int>) { +fn assign3<'a>(x: &'a mut Rc<isize>) { **x = 3; //~ ERROR cannot assign } diff --git a/src/test/compile-fail/borrowck-borrowed-uniq-rvalue.rs b/src/test/compile-fail/borrowck-borrowed-uniq-rvalue.rs index 04ad583a2db..98d1905ed90 100644 --- a/src/test/compile-fail/borrowck-borrowed-uniq-rvalue.rs +++ b/src/test/compile-fail/borrowck-borrowed-uniq-rvalue.rs @@ -16,7 +16,7 @@ extern crate collections; use std::collections::HashMap; fn main() { - let mut buggy_map: HashMap<uint, &uint> = HashMap::new(); + let mut buggy_map: HashMap<usize, &usize> = HashMap::new(); buggy_map.insert(42, &*box 1); //~ ERROR borrowed value does not live long enough // but it is ok if we use a temporary diff --git a/src/test/compile-fail/borrowck-box-insensitivity.rs b/src/test/compile-fail/borrowck-box-insensitivity.rs index bd22b61fe3b..648d0d81ffb 100644 --- a/src/test/compile-fail/borrowck-box-insensitivity.rs +++ b/src/test/compile-fail/borrowck-box-insensitivity.rs @@ -11,23 +11,23 @@ #![feature(box_syntax)] struct A { - x: Box<int>, - y: int, + x: Box<isize>, + y: isize, } struct B { - x: Box<int>, - y: Box<int>, + x: Box<isize>, + y: Box<isize>, } struct C { x: Box<A>, - y: int, + y: isize, } struct D { x: Box<A>, - y: Box<int>, + y: Box<isize>, } fn copy_after_move() { diff --git a/src/test/compile-fail/borrowck-break-uninit-2.rs b/src/test/compile-fail/borrowck-break-uninit-2.rs index 0b10ccfdca1..a52eaeeb9c3 100644 --- a/src/test/compile-fail/borrowck-break-uninit-2.rs +++ b/src/test/compile-fail/borrowck-break-uninit-2.rs @@ -8,17 +8,17 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -fn foo() -> int { - let x: int; +fn foo() -> isize { + let x: isize; - while 1i != 2 { + while 1is != 2 { break; x = 0; } println!("{}", x); //~ ERROR use of possibly uninitialized variable: `x` - return 17i; + return 17is; } fn main() { println!("{}", foo()); } diff --git a/src/test/compile-fail/borrowck-break-uninit.rs b/src/test/compile-fail/borrowck-break-uninit.rs index aa7ce4fa347..8a6a036945b 100644 --- a/src/test/compile-fail/borrowck-break-uninit.rs +++ b/src/test/compile-fail/borrowck-break-uninit.rs @@ -8,8 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -fn foo() -> int { - let x: int; +fn foo() -> isize { + let x: isize; loop { break; 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 9aec8de46b6..010ddb792cc 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 @@ -33,7 +33,7 @@ fn test1() { } fn test2<F>(f: &F) where F: FnMut() { - (*f)(); //~ ERROR: cannot borrow immutable dereference of `&`-pointer `*f` as mutable + (*f)(); //~ ERROR: cannot borrow immutable borrowed content `*f` as mutable } fn test3<F>(f: &mut F) where F: FnMut() { @@ -41,7 +41,7 @@ fn test3<F>(f: &mut F) where F: FnMut() { } fn test4(f: &Test) { - f.f.call_mut(()) //~ ERROR: cannot borrow immutable dereference of `Box` `*f.f` as mutable + f.f.call_mut(()) //~ ERROR: cannot borrow immutable `Box` content `*f.f` as mutable } fn test5(f: &mut Test) { @@ -56,8 +56,8 @@ fn test6() { } fn test7() { - fn foo<F>(_: F) where F: FnMut(Box<FnMut(int)>, int) {} - let mut f = |&mut: g: Box<FnMut(int)>, b: int| {}; + fn foo<F>(_: F) where F: FnMut(Box<FnMut(isize)>, isize) {} + let mut f = |&mut: g: Box<FnMut(isize)>, b: isize| {}; f(box |a| { //~ ERROR: cannot borrow `f` as immutable because it is also borrowed as mutable foo(f); //~ ERROR: cannot move out of captured outer variable }, 3); diff --git a/src/test/compile-fail/borrowck-call-method-from-mut-aliasable.rs b/src/test/compile-fail/borrowck-call-method-from-mut-aliasable.rs index 537e52120d9..bc0b667e895 100644 --- a/src/test/compile-fail/borrowck-call-method-from-mut-aliasable.rs +++ b/src/test/compile-fail/borrowck-call-method-from-mut-aliasable.rs @@ -9,7 +9,7 @@ // except according to those terms. struct Foo { - x: int, + x: isize, } impl Foo { 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 126003b5d82..29c7d6920bd 100644 --- a/src/test/compile-fail/borrowck-closures-mut-and-imm.rs +++ b/src/test/compile-fail/borrowck-closures-mut-and-imm.rs @@ -13,53 +13,53 @@ #![feature(box_syntax)] -fn get(x: &int) -> int { +fn get(x: &isize) -> isize { *x } -fn set(x: &mut int) { +fn set(x: &mut isize) { *x = 4; } fn a() { - let mut x = 3i; + let mut x = 3is; let c1 = |&mut:| x = 4; let c2 = |&mut:| x * 5; //~ ERROR cannot borrow `x` } fn b() { - let mut x = 3i; + let mut x = 3is; let c1 = |&mut:| set(&mut x); let c2 = |&mut:| get(&x); //~ ERROR cannot borrow `x` } fn c() { - let mut x = 3i; + let mut x = 3is; let c1 = |&mut:| set(&mut x); let c2 = |&mut:| x * 5; //~ ERROR cannot borrow `x` } fn d() { - let mut x = 3i; + let mut x = 3is; let c2 = |&mut:| x * 5; x = 5; //~ ERROR cannot assign } fn e() { - let mut x = 3i; + let mut x = 3is; let c1 = |&mut:| get(&x); x = 5; //~ ERROR cannot assign } fn f() { - let mut x = box 3i; + let mut x = box 3is; let c1 = |&mut:| get(&*x); *x = 5; //~ ERROR cannot assign } fn g() { struct Foo { - f: Box<int> + f: Box<isize> } let mut x = box Foo { f: box 3 }; @@ -69,7 +69,7 @@ fn g() { fn h() { struct Foo { - f: Box<int> + f: Box<isize> } let mut x = box Foo { f: box 3 }; diff --git a/src/test/compile-fail/borrowck-closures-mut-of-imm.rs b/src/test/compile-fail/borrowck-closures-mut-of-imm.rs index 30e1421ba26..82607741909 100644 --- a/src/test/compile-fail/borrowck-closures-mut-of-imm.rs +++ b/src/test/compile-fail/borrowck-closures-mut-of-imm.rs @@ -11,15 +11,15 @@ // Tests that two closures cannot simultaneously have mutable // and immutable access to the variable. Issue #6801. -fn get(x: &int) -> int { +fn get(x: &isize) -> isize { *x } -fn set(x: &mut int) { +fn set(x: &mut isize) { *x = 4; } -fn a(x: &int) { +fn a(x: &isize) { let c1 = |&mut:| set(&mut *x); //~^ ERROR cannot borrow let c2 = |&mut:| set(&mut *x); diff --git a/src/test/compile-fail/borrowck-closures-two-mut.rs b/src/test/compile-fail/borrowck-closures-two-mut.rs index e1f557cfab2..5cb49ab7711 100644 --- a/src/test/compile-fail/borrowck-closures-two-mut.rs +++ b/src/test/compile-fail/borrowck-closures-two-mut.rs @@ -15,29 +15,29 @@ #![feature(box_syntax)] fn a() { - let mut x = 3i; + let mut x = 3is; let c1 = |&mut:| x = 4; let c2 = |&mut:| x = 5; //~ ERROR cannot borrow `x` as mutable more than once } -fn set(x: &mut int) { +fn set(x: &mut isize) { *x = 4; } fn b() { - let mut x = 3i; + let mut x = 3is; let c1 = |&mut:| set(&mut x); let c2 = |&mut:| set(&mut x); //~ ERROR cannot borrow `x` as mutable more than once } fn c() { - let mut x = 3i; + let mut x = 3is; let c1 = |&mut:| x = 5; let c2 = |&mut:| set(&mut x); //~ ERROR cannot borrow `x` as mutable more than once } fn d() { - let mut x = 3i; + let mut x = 3is; let c1 = |&mut:| x = 5; let c2 = |&mut:| { let _y = |&mut:| set(&mut x); }; // (nested closure) //~^ ERROR cannot borrow `x` as mutable more than once @@ -45,7 +45,7 @@ fn d() { fn g() { struct Foo { - f: Box<int> + f: Box<isize> } let mut x = box Foo { f: box 3 }; diff --git a/src/test/compile-fail/borrowck-closures-unique-imm.rs b/src/test/compile-fail/borrowck-closures-unique-imm.rs index a9cc9e967f6..cf86602af0b 100644 --- a/src/test/compile-fail/borrowck-closures-unique-imm.rs +++ b/src/test/compile-fail/borrowck-closures-unique-imm.rs @@ -9,7 +9,7 @@ // except according to those terms. struct Foo { - x: int, + x: isize, } pub fn main() { diff --git a/src/test/compile-fail/borrowck-closures-unique.rs b/src/test/compile-fail/borrowck-closures-unique.rs index 9a772cc49b8..f9a6d5ac845 100644 --- a/src/test/compile-fail/borrowck-closures-unique.rs +++ b/src/test/compile-fail/borrowck-closures-unique.rs @@ -14,35 +14,35 @@ // may be *immutable*, but we cannot allow // multiple borrows. -fn get(x: &int) -> int { +fn get(x: &isize) -> isize { *x } -fn set(x: &mut int) -> int { +fn set(x: &mut isize) -> isize { *x } -fn a(x: &mut int) { +fn a(x: &mut isize) { let c1 = |&mut:| get(x); let c2 = |&mut:| get(x); } -fn b(x: &mut int) { +fn b(x: &mut isize) { let c1 = |&mut:| get(x); let c2 = |&mut:| set(x); //~ ERROR closure requires unique access to `x` } -fn c(x: &mut int) { +fn c(x: &mut isize) { let c1 = |&mut:| get(x); let c2 = |&mut:| { get(x); set(x); }; //~ ERROR closure requires unique access to `x` } -fn d(x: &mut int) { +fn d(x: &mut isize) { let c1 = |&mut:| set(x); let c2 = |&mut:| set(x); //~ ERROR closure requires unique access to `x` } -fn e(x: &mut int) { +fn e(x: &mut isize) { let c1 = |&mut:| x = panic!(); //~ ERROR closure cannot assign to immutable local variable } 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 9aa9a50483c..b6529da1883 100644 --- a/src/test/compile-fail/borrowck-closures-use-after-free.rs +++ b/src/test/compile-fail/borrowck-closures-use-after-free.rs @@ -15,7 +15,7 @@ #![feature(box_syntax)] struct Foo { - x: int + x: isize } impl Drop for Foo { diff --git a/src/test/compile-fail/borrowck-field-sensitivity.rs b/src/test/compile-fail/borrowck-field-sensitivity.rs index 52761fa3488..fe5142a7734 100644 --- a/src/test/compile-fail/borrowck-field-sensitivity.rs +++ b/src/test/compile-fail/borrowck-field-sensitivity.rs @@ -10,7 +10,7 @@ #![feature(box_syntax)] -struct A { a: int, b: Box<int> } +struct A { a: isize, b: Box<isize> } fn deref_after_move() { let x = A { a: 1, b: box 2 }; 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 bdcbc839c00..6884ac153a1 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 @@ -13,11 +13,11 @@ #![feature(box_syntax)] struct Foo { - a: [Box<int>; 3], + a: [Box<isize>; 3], } fn main() { - let mut y = 1i; + let mut y = 1is; let x = Some(&mut y); for &a in x.iter() { //~ ERROR cannot move out } @@ -28,7 +28,7 @@ fn main() { for &a in f.a.iter() { //~ ERROR cannot move out } - let x = Some(box 1i); + let x = Some(box 1is); for &a in x.iter() { //~ ERROR cannot move out } } diff --git a/src/test/compile-fail/borrowck-for-loop-head-linkage.rs b/src/test/compile-fail/borrowck-for-loop-head-linkage.rs index cb673f9be34..d2f99ea696a 100644 --- a/src/test/compile-fail/borrowck-for-loop-head-linkage.rs +++ b/src/test/compile-fail/borrowck-for-loop-head-linkage.rs @@ -11,11 +11,11 @@ use std::iter::repeat; fn main() { - let mut vector = vec![1u, 2]; + let mut vector = vec![1us, 2]; for &x in vector.iter() { let cap = vector.capacity(); vector.extend(repeat(0)); //~ ERROR cannot borrow - vector[1u] = 5u; //~ ERROR cannot borrow + vector[1us] = 5us; //~ ERROR cannot borrow } } diff --git a/src/test/compile-fail/borrowck-if-no-else.rs b/src/test/compile-fail/borrowck-if-no-else.rs index 854d42219ea..b98833776fb 100644 --- a/src/test/compile-fail/borrowck-if-no-else.rs +++ b/src/test/compile-fail/borrowck-if-no-else.rs @@ -8,9 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -fn foo(x: int) { println!("{}", x); } +fn foo(x: isize) { println!("{}", x); } fn main() { - let x: int; if 1i > 2 { x = 10; } + let x: isize; if 1is > 2 { x = 10; } foo(x); //~ ERROR use of possibly uninitialized variable: `x` } diff --git a/src/test/compile-fail/borrowck-if-with-else.rs b/src/test/compile-fail/borrowck-if-with-else.rs index e6d59062af2..c74edfd8d07 100644 --- a/src/test/compile-fail/borrowck-if-with-else.rs +++ b/src/test/compile-fail/borrowck-if-with-else.rs @@ -8,11 +8,11 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -fn foo(x: int) { println!("{}", x); } +fn foo(x: isize) { println!("{}", x); } fn main() { - let x: int; - if 1i > 2 { + let x: isize; + if 1is > 2 { println!("whoops"); } else { x = 10; diff --git a/src/test/compile-fail/borrowck-imm-ref-to-mut-rec-field-issue-3162-c.rs b/src/test/compile-fail/borrowck-imm-ref-to-mut-rec-field-issue-3162-c.rs index d127e9345cd..fabfce6ffb3 100644 --- a/src/test/compile-fail/borrowck-imm-ref-to-mut-rec-field-issue-3162-c.rs +++ b/src/test/compile-fail/borrowck-imm-ref-to-mut-rec-field-issue-3162-c.rs @@ -9,7 +9,7 @@ // except according to those terms. fn main() { - let mut _a = 3i; + let mut _a = 3is; let _b = &mut _a; { let _c = &*_b; diff --git a/src/test/compile-fail/borrowck-init-in-called-fn-expr.rs b/src/test/compile-fail/borrowck-init-in-called-fn-expr.rs index 5496a9dd4b3..3c20abab8bd 100644 --- a/src/test/compile-fail/borrowck-init-in-called-fn-expr.rs +++ b/src/test/compile-fail/borrowck-init-in-called-fn-expr.rs @@ -9,8 +9,8 @@ // except according to those terms. fn main() { - let j = |&:| -> int { - let i: int; + let j = |&:| -> isize { + let i: isize; i //~ ERROR use of possibly uninitialized variable: `i` }; j(); diff --git a/src/test/compile-fail/borrowck-init-in-fn-expr.rs b/src/test/compile-fail/borrowck-init-in-fn-expr.rs index 33c284c71b3..31ca39c3f9b 100644 --- a/src/test/compile-fail/borrowck-init-in-fn-expr.rs +++ b/src/test/compile-fail/borrowck-init-in-fn-expr.rs @@ -9,8 +9,8 @@ // except according to those terms. fn main() { - let f = |&:| -> int { - let i: int; + let f = |&:| -> isize { + let i: isize; i //~ ERROR use of possibly uninitialized variable: `i` }; println!("{}", f()); diff --git a/src/test/compile-fail/borrowck-init-in-fru.rs b/src/test/compile-fail/borrowck-init-in-fru.rs index ac90b7cb432..569ddb80c2f 100644 --- a/src/test/compile-fail/borrowck-init-in-fru.rs +++ b/src/test/compile-fail/borrowck-init-in-fru.rs @@ -10,8 +10,8 @@ #[derive(Clone)] struct point { - x: int, - y: int, + x: isize, + y: isize, } fn main() { diff --git a/src/test/compile-fail/borrowck-init-op-equal.rs b/src/test/compile-fail/borrowck-init-op-equal.rs index d6065c81a2d..e0d93fd1d47 100644 --- a/src/test/compile-fail/borrowck-init-op-equal.rs +++ b/src/test/compile-fail/borrowck-init-op-equal.rs @@ -10,7 +10,7 @@ fn test() { - let v: int; + let v: isize; v += 1; //~ ERROR use of possibly uninitialized variable: `v` v.clone(); } diff --git a/src/test/compile-fail/borrowck-init-plus-equal.rs b/src/test/compile-fail/borrowck-init-plus-equal.rs index 6e813809f03..a036286f363 100644 --- a/src/test/compile-fail/borrowck-init-plus-equal.rs +++ b/src/test/compile-fail/borrowck-init-plus-equal.rs @@ -9,7 +9,7 @@ // except according to those terms. fn test() { - let mut v: int; + let mut v: isize; v = v + 1; //~ ERROR use of possibly uninitialized variable: `v` v.clone(); } diff --git a/src/test/compile-fail/borrowck-insert-during-each.rs b/src/test/compile-fail/borrowck-insert-during-each.rs index 0428ee83065..d729af844cb 100644 --- a/src/test/compile-fail/borrowck-insert-during-each.rs +++ b/src/test/compile-fail/borrowck-insert-during-each.rs @@ -12,11 +12,11 @@ extern crate collections; use std::collections::HashSet; struct Foo { - n: HashSet<int>, + n: HashSet<isize>, } impl Foo { - pub fn foo<F>(&mut self, mut fun: F) where F: FnMut(&int) { + pub fn foo<F>(&mut self, mut fun: F) where F: FnMut(&isize) { for f in self.n.iter() { fun(f); } diff --git a/src/test/compile-fail/borrowck-issue-14498.rs b/src/test/compile-fail/borrowck-issue-14498.rs index 8e46db5eba8..cc562afa9f8 100644 --- a/src/test/compile-fail/borrowck-issue-14498.rs +++ b/src/test/compile-fail/borrowck-issue-14498.rs @@ -13,11 +13,11 @@ #![feature(box_syntax)] -struct A { a: int } -struct B<'a> { a: Box<&'a mut int> } +struct A { a: isize } +struct B<'a> { a: Box<&'a mut isize> } fn borrow_in_var_from_var() { - let mut x: int = 1; + let mut x: isize = 1; let y = box &mut x; let p = &y; let q = &***p; @@ -37,7 +37,7 @@ fn borrow_in_var_from_field() { } fn borrow_in_field_from_var() { - let mut x: int = 1; + let mut x: isize = 1; let y = B { a: box &mut x }; let p = &y.a; let q = &***p; diff --git a/src/test/compile-fail/borrowck-issue-2657-1.rs b/src/test/compile-fail/borrowck-issue-2657-1.rs index fa80bf38cfe..dc1c73efc40 100644 --- a/src/test/compile-fail/borrowck-issue-2657-1.rs +++ b/src/test/compile-fail/borrowck-issue-2657-1.rs @@ -11,7 +11,7 @@ #![feature(box_syntax)] fn main() { - let x = Some(box 1i); + let x = Some(box 1is); match x { Some(ref _y) => { let _a = x; //~ ERROR cannot move diff --git a/src/test/compile-fail/borrowck-issue-2657-2.rs b/src/test/compile-fail/borrowck-issue-2657-2.rs index f531b585dde..0b76044f8d6 100644 --- a/src/test/compile-fail/borrowck-issue-2657-2.rs +++ b/src/test/compile-fail/borrowck-issue-2657-2.rs @@ -11,7 +11,7 @@ #![feature(box_syntax)] fn main() { - let x = Some(box 1i); + let x = Some(box 1is); match x { Some(ref y) => { let _b = *y; //~ ERROR cannot move out diff --git a/src/test/compile-fail/borrowck-lend-flow-if.rs b/src/test/compile-fail/borrowck-lend-flow-if.rs index 8a618dfec11..ca8efb5dc96 100644 --- a/src/test/compile-fail/borrowck-lend-flow-if.rs +++ b/src/test/compile-fail/borrowck-lend-flow-if.rs @@ -16,13 +16,13 @@ #![feature(box_syntax)] -fn borrow(_v: &int) {} -fn borrow_mut(_v: &mut int) {} +fn borrow(_v: &isize) {} +fn borrow_mut(_v: &mut isize) {} fn cond() -> bool { panic!() } fn for_func<F>(_f: F) where F: FnOnce() -> bool { panic!() } fn produce<T>() -> T { panic!(); } -fn inc(v: &mut Box<int>) { +fn inc(v: &mut Box<isize>) { *v = box() (**v + 1); } diff --git a/src/test/compile-fail/borrowck-lend-flow-loop.rs b/src/test/compile-fail/borrowck-lend-flow-loop.rs index 954b8010244..491a0d40bec 100644 --- a/src/test/compile-fail/borrowck-lend-flow-loop.rs +++ b/src/test/compile-fail/borrowck-lend-flow-loop.rs @@ -16,12 +16,12 @@ #![feature(box_syntax)] -fn borrow(_v: &int) {} -fn borrow_mut(_v: &mut int) {} +fn borrow(_v: &isize) {} +fn borrow_mut(_v: &mut isize) {} fn cond() -> bool { panic!() } fn produce<T>() -> T { panic!(); } -fn inc(v: &mut Box<int>) { +fn inc(v: &mut Box<isize>) { *v = box() (**v + 1); } @@ -41,7 +41,7 @@ fn block_overarching_alias_mut() { let mut v = box 3; let mut x = &mut v; - for _ in range(0i, 3) { + for _ in range(0is, 3) { borrow(&*v); //~ ERROR cannot borrow } *x = box 5; @@ -113,8 +113,8 @@ fn while_aliased_mut_cond(cond: bool, cond2: bool) { } } -fn loop_break_pops_scopes<'r, F>(_v: &'r mut [uint], mut f: F) where - F: FnMut(&'r mut uint) -> bool, +fn loop_break_pops_scopes<'r, F>(_v: &'r mut [usize], mut f: F) where + F: FnMut(&'r mut usize) -> bool, { // Here we check that when you break out of an inner loop, the // borrows that go out of scope as you exit the inner loop are @@ -123,7 +123,7 @@ fn loop_break_pops_scopes<'r, F>(_v: &'r mut [uint], mut f: F) where while cond() { while cond() { // this borrow is limited to the scope of `r`... - let r: &'r mut uint = produce(); + let r: &'r mut usize = produce(); if !f(&mut *r) { break; // ...so it is not live as exit the `while` loop here } @@ -131,13 +131,15 @@ fn loop_break_pops_scopes<'r, F>(_v: &'r mut [uint], mut f: F) where } } -fn loop_loop_pops_scopes<'r, F>(_v: &'r mut [uint], mut f: F) where F: FnMut(&'r mut uint) -> bool { +fn loop_loop_pops_scopes<'r, F>(_v: &'r mut [usize], mut f: F) + where F: FnMut(&'r mut usize) -> bool +{ // Similar to `loop_break_pops_scopes` but for the `loop` keyword while cond() { while cond() { // this borrow is limited to the scope of `r`... - let r: &'r mut uint = produce(); + let r: &'r mut usize = produce(); if !f(&mut *r) { continue; // ...so it is not live as exit (and re-enter) the `while` loop here } diff --git a/src/test/compile-fail/borrowck-lend-flow-match.rs b/src/test/compile-fail/borrowck-lend-flow-match.rs index 0b40a78425f..f501682847f 100644 --- a/src/test/compile-fail/borrowck-lend-flow-match.rs +++ b/src/test/compile-fail/borrowck-lend-flow-match.rs @@ -19,10 +19,10 @@ fn separate_arms() { None => { // It is ok to reassign x here, because there is in // fact no outstanding loan of x! - x = Some(0i); + x = Some(0is); } Some(ref _i) => { - x = Some(1i); //~ ERROR cannot assign + x = Some(1is); //~ ERROR cannot assign } } x.clone(); // just to prevent liveness warnings diff --git a/src/test/compile-fail/borrowck-lend-flow.rs b/src/test/compile-fail/borrowck-lend-flow.rs index d5419b05851..177976c15f0 100644 --- a/src/test/compile-fail/borrowck-lend-flow.rs +++ b/src/test/compile-fail/borrowck-lend-flow.rs @@ -16,13 +16,13 @@ #![feature(box_syntax)] -fn borrow(_v: &int) {} -fn borrow_mut(_v: &mut int) {} +fn borrow(_v: &isize) {} +fn borrow_mut(_v: &mut isize) {} fn cond() -> bool { panic!() } fn for_func<F>(_f: F) where F: FnOnce() -> bool { panic!() } fn produce<T>() -> T { panic!(); } -fn inc(v: &mut Box<int>) { +fn inc(v: &mut Box<isize>) { *v = box() (**v + 1); } diff --git a/src/test/compile-fail/borrowck-let-suggestion.rs b/src/test/compile-fail/borrowck-let-suggestion.rs index cd1101c05d1..5f5ff4014e1 100644 --- a/src/test/compile-fail/borrowck-let-suggestion.rs +++ b/src/test/compile-fail/borrowck-let-suggestion.rs @@ -9,7 +9,7 @@ // except according to those terms. fn f() { - let x = [1i].iter(); //~ ERROR borrowed value does not live long enough + let x = [1is].iter(); //~ ERROR borrowed value does not live long enough //~^^ NOTE reference must be valid for the block //~^^ HELP consider using a `let` binding to increase its lifetime } 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 8b39b6ff661..bff22257760 100644 --- a/src/test/compile-fail/borrowck-loan-blocks-move-cc.rs +++ b/src/test/compile-fail/borrowck-loan-blocks-move-cc.rs @@ -12,12 +12,12 @@ use std::thread::Thread; -fn borrow<F>(v: &int, f: F) where F: FnOnce(&int) { +fn borrow<F>(v: &isize, f: F) where F: FnOnce(&isize) { f(v); } fn box_imm() { - let v = box 3i; + let v = box 3is; let _w = &v; Thread::spawn(move|| { println!("v={}", *v); @@ -26,7 +26,7 @@ fn box_imm() { } fn box_imm_explicit() { - let v = box 3i; + let v = box 3is; let _w = &v; Thread::spawn(move|| { println!("v={}", *v); diff --git a/src/test/compile-fail/borrowck-loan-blocks-move.rs b/src/test/compile-fail/borrowck-loan-blocks-move.rs index f588dbab4fa..f3f18807314 100644 --- a/src/test/compile-fail/borrowck-loan-blocks-move.rs +++ b/src/test/compile-fail/borrowck-loan-blocks-move.rs @@ -10,7 +10,7 @@ #![feature(box_syntax)] -fn take(_v: Box<int>) { +fn take(_v: Box<isize>) { } fn box_imm() { 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 e59baa1e37c..a52a4484b20 100644 --- a/src/test/compile-fail/borrowck-loan-blocks-mut-uniq.rs +++ b/src/test/compile-fail/borrowck-loan-blocks-mut-uniq.rs @@ -10,7 +10,7 @@ #![feature(box_syntax)] -fn borrow<F>(v: &int, f: F) where F: FnOnce(&int) { +fn borrow<F>(v: &isize, f: F) where F: FnOnce(&isize) { 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 d955e8984bf..902762f687e 100644 --- a/src/test/compile-fail/borrowck-loan-in-overloaded-op.rs +++ b/src/test/compile-fail/borrowck-loan-in-overloaded-op.rs @@ -13,7 +13,7 @@ use std::ops::Add; #[derive(Clone)] -struct foo(Box<uint>); +struct foo(Box<usize>); impl Add for foo { type Output = foo; diff --git a/src/test/compile-fail/borrowck-loan-rcvr-overloaded-op.rs b/src/test/compile-fail/borrowck-loan-rcvr-overloaded-op.rs index 5aa2deb44f1..b1eb06d16b1 100644 --- a/src/test/compile-fail/borrowck-loan-rcvr-overloaded-op.rs +++ b/src/test/compile-fail/borrowck-loan-rcvr-overloaded-op.rs @@ -12,20 +12,20 @@ use std::ops::Add; #[derive(Copy)] struct Point { - x: int, - y: int, + x: isize, + y: isize, } -impl Add<int> for Point { - type Output = int; +impl Add<isize> for Point { + type Output = isize; - fn add(self, z: int) -> int { + fn add(self, z: isize) -> isize { self.x + self.y + z } } impl Point { - pub fn times(&self, z: int) -> int { + pub fn times(&self, z: isize) -> isize { self.x * self.y * z } } diff --git a/src/test/compile-fail/borrowck-loan-rcvr.rs b/src/test/compile-fail/borrowck-loan-rcvr.rs index 0ada3db47a4..014b27f9659 100644 --- a/src/test/compile-fail/borrowck-loan-rcvr.rs +++ b/src/test/compile-fail/borrowck-loan-rcvr.rs @@ -9,7 +9,7 @@ // except according to those terms. -struct point { x: int, y: int } +struct point { x: isize, y: isize } trait methods { fn impurem(&self); diff --git a/src/test/compile-fail/borrowck-loan-vec-content.rs b/src/test/compile-fail/borrowck-loan-vec-content.rs index efb7a5253ed..21d9dea77b2 100644 --- a/src/test/compile-fail/borrowck-loan-vec-content.rs +++ b/src/test/compile-fail/borrowck-loan-vec-content.rs @@ -12,17 +12,17 @@ // (locally rooted) mutable, unique vector, and that we then prevent // modifications to the contents. -fn takes_imm_elt<F>(_v: &int, f: F) where F: FnOnce() { +fn takes_imm_elt<F>(_v: &isize, f: F) where F: FnOnce() { f(); } fn has_mut_vec_and_does_not_try_to_change_it() { - let mut v: Vec<int> = vec!(1, 2, 3); + let mut v: Vec<isize> = vec!(1, 2, 3); takes_imm_elt(&v[0], || {}) } fn has_mut_vec_but_tries_to_change_it() { - let mut v: Vec<int> = vec!(1, 2, 3); + let mut v: Vec<isize> = vec!(1, 2, 3); takes_imm_elt( &v[0], || { //~ ERROR cannot borrow `v` as mutable diff --git a/src/test/compile-fail/borrowck-match-binding-is-assignment.rs b/src/test/compile-fail/borrowck-match-binding-is-assignment.rs index fe0519b8198..575d67c0b83 100644 --- a/src/test/compile-fail/borrowck-match-binding-is-assignment.rs +++ b/src/test/compile-fail/borrowck-match-binding-is-assignment.rs @@ -11,15 +11,15 @@ // Test that immutable pattern bindings cannot be reassigned. enum E { - Foo(int) + Foo(isize) } struct S { - bar: int, + bar: isize, } pub fn main() { - match 1i { + match 1is { x => { x += 1; //~ ERROR re-assignment of immutable variable `x` } @@ -37,13 +37,13 @@ pub fn main() { } } - match (1i,) { + match (1is,) { (x,) => { x += 1; //~ ERROR re-assignment of immutable variable `x` } } - match [1i,2,3] { + match [1is,2,3] { [x,_,_] => { x += 1; //~ ERROR re-assignment of immutable variable `x` } diff --git a/src/test/compile-fail/borrowck-move-by-capture.rs b/src/test/compile-fail/borrowck-move-by-capture.rs index 20212762188..b0d546cd5c8 100644 --- a/src/test/compile-fail/borrowck-move-by-capture.rs +++ b/src/test/compile-fail/borrowck-move-by-capture.rs @@ -13,6 +13,6 @@ pub fn main() { let bar = box 3; let _g = |&mut:| { - let _h = move |:| -> int { *bar }; //~ ERROR cannot move out of captured outer variable + let _h = move |:| -> isize { *bar }; //~ ERROR cannot move out of captured outer variable }; } 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 4984987c5ca..2d82c8be519 100644 --- a/src/test/compile-fail/borrowck-move-error-with-note.rs +++ b/src/test/compile-fail/borrowck-move-error-with-note.rs @@ -45,7 +45,7 @@ fn move_in_match() { // from issue-8064 struct A { - a: Box<int>, + a: Box<isize>, } fn free<T>(_: T) {} 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 936092df42e..0d1a51bbf35 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 @@ -14,7 +14,7 @@ #![feature(box_syntax)] fn main() { - let a = box box 2i; + let a = box box 2is; let b = &a; let z = *a; //~ ERROR: cannot move out of `*a` because it is borrowed diff --git a/src/test/compile-fail/borrowck-move-from-unsafe-ptr.rs b/src/test/compile-fail/borrowck-move-from-unsafe-ptr.rs index 87bb8ef7a58..8310d4ba144 100644 --- a/src/test/compile-fail/borrowck-move-from-unsafe-ptr.rs +++ b/src/test/compile-fail/borrowck-move-from-unsafe-ptr.rs @@ -9,7 +9,7 @@ // except according to those terms. -fn foo(x: *const Box<int>) -> Box<int> { +fn foo(x: *const Box<isize>) -> Box<isize> { let y = *x; //~ ERROR dereference of unsafe pointer requires unsafe function or block return y; } diff --git a/src/test/compile-fail/borrowck-move-in-irrefut-pat.rs b/src/test/compile-fail/borrowck-move-in-irrefut-pat.rs index c5d23925a89..ec505faf885 100644 --- a/src/test/compile-fail/borrowck-move-in-irrefut-pat.rs +++ b/src/test/compile-fail/borrowck-move-in-irrefut-pat.rs @@ -11,16 +11,16 @@ fn with<F>(f: F) where F: FnOnce(&String) {} fn arg_item(&_x: &String) {} - //~^ ERROR cannot move out of dereference of `&`-pointer + //~^ ERROR cannot move out of borrowed content fn arg_closure() { with(|&_x| ()) - //~^ ERROR cannot move out of dereference of `&`-pointer + //~^ ERROR cannot move out of borrowed content } fn let_pat() { let &_x = &"hi".to_string(); - //~^ ERROR cannot move out of dereference of `&`-pointer + //~^ ERROR cannot move out of borrowed content } pub fn main() {} 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 35aef1352d1..43bf3f25d1a 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 @@ -10,7 +10,7 @@ #![feature(box_syntax)] -fn call_f<F:FnOnce() -> int>(f: F) -> int { +fn call_f<F:FnOnce() -> isize>(f: F) -> isize { f() } diff --git a/src/test/compile-fail/borrowck-move-mut-base-ptr.rs b/src/test/compile-fail/borrowck-move-mut-base-ptr.rs index ce2755dbc0f..5bdea6a2bd9 100644 --- a/src/test/compile-fail/borrowck-move-mut-base-ptr.rs +++ b/src/test/compile-fail/borrowck-move-mut-base-ptr.rs @@ -13,8 +13,8 @@ // // Example from src/middle/borrowck/doc.rs -fn foo(t0: &mut int) { - let p: &int = &*t0; // Freezes `*t0` +fn foo(t0: &mut isize) { + let p: &isize = &*t0; // Freezes `*t0` let t1 = t0; //~ ERROR cannot move out of `t0` *t1 = 22; } diff --git a/src/test/compile-fail/borrowck-move-out-of-overloaded-auto-deref.rs b/src/test/compile-fail/borrowck-move-out-of-overloaded-auto-deref.rs index a6723a04611..507f073adb2 100644 --- a/src/test/compile-fail/borrowck-move-out-of-overloaded-auto-deref.rs +++ b/src/test/compile-fail/borrowck-move-out-of-overloaded-auto-deref.rs @@ -11,6 +11,6 @@ use std::rc::Rc; pub fn main() { - let _x = Rc::new(vec!(1i, 2)).into_iter(); - //~^ ERROR cannot move out of dereference of `&`-pointer + let _x = Rc::new(vec!(1is, 2)).into_iter(); + //~^ ERROR cannot move out of borrowed content } diff --git a/src/test/compile-fail/borrowck-move-out-of-overloaded-deref.rs b/src/test/compile-fail/borrowck-move-out-of-overloaded-deref.rs index 8a93790d5a2..fffcf575ab0 100644 --- a/src/test/compile-fail/borrowck-move-out-of-overloaded-deref.rs +++ b/src/test/compile-fail/borrowck-move-out-of-overloaded-deref.rs @@ -12,5 +12,5 @@ use std::rc::Rc; pub fn main() { let _x = *Rc::new("hi".to_string()); - //~^ ERROR cannot move out of dereference of `&`-pointer + //~^ ERROR cannot move out of borrowed content } diff --git a/src/test/compile-fail/borrowck-move-out-of-static-item.rs b/src/test/compile-fail/borrowck-move-out-of-static-item.rs index 730a0c3e235..2f81aa8f381 100644 --- a/src/test/compile-fail/borrowck-move-out-of-static-item.rs +++ b/src/test/compile-fail/borrowck-move-out-of-static-item.rs @@ -13,7 +13,7 @@ use std::marker; struct Foo { - foo: int, + foo: isize, nocopy: marker::NoCopy } diff --git a/src/test/compile-fail/borrowck-move-out-of-vec-tail.rs b/src/test/compile-fail/borrowck-move-out-of-vec-tail.rs index 23ef5331b49..75596af10d7 100644 --- a/src/test/compile-fail/borrowck-move-out-of-vec-tail.rs +++ b/src/test/compile-fail/borrowck-move-out-of-vec-tail.rs @@ -25,7 +25,7 @@ pub fn main() { match x { [_, tail..] => { match tail { - [Foo { string: a }, //~ ERROR cannot move out of dereference of `&`-pointer + [Foo { string: a }, //~ ERROR cannot move out of borrowed content Foo { string: b }] => { //~^^ NOTE attempting to move value to here //~^^ NOTE and here diff --git a/src/test/compile-fail/borrowck-move-subcomponent.rs b/src/test/compile-fail/borrowck-move-subcomponent.rs index bdf6fe1f21d..88871dda659 100644 --- a/src/test/compile-fail/borrowck-move-subcomponent.rs +++ b/src/test/compile-fail/borrowck-move-subcomponent.rs @@ -14,7 +14,7 @@ #![feature(box_syntax)] struct S { - x : Box<int> + x : Box<isize> } fn f<T>(_: T) {} diff --git a/src/test/compile-fail/borrowck-multiple-captures.rs b/src/test/compile-fail/borrowck-multiple-captures.rs index e90d25c781b..33ac5d7fceb 100644 --- a/src/test/compile-fail/borrowck-multiple-captures.rs +++ b/src/test/compile-fail/borrowck-multiple-captures.rs @@ -15,9 +15,9 @@ use std::thread::Thread; fn borrow<T>(_: &T) { } fn different_vars_after_borrows() { - let x1 = box 1i; + let x1 = box 1is; let p1 = &x1; - let x2 = box 2i; + let x2 = box 2is; let p2 = &x2; Thread::spawn(move|| { drop(x1); //~ ERROR cannot move `x1` into closure because it is borrowed @@ -28,9 +28,9 @@ fn different_vars_after_borrows() { } fn different_vars_after_moves() { - let x1 = box 1i; + let x1 = box 1is; drop(x1); - let x2 = box 2i; + let x2 = box 2is; drop(x2); Thread::spawn(move|| { drop(x1); //~ ERROR capture of moved value: `x1` @@ -39,7 +39,7 @@ fn different_vars_after_moves() { } fn same_var_after_borrow() { - let x = box 1i; + let x = box 1is; let p = &x; Thread::spawn(move|| { drop(x); //~ ERROR cannot move `x` into closure because it is borrowed @@ -49,7 +49,7 @@ fn same_var_after_borrow() { } fn same_var_after_move() { - let x = box 1i; + let x = box 1is; drop(x); Thread::spawn(move|| { drop(x); //~ ERROR capture of moved value: `x` diff --git a/src/test/compile-fail/borrowck-mut-addr-of-imm-var.rs b/src/test/compile-fail/borrowck-mut-addr-of-imm-var.rs index 0c0377e7411..b6626a835e4 100644 --- a/src/test/compile-fail/borrowck-mut-addr-of-imm-var.rs +++ b/src/test/compile-fail/borrowck-mut-addr-of-imm-var.rs @@ -9,8 +9,8 @@ // except according to those terms. fn main() { - let x: int = 3; - let y: &mut int = &mut x; //~ ERROR cannot borrow + let x: isize = 3; + let y: &mut isize = &mut x; //~ ERROR cannot borrow *y = 5; println!("{}", *y); } diff --git a/src/test/compile-fail/borrowck-mut-borrow-of-mut-base-ptr.rs b/src/test/compile-fail/borrowck-mut-borrow-of-mut-base-ptr.rs index fb018f3d4bc..71dc61abb64 100644 --- a/src/test/compile-fail/borrowck-mut-borrow-of-mut-base-ptr.rs +++ b/src/test/compile-fail/borrowck-mut-borrow-of-mut-base-ptr.rs @@ -13,16 +13,16 @@ // // Example from src/middle/borrowck/doc.rs -fn foo<'a>(mut t0: &'a mut int, - mut t1: &'a mut int) { - let p: &int = &*t0; // Freezes `*t0` +fn foo<'a>(mut t0: &'a mut isize, + mut t1: &'a mut isize) { + let p: &isize = &*t0; // Freezes `*t0` let mut t2 = &mut t0; //~ ERROR cannot borrow `t0` **t2 += 1; // Mutates `*t0` } -fn bar<'a>(mut t0: &'a mut int, - mut t1: &'a mut int) { - let p: &mut int = &mut *t0; // Claims `*t0` +fn bar<'a>(mut t0: &'a mut isize, + mut t1: &'a mut isize) { + let p: &mut isize = &mut *t0; // Claims `*t0` let mut t2 = &mut t0; //~ ERROR cannot borrow `t0` **t2 += 1; // Mutates `*t0` but not through `*p` } diff --git a/src/test/compile-fail/borrowck-mut-slice-of-imm-vec.rs b/src/test/compile-fail/borrowck-mut-slice-of-imm-vec.rs index 283d6398e9a..b8a92db4e42 100644 --- a/src/test/compile-fail/borrowck-mut-slice-of-imm-vec.rs +++ b/src/test/compile-fail/borrowck-mut-slice-of-imm-vec.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -fn write(v: &mut [int]) { +fn write(v: &mut [isize]) { v[0] += 1; } diff --git a/src/test/compile-fail/borrowck-mutate-in-guard.rs b/src/test/compile-fail/borrowck-mutate-in-guard.rs index 464e42df8aa..44353ab5d96 100644 --- a/src/test/compile-fail/borrowck-mutate-in-guard.rs +++ b/src/test/compile-fail/borrowck-mutate-in-guard.rs @@ -9,11 +9,11 @@ // except according to those terms. enum Enum<'a> { - A(&'a int), + A(&'a isize), B(bool), } -fn foo() -> int { +fn foo() -> isize { let mut n = 42; let mut x = Enum::A(&mut n); match x { diff --git a/src/test/compile-fail/borrowck-or-init.rs b/src/test/compile-fail/borrowck-or-init.rs index 270eeca4c4b..27871a6ab16 100644 --- a/src/test/compile-fail/borrowck-or-init.rs +++ b/src/test/compile-fail/borrowck-or-init.rs @@ -9,7 +9,7 @@ // except according to those terms. fn main() { - let i: int; + let i: isize; println!("{}", false || { i = 5; true }); println!("{}", i); //~ ERROR use of possibly uninitialized variable: `i` diff --git a/src/test/compile-fail/borrowck-overloaded-call.rs b/src/test/compile-fail/borrowck-overloaded-call.rs index 938fc53d610..7d35a27c0ae 100644 --- a/src/test/compile-fail/borrowck-overloaded-call.rs +++ b/src/test/compile-fail/borrowck-overloaded-call.rs @@ -13,23 +13,23 @@ use std::ops::{Fn, FnMut, FnOnce}; struct SFn { - x: int, - y: int, + x: isize, + y: isize, } -impl Fn<(int,),int> for SFn { - extern "rust-call" fn call(&self, (z,): (int,)) -> int { +impl Fn<(isize,),isize> for SFn { + extern "rust-call" fn call(&self, (z,): (isize,)) -> isize { self.x * self.y * z } } struct SFnMut { - x: int, - y: int, + x: isize, + y: isize, } -impl FnMut<(int,),int> for SFnMut { - extern "rust-call" fn call_mut(&mut self, (z,): (int,)) -> int { +impl FnMut<(isize,),isize> for SFnMut { + extern "rust-call" fn call_mut(&mut self, (z,): (isize,)) -> isize { self.x * self.y * z } } @@ -38,8 +38,8 @@ struct SFnOnce { x: String, } -impl FnOnce<(String,),uint> for SFnOnce { - extern "rust-call" fn call_once(self, (z,): (String,)) -> uint { +impl FnOnce<(String,),usize> for SFnOnce { + extern "rust-call" fn call_once(self, (z,): (String,)) -> usize { self.x.len() + z.len() } } diff --git a/src/test/compile-fail/borrowck-overloaded-index-2.rs b/src/test/compile-fail/borrowck-overloaded-index-2.rs index 5e6d235574e..da3da47fa90 100644 --- a/src/test/compile-fail/borrowck-overloaded-index-2.rs +++ b/src/test/compile-fail/borrowck-overloaded-index-2.rs @@ -16,17 +16,17 @@ struct MyVec<T> { data: Vec<T>, } -impl<T> Index<uint> for MyVec<T> { +impl<T> Index<usize> for MyVec<T> { type Output = T; - fn index(&self, &i: &uint) -> &T { + fn index(&self, &i: &usize) -> &T { &self.data[i] } } fn main() { - let v = MyVec { data: vec!(box 1i, box 2, box 3) }; + let v = MyVec { data: vec!(box 1is, box 2, box 3) }; let good = &v[0]; // Shouldn't fail here let bad = v[0]; - //~^ ERROR cannot move out of dereference (dereference is implicit, due to indexing) + //~^ ERROR cannot move out of indexed content } diff --git a/src/test/compile-fail/borrowck-overloaded-index-and-overloaded-deref.rs b/src/test/compile-fail/borrowck-overloaded-index-and-overloaded-deref.rs new file mode 100644 index 00000000000..4188cf00142 --- /dev/null +++ b/src/test/compile-fail/borrowck-overloaded-index-and-overloaded-deref.rs @@ -0,0 +1,47 @@ +// 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. + +// Check that we properly record borrows when we are doing an +// overloaded, autoderef of a value obtained via an overloaded index +// operator. The accounting of the all the implicit things going on +// here is rather subtle. Issue #20232. + +use std::ops::{Deref, Index}; + +struct MyVec<T> { x: T } + +impl<T> Index<usize> for MyVec<T> { + type Output = T; + fn index(&self, _: &usize) -> &T { + &self.x + } +} + +struct MyPtr<T> { x: T } + +impl<T> Deref for MyPtr<T> { + type Target = T; + fn deref(&self) -> &T { + &self.x + } +} + +struct Foo { f: usize } + +fn main() { + let mut v = MyVec { x: MyPtr { x: Foo { f: 22 } } }; + let i = &v[0].f; + v = MyVec { x: MyPtr { x: Foo { f: 23 } } }; + //~^ ERROR cannot assign to `v` + read(*i); +} + +fn read(_: usize) { } + diff --git a/src/test/compile-fail/borrowck-overloaded-index-autoderef.rs b/src/test/compile-fail/borrowck-overloaded-index-autoderef.rs index 416e67dac0c..9193a28511e 100644 --- a/src/test/compile-fail/borrowck-overloaded-index-autoderef.rs +++ b/src/test/compile-fail/borrowck-overloaded-index-autoderef.rs @@ -14,14 +14,14 @@ use std::ops::{Index, IndexMut}; struct Foo { - x: int, - y: int, + x: isize, + y: isize, } impl Index<String> for Foo { - type Output = int; + type Output = isize; - fn index<'a>(&'a self, z: &String) -> &'a int { + fn index<'a>(&'a self, z: &String) -> &'a isize { if z.as_slice() == "x" { &self.x } else { @@ -31,9 +31,9 @@ impl Index<String> for Foo { } impl IndexMut<String> for Foo { - type Output = int; + type Output = isize; - fn index_mut<'a>(&'a mut self, z: &String) -> &'a mut int { + fn index_mut<'a>(&'a mut self, z: &String) -> &'a mut isize { if z.as_slice() == "x" { &mut self.x } else { diff --git a/src/test/compile-fail/borrowck-overloaded-index.rs b/src/test/compile-fail/borrowck-overloaded-index.rs index 80b68dbf519..7259ca8971d 100644 --- a/src/test/compile-fail/borrowck-overloaded-index.rs +++ b/src/test/compile-fail/borrowck-overloaded-index.rs @@ -11,14 +11,14 @@ use std::ops::{Index, IndexMut}; struct Foo { - x: int, - y: int, + x: isize, + y: isize, } impl Index<String> for Foo { - type Output = int; + type Output = isize; - fn index<'a>(&'a self, z: &String) -> &'a int { + fn index<'a>(&'a self, z: &String) -> &'a isize { if z.as_slice() == "x" { &self.x } else { @@ -28,9 +28,9 @@ impl Index<String> for Foo { } impl IndexMut<String> for Foo { - type Output = int; + type Output = isize; - fn index_mut<'a>(&'a mut self, z: &String) -> &'a mut int { + fn index_mut<'a>(&'a mut self, z: &String) -> &'a mut isize { if z.as_slice() == "x" { &mut self.x } else { @@ -40,13 +40,13 @@ impl IndexMut<String> for Foo { } struct Bar { - x: int, + x: isize, } -impl Index<int> for Bar { - type Output = int; +impl Index<isize> for Bar { + type Output = isize; - fn index<'a>(&'a self, z: &int) -> &'a int { + fn index<'a>(&'a self, z: &isize) -> &'a isize { &self.x } } @@ -66,5 +66,5 @@ fn main() { x: 1, }; s[2] = 20; - //~^ ERROR cannot assign to immutable dereference (dereference is implicit, due to indexing) + //~^ ERROR cannot assign to immutable indexed content } diff --git a/src/test/compile-fail/borrowck-pat-reassign-binding.rs b/src/test/compile-fail/borrowck-pat-reassign-binding.rs index f33e5e9b02d..d176245823e 100644 --- a/src/test/compile-fail/borrowck-pat-reassign-binding.rs +++ b/src/test/compile-fail/borrowck-pat-reassign-binding.rs @@ -9,7 +9,7 @@ // except according to those terms. fn main() { - let mut x: Option<int> = None; + let mut x: Option<isize> = None; match x { None => { // Note: on this branch, no borrow has occurred. diff --git a/src/test/compile-fail/borrowck-reborrow-from-mut.rs b/src/test/compile-fail/borrowck-reborrow-from-mut.rs index b4bd64f2135..6f5dfa67be5 100644 --- a/src/test/compile-fail/borrowck-reborrow-from-mut.rs +++ b/src/test/compile-fail/borrowck-reborrow-from-mut.rs @@ -14,8 +14,8 @@ struct Foo { } struct Bar { - int1: int, - int2: int, + int1: isize, + int2: isize, } fn borrow_same_field_twice_mut_mut(foo: &mut Foo) { diff --git a/src/test/compile-fail/borrowck-reborrow-from-shorter-lived-andmut.rs b/src/test/compile-fail/borrowck-reborrow-from-shorter-lived-andmut.rs index 05cadfd5365..eee407472bf 100644 --- a/src/test/compile-fail/borrowck-reborrow-from-shorter-lived-andmut.rs +++ b/src/test/compile-fail/borrowck-reborrow-from-shorter-lived-andmut.rs @@ -12,7 +12,7 @@ // borrowed (but otherwise non-aliasable) location is illegal. struct S<'a> { - pointer: &'a mut int + pointer: &'a mut isize } fn copy_borrowed_ptr<'a,'b>(p: &'a mut S<'b>) -> S<'b> { diff --git a/src/test/compile-fail/borrowck-ref-mut-of-imm.rs b/src/test/compile-fail/borrowck-ref-mut-of-imm.rs index 4a34b85c3ed..1784b72a699 100644 --- a/src/test/compile-fail/borrowck-ref-mut-of-imm.rs +++ b/src/test/compile-fail/borrowck-ref-mut-of-imm.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -fn destructure(x: Option<int>) -> int { +fn destructure(x: Option<isize>) -> isize { match x { None => 0, Some(ref mut v) => *v //~ ERROR cannot borrow diff --git a/src/test/compile-fail/borrowck-report-with-custom-diagnostic.rs b/src/test/compile-fail/borrowck-report-with-custom-diagnostic.rs index 0a47353683c..c3a1e808e37 100644 --- a/src/test/compile-fail/borrowck-report-with-custom-diagnostic.rs +++ b/src/test/compile-fail/borrowck-report-with-custom-diagnostic.rs @@ -11,7 +11,7 @@ #![allow(dead_code)] fn main() { // Original borrow ends at end of function - let mut x = 1u; + let mut x = 1us; let y = &mut x; let z = &x; //~ ERROR cannot borrow } @@ -21,7 +21,7 @@ fn foo() { match true { true => { // Original borrow ends at end of match arm - let mut x = 1u; + let mut x = 1us; let y = &x; let z = &mut x; //~ ERROR cannot borrow } @@ -33,7 +33,7 @@ fn foo() { fn bar() { // Original borrow ends at end of closure |&:| { - let mut x = 1u; + let mut x = 1us; let y = &mut x; let z = &mut x; //~ ERROR cannot borrow }; diff --git a/src/test/compile-fail/borrowck-return.rs b/src/test/compile-fail/borrowck-return.rs index 6558bc57968..74d435b35e7 100644 --- a/src/test/compile-fail/borrowck-return.rs +++ b/src/test/compile-fail/borrowck-return.rs @@ -8,8 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -fn f() -> int { - let x: int; +fn f() -> isize { + let x: isize; return x; //~ ERROR use of possibly uninitialized variable: `x` } diff --git a/src/test/compile-fail/borrowck-struct-update-with-dtor.rs b/src/test/compile-fail/borrowck-struct-update-with-dtor.rs index 98a29f01faf..bbfc5f89a8d 100644 --- a/src/test/compile-fail/borrowck-struct-update-with-dtor.rs +++ b/src/test/compile-fail/borrowck-struct-update-with-dtor.rs @@ -15,10 +15,10 @@ use std::marker::NoCopy as NP; -struct S { a: int, np: NP } +struct S { a: isize, np: NP } impl Drop for S { fn drop(&mut self) { } } -struct T { a: int, mv: Box<int> } +struct T { a: isize, mv: Box<isize> } impl Drop for T { fn drop(&mut self) { } } fn f(s0:S) { diff --git a/src/test/compile-fail/borrowck-swap-mut-base-ptr.rs b/src/test/compile-fail/borrowck-swap-mut-base-ptr.rs index 3e8a0f87659..0102a909188 100644 --- a/src/test/compile-fail/borrowck-swap-mut-base-ptr.rs +++ b/src/test/compile-fail/borrowck-swap-mut-base-ptr.rs @@ -15,9 +15,9 @@ use std::mem::swap; -fn foo<'a>(mut t0: &'a mut int, - mut t1: &'a mut int) { - let p: &int = &*t0; // Freezes `*t0` +fn foo<'a>(mut t0: &'a mut isize, + mut t1: &'a mut isize) { + let p: &isize = &*t0; // Freezes `*t0` swap(&mut t0, &mut t1); //~ ERROR cannot borrow `t0` *t1 = 22; } diff --git a/src/test/compile-fail/borrowck-unary-move.rs b/src/test/compile-fail/borrowck-unary-move.rs index 72941f77210..5b5c5f4da91 100644 --- a/src/test/compile-fail/borrowck-unary-move.rs +++ b/src/test/compile-fail/borrowck-unary-move.rs @@ -9,13 +9,13 @@ // except according to those terms. -fn foo(x: Box<int>) -> int { +fn foo(x: Box<isize>) -> isize { let y = &*x; free(x); //~ ERROR cannot move out of `x` because it is borrowed *y } -fn free(_x: Box<int>) { +fn free(_x: Box<isize>) { } fn main() { diff --git a/src/test/compile-fail/borrowck-unboxed-closures.rs b/src/test/compile-fail/borrowck-unboxed-closures.rs index cca3dcb8b34..8e7e2e3e777 100644 --- a/src/test/compile-fail/borrowck-unboxed-closures.rs +++ b/src/test/compile-fail/borrowck-unboxed-closures.rs @@ -10,17 +10,17 @@ #![feature(overloaded_calls, unboxed_closures)] -fn a<F:Fn(int, int) -> int>(mut f: F) { +fn a<F:Fn(isize, isize) -> isize>(mut f: F) { let g = &mut f; f(1, 2); //~ ERROR cannot borrow `f` as immutable //~^ ERROR cannot borrow `f` as immutable } -fn b<F:FnMut(int, int) -> int>(f: F) { +fn b<F:FnMut(isize, isize) -> isize>(f: F) { f(1, 2); //~ ERROR cannot borrow immutable local variable } -fn c<F:FnOnce(int, int) -> int>(f: F) { +fn c<F:FnOnce(isize, isize) -> isize>(f: F) { f(1, 2); f(1, 2); //~ ERROR use of moved value } diff --git a/src/test/compile-fail/borrowck-uninit-after-item.rs b/src/test/compile-fail/borrowck-uninit-after-item.rs index a828b1d6b9f..acd827d6c62 100644 --- a/src/test/compile-fail/borrowck-uninit-after-item.rs +++ b/src/test/compile-fail/borrowck-uninit-after-item.rs @@ -10,6 +10,6 @@ fn main() { let bar; - fn baz(_x: int) { } + fn baz(_x: isize) { } baz(bar); //~ ERROR use of possibly uninitialized variable: `bar` } diff --git a/src/test/compile-fail/borrowck-uninit-in-assignop.rs b/src/test/compile-fail/borrowck-uninit-in-assignop.rs index b5e462e592a..e253ecc74b9 100644 --- a/src/test/compile-fail/borrowck-uninit-in-assignop.rs +++ b/src/test/compile-fail/borrowck-uninit-in-assignop.rs @@ -12,33 +12,33 @@ // expression is detected. pub fn main() { - let x: int; + let x: isize; x += 1; //~ ERROR use of possibly uninitialized variable: `x` - let x: int; + let x: isize; x -= 1; //~ ERROR use of possibly uninitialized variable: `x` - let x: int; + let x: isize; x *= 1; //~ ERROR use of possibly uninitialized variable: `x` - let x: int; + let x: isize; x /= 1; //~ ERROR use of possibly uninitialized variable: `x` - let x: int; + let x: isize; x %= 1; //~ ERROR use of possibly uninitialized variable: `x` - let x: int; + let x: isize; x ^= 1; //~ ERROR use of possibly uninitialized variable: `x` - let x: int; + let x: isize; x &= 1; //~ ERROR use of possibly uninitialized variable: `x` - let x: int; + let x: isize; x |= 1; //~ ERROR use of possibly uninitialized variable: `x` - let x: int; + let x: isize; x <<= 1; //~ ERROR use of possibly uninitialized variable: `x` - let x: int; + let x: isize; x >>= 1; //~ ERROR use of possibly uninitialized variable: `x` } diff --git a/src/test/compile-fail/borrowck-uninit.rs b/src/test/compile-fail/borrowck-uninit.rs index a64216df6c7..f4b73bc889f 100644 --- a/src/test/compile-fail/borrowck-uninit.rs +++ b/src/test/compile-fail/borrowck-uninit.rs @@ -8,9 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -fn foo(x: int) { println!("{}", x); } +fn foo(x: isize) { println!("{}", x); } fn main() { - let x: int; + let x: isize; foo(x); //~ ERROR use of possibly uninitialized variable: `x` } diff --git a/src/test/compile-fail/borrowck-uniq-via-lend.rs b/src/test/compile-fail/borrowck-uniq-via-lend.rs index b0e8b2a523b..7fadf6d4660 100644 --- a/src/test/compile-fail/borrowck-uniq-via-lend.rs +++ b/src/test/compile-fail/borrowck-uniq-via-lend.rs @@ -10,15 +10,15 @@ #![feature(box_syntax)] -fn borrow(_v: &int) {} +fn borrow(_v: &isize) {} fn local() { - let mut v = box 3i; + let mut v = box 3is; borrow(&*v); } fn local_rec() { - struct F { f: Box<int> } + struct F { f: Box<isize> } let mut v = F {f: box 3}; borrow(&*v.f); } @@ -26,33 +26,33 @@ fn local_rec() { fn local_recs() { struct F { f: G } struct G { g: H } - struct H { h: Box<int> } + struct H { h: Box<isize> } let mut v = F {f: G {g: H {h: box 3}}}; borrow(&*v.f.g.h); } fn aliased_imm() { - let mut v = box 3i; + let mut v = box 3is; let _w = &v; borrow(&*v); } fn aliased_mut() { - let mut v = box 3i; + let mut v = box 3is; let _w = &mut v; borrow(&*v); //~ ERROR cannot borrow `*v` } fn aliased_other() { - let mut v = box 3i; - let mut w = box 4i; + let mut v = box 3is; + let mut w = box 4is; let _x = &mut w; borrow(&*v); } fn aliased_other_reassign() { - let mut v = box 3i; - let mut w = box 4i; + let mut v = box 3is; + let mut w = box 4is; let mut _x = &mut w; _x = &mut v; borrow(&*v); //~ ERROR cannot borrow `*v` diff --git a/src/test/compile-fail/borrowck-use-in-index-lvalue.rs b/src/test/compile-fail/borrowck-use-in-index-lvalue.rs index 3cd582ca0b8..94c1d3a6a45 100644 --- a/src/test/compile-fail/borrowck-use-in-index-lvalue.rs +++ b/src/test/compile-fail/borrowck-use-in-index-lvalue.rs @@ -9,10 +9,10 @@ // except according to those terms. fn test() { - let w: &mut [int]; + let w: &mut [isize]; w[5] = 0; //~ ERROR use of possibly uninitialized variable: `w` - let mut w: &mut [int]; + let mut w: &mut [isize]; w[5] = 0; //~ ERROR use of possibly uninitialized variable: `w` } diff --git a/src/test/compile-fail/borrowck-use-mut-borrow.rs b/src/test/compile-fail/borrowck-use-mut-borrow.rs index 45813c45f03..42e12622b69 100644 --- a/src/test/compile-fail/borrowck-use-mut-borrow.rs +++ b/src/test/compile-fail/borrowck-use-mut-borrow.rs @@ -10,14 +10,14 @@ #![feature(box_syntax)] -struct A { a: int, b: int } +struct A { a: isize, b: isize } impl Copy for A {} -struct B { a: int, b: Box<int> } +struct B { a: isize, b: Box<isize> } fn var_copy_after_var_borrow() { - let mut x: int = 1; + let mut x: isize = 1; let p = &mut x; drop(x); //~ ERROR cannot use `x` because it was mutably borrowed *p = 2; @@ -61,7 +61,7 @@ fn fu_field_copy_after_field_borrow() { } fn var_deref_after_var_borrow() { - let mut x: Box<int> = box 1; + let mut x: Box<isize> = box 1; let p = &mut x; drop(*x); //~ ERROR cannot use `*x` because it was mutably borrowed **p = 2; diff --git a/src/test/compile-fail/borrowck-vec-pattern-element-loan.rs b/src/test/compile-fail/borrowck-vec-pattern-element-loan.rs index 4a5418a4f20..577334cce95 100644 --- a/src/test/compile-fail/borrowck-vec-pattern-element-loan.rs +++ b/src/test/compile-fail/borrowck-vec-pattern-element-loan.rs @@ -10,9 +10,9 @@ #![feature(advanced_slice_patterns)] -fn a<'a>() -> &'a [int] { +fn a<'a>() -> &'a [isize] { let vec = vec!(1, 2, 3, 4); - let vec: &[int] = vec.as_slice(); //~ ERROR does not live long enough + let vec: &[isize] = vec.as_slice(); //~ ERROR does not live long enough let tail = match vec { [_, tail..] => tail, _ => panic!("a") @@ -20,9 +20,9 @@ fn a<'a>() -> &'a [int] { tail } -fn b<'a>() -> &'a [int] { +fn b<'a>() -> &'a [isize] { let vec = vec!(1, 2, 3, 4); - let vec: &[int] = vec.as_slice(); //~ ERROR does not live long enough + let vec: &[isize] = vec.as_slice(); //~ ERROR does not live long enough let init = match vec { [init.., _] => init, _ => panic!("b") @@ -30,9 +30,9 @@ fn b<'a>() -> &'a [int] { init } -fn c<'a>() -> &'a [int] { +fn c<'a>() -> &'a [isize] { let vec = vec!(1, 2, 3, 4); - let vec: &[int] = vec.as_slice(); //~ ERROR does not live long enough + let vec: &[isize] = vec.as_slice(); //~ ERROR does not live long enough let slice = match vec { [_, slice.., _] => slice, _ => panic!("c") diff --git a/src/test/compile-fail/borrowck-vec-pattern-loan-from-mut.rs b/src/test/compile-fail/borrowck-vec-pattern-loan-from-mut.rs index cc1dbc81955..565b8ca2f68 100644 --- a/src/test/compile-fail/borrowck-vec-pattern-loan-from-mut.rs +++ b/src/test/compile-fail/borrowck-vec-pattern-loan-from-mut.rs @@ -10,7 +10,7 @@ fn a() { let mut v = vec!(1, 2, 3); - let vb: &mut [int] = v.as_mut_slice(); + let vb: &mut [isize] = v.as_mut_slice(); match vb { [_a, tail..] => { v.push(tail[0] + tail[1]); //~ ERROR cannot borrow diff --git a/src/test/compile-fail/borrowck-vec-pattern-move-tail.rs b/src/test/compile-fail/borrowck-vec-pattern-move-tail.rs index cb8762f44fb..8869e99efd5 100644 --- a/src/test/compile-fail/borrowck-vec-pattern-move-tail.rs +++ b/src/test/compile-fail/borrowck-vec-pattern-move-tail.rs @@ -9,7 +9,7 @@ // except according to those terms. fn main() { - let mut a = [1i, 2, 3, 4]; + let mut a = [1is, 2, 3, 4]; let t = match a { [1, 2, tail..] => tail, _ => unreachable!() diff --git a/src/test/compile-fail/borrowck-vec-pattern-nesting.rs b/src/test/compile-fail/borrowck-vec-pattern-nesting.rs index c0abc3a2560..49994ebdbba 100644 --- a/src/test/compile-fail/borrowck-vec-pattern-nesting.rs +++ b/src/test/compile-fail/borrowck-vec-pattern-nesting.rs @@ -12,7 +12,7 @@ #![feature(box_syntax)] fn a() { - let mut vec = [box 1i, box 2, box 3]; + let mut vec = [box 1is, box 2, box 3]; match vec { [box ref _a, _, _] => { vec[0] = box 4; //~ ERROR cannot assign @@ -21,8 +21,8 @@ fn a() { } fn b() { - let mut vec = vec!(box 1i, box 2, box 3); - let vec: &mut [Box<int>] = vec.as_mut_slice(); + let mut vec = vec!(box 1is, box 2, box 3); + let vec: &mut [Box<isize>] = vec.as_mut_slice(); match vec { [_b..] => { vec[0] = box 4; //~ ERROR cannot assign @@ -31,8 +31,8 @@ fn b() { } fn c() { - let mut vec = vec!(box 1i, box 2, box 3); - let vec: &mut [Box<int>] = vec.as_mut_slice(); + let mut vec = vec!(box 1is, box 2, box 3); + let vec: &mut [Box<isize>] = vec.as_mut_slice(); match vec { [_a, //~ ERROR cannot move out _b..] => { //~^ NOTE attempting to move value to here @@ -49,8 +49,8 @@ fn c() { } fn d() { - let mut vec = vec!(box 1i, box 2, box 3); - let vec: &mut [Box<int>] = vec.as_mut_slice(); + let mut vec = vec!(box 1is, box 2, box 3); + let vec: &mut [Box<isize>] = vec.as_mut_slice(); match vec { [_a.., //~ ERROR cannot move out _b] => {} //~ NOTE attempting to move value to here @@ -60,8 +60,8 @@ fn d() { } fn e() { - let mut vec = vec!(box 1i, box 2, box 3); - let vec: &mut [Box<int>] = vec.as_mut_slice(); + let mut vec = vec!(box 1is, box 2, box 3); + let vec: &mut [Box<isize>] = vec.as_mut_slice(); match vec { [_a, _b, _c] => {} //~ ERROR cannot move out //~^ NOTE attempting to move value to here diff --git a/src/test/compile-fail/borrowck-vec-pattern-tail-element-loan.rs b/src/test/compile-fail/borrowck-vec-pattern-tail-element-loan.rs index 852eb172c59..bcd1aa81d4c 100644 --- a/src/test/compile-fail/borrowck-vec-pattern-tail-element-loan.rs +++ b/src/test/compile-fail/borrowck-vec-pattern-tail-element-loan.rs @@ -8,9 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -fn a<'a>() -> &'a int { +fn a<'a>() -> &'a isize { let vec = vec!(1, 2, 3, 4); - let vec: &[int] = vec.as_slice(); //~ ERROR `vec` does not live long enough + let vec: &[isize] = vec.as_slice(); //~ ERROR `vec` does not live long enough let tail = match vec { [_a, tail..] => &tail[0], _ => panic!("foo") diff --git a/src/test/compile-fail/borrowck-while-break.rs b/src/test/compile-fail/borrowck-while-break.rs index 15a70b2444d..4752120d691 100644 --- a/src/test/compile-fail/borrowck-while-break.rs +++ b/src/test/compile-fail/borrowck-while-break.rs @@ -11,7 +11,7 @@ fn test(cond: bool) { let v; while cond { - v = 3i; + v = 3is; break; } println!("{}", v); //~ ERROR use of possibly uninitialized variable: `v` diff --git a/src/test/compile-fail/borrowck-while.rs b/src/test/compile-fail/borrowck-while.rs index b5703e56642..f163cf602bf 100644 --- a/src/test/compile-fail/borrowck-while.rs +++ b/src/test/compile-fail/borrowck-while.rs @@ -8,9 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -fn f() -> int { - let mut x: int; - while 1i == 1 { x = 10; } +fn f() -> isize { + let mut x: isize; + while 1is == 1 { x = 10; } return x; //~ ERROR use of possibly uninitialized variable: `x` } diff --git a/src/test/compile-fail/builtin-superkinds-self-type.rs b/src/test/compile-fail/builtin-superkinds-self-type.rs index 9826a5a0126..0ec4f3dce11 100644 --- a/src/test/compile-fail/builtin-superkinds-self-type.rs +++ b/src/test/compile-fail/builtin-superkinds-self-type.rs @@ -22,6 +22,6 @@ impl <T: Sync> Foo for T { } fn main() { let (tx, rx) = channel(); - 1193182i.foo(tx); - assert!(rx.recv() == 1193182i); + 1193182is.foo(tx); + assert!(rx.recv() == 1193182is); } diff --git a/src/test/compile-fail/cannot-mutate-captured-non-mut-var.rs b/src/test/compile-fail/cannot-mutate-captured-non-mut-var.rs index 143e78e5d9f..9148f13c4dd 100644 --- a/src/test/compile-fail/cannot-mutate-captured-non-mut-var.rs +++ b/src/test/compile-fail/cannot-mutate-captured-non-mut-var.rs @@ -9,7 +9,7 @@ // except according to those terms. fn main() { - let x = 1i; + let x = 1is; move|:| { x = 2; }; //~^ ERROR: cannot assign to immutable captured outer variable diff --git a/src/test/compile-fail/capture1.rs b/src/test/compile-fail/capture1.rs index 7d590ca49dd..fd50918a313 100644 --- a/src/test/compile-fail/capture1.rs +++ b/src/test/compile-fail/capture1.rs @@ -12,6 +12,6 @@ // error-pattern: can't capture dynamic environment in a fn item; fn main() { - let bar: int = 5; - fn foo() -> int { return bar; } + let bar: isize = 5; + fn foo() -> isize { return bar; } } diff --git a/src/test/compile-fail/cast-to-bare-fn.rs b/src/test/compile-fail/cast-to-bare-fn.rs index 1db813292b0..a7f0917ed86 100644 --- a/src/test/compile-fail/cast-to-bare-fn.rs +++ b/src/test/compile-fail/cast-to-bare-fn.rs @@ -8,13 +8,13 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -fn foo(_x: int) { } +fn foo(_x: isize) { } fn main() { let v: u64 = 5; - let x = foo as extern "C" fn() -> int; + let x = foo as extern "C" fn() -> isize; //~^ ERROR mismatched types - let y = v as extern "Rust" fn(int) -> (int, int); + let y = v as extern "Rust" fn(isize) -> (isize, isize); //~^ ERROR non-scalar cast y(x()); } diff --git a/src/test/compile-fail/check-static-immutable-mut-slices.rs b/src/test/compile-fail/check-static-immutable-mut-slices.rs index 2945a050247..d1e3fe25253 100644 --- a/src/test/compile-fail/check-static-immutable-mut-slices.rs +++ b/src/test/compile-fail/check-static-immutable-mut-slices.rs @@ -10,7 +10,7 @@ // Checks that immutable static items can't have mutable slices -static TEST: &'static mut [int] = &mut []; +static TEST: &'static mut [isize] = &mut []; //~^ ERROR statics are not allowed to have mutable references pub fn main() { } diff --git a/src/test/compile-fail/check-static-values-constraints.rs b/src/test/compile-fail/check-static-values-constraints.rs index c13faacfee4..7c4f9ada2d3 100644 --- a/src/test/compile-fail/check-static-values-constraints.rs +++ b/src/test/compile-fail/check-static-values-constraints.rs @@ -26,7 +26,7 @@ impl Drop for WithDtor { // 3. Expr calls with unsafe arguments for statics are rejected enum SafeEnum { Variant1, - Variant2(int), + Variant2(isize), Variant3(WithDtor), Variant4(String) } @@ -45,7 +45,7 @@ static STATIC3: SafeEnum = SafeEnum::Variant3(WithDtor); // a destructor. enum UnsafeEnum { Variant5, - Variant6(int) + Variant6(isize) } impl Drop for UnsafeEnum { @@ -132,11 +132,11 @@ static STATIC16: (&'static Box<MyOwned>, &'static Box<MyOwned>) = ( static mut STATIC17: SafeEnum = SafeEnum::Variant1; //~^ ERROR mutable statics are not allowed to have destructors -static STATIC19: Box<int> = +static STATIC19: Box<isize> = box 3; //~^ ERROR statics are not allowed to have custom pointers pub fn main() { - let y = { static x: Box<int> = box 3; x }; + let y = { static x: Box<isize> = box 3; x }; //~^ ERROR statics are not allowed to have custom pointers } diff --git a/src/test/compile-fail/class-cast-to-trait.rs b/src/test/compile-fail/class-cast-to-trait.rs index 25abd904d21..31e09e877c7 100644 --- a/src/test/compile-fail/class-cast-to-trait.rs +++ b/src/test/compile-fail/class-cast-to-trait.rs @@ -15,9 +15,9 @@ trait noisy { } struct cat { - meows : uint, + meows : usize, - how_hungry : int, + how_hungry : isize, name : String, } @@ -50,7 +50,7 @@ impl cat { } } -fn cat(in_x : uint, in_y : int, in_name: String) -> cat { +fn cat(in_x : usize, in_y : isize, in_name: String) -> cat { cat { meows: in_x, how_hungry: in_y, diff --git a/src/test/compile-fail/class-implements-bad-trait.rs b/src/test/compile-fail/class-implements-bad-trait.rs index 9e7366a643d..d709ffdc3fc 100644 --- a/src/test/compile-fail/class-implements-bad-trait.rs +++ b/src/test/compile-fail/class-implements-bad-trait.rs @@ -10,10 +10,10 @@ // error-pattern:nonexistent class cat : nonexistent { - let meows: uint; - new(in_x : uint) { self.meows = in_x; } + let meows: usize; + new(in_x : usize) { self.meows = in_x; } } fn main() { - let nyan = cat(0u); + let nyan = cat(0us); } diff --git a/src/test/compile-fail/class-method-missing.rs b/src/test/compile-fail/class-method-missing.rs index 17cf36b73f6..3b921e07279 100644 --- a/src/test/compile-fail/class-method-missing.rs +++ b/src/test/compile-fail/class-method-missing.rs @@ -13,19 +13,19 @@ trait animal { } struct cat { - meows: uint, + meows: usize, } impl animal for cat { //~^ ERROR not all trait items implemented, missing: `eat` } -fn cat(in_x : uint) -> cat { +fn cat(in_x : usize) -> cat { cat { meows: in_x } } fn main() { - let nyan = cat(0u); + let nyan = cat(0us); } diff --git a/src/test/compile-fail/class-missing-self.rs b/src/test/compile-fail/class-missing-self.rs index 0e75e702277..4d8e4bca784 100644 --- a/src/test/compile-fail/class-missing-self.rs +++ b/src/test/compile-fail/class-missing-self.rs @@ -9,14 +9,14 @@ // except according to those terms. struct cat { - meows : uint, + meows : usize, } impl cat { fn sleep(&self) { loop{} } fn meow(&self) { println!("Meow"); - meows += 1u; //~ ERROR unresolved name + meows += 1us; //~ ERROR unresolved name sleep(); //~ ERROR unresolved name } diff --git a/src/test/compile-fail/coherence-all-remote.rs b/src/test/compile-fail/coherence-all-remote.rs index d86256a7776..f8ddf83c9c6 100644 --- a/src/test/compile-fail/coherence-all-remote.rs +++ b/src/test/compile-fail/coherence-all-remote.rs @@ -13,7 +13,7 @@ extern crate "coherence-lib" as lib; use lib::Remote1; -impl<T> Remote1<T> for int { } +impl<T> Remote1<T> for isize { } //~^ ERROR E0117 fn main() { } diff --git a/src/test/compile-fail/coherence-bigint-int.rs b/src/test/compile-fail/coherence-bigint-int.rs index b4917d0c29f..684773098cd 100644 --- a/src/test/compile-fail/coherence-bigint-int.rs +++ b/src/test/compile-fail/coherence-bigint-int.rs @@ -15,6 +15,6 @@ use lib::Remote1; pub struct BigInt; -impl Remote1<BigInt> for int { } //~ ERROR E0117 +impl Remote1<BigInt> for isize { } //~ ERROR E0117 fn main() { } diff --git a/src/test/compile-fail/coherence-bigint-vecint.rs b/src/test/compile-fail/coherence-bigint-vecint.rs index de4e656110f..28747674b8b 100644 --- a/src/test/compile-fail/coherence-bigint-vecint.rs +++ b/src/test/compile-fail/coherence-bigint-vecint.rs @@ -15,6 +15,6 @@ use lib::Remote1; pub struct BigInt; -impl Remote1<BigInt> for Vec<int> { } //~ ERROR E0117 +impl Remote1<BigInt> for Vec<isize> { } //~ ERROR E0117 fn main() { } diff --git a/src/test/compile-fail/coherence-blanket-conflicts-with-blanket-implemented.rs b/src/test/compile-fail/coherence-blanket-conflicts-with-blanket-implemented.rs index c0d82d35e30..27d97d18c94 100644 --- a/src/test/compile-fail/coherence-blanket-conflicts-with-blanket-implemented.rs +++ b/src/test/compile-fail/coherence-blanket-conflicts-with-blanket-implemented.rs @@ -16,23 +16,23 @@ use std::default::Default; // for the same type (though this crate doesn't). trait MyTrait { - fn get(&self) -> uint; + fn get(&self) -> usize; } trait Even { } trait Odd { } -impl Even for int { } +impl Even for isize { } -impl Odd for uint { } +impl Odd for usize { } impl<T:Even> MyTrait for T { //~ ERROR E0119 - fn get(&self) -> uint { 0 } + fn get(&self) -> usize { 0 } } impl<T:Odd> MyTrait for T { - fn get(&self) -> uint { 0 } + fn get(&self) -> usize { 0 } } fn main() { } diff --git a/src/test/compile-fail/coherence-blanket-conflicts-with-blanket-unimplemented.rs b/src/test/compile-fail/coherence-blanket-conflicts-with-blanket-unimplemented.rs index c44844bcf0b..0f233b78c72 100644 --- a/src/test/compile-fail/coherence-blanket-conflicts-with-blanket-unimplemented.rs +++ b/src/test/compile-fail/coherence-blanket-conflicts-with-blanket-unimplemented.rs @@ -16,7 +16,7 @@ use std::default::Default; // for the same type (though this crate doesn't implement them at all). trait MyTrait { - fn get(&self) -> uint; + fn get(&self) -> usize; } trait Even { } @@ -24,11 +24,11 @@ trait Even { } trait Odd { } impl<T:Even> MyTrait for T { //~ ERROR E0119 - fn get(&self) -> uint { 0 } + fn get(&self) -> usize { 0 } } impl<T:Odd> MyTrait for T { - fn get(&self) -> uint { 0 } + fn get(&self) -> usize { 0 } } fn main() { } diff --git a/src/test/compile-fail/coherence-blanket-conflicts-with-specific-cross-crate.rs b/src/test/compile-fail/coherence-blanket-conflicts-with-specific-cross-crate.rs index 2e163bc11a8..1f6bb08871c 100644 --- a/src/test/compile-fail/coherence-blanket-conflicts-with-specific-cross-crate.rs +++ b/src/test/compile-fail/coherence-blanket-conflicts-with-specific-cross-crate.rs @@ -19,11 +19,11 @@ use std::default::Default; struct MyThingy; impl Go for MyThingy { - fn go(&self, arg: int) { } + fn go(&self, arg: isize) { } } impl GoMut for MyThingy { //~ ERROR conflicting implementations - fn go_mut(&mut self, arg: int) { } + fn go_mut(&mut self, arg: isize) { } } fn main() { } diff --git a/src/test/compile-fail/coherence-blanket-conflicts-with-specific-multidispatch.rs b/src/test/compile-fail/coherence-blanket-conflicts-with-specific-multidispatch.rs index f3efca369b3..c3563792ce3 100644 --- a/src/test/compile-fail/coherence-blanket-conflicts-with-specific-multidispatch.rs +++ b/src/test/compile-fail/coherence-blanket-conflicts-with-specific-multidispatch.rs @@ -26,11 +26,11 @@ impl<T> MyTrait<T> for T { //~ ERROR E0119 #[derive(Clone)] struct MyType { - dummy: uint + dummy: usize } impl MyTrait<MyType> for MyType { - fn get(&self) -> uint { (*self).clone() } + fn get(&self) -> usize { (*self).clone() } } fn main() { } diff --git a/src/test/compile-fail/coherence-blanket-conflicts-with-specific-trait.rs b/src/test/compile-fail/coherence-blanket-conflicts-with-specific-trait.rs index 9db322a5517..eeaa68677eb 100644 --- a/src/test/compile-fail/coherence-blanket-conflicts-with-specific-trait.rs +++ b/src/test/compile-fail/coherence-blanket-conflicts-with-specific-trait.rs @@ -16,19 +16,19 @@ trait OtherTrait { } trait MyTrait { - fn get(&self) -> uint; + fn get(&self) -> usize; } impl<T:OtherTrait> MyTrait for T { //~ ERROR E0119 - fn get(&self) -> uint { 0 } + fn get(&self) -> usize { 0 } } struct MyType { - dummy: uint + dummy: usize } impl MyTrait for MyType { - fn get(&self) -> uint { self.dummy } + fn get(&self) -> usize { self.dummy } } impl OtherTrait for MyType { diff --git a/src/test/compile-fail/coherence-blanket-conflicts-with-specific.rs b/src/test/compile-fail/coherence-blanket-conflicts-with-specific.rs index 936025385bb..980e4256d2b 100644 --- a/src/test/compile-fail/coherence-blanket-conflicts-with-specific.rs +++ b/src/test/compile-fail/coherence-blanket-conflicts-with-specific.rs @@ -15,19 +15,19 @@ use std::default::Default; // specific T. trait MyTrait { - fn get(&self) -> uint; + fn get(&self) -> usize; } impl<T> MyTrait for T { //~ ERROR E0119 - fn get(&self) -> uint { 0 } + fn get(&self) -> usize { 0 } } struct MyType { - dummy: uint + dummy: usize } impl MyTrait for MyType { - fn get(&self) -> uint { self.dummy } + fn get(&self) -> usize { self.dummy } } fn main() { } diff --git a/src/test/compile-fail/coherence-orphan.rs b/src/test/compile-fail/coherence-orphan.rs index 30a382c143d..0bd0224b246 100644 --- a/src/test/compile-fail/coherence-orphan.rs +++ b/src/test/compile-fail/coherence-orphan.rs @@ -16,10 +16,10 @@ use lib::TheTrait; struct TheType; -impl TheTrait<uint> for int { } //~ ERROR E0117 +impl TheTrait<usize> for isize { } //~ ERROR E0117 -impl TheTrait<TheType> for int { } //~ ERROR E0117 +impl TheTrait<TheType> for isize { } //~ ERROR E0117 -impl TheTrait<int> for TheType { } +impl TheTrait<isize> for TheType { } fn main() { } diff --git a/src/test/compile-fail/coherence-tuple-conflict.rs b/src/test/compile-fail/coherence-tuple-conflict.rs index 92fa725cb1e..9673fb6a213 100644 --- a/src/test/compile-fail/coherence-tuple-conflict.rs +++ b/src/test/compile-fail/coherence-tuple-conflict.rs @@ -15,15 +15,15 @@ use std::default::Default; // specific T. trait MyTrait { - fn get(&self) -> uint; + fn get(&self) -> usize; } impl<T> MyTrait for (T,T) { //~ ERROR E0119 - fn get(&self) -> uint { 0 } + fn get(&self) -> usize { 0 } } impl<A,B> MyTrait for (A,B) { - fn get(&self) -> uint { self.dummy } + fn get(&self) -> usize { self.dummy } } fn main() { } diff --git a/src/test/compile-fail/comm-not-freeze-receiver.rs b/src/test/compile-fail/comm-not-freeze-receiver.rs index a7962c09fb3..305acfec401 100644 --- a/src/test/compile-fail/comm-not-freeze-receiver.rs +++ b/src/test/compile-fail/comm-not-freeze-receiver.rs @@ -13,5 +13,5 @@ use std::sync::mpsc::Receiver; fn test<T: Sync>() {} fn main() { - test::<Receiver<int>>(); //~ ERROR: `core::marker::Sync` is not implemented + test::<Receiver<isize>>(); //~ ERROR: `core::marker::Sync` is not implemented } diff --git a/src/test/compile-fail/comm-not-freeze.rs b/src/test/compile-fail/comm-not-freeze.rs index 1977438d423..de2c96920c3 100644 --- a/src/test/compile-fail/comm-not-freeze.rs +++ b/src/test/compile-fail/comm-not-freeze.rs @@ -13,5 +13,5 @@ use std::sync::mpsc::Sender; fn test<T: Sync>() {} fn main() { - test::<Sender<int>>(); //~ ERROR: `core::marker::Sync` is not implemented + test::<Sender<isize>>(); //~ ERROR: `core::marker::Sync` is not implemented } diff --git a/src/test/compile-fail/const-block-non-item-statement.rs b/src/test/compile-fail/const-block-non-item-statement.rs index 1814b1cd544..62e8fccbda0 100644 --- a/src/test/compile-fail/const-block-non-item-statement.rs +++ b/src/test/compile-fail/const-block-non-item-statement.rs @@ -8,18 +8,18 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -static A: uint = { 1u; 2 }; +static A: usize = { 1us; 2 }; //~^ ERROR: blocks in constants are limited to items and tail expressions -static B: uint = { { } 2 }; +static B: usize = { { } 2 }; //~^ ERROR: blocks in constants are limited to items and tail expressions macro_rules! foo { () => (()) //~ ERROR: blocks in constants are limited to items and tail expressions } -static C: uint = { foo!(); 2 }; +static C: usize = { foo!(); 2 }; -static D: uint = { let x = 4u; 2 }; +static D: usize = { let x = 4us; 2 }; //~^ ERROR: blocks in constants are limited to items and tail expressions pub fn main() { diff --git a/src/test/compile-fail/const-recursive.rs b/src/test/compile-fail/const-recursive.rs index 9c633e082b1..ad05c7c423f 100644 --- a/src/test/compile-fail/const-recursive.rs +++ b/src/test/compile-fail/const-recursive.rs @@ -9,8 +9,8 @@ // except according to those terms. // error-pattern: recursive constant -static a: int = b; -static b: int = a; +static a: isize = b; +static b: isize = a; fn main() { } diff --git a/src/test/compile-fail/copy-a-resource.rs b/src/test/compile-fail/copy-a-resource.rs index 01c6970506c..1201db437b9 100644 --- a/src/test/compile-fail/copy-a-resource.rs +++ b/src/test/compile-fail/copy-a-resource.rs @@ -10,14 +10,14 @@ #[derive(Show)] struct foo { - i: int, + i: isize, } impl Drop for foo { fn drop(&mut self) {} } -fn foo(i:int) -> foo { +fn foo(i:isize) -> foo { foo { i: i } diff --git a/src/test/compile-fail/deriving-non-type.rs b/src/test/compile-fail/deriving-non-type.rs index 717ce6e11ef..6015652668e 100644 --- a/src/test/compile-fail/deriving-non-type.rs +++ b/src/test/compile-fail/deriving-non-type.rs @@ -22,10 +22,10 @@ impl S { } impl T for S { } #[derive(PartialEq)] //~ ERROR: `derive` may only be applied to structs and enums -static s: uint = 0u; +static s: usize = 0us; #[derive(PartialEq)] //~ ERROR: `derive` may only be applied to structs and enums -const c: uint = 0u; +const c: usize = 0us; #[derive(PartialEq)] //~ ERROR: `derive` may only be applied to structs and enums mod m { } @@ -34,7 +34,7 @@ mod m { } extern "C" { } #[derive(PartialEq)] //~ ERROR: `derive` may only be applied to structs and enums -type A = uint; +type A = usize; #[derive(PartialEq)] //~ ERROR: `derive` may only be applied to structs and enums fn main() { } diff --git a/src/test/compile-fail/deriving-primitive.rs b/src/test/compile-fail/deriving-primitive.rs index a3c6c8672c8..6e9b120aa69 100644 --- a/src/test/compile-fail/deriving-primitive.rs +++ b/src/test/compile-fail/deriving-primitive.rs @@ -9,25 +9,25 @@ // except according to those terms. use std::num::FromPrimitive; -use std::int; +use std::isize; #[derive(FromPrimitive)] -struct A { x: int } +struct A { x: isize } //~^^ ERROR `FromPrimitive` cannot be derived for structs //~^^^ ERROR `FromPrimitive` cannot be derived for structs #[derive(FromPrimitive)] -struct B(int); +struct B(isize); //~^^ ERROR `FromPrimitive` cannot be derived for structs //~^^^ ERROR `FromPrimitive` cannot be derived for structs #[derive(FromPrimitive)] -enum C { Foo(int), Bar(uint) } +enum C { Foo(isize), Bar(usize) } //~^^ ERROR `FromPrimitive` cannot be derived for enum variants with arguments //~^^^ ERROR `FromPrimitive` cannot be derived for enum variants with arguments #[derive(FromPrimitive)] -enum D { Baz { x: int } } +enum D { Baz { x: isize } } //~^^ ERROR `FromPrimitive` cannot be derived for enums with struct variants //~^^^ ERROR `FromPrimitive` cannot be derived for enums with struct variants diff --git a/src/test/compile-fail/destructure-trait-ref.rs b/src/test/compile-fail/destructure-trait-ref.rs index 0351040d329..5166ef8f72f 100644 --- a/src/test/compile-fail/destructure-trait-ref.rs +++ b/src/test/compile-fail/destructure-trait-ref.rs @@ -14,7 +14,7 @@ #![feature(box_syntax)] trait T {} -impl T for int {} +impl T for isize {} fn main() { // For an expression of the form: @@ -27,17 +27,17 @@ fn main() { // if n > m, it's a type mismatch error. // n < m - let &x = &(&1i as &T); - let &x = &&(&1i as &T); - let &&x = &&(&1i as &T); + let &x = &(&1is as &T); + let &x = &&(&1is as &T); + let &&x = &&(&1is as &T); // n == m - let &x = &1i as &T; //~ ERROR type `&T` cannot be dereferenced - let &&x = &(&1i as &T); //~ ERROR type `&T` cannot be dereferenced - let box x = box 1i as Box<T>; //~ ERROR type `Box<T>` cannot be dereferenced + let &x = &1is as &T; //~ ERROR type `&T` cannot be dereferenced + let &&x = &(&1is as &T); //~ ERROR type `&T` cannot be dereferenced + let box x = box 1is as Box<T>; //~ ERROR type `Box<T>` cannot be dereferenced // n > m - let &&x = &1i as &T; //~ ERROR found &-ptr - let &&&x = &(&1i as &T); //~ ERROR found &-ptr - let box box x = box 1i as Box<T>; //~ ERROR found box + let &&x = &1is as &T; //~ ERROR found &-ptr + let &&&x = &(&1is as &T); //~ ERROR found &-ptr + let box box x = box 1is as Box<T>; //~ ERROR found box } diff --git a/src/test/compile-fail/drop-on-non-struct.rs b/src/test/compile-fail/drop-on-non-struct.rs index 8d2ca0b0a6b..26b247d0d0f 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<'a> Drop for &'a mut int { +impl<'a> Drop for &'a mut isize { //~^ ERROR the Drop trait may only be implemented on structures //~^^ ERROR E0117 fn drop(&mut self) { diff --git a/src/test/compile-fail/dst-bad-assign-2.rs b/src/test/compile-fail/dst-bad-assign-2.rs index 6c40ca558de..7dbb8fc92e3 100644 --- a/src/test/compile-fail/dst-bad-assign-2.rs +++ b/src/test/compile-fail/dst-bad-assign-2.rs @@ -13,7 +13,7 @@ #![feature(box_syntax)] struct Fat<T: ?Sized> { - f1: int, + f1: isize, f2: &'static str, ptr: T } @@ -23,19 +23,19 @@ struct Bar; #[derive(PartialEq,Eq)] struct Bar1 { - f: int + f: isize } trait ToBar { fn to_bar(&self) -> Bar; - fn to_val(&self) -> int; + fn to_val(&self) -> isize; } impl ToBar for Bar1 { fn to_bar(&self) -> Bar { Bar } - fn to_val(&self) -> int { + fn to_val(&self) -> isize { self.f } } diff --git a/src/test/compile-fail/dst-bad-assign.rs b/src/test/compile-fail/dst-bad-assign.rs index 78f70b9add0..634b5999e9e 100644 --- a/src/test/compile-fail/dst-bad-assign.rs +++ b/src/test/compile-fail/dst-bad-assign.rs @@ -13,7 +13,7 @@ #![feature(box_syntax)] struct Fat<T: ?Sized> { - f1: int, + f1: isize, f2: &'static str, ptr: T } @@ -23,19 +23,19 @@ struct Bar; #[derive(PartialEq,Eq)] struct Bar1 { - f: int + f: isize } trait ToBar { fn to_bar(&self) -> Bar; - fn to_val(&self) -> int; + fn to_val(&self) -> isize; } impl ToBar for Bar1 { fn to_bar(&self) -> Bar { Bar } - fn to_val(&self) -> int { + fn to_val(&self) -> isize { self.f } } diff --git a/src/test/compile-fail/dst-bad-coerce2.rs b/src/test/compile-fail/dst-bad-coerce2.rs index 54c625221ba..160197368d6 100644 --- a/src/test/compile-fail/dst-bad-coerce2.rs +++ b/src/test/compile-fail/dst-bad-coerce2.rs @@ -21,8 +21,8 @@ impl Bar for Foo {} pub fn main() { // With a vec of ints. let f1 = Fat { ptr: [1, 2, 3] }; - let f2: &Fat<[int; 3]> = &f1; - let f3: &mut Fat<[int]> = f2; //~ ERROR mismatched types + let f2: &Fat<[isize; 3]> = &f1; + let f3: &mut Fat<[isize]> = f2; //~ ERROR mismatched types // With a trait. let f1 = Fat { ptr: Foo }; diff --git a/src/test/compile-fail/dst-bad-coerce3.rs b/src/test/compile-fail/dst-bad-coerce3.rs index 192d43e32fd..347a2d2ecbe 100644 --- a/src/test/compile-fail/dst-bad-coerce3.rs +++ b/src/test/compile-fail/dst-bad-coerce3.rs @@ -21,8 +21,8 @@ impl Bar for Foo {} fn baz<'a>() { // With a vec of ints. let f1 = Fat { ptr: [1, 2, 3] }; - let f2: &Fat<[int; 3]> = &f1; //~ ERROR `f1` does not live long enough - let f3: &'a Fat<[int]> = f2; + let f2: &Fat<[isize; 3]> = &f1; //~ ERROR `f1` does not live long enough + let f3: &'a Fat<[isize]> = f2; // With a trait. let f1 = Fat { ptr: Foo }; diff --git a/src/test/compile-fail/dst-bad-deep.rs b/src/test/compile-fail/dst-bad-deep.rs index 0276e2e418d..032835d9460 100644 --- a/src/test/compile-fail/dst-bad-deep.rs +++ b/src/test/compile-fail/dst-bad-deep.rs @@ -18,8 +18,8 @@ struct Fat<T: ?Sized> { } pub fn main() { - let f: Fat<[int; 3]> = Fat { ptr: [5i, 6, 7] }; - let g: &Fat<[int]> = &f; - let h: &Fat<Fat<[int]>> = &Fat { ptr: *g }; + let f: Fat<[isize; 3]> = Fat { ptr: [5is, 6, 7] }; + let g: &Fat<[isize]> = &f; + let h: &Fat<Fat<[isize]>> = &Fat { ptr: *g }; //~^ ERROR the trait `core::marker::Sized` is not implemented } diff --git a/src/test/compile-fail/dst-index.rs b/src/test/compile-fail/dst-index.rs index e297ecaac23..2a66b87fece 100644 --- a/src/test/compile-fail/dst-index.rs +++ b/src/test/compile-fail/dst-index.rs @@ -18,10 +18,10 @@ struct S; impl Copy for S {} -impl Index<uint> for S { +impl Index<usize> for S { type Output = str; - fn index<'a>(&'a self, _: &uint) -> &'a str { + fn index<'a>(&'a self, _: &usize) -> &'a str { "hello" } } @@ -30,20 +30,20 @@ struct T; impl Copy for T {} -impl Index<uint> for T { +impl Index<usize> for T { type Output = Show + 'static; - fn index<'a>(&'a self, idx: &uint) -> &'a (Show + 'static) { - static x: uint = 42; + fn index<'a>(&'a self, idx: &usize) -> &'a (Show + 'static) { + static x: usize = 42; &x } } fn main() { S[0]; - //~^ ERROR cannot move out of dereference + //~^ ERROR cannot move out of indexed content //~^^ ERROR E0161 T[0]; - //~^ ERROR cannot move out of dereference + //~^ ERROR cannot move out of indexed content //~^^ ERROR E0161 } diff --git a/src/test/compile-fail/dst-rvalue.rs b/src/test/compile-fail/dst-rvalue.rs index 74e952364cd..69bda8c1671 100644 --- a/src/test/compile-fail/dst-rvalue.rs +++ b/src/test/compile-fail/dst-rvalue.rs @@ -15,10 +15,10 @@ pub fn main() { let _x: Box<str> = box *"hello world"; //~^ ERROR E0161 - //~^^ ERROR cannot move out of dereference + //~^^ ERROR cannot move out of borrowed content - let array: &[int] = &[1, 2, 3]; - let _x: Box<[int]> = box *array; + let array: &[isize] = &[1, 2, 3]; + let _x: Box<[isize]> = box *array; //~^ ERROR E0161 - //~^^ ERROR cannot move out of dereference + //~^^ ERROR cannot move out of borrowed content } diff --git a/src/test/compile-fail/duplicate-parameter.rs b/src/test/compile-fail/duplicate-parameter.rs index c1c0f974de9..18ec55e10bb 100644 --- a/src/test/compile-fail/duplicate-parameter.rs +++ b/src/test/compile-fail/duplicate-parameter.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -fn f(a: int, a: int) {} +fn f(a: isize, a: isize) {} //~^ ERROR identifier `a` is bound more than once in this parameter list fn main() { diff --git a/src/test/compile-fail/enum-and-module-in-same-scope.rs b/src/test/compile-fail/enum-and-module-in-same-scope.rs index 7526c6753e6..f3d8fcf31d7 100644 --- a/src/test/compile-fail/enum-and-module-in-same-scope.rs +++ b/src/test/compile-fail/enum-and-module-in-same-scope.rs @@ -9,7 +9,7 @@ // except according to those terms. mod Foo { - pub static X: int = 42; + pub static X: isize = 42; } enum Foo { //~ ERROR duplicate definition of type or module `Foo` diff --git a/src/test/compile-fail/enum-discrim-too-small.rs b/src/test/compile-fail/enum-discrim-too-small.rs index 2de50ad1d1d..1d7794336a0 100644 --- a/src/test/compile-fail/enum-discrim-too-small.rs +++ b/src/test/compile-fail/enum-discrim-too-small.rs @@ -53,6 +53,6 @@ enum Ei32 { // u64 currently allows negative numbers, and i64 allows numbers greater than `1<<63`. This is a // little counterintuitive, but since the discriminant can store all the bits, and extracting it // with a cast requires specifying the signedness, there is no loss of information in those cases. -// This also applies to int and uint on 64-bit targets. +// This also applies to isize and usize on 64-bit targets. pub fn main() { } diff --git a/src/test/compile-fail/enum-in-scope.rs b/src/test/compile-fail/enum-in-scope.rs index cccf66ef2d5..7be06ec7de8 100644 --- a/src/test/compile-fail/enum-in-scope.rs +++ b/src/test/compile-fail/enum-in-scope.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -struct hello(int); +struct hello(isize); fn main() { let hello = 0; //~ERROR declaration of `hello` shadows diff --git a/src/test/compile-fail/explicit-call-to-dtor.rs b/src/test/compile-fail/explicit-call-to-dtor.rs index 6b334dd6ecd..90030488dd6 100644 --- a/src/test/compile-fail/explicit-call-to-dtor.rs +++ b/src/test/compile-fail/explicit-call-to-dtor.rs @@ -9,7 +9,7 @@ // except according to those terms. struct Foo { - x: int + x: isize } impl Drop for Foo { diff --git a/src/test/compile-fail/explicit-call-to-supertrait-dtor.rs b/src/test/compile-fail/explicit-call-to-supertrait-dtor.rs index d0dd0e68da6..63ed74dfa49 100644 --- a/src/test/compile-fail/explicit-call-to-supertrait-dtor.rs +++ b/src/test/compile-fail/explicit-call-to-supertrait-dtor.rs @@ -9,7 +9,7 @@ // except according to those terms. struct Foo { - x: int + x: isize } trait Bar : Drop { diff --git a/src/test/compile-fail/explicit-self-lifetime-mismatch.rs b/src/test/compile-fail/explicit-self-lifetime-mismatch.rs index 9b2264b8902..fbc5263d82d 100644 --- a/src/test/compile-fail/explicit-self-lifetime-mismatch.rs +++ b/src/test/compile-fail/explicit-self-lifetime-mismatch.rs @@ -9,8 +9,8 @@ // except according to those terms. struct Foo<'a,'b> { - x: &'a int, - y: &'b int, + x: &'a isize, + y: &'b isize, } impl<'a,'b> Foo<'a,'b> { diff --git a/src/test/compile-fail/export.rs b/src/test/compile-fail/export.rs index dec65d4b4f8..3a391e7c609 100644 --- a/src/test/compile-fail/export.rs +++ b/src/test/compile-fail/export.rs @@ -10,8 +10,8 @@ // error-pattern: unresolved name mod foo { - pub fn x(y: int) { log(debug, y); } - fn z(y: int) { log(debug, y); } + pub fn x(y: isize) { log(debug, y); } + fn z(y: isize) { log(debug, y); } } fn main() { foo::z(10); } diff --git a/src/test/compile-fail/extern-with-type-bounds.rs b/src/test/compile-fail/extern-with-type-bounds.rs index 8c7d00a9a11..d2c88865d54 100644 --- a/src/test/compile-fail/extern-with-type-bounds.rs +++ b/src/test/compile-fail/extern-with-type-bounds.rs @@ -22,10 +22,10 @@ extern "rust-intrinsic" { // Bounds aren't checked right now, so this should work // even though it's incorrect. - fn size_of<T: Clone>() -> uint; + fn size_of<T: Clone>() -> usize; // Unresolved bounds should still error. - fn align_of<T: NoSuchTrait>() -> uint; + fn align_of<T: NoSuchTrait>() -> usize; //~^ ERROR attempt to bound type parameter with a nonexistent trait `NoSuchTrait` } diff --git a/src/test/compile-fail/feature-gate-advanced-slice-features.rs b/src/test/compile-fail/feature-gate-advanced-slice-features.rs index 97d593d310e..a37a8a326a6 100644 --- a/src/test/compile-fail/feature-gate-advanced-slice-features.rs +++ b/src/test/compile-fail/feature-gate-advanced-slice-features.rs @@ -9,7 +9,7 @@ // except according to those terms. fn main() { - let x = [ 1i, 2, 3, 4, 5 ]; + let x = [ 1is, 2, 3, 4, 5 ]; match x { [ xs.., 4, 5 ] => {} //~ ERROR multiple-element slice matches [ 1, xs.., 5 ] => {} //~ ERROR multiple-element slice matches diff --git a/src/test/compile-fail/feature-gate-int-uint.rs b/src/test/compile-fail/feature-gate-int-uint.rs new file mode 100644 index 00000000000..016a0394289 --- /dev/null +++ b/src/test/compile-fail/feature-gate-int-uint.rs @@ -0,0 +1,35 @@ +// 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. + +#![allow(dead_code)] + +mod u { + type X = uint; //~ WARN the `uint` type is deprecated + struct Foo { + x: uint //~ WARN the `uint` type is deprecated + } + fn bar(x: uint) { //~ WARN the `uint` type is deprecated + 1u; //~ WARN the `u` suffix on integers is deprecated + } +} +mod i { + type X = int; //~ WARN the `int` type is deprecated + struct Foo { + x: int //~ WARN the `int` type is deprecated + } + fn bar(x: int) { //~ WARN the `int` type is deprecated + 1i; //~ WARN the `i` suffix on integers is deprecated + } +} + +fn main() { + // make compilation fail, after feature gating + let () = 1u8; //~ ERROR +} diff --git a/src/test/compile-fail/fn-bad-block-type.rs b/src/test/compile-fail/fn-bad-block-type.rs index ba568ef5f84..c5c355cfbce 100644 --- a/src/test/compile-fail/fn-bad-block-type.rs +++ b/src/test/compile-fail/fn-bad-block-type.rs @@ -10,6 +10,6 @@ // error-pattern:mismatched types -fn f() -> int { true } +fn f() -> isize { true } fn main() { } diff --git a/src/test/compile-fail/fn-item-type.rs b/src/test/compile-fail/fn-item-type.rs index dd4a24bfb2f..b2394a29899 100644 --- a/src/test/compile-fail/fn-item-type.rs +++ b/src/test/compile-fail/fn-item-type.rs @@ -11,8 +11,8 @@ // Test that the types of distinct fn items are not compatible by // default. See also `run-pass/fn-item-type-*.rs`. -fn foo(x: int) -> int { x * 2 } -fn bar(x: int) -> int { x * 4 } +fn foo(x: isize) -> isize { x * 2 } +fn bar(x: isize) -> isize { x * 4 } fn eq<T>(x: T, y: T) { } diff --git a/src/test/compile-fail/fn-trait-formatting.rs b/src/test/compile-fail/fn-trait-formatting.rs index 723192952f2..3f5a92605b7 100644 --- a/src/test/compile-fail/fn-trait-formatting.rs +++ b/src/test/compile-fail/fn-trait-formatting.rs @@ -21,5 +21,5 @@ fn main() { let _: () = (box |&mut:| -> isize unimplemented!()) as Box<FnMut() -> isize>; //~^ ERROR Box<core::ops::FnMut() -> isize> - needs_fn(1i); //~ ERROR `core::ops::Fn(isize) -> isize` + needs_fn(1is); //~ ERROR `core::ops::Fn(isize) -> isize` } diff --git a/src/test/compile-fail/fn-variance-1.rs b/src/test/compile-fail/fn-variance-1.rs index 039628b6752..838e65e1d05 100644 --- a/src/test/compile-fail/fn-variance-1.rs +++ b/src/test/compile-fail/fn-variance-1.rs @@ -8,9 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -fn takes_imm(x: &int) { } +fn takes_imm(x: &isize) { } -fn takes_mut(x: &mut int) { } +fn takes_mut(x: &mut isize) { } fn apply<T, F>(t: T, f: F) where F: FnOnce(T) { f(t) diff --git a/src/test/compile-fail/for-loop-bogosity.rs b/src/test/compile-fail/for-loop-bogosity.rs index 67d07ca4bd1..fd920f92394 100644 --- a/src/test/compile-fail/for-loop-bogosity.rs +++ b/src/test/compile-fail/for-loop-bogosity.rs @@ -9,12 +9,12 @@ // except according to those terms. struct MyStruct { - x: int, - y: int, + x: isize, + y: isize, } impl MyStruct { - fn next(&mut self) -> Option<int> { + fn next(&mut self) -> Option<isize> { Some(self.x) } } diff --git a/src/test/compile-fail/for-loop-refutable-pattern-error-message.rs b/src/test/compile-fail/for-loop-refutable-pattern-error-message.rs index 8de613ac03d..c381fcf3efb 100644 --- a/src/test/compile-fail/for-loop-refutable-pattern-error-message.rs +++ b/src/test/compile-fail/for-loop-refutable-pattern-error-message.rs @@ -11,6 +11,6 @@ fn main() { for - &1i //~ ERROR refutable pattern in `for` loop binding - in [1i].iter() {} + &1is //~ ERROR refutable pattern in `for` loop binding + in [1is].iter() {} } diff --git a/src/test/compile-fail/forget-init-unsafe.rs b/src/test/compile-fail/forget-init-unsafe.rs index 12df0c71cc5..46a18c98183 100644 --- a/src/test/compile-fail/forget-init-unsafe.rs +++ b/src/test/compile-fail/forget-init-unsafe.rs @@ -12,6 +12,6 @@ use std::intrinsics::{init, forget}; // Test that the `forget` and `init` intrinsics are really unsafe pub fn main() { - let stuff = init::<int>(); //~ ERROR call to unsafe function requires unsafe + let stuff = init::<isize>(); //~ ERROR call to unsafe function requires unsafe forget(stuff); //~ ERROR call to unsafe function requires unsafe } diff --git a/src/test/compile-fail/fully-qualified-type-name3.rs b/src/test/compile-fail/fully-qualified-type-name3.rs index 0a5a54b9a27..dc0c9a093ff 100644 --- a/src/test/compile-fail/fully-qualified-type-name3.rs +++ b/src/test/compile-fail/fully-qualified-type-name3.rs @@ -12,8 +12,8 @@ // ignore-test -type T1 = uint; -type T2 = int; +type T1 = usize; +type T2 = isize; fn bar(x: T1) -> T2 { return x; diff --git a/src/test/compile-fail/functional-struct-update-noncopyable.rs b/src/test/compile-fail/functional-struct-update-noncopyable.rs index da246f85c43..7ce32bbc975 100644 --- a/src/test/compile-fail/functional-struct-update-noncopyable.rs +++ b/src/test/compile-fail/functional-struct-update-noncopyable.rs @@ -12,7 +12,7 @@ use std::sync::Arc; -struct A { y: Arc<int>, x: Arc<int> } +struct A { y: Arc<isize>, x: Arc<isize> } impl Drop for A { fn drop(&mut self) { println!("x={}", *self.x); } diff --git a/src/test/compile-fail/gated-non-ascii-idents.rs b/src/test/compile-fail/gated-non-ascii-idents.rs index 4cbb61d9853..f4b9830d579 100644 --- a/src/test/compile-fail/gated-non-ascii-idents.rs +++ b/src/test/compile-fail/gated-non-ascii-idents.rs @@ -17,9 +17,9 @@ mod föö { //~ ERROR non-ascii idents } fn bär( //~ ERROR non-ascii idents - bäz: int //~ ERROR non-ascii idents + bäz: isize //~ ERROR non-ascii idents ) { - let _ö: int; //~ ERROR non-ascii idents + let _ö: isize; //~ ERROR non-ascii idents match (1, 2) { (_ä, _) => {} //~ ERROR non-ascii idents @@ -27,12 +27,12 @@ fn bär( //~ ERROR non-ascii idents } struct Föö { //~ ERROR non-ascii idents - föö: int //~ ERROR non-ascii idents + föö: isize //~ ERROR non-ascii idents } enum Bär { //~ ERROR non-ascii idents Bäz { //~ ERROR non-ascii idents - qüx: int //~ ERROR non-ascii idents + qüx: isize //~ ERROR non-ascii idents } } diff --git a/src/test/compile-fail/generic-impl-less-params-with-defaults.rs b/src/test/compile-fail/generic-impl-less-params-with-defaults.rs index a8b1911426c..02f09749d61 100644 --- a/src/test/compile-fail/generic-impl-less-params-with-defaults.rs +++ b/src/test/compile-fail/generic-impl-less-params-with-defaults.rs @@ -15,6 +15,6 @@ impl<A, B, C = (A, B)> Foo<A, B, C> { } fn main() { - Foo::<int>::new(); + Foo::<isize>::new(); //~^ ERROR too few type parameters provided } diff --git a/src/test/compile-fail/generic-impl-more-params-with-defaults.rs b/src/test/compile-fail/generic-impl-more-params-with-defaults.rs index 696235333a1..d88da2625c1 100644 --- a/src/test/compile-fail/generic-impl-more-params-with-defaults.rs +++ b/src/test/compile-fail/generic-impl-more-params-with-defaults.rs @@ -17,6 +17,6 @@ impl<T, A = Heap> Vec<T, A> { } fn main() { - Vec::<int, Heap, bool>::new(); + Vec::<isize, Heap, bool>::new(); //~^ ERROR too many type parameters provided } diff --git a/src/test/compile-fail/generic-type-more-params-with-defaults.rs b/src/test/compile-fail/generic-type-more-params-with-defaults.rs index ee3e1818779..19d303488ac 100644 --- a/src/test/compile-fail/generic-type-more-params-with-defaults.rs +++ b/src/test/compile-fail/generic-type-more-params-with-defaults.rs @@ -13,6 +13,6 @@ struct Heap; struct Vec<T, A = Heap>; fn main() { - let _: Vec<int, Heap, bool>; + let _: Vec<isize, Heap, bool>; //~^ ERROR wrong number of type arguments: expected at most 2, found 3 } diff --git a/src/test/compile-fail/glob-resolve1.rs b/src/test/compile-fail/glob-resolve1.rs index d8258a72ce3..fce8a07d727 100644 --- a/src/test/compile-fail/glob-resolve1.rs +++ b/src/test/compile-fail/glob-resolve1.rs @@ -23,7 +23,7 @@ mod bar { struct C; - type D = int; + type D = isize; } fn foo<T>() {} diff --git a/src/test/compile-fail/hashmap-iter-value-lifetime.rs b/src/test/compile-fail/hashmap-iter-value-lifetime.rs index d9d7705fef6..db1e1e8efe4 100644 --- a/src/test/compile-fail/hashmap-iter-value-lifetime.rs +++ b/src/test/compile-fail/hashmap-iter-value-lifetime.rs @@ -10,7 +10,7 @@ fn main() { let mut my_stuff = std::collections::HashMap::new(); - my_stuff.insert(0i, 42i); + my_stuff.insert(0is, 42is); let (_, thing) = my_stuff.iter().next().unwrap(); diff --git a/src/test/compile-fail/hashmap-lifetimes.rs b/src/test/compile-fail/hashmap-lifetimes.rs index edd57477d76..40673dd92b8 100644 --- a/src/test/compile-fail/hashmap-lifetimes.rs +++ b/src/test/compile-fail/hashmap-lifetimes.rs @@ -10,7 +10,7 @@ fn main() { let mut my_stuff = std::collections::HashMap::new(); - my_stuff.insert(0i, 42i); + my_stuff.insert(0is, 42is); let mut it = my_stuff.iter(); my_stuff.insert(1, 43); //~ ERROR cannot borrow diff --git a/src/test/compile-fail/hrtb-conflate-regions.rs b/src/test/compile-fail/hrtb-conflate-regions.rs index 5eb8fd69312..3efe0501267 100644 --- a/src/test/compile-fail/hrtb-conflate-regions.rs +++ b/src/test/compile-fail/hrtb-conflate-regions.rs @@ -16,12 +16,12 @@ trait Foo<X> { } fn want_foo2<T>() - where T : for<'a,'b> Foo<(&'a int, &'b int)> + where T : for<'a,'b> Foo<(&'a isize, &'b isize)> { } fn want_foo1<T>() - where T : for<'z> Foo<(&'z int, &'z int)> + where T : for<'z> Foo<(&'z isize, &'z isize)> { } @@ -30,7 +30,7 @@ fn want_foo1<T>() struct SomeStruct; -impl<'a> Foo<(&'a int, &'a int)> for SomeStruct +impl<'a> Foo<(&'a isize, &'a isize)> for SomeStruct { } diff --git a/src/test/compile-fail/hrtb-debruijn-in-receiver.rs b/src/test/compile-fail/hrtb-debruijn-in-receiver.rs index 2dbd16107b0..2365f494075 100644 --- a/src/test/compile-fail/hrtb-debruijn-in-receiver.rs +++ b/src/test/compile-fail/hrtb-debruijn-in-receiver.rs @@ -14,7 +14,7 @@ use std::collections::HashMap; struct Foo<'a> { - map: HashMap<uint, &'a str> + map: HashMap<usize, &'a str> } impl<'a> Foo<'a> { diff --git a/src/test/compile-fail/hrtb-higher-ranker-supertraits-transitive.rs b/src/test/compile-fail/hrtb-higher-ranker-supertraits-transitive.rs index 4199deee7b8..249256f8e01 100644 --- a/src/test/compile-fail/hrtb-higher-ranker-supertraits-transitive.rs +++ b/src/test/compile-fail/hrtb-higher-ranker-supertraits-transitive.rs @@ -12,13 +12,13 @@ trait Foo<'tcx> { - fn foo(&'tcx self) -> &'tcx int; + fn foo(&'tcx self) -> &'tcx isize; } trait Bar<'ccx> : for<'tcx> Foo<'tcx> { - fn bar(&'ccx self) -> &'ccx int; + fn bar(&'ccx self) -> &'ccx isize; } trait Baz diff --git a/src/test/compile-fail/hrtb-higher-ranker-supertraits.rs b/src/test/compile-fail/hrtb-higher-ranker-supertraits.rs index 108ca1b82e0..441ad76b602 100644 --- a/src/test/compile-fail/hrtb-higher-ranker-supertraits.rs +++ b/src/test/compile-fail/hrtb-higher-ranker-supertraits.rs @@ -12,13 +12,13 @@ trait Foo<'tcx> { - fn foo(&'tcx self) -> &'tcx int; + fn foo(&'tcx self) -> &'tcx isize; } trait Bar<'ccx> : for<'tcx> Foo<'tcx> { - fn bar(&'ccx self) -> &'ccx int; + fn bar(&'ccx self) -> &'ccx isize; } fn want_foo_for_some_tcx<'x,F>(f: &'x F) diff --git a/src/test/compile-fail/hrtb-identity-fn-borrows.rs b/src/test/compile-fail/hrtb-identity-fn-borrows.rs index 733a5b2a85a..17939cf9fe0 100644 --- a/src/test/compile-fail/hrtb-identity-fn-borrows.rs +++ b/src/test/compile-fail/hrtb-identity-fn-borrows.rs @@ -16,7 +16,7 @@ trait FnLike<A,R> { } fn call_repeatedly<F>(f: F) - where F : for<'a> FnLike<&'a int, &'a int> + where F : for<'a> FnLike<&'a isize, &'a isize> { // Result is stored: cannot re-assign `x` let mut x = 3; diff --git a/src/test/compile-fail/huge-array-simple.rs b/src/test/compile-fail/huge-array-simple.rs index a9dda771b7f..1e04e685e41 100644 --- a/src/test/compile-fail/huge-array-simple.rs +++ b/src/test/compile-fail/huge-array-simple.rs @@ -11,5 +11,5 @@ // error-pattern: too big for the current fn main() { - let fat : [u8; (1<<61)+(1<<31)] = [0; (1u64<<61) as uint +(1u64<<31) as uint]; + let fat : [u8; (1<<61)+(1<<31)] = [0; (1u64<<61) as usize +(1u64<<31) as usize]; } diff --git a/src/test/compile-fail/if-let.rs b/src/test/compile-fail/if-let.rs index 971f643c0fe..d83779c4f0f 100644 --- a/src/test/compile-fail/if-let.rs +++ b/src/test/compile-fail/if-let.rs @@ -20,20 +20,20 @@ fn macros() { }} } - foo!(a, 1i, { //~ ERROR irrefutable if-let + foo!(a, 1is, { //~ ERROR irrefutable if-let println!("irrefutable pattern"); }); - bar!(a, 1i, { //~ ERROR irrefutable if-let + bar!(a, 1is, { //~ ERROR irrefutable if-let println!("irrefutable pattern"); }); } pub fn main() { - if let a = 1i { //~ ERROR irrefutable if-let + if let a = 1is { //~ ERROR irrefutable if-let println!("irrefutable pattern"); } - if let a = 1i { //~ ERROR irrefutable if-let + if let a = 1is { //~ ERROR irrefutable if-let println!("irrefutable pattern"); } else if true { println!("else-if in irrefutable if-let"); @@ -41,15 +41,15 @@ pub fn main() { println!("else in irrefutable if-let"); } - if let 1i = 2i { + if let 1is = 2is { println!("refutable pattern"); - } else if let a = 1i { //~ ERROR irrefutable if-let + } else if let a = 1is { //~ ERROR irrefutable if-let println!("irrefutable pattern"); } if true { println!("if"); - } else if let a = 1i { //~ ERROR irrefutable if-let + } else if let a = 1is { //~ ERROR irrefutable if-let println!("irrefutable pattern"); } } diff --git a/src/test/compile-fail/immut-function-arguments.rs b/src/test/compile-fail/immut-function-arguments.rs index 827e648cca8..99927d8b9bf 100644 --- a/src/test/compile-fail/immut-function-arguments.rs +++ b/src/test/compile-fail/immut-function-arguments.rs @@ -9,12 +9,12 @@ // except according to those terms. -fn f(y: Box<int>) { +fn f(y: Box<isize>) { *y = 5; //~ ERROR cannot assign } fn g() { - let _frob = |&: q: Box<int>| { *q = 2; }; //~ ERROR cannot assign + let _frob = |&: q: Box<isize>| { *q = 2; }; //~ ERROR cannot assign } diff --git a/src/test/compile-fail/impl-bounds-checking.rs b/src/test/compile-fail/impl-bounds-checking.rs index 69a35bcbd7b..8c8f67e40ab 100644 --- a/src/test/compile-fail/impl-bounds-checking.rs +++ b/src/test/compile-fail/impl-bounds-checking.rs @@ -17,8 +17,8 @@ trait Getter<T: Clone2> { fn get(&self) -> T; } -impl Getter<int> for int { //~ ERROR the trait `Clone2` is not implemented - fn get(&self) -> int { *self } +impl Getter<isize> for isize { //~ ERROR the trait `Clone2` is not implemented + fn get(&self) -> isize { *self } } fn main() { } diff --git a/src/test/compile-fail/impl-not-adjacent-to-type.rs b/src/test/compile-fail/impl-not-adjacent-to-type.rs index 7a5428d63e8..7a7673d871d 100644 --- a/src/test/compile-fail/impl-not-adjacent-to-type.rs +++ b/src/test/compile-fail/impl-not-adjacent-to-type.rs @@ -10,8 +10,8 @@ mod foo { pub struct Foo { - x: int, - y: int, + x: isize, + y: isize, } } diff --git a/src/test/compile-fail/impl-unused-tps.rs b/src/test/compile-fail/impl-unused-tps.rs index 99c6c6b8985..c9399afbb93 100644 --- a/src/test/compile-fail/impl-unused-tps.rs +++ b/src/test/compile-fail/impl-unused-tps.rs @@ -16,19 +16,19 @@ trait Bar { type Out; } -impl<T> Foo<T> for [int;0] { +impl<T> Foo<T> for [isize;0] { // OK, T is used in `Foo<T>`. } -impl<T,U> Foo<T> for [int;1] { +impl<T,U> Foo<T> for [isize;1] { //~^ ERROR the type parameter `U` is not constrained } -impl<T,U> Foo<T> for [int;2] where T : Bar<Out=U> { +impl<T,U> Foo<T> for [isize;2] where T : Bar<Out=U> { // OK, `U` is now constrained by the output type parameter. } -impl<T:Bar<Out=U>,U> Foo<T> for [int;3] { +impl<T:Bar<Out=U>,U> Foo<T> for [isize;3] { // OK, same as above but written differently. } diff --git a/src/test/compile-fail/implicit-method-bind.rs b/src/test/compile-fail/implicit-method-bind.rs index 34367f06793..d329f72f788 100644 --- a/src/test/compile-fail/implicit-method-bind.rs +++ b/src/test/compile-fail/implicit-method-bind.rs @@ -11,5 +11,5 @@ use std::num::SignedInt; fn main() { - let _f = 10i.abs; //~ ERROR attempted to take value of method + let _f = 10is.abs; //~ ERROR attempted to take value of method } diff --git a/src/test/compile-fail/import-glob-circular.rs b/src/test/compile-fail/import-glob-circular.rs index fda7b190d72..0f6e3dc134d 100644 --- a/src/test/compile-fail/import-glob-circular.rs +++ b/src/test/compile-fail/import-glob-circular.rs @@ -13,13 +13,13 @@ mod circ1 { pub use circ2::f2; pub fn f1() { println!("f1"); } - pub fn common() -> uint { return 0u; } + pub fn common() -> usize { return 0us; } } mod circ2 { pub use circ1::f1; pub fn f2() { println!("f2"); } - pub fn common() -> uint { return 1u; } + pub fn common() -> usize { return 1us; } } mod test { diff --git a/src/test/compile-fail/import-shadow-1.rs b/src/test/compile-fail/import-shadow-1.rs index eac5a98140f..503fa4eca52 100644 --- a/src/test/compile-fail/import-shadow-1.rs +++ b/src/test/compile-fail/import-shadow-1.rs @@ -16,11 +16,11 @@ use foo::*; use bar::*; //~ERROR a type named `Baz` has already been imported in this module mod foo { - pub type Baz = int; + pub type Baz = isize; } mod bar { - pub type Baz = int; + pub type Baz = isize; } mod qux { diff --git a/src/test/compile-fail/import-shadow-2.rs b/src/test/compile-fail/import-shadow-2.rs index 8b0809fd55a..0c107cf27f5 100644 --- a/src/test/compile-fail/import-shadow-2.rs +++ b/src/test/compile-fail/import-shadow-2.rs @@ -16,11 +16,11 @@ use foo::*; use foo::*; //~ERROR a type named `Baz` has already been imported in this module mod foo { - pub type Baz = int; + pub type Baz = isize; } mod bar { - pub type Baz = int; + pub type Baz = isize; } mod qux { diff --git a/src/test/compile-fail/import-shadow-3.rs b/src/test/compile-fail/import-shadow-3.rs index cef481af6ba..bf90973c285 100644 --- a/src/test/compile-fail/import-shadow-3.rs +++ b/src/test/compile-fail/import-shadow-3.rs @@ -16,11 +16,11 @@ use foo::Baz; use bar::*; //~ERROR a type named `Baz` has already been imported in this module mod foo { - pub type Baz = int; + pub type Baz = isize; } mod bar { - pub type Baz = int; + pub type Baz = isize; } mod qux { diff --git a/src/test/compile-fail/import-shadow-4.rs b/src/test/compile-fail/import-shadow-4.rs index 919eea0e046..f21fdaae47b 100644 --- a/src/test/compile-fail/import-shadow-4.rs +++ b/src/test/compile-fail/import-shadow-4.rs @@ -16,11 +16,11 @@ use foo::*; use bar::Baz; //~ERROR a type named `Baz` has already been imported in this module mod foo { - pub type Baz = int; + pub type Baz = isize; } mod bar { - pub type Baz = int; + pub type Baz = isize; } mod qux { diff --git a/src/test/compile-fail/import-shadow-5.rs b/src/test/compile-fail/import-shadow-5.rs index df17b7f0a20..dc300bc7baa 100644 --- a/src/test/compile-fail/import-shadow-5.rs +++ b/src/test/compile-fail/import-shadow-5.rs @@ -16,11 +16,11 @@ use foo::Baz; use bar::Baz; //~ERROR a type named `Baz` has already been imported in this module mod foo { - pub type Baz = int; + pub type Baz = isize; } mod bar { - pub type Baz = int; + pub type Baz = isize; } mod qux { diff --git a/src/test/compile-fail/import-shadow-6.rs b/src/test/compile-fail/import-shadow-6.rs index 94269043b02..fa3b75c70f0 100644 --- a/src/test/compile-fail/import-shadow-6.rs +++ b/src/test/compile-fail/import-shadow-6.rs @@ -16,11 +16,11 @@ use qux::*; use foo::*; //~ERROR a type named `Baz` has already been imported in this module mod foo { - pub type Baz = int; + pub type Baz = isize; } mod bar { - pub type Baz = int; + pub type Baz = isize; } mod qux { diff --git a/src/test/compile-fail/import-shadow-7.rs b/src/test/compile-fail/import-shadow-7.rs index b3bac380710..34aba15b392 100644 --- a/src/test/compile-fail/import-shadow-7.rs +++ b/src/test/compile-fail/import-shadow-7.rs @@ -16,11 +16,11 @@ use foo::*; use qux::*; //~ERROR a type named `Baz` has already been imported in this module mod foo { - pub type Baz = int; + pub type Baz = isize; } mod bar { - pub type Baz = int; + pub type Baz = isize; } mod qux { diff --git a/src/test/compile-fail/index-bot.rs b/src/test/compile-fail/index-bot.rs index bd01d45fd44..876c1e481f6 100644 --- a/src/test/compile-fail/index-bot.rs +++ b/src/test/compile-fail/index-bot.rs @@ -9,5 +9,5 @@ // except according to those terms. fn main() { - (return)[0u]; //~ ERROR the type of this value must be known in this context + (return)[0us]; //~ ERROR the type of this value must be known in this context } diff --git a/src/test/compile-fail/indexing-requires-a-uint.rs b/src/test/compile-fail/indexing-requires-a-uint.rs index e5edb2358f8..901d8783d02 100644 --- a/src/test/compile-fail/indexing-requires-a-uint.rs +++ b/src/test/compile-fail/indexing-requires-a-uint.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// Make sure that indexing an array is only valid with a `uint`, not any other +// Make sure that indexing an array is only valid with a `usize`, not any other // integral type. fn main() { @@ -16,11 +16,11 @@ fn main() { [0][0u8]; //~ ERROR: the trait `core::ops::Index<u8>` is not implemented //~^ ERROR: the trait `core::ops::Index<u8>` is not implemented - [0][0]; // should infer to be a uint + [0][0]; // should infer to be a usize let i = 0; // i is an IntVar - [0][i]; // i should be locked to uint - bar::<int>(i); // i should not be re-coerced back to an int + [0][i]; // i should be locked to usize + bar::<isize>(i); // i should not be re-coerced back to an isize //~^ ERROR: mismatched types } diff --git a/src/test/compile-fail/infinite-instantiation.rs b/src/test/compile-fail/infinite-instantiation.rs index b8fa6285d99..a922f5fe452 100644 --- a/src/test/compile-fail/infinite-instantiation.rs +++ b/src/test/compile-fail/infinite-instantiation.rs @@ -15,8 +15,8 @@ trait to_opt { fn to_option(&self) -> Option<Self>; } -impl to_opt for uint { - fn to_option(&self) -> Option<uint> { +impl to_opt for usize { + fn to_option(&self) -> Option<usize> { Some(*self) } } @@ -27,12 +27,12 @@ impl<T:Clone> to_opt for Option<T> { } } -fn function<T:to_opt + Clone>(counter: uint, t: T) { - if counter > 0u { - function(counter - 1u, t.to_option()); +fn function<T:to_opt + Clone>(counter: usize, t: T) { + if counter > 0us { + function(counter - 1us, t.to_option()); } } fn main() { - function(22u, 22u); + function(22us, 22us); } diff --git a/src/test/compile-fail/infinite-tag-type-recursion.rs b/src/test/compile-fail/infinite-tag-type-recursion.rs index f8d89a8269d..a57c015d684 100644 --- a/src/test/compile-fail/infinite-tag-type-recursion.rs +++ b/src/test/compile-fail/infinite-tag-type-recursion.rs @@ -11,6 +11,6 @@ // error-pattern: illegal recursive enum type; wrap the inner value in a box -enum mlist { cons(int, mlist), nil, } +enum mlist { cons(isize, mlist), nil, } fn main() { let a = mlist::cons(10, mlist::cons(11, mlist::nil)); } diff --git a/src/test/compile-fail/int-literal-too-large-span.rs b/src/test/compile-fail/int-literal-too-large-span.rs index 8a496c934b9..2aeaf6efaa4 100644 --- a/src/test/compile-fail/int-literal-too-large-span.rs +++ b/src/test/compile-fail/int-literal-too-large-span.rs @@ -11,7 +11,7 @@ // issue #17123 fn main() { - 100000000000000000000000000000000 //~ ERROR int literal is too large + 100000000000000000000000000000000is //~ ERROR int literal is too large ; // the span shouldn't point to this. } diff --git a/src/test/compile-fail/integral-indexing.rs b/src/test/compile-fail/integral-indexing.rs index bbceb00abd3..ef651dd9ce7 100644 --- a/src/test/compile-fail/integral-indexing.rs +++ b/src/test/compile-fail/integral-indexing.rs @@ -9,9 +9,9 @@ // except according to those terms. pub fn main() { - let v: Vec<int> = vec!(0, 1, 2, 3, 4, 5); + let v: Vec<isize> = vec!(0, 1, 2, 3, 4, 5); let s: String = "abcdef".to_string(); - v.as_slice()[3u]; + v.as_slice()[3us]; v.as_slice()[3]; v.as_slice()[3u8]; //~ERROR the trait `core::ops::Index<u8>` is not implemented //~^ ERROR the trait `core::ops::Index<u8>` is not implemented @@ -21,7 +21,7 @@ pub fn main() { //~^ ERROR the trait `core::ops::Index<u32>` is not implemented v.as_slice()[3i32]; //~ERROR the trait `core::ops::Index<i32>` is not implemented //~^ ERROR the trait `core::ops::Index<i32>` is not implemented - s.as_bytes()[3u]; + s.as_bytes()[3us]; s.as_bytes()[3]; s.as_bytes()[3u8]; //~ERROR the trait `core::ops::Index<u8>` is not implemented //~^ERROR the trait `core::ops::Index<u8>` is not implemented diff --git a/src/test/compile-fail/intrinsic-return-address.rs b/src/test/compile-fail/intrinsic-return-address.rs index 9c1db4057c6..a80d3931555 100644 --- a/src/test/compile-fail/intrinsic-return-address.rs +++ b/src/test/compile-fail/intrinsic-return-address.rs @@ -20,7 +20,7 @@ unsafe fn f() { //~^ ERROR invalid use of `return_address` intrinsic: function does not use out pointer } -unsafe fn g() -> int { +unsafe fn g() -> isize { let _ = return_address(); //~^ ERROR invalid use of `return_address` intrinsic: function does not use out pointer 0 diff --git a/src/test/compile-fail/issue-10200.rs b/src/test/compile-fail/issue-10200.rs index 2b9ac705f32..03d4e9b81eb 100644 --- a/src/test/compile-fail/issue-10200.rs +++ b/src/test/compile-fail/issue-10200.rs @@ -9,7 +9,7 @@ // except according to those terms. struct Foo(bool); -fn foo(_: uint) -> Foo { Foo(false) } +fn foo(_: usize) -> Foo { Foo(false) } fn main() { match Foo(true) { diff --git a/src/test/compile-fail/issue-10291.rs b/src/test/compile-fail/issue-10291.rs index 453746ffd6a..45f6e55914a 100644 --- a/src/test/compile-fail/issue-10291.rs +++ b/src/test/compile-fail/issue-10291.rs @@ -10,8 +10,8 @@ #![feature(box_syntax)] -fn test<'x>(x: &'x int) { - drop::<Box<for<'z> FnMut(&'z int) -> &'z int>>(box |z| { +fn test<'x>(x: &'x isize) { + drop::<Box<for<'z> FnMut(&'z isize) -> &'z isize>>(box |z| { x //~^ ERROR cannot infer an appropriate lifetime }); diff --git a/src/test/compile-fail/issue-10392-2.rs b/src/test/compile-fail/issue-10392-2.rs index 2cbb59cc15a..b077081c5b0 100644 --- a/src/test/compile-fail/issue-10392-2.rs +++ b/src/test/compile-fail/issue-10392-2.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -struct A { foo: int } +struct A { foo: isize } fn a() -> A { panic!() } diff --git a/src/test/compile-fail/issue-10392.rs b/src/test/compile-fail/issue-10392.rs index 4d0e02c6310..3f8d26bfec0 100644 --- a/src/test/compile-fail/issue-10392.rs +++ b/src/test/compile-fail/issue-10392.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -struct A { foo: int } +struct A { foo: isize } fn a() -> A { panic!() } diff --git a/src/test/compile-fail/issue-10398.rs b/src/test/compile-fail/issue-10398.rs index 11c577f9dc3..c1102bc84ab 100644 --- a/src/test/compile-fail/issue-10398.rs +++ b/src/test/compile-fail/issue-10398.rs @@ -11,7 +11,7 @@ #![feature(box_syntax)] fn main() { - let x = box 1i; + let x = box 1is; let f = move|:| { let _a = x; drop(x); diff --git a/src/test/compile-fail/issue-10636-1.rs b/src/test/compile-fail/issue-10636-1.rs index 710c5a306f3..bb020d55bdb 100644 --- a/src/test/compile-fail/issue-10636-1.rs +++ b/src/test/compile-fail/issue-10636-1.rs @@ -9,5 +9,5 @@ // except according to those terms. struct Obj { //~ NOTE: unclosed delimiter - member: uint + member: usize ) //~ ERROR: incorrect close delimiter diff --git a/src/test/compile-fail/issue-10636-2.rs b/src/test/compile-fail/issue-10636-2.rs index 2303f858fcc..a92ef248924 100644 --- a/src/test/compile-fail/issue-10636-2.rs +++ b/src/test/compile-fail/issue-10636-2.rs @@ -8,6 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -pub fn trace_option(option: Option<int>) { +pub fn trace_option(option: Option<isize>) { option.map(|some| 42; //~ NOTE: unclosed delimiter } //~ ERROR: incorrect close delimiter diff --git a/src/test/compile-fail/issue-10877.rs b/src/test/compile-fail/issue-10877.rs index 2a9cadf1f33..39f25b837cd 100644 --- a/src/test/compile-fail/issue-10877.rs +++ b/src/test/compile-fail/issue-10877.rs @@ -8,17 +8,17 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -struct Foo { x: int } +struct Foo { x: isize } extern { fn foo(1: ()); //~^ ERROR: patterns aren't allowed in foreign function declarations - fn bar((): int); + fn bar((): isize); //~^ ERROR: patterns aren't allowed in foreign function declarations - fn baz(Foo { x }: int); + fn baz(Foo { x }: isize); //~^ ERROR: patterns aren't allowed in foreign function declarations fn qux((x,y): ()); //~^ ERROR: patterns aren't allowed in foreign function declarations - fn this_is_actually_ok(a: uint); - fn and_so_is_this(_: uint); + fn this_is_actually_ok(a: usize); + fn and_so_is_this(_: usize); } fn main() {} diff --git a/src/test/compile-fail/issue-11192.rs b/src/test/compile-fail/issue-11192.rs index 3784d3d6437..0d7a846bff6 100644 --- a/src/test/compile-fail/issue-11192.rs +++ b/src/test/compile-fail/issue-11192.rs @@ -11,7 +11,7 @@ #![feature(box_syntax)] struct Foo { - x: int + x: isize } impl Drop for Foo { diff --git a/src/test/compile-fail/issue-11493.rs b/src/test/compile-fail/issue-11493.rs index 7856a5dcf7f..895eb4cf96f 100644 --- a/src/test/compile-fail/issue-11493.rs +++ b/src/test/compile-fail/issue-11493.rs @@ -11,6 +11,6 @@ // This file must never have a trailing newline fn main() { - let x = Some(3i); - let y = x.as_ref().unwrap_or(&5i); //~ ERROR: borrowed value does not live long enough + let x = Some(3is); + let y = x.as_ref().unwrap_or(&5is); //~ ERROR: borrowed value does not live long enough } diff --git a/src/test/compile-fail/issue-11714.rs b/src/test/compile-fail/issue-11714.rs index ed00d4131db..eef035d3d94 100644 --- a/src/test/compile-fail/issue-11714.rs +++ b/src/test/compile-fail/issue-11714.rs @@ -8,8 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -fn blah() -> int { //~ ERROR not all control paths return a value - 1i +fn blah() -> isize { //~ ERROR not all control paths return a value + 1is ; //~ HELP consider removing this semicolon: } diff --git a/src/test/compile-fail/issue-11873.rs b/src/test/compile-fail/issue-11873.rs index 89667937531..67578de8922 100644 --- a/src/test/compile-fail/issue-11873.rs +++ b/src/test/compile-fail/issue-11873.rs @@ -9,8 +9,8 @@ // except according to those terms. fn main() { - let mut v = vec!(1i); - let mut f = |&mut:| v.push(2i); + let mut v = vec!(1is); + let mut f = |&mut:| v.push(2is); let _w = v; //~ ERROR: cannot move out of `v` f(); diff --git a/src/test/compile-fail/issue-11925.rs b/src/test/compile-fail/issue-11925.rs index 71e4598d635..e5f3b7d62d3 100644 --- a/src/test/compile-fail/issue-11925.rs +++ b/src/test/compile-fail/issue-11925.rs @@ -12,7 +12,7 @@ fn main() { let r = { - let x = box 42i; + let x = box 42is; let f = move|:| &x; //~ ERROR: `x` does not live long enough f() }; diff --git a/src/test/compile-fail/issue-12041.rs b/src/test/compile-fail/issue-12041.rs index 094f6d64edc..02c19204f79 100644 --- a/src/test/compile-fail/issue-12041.rs +++ b/src/test/compile-fail/issue-12041.rs @@ -17,7 +17,7 @@ fn main() { loop { let tx = tx; //~^ ERROR: use of moved value: `tx` - tx.send(1i); + tx.send(1is); } }); } diff --git a/src/test/compile-fail/issue-12116.rs b/src/test/compile-fail/issue-12116.rs index 8a5e8c27259..6f75909fada 100644 --- a/src/test/compile-fail/issue-12116.rs +++ b/src/test/compile-fail/issue-12116.rs @@ -11,7 +11,7 @@ #![feature(box_syntax)] enum IntList { - Cons(int, Box<IntList>), + Cons(isize, Box<IntList>), Nil } diff --git a/src/test/compile-fail/issue-12127.rs b/src/test/compile-fail/issue-12127.rs index 2d87bdaf524..c06082de3cd 100644 --- a/src/test/compile-fail/issue-12127.rs +++ b/src/test/compile-fail/issue-12127.rs @@ -10,7 +10,7 @@ #![feature(box_syntax)] -fn do_it(x: &int) { } +fn do_it(x: &isize) { } fn main() { let x = box 22; diff --git a/src/test/compile-fail/issue-12369.rs b/src/test/compile-fail/issue-12369.rs index 4522b536ffd..0587bdf6136 100644 --- a/src/test/compile-fail/issue-12369.rs +++ b/src/test/compile-fail/issue-12369.rs @@ -10,7 +10,7 @@ fn main() { let sl = vec![1,2,3]; - let v: int = match sl.as_slice() { + let v: isize = match sl.as_slice() { [] => 0, [a,b,c] => 3, [a, rest..] => a, diff --git a/src/test/compile-fail/issue-12470.rs b/src/test/compile-fail/issue-12470.rs index 31874655302..93785817e14 100644 --- a/src/test/compile-fail/issue-12470.rs +++ b/src/test/compile-fail/issue-12470.rs @@ -11,16 +11,16 @@ #![feature(box_syntax)] trait X { - fn get_i(&self) -> int; + fn get_i(&self) -> isize; } struct B { - i: int + i: isize } impl X for B { - fn get_i(&self) -> int { + fn get_i(&self) -> isize { self.i } } diff --git a/src/test/compile-fail/issue-12567.rs b/src/test/compile-fail/issue-12567.rs index 26866cbbc60..d186a83676a 100644 --- a/src/test/compile-fail/issue-12567.rs +++ b/src/test/compile-fail/issue-12567.rs @@ -12,11 +12,11 @@ fn match_vecs<'a, T>(l1: &'a [T], l2: &'a [T]) { match (l1, l2) { ([], []) => println!("both empty"), ([], [hd, tl..]) | ([hd, tl..], []) => println!("one empty"), - //~^ ERROR: cannot move out of dereference - //~^^ ERROR: cannot move out of dereference + //~^ ERROR: cannot move out of borrowed content + //~^^ ERROR: cannot move out of borrowed content ([hd1, tl1..], [hd2, tl2..]) => println!("both nonempty"), - //~^ ERROR: cannot move out of dereference - //~^^ ERROR: cannot move out of dereference + //~^ ERROR: cannot move out of borrowed content + //~^^ ERROR: cannot move out of borrowed content } } diff --git a/src/test/compile-fail/issue-12997-1.rs b/src/test/compile-fail/issue-12997-1.rs index 193cbcb25b7..2d8d7857c99 100644 --- a/src/test/compile-fail/issue-12997-1.rs +++ b/src/test/compile-fail/issue-12997-1.rs @@ -16,4 +16,4 @@ fn foo() { } //~ ERROR functions used as benches #[bench] -fn bar(x: int, y: int) { } //~ ERROR functions used as benches +fn bar(x: isize, y: isize) { } //~ ERROR functions used as benches diff --git a/src/test/compile-fail/issue-13058.rs b/src/test/compile-fail/issue-13058.rs index 8f507864052..eee82483cae 100644 --- a/src/test/compile-fail/issue-13058.rs +++ b/src/test/compile-fail/issue-13058.rs @@ -34,6 +34,6 @@ fn check<'r, I: Iterator<Item=usize>, T: Itble<'r, usize, I>>(cont: &T) -> bool } fn main() { - check((3u, 5u)); + check((3us, 5us)); //~^ ERROR mismatched types: expected `&_`, found `(usize, usize)` (expected &-ptr, found tuple) } diff --git a/src/test/compile-fail/issue-13359.rs b/src/test/compile-fail/issue-13359.rs index 25e64e070f4..2e338860377 100644 --- a/src/test/compile-fail/issue-13359.rs +++ b/src/test/compile-fail/issue-13359.rs @@ -13,9 +13,9 @@ fn foo(_s: i16) { } fn bar(_s: u32) { } fn main() { - foo(1*(1 as int)); + foo(1*(1 as isize)); //~^ ERROR: mismatched types: expected `i16`, found `isize` (expected i16, found isize) - bar(1*(1 as uint)); + bar(1*(1 as usize)); //~^ ERROR: mismatched types: expected `u32`, found `usize` (expected u32, found usize) } diff --git a/src/test/compile-fail/issue-1362.rs b/src/test/compile-fail/issue-1362.rs index bfbbc9d8aed..28d16f9c0b7 100644 --- a/src/test/compile-fail/issue-1362.rs +++ b/src/test/compile-fail/issue-1362.rs @@ -11,7 +11,7 @@ // Regression test for issue #1362 - without that fix the span will be bogus // no-reformat fn main() { - let x: uint = 20i; //~ ERROR mismatched types + let x: usize = 20is; //~ ERROR mismatched types } // NOTE: Do not add any extra lines as the line number the error is // on is significant; an error later in the source file might not diff --git a/src/test/compile-fail/issue-13853-4.rs b/src/test/compile-fail/issue-13853-4.rs index 7d653f5ab9e..b0db9e58dba 100644 --- a/src/test/compile-fail/issue-13853-4.rs +++ b/src/test/compile-fail/issue-13853-4.rs @@ -9,7 +9,7 @@ // except according to those terms. struct AutoBuilder<'a> { - context: &'a int + context: &'a isize } impl<'a> Drop for AutoBuilder<'a> { diff --git a/src/test/compile-fail/issue-14182.rs b/src/test/compile-fail/issue-14182.rs index 5033576a234..364951a4fea 100644 --- a/src/test/compile-fail/issue-14182.rs +++ b/src/test/compile-fail/issue-14182.rs @@ -11,8 +11,8 @@ // ignore-test FIXME(japari) remove test struct Foo { - f: for <'b> |&'b int|: - 'b -> &'b int //~ ERROR use of undeclared lifetime name `'b` + f: for <'b> |&'b isize|: + 'b -> &'b isize //~ ERROR use of undeclared lifetime name `'b` } fn main() { diff --git a/src/test/compile-fail/issue-14254.rs b/src/test/compile-fail/issue-14254.rs index dc19b9d51c8..74eea0c57a0 100644 --- a/src/test/compile-fail/issue-14254.rs +++ b/src/test/compile-fail/issue-14254.rs @@ -15,7 +15,7 @@ trait Foo { } struct BarTy { - x : int, + x : isize, y : f64, } @@ -76,7 +76,7 @@ impl Foo for Box<BarTy> { } } -impl Foo for *const int { +impl Foo for *const isize { fn bar(&self) { baz(); //~^ ERROR: unresolved name `baz`. Did you mean to call `self.baz`? @@ -85,7 +85,7 @@ impl Foo for *const int { } } -impl<'a> Foo for &'a int { +impl<'a> Foo for &'a isize { fn bar(&self) { baz(); //~^ ERROR: unresolved name `baz`. Did you mean to call `self.baz`? @@ -94,7 +94,7 @@ impl<'a> Foo for &'a int { } } -impl<'a> Foo for &'a mut int { +impl<'a> Foo for &'a mut isize { fn bar(&self) { baz(); //~^ ERROR: unresolved name `baz`. Did you mean to call `self.baz`? @@ -103,7 +103,7 @@ impl<'a> Foo for &'a mut int { } } -impl Foo for Box<int> { +impl Foo for Box<isize> { fn bar(&self) { baz(); //~^ ERROR: unresolved name `baz`. Did you mean to call `self.baz`? diff --git a/src/test/compile-fail/issue-14303-fncall.rs b/src/test/compile-fail/issue-14303-fncall.rs index 3a5c8bbc546..0ec64ba6a3f 100644 --- a/src/test/compile-fail/issue-14303-fncall.rs +++ b/src/test/compile-fail/issue-14303-fncall.rs @@ -11,6 +11,6 @@ fn main() { range(0, 4) .map(|x| x * 2) - .collect::<Vec<'a, uint, 'b>>() + .collect::<Vec<'a, usize, 'b>>() //~^ ERROR lifetime parameters must be declared prior to type parameters } diff --git a/src/test/compile-fail/issue-14303-impl.rs b/src/test/compile-fail/issue-14303-impl.rs index 46d0219da81..c4a00581274 100644 --- a/src/test/compile-fail/issue-14303-impl.rs +++ b/src/test/compile-fail/issue-14303-impl.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -struct X { x: int } +struct X { x: isize } impl<'a, T, 'b> X {} //~^ ERROR lifetime parameters must be declared prior to type parameters diff --git a/src/test/compile-fail/issue-1448-2.rs b/src/test/compile-fail/issue-1448-2.rs index 234fa85c89a..371adf931b0 100644 --- a/src/test/compile-fail/issue-1448-2.rs +++ b/src/test/compile-fail/issue-1448-2.rs @@ -10,8 +10,8 @@ // Regression test for issue #1448 and #1386 -fn foo(a: uint) -> uint { a } +fn foo(a: usize) -> usize { a } fn main() { - println!("{}", foo(10i)); //~ ERROR mismatched types + println!("{}", foo(10is)); //~ ERROR mismatched types } diff --git a/src/test/compile-fail/issue-15094.rs b/src/test/compile-fail/issue-15094.rs index 5292848f8ee..5b33069b595 100644 --- a/src/test/compile-fail/issue-15094.rs +++ b/src/test/compile-fail/issue-15094.rs @@ -28,6 +28,6 @@ fn make_shower<T>(x: T) -> Shower<T> { } pub fn main() { - let show3 = make_shower(3i); + let show3 = make_shower(3is); show3(); } diff --git a/src/test/compile-fail/issue-15129.rs b/src/test/compile-fail/issue-15129.rs index f56430f4228..7a7ba46de74 100644 --- a/src/test/compile-fail/issue-15129.rs +++ b/src/test/compile-fail/issue-15129.rs @@ -14,7 +14,7 @@ pub enum T { } pub enum V { - V1(int), + V1(isize), V2(bool) } diff --git a/src/test/compile-fail/issue-15167.rs b/src/test/compile-fail/issue-15167.rs index d4de4e177f0..630c35d6a4f 100644 --- a/src/test/compile-fail/issue-15167.rs +++ b/src/test/compile-fail/issue-15167.rs @@ -18,7 +18,7 @@ macro_rules! f { () => (n) } fn main() -> (){ - for n in range(0i, 1) { + for n in range(0is, 1) { println!("{}", f!()); //~ ERROR unresolved name `n` } } diff --git a/src/test/compile-fail/issue-15260.rs b/src/test/compile-fail/issue-15260.rs index e3d19729710..2228b6d3779 100644 --- a/src/test/compile-fail/issue-15260.rs +++ b/src/test/compile-fail/issue-15260.rs @@ -9,7 +9,7 @@ // except according to those terms. struct Foo { - a: uint, + a: usize, } fn main() { diff --git a/src/test/compile-fail/issue-15480.rs b/src/test/compile-fail/issue-15480.rs index abcc2eb1f98..59d87b5277a 100644 --- a/src/test/compile-fail/issue-15480.rs +++ b/src/test/compile-fail/issue-15480.rs @@ -10,7 +10,7 @@ fn main() { let v = vec![ - &3i + &3is //~^ ERROR borrowed value does not live long enough ]; diff --git a/src/test/compile-fail/issue-15524.rs b/src/test/compile-fail/issue-15524.rs index 6d9657ab289..b378d2f885e 100644 --- a/src/test/compile-fail/issue-15524.rs +++ b/src/test/compile-fail/issue-15524.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -const N: int = 1; +const N: isize = 1; enum Foo { A = 1, diff --git a/src/test/compile-fail/issue-15783.rs b/src/test/compile-fail/issue-15783.rs index f3e7a65db48..1b1b0302383 100644 --- a/src/test/compile-fail/issue-15783.rs +++ b/src/test/compile-fail/issue-15783.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -pub fn foo(params: Option<&[&str]>) -> uint { +pub fn foo(params: Option<&[&str]>) -> usize { params.unwrap().first().unwrap().len() } diff --git a/src/test/compile-fail/issue-15896.rs b/src/test/compile-fail/issue-15896.rs index 7b91063e2f9..c4373ba3351 100644 --- a/src/test/compile-fail/issue-15896.rs +++ b/src/test/compile-fail/issue-15896.rs @@ -12,7 +12,7 @@ fn main() { enum R { REB(()) } - struct Tau { t: uint } + struct Tau { t: usize } enum E { B(R, Tau) } let e = E::B(R::REB(()), Tau { t: 3 }); diff --git a/src/test/compile-fail/issue-16149.rs b/src/test/compile-fail/issue-16149.rs index aa586e58f70..a924cc9f9bb 100644 --- a/src/test/compile-fail/issue-16149.rs +++ b/src/test/compile-fail/issue-16149.rs @@ -9,7 +9,7 @@ // except according to those terms. extern { - static externalValue: int; + static externalValue: isize; } fn main() { diff --git a/src/test/compile-fail/issue-16465.rs b/src/test/compile-fail/issue-16465.rs index 280f19cfe9c..825b40cb322 100644 --- a/src/test/compile-fail/issue-16465.rs +++ b/src/test/compile-fail/issue-16465.rs @@ -14,7 +14,7 @@ struct Foo<T>{ x : T } -type FooInt = Foo<int>; +type FooInt = Foo<isize>; impl Drop for FooInt { //~^ ERROR cannot implement a destructor on a structure with type parameters diff --git a/src/test/compile-fail/issue-16538.rs b/src/test/compile-fail/issue-16538.rs index af686b86813..a6b73dcc19c 100644 --- a/src/test/compile-fail/issue-16538.rs +++ b/src/test/compile-fail/issue-16538.rs @@ -9,9 +9,9 @@ // except according to those terms. mod Y { - type X = uint; + type X = usize; extern { - static x: *const uint; + static x: *const usize; } fn foo(value: *const X) -> *const X { value diff --git a/src/test/compile-fail/issue-16562.rs b/src/test/compile-fail/issue-16562.rs index 626a442a2c3..a400263a243 100644 --- a/src/test/compile-fail/issue-16562.rs +++ b/src/test/compile-fail/issue-16562.rs @@ -15,11 +15,11 @@ struct Col<D, C> { col: C, } -trait Collection { fn len(&self) -> uint; } +trait Collection { fn len(&self) -> usize; } -impl<T, M: MatrixShape> Collection for Col<M, uint> { +impl<T, M: MatrixShape> Collection for Col<M, usize> { //~^ ERROR type parameter `T` is not constrained - fn len(&self) -> uint { + fn len(&self) -> usize { unimplemented!() } } diff --git a/src/test/compile-fail/issue-16747.rs b/src/test/compile-fail/issue-16747.rs index 22e3e9ed09e..814b885e3aa 100644 --- a/src/test/compile-fail/issue-16747.rs +++ b/src/test/compile-fail/issue-16747.rs @@ -12,7 +12,7 @@ trait ListItem<'a> { fn list_name() -> &'a str; } -trait Collection { fn len(&self) -> uint; } +trait Collection { fn len(&self) -> usize; } struct List<'a, T: ListItem<'a>> { //~^ ERROR the parameter type `T` may not live long enough @@ -22,7 +22,7 @@ struct List<'a, T: ListItem<'a>> { } impl<'a, T: ListItem<'a>> Collection for List<'a, T> { - fn len(&self) -> uint { + fn len(&self) -> usize { 0 } } diff --git a/src/test/compile-fail/issue-17252.rs b/src/test/compile-fail/issue-17252.rs index 4adb3f041a3..2e9ef8d6077 100644 --- a/src/test/compile-fail/issue-17252.rs +++ b/src/test/compile-fail/issue-17252.rs @@ -8,12 +8,12 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -static FOO: uint = FOO; //~ ERROR recursive constant +static FOO: usize = FOO; //~ ERROR recursive constant fn main() { let _x: [u8; FOO]; // caused stack overflow prior to fix - let _y: uint = 1 + { - static BAR: uint = BAR; //~ ERROR recursive constant + let _y: usize = 1 + { + static BAR: usize = BAR; //~ ERROR recursive constant let _z: [u8; BAR]; // caused stack overflow prior to fix 1 }; diff --git a/src/test/compile-fail/issue-17263.rs b/src/test/compile-fail/issue-17263.rs index ba993259216..543063b3fc9 100644 --- a/src/test/compile-fail/issue-17263.rs +++ b/src/test/compile-fail/issue-17263.rs @@ -10,7 +10,7 @@ #![feature(box_syntax)] -struct Foo { a: int, b: int } +struct Foo { a: isize, b: isize } fn main() { let mut x = box Foo { a: 1, b: 2 }; diff --git a/src/test/compile-fail/issue-17283.rs b/src/test/compile-fail/issue-17283.rs index 122c1f08395..0c9fd9d9486 100644 --- a/src/test/compile-fail/issue-17283.rs +++ b/src/test/compile-fail/issue-17283.rs @@ -12,11 +12,11 @@ // within assignments in if expressions. struct Foo { - foo: uint + foo: usize } fn main() { - let x = 1u; + let x = 1us; let y: Foo; // `x { ... }` should not be interpreted as a struct literal here diff --git a/src/test/compile-fail/issue-17337.rs b/src/test/compile-fail/issue-17337.rs index e0f655084ff..24425e5eeec 100644 --- a/src/test/compile-fail/issue-17337.rs +++ b/src/test/compile-fail/issue-17337.rs @@ -8,6 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![staged_api] #![deny(deprecated)] struct Foo; diff --git a/src/test/compile-fail/issue-17383.rs b/src/test/compile-fail/issue-17383.rs index 24007364550..c71e0ecd494 100644 --- a/src/test/compile-fail/issue-17383.rs +++ b/src/test/compile-fail/issue-17383.rs @@ -12,7 +12,7 @@ enum X { A = b'a' //~ ERROR discriminator values can only be used with a c-like enum , - B(int) + B(isize) } fn main() {} diff --git a/src/test/compile-fail/issue-17385.rs b/src/test/compile-fail/issue-17385.rs index 62a5c7318b9..38278c524c8 100644 --- a/src/test/compile-fail/issue-17385.rs +++ b/src/test/compile-fail/issue-17385.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -struct X(int); +struct X(isize); enum Enum { Variant1, @@ -23,10 +23,10 @@ impl Drop for Enum { } fn main() { - let foo = X(1i); + let foo = X(1is); drop(foo); match foo { //~ ERROR use of moved value - X(1i) => (), + X(1is) => (), _ => unreachable!() } diff --git a/src/test/compile-fail/issue-17405.rs b/src/test/compile-fail/issue-17405.rs index c956f00c8e7..63120e85b09 100644 --- a/src/test/compile-fail/issue-17405.rs +++ b/src/test/compile-fail/issue-17405.rs @@ -9,11 +9,11 @@ // except according to those terms. enum Foo { - Bar(int) + Bar(isize) } fn main() { - match Foo::Bar(1i) { + match Foo::Bar(1is) { Foo { i } => () //~ ERROR `Foo` does not name a struct or a struct variant } } diff --git a/src/test/compile-fail/issue-17441.rs b/src/test/compile-fail/issue-17441.rs index a28162159a5..e9e69dadd3b 100644 --- a/src/test/compile-fail/issue-17441.rs +++ b/src/test/compile-fail/issue-17441.rs @@ -11,16 +11,16 @@ #![feature(box_syntax)] fn main() { - let _foo = &[1u, 2] as [usize]; + let _foo = &[1us, 2] as [usize]; //~^ ERROR cast to unsized type: `&[usize; 2]` as `[usize]` //~^^ HELP consider using an implicit coercion to `&[usize]` instead - let _bar = box 1u as std::fmt::Show; + let _bar = box 1us as std::fmt::Show; //~^ ERROR cast to unsized type: `Box<usize>` as `core::fmt::Show` //~^^ HELP did you mean `Box<core::fmt::Show>`? - let _baz = 1u as std::fmt::Show; + let _baz = 1us as std::fmt::Show; //~^ ERROR cast to unsized type: `usize` as `core::fmt::Show` //~^^ HELP consider using a box or reference as appropriate - let _quux = [1u, 2] as [usize]; + let _quux = [1us, 2] as [usize]; //~^ ERROR cast to unsized type: `[usize; 2]` as `[usize]` //~^^ HELP consider using a box or reference as appropriate } diff --git a/src/test/compile-fail/issue-17450.rs b/src/test/compile-fail/issue-17450.rs index ca611c62577..5471d8522df 100644 --- a/src/test/compile-fail/issue-17450.rs +++ b/src/test/compile-fail/issue-17450.rs @@ -10,8 +10,8 @@ #![allow(dead_code)] -static mut x: int = 3; -static mut y: int = unsafe { +static mut x: isize = 3; +static mut y: isize = unsafe { x //~^ ERROR cannot refer to other statics by value, use the address-of operator or a constant instea }; diff --git a/src/test/compile-fail/issue-17458.rs b/src/test/compile-fail/issue-17458.rs index b1fbe6f5549..d9fd67f9197 100644 --- a/src/test/compile-fail/issue-17458.rs +++ b/src/test/compile-fail/issue-17458.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -static X: uint = 0 as *const uint as uint; +static X: usize = 0 as *const usize as usize; //~^ ERROR: can not cast a pointer to an integer in a constant expression fn main() { diff --git a/src/test/compile-fail/issue-17651.rs b/src/test/compile-fail/issue-17651.rs index d3678f7d87f..fbecd0487bf 100644 --- a/src/test/compile-fail/issue-17651.rs +++ b/src/test/compile-fail/issue-17651.rs @@ -15,6 +15,6 @@ fn main() { (|&:| box *[0us].as_slice())(); - //~^ ERROR cannot move out of dereference + //~^ ERROR cannot move out of borrowed content //~^^ ERROR cannot move a value of type [usize] } diff --git a/src/test/compile-fail/issue-17718-borrow-interior.rs b/src/test/compile-fail/issue-17718-borrow-interior.rs index 8aa5fdf1c4d..d33c12668f2 100644 --- a/src/test/compile-fail/issue-17718-borrow-interior.rs +++ b/src/test/compile-fail/issue-17718-borrow-interior.rs @@ -8,17 +8,17 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -struct S { a: uint } +struct S { a: usize } static A: S = S { a: 3 }; -static B: &'static uint = &A.a; +static B: &'static usize = &A.a; //~^ ERROR: cannot refer to the interior of another static -static C: &'static uint = &(A.a); +static C: &'static usize = &(A.a); //~^ ERROR: cannot refer to the interior of another static -static D: [uint; 1] = [1]; -static E: uint = D[0]; +static D: [usize; 1] = [1]; +static E: usize = D[0]; //~^ ERROR: cannot refer to other statics by value -static F: &'static uint = &D[0]; +static F: &'static usize = &D[0]; //~^ ERROR: cannot refer to the interior of another static fn main() {} diff --git a/src/test/compile-fail/issue-17718-const-bad-values.rs b/src/test/compile-fail/issue-17718-const-bad-values.rs index 6425dbda5c6..daa250d12f5 100644 --- a/src/test/compile-fail/issue-17718-const-bad-values.rs +++ b/src/test/compile-fail/issue-17718-const-bad-values.rs @@ -8,11 +8,11 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -const C1: &'static mut [uint] = &mut []; +const C1: &'static mut [usize] = &mut []; //~^ ERROR: constants are not allowed to have mutable references -static mut S: uint = 3; -const C2: &'static mut uint = &mut S; +static mut S: usize = 3; +const C2: &'static mut usize = &mut S; //~^ ERROR: constants cannot refer to other statics //~^^ ERROR: are not allowed to have mutable references diff --git a/src/test/compile-fail/issue-17718-const-borrow.rs b/src/test/compile-fail/issue-17718-const-borrow.rs index 21cc9a757cf..dfa5bca8ccd 100644 --- a/src/test/compile-fail/issue-17718-const-borrow.rs +++ b/src/test/compile-fail/issue-17718-const-borrow.rs @@ -10,13 +10,13 @@ use std::cell::UnsafeCell; -const A: UnsafeCell<uint> = UnsafeCell { value: 1 }; -const B: &'static UnsafeCell<uint> = &A; +const A: UnsafeCell<usize> = UnsafeCell { value: 1 }; +const B: &'static UnsafeCell<usize> = &A; //~^ ERROR: cannot borrow a constant which contains interior mutability -struct C { a: UnsafeCell<uint> } +struct C { a: UnsafeCell<usize> } const D: C = C { a: UnsafeCell { value: 1 } }; -const E: &'static UnsafeCell<uint> = &D.a; +const E: &'static UnsafeCell<usize> = &D.a; //~^ ERROR: cannot borrow a constant which contains interior mutability const F: &'static C = &D; //~^ ERROR: cannot borrow a constant which contains interior mutability diff --git a/src/test/compile-fail/issue-17718-const-mut.rs b/src/test/compile-fail/issue-17718-const-mut.rs index 12b9cf4ba8c..5177ebbc188 100644 --- a/src/test/compile-fail/issue-17718-const-mut.rs +++ b/src/test/compile-fail/issue-17718-const-mut.rs @@ -11,7 +11,7 @@ const mut //~ ERROR: const globals cannot be mutable //~^ HELP did you mean to declare a static? -FOO: uint = 3; +FOO: usize = 3; fn main() { } diff --git a/src/test/compile-fail/issue-17718-const-naming.rs b/src/test/compile-fail/issue-17718-const-naming.rs index 0cfee6daf3f..15f66493f88 100644 --- a/src/test/compile-fail/issue-17718-const-naming.rs +++ b/src/test/compile-fail/issue-17718-const-naming.rs @@ -10,7 +10,7 @@ #[deny(warnings)] -const foo: int = 3; +const foo: isize = 3; //~^ ERROR: should have an uppercase name such as //~^^ ERROR: constant item is never used diff --git a/src/test/compile-fail/issue-17718-const-privacy.rs b/src/test/compile-fail/issue-17718-const-privacy.rs index d3be9f3dd3f..a9af30a3ff0 100644 --- a/src/test/compile-fail/issue-17718-const-privacy.rs +++ b/src/test/compile-fail/issue-17718-const-privacy.rs @@ -20,7 +20,7 @@ use other::{ }; mod a { - const B: uint = 3; + const B: usize = 3; } fn main() {} diff --git a/src/test/compile-fail/issue-17718-constants-not-static.rs b/src/test/compile-fail/issue-17718-constants-not-static.rs index 8c51b592054..db56d2c6cf3 100644 --- a/src/test/compile-fail/issue-17718-constants-not-static.rs +++ b/src/test/compile-fail/issue-17718-constants-not-static.rs @@ -8,9 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -const FOO: uint = 3; +const FOO: usize = 3; -fn foo() -> &'static uint { &FOO } +fn foo() -> &'static usize { &FOO } //~^ ERROR: borrowed value does not live long enough fn main() { diff --git a/src/test/compile-fail/issue-17718-patterns.rs b/src/test/compile-fail/issue-17718-patterns.rs index 01dfb1b4af9..6c4d0874703 100644 --- a/src/test/compile-fail/issue-17718-patterns.rs +++ b/src/test/compile-fail/issue-17718-patterns.rs @@ -8,12 +8,12 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -static A1: uint = 1; -static mut A2: uint = 1; -const A3: uint = 1; +static A1: usize = 1; +static mut A2: usize = 1; +const A3: usize = 1; fn main() { - match 1u { + match 1us { A1 => {} //~ ERROR: static variables cannot be referenced in a pattern A2 => {} //~ ERROR: static variables cannot be referenced in a pattern A3 => {} diff --git a/src/test/compile-fail/issue-17718-recursive.rs b/src/test/compile-fail/issue-17718-recursive.rs index a13dfe639c1..9959b0c6fc5 100644 --- a/src/test/compile-fail/issue-17718-recursive.rs +++ b/src/test/compile-fail/issue-17718-recursive.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -const A: uint = B; //~ ERROR: recursive constant -const B: uint = A; //~ ERROR: recursive constant +const A: usize = B; //~ ERROR: recursive constant +const B: usize = A; //~ ERROR: recursive constant fn main() {} diff --git a/src/test/compile-fail/issue-17718-references.rs b/src/test/compile-fail/issue-17718-references.rs index 7b272e1610c..9d8b116f569 100644 --- a/src/test/compile-fail/issue-17718-references.rs +++ b/src/test/compile-fail/issue-17718-references.rs @@ -8,21 +8,21 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -struct Struct { a: uint } +struct Struct { a: usize } -const C: uint = 1; -static S: uint = 1; +const C: usize = 1; +static S: usize = 1; -const T1: &'static uint = &C; -const T2: &'static uint = &S; //~ ERROR: constants cannot refer to other statics -static T3: &'static uint = &C; -static T4: &'static uint = &S; +const T1: &'static usize = &C; +const T2: &'static usize = &S; //~ ERROR: constants cannot refer to other statics +static T3: &'static usize = &C; +static T4: &'static usize = &S; -const T5: uint = C; -const T6: uint = S; //~ ERROR: constants cannot refer to other statics +const T5: usize = C; +const T6: usize = S; //~ ERROR: constants cannot refer to other statics //~^ cannot refer to other statics -static T7: uint = C; -static T8: uint = S; //~ ERROR: cannot refer to other statics by value +static T7: usize = C; +static T8: usize = S; //~ ERROR: cannot refer to other statics by value const T9: Struct = Struct { a: C }; const T10: Struct = Struct { a: S }; //~ ERROR: cannot refer to other statics by value diff --git a/src/test/compile-fail/issue-17718-static-sync.rs b/src/test/compile-fail/issue-17718-static-sync.rs index 147bff2e977..394a9cc69be 100644 --- a/src/test/compile-fail/issue-17718-static-sync.rs +++ b/src/test/compile-fail/issue-17718-static-sync.rs @@ -12,7 +12,7 @@ use std::marker; struct Foo { marker: marker::NoSync } -static FOO: uint = 3; +static FOO: usize = 3; static BAR: Foo = Foo { marker: marker::NoSync }; //~^ ERROR: the trait `core::marker::Sync` is not implemented diff --git a/src/test/compile-fail/issue-17800.rs b/src/test/compile-fail/issue-17800.rs index 9590ef3dab4..89611e4f3fe 100644 --- a/src/test/compile-fail/issue-17800.rs +++ b/src/test/compile-fail/issue-17800.rs @@ -14,8 +14,8 @@ enum MyOption<T> { } fn main() { - match MyOption::MySome(42i) { - MyOption::MySome { x: 42i } => (), + match MyOption::MySome(42is) { + MyOption::MySome { x: 42is } => (), //~^ ERROR `MyOption::MySome` does not name a struct or a struct variant _ => (), } diff --git a/src/test/compile-fail/issue-17913.rs b/src/test/compile-fail/issue-17913.rs index e2dbad56f84..56cd544b3c6 100644 --- a/src/test/compile-fail/issue-17913.rs +++ b/src/test/compile-fail/issue-17913.rs @@ -15,14 +15,14 @@ #[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]; + let n = 0us; + let a = box [&n; 0xF000000000000000us]; println!("{}", a[0xFFFFFFu]); } #[cfg(any(all(stage0, target_word_size = "32"), all(not(stage0), target_pointer_width = "32")))] fn main() { - let n = 0u; + let n = 0us; let a = box [&n; 0xFFFFFFFFu]; println!("{}", a[0xFFFFFFu]); } diff --git a/src/test/compile-fail/issue-17933.rs b/src/test/compile-fail/issue-17933.rs index de5a38507bc..47f8d75250d 100644 --- a/src/test/compile-fail/issue-17933.rs +++ b/src/test/compile-fail/issue-17933.rs @@ -8,10 +8,10 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -pub static X: uint = 1u; +pub static X: usize = 1us; fn main() { - match 1u { + match 1us { self::X => { }, //~^ ERROR static variables cannot be referenced in a pattern, use a `const` instead _ => { }, diff --git a/src/test/compile-fail/issue-17999.rs b/src/test/compile-fail/issue-17999.rs index e3ad2dd1b06..5726960f66a 100644 --- a/src/test/compile-fail/issue-17999.rs +++ b/src/test/compile-fail/issue-17999.rs @@ -11,7 +11,7 @@ #![deny(unused_variables)] fn main() { - for _ in range(1i, 101) { + for _ in range(1is, 101) { let x = (); //~ ERROR: unused variable: `x` match () { a => {} //~ ERROR: unused variable: `a` diff --git a/src/test/compile-fail/issue-18107.rs b/src/test/compile-fail/issue-18107.rs index b8249ebd479..83427e8aa67 100644 --- a/src/test/compile-fail/issue-18107.rs +++ b/src/test/compile-fail/issue-18107.rs @@ -16,7 +16,7 @@ fn _create_render(_: &()) -> AbstractRenderer //~^ ERROR: the trait `core::marker::Sized` is not implemented { - match 0u { + match 0us { _ => unimplemented!() } } diff --git a/src/test/compile-fail/issue-18118.rs b/src/test/compile-fail/issue-18118.rs index 4497c8088c3..129f28f1d89 100644 --- a/src/test/compile-fail/issue-18118.rs +++ b/src/test/compile-fail/issue-18118.rs @@ -9,7 +9,7 @@ // except according to those terms. pub fn main() { - static z: &'static int = { + static z: &'static isize = { let p = 3; &p //~^ ERROR cannot borrow a local variable inside a static block, define a separate static instead diff --git a/src/test/compile-fail/issue-18252.rs b/src/test/compile-fail/issue-18252.rs index 02493b96dc8..822c86d1d3e 100644 --- a/src/test/compile-fail/issue-18252.rs +++ b/src/test/compile-fail/issue-18252.rs @@ -9,9 +9,9 @@ // except according to those terms. enum Foo { - Variant { x: uint } + Variant { x: usize } } fn main() { - let f = Foo::Variant(42u); //~ ERROR uses it like a function + let f = Foo::Variant(42us); //~ ERROR uses it like a function } diff --git a/src/test/compile-fail/issue-18294.rs b/src/test/compile-fail/issue-18294.rs index ca4cf526f07..efc1ba1635c 100644 --- a/src/test/compile-fail/issue-18294.rs +++ b/src/test/compile-fail/issue-18294.rs @@ -10,6 +10,6 @@ fn main() { const X: u32 = 1; - const Y: uint = &X as *const u32 as uint; //~ ERROR E0018 + const Y: usize = &X as *const u32 as usize; //~ ERROR E0018 println!("{}", Y); } diff --git a/src/test/compile-fail/issue-18423.rs b/src/test/compile-fail/issue-18423.rs index 63b110b5579..5945a7a1c9a 100644 --- a/src/test/compile-fail/issue-18423.rs +++ b/src/test/compile-fail/issue-18423.rs @@ -11,7 +11,7 @@ // Test that `Box` cannot be used with a lifetime parameter. struct Foo<'a> { - x: Box<'a, int> //~ ERROR wrong number of lifetime parameters + x: Box<'a, isize> //~ ERROR wrong number of lifetime parameters } pub fn main() { diff --git a/src/test/compile-fail/issue-18566.rs b/src/test/compile-fail/issue-18566.rs index 0d1a1f16c2c..85dda340d19 100644 --- a/src/test/compile-fail/issue-18566.rs +++ b/src/test/compile-fail/issue-18566.rs @@ -10,25 +10,25 @@ use std::ops::Deref; -struct MyPtr<'a>(&'a mut uint); +struct MyPtr<'a>(&'a mut usize); impl<'a> Deref for MyPtr<'a> { - type Target = uint; + type Target = usize; - fn deref<'b>(&'b self) -> &'b uint { self.0 } + fn deref<'b>(&'b self) -> &'b usize { self.0 } } trait Tr { - fn poke(&self, s: &mut uint); + fn poke(&self, s: &mut usize); } -impl Tr for uint { - fn poke(&self, s: &mut uint) { +impl Tr for usize { + fn poke(&self, s: &mut usize) { *s = 2; } } fn main() { - let s = &mut 1u; + let s = &mut 1us; MyPtr(s).poke(s); //~^ ERROR cannot borrow `*s` as mutable more than once at a time diff --git a/src/test/compile-fail/issue-18783.rs b/src/test/compile-fail/issue-18783.rs index 657ef85233d..bed835d9bde 100644 --- a/src/test/compile-fail/issue-18783.rs +++ b/src/test/compile-fail/issue-18783.rs @@ -14,7 +14,7 @@ use std::cell::RefCell; fn main() { let c = RefCell::new(vec![]); - let mut y = 1u; + let mut y = 1us; c.push(box || y = 0); c.push(box || y = 0); //~^ ERROR cannot borrow `y` as mutable more than once at a time @@ -22,7 +22,7 @@ fn main() { fn ufcs() { let c = RefCell::new(vec![]); - let mut y = 1u; + let mut y = 1us; Push::push(&c, box || y = 0); Push::push(&c, box || y = 0); diff --git a/src/test/compile-fail/issue-18959.rs b/src/test/compile-fail/issue-18959.rs index 7aba1bc8e65..e174fb9b7ad 100644 --- a/src/test/compile-fail/issue-18959.rs +++ b/src/test/compile-fail/issue-18959.rs @@ -17,7 +17,7 @@ impl Foo for Thing { fn foo<T>(&self, _: &T) {} } -#[inline(never)] fn foo(b: &Bar) { b.foo(&0u) } +#[inline(never)] fn foo(b: &Bar) { b.foo(&0us) } fn main() { let mut thing = Thing; diff --git a/src/test/compile-fail/issue-19096.rs b/src/test/compile-fail/issue-19096.rs index 5d915d6a59b..7bc79463d3a 100644 --- a/src/test/compile-fail/issue-19096.rs +++ b/src/test/compile-fail/issue-19096.rs @@ -9,6 +9,6 @@ // except according to those terms. fn main() { - let t = (42i, 42i); - t.0::<int>; //~ ERROR expected one of `.`, `;`, `}`, or an operator, found `::` + let t = (42is, 42is); + t.0::<isize>; //~ ERROR expected one of `.`, `;`, `}`, or an operator, found `::` } diff --git a/src/test/compile-fail/issue-19244-1.rs b/src/test/compile-fail/issue-19244-1.rs index fafe6377397..0850705aee6 100644 --- a/src/test/compile-fail/issue-19244-1.rs +++ b/src/test/compile-fail/issue-19244-1.rs @@ -8,9 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -const TUP: (uint,) = (42,); +const TUP: (usize,) = (42,); fn main() { - let a: [int; TUP.1]; + let a: [isize; TUP.1]; //~^ ERROR expected constant expr for array length: tuple index out of bounds } diff --git a/src/test/compile-fail/issue-19244-2.rs b/src/test/compile-fail/issue-19244-2.rs index 95965ca35f9..93a3fc87eb0 100644 --- a/src/test/compile-fail/issue-19244-2.rs +++ b/src/test/compile-fail/issue-19244-2.rs @@ -8,10 +8,10 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -struct MyStruct { field: uint } +struct MyStruct { field: usize } const STRUCT: MyStruct = MyStruct { field: 42 }; fn main() { - let a: [int; STRUCT.nonexistent_field]; + let a: [isize; STRUCT.nonexistent_field]; //~^ ERROR expected constant expr for array length: nonexistent struct field } diff --git a/src/test/compile-fail/issue-1962.rs b/src/test/compile-fail/issue-1962.rs index c59ee328eff..44abfca1653 100644 --- a/src/test/compile-fail/issue-1962.rs +++ b/src/test/compile-fail/issue-1962.rs @@ -10,9 +10,9 @@ // compile-flags: -D while-true fn main() { - let mut i = 0i; + let mut i = 0is; while true { //~ ERROR denote infinite loops with loop - i += 1i; - if i == 5i { break; } + i += 1is; + if i == 5is { break; } } } diff --git a/src/test/compile-fail/issue-2111.rs b/src/test/compile-fail/issue-2111.rs index 3d9c7401ded..8180ce52bdb 100644 --- a/src/test/compile-fail/issue-2111.rs +++ b/src/test/compile-fail/issue-2111.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -fn foo(a: Option<uint>, b: Option<uint>) { +fn foo(a: Option<usize>, b: Option<usize>) { match (a,b) { //~^ ERROR: non-exhaustive patterns: `(None, None)` not covered (Some(a), Some(b)) if a == b => { } diff --git a/src/test/compile-fail/issue-2150.rs b/src/test/compile-fail/issue-2150.rs index 455cde63f27..f18db94acf3 100644 --- a/src/test/compile-fail/issue-2150.rs +++ b/src/test/compile-fail/issue-2150.rs @@ -12,10 +12,10 @@ #![allow(unused_variables)] #![allow(dead_code)] -fn fail_len(v: Vec<int> ) -> uint { +fn fail_len(v: Vec<isize> ) -> usize { let mut i = 3; panic!(); - for x in v.iter() { i += 1u; } + for x in v.iter() { i += 1us; } //~^ ERROR: unreachable statement return i; } diff --git a/src/test/compile-fail/issue-2330.rs b/src/test/compile-fail/issue-2330.rs index 6291b024053..63f146a21d9 100644 --- a/src/test/compile-fail/issue-2330.rs +++ b/src/test/compile-fail/issue-2330.rs @@ -15,8 +15,8 @@ trait channel<T> { } // `chan` is not a trait, it's an enum -impl chan for int { //~ ERROR `chan` is not a trait - fn send(&self, v: int) { panic!() } +impl chan for isize { //~ ERROR `chan` is not a trait + fn send(&self, v: isize) { panic!() } } fn main() { diff --git a/src/test/compile-fail/issue-2354-1.rs b/src/test/compile-fail/issue-2354-1.rs index 67b5c6becc7..d37837b9714 100644 --- a/src/test/compile-fail/issue-2354-1.rs +++ b/src/test/compile-fail/issue-2354-1.rs @@ -8,5 +8,5 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -static foo: int = 2; } //~ ERROR incorrect close delimiter: +static foo: isize = 2; } //~ ERROR incorrect close delimiter: diff --git a/src/test/compile-fail/issue-2356.rs b/src/test/compile-fail/issue-2356.rs index 850edd05781..f0ae0eb59f5 100644 --- a/src/test/compile-fail/issue-2356.rs +++ b/src/test/compile-fail/issue-2356.rs @@ -13,7 +13,7 @@ trait Groom { } pub struct cat { - whiskers: int, + whiskers: isize, } pub enum MaybeDog { @@ -30,7 +30,7 @@ impl MaybeDog { } impl Groom for cat { - fn shave(&self, other: uint) { + fn shave(&self, other: usize) { whiskers -= other; //~^ ERROR: unresolved name `whiskers`. Did you mean `self.whiskers`? shave(4); @@ -75,7 +75,7 @@ impl cat { //~^ ERROR: unresolved name `whiskers`. Did you mean `self.whiskers`? } - pub fn grow_older(other:uint) { + pub fn grow_older(other:usize) { whiskers = 4; //~^ ERROR: unresolved name `whiskers`. Did you mean `self.whiskers`? purr_louder(); diff --git a/src/test/compile-fail/issue-2478.rs b/src/test/compile-fail/issue-2478.rs index 860192ba3e5..3aea9c32e3a 100644 --- a/src/test/compile-fail/issue-2478.rs +++ b/src/test/compile-fail/issue-2478.rs @@ -10,8 +10,8 @@ // ignore-test -fn foo<'a>() -> &'a int { //~ ERROR unconstrained region +fn foo<'a>() -> &'a isize { //~ ERROR unconstrained region return &x; } -static x: int = 5; +static x: isize = 5; fn main() {} diff --git a/src/test/compile-fail/issue-2590.rs b/src/test/compile-fail/issue-2590.rs index 79a66e30fdb..d7e438d1049 100644 --- a/src/test/compile-fail/issue-2590.rs +++ b/src/test/compile-fail/issue-2590.rs @@ -10,16 +10,16 @@ struct parser { - tokens: Vec<int> , + tokens: Vec<isize> , } trait parse { - fn parse(&self) -> Vec<int> ; + fn parse(&self) -> Vec<isize> ; } impl parse for parser { - fn parse(&self) -> Vec<int> { - self.tokens //~ ERROR cannot move out of dereference of `&`-pointer + fn parse(&self) -> Vec<isize> { + self.tokens //~ ERROR cannot move out of borrowed content } } diff --git a/src/test/compile-fail/issue-2611-4.rs b/src/test/compile-fail/issue-2611-4.rs index 70ffa86359d..b141c1f441a 100644 --- a/src/test/compile-fail/issue-2611-4.rs +++ b/src/test/compile-fail/issue-2611-4.rs @@ -16,7 +16,7 @@ trait A { } struct E { - f: int + f: isize } impl A for E { diff --git a/src/test/compile-fail/issue-2611-5.rs b/src/test/compile-fail/issue-2611-5.rs index 2eda5d67edd..440294f38ae 100644 --- a/src/test/compile-fail/issue-2611-5.rs +++ b/src/test/compile-fail/issue-2611-5.rs @@ -16,7 +16,7 @@ trait A { } struct E { - f: int + f: isize } impl A for E { diff --git a/src/test/compile-fail/issue-2823.rs b/src/test/compile-fail/issue-2823.rs index b6820a1d8e4..1996cb737fc 100644 --- a/src/test/compile-fail/issue-2823.rs +++ b/src/test/compile-fail/issue-2823.rs @@ -9,7 +9,7 @@ // except according to those terms. struct C { - x: int, + x: isize, } impl Drop for C { diff --git a/src/test/compile-fail/issue-2849.rs b/src/test/compile-fail/issue-2849.rs index 5aaeb7e8c6d..48f4cac9711 100644 --- a/src/test/compile-fail/issue-2849.rs +++ b/src/test/compile-fail/issue-2849.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -enum foo { alpha, beta(int) } +enum foo { alpha, beta(isize) } fn main() { match foo::alpha { diff --git a/src/test/compile-fail/issue-2995.rs b/src/test/compile-fail/issue-2995.rs index 920897e6828..8fbf97411cc 100644 --- a/src/test/compile-fail/issue-2995.rs +++ b/src/test/compile-fail/issue-2995.rs @@ -8,8 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -fn bad (p: *const int) { - let _q: &int = p as ∫ //~ ERROR non-scalar cast +fn bad (p: *const isize) { + let _q: &isize = p as &isize; //~ ERROR non-scalar cast } fn main() { } diff --git a/src/test/compile-fail/issue-3038.rs b/src/test/compile-fail/issue-3038.rs index d9fe3550c9e..1eec62df788 100644 --- a/src/test/compile-fail/issue-3038.rs +++ b/src/test/compile-fail/issue-3038.rs @@ -8,12 +8,12 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -enum f { g(int, int) } +enum f { g(isize, isize) } enum h { i(j, k) } -enum j { l(int, int) } -enum k { m(int, int) } +enum j { l(isize, isize) } +enum k { m(isize, isize) } fn main() { diff --git a/src/test/compile-fail/issue-3344.rs b/src/test/compile-fail/issue-3344.rs index 27a91f891a2..73532cb768a 100644 --- a/src/test/compile-fail/issue-3344.rs +++ b/src/test/compile-fail/issue-3344.rs @@ -9,7 +9,7 @@ // except according to those terms. #[derive(PartialEq)] -struct thing(uint); +struct thing(usize); impl PartialOrd for thing { //~ ERROR not all trait items implemented, missing: `partial_cmp` fn le(&self, other: &thing) -> bool { true } fn ge(&self, other: &thing) -> bool { true } diff --git a/src/test/compile-fail/issue-3521-2.rs b/src/test/compile-fail/issue-3521-2.rs index cdfc9906776..678618d7216 100644 --- a/src/test/compile-fail/issue-3521-2.rs +++ b/src/test/compile-fail/issue-3521-2.rs @@ -11,7 +11,7 @@ fn main() { let foo = 100; - static y: int = foo + 1; //~ ERROR: attempt to use a non-constant value in a constant + static y: isize = foo + 1; //~ ERROR: attempt to use a non-constant value in a constant println!("{}", y); } diff --git a/src/test/compile-fail/issue-3668-2.rs b/src/test/compile-fail/issue-3668-2.rs index f7637f684be..0577b152723 100644 --- a/src/test/compile-fail/issue-3668-2.rs +++ b/src/test/compile-fail/issue-3668-2.rs @@ -8,8 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -fn f(x:int) { - static child: int = x + 1; //~ ERROR attempt to use a non-constant value in a constant +fn f(x:isize) { + static child: isize = x + 1; //~ ERROR attempt to use a non-constant value in a constant } fn main() {} diff --git a/src/test/compile-fail/issue-3702-2.rs b/src/test/compile-fail/issue-3702-2.rs index 1e80fd7a7e9..2b732899ea4 100644 --- a/src/test/compile-fail/issue-3702-2.rs +++ b/src/test/compile-fail/issue-3702-2.rs @@ -11,13 +11,13 @@ use std::num::ToPrimitive; trait Add { - fn to_int(&self) -> int; - fn add_dynamic(&self, other: &Add) -> int; + fn to_int(&self) -> isize; + fn add_dynamic(&self, other: &Add) -> isize; } -impl Add for int { - fn to_int(&self) -> int { *self } - fn add_dynamic(&self, other: &Add) -> int { +impl Add for isize { + fn to_int(&self) -> isize { *self } + fn add_dynamic(&self, other: &Add) -> isize { self.to_int() + other.to_int() //~ ERROR multiple applicable methods in scope } } diff --git a/src/test/compile-fail/issue-3707.rs b/src/test/compile-fail/issue-3707.rs index 2445638d62e..0aa357f2398 100644 --- a/src/test/compile-fail/issue-3707.rs +++ b/src/test/compile-fail/issue-3707.rs @@ -9,12 +9,12 @@ // except according to those terms. struct Obj { - member: uint + member: usize } impl Obj { pub fn boom() -> bool { - return 1i+1 == 2 + return 1is+1 == 2 } pub fn chirp(&self) { self.boom(); //~ ERROR `&Obj` does not implement any method in scope named `boom` @@ -24,5 +24,5 @@ impl Obj { fn main() { let o = Obj { member: 0 }; o.chirp(); - 1i + 1; + 1is + 1; } diff --git a/src/test/compile-fail/issue-3763.rs b/src/test/compile-fail/issue-3763.rs index 06939d8f358..6e6c19a5bf6 100644 --- a/src/test/compile-fail/issue-3763.rs +++ b/src/test/compile-fail/issue-3763.rs @@ -12,7 +12,7 @@ mod my_mod { pub struct MyStruct { - priv_field: int + priv_field: isize } pub fn MyStruct () -> MyStruct { MyStruct {priv_field: 4} diff --git a/src/test/compile-fail/issue-3820.rs b/src/test/compile-fail/issue-3820.rs index 06577afa6dd..28de76f18da 100644 --- a/src/test/compile-fail/issue-3820.rs +++ b/src/test/compile-fail/issue-3820.rs @@ -9,11 +9,11 @@ // except according to those terms. struct Thing { - x: int + x: isize } impl Thing { - fn mul(&self, c: &int) -> Thing { + fn mul(&self, c: &isize) -> Thing { Thing {x: self.x * *c} } } diff --git a/src/test/compile-fail/issue-3907-2.rs b/src/test/compile-fail/issue-3907-2.rs index 546b808a38f..9a166a6752b 100644 --- a/src/test/compile-fail/issue-3907-2.rs +++ b/src/test/compile-fail/issue-3907-2.rs @@ -14,7 +14,7 @@ extern crate issue_3907; type Foo = issue_3907::Foo+'static; struct S { - name: int + name: isize } fn bar(_x: Foo) {} //~ ERROR the trait `core::marker::Sized` is not implemented diff --git a/src/test/compile-fail/issue-3907.rs b/src/test/compile-fail/issue-3907.rs index a2faef59fd8..001de796b4a 100644 --- a/src/test/compile-fail/issue-3907.rs +++ b/src/test/compile-fail/issue-3907.rs @@ -14,7 +14,7 @@ extern crate issue_3907; type Foo = issue_3907::Foo; struct S { - name: int + name: isize } impl Foo for S { //~ ERROR: `Foo` is not a trait diff --git a/src/test/compile-fail/issue-3953.rs b/src/test/compile-fail/issue-3953.rs index ab2018af999..0f1dd2d7fd6 100644 --- a/src/test/compile-fail/issue-3953.rs +++ b/src/test/compile-fail/issue-3953.rs @@ -16,7 +16,7 @@ trait Hahaha: PartialEq + PartialEq { //~^ ERROR trait `PartialEq` already appears in the list of bounds } -struct Lol(int); +struct Lol(isize); impl Hahaha for Lol { } diff --git a/src/test/compile-fail/issue-4265.rs b/src/test/compile-fail/issue-4265.rs index a1a77092b12..b4bc7ecdc5f 100644 --- a/src/test/compile-fail/issue-4265.rs +++ b/src/test/compile-fail/issue-4265.rs @@ -9,7 +9,7 @@ // except according to those terms. struct Foo { - baz: uint + baz: usize } impl Foo { diff --git a/src/test/compile-fail/issue-4335.rs b/src/test/compile-fail/issue-4335.rs index f35332a2f03..292d1d9616a 100644 --- a/src/test/compile-fail/issue-4335.rs +++ b/src/test/compile-fail/issue-4335.rs @@ -18,6 +18,6 @@ fn f<'r, T>(v: &'r T) -> Box<FnMut() -> T + 'r> { } fn main() { - let v = &5i; + let v = &5is; println!("{}", f(v).call_mut(())); } diff --git a/src/test/compile-fail/issue-4366-2.rs b/src/test/compile-fail/issue-4366-2.rs index 289e9855525..e8dfac45447 100644 --- a/src/test/compile-fail/issue-4366-2.rs +++ b/src/test/compile-fail/issue-4366-2.rs @@ -18,7 +18,7 @@ mod foo { mod a { pub mod b { use foo::foo; - type bar = int; + type bar = isize; } pub mod sub { use a::b::*; diff --git a/src/test/compile-fail/issue-4366.rs b/src/test/compile-fail/issue-4366.rs index 289aa21e1cb..5625ac00c85 100644 --- a/src/test/compile-fail/issue-4366.rs +++ b/src/test/compile-fail/issue-4366.rs @@ -21,11 +21,11 @@ mod foo { mod a { pub mod b { use foo::foo; - type bar = int; + type bar = isize; } pub mod sub { use a::b::*; - fn sub() -> int { foo(); 1 } //~ ERROR: unresolved name `foo` + fn sub() -> isize { foo(); 1 } //~ ERROR: unresolved name `foo` } } diff --git a/src/test/compile-fail/issue-4935.rs b/src/test/compile-fail/issue-4935.rs index 3a0db4246be..b37b8e237ed 100644 --- a/src/test/compile-fail/issue-4935.rs +++ b/src/test/compile-fail/issue-4935.rs @@ -10,5 +10,5 @@ // Regression test for issue #4935 -fn foo(a: uint) {} +fn foo(a: usize) {} fn main() { foo(5, 6) } //~ ERROR this function takes 1 parameter but 2 parameters were supplied diff --git a/src/test/compile-fail/issue-5035.rs b/src/test/compile-fail/issue-5035.rs index 8ffe308a669..cdf9d3bd36e 100644 --- a/src/test/compile-fail/issue-5035.rs +++ b/src/test/compile-fail/issue-5035.rs @@ -10,6 +10,6 @@ trait I {} type K = I; -impl K for int {} //~ ERROR: `K` is not a trait +impl K for isize {} //~ ERROR: `K` is not a trait //~^ NOTE: `type` aliases cannot be used for traits fn main() {} diff --git a/src/test/compile-fail/issue-5153.rs b/src/test/compile-fail/issue-5153.rs index 57a158d2438..c10c7cba455 100644 --- a/src/test/compile-fail/issue-5153.rs +++ b/src/test/compile-fail/issue-5153.rs @@ -14,8 +14,8 @@ trait Foo { fn foo(self: Box<Self>); } -impl Foo for int { - fn foo(self: Box<int>) { } +impl Foo for isize { + fn foo(self: Box<isize>) { } } fn main() { diff --git a/src/test/compile-fail/issue-5358-1.rs b/src/test/compile-fail/issue-5358-1.rs index 576dfe8b67b..96bad3a6a44 100644 --- a/src/test/compile-fail/issue-5358-1.rs +++ b/src/test/compile-fail/issue-5358-1.rs @@ -9,7 +9,7 @@ // except according to those terms. enum Either<T, U> { Left(T), Right(U) } -struct S(Either<uint, uint>); +struct S(Either<usize, usize>); fn main() { match S(Either::Left(5)) { diff --git a/src/test/compile-fail/issue-5439.rs b/src/test/compile-fail/issue-5439.rs index 72074d64edc..4e618f3d858 100644 --- a/src/test/compile-fail/issue-5439.rs +++ b/src/test/compile-fail/issue-5439.rs @@ -11,15 +11,15 @@ #![feature(box_syntax)] struct Foo { - foo: int, + foo: isize, } struct Bar { - bar: int, + bar: isize, } impl Bar { - fn make_foo (&self, i: int) -> Box<Foo> { + fn make_foo (&self, i: isize) -> Box<Foo> { return box Foo { nonexistent: self, foo: i }; //~ ERROR: no field named } } diff --git a/src/test/compile-fail/issue-5500-1.rs b/src/test/compile-fail/issue-5500-1.rs index 0edcfa8a547..7e5809cdee0 100644 --- a/src/test/compile-fail/issue-5500-1.rs +++ b/src/test/compile-fail/issue-5500-1.rs @@ -9,7 +9,7 @@ // except according to those terms. struct TrieMapIterator<'a> { - node: &'a uint + node: &'a usize } fn main() { diff --git a/src/test/compile-fail/issue-5544-b.rs b/src/test/compile-fail/issue-5544-b.rs index bbe43e652a8..1f166ec0d1c 100644 --- a/src/test/compile-fail/issue-5544-b.rs +++ b/src/test/compile-fail/issue-5544-b.rs @@ -9,6 +9,6 @@ // except according to those terms. fn main() { - let _i = 0xff_ffff_ffff_ffff_ffff; + let _i = 0xff_ffff_ffff_ffff_ffff_is; //~^ ERROR int literal is too large } diff --git a/src/test/compile-fail/issue-5997-enum.rs b/src/test/compile-fail/issue-5997-enum.rs index 39e1e117cd0..ad485f2d330 100644 --- a/src/test/compile-fail/issue-5997-enum.rs +++ b/src/test/compile-fail/issue-5997-enum.rs @@ -16,6 +16,6 @@ fn f<Z>() -> bool { } fn main() { - let b = f::<int>(); + let b = f::<isize>(); assert!(b); } diff --git a/src/test/compile-fail/issue-5997-struct.rs b/src/test/compile-fail/issue-5997-struct.rs index b2a63ed1c7b..587c7c63f4c 100644 --- a/src/test/compile-fail/issue-5997-struct.rs +++ b/src/test/compile-fail/issue-5997-struct.rs @@ -16,6 +16,6 @@ fn f<T>() -> bool { } fn main() { - let b = f::<int>(); + let b = f::<isize>(); assert!(b); } diff --git a/src/test/compile-fail/issue-6702.rs b/src/test/compile-fail/issue-6702.rs index 3e35e4a659d..d035c615ec3 100644 --- a/src/test/compile-fail/issue-6702.rs +++ b/src/test/compile-fail/issue-6702.rs @@ -9,7 +9,7 @@ // except according to those terms. struct Monster { - damage: int + damage: isize } diff --git a/src/test/compile-fail/issue-6801.rs b/src/test/compile-fail/issue-6801.rs index 27230989f63..9424ff22dc7 100644 --- a/src/test/compile-fail/issue-6801.rs +++ b/src/test/compile-fail/issue-6801.rs @@ -14,16 +14,16 @@ #![feature(box_syntax)] -fn twice(x: Box<uint>) -> uint { +fn twice(x: Box<usize>) -> usize { *x * 2 } -fn invoke<F>(f: F) where F: FnOnce() -> uint { +fn invoke<F>(f: F) where F: FnOnce() -> usize { f(); } fn main() { - let x : Box<uint> = box 9; + let x : Box<usize> = box 9; let sq = |:| { *x * *x }; twice(x); //~ ERROR: cannot move out of diff --git a/src/test/compile-fail/issue-6991.rs b/src/test/compile-fail/issue-6991.rs index a5d23c70bd5..0cc5898adfc 100644 --- a/src/test/compile-fail/issue-6991.rs +++ b/src/test/compile-fail/issue-6991.rs @@ -8,8 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -static x: &'static uint = &1; -static y: uint = *x; +static x: &'static usize = &1; +static y: usize = *x; //~^ ERROR cannot refer to other statics by value, // use the address-of operator or a constant instead fn main() {} diff --git a/src/test/compile-fail/issue-7044.rs b/src/test/compile-fail/issue-7044.rs index ee332789b0e..6f9fb2e61f2 100644 --- a/src/test/compile-fail/issue-7044.rs +++ b/src/test/compile-fail/issue-7044.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -static X: int = 0; +static X: isize = 0; struct X; //~ ERROR error: duplicate definition of value `X` fn main() {} diff --git a/src/test/compile-fail/issue-7364.rs b/src/test/compile-fail/issue-7364.rs index b4df38a6aac..2e644b65402 100644 --- a/src/test/compile-fail/issue-7364.rs +++ b/src/test/compile-fail/issue-7364.rs @@ -13,7 +13,7 @@ use std::cell::RefCell; // Regresion test for issue 7364 -static boxed: Box<RefCell<int>> = box RefCell::new(0); +static boxed: Box<RefCell<isize>> = box RefCell::new(0); //~^ ERROR statics are not allowed to have custom pointers //~| ERROR: the trait `core::marker::Sync` is not implemented for the type //~| ERROR: the trait `core::marker::Sync` is not implemented for the type diff --git a/src/test/compile-fail/issue-7575.rs b/src/test/compile-fail/issue-7575.rs index 0d5156956e5..49e54f25bf6 100644 --- a/src/test/compile-fail/issue-7575.rs +++ b/src/test/compile-fail/issue-7575.rs @@ -30,17 +30,17 @@ trait UnusedTrait { impl CtxtFn for usize { fn f8(self, i: usize) -> usize { - i * 4u + i * 4us } fn f9(i: usize) -> usize { - i * 4u + i * 4us } } impl OtherTrait for usize { fn f9(i: usize) -> usize { - i * 8u + i * 8us } } diff --git a/src/test/compile-fail/issue-7607-1.rs b/src/test/compile-fail/issue-7607-1.rs index 9bf1bd2e011..48fc393d0da 100644 --- a/src/test/compile-fail/issue-7607-1.rs +++ b/src/test/compile-fail/issue-7607-1.rs @@ -11,7 +11,7 @@ // ignore-tidy-linelength struct Foo { - x: int + x: isize } impl Fo { //~ERROR inherent implementations are not allowed for types not defined in the current module diff --git a/src/test/compile-fail/issue-7607-2.rs b/src/test/compile-fail/issue-7607-2.rs index 8a7022a9a32..9541899b469 100644 --- a/src/test/compile-fail/issue-7607-2.rs +++ b/src/test/compile-fail/issue-7607-2.rs @@ -11,7 +11,7 @@ // ignore-tidy-linelength pub mod a { - pub struct Foo { a: uint } + pub struct Foo { a: usize } } pub mod b { diff --git a/src/test/compile-fail/issue-8153.rs b/src/test/compile-fail/issue-8153.rs index 2af531135ec..ea7224939ce 100644 --- a/src/test/compile-fail/issue-8153.rs +++ b/src/test/compile-fail/issue-8153.rs @@ -13,12 +13,12 @@ struct Foo; trait Bar { - fn bar(&self) -> int; + fn bar(&self) -> isize; } impl Bar for Foo { - fn bar(&self) -> int {1} - fn bar(&self) -> int {2} //~ ERROR duplicate method + fn bar(&self) -> isize {1} + fn bar(&self) -> isize {2} //~ ERROR duplicate method } fn main() { diff --git a/src/test/compile-fail/issue-9243.rs b/src/test/compile-fail/issue-9243.rs index eb3618c9f04..808aa098c5a 100644 --- a/src/test/compile-fail/issue-9243.rs +++ b/src/test/compile-fail/issue-9243.rs @@ -11,7 +11,7 @@ // Regresion test for issue 9243 struct Test { - mem: int, + mem: isize, } pub static g_test: Test = Test {mem: 0}; //~ ERROR statics are not allowed to have destructors diff --git a/src/test/compile-fail/issue-9725.rs b/src/test/compile-fail/issue-9725.rs index 9545ad43ff8..1a3c926ba38 100644 --- a/src/test/compile-fail/issue-9725.rs +++ b/src/test/compile-fail/issue-9725.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -struct A { foo: int } +struct A { foo: isize } fn main() { let A { foo, foo } = A { foo: 3 }; diff --git a/src/test/compile-fail/issue-9814.rs b/src/test/compile-fail/issue-9814.rs index d6cc493e936..8aefc5919d1 100644 --- a/src/test/compile-fail/issue-9814.rs +++ b/src/test/compile-fail/issue-9814.rs @@ -11,7 +11,7 @@ // Verify that single-variant enums cant be de-referenced // Regression test for issue #9814 -enum Foo { Bar(int) } +enum Foo { Bar(isize) } fn main() { let _ = *Foo::Bar(2); //~ ERROR type `Foo` cannot be dereferenced diff --git a/src/test/compile-fail/issue-9957.rs b/src/test/compile-fail/issue-9957.rs index 573d847cbe3..b1204e82890 100644 --- a/src/test/compile-fail/issue-9957.rs +++ b/src/test/compile-fail/issue-9957.rs @@ -11,5 +11,5 @@ pub extern crate core; //~ ERROR: `pub` visibility is not allowed fn main() { - pub use std::uint; //~ ERROR: imports in functions are never reachable + pub use std::usize; //~ ERROR: imports in functions are never reachable } diff --git a/src/test/compile-fail/keyword-super.rs b/src/test/compile-fail/keyword-super.rs index 6cbc8aa1ea6..0c94f76f1f6 100644 --- a/src/test/compile-fail/keyword-super.rs +++ b/src/test/compile-fail/keyword-super.rs @@ -9,5 +9,5 @@ // except according to those terms. fn main() { - let super: int; //~ ERROR expected identifier, found keyword `super` + let super: isize; //~ ERROR expected identifier, found keyword `super` } diff --git a/src/test/compile-fail/kindck-copy.rs b/src/test/compile-fail/kindck-copy.rs index ac088e69a28..4398be4b212 100644 --- a/src/test/compile-fail/kindck-copy.rs +++ b/src/test/compile-fail/kindck-copy.rs @@ -18,8 +18,8 @@ fn assert_copy<T:Copy>() { } trait Dummy { } struct MyStruct { - x: int, - y: int, + x: isize, + y: isize, } impl Copy for MyStruct {} @@ -28,22 +28,22 @@ struct MyNoncopyStruct { x: Box<char>, } -fn test<'a,T,U:Copy>(_: &'a int) { +fn test<'a,T,U:Copy>(_: &'a isize) { // lifetime pointers are ok... - assert_copy::<&'static int>(); - assert_copy::<&'a int>(); + assert_copy::<&'static isize>(); + assert_copy::<&'a isize>(); assert_copy::<&'a str>(); - assert_copy::<&'a [int]>(); + assert_copy::<&'a [isize]>(); // ...unless they are mutable - assert_copy::<&'static mut int>(); //~ ERROR `core::marker::Copy` is not implemented - assert_copy::<&'a mut int>(); //~ ERROR `core::marker::Copy` is not implemented + assert_copy::<&'static mut isize>(); //~ ERROR `core::marker::Copy` is not implemented + assert_copy::<&'a mut isize>(); //~ ERROR `core::marker::Copy` is not implemented // ~ pointers are not ok - assert_copy::<Box<int>>(); //~ ERROR `core::marker::Copy` is not implemented + assert_copy::<Box<isize>>(); //~ ERROR `core::marker::Copy` is not implemented assert_copy::<String>(); //~ ERROR `core::marker::Copy` is not implemented - assert_copy::<Vec<int> >(); //~ ERROR `core::marker::Copy` is not implemented - assert_copy::<Box<&'a mut int>>(); //~ ERROR `core::marker::Copy` is not implemented + assert_copy::<Vec<isize> >(); //~ ERROR `core::marker::Copy` is not implemented + assert_copy::<Box<&'a mut isize>>(); //~ ERROR `core::marker::Copy` is not implemented // borrowed object types are generally ok assert_copy::<&'a Dummy>(); @@ -58,16 +58,16 @@ fn test<'a,T,U:Copy>(_: &'a int) { assert_copy::<&'a mut (Dummy+Copy)>(); //~ ERROR `core::marker::Copy` is not implemented // unsafe ptrs are ok - assert_copy::<*const int>(); - assert_copy::<*const &'a mut int>(); + assert_copy::<*const isize>(); + assert_copy::<*const &'a mut isize>(); // regular old ints and such are ok - assert_copy::<int>(); + assert_copy::<isize>(); assert_copy::<bool>(); assert_copy::<()>(); // tuples are ok - assert_copy::<(int,int)>(); + assert_copy::<(isize,isize)>(); // structs of POD are ok assert_copy::<MyStruct>(); @@ -76,7 +76,7 @@ fn test<'a,T,U:Copy>(_: &'a int) { assert_copy::<MyNoncopyStruct>(); //~ ERROR `core::marker::Copy` is not implemented // ref counted types are not ok - assert_copy::<Rc<int>>(); //~ ERROR `core::marker::Copy` is not implemented + assert_copy::<Rc<isize>>(); //~ ERROR `core::marker::Copy` is not implemented } pub fn main() { diff --git a/src/test/compile-fail/kindck-destructor-owned.rs b/src/test/compile-fail/kindck-destructor-owned.rs index 803da617abd..7f3704144be 100644 --- a/src/test/compile-fail/kindck-destructor-owned.rs +++ b/src/test/compile-fail/kindck-destructor-owned.rs @@ -10,7 +10,7 @@ struct Bar<'a> { - f: &'a int, + f: &'a isize, } impl<'a> Drop for Bar<'a> { @@ -20,7 +20,7 @@ impl<'a> Drop for Bar<'a> { } struct Baz { - f: &'static int, + f: &'static isize, } impl Drop for Baz { 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 e188fa9b813..cd47bd721fc 100644 --- a/src/test/compile-fail/kindck-impl-type-params-2.rs +++ b/src/test/compile-fail/kindck-impl-type-params-2.rs @@ -19,7 +19,7 @@ impl<T:Copy> Foo for T { fn take_param<T:Foo>(foo: &T) { } fn main() { - let x = box 3i; + let x = box 3is; take_param(&x); //~^ ERROR the trait `core::marker::Copy` is not implemented } diff --git a/src/test/compile-fail/kindck-impl-type-params.rs b/src/test/compile-fail/kindck-impl-type-params.rs index 34e77353463..5d090689415 100644 --- a/src/test/compile-fail/kindck-impl-type-params.rs +++ b/src/test/compile-fail/kindck-impl-type-params.rs @@ -34,8 +34,8 @@ fn g<T>(val: T) { } fn foo<'a>() { - let t: S<&'a int> = S; - let a = &t as &Gettable<&'a int>; + let t: S<&'a isize> = S; + let a = &t as &Gettable<&'a isize>; //~^ ERROR declared lifetime bound not satisfied } diff --git a/src/test/compile-fail/kindck-inherited-copy-bound.rs b/src/test/compile-fail/kindck-inherited-copy-bound.rs index 192e358283f..4ccb240071d 100644 --- a/src/test/compile-fail/kindck-inherited-copy-bound.rs +++ b/src/test/compile-fail/kindck-inherited-copy-bound.rs @@ -23,12 +23,12 @@ impl<T:Copy> Foo for T { fn take_param<T:Foo>(foo: &T) { } fn a() { - let x = box 3i; + let x = box 3is; take_param(&x); //~ ERROR `core::marker::Copy` is not implemented } fn b() { - let x = box 3i; + let x = box 3is; let y = &x; let z = &x as &Foo; //~ ERROR `core::marker::Copy` is not implemented } diff --git a/src/test/compile-fail/kindck-nonsendable-1.rs b/src/test/compile-fail/kindck-nonsendable-1.rs index a13a3f7c4ab..79aec386d9a 100644 --- a/src/test/compile-fail/kindck-nonsendable-1.rs +++ b/src/test/compile-fail/kindck-nonsendable-1.rs @@ -11,12 +11,12 @@ use std::rc::Rc; -fn foo(_x: Rc<uint>) {} +fn foo(_x: Rc<usize>) {} fn bar<F:FnOnce() + Send>(_: F) { } fn main() { - let x = Rc::new(3u); + let x = Rc::new(3us); bar(move|| foo(x)); //~^ ERROR `core::marker::Send` is not implemented //~^^ ERROR `core::marker::Send` is not implemented diff --git a/src/test/compile-fail/kindck-send-owned.rs b/src/test/compile-fail/kindck-send-owned.rs index 11148d2846c..7025249fafb 100644 --- a/src/test/compile-fail/kindck-send-owned.rs +++ b/src/test/compile-fail/kindck-send-owned.rs @@ -13,13 +13,13 @@ fn assert_send<T:Send>() { } // owned content are ok -fn test30() { assert_send::<Box<int>>(); } +fn test30() { assert_send::<Box<isize>>(); } fn test31() { assert_send::<String>(); } -fn test32() { assert_send::<Vec<int> >(); } +fn test32() { assert_send::<Vec<isize> >(); } // but not if they own a bad thing -fn test40<'a>(_: &'a int) { - assert_send::<Box<&'a int>>(); //~ ERROR declared lifetime bound not satisfied +fn test40<'a>(_: &'a isize) { + assert_send::<Box<&'a isize>>(); //~ ERROR declared lifetime bound not satisfied } fn main() { } diff --git a/src/test/compile-fail/kindck-send-region-pointers.rs b/src/test/compile-fail/kindck-send-region-pointers.rs index 04172932cfe..c6987e89e3a 100644 --- a/src/test/compile-fail/kindck-send-region-pointers.rs +++ b/src/test/compile-fail/kindck-send-region-pointers.rs @@ -13,22 +13,22 @@ fn assert_send<T:Send>() { } // lifetime pointers with 'static lifetime are ok -fn test01() { assert_send::<&'static int>(); } +fn test01() { assert_send::<&'static isize>(); } fn test02() { assert_send::<&'static str>(); } -fn test03() { assert_send::<&'static [int]>(); } +fn test03() { assert_send::<&'static [isize]>(); } // whether or not they are mutable -fn test10() { assert_send::<&'static mut int>(); } +fn test10() { assert_send::<&'static mut isize>(); } // otherwise lifetime pointers are not ok -fn test20<'a>(_: &'a int) { - assert_send::<&'a int>(); //~ ERROR declared lifetime bound not satisfied +fn test20<'a>(_: &'a isize) { + assert_send::<&'a isize>(); //~ ERROR declared lifetime bound not satisfied } -fn test21<'a>(_: &'a int) { +fn test21<'a>(_: &'a isize) { assert_send::<&'a str>(); //~ ERROR declared lifetime bound not satisfied } -fn test22<'a>(_: &'a int) { - assert_send::<&'a [int]>(); //~ ERROR declared lifetime bound not satisfied +fn test22<'a>(_: &'a isize) { + assert_send::<&'a [isize]>(); //~ ERROR declared lifetime bound not satisfied } fn main() { } diff --git a/src/test/compile-fail/kindck-send-unsafe.rs b/src/test/compile-fail/kindck-send-unsafe.rs index 1bfd0d4a11f..bce765a986a 100644 --- a/src/test/compile-fail/kindck-send-unsafe.rs +++ b/src/test/compile-fail/kindck-send-unsafe.rs @@ -13,7 +13,7 @@ extern crate core; fn assert_send<T:Send>() { } fn test71<'a>() { - assert_send::<*mut &'a int>(); + assert_send::<*mut &'a isize>(); //~^ ERROR the trait `core::marker::Send` is not implemented for the type } diff --git a/src/test/compile-fail/lang-item-missing.rs b/src/test/compile-fail/lang-item-missing.rs index bcde10a0b22..793d9c77c3b 100644 --- a/src/test/compile-fail/lang-item-missing.rs +++ b/src/test/compile-fail/lang-item-missing.rs @@ -16,6 +16,6 @@ #![no_std] #[start] -fn start(argc: int, argv: *const *const u8) -> int { +fn start(argc: isize, argv: *const *const u8) -> isize { 0 } diff --git a/src/test/compile-fail/lifetime-elision-return-type-requires-explicit-lifetime.rs b/src/test/compile-fail/lifetime-elision-return-type-requires-explicit-lifetime.rs index 817582a877f..55cce016335 100644 --- a/src/test/compile-fail/lifetime-elision-return-type-requires-explicit-lifetime.rs +++ b/src/test/compile-fail/lifetime-elision-return-type-requires-explicit-lifetime.rs @@ -9,29 +9,29 @@ // except according to those terms. // Lifetime annotation needed because we have no arguments. -fn f() -> &int { //~ ERROR missing lifetime specifier +fn f() -> &isize { //~ ERROR missing lifetime specifier //~^ HELP there is no value for it to be borrowed from panic!() } // Lifetime annotation needed because we have two by-reference parameters. -fn g(_x: &int, _y: &int) -> &int { //~ ERROR missing lifetime specifier +fn g(_x: &isize, _y: &isize) -> &isize { //~ ERROR missing lifetime specifier //~^ HELP the signature does not say whether it is borrowed from `_x` or `_y` panic!() } struct Foo<'a> { - x: &'a int, + x: &'a isize, } // Lifetime annotation needed because we have two lifetimes: one as a parameter // and one on the reference. -fn h(_x: &Foo) -> &int { //~ ERROR missing lifetime specifier +fn h(_x: &Foo) -> &isize { //~ ERROR missing lifetime specifier //~^ HELP the signature does not say which one of `_x`'s 2 elided lifetimes it is borrowed from panic!() } -fn i(_x: int) -> &int { //~ ERROR missing lifetime specifier +fn i(_x: isize) -> &isize { //~ ERROR missing lifetime specifier //~^ HELP this function's return type contains a borrowed value panic!() } diff --git a/src/test/compile-fail/lifetime-inference-give-expl-lifetime-param-2.rs b/src/test/compile-fail/lifetime-inference-give-expl-lifetime-param-2.rs index 7d91b1998bf..fac518c7635 100644 --- a/src/test/compile-fail/lifetime-inference-give-expl-lifetime-param-2.rs +++ b/src/test/compile-fail/lifetime-inference-give-expl-lifetime-param-2.rs @@ -14,15 +14,15 @@ use std::iter::{Range,range}; trait Itble<'r, T, I: Iterator<Item=T>> { fn iter(&'r self) -> I; } -impl<'r> Itble<'r, uint, Range<uint>> for (uint, uint) { - fn iter(&'r self) -> Range<uint> { +impl<'r> Itble<'r, usize, Range<usize>> for (usize, usize) { + fn iter(&'r self) -> Range<usize> { let &(min, max) = self; range(min, max) } } -fn check<'r, I: Iterator<Item=uint>, T: Itble<'r, uint, I>>(cont: &T) -> bool { -//~^ HELP: consider using an explicit lifetime parameter as shown: fn check<'r, I: Iterator<Item = uint>, T: Itble<'r, uint, I>>(cont: &'r T) +fn check<'r, I: Iterator<Item=usize>, T: Itble<'r, usize, I>>(cont: &T) -> bool { +//~^ HELP: consider using an explicit lifetime parameter as shown: fn check<'r, I: Iterator<Item = usize>, T: Itble<'r, usize, I>>(cont: &'r T) let cont_iter = cont.iter(); //~ ERROR: cannot infer let result = cont_iter.fold(Some(0u16), |state, val| { state.map_or(None, |mask| { diff --git a/src/test/compile-fail/lifetime-inference-give-expl-lifetime-param-3.rs b/src/test/compile-fail/lifetime-inference-give-expl-lifetime-param-3.rs index 29265b8750c..04c5b223cb8 100644 --- a/src/test/compile-fail/lifetime-inference-give-expl-lifetime-param-3.rs +++ b/src/test/compile-fail/lifetime-inference-give-expl-lifetime-param-3.rs @@ -10,17 +10,17 @@ // ignore-tidy-linelength -struct Bar<'x, 'y, 'z> { bar: &'y int, baz: int } -fn bar1<'a>(x: &Bar) -> (&'a int, &'a int, &'a int) { -//~^ HELP: consider using an explicit lifetime parameter as shown: fn bar1<'b, 'c, 'a>(x: &'a Bar<'b, 'a, 'c>) -> (&'a int, &'a int, &'a int) +struct Bar<'x, 'y, 'z> { bar: &'y i32, baz: i32 } +fn bar1<'a>(x: &Bar) -> (&'a i32, &'a i32, &'a i32) { +//~^ HELP: consider using an explicit lifetime parameter as shown: fn bar1<'b, 'c, 'a>(x: &'a Bar<'b, 'a, 'c>) -> (&'a i32, &'a i32, &'a i32) (x.bar, &x.baz, &x.baz) //~^ ERROR: cannot infer //~^^ ERROR: cannot infer //~^^^ ERROR: cannot infer } -fn bar2<'a, 'b, 'c>(x: &Bar<'a, 'b, 'c>) -> (&'a int, &'a int, &'a int) { -//~^ HELP: consider using an explicit lifetime parameter as shown: fn bar2<'a, 'c>(x: &'a Bar<'a, 'a, 'c>) -> (&'a int, &'a int, &'a int) +fn bar2<'a, 'b, 'c>(x: &Bar<'a, 'b, 'c>) -> (&'a i32, &'a i32, &'a i32) { +//~^ HELP: consider using an explicit lifetime parameter as shown: fn bar2<'a, 'c>(x: &'a Bar<'a, 'a, 'c>) -> (&'a i32, &'a i32, &'a i32) (x.bar, &x.baz, &x.baz) //~^ ERROR: cannot infer //~^^ ERROR: cannot infer diff --git a/src/test/compile-fail/lifetime-inference-give-expl-lifetime-param.rs b/src/test/compile-fail/lifetime-inference-give-expl-lifetime-param.rs index 4abf045501c..c60e321219b 100644 --- a/src/test/compile-fail/lifetime-inference-give-expl-lifetime-param.rs +++ b/src/test/compile-fail/lifetime-inference-give-expl-lifetime-param.rs @@ -10,43 +10,43 @@ // ignore-tidy-linelength -struct Foo<'x> { bar: int } -fn foo1<'a>(x: &Foo) -> &'a int { -//~^ HELP: consider using an explicit lifetime parameter as shown: fn foo1<'a>(x: &'a Foo) -> &'a int +struct Foo<'x> { bar: isize } +fn foo1<'a>(x: &Foo) -> &'a isize { +//~^ HELP: consider using an explicit lifetime parameter as shown: fn foo1<'a>(x: &'a Foo) -> &'a isize &x.bar //~ ERROR: cannot infer } -fn foo2<'a, 'b>(x: &'a Foo) -> &'b int { -//~^ HELP: consider using an explicit lifetime parameter as shown: fn foo2<'a>(x: &'a Foo) -> &'a int +fn foo2<'a, 'b>(x: &'a Foo) -> &'b isize { +//~^ HELP: consider using an explicit lifetime parameter as shown: fn foo2<'a>(x: &'a Foo) -> &'a isize &x.bar //~ ERROR: cannot infer } -fn foo3<'a>(x: &Foo) -> (&'a int, &'a int) { -//~^ HELP: consider using an explicit lifetime parameter as shown: fn foo3<'a>(x: &'a Foo) -> (&'a int, &'a int) +fn foo3<'a>(x: &Foo) -> (&'a isize, &'a isize) { +//~^ HELP: consider using an explicit lifetime parameter as shown: fn foo3<'a>(x: &'a Foo) -> (&'a isize, &'a isize) (&x.bar, &x.bar) //~ ERROR: cannot infer //~^ ERROR: cannot infer } -fn foo4<'a, 'b>(x: &'a Foo) -> (&'b int, &'a int, &'b int) { -//~^ HELP: consider using an explicit lifetime parameter as shown: fn foo4<'a>(x: &'a Foo) -> (&'a int, &'a int, &'a int) +fn foo4<'a, 'b>(x: &'a Foo) -> (&'b isize, &'a isize, &'b isize) { +//~^ HELP: consider using an explicit lifetime parameter as shown: fn foo4<'a>(x: &'a Foo) -> (&'a isize, &'a isize, &'a isize) (&x.bar, &x.bar, &x.bar) //~ ERROR: cannot infer //~^ ERROR: cannot infer } -struct Cat<'x, T> { cat: &'x int, t: T } -struct Dog<'y> { dog: &'y int } +struct Cat<'x, T> { cat: &'x isize, t: T } +struct Dog<'y> { dog: &'y isize } -fn cat2<'x, 'y>(x: Cat<'x, Dog<'y>>) -> &'x int { -//~^ HELP: consider using an explicit lifetime parameter as shown: fn cat2<'x>(x: Cat<'x, Dog<'x>>) -> &'x int +fn cat2<'x, 'y>(x: Cat<'x, Dog<'y>>) -> &'x isize { +//~^ HELP: consider using an explicit lifetime parameter as shown: fn cat2<'x>(x: Cat<'x, Dog<'x>>) -> &'x isize x.t.dog //~ ERROR: cannot infer } struct Baz<'x> { - bar: &'x int + bar: &'x isize } impl<'a> Baz<'a> { - fn baz2<'b>(&self, x: &int) -> (&'b int, &'b int) { + fn baz2<'b>(&self, x: &isize) -> (&'b isize, &'b isize) { // The lifetime that gets assigned to `x` seems somewhat random. // I have disabled this test for the time being. --pcwalton (self.bar, x) //~ ERROR: cannot infer diff --git a/src/test/compile-fail/lifetime-no-keyword.rs b/src/test/compile-fail/lifetime-no-keyword.rs index 0ef13d73fab..8ffbcd90df8 100644 --- a/src/test/compile-fail/lifetime-no-keyword.rs +++ b/src/test/compile-fail/lifetime-no-keyword.rs @@ -8,8 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -fn foo<'a>(a: &'a int) { } -fn bar(a: &'static int) { } -fn baz(a: &'let int) { } //~ ERROR invalid lifetime name +fn foo<'a>(a: &'a isize) { } +fn bar(a: &'static isize) { } +fn baz(a: &'let isize) { } //~ ERROR invalid lifetime name fn main() { } diff --git a/src/test/compile-fail/lifetime-obsoleted-self.rs b/src/test/compile-fail/lifetime-obsoleted-self.rs index a99daaab249..766922f2f88 100644 --- a/src/test/compile-fail/lifetime-obsoleted-self.rs +++ b/src/test/compile-fail/lifetime-obsoleted-self.rs @@ -8,6 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -fn baz(a: &'self int) { } //~ ERROR invalid lifetime name: 'self is no longer a special lifetime +fn baz(a: &'self isize) { } //~ ERROR invalid lifetime name: 'self is no longer a special lifetime fn main() { } diff --git a/src/test/compile-fail/linkage1.rs b/src/test/compile-fail/linkage1.rs index a045b838d51..555cc2b9a7a 100644 --- a/src/test/compile-fail/linkage1.rs +++ b/src/test/compile-fail/linkage1.rs @@ -9,6 +9,6 @@ // except according to those terms. extern { - #[linkage = "extern_weak"] static foo: int; + #[linkage = "extern_weak"] static foo: isize; //~^ ERROR: the `linkage` attribute is experimental and not portable } diff --git a/src/test/compile-fail/linkage4.rs b/src/test/compile-fail/linkage4.rs index 8f68f3e553c..635d58e04c7 100644 --- a/src/test/compile-fail/linkage4.rs +++ b/src/test/compile-fail/linkage4.rs @@ -9,7 +9,7 @@ // except according to those terms. #[linkage = "external"] -static foo: int = 0; +static foo: isize = 0; //~^ ERROR: the `linkage` attribute is experimental and not portable fn main() {} diff --git a/src/test/compile-fail/lint-ctypes.rs b/src/test/compile-fail/lint-ctypes.rs index 1755a9a2481..801f9dfd1cf 100644 --- a/src/test/compile-fail/lint-ctypes.rs +++ b/src/test/compile-fail/lint-ctypes.rs @@ -13,10 +13,10 @@ extern crate libc; extern { - pub fn bare_type1(size: int); //~ ERROR: found rust type - pub fn bare_type2(size: uint); //~ ERROR: found rust type - pub fn ptr_type1(size: *const int); //~ ERROR: found rust type - pub fn ptr_type2(size: *const uint); //~ ERROR: found rust type + pub fn bare_type1(size: isize); //~ ERROR: found rust type + pub fn bare_type2(size: usize); //~ ERROR: found rust type + pub fn ptr_type1(size: *const isize); //~ ERROR: found rust type + pub fn ptr_type2(size: *const usize); //~ ERROR: found rust type pub fn good1(size: *const libc::c_int); pub fn good2(size: *const libc::c_uint); diff --git a/src/test/compile-fail/lint-dead-code-1.rs b/src/test/compile-fail/lint-dead-code-1.rs index 9e5f15c2721..34c79be7118 100644 --- a/src/test/compile-fail/lint-dead-code-1.rs +++ b/src/test/compile-fail/lint-dead-code-1.rs @@ -29,28 +29,28 @@ mod foo2 { pub struct Bar2; } -pub static pub_static: int = 0; -static priv_static: int = 0; //~ ERROR: static item is never used -const used_static: int = 0; -pub static used_static2: int = used_static; -const USED_STATIC: int = 0; -const STATIC_USED_IN_ENUM_DISCRIMINANT: int = 10; - -pub const pub_const: int = 0; -const priv_const: int = 0; //~ ERROR: constant item is never used -const used_const: int = 0; -pub const used_const2: int = used_const; -const USED_CONST: int = 1; -const CONST_USED_IN_ENUM_DISCRIMINANT: int = 11; +pub static pub_static: isize = 0; +static priv_static: isize = 0; //~ ERROR: static item is never used +const used_static: isize = 0; +pub static used_static2: isize = used_static; +const USED_STATIC: isize = 0; +const STATIC_USED_IN_ENUM_DISCRIMINANT: isize = 10; + +pub const pub_const: isize = 0; +const priv_const: isize = 0; //~ ERROR: constant item is never used +const used_const: isize = 0; +pub const used_const2: isize = used_const; +const USED_CONST: isize = 1; +const CONST_USED_IN_ENUM_DISCRIMINANT: isize = 11; pub type typ = *const UsedStruct4; pub struct PubStruct; struct PrivStruct; //~ ERROR: struct is never used struct UsedStruct1 { #[allow(dead_code)] - x: int + x: isize } -struct UsedStruct2(int); +struct UsedStruct2(isize); struct UsedStruct3; struct UsedStruct4; // this struct is never used directly, but its method is, so we don't want @@ -90,7 +90,7 @@ pub fn pub_fn() { let e = used_enum::foo3; SemiUsedStruct::la_la_la(); - let i = 1i; + let i = 1is; match i { USED_STATIC => (), USED_CONST => (), diff --git a/src/test/compile-fail/lint-dead-code-2.rs b/src/test/compile-fail/lint-dead-code-2.rs index c7199eec8a3..e8b85ffd69a 100644 --- a/src/test/compile-fail/lint-dead-code-2.rs +++ b/src/test/compile-fail/lint-dead-code-2.rs @@ -36,7 +36,7 @@ fn dead_fn2() {} //~ ERROR: function is never used fn used_fn() {} #[start] -fn start(_: int, _: *const *const u8) -> int { +fn start(_: isize, _: *const *const u8) -> isize { used_fn(); let foo = Foo; foo.bar2(); diff --git a/src/test/compile-fail/lint-dead-code-3.rs b/src/test/compile-fail/lint-dead-code-3.rs index 4ef76030bcc..03b89c522ce 100644 --- a/src/test/compile-fail/lint-dead-code-3.rs +++ b/src/test/compile-fail/lint-dead-code-3.rs @@ -79,12 +79,12 @@ mod inner { fn f(&self) { f(); } } - impl Trait for int {} + impl Trait for isize {} fn f() {} } pub fn foo() { - let a = &1i as &inner::Trait; + let a = &1is as &inner::Trait; a.f(); } diff --git a/src/test/compile-fail/lint-dead-code-4.rs b/src/test/compile-fail/lint-dead-code-4.rs index 21e1ab4c33e..ac8f158f8fb 100644 --- a/src/test/compile-fail/lint-dead-code-4.rs +++ b/src/test/compile-fail/lint-dead-code-4.rs @@ -17,12 +17,12 @@ extern crate libc; use std::num::Int; struct Foo { - x: uint, + x: usize, b: bool, //~ ERROR: struct field is never used marker: std::marker::NoCopy } -fn field_read(f: Foo) -> uint { +fn field_read(f: Foo) -> usize { f.x.pow(2) } @@ -30,7 +30,7 @@ enum XYZ { X, //~ ERROR variant is never used Y { //~ ERROR variant is never used a: String, - b: int //~ ERROR: struct field is never used + b: isize //~ ERROR: struct field is never used }, Z } @@ -43,7 +43,7 @@ fn field_match_in_patterns(b: XYZ) -> String { } struct Bar { - x: uint, //~ ERROR: struct field is never used + x: usize, //~ ERROR: struct field is never used b: bool, _guard: () } @@ -61,6 +61,6 @@ fn field_match_in_let(f: Bar) -> bool { fn main() { field_read(Foo { x: 1, b: false, marker: std::marker::NoCopy }); field_match_in_patterns(XYZ::Z); - field_match_in_let(Bar { x: 42u, b: true, _guard: () }); + field_match_in_let(Bar { x: 42us, b: true, _guard: () }); let _ = Baz { x: 0 }; } diff --git a/src/test/compile-fail/lint-dead-code-5.rs b/src/test/compile-fail/lint-dead-code-5.rs index d6a31c96100..04d6547d938 100644 --- a/src/test/compile-fail/lint-dead-code-5.rs +++ b/src/test/compile-fail/lint-dead-code-5.rs @@ -12,16 +12,16 @@ #![deny(dead_code)] enum Enum1 { - Variant1(int), + Variant1(isize), Variant2 //~ ERROR: variant is never used } enum Enum2 { Variant3(bool), #[allow(dead_code)] - Variant4(int), - Variant5 { _x: int }, //~ ERROR: variant is never used: `Variant5` - Variant6(int), //~ ERROR: variant is never used: `Variant6` + Variant4(isize), + Variant5 { _x: isize }, //~ ERROR: variant is never used: `Variant5` + Variant6(isize), //~ ERROR: variant is never used: `Variant6` _Variant7, } diff --git a/src/test/compile-fail/lint-directives-on-use-items-issue-10534.rs b/src/test/compile-fail/lint-directives-on-use-items-issue-10534.rs index efb28449564..18159aec708 100644 --- a/src/test/compile-fail/lint-directives-on-use-items-issue-10534.rs +++ b/src/test/compile-fail/lint-directives-on-use-items-issue-10534.rs @@ -16,7 +16,7 @@ // ignored. #[allow(dead_code)] -mod a { pub static x: int = 3; pub static y: int = 4; } +mod a { pub static x: isize = 3; pub static y: isize = 4; } mod b { use a::x; //~ ERROR: unused import diff --git a/src/test/compile-fail/lint-exceeding-bitshifts.rs b/src/test/compile-fail/lint-exceeding-bitshifts.rs index dbb65d8b7ce..91a4d0fea0a 100644 --- a/src/test/compile-fail/lint-exceeding-bitshifts.rs +++ b/src/test/compile-fail/lint-exceeding-bitshifts.rs @@ -56,7 +56,7 @@ fn main() { let n = 1u8 << (4+3); let n = 1u8 << (4+4); //~ ERROR: bitshift exceeds the type's number of bits - let n = 1i << std::int::BITS; //~ ERROR: bitshift exceeds the type's number of bits - let n = 1u << std::uint::BITS; //~ ERROR: bitshift exceeds the type's number of bits + let n = 1is << std::isize::BITS; //~ ERROR: bitshift exceeds the type's number of bits + let n = 1us << std::usize::BITS; //~ ERROR: bitshift exceeds the type's number of bits } diff --git a/src/test/compile-fail/lint-forbid-attr.rs b/src/test/compile-fail/lint-forbid-attr.rs index 92fabd6050b..d1fcf62115b 100644 --- a/src/test/compile-fail/lint-forbid-attr.rs +++ b/src/test/compile-fail/lint-forbid-attr.rs @@ -8,8 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![forbid(experimental)] +#![forbid(unstable)] -#[allow(experimental)] //~ ERROR allow(experimental) overruled by outer forbid(experimental) +#[allow(unstable)] //~ ERROR allow(unstable) overruled by outer forbid(unstable) fn main() { } diff --git a/src/test/compile-fail/lint-forbid-cmdline.rs b/src/test/compile-fail/lint-forbid-cmdline.rs index 4de84825ada..e3be0d06a35 100644 --- a/src/test/compile-fail/lint-forbid-cmdline.rs +++ b/src/test/compile-fail/lint-forbid-cmdline.rs @@ -8,8 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// compile-flags: -F experimental +// compile-flags: -F unstable -#[allow(experimental)] //~ ERROR allow(experimental) overruled by outer forbid(experimental) +#![staged_api] +#[allow(unstable)] //~ ERROR allow(unstable) overruled by outer forbid(unstable) fn main() { } diff --git a/src/test/compile-fail/lint-group-style.rs b/src/test/compile-fail/lint-group-style.rs index 63d65fc06aa..24d16bcaafc 100644 --- a/src/test/compile-fail/lint-group-style.rs +++ b/src/test/compile-fail/lint-group-style.rs @@ -24,7 +24,7 @@ mod test { mod bad { fn CamelCase() {} //~ ERROR function `CamelCase` should have a snake case name - static bad: int = 1; //~ ERROR static constant `bad` should have an uppercase name + static bad: isize = 1; //~ ERROR static constant `bad` should have an uppercase name } mod warn { diff --git a/src/test/compile-fail/lint-impl-fn.rs b/src/test/compile-fail/lint-impl-fn.rs index eaef43a9083..608aec327b6 100644 --- a/src/test/compile-fail/lint-impl-fn.rs +++ b/src/test/compile-fail/lint-impl-fn.rs @@ -11,7 +11,7 @@ #![allow(while_true)] #![allow(dead_code)] -struct A(int); +struct A(isize); impl A { fn foo(&self) { while true {} } @@ -22,7 +22,7 @@ impl A { #[deny(while_true)] mod foo { - struct B(int); + struct B(isize); impl B { fn foo(&self) { while true {} } //~ ERROR: infinite loops diff --git a/src/test/compile-fail/lint-missing-doc.rs b/src/test/compile-fail/lint-missing-doc.rs index e50f636050c..55103f10f2c 100644 --- a/src/test/compile-fail/lint-missing-doc.rs +++ b/src/test/compile-fail/lint-missing-doc.rs @@ -21,19 +21,19 @@ type Typedef = String; pub type PubTypedef = String; //~ ERROR: missing documentation struct Foo { - a: int, - b: int, + a: isize, + b: isize, } pub struct PubFoo { //~ ERROR: missing documentation - pub a: int, //~ ERROR: missing documentation - b: int, + pub a: isize, //~ ERROR: missing documentation + b: isize, } #[allow(missing_docs)] pub struct PubFoo2 { - pub a: int, - pub c: int, + pub a: isize, + pub c: isize, } mod module_no_dox {} @@ -100,15 +100,15 @@ mod a { enum Baz { BazA { - a: int, - b: int + a: isize, + b: isize }, BarB } pub enum PubBaz { //~ ERROR: missing documentation PubBazA { //~ ERROR: missing documentation - a: int, //~ ERROR: missing documentation + a: isize, //~ ERROR: missing documentation }, } @@ -117,14 +117,14 @@ pub enum PubBaz2 { /// dox PubBaz2A { /// dox - a: int, + a: isize, }, } #[allow(missing_docs)] pub enum PubBaz3 { PubBaz3A { - b: int + b: isize }, } diff --git a/src/test/compile-fail/lint-non-camel-case-types.rs b/src/test/compile-fail/lint-non-camel-case-types.rs index 6ce63e2ecdb..70d6b240985 100644 --- a/src/test/compile-fail/lint-non-camel-case-types.rs +++ b/src/test/compile-fail/lint-non-camel-case-types.rs @@ -12,7 +12,7 @@ #![allow(dead_code)] struct foo { //~ ERROR type `foo` should have a camel case name such as `Foo` - bar: int, + bar: isize, } enum foo2 { //~ ERROR type `foo2` should have a camel case name such as `Foo2` @@ -20,10 +20,10 @@ enum foo2 { //~ ERROR type `foo2` should have a camel case name such as `Foo2` } struct foo3 { //~ ERROR type `foo3` should have a camel case name such as `Foo3` - bar: int + bar: isize } -type foo4 = int; //~ ERROR type `foo4` should have a camel case name such as `Foo4` +type foo4 = isize; //~ ERROR type `foo4` should have a camel case name such as `Foo4` enum Foo5 { bar //~ ERROR variant `bar` should have a camel case name such as `Bar` @@ -36,9 +36,9 @@ fn f<ty>(_: ty) {} //~ ERROR type parameter `ty` should have a camel case name s #[repr(C)] struct foo7 { - bar: int, + bar: isize, } -type __ = int; //~ ERROR type `__` should have a camel case name such as `CamelCase` +type __ = isize; //~ ERROR type `__` should have a camel case name such as `CamelCase` fn main() { } diff --git a/src/test/compile-fail/lint-non-uppercase-statics.rs b/src/test/compile-fail/lint-non-uppercase-statics.rs index 7ff5cafd097..10475f967d7 100644 --- a/src/test/compile-fail/lint-non-uppercase-statics.rs +++ b/src/test/compile-fail/lint-non-uppercase-statics.rs @@ -11,6 +11,6 @@ #![forbid(non_upper_case_globals)] #![allow(dead_code)] -static foo: int = 1; //~ ERROR static constant `foo` should have an uppercase name such as `FOO` +static foo: isize = 1; //~ ERROR static constant `foo` should have an uppercase name such as `FOO` fn main() { } diff --git a/src/test/compile-fail/lint-output-format.rs b/src/test/compile-fail/lint-output-format.rs index 35721ee5b14..10217481bf3 100644 --- a/src/test/compile-fail/lint-output-format.rs +++ b/src/test/compile-fail/lint-output-format.rs @@ -8,14 +8,13 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// compile-flags:-F experimental -D unstable +// compile-flags:-F unstable // aux-build:lint_output_format.rs extern crate lint_output_format; //~ ERROR: use of unmarked item -use lint_output_format::{foo, bar, baz}; +use lint_output_format::{foo, bar}; fn main() { let _x = foo(); //~ WARNING #[warn(deprecated)] on by default - let _y = bar(); //~ ERROR [-F experimental] - let _z = baz(); //~ ERROR [-D unstable] + let _y = bar(); //~ ERROR [-F unstable] } diff --git a/src/test/compile-fail/lint-owned-heap-memory.rs b/src/test/compile-fail/lint-owned-heap-memory.rs index 1702cefec6d..9c68da8beaf 100644 --- a/src/test/compile-fail/lint-owned-heap-memory.rs +++ b/src/test/compile-fail/lint-owned-heap-memory.rs @@ -13,7 +13,7 @@ #![feature(box_syntax)] struct Foo { - x: Box<int> //~ ERROR type uses owned + x: Box<isize> //~ ERROR type uses owned } fn main() { diff --git a/src/test/compile-fail/lint-raw-ptr-derive.rs b/src/test/compile-fail/lint-raw-ptr-derive.rs index 3198e782df8..4320b3e7441 100644 --- a/src/test/compile-fail/lint-raw-ptr-derive.rs +++ b/src/test/compile-fail/lint-raw-ptr-derive.rs @@ -13,22 +13,22 @@ #[derive(Clone)] struct Foo { - x: *const int //~ ERROR use of `#[derive]` with a raw pointer + x: *const isize //~ ERROR use of `#[derive]` with a raw pointer } #[derive(Clone)] -struct Bar(*mut int); //~ ERROR use of `#[derive]` with a raw pointer +struct Bar(*mut isize); //~ ERROR use of `#[derive]` with a raw pointer #[derive(Clone)] enum Baz { - A(*const int), //~ ERROR use of `#[derive]` with a raw pointer - B { x: *mut int } //~ ERROR use of `#[derive]` with a raw pointer + A(*const isize), //~ ERROR use of `#[derive]` with a raw pointer + B { x: *mut isize } //~ ERROR use of `#[derive]` with a raw pointer } #[derive(Clone)] struct Buzz { - x: (*const int, //~ ERROR use of `#[derive]` with a raw pointer - *const uint) //~ ERROR use of `#[derive]` with a raw pointer + x: (*const isize, //~ ERROR use of `#[derive]` with a raw pointer + *const usize) //~ ERROR use of `#[derive]` with a raw pointer } fn main() {} diff --git a/src/test/compile-fail/lint-shorthand-field.rs b/src/test/compile-fail/lint-shorthand-field.rs index eb4da4d66f3..97a976a493f 100644 --- a/src/test/compile-fail/lint-shorthand-field.rs +++ b/src/test/compile-fail/lint-shorthand-field.rs @@ -12,8 +12,8 @@ #![deny(non_shorthand_field_patterns)] struct Foo { - x: int, - y: int, + x: isize, + y: isize, } fn main() { @@ -30,7 +30,7 @@ fn main() { } { - const x: int = 1; + const x: isize = 1; match (Foo { x: 1, y: 1 }) { Foo { x: x, ..} => {}, diff --git a/src/test/compile-fail/lint-stability.rs b/src/test/compile-fail/lint-stability.rs index 0e24269ec44..eab5e98d68f 100644 --- a/src/test/compile-fail/lint-stability.rs +++ b/src/test/compile-fail/lint-stability.rs @@ -15,15 +15,16 @@ #![deny(unstable)] #![deny(deprecated)] -#![deny(experimental)] +#![deny(unstable)] #![allow(dead_code)] +#![staged_api] #[macro_use] extern crate lint_stability; //~ ERROR: use of unmarked item mod cross_crate { extern crate stability_cfg1; - extern crate stability_cfg2; //~ ERROR: use of experimental item + extern crate stability_cfg2; //~ ERROR: use of unstable item use lint_stability::*; @@ -38,13 +39,13 @@ mod cross_crate { foo.method_deprecated_text(); //~ ERROR use of deprecated item: text foo.trait_deprecated_text(); //~ ERROR use of deprecated item: text - experimental(); //~ ERROR use of experimental item - foo.method_experimental(); //~ ERROR use of experimental item - foo.trait_experimental(); //~ ERROR use of experimental item + experimental(); //~ ERROR use of unstable item + foo.method_experimental(); //~ ERROR use of unstable item + foo.trait_experimental(); //~ ERROR use of unstable item - experimental_text(); //~ ERROR use of experimental item: text - foo.method_experimental_text(); //~ ERROR use of experimental item: text - foo.trait_experimental_text(); //~ ERROR use of experimental item: text + experimental_text(); //~ ERROR use of unstable item: text + foo.method_experimental_text(); //~ ERROR use of unstable item: text + foo.trait_experimental_text(); //~ ERROR use of unstable item: text unstable(); //~ ERROR use of unstable item foo.method_unstable(); //~ ERROR use of unstable item @@ -83,7 +84,7 @@ mod cross_crate { foo.trait_locked_text(); let _ = DeprecatedStruct { i: 0 }; //~ ERROR use of deprecated item - let _ = ExperimentalStruct { i: 0 }; //~ ERROR use of experimental item + let _ = ExperimentalStruct { i: 0 }; //~ ERROR use of unstable item let _ = UnstableStruct { i: 0 }; //~ ERROR use of unstable item let _ = UnmarkedStruct { i: 0 }; //~ ERROR use of unmarked item let _ = StableStruct { i: 0 }; @@ -91,7 +92,7 @@ mod cross_crate { let _ = LockedStruct { i: 0 }; let _ = DeprecatedUnitStruct; //~ ERROR use of deprecated item - let _ = ExperimentalUnitStruct; //~ ERROR use of experimental item + let _ = ExperimentalUnitStruct; //~ ERROR use of unstable item let _ = UnstableUnitStruct; //~ ERROR use of unstable item let _ = UnmarkedUnitStruct; //~ ERROR use of unmarked item let _ = StableUnitStruct; @@ -99,7 +100,7 @@ mod cross_crate { let _ = LockedUnitStruct; let _ = Enum::DeprecatedVariant; //~ ERROR use of deprecated item - let _ = Enum::ExperimentalVariant; //~ ERROR use of experimental item + let _ = Enum::ExperimentalVariant; //~ ERROR use of unstable item let _ = Enum::UnstableVariant; //~ ERROR use of unstable item let _ = Enum::UnmarkedVariant; //~ ERROR use of unmarked item let _ = Enum::StableVariant; @@ -107,7 +108,7 @@ mod cross_crate { let _ = Enum::LockedVariant; let _ = DeprecatedTupleStruct (1); //~ ERROR use of deprecated item - let _ = ExperimentalTupleStruct (1); //~ ERROR use of experimental item + let _ = ExperimentalTupleStruct (1); //~ ERROR use of unstable item let _ = UnstableTupleStruct (1); //~ ERROR use of unstable item let _ = UnmarkedTupleStruct (1); //~ ERROR use of unmarked item let _ = StableTupleStruct (1); @@ -128,8 +129,8 @@ mod cross_crate { fn test_method_param<F: Trait>(foo: F) { foo.trait_deprecated(); //~ ERROR use of deprecated item foo.trait_deprecated_text(); //~ ERROR use of deprecated item: text - foo.trait_experimental(); //~ ERROR use of experimental item - foo.trait_experimental_text(); //~ ERROR use of experimental item: text + foo.trait_experimental(); //~ ERROR use of unstable item + foo.trait_experimental_text(); //~ ERROR use of unstable item: text foo.trait_unstable(); //~ ERROR use of unstable item foo.trait_unstable_text(); //~ ERROR use of unstable item: text foo.trait_unmarked(); //~ ERROR use of unmarked item @@ -139,8 +140,8 @@ mod cross_crate { fn test_method_object(foo: &Trait) { foo.trait_deprecated(); //~ ERROR use of deprecated item foo.trait_deprecated_text(); //~ ERROR use of deprecated item: text - foo.trait_experimental(); //~ ERROR use of experimental item - foo.trait_experimental_text(); //~ ERROR use of experimental item: text + foo.trait_experimental(); //~ ERROR use of unstable item + foo.trait_experimental_text(); //~ ERROR use of unstable item: text foo.trait_unstable(); //~ ERROR use of unstable item foo.trait_unstable_text(); //~ ERROR use of unstable item: text foo.trait_unmarked(); //~ ERROR use of unmarked item @@ -149,33 +150,33 @@ mod cross_crate { struct S; - impl ExperimentalTrait for S { } //~ ERROR use of experimental item + impl ExperimentalTrait for S { } //~ ERROR use of unstable item - trait LocalTrait : ExperimentalTrait { } //~ ERROR use of experimental item + trait LocalTrait : ExperimentalTrait { } //~ ERROR use of unstable item } mod inheritance { - extern crate inherited_stability; //~ ERROR: use of experimental item + extern crate inherited_stability; //~ ERROR: use of unstable item use self::inherited_stability::*; fn test_inheritance() { - experimental(); //~ ERROR use of experimental item + experimental(); //~ ERROR use of unstable item stable(); - stable_mod::experimental(); //~ ERROR use of experimental item + stable_mod::experimental(); //~ ERROR use of unstable item stable_mod::stable(); - unstable_mod::experimental(); //~ ERROR use of experimental item + unstable_mod::experimental(); //~ ERROR use of unstable item unstable_mod::unstable(); //~ ERROR use of unstable item - experimental_mod::experimental(); //~ ERROR use of experimental item + experimental_mod::experimental(); //~ ERROR use of unstable item experimental_mod::stable(); - let _ = Experimental::ExperimentalVariant; //~ ERROR use of experimental item + let _ = Experimental::ExperimentalVariant; //~ ERROR use of unstable item let _ = Experimental::StableVariant; - let x: uint = 0; - x.experimental(); //~ ERROR use of experimental item + let x: usize = 0; + x.experimental(); //~ ERROR use of unstable item x.stable(); } } @@ -186,9 +187,9 @@ mod this_crate { #[deprecated="text"] pub fn deprecated_text() {} - #[experimental] + #[unstable] pub fn experimental() {} - #[experimental="text"] + #[unstable="text"] pub fn experimental_text() {} #[unstable] @@ -222,9 +223,9 @@ mod this_crate { #[deprecated="text"] pub fn method_deprecated_text(&self) {} - #[experimental] + #[unstable] pub fn method_experimental(&self) {} - #[experimental="text"] + #[unstable="text"] pub fn method_experimental_text(&self) {} #[unstable] @@ -256,9 +257,9 @@ mod this_crate { #[deprecated="text"] fn trait_deprecated_text(&self) {} - #[experimental] + #[unstable] fn trait_experimental(&self) {} - #[experimental="text"] + #[unstable="text"] fn trait_experimental_text(&self) {} #[unstable] @@ -287,22 +288,22 @@ mod this_crate { impl Trait for MethodTester {} #[deprecated] - pub struct DeprecatedStruct { i: int } - #[experimental] - pub struct ExperimentalStruct { i: int } + pub struct DeprecatedStruct { i: isize } + #[unstable] + pub struct ExperimentalStruct { i: isize } #[unstable] - pub struct UnstableStruct { i: int } - pub struct UnmarkedStruct { i: int } + pub struct UnstableStruct { i: isize } + pub struct UnmarkedStruct { i: isize } #[stable] - pub struct StableStruct { i: int } + pub struct StableStruct { i: isize } #[frozen] - pub struct FrozenStruct { i: int } + pub struct FrozenStruct { i: isize } #[locked] - pub struct LockedStruct { i: int } + pub struct LockedStruct { i: isize } #[deprecated] pub struct DeprecatedUnitStruct; - #[experimental] + #[unstable] pub struct ExperimentalUnitStruct; #[unstable] pub struct UnstableUnitStruct; @@ -317,7 +318,7 @@ mod this_crate { pub enum Enum { #[deprecated] DeprecatedVariant, - #[experimental] + #[unstable] ExperimentalVariant, #[unstable] UnstableVariant, @@ -332,18 +333,18 @@ mod this_crate { } #[deprecated] - pub struct DeprecatedTupleStruct(int); - #[experimental] - pub struct ExperimentalTupleStruct(int); + pub struct DeprecatedTupleStruct(isize); + #[unstable] + pub struct ExperimentalTupleStruct(isize); #[unstable] - pub struct UnstableTupleStruct(int); - pub struct UnmarkedTupleStruct(int); + pub struct UnstableTupleStruct(isize); + pub struct UnmarkedTupleStruct(isize); #[stable] - pub struct StableTupleStruct(int); + pub struct StableTupleStruct(isize); #[frozen] - pub struct FrozenTupleStruct(int); + pub struct FrozenTupleStruct(isize); #[locked] - pub struct LockedTupleStruct(int); + pub struct LockedTupleStruct(isize); fn test() { // Only the deprecated cases of the following should generate diff --git a/src/test/compile-fail/lint-type-limits.rs b/src/test/compile-fail/lint-type-limits.rs index 67ef9cd0680..a2bc464ac49 100644 --- a/src/test/compile-fail/lint-type-limits.rs +++ b/src/test/compile-fail/lint-type-limits.rs @@ -14,7 +14,7 @@ fn main() { } fn foo() { - let mut i = 100u; + let mut i = 100us; while i >= 0 { //~ ERROR comparison is useless due to type limits i -= 1; } @@ -50,12 +50,12 @@ fn qux() { } fn quy() { - let i = -23u; //~ WARNING negation of unsigned int literal may be unintentional + let i = -23us; //~ WARNING negation of unsigned int literal may be unintentional //~^ WARNING unused variable } fn quz() { - let i = 23u; + let i = 23us; let j = -i; //~ WARNING negation of unsigned int variable may be unintentional //~^ WARNING unused variable } diff --git a/src/test/compile-fail/lint-unnecessary-parens.rs b/src/test/compile-fail/lint-unnecessary-parens.rs index 1c7a2d7e9d5..4ccc3d8b641 100644 --- a/src/test/compile-fail/lint-unnecessary-parens.rs +++ b/src/test/compile-fail/lint-unnecessary-parens.rs @@ -16,8 +16,8 @@ impl X { fn foo(&self) -> bool { self.y } } -fn foo() -> int { - return (1i); //~ ERROR unnecessary parentheses around `return` value +fn foo() -> isize { + return (1is); //~ ERROR unnecessary parentheses around `return` value } fn bar() -> X { return (X { y: true }); //~ ERROR unnecessary parentheses around `return` value @@ -32,8 +32,8 @@ fn main() { match (true) { //~ ERROR unnecessary parentheses around `match` head expression _ => {} } - if let 1i = (1i) {} //~ ERROR unnecessary parentheses around `if let` head expression - while let 1i = (2i) {} //~ ERROR unnecessary parentheses around `while let` head expression + if let 1is = (1is) {} //~ ERROR unnecessary parentheses around `if let` head expression + while let 1is = (2is) {} //~ ERROR unnecessary parentheses around `while let` head expression let v = X { y: false }; // struct lits needs parens, so these shouldn't warn. if (v == X { y: true }) {} @@ -47,7 +47,7 @@ fn main() { _ => {} } - let mut _a = (0i); //~ ERROR unnecessary parentheses around assigned value - _a = (0i); //~ ERROR unnecessary parentheses around assigned value - _a += (1i); //~ ERROR unnecessary parentheses around assigned value + let mut _a = (0is); //~ ERROR unnecessary parentheses around assigned value + _a = (0is); //~ ERROR unnecessary parentheses around assigned value + _a += (1is); //~ ERROR unnecessary parentheses around assigned value } diff --git a/src/test/compile-fail/lint-unused-extern-crate.rs b/src/test/compile-fail/lint-unused-extern-crate.rs index a77de551f5d..c9d34d40479 100644 --- a/src/test/compile-fail/lint-unused-extern-crate.rs +++ b/src/test/compile-fail/lint-unused-extern-crate.rs @@ -28,6 +28,6 @@ use rand::isaac::IsaacRng; use other::*; fn main() { - let x: collecs::vec::Vec<uint> = Vec::new(); + let x: collecs::vec::Vec<usize> = Vec::new(); let y = foo(); } diff --git a/src/test/compile-fail/lint-unused-imports.rs b/src/test/compile-fail/lint-unused-imports.rs index b5c0dce6e53..84d7200314f 100644 --- a/src/test/compile-fail/lint-unused-imports.rs +++ b/src/test/compile-fail/lint-unused-imports.rs @@ -43,8 +43,8 @@ mod test { } mod foo { - pub struct Point{pub x: int, pub y: int} - pub struct Square{pub p: Point, pub h: uint, pub w: uint} + pub struct Point{pub x: isize, pub y: isize} + pub struct Square{pub p: Point, pub h: usize, pub w: usize} } mod bar { @@ -54,7 +54,7 @@ mod bar { pub mod c { use foo::Point; use foo::Square; //~ ERROR unused import - pub fn cc(p: Point) -> int { return 2i * (p.x + p.y); } + pub fn cc(p: Point) -> isize { return 2is * (p.x + p.y); } } #[allow(unused_imports)] @@ -65,8 +65,8 @@ mod bar { fn main() { cal(foo::Point{x:3, y:9}); - let mut a = 3i; - let mut b = 4i; + let mut a = 3is; + let mut b = 4is; swap(&mut a, &mut b); test::C.b(); let _a = foo(); diff --git a/src/test/compile-fail/lint-unused-mut-variables.rs b/src/test/compile-fail/lint-unused-mut-variables.rs index 7513e1bc21a..501eea770d8 100644 --- a/src/test/compile-fail/lint-unused-mut-variables.rs +++ b/src/test/compile-fail/lint-unused-mut-variables.rs @@ -18,16 +18,16 @@ fn main() { // negative cases - let mut a = 3i; //~ ERROR: variable does not need to be mutable - let mut a = 2i; //~ ERROR: variable does not need to be mutable - let mut b = 3i; //~ ERROR: variable does not need to be mutable - let mut a = vec!(3i); //~ ERROR: variable does not need to be mutable - let (mut a, b) = (1i, 2i); //~ ERROR: variable does not need to be mutable + let mut a = 3is; //~ ERROR: variable does not need to be mutable + let mut a = 2is; //~ ERROR: variable does not need to be mutable + let mut b = 3is; //~ ERROR: variable does not need to be mutable + let mut a = vec!(3is); //~ ERROR: variable does not need to be mutable + let (mut a, b) = (1is, 2is); //~ ERROR: variable does not need to be mutable - match 30i { + match 30is { mut x => {} //~ ERROR: variable does not need to be mutable } - match (30i, 2i) { + match (30is, 2is) { (mut x, 1) | //~ ERROR: variable does not need to be mutable (mut x, 2) | (mut x, 3) => { @@ -35,28 +35,28 @@ fn main() { _ => {} } - let x = |&: mut y: int| 10i; //~ ERROR: variable does not need to be mutable - fn what(mut foo: int) {} //~ ERROR: variable does not need to be mutable + let x = |&: mut y: isize| 10is; //~ ERROR: variable does not need to be mutable + fn what(mut foo: isize) {} //~ ERROR: variable does not need to be mutable // positive cases - let mut a = 2i; - a = 3i; + let mut a = 2is; + a = 3is; let mut a = Vec::new(); - a.push(3i); + a.push(3is); let mut a = Vec::new(); callback(|| { - a.push(3i); + a.push(3is); }); - let (mut a, b) = (1i, 2i); + let (mut a, b) = (1is, 2is); a = 34; - match 30i { + match 30is { mut x => { - x = 21i; + x = 21is; } } - match (30i, 2i) { + match (30is, 2is) { (mut x, 1) | (mut x, 2) | (mut x, 3) => { @@ -65,19 +65,19 @@ fn main() { _ => {} } - let x = |&mut: mut y: int| y = 32i; - fn nothing(mut foo: int) { foo = 37i; } + let x = |&mut: mut y: isize| y = 32is; + fn nothing(mut foo: isize) { foo = 37is; } // leading underscore should avoid the warning, just like the // unused variable lint. - let mut _allowed = 1i; + let mut _allowed = 1is; } fn callback<F>(f: F) where F: FnOnce() {} // make sure the lint attribute can be turned off #[allow(unused_mut)] -fn foo(mut a: int) { - let mut a = 3i; - let mut b = vec!(2i); +fn foo(mut a: isize) { + let mut a = 3is; + let mut b = vec!(2is); } diff --git a/src/test/compile-fail/lint-uppercase-variables.rs b/src/test/compile-fail/lint-uppercase-variables.rs index b6eda8635c2..9317e465a7a 100644 --- a/src/test/compile-fail/lint-uppercase-variables.rs +++ b/src/test/compile-fail/lint-uppercase-variables.rs @@ -17,15 +17,15 @@ use std::io::File; use std::io::IoError; struct Something { - X: uint //~ ERROR structure field `X` should have a snake case name such as `x` + X: usize //~ ERROR structure field `X` should have a snake case name such as `x` } -fn test(Xx: uint) { //~ ERROR variable `Xx` should have a snake case name such as `xx` +fn test(Xx: usize) { //~ ERROR variable `Xx` should have a snake case name such as `xx` println!("{}", Xx); } fn main() { - let Test: uint = 0; //~ ERROR variable `Test` should have a snake case name such as `test` + let Test: usize = 0; //~ ERROR variable `Test` should have a snake case name such as `test` println!("{}", Test); let mut f = File::open(&Path::new("something.txt")); diff --git a/src/test/compile-fail/lint-visible-private-types.rs b/src/test/compile-fail/lint-visible-private-types.rs index 373bcb1f859..8cf375f80fb 100644 --- a/src/test/compile-fail/lint-visible-private-types.rs +++ b/src/test/compile-fail/lint-visible-private-types.rs @@ -15,108 +15,108 @@ struct Private<T>; pub struct Public<T>; -impl Private<Public<int>> { - pub fn a(&self) -> Private<int> { panic!() } - fn b(&self) -> Private<int> { panic!() } +impl Private<Public<isize>> { + pub fn a(&self) -> Private<isize> { panic!() } + fn b(&self) -> Private<isize> { panic!() } - pub fn c() -> Private<int> { panic!() } - fn d() -> Private<int> { panic!() } + pub fn c() -> Private<isize> { panic!() } + fn d() -> Private<isize> { panic!() } } -impl Private<int> { - pub fn e(&self) -> Private<int> { panic!() } - fn f(&self) -> Private<int> { panic!() } +impl Private<isize> { + pub fn e(&self) -> Private<isize> { panic!() } + fn f(&self) -> Private<isize> { panic!() } } -impl Public<Private<int>> { - pub fn a(&self) -> Private<int> { panic!() } - fn b(&self) -> Private<int> { panic!() } +impl Public<Private<isize>> { + pub fn a(&self) -> Private<isize> { panic!() } + fn b(&self) -> Private<isize> { panic!() } - pub fn c() -> Private<int> { panic!() } //~ ERROR private type in exported type signature - fn d() -> Private<int> { panic!() } + pub fn c() -> Private<isize> { panic!() } //~ ERROR private type in exported type signature + fn d() -> Private<isize> { panic!() } } -impl Public<int> { - pub fn e(&self) -> Private<int> { panic!() } //~ ERROR private type in exported type signature - fn f(&self) -> Private<int> { panic!() } +impl Public<isize> { + pub fn e(&self) -> Private<isize> { panic!() } //~ ERROR private type in exported type signature + fn f(&self) -> Private<isize> { panic!() } } -pub fn x(_: Private<int>) {} //~ ERROR private type in exported type signature +pub fn x(_: Private<isize>) {} //~ ERROR private type in exported type signature -fn y(_: Private<int>) {} +fn y(_: Private<isize>) {} pub struct Foo { - pub x: Private<int>, //~ ERROR private type in exported type signature - y: Private<int> + pub x: Private<isize>, //~ ERROR private type in exported type signature + y: Private<isize> } struct Bar { - x: Private<int>, + x: Private<isize>, } pub enum Baz { - Baz1(Private<int>), //~ ERROR private type in exported type signature + Baz1(Private<isize>), //~ ERROR private type in exported type signature Baz2 { - y: Private<int> //~ ERROR private type in exported type signature + y: Private<isize> //~ ERROR private type in exported type signature }, } enum Qux { - Qux1(Private<int>), + Qux1(Private<isize>), Qux2 { - x: Private<int>, + x: Private<isize>, } } pub trait PubTrait { - fn foo(&self) -> Private<int> { panic!( )} //~ ERROR private type in exported type signature - fn bar(&self) -> Private<int>; //~ ERROR private type in exported type signature - fn baz() -> Private<int>; //~ ERROR private type in exported type signature + fn foo(&self) -> Private<isize> { panic!( )} //~ ERROR private type in exported type signature + fn bar(&self) -> Private<isize>; //~ ERROR private type in exported type signature + fn baz() -> Private<isize>; //~ ERROR private type in exported type signature } -impl PubTrait for Public<int> { - fn bar(&self) -> Private<int> { panic!() } - fn baz() -> Private<int> { panic!() } +impl PubTrait for Public<isize> { + fn bar(&self) -> Private<isize> { panic!() } + fn baz() -> Private<isize> { panic!() } } -impl PubTrait for Public<Private<int>> { - fn bar(&self) -> Private<int> { panic!() } - fn baz() -> Private<int> { panic!() } +impl PubTrait for Public<Private<isize>> { + fn bar(&self) -> Private<isize> { panic!() } + fn baz() -> Private<isize> { panic!() } } -impl PubTrait for Private<int> { - fn bar(&self) -> Private<int> { panic!() } - fn baz() -> Private<int> { panic!() } +impl PubTrait for Private<isize> { + fn bar(&self) -> Private<isize> { panic!() } + fn baz() -> Private<isize> { panic!() } } -impl PubTrait for (Private<int>,) { - fn bar(&self) -> Private<int> { panic!() } - fn baz() -> Private<int> { panic!() } +impl PubTrait for (Private<isize>,) { + fn bar(&self) -> Private<isize> { panic!() } + fn baz() -> Private<isize> { panic!() } } trait PrivTrait { - fn foo(&self) -> Private<int> { panic!( )} - fn bar(&self) -> Private<int>; + fn foo(&self) -> Private<isize> { panic!( )} + fn bar(&self) -> Private<isize>; } -impl PrivTrait for Private<int> { - fn bar(&self) -> Private<int> { panic!() } +impl PrivTrait for Private<isize> { + fn bar(&self) -> Private<isize> { panic!() } } -impl PrivTrait for (Private<int>,) { - fn bar(&self) -> Private<int> { panic!() } +impl PrivTrait for (Private<isize>,) { + fn bar(&self) -> Private<isize> { panic!() } } pub trait ParamTrait<T> { fn foo() -> T; } -impl ParamTrait<Private<int>> //~ ERROR private type in exported type signature - for Public<int> { - fn foo() -> Private<int> { panic!() } +impl ParamTrait<Private<isize>> //~ ERROR private type in exported type signature + for Public<isize> { + fn foo() -> Private<isize> { panic!() } } -impl ParamTrait<Private<int>> for Private<int> { - fn foo() -> Private<int> { panic!( )} +impl ParamTrait<Private<isize>> for Private<isize> { + fn foo() -> Private<isize> { panic!( )} } -impl<T: ParamTrait<Private<int>>> //~ ERROR private type in exported type signature +impl<T: ParamTrait<Private<isize>>> //~ ERROR private type in exported type signature ParamTrait<T> for Public<i8> { fn foo() -> T { panic!() } } diff --git a/src/test/compile-fail/liveness-assign-imm-local-in-loop.rs b/src/test/compile-fail/liveness-assign-imm-local-in-loop.rs index f8afc10c49b..f50a9345106 100644 --- a/src/test/compile-fail/liveness-assign-imm-local-in-loop.rs +++ b/src/test/compile-fail/liveness-assign-imm-local-in-loop.rs @@ -9,7 +9,7 @@ // except according to those terms. fn test() { - let v: int; + let v: isize; loop { v = 1; //~ ERROR re-assignment of immutable variable //~^ NOTE prior assignment occurs here diff --git a/src/test/compile-fail/liveness-assign-imm-local-in-op-eq.rs b/src/test/compile-fail/liveness-assign-imm-local-in-op-eq.rs index 43d7ca83753..df57bb9e441 100644 --- a/src/test/compile-fail/liveness-assign-imm-local-in-op-eq.rs +++ b/src/test/compile-fail/liveness-assign-imm-local-in-op-eq.rs @@ -9,7 +9,7 @@ // except according to those terms. fn test() { - let v: int; + let v: isize; v = 2; //~ NOTE prior assignment occurs here v += 1; //~ ERROR re-assignment of immutable variable v.clone(); diff --git a/src/test/compile-fail/liveness-assign-imm-local-with-init.rs b/src/test/compile-fail/liveness-assign-imm-local-with-init.rs index 8eb84525b83..28218bff60d 100644 --- a/src/test/compile-fail/liveness-assign-imm-local-with-init.rs +++ b/src/test/compile-fail/liveness-assign-imm-local-with-init.rs @@ -9,7 +9,7 @@ // except according to those terms. fn test() { - let v: int = 1; //~ NOTE prior assignment occurs here + let v: isize = 1; //~ NOTE prior assignment occurs here v.clone(); v = 2; //~ ERROR re-assignment of immutable variable v.clone(); diff --git a/src/test/compile-fail/liveness-bad-bang-2.rs b/src/test/compile-fail/liveness-bad-bang-2.rs index 04364e4e010..bb049175594 100644 --- a/src/test/compile-fail/liveness-bad-bang-2.rs +++ b/src/test/compile-fail/liveness-bad-bang-2.rs @@ -10,8 +10,8 @@ // Tests that a function with a ! annotation always actually fails -fn bad_bang(i: uint) -> ! { //~ ERROR computation may converge in a function marked as diverging - println!("{}", 3i); +fn bad_bang(i: usize) -> ! { //~ ERROR computation may converge in a function marked as diverging + println!("{}", 3is); } -fn main() { bad_bang(5u); } +fn main() { bad_bang(5us); } diff --git a/src/test/compile-fail/liveness-closure-require-ret.rs b/src/test/compile-fail/liveness-closure-require-ret.rs index 82de02f0981..17cd8231222 100644 --- a/src/test/compile-fail/liveness-closure-require-ret.rs +++ b/src/test/compile-fail/liveness-closure-require-ret.rs @@ -8,5 +8,5 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -fn force<F>(f: F) -> int where F: FnOnce() -> int { f() } +fn force<F>(f: F) -> isize where F: FnOnce() -> isize { f() } fn main() { println!("{}", force(|| {})); } //~ ERROR mismatched types diff --git a/src/test/compile-fail/liveness-dead.rs b/src/test/compile-fail/liveness-dead.rs index 18baf7a9c3f..dc7b0fc4fd0 100644 --- a/src/test/compile-fail/liveness-dead.rs +++ b/src/test/compile-fail/liveness-dead.rs @@ -11,18 +11,18 @@ #![allow(dead_code)] #![deny(unused_assignments)] -fn f1(x: &mut int) { +fn f1(x: &mut isize) { *x = 1; // no error } fn f2() { - let mut x: int = 3; //~ ERROR: value assigned to `x` is never read + let mut x: isize = 3; //~ ERROR: value assigned to `x` is never read x = 4; x.clone(); } fn f3() { - let mut x: int = 3; + let mut x: isize = 3; x.clone(); x = 4; //~ ERROR: value assigned to `x` is never read } diff --git a/src/test/compile-fail/liveness-forgot-ret.rs b/src/test/compile-fail/liveness-forgot-ret.rs index 305cbcad738..e08515e40af 100644 --- a/src/test/compile-fail/liveness-forgot-ret.rs +++ b/src/test/compile-fail/liveness-forgot-ret.rs @@ -10,8 +10,8 @@ // error-pattern: not all control paths return a value -fn god_exists(a: int) -> bool { return god_exists(a); } +fn god_exists(a: isize) -> bool { return god_exists(a); } -fn f(a: int) -> int { if god_exists(a) { return 5; }; } +fn f(a: isize) -> isize { if god_exists(a) { return 5; }; } fn main() { f(12); } diff --git a/src/test/compile-fail/liveness-issue-2163.rs b/src/test/compile-fail/liveness-issue-2163.rs index e46d00c4ab9..69bceec8c32 100644 --- a/src/test/compile-fail/liveness-issue-2163.rs +++ b/src/test/compile-fail/liveness-issue-2163.rs @@ -11,7 +11,7 @@ use std::vec::Vec; fn main() { - let a: Vec<int> = Vec::new(); + let a: Vec<isize> = Vec::new(); a.iter().all(|_| -> bool { //~^ ERROR mismatched types }); diff --git a/src/test/compile-fail/liveness-missing-ret2.rs b/src/test/compile-fail/liveness-missing-ret2.rs index 541e8ec97fa..b53bb6159e8 100644 --- a/src/test/compile-fail/liveness-missing-ret2.rs +++ b/src/test/compile-fail/liveness-missing-ret2.rs @@ -10,7 +10,7 @@ // error-pattern: not all control paths return a value -fn f() -> int { +fn f() -> isize { // Make sure typestate doesn't interpret this match expression as // the function result match true { true => { } _ => {} }; diff --git a/src/test/compile-fail/liveness-move-call-arg.rs b/src/test/compile-fail/liveness-move-call-arg.rs index 08a523fb8ff..9340964c1fb 100644 --- a/src/test/compile-fail/liveness-move-call-arg.rs +++ b/src/test/compile-fail/liveness-move-call-arg.rs @@ -10,11 +10,11 @@ #![feature(box_syntax)] -fn take(_x: Box<int>) {} +fn take(_x: Box<isize>) {} fn main() { - let x: Box<int> = box 25; + let x: Box<isize> = box 25; loop { take(x); //~ ERROR use of moved value: `x` } diff --git a/src/test/compile-fail/liveness-move-in-loop.rs b/src/test/compile-fail/liveness-move-in-loop.rs index b2142258fb0..65ccaceac08 100644 --- a/src/test/compile-fail/liveness-move-in-loop.rs +++ b/src/test/compile-fail/liveness-move-in-loop.rs @@ -11,8 +11,8 @@ #![feature(box_syntax)] fn main() { - let y: Box<int> = box 42; - let mut x: Box<int>; + let y: Box<isize> = box 42; + let mut x: Box<isize>; loop { println!("{}", y); loop { diff --git a/src/test/compile-fail/liveness-move-in-while.rs b/src/test/compile-fail/liveness-move-in-while.rs index 549cf523d03..cadfd487121 100644 --- a/src/test/compile-fail/liveness-move-in-while.rs +++ b/src/test/compile-fail/liveness-move-in-while.rs @@ -11,8 +11,8 @@ #![feature(box_syntax)] fn main() { - let y: Box<int> = box 42; - let mut x: Box<int>; + let y: Box<isize> = box 42; + let mut x: Box<isize>; loop { println!("{}", y); //~ ERROR use of moved value: `y` while true { while true { while true { x = y; x.clone(); } } } diff --git a/src/test/compile-fail/liveness-return-last-stmt-semi.rs b/src/test/compile-fail/liveness-return-last-stmt-semi.rs index 9cfffb5fa6b..4b8f84ae704 100644 --- a/src/test/compile-fail/liveness-return-last-stmt-semi.rs +++ b/src/test/compile-fail/liveness-return-last-stmt-semi.rs @@ -10,11 +10,11 @@ // // regression test for #8005 -macro_rules! test { () => { fn foo() -> int { 1i; } } } +macro_rules! test { () => { fn foo() -> isize { 1is; } } } //~^ ERROR not all control paths return a value //~^^ HELP consider removing this semicolon -fn no_return() -> int {} //~ ERROR not all control paths return a value +fn no_return() -> isize {} //~ ERROR not all control paths return a value fn bar(x: u32) -> u32 { //~ ERROR not all control paths return a value x * 2; //~ HELP consider removing this semicolon diff --git a/src/test/compile-fail/liveness-unused.rs b/src/test/compile-fail/liveness-unused.rs index e93872eba0c..c9f8230b6c5 100644 --- a/src/test/compile-fail/liveness-unused.rs +++ b/src/test/compile-fail/liveness-unused.rs @@ -12,57 +12,57 @@ #![deny(unused_assignments)] #![allow(dead_code, non_camel_case_types)] -fn f1(x: int) { +fn f1(x: isize) { //~^ ERROR unused variable: `x` } -fn f1b(x: &mut int) { +fn f1b(x: &mut isize) { //~^ ERROR unused variable: `x` } #[allow(unused_variables)] -fn f1c(x: int) {} +fn f1c(x: isize) {} fn f1d() { - let x: int; + let x: isize; //~^ ERROR unused variable: `x` } fn f2() { - let x = 3i; + let x = 3is; //~^ ERROR unused variable: `x` } fn f3() { - let mut x = 3i; + let mut x = 3is; //~^ ERROR variable `x` is assigned to, but never used - x += 4i; + x += 4is; //~^ ERROR value assigned to `x` is never read } fn f3b() { - let mut z = 3i; + let mut z = 3is; //~^ ERROR variable `z` is assigned to, but never used loop { - z += 4i; + z += 4is; } } #[allow(unused_variables)] fn f3c() { - let mut z = 3i; - loop { z += 4i; } + let mut z = 3is; + loop { z += 4is; } } #[allow(unused_variables)] #[allow(unused_assignments)] fn f3d() { - let mut x = 3i; - x += 4i; + let mut x = 3is; + x += 4is; } fn f4() { - match Some(3i) { + match Some(3is) { Some(i) => { //~^ ERROR unused variable: `i` } @@ -71,11 +71,11 @@ fn f4() { } enum tri { - a(int), b(int), c(int) + a(isize), b(isize), c(isize) } -fn f4b() -> int { - match tri::a(3i) { +fn f4b() -> isize { + match tri::a(3is) { tri::a(i) | tri::b(i) | tri::c(i) => { i } @@ -83,17 +83,17 @@ fn f4b() -> int { } fn f5a() { - for x in range(1i, 10) { } + for x in range(1is, 10) { } //~^ ERROR unused variable: `x` } fn f5b() { - for (x, _) in [1i, 2, 3].iter().enumerate() { } + for (x, _) in [1is, 2, 3].iter().enumerate() { } //~^ ERROR unused variable: `x` } fn f5c() { - for (_, x) in [1i, 2, 3].iter().enumerate() { + for (_, x) in [1is, 2, 3].iter().enumerate() { //~^ ERROR unused variable: `x` continue; std::os::set_exit_status(*x); //~ WARNING unreachable statement diff --git a/src/test/compile-fail/liveness-use-after-move.rs b/src/test/compile-fail/liveness-use-after-move.rs index e1cd12989ca..21e52f13060 100644 --- a/src/test/compile-fail/liveness-use-after-move.rs +++ b/src/test/compile-fail/liveness-use-after-move.rs @@ -11,7 +11,7 @@ #![feature(box_syntax)] fn main() { - let x = box 5i; + let x = box 5is; let y = x; println!("{}", *x); //~ ERROR use of moved value: `*x` y.clone(); diff --git a/src/test/compile-fail/liveness-use-after-send.rs b/src/test/compile-fail/liveness-use-after-send.rs index 44d45463f19..4ba24800f5d 100644 --- a/src/test/compile-fail/liveness-use-after-send.rs +++ b/src/test/compile-fail/liveness-use-after-send.rs @@ -15,11 +15,11 @@ fn send<T:Send + std::fmt::Show>(ch: _chan<T>, data: T) { } #[derive(Show)] -struct _chan<T>(int); +struct _chan<T>(isize); // Tests that "log(debug, message);" is flagged as using // message after the send deinitializes it -fn test00_start(ch: _chan<Box<int>>, message: Box<int>, _count: Box<int>) { +fn test00_start(ch: _chan<Box<isize>>, message: Box<isize>, _count: Box<isize>) { send(ch, message); println!("{}", message); //~ ERROR use of moved value: `message` } diff --git a/src/test/compile-fail/loop-does-not-diverge.rs b/src/test/compile-fail/loop-does-not-diverge.rs index 9488e6bf969..e2d3d059ad8 100644 --- a/src/test/compile-fail/loop-does-not-diverge.rs +++ b/src/test/compile-fail/loop-does-not-diverge.rs @@ -14,7 +14,7 @@ fn forever() -> ! { loop { break; } - return 42i; //~ ERROR `return` in a function declared as diverging + return 42is; //~ ERROR `return` in a function declared as diverging } fn main() { diff --git a/src/test/compile-fail/macro-no-implicit-reexport.rs b/src/test/compile-fail/macro-no-implicit-reexport.rs index 4a427f121fc..1e2172f4a7c 100644 --- a/src/test/compile-fail/macro-no-implicit-reexport.rs +++ b/src/test/compile-fail/macro-no-implicit-reexport.rs @@ -16,5 +16,5 @@ extern crate macro_non_reexport_2; fn main() { - assert_eq!(reexported!(), 3u); //~ ERROR macro undefined + assert_eq!(reexported!(), 3us); //~ ERROR macro undefined } diff --git a/src/test/compile-fail/macro-reexport-not-locally-visible.rs b/src/test/compile-fail/macro-reexport-not-locally-visible.rs index c8e59f98d3c..cf0d79e0fef 100644 --- a/src/test/compile-fail/macro-reexport-not-locally-visible.rs +++ b/src/test/compile-fail/macro-reexport-not-locally-visible.rs @@ -16,5 +16,5 @@ extern crate macro_reexport_1; fn main() { - assert_eq!(reexported!(), 3u); //~ ERROR macro undefined + assert_eq!(reexported!(), 3us); //~ ERROR macro undefined } diff --git a/src/test/compile-fail/main-wrong-type.rs b/src/test/compile-fail/main-wrong-type.rs index ae990880523..d9c617a7172 100644 --- a/src/test/compile-fail/main-wrong-type.rs +++ b/src/test/compile-fail/main-wrong-type.rs @@ -9,8 +9,8 @@ // except according to those terms. struct S { - x: int, - y: int, + x: isize, + y: isize, } fn main(foo: S) { diff --git a/src/test/compile-fail/match-ill-type1.rs b/src/test/compile-fail/match-ill-type1.rs index 2b4c77bf9e8..908d46f398c 100644 --- a/src/test/compile-fail/match-ill-type1.rs +++ b/src/test/compile-fail/match-ill-type1.rs @@ -10,7 +10,7 @@ fn main() { match 1 { - 1...2u => 1, //~ ERROR mismatched types in range + 1...2us => 1, //~ ERROR mismatched types in range _ => 2, }; } diff --git a/src/test/compile-fail/match-ill-type2.rs b/src/test/compile-fail/match-ill-type2.rs index 17f02abc8ec..6b6954101b2 100644 --- a/src/test/compile-fail/match-ill-type2.rs +++ b/src/test/compile-fail/match-ill-type2.rs @@ -9,9 +9,9 @@ // except according to those terms. fn main() { - match 1i { - 1i => 1i, - 2u => 1i, //~ ERROR mismatched types - _ => 2i, + match 1is { + 1is => 1is, + 2us => 1is, //~ ERROR mismatched types + _ => 2is, }; } diff --git a/src/test/compile-fail/match-join.rs b/src/test/compile-fail/match-join.rs index e78561b9fdb..4ec426fd3aa 100644 --- a/src/test/compile-fail/match-join.rs +++ b/src/test/compile-fail/match-join.rs @@ -17,5 +17,5 @@ fn main() { match true { false => { my_panic(); } true => { } } println!("{}", x); //~ ERROR unresolved name `x` - let x: int; + let x: isize; } diff --git a/src/test/compile-fail/match-non-exhaustive.rs b/src/test/compile-fail/match-non-exhaustive.rs index 20adbeebdf1..2aeccacb0f6 100644 --- a/src/test/compile-fail/match-non-exhaustive.rs +++ b/src/test/compile-fail/match-non-exhaustive.rs @@ -9,6 +9,6 @@ // except according to those terms. fn main() { - match 0i { 1i => () } //~ ERROR non-exhaustive patterns - match 0i { 0i if false => () } //~ ERROR non-exhaustive patterns + match 0is { 1is => () } //~ ERROR non-exhaustive patterns + match 0is { 0is if false => () } //~ ERROR non-exhaustive patterns } diff --git a/src/test/compile-fail/match-pattern-field-mismatch-2.rs b/src/test/compile-fail/match-pattern-field-mismatch-2.rs index ab9efdcc8cc..e63ddf6c7fd 100644 --- a/src/test/compile-fail/match-pattern-field-mismatch-2.rs +++ b/src/test/compile-fail/match-pattern-field-mismatch-2.rs @@ -10,8 +10,8 @@ fn main() { enum color { - rgb(uint, uint, uint), - cmyk(uint, uint, uint, uint), + rgb(usize, usize, usize), + cmyk(usize, usize, usize, usize), no_color, } diff --git a/src/test/compile-fail/match-pattern-field-mismatch.rs b/src/test/compile-fail/match-pattern-field-mismatch.rs index 243690bbf31..8426ecdaf99 100644 --- a/src/test/compile-fail/match-pattern-field-mismatch.rs +++ b/src/test/compile-fail/match-pattern-field-mismatch.rs @@ -10,8 +10,8 @@ fn main() { enum color { - rgb(uint, uint, uint), - cmyk(uint, uint, uint, uint), + rgb(usize, usize, usize), + cmyk(usize, usize, usize, usize), no_color, } diff --git a/src/test/compile-fail/match-range-fail-dominate.rs b/src/test/compile-fail/match-range-fail-dominate.rs index 7a4451f99ab..7d33963003f 100644 --- a/src/test/compile-fail/match-range-fail-dominate.rs +++ b/src/test/compile-fail/match-range-fail-dominate.rs @@ -15,21 +15,21 @@ //error-pattern: unreachable fn main() { - match 5u { - 1u ... 10u => { } - 5u ... 6u => { } + match 5us { + 1us ... 10us => { } + 5us ... 6us => { } _ => {} }; - match 5u { - 3u ... 6u => { } - 4u ... 6u => { } + match 5us { + 3us ... 6us => { } + 4us ... 6us => { } _ => {} }; - match 5u { - 4u ... 6u => { } - 4u ... 6u => { } + match 5us { + 4us ... 6us => { } + 4us ... 6us => { } _ => {} }; diff --git a/src/test/compile-fail/match-range-fail.rs b/src/test/compile-fail/match-range-fail.rs index 9fbd1545fcf..1c804b0552c 100644 --- a/src/test/compile-fail/match-range-fail.rs +++ b/src/test/compile-fail/match-range-fail.rs @@ -13,8 +13,8 @@ //error-pattern: mismatched types fn main() { - match 5u { - 6u ... 1u => { } + match 5us { + 6us ... 1us => { } _ => { } }; @@ -22,8 +22,8 @@ fn main() { "bar" ... "foo" => { } }; - match 5u { - 'c' ... 100u => { } + match 5us { + 'c' ... 100us => { } _ => { } }; } diff --git a/src/test/compile-fail/match-static-const-lc.rs b/src/test/compile-fail/match-static-const-lc.rs index 15a832aad89..345c4aa69a7 100644 --- a/src/test/compile-fail/match-static-const-lc.rs +++ b/src/test/compile-fail/match-static-const-lc.rs @@ -14,7 +14,7 @@ #![deny(non_upper_case_globals)] #[allow(non_upper_case_globals)] -pub const a : int = 97; +pub const a : isize = 97; fn f() { let r = match (0,0) { @@ -27,7 +27,7 @@ fn f() { mod m { #[allow(non_upper_case_globals)] - pub const aha : int = 7; + pub const aha : isize = 7; } fn g() { @@ -41,7 +41,7 @@ fn g() { } mod n { - pub const OKAY : int = 8; + pub const OKAY : isize = 8; } fn h() { diff --git a/src/test/compile-fail/match-struct.rs b/src/test/compile-fail/match-struct.rs index 65082f93d35..e3b47372a4f 100644 --- a/src/test/compile-fail/match-struct.rs +++ b/src/test/compile-fail/match-struct.rs @@ -9,8 +9,8 @@ // except according to those terms. -struct S { a: int } -enum E { C(int) } +struct S { a: isize } +enum E { C(isize) } fn main() { match (S { a: 1 }) { diff --git a/src/test/compile-fail/match-tag-unary.rs b/src/test/compile-fail/match-tag-unary.rs index 89012e42bdc..48733fd423d 100644 --- a/src/test/compile-fail/match-tag-unary.rs +++ b/src/test/compile-fail/match-tag-unary.rs @@ -10,7 +10,7 @@ // error-pattern: mismatched types -enum a { A(int), } -enum b { B(int), } +enum a { A(isize), } +enum b { B(isize), } fn main() { let x: a = a::A(0); match x { b::B(y) => { } } } diff --git a/src/test/compile-fail/match-vec-fixed.rs b/src/test/compile-fail/match-vec-fixed.rs index bac9fef2b17..c35dc8d7c86 100644 --- a/src/test/compile-fail/match-vec-fixed.rs +++ b/src/test/compile-fail/match-vec-fixed.rs @@ -9,7 +9,7 @@ // except according to those terms. fn a() { - let v = [1i, 2, 3]; + let v = [1is, 2, 3]; match v { [_, _, _] => {} [_, _, _] => {} //~ ERROR unreachable pattern diff --git a/src/test/compile-fail/match-vec-unreachable.rs b/src/test/compile-fail/match-vec-unreachable.rs index a85ce660e8b..e2671552b43 100644 --- a/src/test/compile-fail/match-vec-unreachable.rs +++ b/src/test/compile-fail/match-vec-unreachable.rs @@ -10,8 +10,8 @@ fn main() { - let x: Vec<(int, int)> = Vec::new(); - let x: &[(int, int)] = x.as_slice(); + let x: Vec<(isize, isize)> = Vec::new(); + let x: &[(isize, isize)] = x.as_slice(); match x { [a, (2, 3), _] => (), [(1, 2), (2, 3), b] => (), //~ ERROR unreachable pattern diff --git a/src/test/compile-fail/method-ambig-one-trait-coerce.rs b/src/test/compile-fail/method-ambig-one-trait-coerce.rs index 5e3206ea516..cb5da4bb547 100644 --- a/src/test/compile-fail/method-ambig-one-trait-coerce.rs +++ b/src/test/compile-fail/method-ambig-one-trait-coerce.rs @@ -15,15 +15,15 @@ trait Object { } trait foo { - fn foo(self) -> int; + fn foo(self) -> isize; } impl foo for Box<Object+'static> { - fn foo(self) -> int {1} + fn foo(self) -> isize {1} } impl foo for Box<Object+Send> { - fn foo(self) -> int {2} + fn foo(self) -> isize {2} } fn test1(x: Box<Object+Send+Sync>) { diff --git a/src/test/compile-fail/method-ambig-one-trait-unknown-int-type.rs b/src/test/compile-fail/method-ambig-one-trait-unknown-int-type.rs index e211db2dcd2..c6d45f1c9db 100644 --- a/src/test/compile-fail/method-ambig-one-trait-unknown-int-type.rs +++ b/src/test/compile-fail/method-ambig-one-trait-unknown-int-type.rs @@ -13,15 +13,15 @@ // of what kind of `Vec` we have, eventually leading to a type error. trait foo { - fn foo(&self) -> int; + fn foo(&self) -> isize; } -impl foo for Vec<uint> { - fn foo(&self) -> int {1} +impl foo for Vec<usize> { + fn foo(&self) -> isize {1} } -impl foo for Vec<int> { - fn foo(&self) -> int {2} +impl foo for Vec<isize> { + fn foo(&self) -> isize {2} } // This is very hokey: we have heuristics to suppress messages about @@ -39,7 +39,7 @@ fn m2() { let mut x = Vec::new(); // ...but we still resolved `foo()` to the trait and hence know the return type. - let y: uint = x.foo(); //~ ERROR mismatched types + let y: usize = x.foo(); //~ ERROR mismatched types } fn main() { } diff --git a/src/test/compile-fail/method-ambig-two-traits-cross-crate.rs b/src/test/compile-fail/method-ambig-two-traits-cross-crate.rs index 30e635149c4..cab6a8610bf 100644 --- a/src/test/compile-fail/method-ambig-two-traits-cross-crate.rs +++ b/src/test/compile-fail/method-ambig-two-traits-cross-crate.rs @@ -15,8 +15,8 @@ extern crate ambig_impl_2_lib; use ambig_impl_2_lib::me; trait me2 { - fn me(&self) -> uint; + fn me(&self) -> usize; } -impl me2 for uint { fn me(&self) -> uint { *self } } -fn main() { 1u.me(); } //~ ERROR E0034 +impl me2 for usize { fn me(&self) -> usize { *self } } +fn main() { 1us.me(); } //~ ERROR E0034 diff --git a/src/test/compile-fail/method-ambig-two-traits-with-default-method.rs b/src/test/compile-fail/method-ambig-two-traits-with-default-method.rs index 87efaed4e3d..87e3655d31e 100644 --- a/src/test/compile-fail/method-ambig-two-traits-with-default-method.rs +++ b/src/test/compile-fail/method-ambig-two-traits-with-default-method.rs @@ -15,9 +15,9 @@ trait Foo { fn method(&self) {} } trait Bar { fn method(&self) {} } -impl Foo for uint {} -impl Bar for uint {} +impl Foo for usize {} +impl Bar for usize {} fn main() { - 1u.method(); //~ ERROR E0034 + 1us.method(); //~ ERROR E0034 } diff --git a/src/test/compile-fail/method-call-err-msg.rs b/src/test/compile-fail/method-call-err-msg.rs index 3610a0e2e9d..2f82441762f 100644 --- a/src/test/compile-fail/method-call-err-msg.rs +++ b/src/test/compile-fail/method-call-err-msg.rs @@ -13,8 +13,8 @@ pub struct Foo; impl Foo { fn zero(self) -> Foo { self } - fn one(self, _: int) -> Foo { self } - fn two(self, _: int, _: int) -> Foo { self } + fn one(self, _: isize) -> Foo { self } + fn two(self, _: isize, _: isize) -> Foo { self } } fn main() { diff --git a/src/test/compile-fail/method-missing-call.rs b/src/test/compile-fail/method-missing-call.rs index ddfa447f60e..899c1ef16a6 100644 --- a/src/test/compile-fail/method-missing-call.rs +++ b/src/test/compile-fail/method-missing-call.rs @@ -14,26 +14,26 @@ struct Point { - x: int, - y: int + x: isize, + y: isize } impl Point { fn new() -> Point { Point{x:0, y:0} } - fn get_x(&self) -> int { + fn get_x(&self) -> isize { self.x } } fn main() { let point: Point = Point::new(); - let px: int = point + let px: isize = point .get_x;//~ ERROR attempted to take value of method `get_x` on type `Point` //~^ HELP maybe a `()` to call it is missing // Ensure the span is useful - let ys = &[1i,2,3,4,5,6,7]; + let ys = &[1is,2,3,4,5,6,7]; let a = ys.iter() .map(|x| x) .filter(|&&x| x == 1) diff --git a/src/test/compile-fail/method-self-arg-2.rs b/src/test/compile-fail/method-self-arg-2.rs index 0ac0851619c..ad255ecd9c0 100644 --- a/src/test/compile-fail/method-self-arg-2.rs +++ b/src/test/compile-fail/method-self-arg-2.rs @@ -23,5 +23,5 @@ fn main() { Foo::bar(&x); //~ERROR cannot borrow `x` let x = Foo; - Foo::baz(&x); //~ERROR cannot borrow immutable dereference of `&`-pointer as mutable + Foo::baz(&x); //~ERROR cannot borrow immutable borrowed content as mutable } diff --git a/src/test/compile-fail/missing-derivable-attr.rs b/src/test/compile-fail/missing-derivable-attr.rs index db960ac3409..7eee51e4076 100644 --- a/src/test/compile-fail/missing-derivable-attr.rs +++ b/src/test/compile-fail/missing-derivable-attr.rs @@ -13,11 +13,11 @@ trait MyEq { } struct A { - x: int + x: isize } -impl MyEq for int { - fn eq(&self, other: &int) -> bool { *self == *other } +impl MyEq for isize { + fn eq(&self, other: &isize) -> bool { *self == *other } } impl MyEq for A {} //~ ERROR not all trait items implemented, missing: `eq` diff --git a/src/test/compile-fail/missing-return.rs b/src/test/compile-fail/missing-return.rs index 1dc817cc6e6..efd0c827a35 100644 --- a/src/test/compile-fail/missing-return.rs +++ b/src/test/compile-fail/missing-return.rs @@ -10,6 +10,6 @@ // error-pattern: return -fn f() -> int { } +fn f() -> isize { } fn main() { f(); } diff --git a/src/test/compile-fail/mod_file_aux.rs b/src/test/compile-fail/mod_file_aux.rs index 4d18decdc13..b7470811f60 100644 --- a/src/test/compile-fail/mod_file_aux.rs +++ b/src/test/compile-fail/mod_file_aux.rs @@ -10,4 +10,4 @@ // ignore-test Not a test. Used by other tests -pub fn foo() -> int { 10 } +pub fn foo() -> isize { 10 } diff --git a/src/test/compile-fail/move-fragments-1.rs b/src/test/compile-fail/move-fragments-1.rs index e45862a7fc6..3f14be2da10 100644 --- a/src/test/compile-fail/move-fragments-1.rs +++ b/src/test/compile-fail/move-fragments-1.rs @@ -18,7 +18,7 @@ // These are all fairly trivial cases: unused variables or direct // drops of substructure. -pub struct D { d: int } +pub struct D { d: isize } impl Drop for D { fn drop(&mut self) { } } #[rustc_move_fragments] diff --git a/src/test/compile-fail/move-fragments-2.rs b/src/test/compile-fail/move-fragments-2.rs index ceb1d5a0f09..6c0635d6be9 100644 --- a/src/test/compile-fail/move-fragments-2.rs +++ b/src/test/compile-fail/move-fragments-2.rs @@ -20,7 +20,7 @@ use self::Lonely::{Zero, One, Two}; -pub struct D { d: int } +pub struct D { d: isize } impl Drop for D { fn drop(&mut self) { } } pub enum Lonely<X,Y> { Zero, One(X), Two(X, Y) } diff --git a/src/test/compile-fail/move-fragments-3.rs b/src/test/compile-fail/move-fragments-3.rs index 4540b0c5a91..24d73ec2274 100644 --- a/src/test/compile-fail/move-fragments-3.rs +++ b/src/test/compile-fail/move-fragments-3.rs @@ -20,7 +20,7 @@ use self::Lonely::{Zero, One, Two}; -pub struct D { d: int } +pub struct D { d: isize } impl Drop for D { fn drop(&mut self) { } } pub enum Lonely<X,Y> { Zero, One(X), Two(X, Y) } diff --git a/src/test/compile-fail/move-fragments-4.rs b/src/test/compile-fail/move-fragments-4.rs index dc43dcb9b0e..97e8e45ed06 100644 --- a/src/test/compile-fail/move-fragments-4.rs +++ b/src/test/compile-fail/move-fragments-4.rs @@ -19,7 +19,7 @@ // early draft of the code did not properly traverse up through all of // the parents of the leaf fragment.) -pub struct D { d: int } +pub struct D { d: isize } impl Drop for D { fn drop(&mut self) { } } pub struct Pair<X,Y> { x: X, y: Y } diff --git a/src/test/compile-fail/move-fragments-5.rs b/src/test/compile-fail/move-fragments-5.rs index bef2f12d642..9f70421fa84 100644 --- a/src/test/compile-fail/move-fragments-5.rs +++ b/src/test/compile-fail/move-fragments-5.rs @@ -17,7 +17,7 @@ // This is the first test that checks moving into local variables. -pub struct D { d: int } +pub struct D { d: isize } impl Drop for D { fn drop(&mut self) { } } pub struct Pair<X,Y> { x: X, y: Y } diff --git a/src/test/compile-fail/move-fragments-7.rs b/src/test/compile-fail/move-fragments-7.rs index 6b2c77bcac1..2af2b2957f8 100644 --- a/src/test/compile-fail/move-fragments-7.rs +++ b/src/test/compile-fail/move-fragments-7.rs @@ -19,7 +19,7 @@ // both moving out of the structure (i.e. reading `*p.x`) and writing // into the container (i.e. writing `*p.x`). -pub struct D { d: int } +pub struct D { d: isize } impl Drop for D { fn drop(&mut self) { } } pub struct Pair<X,Y> { x: X, y: Y } diff --git a/src/test/compile-fail/move-fragments-8.rs b/src/test/compile-fail/move-fragments-8.rs index 40ab541128c..18bf4066076 100644 --- a/src/test/compile-fail/move-fragments-8.rs +++ b/src/test/compile-fail/move-fragments-8.rs @@ -22,7 +22,7 @@ // also that in this case we cannot do a move out of `&T`, so we only // test writing `*p.x` here. -pub struct D { d: int } +pub struct D { d: isize } impl Drop for D { fn drop(&mut self) { } } pub struct Pair<X,Y> { x: X, y: Y } diff --git a/src/test/compile-fail/move-fragments-9.rs b/src/test/compile-fail/move-fragments-9.rs index 0b095ff6f82..d0eeebd02f8 100644 --- a/src/test/compile-fail/move-fragments-9.rs +++ b/src/test/compile-fail/move-fragments-9.rs @@ -14,7 +14,7 @@ // Note also that the `test_move_array_then_overwrite` tests represent // cases that we probably should make illegal. -pub struct D { d: int } +pub struct D { d: isize } impl Drop for D { fn drop(&mut self) { } } #[rustc_move_fragments] @@ -34,7 +34,7 @@ pub fn test_move_array_into_recv(a: [D; 3], recv: &mut [D; 3]) { } #[rustc_move_fragments] -pub fn test_extract_array_elem(a: [D; 3], i: uint) -> D { +pub fn test_extract_array_elem(a: [D; 3], i: usize) -> D { //~^ ERROR parent_of_fragments: `$(local a)` //~| ERROR assigned_leaf_path: `$(local i)` //~| ERROR moved_leaf_path: `$(local a).[]` @@ -43,7 +43,7 @@ pub fn test_extract_array_elem(a: [D; 3], i: uint) -> D { } #[rustc_move_fragments] -pub fn test_overwrite_array_elem(mut a: [D; 3], i: uint, d: D) { +pub fn test_overwrite_array_elem(mut a: [D; 3], i: usize, d: D) { //~^ ERROR parent_of_fragments: `$(local mut a)` //~| ERROR assigned_leaf_path: `$(local i)` //~| ERROR assigned_leaf_path: `$(local d)` @@ -59,7 +59,7 @@ pub fn test_overwrite_array_elem(mut a: [D; 3], i: uint, d: D) { // See RFC PR 320 for more discussion. #[rustc_move_fragments] -pub fn test_move_array_then_overwrite_elem1(mut a: [D; 3], i: uint, recv: &mut [D; 3], d: D) { +pub fn test_move_array_then_overwrite_elem1(mut a: [D; 3], i: usize, recv: &mut [D; 3], d: D) { //~^ ERROR parent_of_fragments: `$(local mut a)` //~| ERROR parent_of_fragments: `$(local recv)` //~| ERROR assigned_leaf_path: `$(local recv).*` @@ -76,7 +76,7 @@ pub fn test_move_array_then_overwrite_elem1(mut a: [D; 3], i: uint, recv: &mut [ } #[rustc_move_fragments] -pub fn test_move_array_then_overwrite_elem2(mut a: [D; 3], i: uint, j: uint, +pub fn test_move_array_then_overwrite_elem2(mut a: [D; 3], i: usize, j: usize, recv: &mut [D; 3], d1: D, d2: D) { //~^^ ERROR parent_of_fragments: `$(local mut a)` //~| ERROR parent_of_fragments: `$(local recv)` 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 78b6736c1c8..ace6c80e3e3 100644 --- a/src/test/compile-fail/move-out-of-tuple-field.rs +++ b/src/test/compile-fail/move-out-of-tuple-field.rs @@ -10,14 +10,14 @@ #![feature(box_syntax)] -struct Foo(Box<int>); +struct Foo(Box<isize>); fn main() { - let x = (box 1i,); + let x = (box 1is,); let y = x.0; let z = x.0; //~ ERROR use of moved value: `x.0` - let x = Foo(box 1i); + let x = Foo(box 1is); let y = x.0; let z = x.0; //~ ERROR use of moved value: `x.0` } diff --git a/src/test/compile-fail/moves-based-on-type-access-to-field.rs b/src/test/compile-fail/moves-based-on-type-access-to-field.rs index c9efce0d684..b8572fbd215 100644 --- a/src/test/compile-fail/moves-based-on-type-access-to-field.rs +++ b/src/test/compile-fail/moves-based-on-type-access-to-field.rs @@ -11,7 +11,7 @@ // Tests that if you move from `x.f` or `x[0]`, `x` is inaccessible. // Also tests that we give a more specific error message. -struct Foo { f: String, y: int } +struct Foo { f: String, y: isize } fn consume(_s: String) {} fn touch<A>(_a: &A) {} 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 379397f22bd..179c71d3659 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 @@ -18,7 +18,7 @@ struct S { enum E { Foo(Box<S>), - Bar(Box<int>), + Bar(Box<isize>), Baz } diff --git a/src/test/compile-fail/moves-based-on-type-cyclic-types-issue-4821.rs b/src/test/compile-fail/moves-based-on-type-cyclic-types-issue-4821.rs index 805c82f03f9..865784c2f1e 100644 --- a/src/test/compile-fail/moves-based-on-type-cyclic-types-issue-4821.rs +++ b/src/test/compile-fail/moves-based-on-type-cyclic-types-issue-4821.rs @@ -13,9 +13,9 @@ // See middle::ty::type_contents() for more information. -struct List { key: int, next: Option<Box<List>> } +struct List { key: isize, next: Option<Box<List>> } -fn foo(node: Box<List>) -> int { +fn foo(node: Box<List>) -> isize { let r = match node.next { Some(right) => consume(right), None => 0 @@ -23,7 +23,7 @@ fn foo(node: Box<List>) -> int { consume(node) + r //~ ERROR use of partially moved value: `node` } -fn consume(v: Box<List>) -> int { +fn consume(v: Box<List>) -> isize { v.key } diff --git a/src/test/compile-fail/moves-based-on-type-exprs.rs b/src/test/compile-fail/moves-based-on-type-exprs.rs index d8d84e558a9..58f1f78fa5d 100644 --- a/src/test/compile-fail/moves-based-on-type-exprs.rs +++ b/src/test/compile-fail/moves-based-on-type-exprs.rs @@ -24,13 +24,13 @@ fn f10() { fn f20() { let x = "hi".to_string(); - let _y = (x, 3i); + let _y = (x, 3is); touch(&x); //~ ERROR use of moved value: `x` } fn f21() { - let x = vec!(1i, 2, 3); - let _y = (x[0], 3i); + let x = vec!(1is, 2, 3); + let _y = (x[0], 3is); touch(&x); } @@ -61,9 +61,9 @@ fn f50(cond: bool) { let x = "hi".to_string(); let y = "ho".to_string(); let _y = match cond { - _ if guard(x) => 10i, - true => 10i, - false => 20i, + _ if guard(x) => 10is, + true => 10is, + false => 20is, }; touch(&x); //~ ERROR use of moved value: `x` touch(&y); 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 0f5e012ef19..5dfe7f0c71f 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 @@ -10,9 +10,9 @@ #![feature(box_syntax)] -use std::uint; +use std::usize; -fn test(_x: Box<uint>) {} +fn test(_x: Box<usize>) {} fn main() { let i = box 3; 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 397b22c486e..30388f9d2f7 100644 --- a/src/test/compile-fail/moves-based-on-type-tuple.rs +++ b/src/test/compile-fail/moves-based-on-type-tuple.rs @@ -10,7 +10,7 @@ #![feature(box_syntax)] -fn dup(x: Box<int>) -> Box<(Box<int>,Box<int>)> { box() (x, x) } //~ ERROR use of moved value +fn dup(x: Box<isize>) -> Box<(Box<isize>,Box<isize>)> { box() (x, x) } //~ ERROR use of moved value fn main() { dup(box 3); } diff --git a/src/test/compile-fail/moves-sru-moved-field.rs b/src/test/compile-fail/moves-sru-moved-field.rs index 6c351f88713..15977fbeb73 100644 --- a/src/test/compile-fail/moves-sru-moved-field.rs +++ b/src/test/compile-fail/moves-sru-moved-field.rs @@ -10,11 +10,11 @@ #![feature(box_syntax)] -type Noncopyable = Box<int>; +type Noncopyable = Box<isize>; struct Foo { - copied: int, - moved: Box<int>, + copied: isize, + moved: Box<isize>, noncopyable: Noncopyable } diff --git a/src/test/compile-fail/multitrait.rs b/src/test/compile-fail/multitrait.rs index 7add747fbfa..a0e210aed40 100644 --- a/src/test/compile-fail/multitrait.rs +++ b/src/test/compile-fail/multitrait.rs @@ -9,7 +9,7 @@ // except according to those terms. struct S { - y: int + y: isize } impl Cmp, ToString for S { //~ ERROR: expected one of `(`, `+`, `::`, or `{`, found `,` diff --git a/src/test/compile-fail/mut-cant-alias.rs b/src/test/compile-fail/mut-cant-alias.rs index ce6e793d55d..847a3eaf8a1 100644 --- a/src/test/compile-fail/mut-cant-alias.rs +++ b/src/test/compile-fail/mut-cant-alias.rs @@ -11,7 +11,7 @@ use std::cell::RefCell; fn main() { - let m = RefCell::new(0i); + let m = RefCell::new(0is); let mut b = m.borrow_mut(); let b1 = &mut *b; let b2 = &mut *b; //~ ERROR cannot borrow diff --git a/src/test/compile-fail/mut-cross-borrowing.rs b/src/test/compile-fail/mut-cross-borrowing.rs index 90bc0019531..7fb5c2ac4a4 100644 --- a/src/test/compile-fail/mut-cross-borrowing.rs +++ b/src/test/compile-fail/mut-cross-borrowing.rs @@ -10,10 +10,10 @@ #![feature(box_syntax)] -fn f(_: &mut int) {} +fn f(_: &mut isize) {} fn main() { - let mut x = box 3i; + let mut x = box 3is; f(x) //~ ERROR mismatched types } diff --git a/src/test/compile-fail/mut-not-freeze.rs b/src/test/compile-fail/mut-not-freeze.rs index d7529c86aa5..8c39320276a 100644 --- a/src/test/compile-fail/mut-not-freeze.rs +++ b/src/test/compile-fail/mut-not-freeze.rs @@ -13,7 +13,7 @@ use std::cell::RefCell; fn f<T: Sync>(_: T) {} fn main() { - let x = RefCell::new(0i); + let x = RefCell::new(0is); f(x); //~^ ERROR `core::marker::Sync` is not implemented //~^^ ERROR `core::marker::Sync` is not implemented diff --git a/src/test/compile-fail/mut-pattern-internal-mutability.rs b/src/test/compile-fail/mut-pattern-internal-mutability.rs index 05c6c4a9655..92f02114a13 100644 --- a/src/test/compile-fail/mut-pattern-internal-mutability.rs +++ b/src/test/compile-fail/mut-pattern-internal-mutability.rs @@ -9,7 +9,7 @@ // except according to those terms. fn main() { - let foo = &mut 1i; + let foo = &mut 1is; let &mut x = foo; x += 1; //~ ERROR re-assignment of immutable variable diff --git a/src/test/compile-fail/mut-patterns.rs b/src/test/compile-fail/mut-patterns.rs index a78e82bb73c..cde05bc1d52 100644 --- a/src/test/compile-fail/mut-patterns.rs +++ b/src/test/compile-fail/mut-patterns.rs @@ -11,6 +11,6 @@ // Can't put mut in non-ident pattern pub fn main() { - struct Foo { x: int } + struct Foo { x: isize } let mut Foo { x: x } = Foo { x: 3 }; //~ ERROR: expected one of `:`, `;`, `=`, or `@`, found `{` } diff --git a/src/test/compile-fail/mut-ptr-cant-outlive-ref.rs b/src/test/compile-fail/mut-ptr-cant-outlive-ref.rs index e269a736ce2..74b561c37aa 100644 --- a/src/test/compile-fail/mut-ptr-cant-outlive-ref.rs +++ b/src/test/compile-fail/mut-ptr-cant-outlive-ref.rs @@ -11,7 +11,7 @@ use std::cell::RefCell; fn main() { - let m = RefCell::new(0i); + let m = RefCell::new(0is); let p; { let b = m.borrow(); diff --git a/src/test/compile-fail/mutable-class-fields-2.rs b/src/test/compile-fail/mutable-class-fields-2.rs index 377c745acf3..932c2a9715f 100644 --- a/src/test/compile-fail/mutable-class-fields-2.rs +++ b/src/test/compile-fail/mutable-class-fields-2.rs @@ -9,9 +9,9 @@ // except according to those terms. struct cat { - meows : uint, + meows : usize, - how_hungry : int, + how_hungry : isize, } impl cat { @@ -21,7 +21,7 @@ impl cat { } -fn cat(in_x : uint, in_y : int) -> cat { +fn cat(in_x : usize, in_y : isize) -> cat { cat { meows: in_x, how_hungry: in_y @@ -29,6 +29,6 @@ fn cat(in_x : uint, in_y : int) -> cat { } fn main() { - let nyan : cat = cat(52u, 99); + let nyan : cat = cat(52us, 99); nyan.eat(); } diff --git a/src/test/compile-fail/mutable-class-fields.rs b/src/test/compile-fail/mutable-class-fields.rs index 4d77d1824ab..a840ac63dd8 100644 --- a/src/test/compile-fail/mutable-class-fields.rs +++ b/src/test/compile-fail/mutable-class-fields.rs @@ -9,11 +9,11 @@ // except according to those terms. struct cat { - meows : uint, - how_hungry : int, + meows : usize, + how_hungry : isize, } -fn cat(in_x : uint, in_y : int) -> cat { +fn cat(in_x : usize, in_y : isize) -> cat { cat { meows: in_x, how_hungry: in_y @@ -21,6 +21,6 @@ fn cat(in_x : uint, in_y : int) -> cat { } fn main() { - let nyan : cat = cat(52u, 99); + let nyan : cat = cat(52us, 99); nyan.how_hungry = 0; //~ ERROR cannot assign } diff --git a/src/test/compile-fail/name-clash-nullary.rs b/src/test/compile-fail/name-clash-nullary.rs index 2f0588b261e..1250318a729 100644 --- a/src/test/compile-fail/name-clash-nullary.rs +++ b/src/test/compile-fail/name-clash-nullary.rs @@ -12,6 +12,6 @@ use std::option::*; fn main() { - let None: int = 42; + let None: isize = 42; log(debug, None); } diff --git a/src/test/compile-fail/namespaced-enum-glob-import-no-impls.rs b/src/test/compile-fail/namespaced-enum-glob-import-no-impls.rs index 602ec9ba762..4437482fb67 100644 --- a/src/test/compile-fail/namespaced-enum-glob-import-no-impls.rs +++ b/src/test/compile-fail/namespaced-enum-glob-import-no-impls.rs @@ -11,8 +11,8 @@ mod m2 { pub enum Foo { A, - B(int), - C { a: int }, + B(isize), + C { a: isize }, } impl Foo { diff --git a/src/test/compile-fail/no-capture-arc.rs b/src/test/compile-fail/no-capture-arc.rs index 3d4d0fee0bf..beb0d0ee47e 100644 --- a/src/test/compile-fail/no-capture-arc.rs +++ b/src/test/compile-fail/no-capture-arc.rs @@ -14,7 +14,7 @@ use std::sync::Arc; use std::thread::Thread; fn main() { - let v = vec!(1i, 2, 3, 4, 5, 6, 7, 8, 9, 10); + let v = vec!(1is, 2, 3, 4, 5, 6, 7, 8, 9, 10); let arc_v = Arc::new(v); Thread::spawn(move|| { diff --git a/src/test/compile-fail/no-reuse-move-arc.rs b/src/test/compile-fail/no-reuse-move-arc.rs index 02028fe62e5..d8f0fa497a4 100644 --- a/src/test/compile-fail/no-reuse-move-arc.rs +++ b/src/test/compile-fail/no-reuse-move-arc.rs @@ -12,7 +12,7 @@ use std::sync::Arc; use std::thread::Thread; fn main() { - let v = vec!(1i, 2, 3, 4, 5, 6, 7, 8, 9, 10); + let v = vec!(1is, 2, 3, 4, 5, 6, 7, 8, 9, 10); let arc_v = Arc::new(v); Thread::spawn(move|| { diff --git a/src/test/compile-fail/no_send-rc.rs b/src/test/compile-fail/no_send-rc.rs index 95855ed584b..82cc319466a 100644 --- a/src/test/compile-fail/no_send-rc.rs +++ b/src/test/compile-fail/no_send-rc.rs @@ -13,7 +13,7 @@ use std::rc::Rc; fn bar<T: Send>(_: T) {} fn main() { - let x = Rc::new(5i); + let x = Rc::new(5is); bar(x); //~^ ERROR `core::marker::Send` is not implemented //~^^ ERROR `core::marker::Send` is not implemented diff --git a/src/test/compile-fail/no_send-struct.rs b/src/test/compile-fail/no_send-struct.rs index c2d6f04c7d4..bef70523787 100644 --- a/src/test/compile-fail/no_send-struct.rs +++ b/src/test/compile-fail/no_send-struct.rs @@ -11,7 +11,7 @@ use std::marker; struct Foo { - a: int, + a: isize, ns: marker::NoSend } diff --git a/src/test/compile-fail/no_share-rc.rs b/src/test/compile-fail/no_share-rc.rs index 0f3573e0ad5..0d3e380d4a1 100644 --- a/src/test/compile-fail/no_share-rc.rs +++ b/src/test/compile-fail/no_share-rc.rs @@ -14,7 +14,7 @@ use std::cell::RefCell; fn bar<T: Sync>(_: T) {} fn main() { - let x = Rc::new(RefCell::new(5i)); + let x = Rc::new(RefCell::new(5is)); bar(x); //~^ ERROR the trait `core::marker::Sync` is not implemented //~^^ ERROR the trait `core::marker::Sync` is not implemented diff --git a/src/test/compile-fail/no_share-struct.rs b/src/test/compile-fail/no_share-struct.rs index 59864b63b04..c7028ce9786 100644 --- a/src/test/compile-fail/no_share-struct.rs +++ b/src/test/compile-fail/no_share-struct.rs @@ -10,7 +10,7 @@ use std::marker; -struct Foo { a: int, m: marker::NoSync } +struct Foo { a: isize, m: marker::NoSync } fn bar<T: Sync>(_: T) {} diff --git a/src/test/compile-fail/noexporttypeexe.rs b/src/test/compile-fail/noexporttypeexe.rs index 4081792b654..8fa4e81c889 100644 --- a/src/test/compile-fail/noexporttypeexe.rs +++ b/src/test/compile-fail/noexporttypeexe.rs @@ -17,6 +17,6 @@ fn main() { // This used to cause internal errors when serializing // because the def_id associated with the type was // not convertible to a path. - let x: int = noexporttypelib::foo(); + let x: isize = noexporttypelib::foo(); //~^ ERROR expected `isize`, found `core::option::Option<isize>` } diff --git a/src/test/compile-fail/non-constant-enum-for-vec-repeat.rs b/src/test/compile-fail/non-constant-enum-for-vec-repeat.rs index a1dc2ab2041..0212adff305 100644 --- a/src/test/compile-fail/non-constant-enum-for-vec-repeat.rs +++ b/src/test/compile-fail/non-constant-enum-for-vec-repeat.rs @@ -11,6 +11,6 @@ enum State { ST_NULL, ST_WHITESPACE } fn main() { - [State::ST_NULL; (State::ST_WHITESPACE as uint)]; + [State::ST_NULL; (State::ST_WHITESPACE as usize)]; //~^ ERROR expected constant integer for repeat count, found non-constant expression } diff --git a/src/test/compile-fail/non-constant-expr-for-fixed-len-vec.rs b/src/test/compile-fail/non-constant-expr-for-fixed-len-vec.rs index 85d734ddaf2..14d2c8d0326 100644 --- a/src/test/compile-fail/non-constant-expr-for-fixed-len-vec.rs +++ b/src/test/compile-fail/non-constant-expr-for-fixed-len-vec.rs @@ -11,8 +11,8 @@ // Check that non-constant exprs do fail as count in fixed length vec type fn main() { - fn bar(n: int) { - let _x: [int; n]; + fn bar(n: isize) { + let _x: [isize; n]; //~^ ERROR expected constant expr for array length: non-constant path in constant expr } } diff --git a/src/test/compile-fail/non-constant-expr-for-vec-repeat.rs b/src/test/compile-fail/non-constant-expr-for-vec-repeat.rs index 2e063e5237c..26528543b43 100644 --- a/src/test/compile-fail/non-constant-expr-for-vec-repeat.rs +++ b/src/test/compile-fail/non-constant-expr-for-vec-repeat.rs @@ -11,7 +11,7 @@ // Check that non constant exprs fail for vector repeat syntax fn main() { - fn bar(n: uint) { + fn bar(n: usize) { let _x = [0; n]; //~ ERROR expected constant integer for repeat count, found variable } } diff --git a/src/test/compile-fail/non-copyable-void.rs b/src/test/compile-fail/non-copyable-void.rs index cd134ccf71d..40b641519b0 100644 --- a/src/test/compile-fail/non-copyable-void.rs +++ b/src/test/compile-fail/non-copyable-void.rs @@ -11,7 +11,7 @@ extern crate libc; fn main() { - let x : *const Vec<int> = &vec!(1,2,3); + let x : *const Vec<isize> = &vec!(1,2,3); let y : *const libc::c_void = x as *const libc::c_void; unsafe { let _z = (*y).clone(); diff --git a/src/test/compile-fail/non-exhaustive-match.rs b/src/test/compile-fail/non-exhaustive-match.rs index 8fcf10f1c35..ccf69a4d2c8 100644 --- a/src/test/compile-fail/non-exhaustive-match.rs +++ b/src/test/compile-fail/non-exhaustive-match.rs @@ -16,10 +16,10 @@ fn main() { match true { //~ ERROR non-exhaustive patterns: `false` not covered true => {} } - match Some(10i) { //~ ERROR non-exhaustive patterns: `Some(_)` not covered + match Some(10is) { //~ ERROR non-exhaustive patterns: `Some(_)` not covered None => {} } - match (2i, 3i, 4i) { //~ ERROR non-exhaustive patterns: `(_, _, _)` not covered + match (2is, 3is, 4is) { //~ ERROR non-exhaustive patterns: `(_, _, _)` not covered (_, _, 4) => {} } match (t::a, t::a) { //~ ERROR non-exhaustive patterns: `(a, a)` not covered @@ -35,15 +35,15 @@ fn main() { (_, t::a) => {} (t::b, t::b) => {} } - let vec = vec!(Some(42i), None, Some(21i)); - let vec: &[Option<int>] = vec.as_slice(); + let vec = vec!(Some(42is), None, Some(21is)); + let vec: &[Option<isize>] = vec.as_slice(); match vec { //~ ERROR non-exhaustive patterns: `[]` not covered [Some(..), None, tail..] => {} [Some(..), Some(..), tail..] => {} [None] => {} } - let vec = vec!(1i); - let vec: &[int] = vec.as_slice(); + let vec = vec!(1is); + let vec: &[isize] = vec.as_slice(); match vec { [_, tail..] => (), [] => () @@ -56,8 +56,8 @@ fn main() { [0.1] => (), [] => () } - let vec = vec!(Some(42i), None, Some(21i)); - let vec: &[Option<int>] = vec.as_slice(); + let vec = vec!(Some(42is), None, Some(21is)); + let vec: &[Option<isize>] = vec.as_slice(); match vec { [Some(..), None, tail..] => {} [Some(..), Some(..), tail..] => {} diff --git a/src/test/compile-fail/non-exhaustive-pattern-witness.rs b/src/test/compile-fail/non-exhaustive-pattern-witness.rs index d35e3ad3c55..3bd3a0c653c 100644 --- a/src/test/compile-fail/non-exhaustive-pattern-witness.rs +++ b/src/test/compile-fail/non-exhaustive-pattern-witness.rs @@ -12,7 +12,7 @@ struct Foo { first: bool, - second: Option<[uint; 4]> + second: Option<[usize; 4]> } enum Color { @@ -27,7 +27,7 @@ fn struct_with_a_nested_enum_and_vector() { Foo { first: true, second: None } => (), Foo { first: true, second: Some(_) } => (), Foo { first: false, second: None } => (), - Foo { first: false, second: Some([1u, 2u, 3u, 4u]) } => () + Foo { first: false, second: Some([1us, 2us, 3us, 4us]) } => () } } diff --git a/src/test/compile-fail/noncopyable-class.rs b/src/test/compile-fail/noncopyable-class.rs index ec8369d6736..029b8485993 100644 --- a/src/test/compile-fail/noncopyable-class.rs +++ b/src/test/compile-fail/noncopyable-class.rs @@ -13,14 +13,14 @@ #[derive(Show)] struct bar { - x: int, + x: isize, } impl Drop for bar { fn drop(&mut self) {} } -fn bar(x:int) -> bar { +fn bar(x:isize) -> bar { bar { x: x } @@ -28,11 +28,11 @@ fn bar(x:int) -> bar { #[derive(Show)] struct foo { - i: int, + i: isize, j: bar, } -fn foo(i:int) -> foo { +fn foo(i:isize) -> foo { foo { i: i, j: bar(5) diff --git a/src/test/compile-fail/nonscalar-cast.rs b/src/test/compile-fail/nonscalar-cast.rs index 728f66a6aa7..f32c96b7b64 100644 --- a/src/test/compile-fail/nonscalar-cast.rs +++ b/src/test/compile-fail/nonscalar-cast.rs @@ -12,9 +12,9 @@ #[derive(Show)] struct foo { - x: int + x: isize } fn main() { - println!("{}", foo{ x: 1 } as int); + println!("{}", foo{ x: 1 } as isize); } diff --git a/src/test/compile-fail/not-a-pred.rs b/src/test/compile-fail/not-a-pred.rs index 2e16c58eaad..782c90a6c26 100644 --- a/src/test/compile-fail/not-a-pred.rs +++ b/src/test/compile-fail/not-a-pred.rs @@ -10,8 +10,8 @@ // error-pattern: lt -fn f(a: int, b: int) : lt(a, b) { } +fn f(a: isize, b: isize) : lt(a, b) { } -fn lt(a: int, b: int) { } +fn lt(a: isize, b: isize) { } -fn main() { let a: int = 10; let b: int = 23; check (lt(a, b)); f(a, b); } +fn main() { let a: isize = 10; let b: isize = 23; check (lt(a, b)); f(a, b); } diff --git a/src/test/compile-fail/not-enough-arguments.rs b/src/test/compile-fail/not-enough-arguments.rs index 2deb9591a83..c952906e5e8 100644 --- a/src/test/compile-fail/not-enough-arguments.rs +++ b/src/test/compile-fail/not-enough-arguments.rs @@ -12,7 +12,7 @@ // mismatch between the # of params, and not other // unrelated errors. -fn foo(a: int, b: int, c: int, d:int) { +fn foo(a: isize, b: isize, c: isize, d:isize) { panic!(); } diff --git a/src/test/compile-fail/obsolete-tilde.rs b/src/test/compile-fail/obsolete-tilde.rs index fa59798c1d5..d290d5536a4 100644 --- a/src/test/compile-fail/obsolete-tilde.rs +++ b/src/test/compile-fail/obsolete-tilde.rs @@ -10,12 +10,12 @@ // Test that ~ pointers give an obsolescence message. -fn foo(x: ~int) {} //~ ERROR obsolete syntax: `~` notation for owned pointers +fn foo(x: ~isize) {} //~ ERROR obsolete syntax: `~` notation for owned pointers fn bar(x: ~str) {} //~ ERROR obsolete syntax: `~` notation for owned pointers -fn baz(x: ~[int]) {} //~ ERROR obsolete syntax: `~[T]` is no longer a type +fn baz(x: ~[isize]) {} //~ ERROR obsolete syntax: `~[T]` is no longer a type fn main() { - let x = ~4i; //~ ERROR obsolete syntax: `~` notation for owned pointer allocation + let x = ~4is; //~ ERROR obsolete syntax: `~` notation for owned pointer allocation let y = ~"hello"; //~ ERROR obsolete syntax: `~` notation for owned pointer allocation - let z = ~[1i, 2, 3]; //~ ERROR obsolete syntax: `~[T]` is no longer a type + let z = ~[1is, 2, 3]; //~ ERROR obsolete syntax: `~[T]` is no longer a type } diff --git a/src/test/compile-fail/obsolete-tuple-struct-deref.rs b/src/test/compile-fail/obsolete-tuple-struct-deref.rs index 9ea7d960da9..ad5fac3e21e 100644 --- a/src/test/compile-fail/obsolete-tuple-struct-deref.rs +++ b/src/test/compile-fail/obsolete-tuple-struct-deref.rs @@ -9,7 +9,7 @@ // except according to those terms. fn main() { - struct S(int); + struct S(isize); let s = S(0); let x = *s; //~ ERROR single-field tuple-structs can no longer be dereferenced } diff --git a/src/test/compile-fail/occurs-check-3.rs b/src/test/compile-fail/occurs-check-3.rs index 4cda97bcb4a..ba7688e8524 100644 --- a/src/test/compile-fail/occurs-check-3.rs +++ b/src/test/compile-fail/occurs-check-3.rs @@ -11,4 +11,4 @@ // error-pattern:mismatched types // From Issue #778 enum clam<T> { a(T), } -fn main() { let c; c = clam::a(c); match c { clam::a::<int>(_) => { } } } +fn main() { let c; c = clam::a(c); match c { clam::a::<isize>(_) => { } } } diff --git a/src/test/compile-fail/opt-out-copy-bad.rs b/src/test/compile-fail/opt-out-copy-bad.rs deleted file mode 100644 index 9e425fa8f2e..00000000000 --- a/src/test/compile-fail/opt-out-copy-bad.rs +++ /dev/null @@ -1,44 +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. - -#![feature(opt_out_copy)] -//~^ WARNING feature is deprecated -//~| WARNING feature is deprecated - -// Test that when using the `opt-out-copy` feature we still consider -// destructors to be non-movable - -struct CantCopyThis; - -impl Drop for CantCopyThis { - fn drop(&mut self) { } -} - -struct IWantToCopyThis { - but_i_cant: CantCopyThis, -} - -impl Copy for IWantToCopyThis {} -//~^ ERROR the trait `Copy` may not be implemented for this type - -enum CantCopyThisEither { - A, - B(::std::marker::NoCopy), -} - -enum IWantToCopyThisToo { - ButICant(CantCopyThisEither), -} - -impl Copy for IWantToCopyThisToo {} -//~^ ERROR the trait `Copy` may not be implemented for this type - -fn main() {} - diff --git a/src/test/compile-fail/or-patter-mismatch.rs b/src/test/compile-fail/or-patter-mismatch.rs index e79113ceb89..74f674e64ba 100644 --- a/src/test/compile-fail/or-patter-mismatch.rs +++ b/src/test/compile-fail/or-patter-mismatch.rs @@ -10,6 +10,6 @@ // error-pattern: mismatched types -enum blah { a(int, int, uint), b(int, int), } +enum blah { a(isize, isize, usize), b(isize, isize), } -fn main() { match blah::a(1, 1, 2u) { blah::a(_, x, y) | blah::b(x, y) => { } } } +fn main() { match blah::a(1, 1, 2us) { blah::a(_, x, y) | blah::b(x, y) => { } } } diff --git a/src/test/compile-fail/output-type-mismatch.rs b/src/test/compile-fail/output-type-mismatch.rs index bc77765ebf4..158e99ac200 100644 --- a/src/test/compile-fail/output-type-mismatch.rs +++ b/src/test/compile-fail/output-type-mismatch.rs @@ -12,4 +12,4 @@ fn f() { } -fn main() { let i: int; i = f(); } +fn main() { let i: isize; i = f(); } diff --git a/src/test/compile-fail/overloaded-calls-bad.rs b/src/test/compile-fail/overloaded-calls-bad.rs index b3a4c312589..d784ba2d0d6 100644 --- a/src/test/compile-fail/overloaded-calls-bad.rs +++ b/src/test/compile-fail/overloaded-calls-bad.rs @@ -13,12 +13,12 @@ use std::ops::FnMut; struct S { - x: int, - y: int, + x: isize, + y: isize, } -impl FnMut<(int,),int> for S { - extern "rust-call" fn call_mut(&mut self, (z,): (int,)) -> int { +impl FnMut<(isize,),isize> for S { + extern "rust-call" fn call_mut(&mut self, (z,): (isize,)) -> isize { self.x * self.y * z } } diff --git a/src/test/compile-fail/overloaded-calls-nontuple.rs b/src/test/compile-fail/overloaded-calls-nontuple.rs index 396a809c2e1..c06ab04cd84 100644 --- a/src/test/compile-fail/overloaded-calls-nontuple.rs +++ b/src/test/compile-fail/overloaded-calls-nontuple.rs @@ -13,12 +13,12 @@ use std::ops::FnMut; struct S { - x: int, - y: int, + x: isize, + y: isize, } -impl FnMut<int,int> for S { - extern "rust-call" fn call_mut(&mut self, z: int) -> int { +impl FnMut<isize,isize> for S { + extern "rust-call" fn call_mut(&mut self, z: isize) -> isize { self.x + self.y + z } } diff --git a/src/test/compile-fail/packed-struct-transmute.rs b/src/test/compile-fail/packed-struct-transmute.rs index 200c8a5137a..b80dd0b36ed 100644 --- a/src/test/compile-fail/packed-struct-transmute.rs +++ b/src/test/compile-fail/packed-struct-transmute.rs @@ -20,13 +20,13 @@ use std::mem; #[repr(packed)] struct Foo { bar: u8, - baz: uint + baz: usize } #[derive(Show)] struct Oof { rab: u8, - zab: uint + zab: usize } fn main() { diff --git a/src/test/compile-fail/pat-range-bad-dots.rs b/src/test/compile-fail/pat-range-bad-dots.rs index 7fe073a4c3d..7f67d7a5fb1 100644 --- a/src/test/compile-fail/pat-range-bad-dots.rs +++ b/src/test/compile-fail/pat-range-bad-dots.rs @@ -9,7 +9,7 @@ // except according to those terms. pub fn main() { - match 22i { + match 22is { 0 .. 3 => {} //~ ERROR expected one of `...`, `=>`, or `|`, found `..` _ => {} } diff --git a/src/test/compile-fail/pat-ref-enum.rs b/src/test/compile-fail/pat-ref-enum.rs index f1f0637a318..062d3308c3d 100644 --- a/src/test/compile-fail/pat-ref-enum.rs +++ b/src/test/compile-fail/pat-ref-enum.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -fn matcher(x: Option<int>) { +fn matcher(x: Option<isize>) { match x { ref Some(i) => {} //~ ERROR expected identifier, found enum pattern None => {} diff --git a/src/test/compile-fail/pat-shadow-in-nested-binding.rs b/src/test/compile-fail/pat-shadow-in-nested-binding.rs index 4d89ec14d94..526e4c16187 100644 --- a/src/test/compile-fail/pat-shadow-in-nested-binding.rs +++ b/src/test/compile-fail/pat-shadow-in-nested-binding.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -struct foo(uint); +struct foo(usize); fn main() { let (foo, _) = (2, 3); //~ ERROR declaration of `foo` shadows diff --git a/src/test/compile-fail/pattern-bindings-after-at.rs b/src/test/compile-fail/pattern-bindings-after-at.rs index 54ac3cba636..70840200aad 100644 --- a/src/test/compile-fail/pattern-bindings-after-at.rs +++ b/src/test/compile-fail/pattern-bindings-after-at.rs @@ -14,7 +14,7 @@ enum Option<T> { } fn main() { - match &mut Some(1i) { + match &mut Some(1is) { ref mut z @ &mut Some(ref a) => { //~^ ERROR pattern bindings are not allowed after an `@` **z = None; diff --git a/src/test/compile-fail/pattern-error-continue.rs b/src/test/compile-fail/pattern-error-continue.rs index 8b65af00fb1..c288429dcda 100644 --- a/src/test/compile-fail/pattern-error-continue.rs +++ b/src/test/compile-fail/pattern-error-continue.rs @@ -11,13 +11,13 @@ // Test that certain pattern-match type errors are non-fatal enum A { - B(int, int), - C(int, int, int), + B(isize, isize), + C(isize, isize, isize), D } struct S { - a: int + a: isize } fn f(_c: char) {} diff --git a/src/test/compile-fail/pattern-ident-path-generics.rs b/src/test/compile-fail/pattern-ident-path-generics.rs index ab77e376979..58288fa4842 100644 --- a/src/test/compile-fail/pattern-ident-path-generics.rs +++ b/src/test/compile-fail/pattern-ident-path-generics.rs @@ -10,7 +10,7 @@ fn main() { match Some("foo") { - None::<int> => {} //~ ERROR mismatched types + None::<isize> => {} //~ ERROR mismatched types Some(_) => {} } } diff --git a/src/test/compile-fail/pattern-tyvar-2.rs b/src/test/compile-fail/pattern-tyvar-2.rs index ff898ebd16b..cd4a98835c8 100644 --- a/src/test/compile-fail/pattern-tyvar-2.rs +++ b/src/test/compile-fail/pattern-tyvar-2.rs @@ -8,10 +8,10 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -enum bar { t1((), Option<Vec<int>>), t2, } +enum bar { t1((), Option<Vec<isize>>), t2, } // n.b. my change changes this error message, but I think it's right -- tjc -fn foo(t: bar) -> int { match t { bar::t1(_, Some(x)) => { return x * 3; } _ => { panic!(); } } } +fn foo(t: bar) -> isize { match t { bar::t1(_, Some(x)) => { return x * 3; } _ => { panic!(); } } } //~^ ERROR binary operation `*` cannot be applied to fn main() { } diff --git a/src/test/compile-fail/pattern-tyvar.rs b/src/test/compile-fail/pattern-tyvar.rs index 01b288fdaad..be8d3e027e7 100644 --- a/src/test/compile-fail/pattern-tyvar.rs +++ b/src/test/compile-fail/pattern-tyvar.rs @@ -10,11 +10,11 @@ // error-pattern: mismatched types -enum bar { t1((), Option<Vec<int> >), t2, } +enum bar { t1((), Option<Vec<isize> >), t2, } fn foo(t: bar) { match t { - bar::t1(_, Some::<int>(x)) => { + bar::t1(_, Some::<isize>(x)) => { println!("{}", x); } _ => { panic!(); } diff --git a/src/test/compile-fail/pptypedef.rs b/src/test/compile-fail/pptypedef.rs index b33b89be35d..e3c440d61ce 100644 --- a/src/test/compile-fail/pptypedef.rs +++ b/src/test/compile-fail/pptypedef.rs @@ -11,9 +11,9 @@ fn let_in<T, F>(x: T, f: F) where F: FnOnce(T) {} fn main() { - let_in(3u, |i| { assert!(i == 3is); }); + let_in(3us, |i| { assert!(i == 3is); }); //~^ ERROR expected `usize`, found `isize` - let_in(3i, |i| { assert!(i == 3us); }); + let_in(3is, |i| { assert!(i == 3us); }); //~^ ERROR expected `isize`, found `usize` } diff --git a/src/test/compile-fail/prim-with-args.rs b/src/test/compile-fail/prim-with-args.rs index 0587e033a97..cc0b74dc82a 100644 --- a/src/test/compile-fail/prim-with-args.rs +++ b/src/test/compile-fail/prim-with-args.rs @@ -10,24 +10,24 @@ fn main() { -let x: int<int>; //~ ERROR type parameters are not allowed on this type -let x: i8<int>; //~ ERROR type parameters are not allowed on this type -let x: i16<int>; //~ ERROR type parameters are not allowed on this type -let x: i32<int>; //~ ERROR type parameters are not allowed on this type -let x: i64<int>; //~ ERROR type parameters are not allowed on this type -let x: uint<int>; //~ ERROR type parameters are not allowed on this type -let x: u8<int>; //~ ERROR type parameters are not allowed on this type -let x: u16<int>; //~ ERROR type parameters are not allowed on this type -let x: u32<int>; //~ ERROR type parameters are not allowed on this type -let x: u64<int>; //~ ERROR type parameters are not allowed on this type -let x: char<int>; //~ ERROR type parameters are not allowed on this type +let x: isize<isize>; //~ ERROR type parameters are not allowed on this type +let x: i8<isize>; //~ ERROR type parameters are not allowed on this type +let x: i16<isize>; //~ ERROR type parameters are not allowed on this type +let x: i32<isize>; //~ ERROR type parameters are not allowed on this type +let x: i64<isize>; //~ ERROR type parameters are not allowed on this type +let x: usize<isize>; //~ ERROR type parameters are not allowed on this type +let x: u8<isize>; //~ ERROR type parameters are not allowed on this type +let x: u16<isize>; //~ ERROR type parameters are not allowed on this type +let x: u32<isize>; //~ ERROR type parameters are not allowed on this type +let x: u64<isize>; //~ ERROR type parameters are not allowed on this type +let x: char<isize>; //~ ERROR type parameters are not allowed on this type -let x: int<'static>; //~ ERROR lifetime parameters are not allowed on this type +let x: isize<'static>; //~ ERROR lifetime parameters are not allowed on this type let x: i8<'static>; //~ ERROR lifetime parameters are not allowed on this type let x: i16<'static>; //~ ERROR lifetime parameters are not allowed on this type let x: i32<'static>; //~ ERROR lifetime parameters are not allowed on this type let x: i64<'static>; //~ ERROR lifetime parameters are not allowed on this type -let x: uint<'static>; //~ ERROR lifetime parameters are not allowed on this type +let x: usize<'static>; //~ ERROR lifetime parameters are not allowed on this type let x: u8<'static>; //~ ERROR lifetime parameters are not allowed on this type let x: u16<'static>; //~ ERROR lifetime parameters are not allowed on this type let x: u32<'static>; //~ ERROR lifetime parameters are not allowed on this type diff --git a/src/test/compile-fail/privacy1.rs b/src/test/compile-fail/privacy1.rs index ffee00642ac..9dafae3d87d 100644 --- a/src/test/compile-fail/privacy1.rs +++ b/src/test/compile-fail/privacy1.rs @@ -41,7 +41,7 @@ mod bar { fn foo() -> Self; } - impl B for int { fn foo() -> int { 3 } } + impl B for isize { fn foo() -> isize { 3 } } pub enum Enum { Pub @@ -119,7 +119,7 @@ mod foo { //~^ ERROR: method `bar2` is private //~^^ NOTE: module `baz` is private - let _: int = + let _: isize = ::bar::B::foo(); //~ ERROR: method `foo` is inaccessible //~^ NOTE: trait `B` is private ::lol(); @@ -186,4 +186,4 @@ pub mod mytest { } } -#[start] fn main(_: int, _: *const *const u8) -> int { 3 } +#[start] fn main(_: isize, _: *const *const u8) -> isize { 3 } diff --git a/src/test/compile-fail/privacy2.rs b/src/test/compile-fail/privacy2.rs index b38d7aedf84..b59905776d3 100644 --- a/src/test/compile-fail/privacy2.rs +++ b/src/test/compile-fail/privacy2.rs @@ -32,4 +32,4 @@ fn test2() { //~^ ERROR unresolved import `bar::glob::foo`. There is no `foo` in `bar::glob` } -#[start] fn main(_: int, _: *const *const u8) -> int { 3 } +#[start] fn main(_: isize, _: *const *const u8) -> isize { 3 } diff --git a/src/test/compile-fail/privacy3.rs b/src/test/compile-fail/privacy3.rs index 5ec10d5a4ca..80219b70e07 100644 --- a/src/test/compile-fail/privacy3.rs +++ b/src/test/compile-fail/privacy3.rs @@ -29,4 +29,4 @@ fn test1() { gpriv(); } -#[start] fn main(_: int, _: *const *const u8) -> int { 3 } +#[start] fn main(_: isize, _: *const *const u8) -> isize { 3 } diff --git a/src/test/compile-fail/privacy4.rs b/src/test/compile-fail/privacy4.rs index 92f3a57c69d..3f17d463890 100644 --- a/src/test/compile-fail/privacy4.rs +++ b/src/test/compile-fail/privacy4.rs @@ -32,4 +32,4 @@ fn test2() { gpriv(); } -#[start] fn main(_: int, _: *const *const u8) -> int { 3 } +#[start] fn main(_: isize, _: *const *const u8) -> isize { 3 } diff --git a/src/test/compile-fail/privacy5.rs b/src/test/compile-fail/privacy5.rs index 555969b65ff..df570fd4647 100644 --- a/src/test/compile-fail/privacy5.rs +++ b/src/test/compile-fail/privacy5.rs @@ -15,9 +15,9 @@ extern crate "privacy-tuple-struct" as other; mod a { pub struct A(()); - pub struct B(int); - pub struct C(pub int, int); - pub struct D(pub int); + pub struct B(isize); + pub struct C(pub isize, isize); + pub struct D(pub isize); fn test() { let a = A(()); diff --git a/src/test/compile-fail/private-impl-method.rs b/src/test/compile-fail/private-impl-method.rs index fe5908b40ab..c6e329aab04 100644 --- a/src/test/compile-fail/private-impl-method.rs +++ b/src/test/compile-fail/private-impl-method.rs @@ -10,7 +10,7 @@ mod a { pub struct Foo { - pub x: int + pub x: isize } impl Foo { diff --git a/src/test/compile-fail/private-method.rs b/src/test/compile-fail/private-method.rs index 88ab73e1f9d..e8e26cf8ce3 100644 --- a/src/test/compile-fail/private-method.rs +++ b/src/test/compile-fail/private-method.rs @@ -12,16 +12,16 @@ mod kitties { pub struct cat { - meows : uint, + meows : usize, - how_hungry : int, + how_hungry : isize, } impl cat { fn nap(&self) {} } - pub fn cat(in_x : uint, in_y : int) -> cat { + pub fn cat(in_x : usize, in_y : isize) -> cat { cat { meows: in_x, how_hungry: in_y @@ -30,6 +30,6 @@ mod kitties { } fn main() { - let nyan : kitties::cat = kitties::cat(52u, 99); + let nyan : kitties::cat = kitties::cat(52us, 99); nyan.nap(); } diff --git a/src/test/compile-fail/private-struct-field-cross-crate.rs b/src/test/compile-fail/private-struct-field-cross-crate.rs index 45c4b2b7ae1..36b6000ceeb 100644 --- a/src/test/compile-fail/private-struct-field-cross-crate.rs +++ b/src/test/compile-fail/private-struct-field-cross-crate.rs @@ -13,7 +13,7 @@ extern crate cci_class; use cci_class::kitties::cat; fn main() { - let nyan : cat = cat(52u, 99); - assert!((nyan.meows == 52u)); + let nyan : cat = cat(52us, 99); + assert!((nyan.meows == 52us)); //~^ ERROR field `meows` of struct `cci_class::kitties::cat` is private } diff --git a/src/test/compile-fail/private-struct-field-ctor.rs b/src/test/compile-fail/private-struct-field-ctor.rs index ae19c221496..0a0f2d490a8 100644 --- a/src/test/compile-fail/private-struct-field-ctor.rs +++ b/src/test/compile-fail/private-struct-field-ctor.rs @@ -10,7 +10,7 @@ mod a { pub struct Foo { - x: int + x: isize } } diff --git a/src/test/compile-fail/private-struct-field-pattern.rs b/src/test/compile-fail/private-struct-field-pattern.rs index 991457ef1ce..e9dd6cd1d74 100644 --- a/src/test/compile-fail/private-struct-field-pattern.rs +++ b/src/test/compile-fail/private-struct-field-pattern.rs @@ -12,7 +12,7 @@ use a::Foo; mod a { pub struct Foo { - x: int + x: isize } pub fn make() -> Foo { diff --git a/src/test/compile-fail/private-struct-field.rs b/src/test/compile-fail/private-struct-field.rs index 3f6fa573cc0..b98719e157e 100644 --- a/src/test/compile-fail/private-struct-field.rs +++ b/src/test/compile-fail/private-struct-field.rs @@ -10,7 +10,7 @@ mod cat { pub struct Cat { - meows: uint + meows: usize } pub fn new_cat() -> Cat { diff --git a/src/test/compile-fail/ptr-coercion.rs b/src/test/compile-fail/ptr-coercion.rs index d9b20748a7a..392a803b0dd 100644 --- a/src/test/compile-fail/ptr-coercion.rs +++ b/src/test/compile-fail/ptr-coercion.rs @@ -13,12 +13,12 @@ pub fn main() { // *const -> *mut - let x: *const int = &42i; - let x: *mut int = x; //~ERROR values differ in mutability + let x: *const isize = &42is; + let x: *mut isize = x; //~ERROR values differ in mutability // & -> *mut - let x: *mut int = &42; //~ERROR values differ in mutability + let x: *mut isize = &42; //~ERROR values differ in mutability - let x: *const int = &42; - let x: *mut int = x; //~ERROR values differ in mutability + let x: *const isize = &42; + let x: *mut isize = x; //~ERROR values differ in mutability } diff --git a/src/test/compile-fail/qquote-2.rs b/src/test/compile-fail/qquote-2.rs index 94485dddd13..978287a681e 100644 --- a/src/test/compile-fail/qquote-2.rs +++ b/src/test/compile-fail/qquote-2.rs @@ -52,7 +52,7 @@ fn mk_ctxt() -> fake_ext_ctxt { fn main() { let cx = mk_ctxt(); - let stmt = quote_stmt!(cx, let x int = 20;); //~ ERROR expected end-of-string + let stmt = quote_stmt!(cx, let x isize = 20;); //~ ERROR expected end-of-string check_pp(*stmt, pprust::print_stmt, ""); } diff --git a/src/test/compile-fail/range-1.rs b/src/test/compile-fail/range-1.rs index 1668b868e64..9888c085695 100644 --- a/src/test/compile-fail/range-1.rs +++ b/src/test/compile-fail/range-1.rs @@ -12,7 +12,7 @@ pub fn main() { // Mixed types. - let _ = 0u..10i; + let _ = 0us..10is; //~^ ERROR start and end of range have incompatible types // Float => does not implement iterator. @@ -20,7 +20,7 @@ pub fn main() { //~^ ERROR `for` loop expression has type `core::ops::Range<f32>` which does not implement // Unsized type. - let arr: &[_] = &[1u, 2, 3]; + let arr: &[_] = &[1us, 2, 3]; let range = (*arr)..; //~^ ERROR the trait `core::marker::Sized` is not implemented } diff --git a/src/test/compile-fail/range-2.rs b/src/test/compile-fail/range-2.rs index 40690bd844b..6d176ca3700 100644 --- a/src/test/compile-fail/range-2.rs +++ b/src/test/compile-fail/range-2.rs @@ -12,7 +12,7 @@ pub fn main() { let r = { - (&42i)..&42 + (&42is)..&42 //~^ ERROR borrowed value does not live long enough //~^^ ERROR borrowed value does not live long enough }; diff --git a/src/test/compile-fail/recursion.rs b/src/test/compile-fail/recursion.rs index de326677c86..f39c839a0e7 100644 --- a/src/test/compile-fail/recursion.rs +++ b/src/test/compile-fail/recursion.rs @@ -16,17 +16,17 @@ // that is more helpful. enum Nil {NilValue} -struct Cons<T> {head:int, tail:T} -trait Dot {fn dot(&self, other:Self) -> int;} +struct Cons<T> {head:isize, tail:T} +trait Dot {fn dot(&self, other:Self) -> isize;} impl Dot for Nil { - fn dot(&self, _:Nil) -> int {0} + fn dot(&self, _:Nil) -> isize {0} } impl<T:Dot> Dot for Cons<T> { - fn dot(&self, other:Cons<T>) -> int { + fn dot(&self, other:Cons<T>) -> isize { self.head * other.head + self.tail.dot(other.tail) } } -fn test<T:Dot> (n:int, i:int, first:T, second:T) ->int { +fn test<T:Dot> (n:isize, i:isize, first:T, second:T) ->isize { match n { 0 => {first.dot(second)} //~^ ERROR: reached the recursion limit during monomorphization // Error message should be here. It should be a type error diff --git a/src/test/compile-fail/recursion_limit.rs b/src/test/compile-fail/recursion_limit.rs index 6e1ecb10e3a..6cd984c071a 100644 --- a/src/test/compile-fail/recursion_limit.rs +++ b/src/test/compile-fail/recursion_limit.rs @@ -35,7 +35,7 @@ link! { K, L } link! { L, M } link! { M, N } -enum N { N(uint) } +enum N { N(usize) } fn is_send<T:Send>() { } diff --git a/src/test/compile-fail/refutable-pattern-errors.rs b/src/test/compile-fail/refutable-pattern-errors.rs index 98d616ee3af..d06c73c4cc0 100644 --- a/src/test/compile-fail/refutable-pattern-errors.rs +++ b/src/test/compile-fail/refutable-pattern-errors.rs @@ -9,10 +9,10 @@ // except according to those terms. -fn func((1, (Some(1), 2...3)): (int, (Option<int>, int))) { } +fn func((1, (Some(1), 2...3)): (isize, (Option<isize>, isize))) { } //~^ ERROR refutable pattern in function argument: `(_, _)` not covered fn main() { - let (1i, (Some(1i), 2i...3i)) = (1i, (None, 2i)); + let (1is, (Some(1is), 2is...3is)) = (1is, (None, 2is)); //~^ ERROR refutable pattern in local binding: `(_, _)` not covered } diff --git a/src/test/compile-fail/refutable-pattern-in-fn-arg.rs b/src/test/compile-fail/refutable-pattern-in-fn-arg.rs index 575e9864a92..53f923e5061 100644 --- a/src/test/compile-fail/refutable-pattern-in-fn-arg.rs +++ b/src/test/compile-fail/refutable-pattern-in-fn-arg.rs @@ -9,7 +9,7 @@ // except according to those terms. fn main() { - let f = |&: 3: int| println!("hello"); + let f = |&: 3: isize| println!("hello"); //~^ ERROR refutable pattern in function argument: `_` not covered f(4); } diff --git a/src/test/compile-fail/region-bound-on-closure-outlives-call.rs b/src/test/compile-fail/region-bound-on-closure-outlives-call.rs index 9e8281faf2f..5b04fa3d87c 100644 --- a/src/test/compile-fail/region-bound-on-closure-outlives-call.rs +++ b/src/test/compile-fail/region-bound-on-closure-outlives-call.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -fn call_rec<F>(mut f: F) -> uint where F: FnMut(uint) -> uint { +fn call_rec<F>(mut f: F) -> usize where F: FnMut(usize) -> usize { (|&mut: x| f(x))(call_rec(f)) //~ ERROR cannot move out of `f` } diff --git a/src/test/compile-fail/region-lifetime-bounds-on-fns-where-clause.rs b/src/test/compile-fail/region-lifetime-bounds-on-fns-where-clause.rs index 3e6a95b04f7..ee05ba676ac 100644 --- a/src/test/compile-fail/region-lifetime-bounds-on-fns-where-clause.rs +++ b/src/test/compile-fail/region-lifetime-bounds-on-fns-where-clause.rs @@ -8,17 +8,17 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -fn a<'a, 'b>(x: &mut &'a int, y: &mut &'b int) where 'b: 'a { +fn a<'a, 'b>(x: &mut &'a isize, y: &mut &'b isize) where 'b: 'a { // Note: this is legal because of the `'b:'a` declaration. *x = *y; } -fn b<'a, 'b>(x: &mut &'a int, y: &mut &'b int) { +fn b<'a, 'b>(x: &mut &'a isize, y: &mut &'b isize) { // Illegal now because there is no `'b:'a` declaration. *x = *y; //~ ERROR cannot infer } -fn c<'a,'b>(x: &mut &'a int, y: &mut &'b int) { +fn c<'a,'b>(x: &mut &'a isize, y: &mut &'b isize) { // Here we try to call `foo` but do not know that `'a` and `'b` are // related as required. a(x, y); //~ ERROR cannot infer @@ -27,13 +27,13 @@ fn c<'a,'b>(x: &mut &'a int, y: &mut &'b int) { fn d() { // 'a and 'b are early bound in the function `a` because they appear // inconstraints: - let _: fn(&mut &int, &mut &int) = a; //~ ERROR mismatched types + let _: fn(&mut &isize, &mut &isize) = a; //~ ERROR mismatched types } fn e() { // 'a and 'b are late bound in the function `b` because there are // no constraints: - let _: fn(&mut &int, &mut &int) = b; + let _: fn(&mut &isize, &mut &isize) = b; } fn main() { } diff --git a/src/test/compile-fail/region-multiple-lifetime-bounds-on-fns-where-clause.rs b/src/test/compile-fail/region-multiple-lifetime-bounds-on-fns-where-clause.rs index 2d635e9fc27..30e6a4e1277 100644 --- a/src/test/compile-fail/region-multiple-lifetime-bounds-on-fns-where-clause.rs +++ b/src/test/compile-fail/region-multiple-lifetime-bounds-on-fns-where-clause.rs @@ -8,19 +8,19 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -fn a<'a, 'b, 'c>(x: &mut &'a int, y: &mut &'b int, z: &mut &'c int) where 'b: 'a + 'c { +fn a<'a, 'b, 'c>(x: &mut &'a isize, y: &mut &'b isize, z: &mut &'c isize) where 'b: 'a + 'c { // Note: this is legal because of the `'b:'a` declaration. *x = *y; *z = *y; } -fn b<'a, 'b, 'c>(x: &mut &'a int, y: &mut &'b int, z: &mut &'c int) { +fn b<'a, 'b, 'c>(x: &mut &'a isize, y: &mut &'b isize, z: &mut &'c isize) { // Illegal now because there is no `'b:'a` declaration. *x = *y; //~ ERROR cannot infer *z = *y; //~ ERROR cannot infer } -fn c<'a,'b, 'c>(x: &mut &'a int, y: &mut &'b int, z: &mut &'c int) { +fn c<'a,'b, 'c>(x: &mut &'a isize, y: &mut &'b isize, z: &mut &'c isize) { // Here we try to call `foo` but do not know that `'a` and `'b` are // related as required. a(x, y, z); //~ ERROR cannot infer @@ -29,13 +29,13 @@ fn c<'a,'b, 'c>(x: &mut &'a int, y: &mut &'b int, z: &mut &'c int) { fn d() { // 'a and 'b are early bound in the function `a` because they appear // inconstraints: - let _: fn(&mut &int, &mut &int, &mut &int) = a; //~ ERROR mismatched types + let _: fn(&mut &isize, &mut &isize, &mut &isize) = a; //~ ERROR mismatched types } fn e() { // 'a and 'b are late bound in the function `b` because there are // no constraints: - let _: fn(&mut &int, &mut &int, &mut &int) = b; + let _: fn(&mut &isize, &mut &isize, &mut &isize) = b; } fn main() { } diff --git a/src/test/compile-fail/regionck-unboxed-closure-lifetimes.rs b/src/test/compile-fail/regionck-unboxed-closure-lifetimes.rs index 75e9e55138e..cdaa3468a46 100644 --- a/src/test/compile-fail/regionck-unboxed-closure-lifetimes.rs +++ b/src/test/compile-fail/regionck-unboxed-closure-lifetimes.rs @@ -17,7 +17,7 @@ fn main() { { let c = 1; let c_ref = &c; //~ ERROR `c` does not live long enough - f = move |&mut: a: int, b: int| { a + b + *c_ref }; + f = move |&mut: a: isize, b: isize| { a + b + *c_ref }; } } diff --git a/src/test/compile-fail/regions-addr-of-arg.rs b/src/test/compile-fail/regions-addr-of-arg.rs index 3e568180b53..c54b4aaace5 100644 --- a/src/test/compile-fail/regions-addr-of-arg.rs +++ b/src/test/compile-fail/regions-addr-of-arg.rs @@ -11,15 +11,15 @@ // Check that taking the address of an argument yields a lifetime // bounded by the current function call. -fn foo(a: int) { - let _p: &'static int = &a; //~ ERROR `a` does not live long enough +fn foo(a: isize) { + let _p: &'static isize = &a; //~ ERROR `a` does not live long enough } -fn bar(a: int) { - let _q: &int = &a; +fn bar(a: isize) { + let _q: &isize = &a; } -fn zed<'a>(a: int) -> &'a int { +fn zed<'a>(a: isize) -> &'a isize { &a //~ ERROR `a` does not live long enough } diff --git a/src/test/compile-fail/regions-addr-of-self.rs b/src/test/compile-fail/regions-addr-of-self.rs index fb2dbacef84..b69224d4499 100644 --- a/src/test/compile-fail/regions-addr-of-self.rs +++ b/src/test/compile-fail/regions-addr-of-self.rs @@ -9,24 +9,24 @@ // except according to those terms. struct dog { - cats_chased: uint, + cats_chased: usize, } impl dog { pub fn chase_cat(&mut self) { - let p: &'static mut uint = &mut self.cats_chased; //~ ERROR cannot infer - *p += 1u; + let p: &'static mut usize = &mut self.cats_chased; //~ ERROR cannot infer + *p += 1us; } pub fn chase_cat_2(&mut self) { - let p: &mut uint = &mut self.cats_chased; - *p += 1u; + let p: &mut usize = &mut self.cats_chased; + *p += 1us; } } fn dog() -> dog { dog { - cats_chased: 0u + cats_chased: 0us } } diff --git a/src/test/compile-fail/regions-addr-of-upvar-self.rs b/src/test/compile-fail/regions-addr-of-upvar-self.rs index fb60d8f7b27..fa76ab758ab 100644 --- a/src/test/compile-fail/regions-addr-of-upvar-self.rs +++ b/src/test/compile-fail/regions-addr-of-upvar-self.rs @@ -8,17 +8,17 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::uint; +use std::usize; struct dog { - food: uint, + food: usize, } impl dog { pub fn chase_cat(&mut self) { let _f = |&:| { - let p: &'static mut uint = &mut self.food; //~ ERROR cannot infer - *p = 3u; + let p: &'static mut usize = &mut self.food; //~ ERROR cannot infer + *p = 3us; }; } } diff --git a/src/test/compile-fail/regions-bound-missing-bound-in-impl.rs b/src/test/compile-fail/regions-bound-missing-bound-in-impl.rs index c6a9f67cfc6..5028ec89972 100644 --- a/src/test/compile-fail/regions-bound-missing-bound-in-impl.rs +++ b/src/test/compile-fail/regions-bound-missing-bound-in-impl.rs @@ -13,7 +13,7 @@ // checked. struct Inv<'a> { // invariant w/r/t 'a - x: &'a mut &'a int + x: &'a mut &'a isize } pub trait Foo<'a> { @@ -24,7 +24,7 @@ pub trait Foo<'a> { } -impl<'a> Foo<'a> for &'a int { +impl<'a> Foo<'a> for &'a isize { fn no_bound<'b:'a>(self, b: Inv<'b>) { //~^ ERROR lifetime parameters or bounds on method `no_bound` do not match } diff --git a/src/test/compile-fail/regions-bounded-by-send.rs b/src/test/compile-fail/regions-bounded-by-send.rs index 0628bbb8bb0..e3f0d3bcdb6 100644 --- a/src/test/compile-fail/regions-bounded-by-send.rs +++ b/src/test/compile-fail/regions-bounded-by-send.rs @@ -20,41 +20,41 @@ trait Dummy:Send { } // lifetime pointers with 'static lifetime are ok -fn static_lifime_ok<'a,T,U:Send>(_: &'a int) { - assert_send::<&'static int>(); +fn static_lifime_ok<'a,T,U:Send>(_: &'a isize) { + assert_send::<&'static isize>(); assert_send::<&'static str>(); - assert_send::<&'static [int]>(); + assert_send::<&'static [isize]>(); // whether or not they are mutable - assert_send::<&'static mut int>(); + assert_send::<&'static mut isize>(); } // otherwise lifetime pointers are not ok -fn param_not_ok<'a>(x: &'a int) { - assert_send::<&'a int>(); //~ ERROR declared lifetime bound not satisfied +fn param_not_ok<'a>(x: &'a isize) { + assert_send::<&'a isize>(); //~ ERROR declared lifetime bound not satisfied } -fn param_not_ok1<'a>(_: &'a int) { +fn param_not_ok1<'a>(_: &'a isize) { assert_send::<&'a str>(); //~ ERROR declared lifetime bound not satisfied } -fn param_not_ok2<'a>(_: &'a int) { - assert_send::<&'a [int]>(); //~ ERROR declared lifetime bound not satisfied +fn param_not_ok2<'a>(_: &'a isize) { + assert_send::<&'a [isize]>(); //~ ERROR declared lifetime bound not satisfied } // boxes are ok fn box_ok() { - assert_send::<Box<int>>(); + assert_send::<Box<isize>>(); assert_send::<String>(); - assert_send::<Vec<int>>(); + assert_send::<Vec<isize>>(); } // but not if they own a bad thing fn box_with_region_not_ok<'a>() { - assert_send::<Box<&'a int>>(); //~ ERROR declared lifetime bound not satisfied + assert_send::<Box<&'a isize>>(); //~ ERROR declared lifetime bound not satisfied } // objects with insufficient bounds no ok @@ -71,11 +71,11 @@ fn object_with_send_bound_not_ok<'a>() { // unsafe pointers are ok unless they point at unsendable things -struct UniqueUnsafePtr(Unique<*const int>); +struct UniqueUnsafePtr(Unique<*const isize>); unsafe impl Send for UniqueUnsafePtr {} -fn unsafe_ok1<'a>(_: &'a int) { +fn unsafe_ok1<'a>(_: &'a isize) { assert_send::<UniqueUnsafePtr>(); } diff --git a/src/test/compile-fail/regions-bounded-by-trait-requiring-static.rs b/src/test/compile-fail/regions-bounded-by-trait-requiring-static.rs index e3939a4e390..8194af25d73 100644 --- a/src/test/compile-fail/regions-bounded-by-trait-requiring-static.rs +++ b/src/test/compile-fail/regions-bounded-by-trait-requiring-static.rs @@ -17,56 +17,56 @@ fn assert_send<T:'static>() { } // lifetime pointers with 'static lifetime are ok -fn static_lifime_ok<'a,T,U:Send>(_: &'a int) { - assert_send::<&'static int>(); +fn static_lifime_ok<'a,T,U:Send>(_: &'a isize) { + assert_send::<&'static isize>(); assert_send::<&'static str>(); - assert_send::<&'static [int]>(); + assert_send::<&'static [isize]>(); // whether or not they are mutable - assert_send::<&'static mut int>(); + assert_send::<&'static mut isize>(); } // otherwise lifetime pointers are not ok -fn param_not_ok<'a>(x: &'a int) { - assert_send::<&'a int>(); //~ ERROR declared lifetime bound not satisfied +fn param_not_ok<'a>(x: &'a isize) { + assert_send::<&'a isize>(); //~ ERROR declared lifetime bound not satisfied } -fn param_not_ok1<'a>(_: &'a int) { +fn param_not_ok1<'a>(_: &'a isize) { assert_send::<&'a str>(); //~ ERROR declared lifetime bound not satisfied } -fn param_not_ok2<'a>(_: &'a int) { - assert_send::<&'a [int]>(); //~ ERROR declared lifetime bound not satisfied +fn param_not_ok2<'a>(_: &'a isize) { + assert_send::<&'a [isize]>(); //~ ERROR declared lifetime bound not satisfied } // boxes are ok fn box_ok() { - assert_send::<Box<int>>(); + assert_send::<Box<isize>>(); assert_send::<String>(); - assert_send::<Vec<int>>(); + assert_send::<Vec<isize>>(); } // but not if they own a bad thing fn box_with_region_not_ok<'a>() { - assert_send::<Box<&'a int>>(); //~ ERROR declared lifetime bound not satisfied + assert_send::<Box<&'a isize>>(); //~ ERROR declared lifetime bound not satisfied } // unsafe pointers are ok unless they point at unsendable things -fn unsafe_ok1<'a>(_: &'a int) { - assert_send::<*const int>(); - assert_send::<*mut int>(); +fn unsafe_ok1<'a>(_: &'a isize) { + assert_send::<*const isize>(); + assert_send::<*mut isize>(); } -fn unsafe_ok2<'a>(_: &'a int) { - assert_send::<*const &'a int>(); //~ ERROR declared lifetime bound not satisfied +fn unsafe_ok2<'a>(_: &'a isize) { + assert_send::<*const &'a isize>(); //~ ERROR declared lifetime bound not satisfied } -fn unsafe_ok3<'a>(_: &'a int) { - assert_send::<*mut &'a int>(); //~ ERROR declared lifetime bound not satisfied +fn unsafe_ok3<'a>(_: &'a isize) { + assert_send::<*mut &'a isize>(); //~ ERROR declared lifetime bound not satisfied } fn main() { diff --git a/src/test/compile-fail/regions-bounded-method-type-parameters-trait-bound.rs b/src/test/compile-fail/regions-bounded-method-type-parameters-trait-bound.rs index e628eb3285a..acc721f26b3 100644 --- a/src/test/compile-fail/regions-bounded-method-type-parameters-trait-bound.rs +++ b/src/test/compile-fail/regions-bounded-method-type-parameters-trait-bound.rs @@ -19,7 +19,7 @@ trait Sized { } struct Inv<'a> { // invariant w/r/t 'a - x: &'a mut &'a int + x: &'a mut &'a isize } trait Foo<'x> { diff --git a/src/test/compile-fail/regions-bounded-method-type-parameters.rs b/src/test/compile-fail/regions-bounded-method-type-parameters.rs index 10484925980..9afacacd662 100644 --- a/src/test/compile-fail/regions-bounded-method-type-parameters.rs +++ b/src/test/compile-fail/regions-bounded-method-type-parameters.rs @@ -18,8 +18,8 @@ impl Foo { fn some_method<A:'static>(self) { } } -fn caller<'a>(x: &int) { - Foo.some_method::<&'a int>(); +fn caller<'a>(x: &isize) { + Foo.some_method::<&'a isize>(); //~^ ERROR declared lifetime bound not satisfied } diff --git a/src/test/compile-fail/regions-bounds.rs b/src/test/compile-fail/regions-bounds.rs index e13a6b211a5..c26740c9598 100644 --- a/src/test/compile-fail/regions-bounds.rs +++ b/src/test/compile-fail/regions-bounds.rs @@ -12,8 +12,8 @@ // nominal types (but not on other types) and that they are type // checked. -struct an_enum<'a>(&'a int); -struct a_class<'a> { x:&'a int } +struct an_enum<'a>(&'a isize); +struct a_class<'a> { x:&'a isize } fn a_fn1<'a,'b>(e: an_enum<'a>) -> an_enum<'b> { return e; //~ ERROR mismatched types: expected `an_enum<'b>`, found `an_enum<'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 e17786e6a51..25b8137d29c 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 @@ -12,12 +12,12 @@ trait Foo { } -impl<'a> Foo for &'a int { } +impl<'a> Foo for &'a isize { } fn main() { let blah; { - let ss: &int = &1; //~ ERROR borrowed value does not live long enough + let ss: &isize = &1; //~ ERROR borrowed value does not live long enough blah = box ss as Box<Foo>; } } 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 985ae6116f0..fc18095fc83 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 @@ -14,7 +14,7 @@ // an object. This should yield errors unless `A` (and the object) // both have suitable bounds. -trait SomeTrait { fn get(&self) -> int; } +trait SomeTrait { fn get(&self) -> isize; } fn make_object1<A:SomeTrait>(v: A) -> Box<SomeTrait+'static> { box v as Box<SomeTrait+'static> 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 85ff336b4cb..543d4d1620b 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 @@ -26,10 +26,10 @@ fn repeater3<'a,A:'a>(v: A) -> Box<Foo+'a> { fn main() { // Error results because the type of is inferred to be - // ~Repeat<&'blk int> where blk is the lifetime of the block below. + // ~Repeat<&'blk isize> where blk is the lifetime of the block below. let _ = { - let tmp0 = 3i; + let tmp0 = 3is; let tmp1 = &tmp0; //~ ERROR `tmp0` does not live long enough repeater3(tmp1) }; 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 2aa77b2e53d..0f8bc6d684f 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 @@ -13,7 +13,7 @@ // Various tests where we over type parameters with multiple lifetime // bounds. -trait SomeTrait { fn get(&self) -> int; } +trait SomeTrait { fn get(&self) -> isize; } fn make_object_good1<'a,'b,A:SomeTrait+'a+'b>(v: A) -> Box<SomeTrait+'a> { // A outlives 'a AND 'b... diff --git a/src/test/compile-fail/regions-creating-enums.rs b/src/test/compile-fail/regions-creating-enums.rs index 1774c9fada9..83cef9397c3 100644 --- a/src/test/compile-fail/regions-creating-enums.rs +++ b/src/test/compile-fail/regions-creating-enums.rs @@ -9,25 +9,25 @@ // except according to those terms. enum ast<'a> { - num(uint), + num(usize), add(&'a ast<'a>, &'a ast<'a>) } fn build() { - let x = ast::num(3u); - let y = ast::num(4u); + let x = ast::num(3us); + let y = ast::num(4us); let z = ast::add(&x, &y); compute(&z); } -fn compute(x: &ast) -> uint { +fn compute(x: &ast) -> usize { match *x { ast::num(x) => { x } ast::add(x, y) => { compute(x) + compute(y) } } } -fn map_nums<'a,'b, F>(x: &ast, f: &mut F) -> &'a ast<'b> where F: FnMut(uint) -> uint { +fn map_nums<'a,'b, F>(x: &ast, f: &mut F) -> &'a ast<'b> where F: FnMut(usize) -> usize { match *x { ast::num(x) => { return &ast::num((*f)(x)); //~ ERROR borrowed value does not live long enough diff --git a/src/test/compile-fail/regions-creating-enums3.rs b/src/test/compile-fail/regions-creating-enums3.rs index 6f38f29591f..4c8484540aa 100644 --- a/src/test/compile-fail/regions-creating-enums3.rs +++ b/src/test/compile-fail/regions-creating-enums3.rs @@ -9,7 +9,7 @@ // except according to those terms. enum ast<'a> { - num(uint), + num(usize), add(&'a ast<'a>, &'a ast<'a>) } diff --git a/src/test/compile-fail/regions-creating-enums4.rs b/src/test/compile-fail/regions-creating-enums4.rs index 34a125c809f..5dc9b370f32 100644 --- a/src/test/compile-fail/regions-creating-enums4.rs +++ b/src/test/compile-fail/regions-creating-enums4.rs @@ -9,7 +9,7 @@ // except according to those terms. enum ast<'a> { - num(uint), + num(usize), add(&'a ast<'a>, &'a ast<'a>) } diff --git a/src/test/compile-fail/regions-early-bound-error-method.rs b/src/test/compile-fail/regions-early-bound-error-method.rs index 0cb88b924f8..9de0ed070c7 100644 --- a/src/test/compile-fail/regions-early-bound-error-method.rs +++ b/src/test/compile-fail/regions-early-bound-error-method.rs @@ -12,21 +12,21 @@ // the value for a type parameter in a bound. trait GetRef<'a> { - fn get(&self) -> &'a int; + fn get(&self) -> &'a isize; } struct Box<'a> { - t: &'a int + t: &'a isize } impl<'a> GetRef<'a> for Box<'a> { - fn get(&self) -> &'a int { + fn get(&self) -> &'a isize { self.t } } impl<'a> Box<'a> { - fn or<'b,G:GetRef<'b>>(&self, g2: G) -> &'a int { + fn or<'b,G:GetRef<'b>>(&self, g2: G) -> &'a isize { g2.get() //~ ERROR cannot infer an appropriate lifetime for automatic coercion due to } } diff --git a/src/test/compile-fail/regions-early-bound-error.rs b/src/test/compile-fail/regions-early-bound-error.rs index 5da281d93dd..37b74aea539 100644 --- a/src/test/compile-fail/regions-early-bound-error.rs +++ b/src/test/compile-fail/regions-early-bound-error.rs @@ -25,7 +25,7 @@ impl<'a,T:Clone> GetRef<'a,T> for Box<'a,T> { } } -fn get<'a,'b,G:GetRef<'a, int>>(g1: G, b: &'b int) -> &'b int { +fn get<'a,'b,G:GetRef<'a, isize>>(g1: G, b: &'b isize) -> &'b isize { g1.get() //~ ERROR cannot infer an appropriate lifetime for automatic coercion due to } diff --git a/src/test/compile-fail/regions-enum-not-wf.rs b/src/test/compile-fail/regions-enum-not-wf.rs index 0691ad0de73..0165dbdabf3 100644 --- a/src/test/compile-fail/regions-enum-not-wf.rs +++ b/src/test/compile-fail/regions-enum-not-wf.rs @@ -18,7 +18,7 @@ enum Ref1<'a, T> { //~ ERROR the parameter type `T` may not live long enough enum Ref2<'a, T> { //~ ERROR the parameter type `T` may not live long enough Ref2Variant1, - Ref2Variant2(int, &'a T), + Ref2Variant2(isize, &'a T), } enum RefOk<'a, T:'a> { @@ -26,7 +26,7 @@ enum RefOk<'a, T:'a> { } enum RefIndirect<'a, T> { //~ ERROR the parameter type `T` may not live long enough - RefIndirectVariant1(int, RefOk<'a,T>) + RefIndirectVariant1(isize, RefOk<'a,T>) } enum RefDouble<'a, 'b, T> { //~ ERROR reference has a longer lifetime than the data diff --git a/src/test/compile-fail/regions-escape-bound-fn-2.rs b/src/test/compile-fail/regions-escape-bound-fn-2.rs index 547accbf086..1329d05a0f6 100644 --- a/src/test/compile-fail/regions-escape-bound-fn-2.rs +++ b/src/test/compile-fail/regions-escape-bound-fn-2.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -fn with_int<F>(f: F) where F: FnOnce(&int) { +fn with_int<F>(f: F) where F: FnOnce(&isize) { let x = 3; f(&x); } diff --git a/src/test/compile-fail/regions-escape-bound-fn.rs b/src/test/compile-fail/regions-escape-bound-fn.rs index 6d67bd80650..02e62ffddfd 100644 --- a/src/test/compile-fail/regions-escape-bound-fn.rs +++ b/src/test/compile-fail/regions-escape-bound-fn.rs @@ -8,12 +8,12 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -fn with_int<F>(f: F) where F: FnOnce(&int) { +fn with_int<F>(f: F) where F: FnOnce(&isize) { let x = 3; f(&x); } fn main() { - let mut x: Option<&int> = None; + let mut x: Option<&isize> = None; with_int(|y| x = Some(y)); //~ ERROR cannot infer } diff --git a/src/test/compile-fail/regions-escape-loop-via-variable.rs b/src/test/compile-fail/regions-escape-loop-via-variable.rs index 472df87dd2b..c300c86f70f 100644 --- a/src/test/compile-fail/regions-escape-loop-via-variable.rs +++ b/src/test/compile-fail/regions-escape-loop-via-variable.rs @@ -9,7 +9,7 @@ // except according to those terms. fn main() { - let x = 3i; + let x = 3is; // Here, the variable `p` gets inferred to a type with a lifetime // of the loop body. The regionck then determines that this type @@ -17,7 +17,7 @@ fn main() { let mut p = &x; loop { - let x = 1i + *p; + let x = 1is + *p; p = &x; //~ ERROR `x` does not live long enough } } diff --git a/src/test/compile-fail/regions-escape-loop-via-vec.rs b/src/test/compile-fail/regions-escape-loop-via-vec.rs index 22c6bdd2d50..5e6e1858cf1 100644 --- a/src/test/compile-fail/regions-escape-loop-via-vec.rs +++ b/src/test/compile-fail/regions-escape-loop-via-vec.rs @@ -10,7 +10,7 @@ // The type of `y` ends up getting inferred to the type of the block. fn broken() { - let mut x = 3i; + let mut x = 3is; let mut _y = vec!(&mut x); while x < 10 { //~ ERROR cannot use `x` because it was mutably borrowed let mut z = x; //~ ERROR cannot use `x` because it was mutably borrowed diff --git a/src/test/compile-fail/regions-escape-unboxed-closure.rs b/src/test/compile-fail/regions-escape-unboxed-closure.rs index 70f0d61b5ee..06768fa6880 100644 --- a/src/test/compile-fail/regions-escape-unboxed-closure.rs +++ b/src/test/compile-fail/regions-escape-unboxed-closure.rs @@ -10,10 +10,10 @@ #![feature(unboxed_closures)] -fn with_int(f: &mut FnMut(&int)) { +fn with_int(f: &mut FnMut(&isize)) { } fn main() { - let mut x: Option<&int> = None; + let mut x: Option<&isize> = None; with_int(&mut |&mut: y| x = Some(y)); //~ ERROR cannot infer } diff --git a/src/test/compile-fail/regions-escape-via-trait-or-not.rs b/src/test/compile-fail/regions-escape-via-trait-or-not.rs index 873d4cea039..a4363b00e1c 100644 --- a/src/test/compile-fail/regions-escape-via-trait-or-not.rs +++ b/src/test/compile-fail/regions-escape-via-trait-or-not.rs @@ -11,20 +11,20 @@ #![allow(dead_code)] trait Deref { - fn get(self) -> int; + fn get(self) -> isize; } -impl<'a> Deref for &'a int { - fn get(self) -> int { +impl<'a> Deref for &'a isize { + fn get(self) -> isize { *self } } -fn with<R:Deref, F>(f: F) -> int where F: FnOnce(&int) -> R { +fn with<R:Deref, F>(f: F) -> isize where F: FnOnce(&isize) -> R { f(&3).get() } -fn return_it() -> int { +fn return_it() -> isize { with(|o| o) //~ ERROR cannot infer } diff --git a/src/test/compile-fail/regions-free-region-ordering-callee.rs b/src/test/compile-fail/regions-free-region-ordering-callee.rs index 6e59a29b8cf..22724081a1b 100644 --- a/src/test/compile-fail/regions-free-region-ordering-callee.rs +++ b/src/test/compile-fail/regions-free-region-ordering-callee.rs @@ -12,32 +12,32 @@ // that appear in their parameter list. See also // regions-free-region-ordering-caller.rs -fn ordering1<'a, 'b>(x: &'a &'b uint) -> &'a uint { +fn ordering1<'a, 'b>(x: &'a &'b usize) -> &'a usize { // It is safe to assume that 'a <= 'b due to the type of x - let y: &'b uint = &**x; + let y: &'b usize = &**x; return y; } -fn ordering2<'a, 'b>(x: &'a &'b uint, y: &'a uint) -> &'b uint { +fn ordering2<'a, 'b>(x: &'a &'b usize, y: &'a usize) -> &'b usize { // However, it is not safe to assume that 'b <= 'a &*y //~ ERROR cannot infer } -fn ordering3<'a, 'b>(x: &'a uint, y: &'b uint) -> &'a &'b uint { +fn ordering3<'a, 'b>(x: &'a usize, y: &'b usize) -> &'a &'b usize { // Do not infer an ordering from the return value. - let z: &'b uint = &*x; + let z: &'b usize = &*x; //~^ ERROR cannot infer panic!(); } -fn ordering4<'a, 'b, F>(a: &'a uint, b: &'b uint, x: F) where F: FnOnce(&'a &'b uint) { +fn ordering4<'a, 'b, F>(a: &'a usize, b: &'b usize, x: F) where F: FnOnce(&'a &'b usize) { // Do not infer ordering from closure argument types. - let z: Option<&'a &'b uint> = None; + let z: Option<&'a &'b usize> = None; //~^ ERROR reference has a longer lifetime than the data it references } -fn ordering5<'a, 'b>(a: &'a uint, b: &'b uint, x: Option<&'a &'b uint>) { - let z: Option<&'a &'b uint> = None; +fn ordering5<'a, 'b>(a: &'a usize, b: &'b usize, x: Option<&'a &'b usize>) { + let z: Option<&'a &'b usize> = None; } fn main() {} diff --git a/src/test/compile-fail/regions-free-region-ordering-caller.rs b/src/test/compile-fail/regions-free-region-ordering-caller.rs index 55c0cf3bb26..edca3b7ed41 100644 --- a/src/test/compile-fail/regions-free-region-ordering-caller.rs +++ b/src/test/compile-fail/regions-free-region-ordering-caller.rs @@ -12,21 +12,21 @@ // than the thing it points at and ensure that they result in // errors. See also regions-free-region-ordering-callee.rs -struct Paramd<'a> { x: &'a uint } +struct Paramd<'a> { x: &'a usize } -fn call2<'a, 'b>(a: &'a uint, b: &'b uint) { - let z: Option<&'b &'a uint> = None; +fn call2<'a, 'b>(a: &'a usize, b: &'b usize) { + let z: Option<&'b &'a usize> = None; //~^ ERROR reference has a longer lifetime than the data it references } -fn call3<'a, 'b>(a: &'a uint, b: &'b uint) { +fn call3<'a, 'b>(a: &'a usize, b: &'b usize) { let y: Paramd<'a> = Paramd { x: a }; let z: Option<&'b Paramd<'a>> = None; //~^ ERROR reference has a longer lifetime than the data it references } -fn call4<'a, 'b>(a: &'a uint, b: &'b uint) { - let z: Option<&'a &'b uint> = None; +fn call4<'a, 'b>(a: &'a usize, b: &'b usize) { + let z: Option<&'a &'b usize> = None; //~^ ERROR reference has a longer lifetime than the data it references } diff --git a/src/test/compile-fail/regions-free-region-ordering-caller1.rs b/src/test/compile-fail/regions-free-region-ordering-caller1.rs index b117a1a6476..b29518ccdab 100644 --- a/src/test/compile-fail/regions-free-region-ordering-caller1.rs +++ b/src/test/compile-fail/regions-free-region-ordering-caller1.rs @@ -12,11 +12,11 @@ // than the thing it points at and ensure that they result in // errors. See also regions-free-region-ordering-callee.rs -fn call1<'a>(x: &'a uint) { +fn call1<'a>(x: &'a usize) { // Test that creating a pointer like - // &'a &'z uint requires that 'a <= 'z: - let y: uint = 3; - let z: &'a & uint = &(&y); + // &'a &'z usize requires that 'a <= 'z: + let y: usize = 3; + let z: &'a & usize = &(&y); //~^ ERROR borrowed value does not live long enough //~^^ ERROR `y` does not live long enough } diff --git a/src/test/compile-fail/regions-glb-free-free.rs b/src/test/compile-fail/regions-glb-free-free.rs index 0eb47da16b6..f43d35c579e 100644 --- a/src/test/compile-fail/regions-glb-free-free.rs +++ b/src/test/compile-fail/regions-glb-free-free.rs @@ -12,8 +12,8 @@ mod argparse { pub struct Flag<'a> { name: &'a str, desc: &'a str, - max_count: uint, - value: uint + max_count: usize, + value: usize } pub fn flag<'r>(name: &'r str, desc: &'r str) -> Flag<'r> { diff --git a/src/test/compile-fail/regions-in-consts.rs b/src/test/compile-fail/regions-in-consts.rs index 9f2facf4e1f..8d0829a4cff 100644 --- a/src/test/compile-fail/regions-in-consts.rs +++ b/src/test/compile-fail/regions-in-consts.rs @@ -8,8 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -static c_y: &int = &22; //~ ERROR missing lifetime specifier -static c_z: &'static int = &22; +static c_y: &isize = &22; //~ ERROR missing lifetime specifier +static c_z: &'static isize = &22; fn main() { } diff --git a/src/test/compile-fail/regions-in-enums-anon.rs b/src/test/compile-fail/regions-in-enums-anon.rs index 5c7a37d0359..305bf88c4d5 100644 --- a/src/test/compile-fail/regions-in-enums-anon.rs +++ b/src/test/compile-fail/regions-in-enums-anon.rs @@ -11,7 +11,7 @@ // Test that anonymous lifetimes are not permitted in enum declarations enum Foo { - Bar(&int) //~ ERROR missing lifetime specifier + Bar(&isize) //~ ERROR missing lifetime specifier } fn main() {} diff --git a/src/test/compile-fail/regions-in-enums.rs b/src/test/compile-fail/regions-in-enums.rs index 72b32e4a9af..613a90dda67 100644 --- a/src/test/compile-fail/regions-in-enums.rs +++ b/src/test/compile-fail/regions-in-enums.rs @@ -12,19 +12,19 @@ // See also regions-undeclared.rs enum yes0<'lt> { - X3(&'lt uint) + X3(&'lt usize) } enum yes1<'a> { - X4(&'a uint) + X4(&'a usize) } enum no0 { - X5(&'foo uint) //~ ERROR use of undeclared lifetime name `'foo` + X5(&'foo usize) //~ ERROR use of undeclared lifetime name `'foo` } enum no1 { - X6(&'a uint) //~ ERROR use of undeclared lifetime name `'a` + X6(&'a usize) //~ ERROR use of undeclared lifetime name `'a` } fn main() {} diff --git a/src/test/compile-fail/regions-in-structs-anon.rs b/src/test/compile-fail/regions-in-structs-anon.rs index 0f2036a56cd..b85928b1b9f 100644 --- a/src/test/compile-fail/regions-in-structs-anon.rs +++ b/src/test/compile-fail/regions-in-structs-anon.rs @@ -11,7 +11,7 @@ // Test that anonymous lifetimes are not permitted in struct declarations struct Foo { - x: &int //~ ERROR missing lifetime specifier + x: &isize //~ ERROR missing lifetime specifier } fn main() {} diff --git a/src/test/compile-fail/regions-in-structs.rs b/src/test/compile-fail/regions-in-structs.rs index 0c5cb98e6a4..c231d3a913e 100644 --- a/src/test/compile-fail/regions-in-structs.rs +++ b/src/test/compile-fail/regions-in-structs.rs @@ -9,16 +9,16 @@ // except according to those terms. struct yes1<'a> { - x: &'a uint, + x: &'a usize, } struct yes2<'a> { - x: &'a uint, + x: &'a usize, } struct StructDecl { - a: &'a int, //~ ERROR use of undeclared lifetime name `'a` - b: &'a int, //~ ERROR use of undeclared lifetime name `'a` + a: &'a isize, //~ ERROR use of undeclared lifetime name `'a` + b: &'a isize, //~ ERROR use of undeclared lifetime name `'a` } diff --git a/src/test/compile-fail/regions-infer-borrow-scope-too-big.rs b/src/test/compile-fail/regions-infer-borrow-scope-too-big.rs index b710578969b..2628e6a1ce2 100644 --- a/src/test/compile-fail/regions-infer-borrow-scope-too-big.rs +++ b/src/test/compile-fail/regions-infer-borrow-scope-too-big.rs @@ -10,15 +10,15 @@ struct point { - x: int, - y: int, + x: isize, + y: isize, } -fn x_coord<'r>(p: &'r point) -> &'r int { +fn x_coord<'r>(p: &'r point) -> &'r isize { return &p.x; } -fn foo<'a>(p: Box<point>) -> &'a int { +fn foo<'a>(p: Box<point>) -> &'a isize { let xc = x_coord(&*p); //~ ERROR `*p` does not live long enough assert_eq!(*xc, 3); return xc; diff --git a/src/test/compile-fail/regions-infer-borrow-scope-within-loop.rs b/src/test/compile-fail/regions-infer-borrow-scope-within-loop.rs index c8edd936bf2..a05658e9e58 100644 --- a/src/test/compile-fail/regions-infer-borrow-scope-within-loop.rs +++ b/src/test/compile-fail/regions-infer-borrow-scope-within-loop.rs @@ -13,9 +13,9 @@ fn borrow<T>(x: &T) -> &T {x} fn foo<C, M>(mut cond: C, mut make_box: M) where C: FnMut() -> bool, - M: FnMut() -> Box<int>, + M: FnMut() -> Box<isize>, { - let mut y: ∫ + let mut y: &isize; loop { let x = make_box(); diff --git a/src/test/compile-fail/regions-infer-bound-from-trait-self.rs b/src/test/compile-fail/regions-infer-bound-from-trait-self.rs index aeb003ca5d0..23b8ebfe54b 100644 --- a/src/test/compile-fail/regions-infer-bound-from-trait-self.rs +++ b/src/test/compile-fail/regions-infer-bound-from-trait-self.rs @@ -16,7 +16,7 @@ trait Static : 'static { } trait Is<'a> : 'a { } struct Inv<'a> { - x: Option<&'a mut &'a int> + x: Option<&'a mut &'a isize> } fn check_bound<'a,A:'a>(x: Inv<'a>, a: A) { } diff --git a/src/test/compile-fail/regions-infer-bound-from-trait.rs b/src/test/compile-fail/regions-infer-bound-from-trait.rs index d1111377f1e..f7a91054766 100644 --- a/src/test/compile-fail/regions-infer-bound-from-trait.rs +++ b/src/test/compile-fail/regions-infer-bound-from-trait.rs @@ -16,7 +16,7 @@ trait Static : 'static { } trait Is<'a> : 'a { } struct Inv<'a> { - x: Option<&'a mut &'a int> + x: Option<&'a mut &'a isize> } fn check_bound<'a,A:'a>(x: Inv<'a>, a: A) { } diff --git a/src/test/compile-fail/regions-infer-call-3.rs b/src/test/compile-fail/regions-infer-call-3.rs index ac41f2a5b3e..95783a420b6 100644 --- a/src/test/compile-fail/regions-infer-call-3.rs +++ b/src/test/compile-fail/regions-infer-call-3.rs @@ -8,13 +8,13 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -fn select<'r>(x: &'r int, y: &'r int) -> &'r int { x } +fn select<'r>(x: &'r isize, y: &'r isize) -> &'r isize { x } -fn with<T, F>(f: F) -> T where F: FnOnce(&int) -> T { +fn with<T, F>(f: F) -> T where F: FnOnce(&isize) -> T { f(&20) } -fn manip<'a>(x: &'a int) -> int { +fn manip<'a>(x: &'a isize) -> isize { let z = with(|y| { select(x, y) }); //~^ ERROR cannot infer *z diff --git a/src/test/compile-fail/regions-infer-contravariance-due-to-decl.rs b/src/test/compile-fail/regions-infer-contravariance-due-to-decl.rs index 4d31d2c8e69..6c5e90a54de 100644 --- a/src/test/compile-fail/regions-infer-contravariance-due-to-decl.rs +++ b/src/test/compile-fail/regions-infer-contravariance-due-to-decl.rs @@ -24,8 +24,8 @@ struct Contravariant<'a> { } fn use_<'short,'long>(c: Contravariant<'short>, - s: &'short int, - l: &'long int, + s: &'short isize, + l: &'long isize, _where:Option<&'short &'long ()>) { // Test whether Contravariant<'short> <: Contravariant<'long>. Since diff --git a/src/test/compile-fail/regions-infer-covariance-due-to-decl.rs b/src/test/compile-fail/regions-infer-covariance-due-to-decl.rs index 1c3b7bb5960..d8e31fa1374 100644 --- a/src/test/compile-fail/regions-infer-covariance-due-to-decl.rs +++ b/src/test/compile-fail/regions-infer-covariance-due-to-decl.rs @@ -21,8 +21,8 @@ struct Covariant<'a> { } fn use_<'short,'long>(c: Covariant<'long>, - s: &'short int, - l: &'long int, + s: &'short isize, + l: &'long isize, _where:Option<&'short &'long ()>) { // Test whether Covariant<'long> <: Covariant<'short>. Since diff --git a/src/test/compile-fail/regions-infer-invariance-due-to-mutability-3.rs b/src/test/compile-fail/regions-infer-invariance-due-to-mutability-3.rs index 190e444fe7e..e42aa684e14 100644 --- a/src/test/compile-fail/regions-infer-invariance-due-to-mutability-3.rs +++ b/src/test/compile-fail/regions-infer-invariance-due-to-mutability-3.rs @@ -10,7 +10,7 @@ struct invariant<'a> { - f: Box<FnOnce(&mut &'a int) + 'static>, + f: Box<FnOnce(&mut &'a isize) + 'static>, } fn to_same_lifetime<'r>(bi: invariant<'r>) { diff --git a/src/test/compile-fail/regions-infer-invariance-due-to-mutability-4.rs b/src/test/compile-fail/regions-infer-invariance-due-to-mutability-4.rs index 71d0c988c5e..2e634dfe3eb 100644 --- a/src/test/compile-fail/regions-infer-invariance-due-to-mutability-4.rs +++ b/src/test/compile-fail/regions-infer-invariance-due-to-mutability-4.rs @@ -10,7 +10,7 @@ struct invariant<'a> { - f: Box<for<'b> FnOnce() -> &'b mut &'a int + 'static>, + f: Box<for<'b> FnOnce() -> &'b mut &'a isize + 'static>, } fn to_same_lifetime<'r>(bi: invariant<'r>) { diff --git a/src/test/compile-fail/regions-infer-not-param.rs b/src/test/compile-fail/regions-infer-not-param.rs index 323ebc3c20b..5d7a218ca8a 100644 --- a/src/test/compile-fail/regions-infer-not-param.rs +++ b/src/test/compile-fail/regions-infer-not-param.rs @@ -9,7 +9,7 @@ // except according to those terms. struct direct<'a> { - f: &'a int + f: &'a isize } struct indirect1 { diff --git a/src/test/compile-fail/regions-infer-paramd-method.rs b/src/test/compile-fail/regions-infer-paramd-method.rs index 772ccadda52..ef331bb0fd7 100644 --- a/src/test/compile-fail/regions-infer-paramd-method.rs +++ b/src/test/compile-fail/regions-infer-paramd-method.rs @@ -25,9 +25,9 @@ // refers to self. trait foo<'a> { - fn self_int(self) -> &'a int; + fn self_int(self) -> &'a isize; - fn any_int(self) -> ∫ + fn any_int(self) -> &isize; } struct with_foo<'a> { @@ -47,7 +47,7 @@ impl<'a> set_foo_foo for with_foo<'a> { // Bar is not region parameterized. trait bar { - fn any_int(&self) -> ∫ + fn any_int(&self) -> &isize; } struct with_bar { diff --git a/src/test/compile-fail/regions-infer-proc-static-upvar.rs b/src/test/compile-fail/regions-infer-proc-static-upvar.rs index 8b2fdfe7cdd..4e99f64dbf7 100644 --- a/src/test/compile-fail/regions-infer-proc-static-upvar.rs +++ b/src/test/compile-fail/regions-infer-proc-static-upvar.rs @@ -13,10 +13,10 @@ fn foo<F:FnOnce()+'static>(_p: F) { } -static i: int = 3; +static i: isize = 3; fn capture_local() { - let x = 3i; + let x = 3is; let y = &x; //~ ERROR `x` does not live long enough foo(move|| { let _a = *y; diff --git a/src/test/compile-fail/regions-lifetime-bounds-on-fns.rs b/src/test/compile-fail/regions-lifetime-bounds-on-fns.rs index 4a42728da6f..43940d499d2 100644 --- a/src/test/compile-fail/regions-lifetime-bounds-on-fns.rs +++ b/src/test/compile-fail/regions-lifetime-bounds-on-fns.rs @@ -8,17 +8,17 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -fn a<'a, 'b:'a>(x: &mut &'a int, y: &mut &'b int) { +fn a<'a, 'b:'a>(x: &mut &'a isize, y: &mut &'b isize) { // Note: this is legal because of the `'b:'a` declaration. *x = *y; } -fn b<'a, 'b>(x: &mut &'a int, y: &mut &'b int) { +fn b<'a, 'b>(x: &mut &'a isize, y: &mut &'b isize) { // Illegal now because there is no `'b:'a` declaration. *x = *y; //~ ERROR cannot infer } -fn c<'a,'b>(x: &mut &'a int, y: &mut &'b int) { +fn c<'a,'b>(x: &mut &'a isize, y: &mut &'b isize) { // Here we try to call `foo` but do not know that `'a` and `'b` are // related as required. a(x, y); //~ ERROR cannot infer @@ -27,13 +27,13 @@ fn c<'a,'b>(x: &mut &'a int, y: &mut &'b int) { fn d() { // 'a and 'b are early bound in the function `a` because they appear // inconstraints: - let _: fn(&mut &int, &mut &int) = a; //~ ERROR mismatched types + let _: fn(&mut &isize, &mut &isize) = a; //~ ERROR mismatched types } fn e() { // 'a and 'b are late bound in the function `b` because there are // no constraints: - let _: fn(&mut &int, &mut &int) = b; + let _: fn(&mut &isize, &mut &isize) = b; } fn main() { } diff --git a/src/test/compile-fail/regions-name-duplicated.rs b/src/test/compile-fail/regions-name-duplicated.rs index 518fe0b00b6..b4b9cfd75cb 100644 --- a/src/test/compile-fail/regions-name-duplicated.rs +++ b/src/test/compile-fail/regions-name-duplicated.rs @@ -9,7 +9,7 @@ // except according to those terms. struct Foo<'a, 'a> { //~ ERROR lifetime name `'a` declared twice - x: &'a int + x: &'a isize } fn main() {} diff --git a/src/test/compile-fail/regions-name-static.rs b/src/test/compile-fail/regions-name-static.rs index 9f50ad36660..29896aa486b 100644 --- a/src/test/compile-fail/regions-name-static.rs +++ b/src/test/compile-fail/regions-name-static.rs @@ -9,7 +9,7 @@ // except according to those terms. struct Foo<'static> { //~ ERROR illegal lifetime parameter name: `'static` - x: &'static int + x: &'static isize } fn main() {} diff --git a/src/test/compile-fail/regions-name-undeclared.rs b/src/test/compile-fail/regions-name-undeclared.rs index b9c721159f2..a61d3094933 100644 --- a/src/test/compile-fail/regions-name-undeclared.rs +++ b/src/test/compile-fail/regions-name-undeclared.rs @@ -12,48 +12,48 @@ // rules correctly in various scenarios. struct Foo<'a> { - x: &'a int + x: &'a isize } impl<'a> Foo<'a> { // &'a is inherited: - fn m1(&self, arg: &'a int) { } + fn m1(&self, arg: &'a isize) { } fn m2(&'a self) { } fn m3(&self, arg: Foo<'a>) { } // &'b is not: - fn m4(&self, arg: &'b int) { } //~ ERROR undeclared lifetime + fn m4(&self, arg: &'b isize) { } //~ ERROR undeclared lifetime fn m5(&'b self) { } //~ ERROR undeclared lifetime fn m6(&self, arg: Foo<'b>) { } //~ ERROR undeclared lifetime } -fn bar<'a>(x: &'a int) { +fn bar<'a>(x: &'a isize) { // &'a is visible to code: - let y: &'a int = x; + let y: &'a isize = x; // &'a is not visible to *items*: - type X = Option<&'a int>; //~ ERROR undeclared lifetime + type X = Option<&'a isize>; //~ ERROR undeclared lifetime enum E { - E1(&'a int) //~ ERROR undeclared lifetime + E1(&'a isize) //~ ERROR undeclared lifetime } struct S { - f: &'a int //~ ERROR undeclared lifetime + f: &'a isize //~ ERROR undeclared lifetime } - fn f(a: &'a int) { } //~ ERROR undeclared lifetime + fn f(a: &'a isize) { } //~ ERROR undeclared lifetime // &'a CAN be declared on functions and used then: - fn g<'a>(a: &'a int) { } // OK - fn h(a: Box<for<'a> FnOnce(&'a int)>) { } // OK + fn g<'a>(a: &'a isize) { } // OK + fn h(a: Box<for<'a> FnOnce(&'a isize)>) { } // OK } // Test nesting of lifetimes in fn type declarations -fn fn_types(a: &'a int, //~ ERROR undeclared lifetime - b: Box<for<'a> FnOnce(&'a int, - &'b int, //~ ERROR undeclared lifetime - Box<for<'b> FnOnce(&'a int, - &'b int)>, - &'b int)>, //~ ERROR undeclared lifetime - c: &'a int) //~ ERROR undeclared lifetime +fn fn_types(a: &'a isize, //~ ERROR undeclared lifetime + b: Box<for<'a> FnOnce(&'a isize, + &'b isize, //~ ERROR undeclared lifetime + Box<for<'b> FnOnce(&'a isize, + &'b isize)>, + &'b isize)>, //~ ERROR undeclared lifetime + c: &'a isize) //~ ERROR undeclared lifetime { } diff --git a/src/test/compile-fail/regions-nested-fns-2.rs b/src/test/compile-fail/regions-nested-fns-2.rs index b7fe893a1f5..bdebadb2832 100644 --- a/src/test/compile-fail/regions-nested-fns-2.rs +++ b/src/test/compile-fail/regions-nested-fns-2.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -fn ignore<F>(_f: F) where F: for<'z> FnOnce(&'z int) -> &'z int {} +fn ignore<F>(_f: F) where F: for<'z> FnOnce(&'z isize) -> &'z isize {} fn nested() { let y = 3; diff --git a/src/test/compile-fail/regions-nested-fns.rs b/src/test/compile-fail/regions-nested-fns.rs index e8054779774..58386c319f8 100644 --- a/src/test/compile-fail/regions-nested-fns.rs +++ b/src/test/compile-fail/regions-nested-fns.rs @@ -12,17 +12,17 @@ fn ignore<T>(t: T) {} -fn nested<'x>(x: &'x int) { +fn nested<'x>(x: &'x isize) { let y = 3; let mut ay = &y; - ignore::<Box<for<'z> FnMut(&'z int)>>(box |z| { + ignore::<Box<for<'z> FnMut(&'z isize)>>(box |z| { ay = x; //~ ERROR cannot infer ay = &y; ay = z; }); - ignore::< Box<for<'z> FnMut(&'z int) -> &'z int>>(box |z| { + ignore::< Box<for<'z> FnMut(&'z isize) -> &'z isize>>(box |z| { if false { return x; } //~ ERROR cannot infer an appropriate lifetime for automatic if false { return ay; } return z; diff --git a/src/test/compile-fail/regions-proc-bound-capture.rs b/src/test/compile-fail/regions-proc-bound-capture.rs index b849ddf7b82..7ea4d1c7507 100644 --- a/src/test/compile-fail/regions-proc-bound-capture.rs +++ b/src/test/compile-fail/regions-proc-bound-capture.rs @@ -10,13 +10,13 @@ #![feature(box_syntax)] -fn borrowed_proc<'a>(x: &'a int) -> Box<FnMut()->(int) + 'a> { +fn borrowed_proc<'a>(x: &'a isize) -> Box<FnMut()->(isize) + 'a> { // This is legal, because the region bound on `proc` // states that it captures `x`. box move|| { *x } } -fn static_proc(x: &int) -> Box<FnMut()->(int) + 'static> { +fn static_proc(x: &isize) -> Box<FnMut()->(isize) + 'static> { // This is illegal, because the region bound on `proc` is 'static. box move|| { *x } //~ ERROR cannot infer } diff --git a/src/test/compile-fail/regions-reborrow-from-shorter-mut-ref-mut-ref.rs b/src/test/compile-fail/regions-reborrow-from-shorter-mut-ref-mut-ref.rs index 783009f6dcb..9743f11c966 100644 --- a/src/test/compile-fail/regions-reborrow-from-shorter-mut-ref-mut-ref.rs +++ b/src/test/compile-fail/regions-reborrow-from-shorter-mut-ref-mut-ref.rs @@ -10,7 +10,7 @@ // Issue #8624. Test for reborrowing with 3 levels, not just two. -fn copy_borrowed_ptr<'a, 'b, 'c>(p: &'a mut &'b mut &'c mut int) -> &'b mut int { +fn copy_borrowed_ptr<'a, 'b, 'c>(p: &'a mut &'b mut &'c mut isize) -> &'b mut isize { &mut ***p //~ ERROR cannot infer } diff --git a/src/test/compile-fail/regions-reborrow-from-shorter-mut-ref.rs b/src/test/compile-fail/regions-reborrow-from-shorter-mut-ref.rs index 4b1c7a2928b..399ebd6a2a7 100644 --- a/src/test/compile-fail/regions-reborrow-from-shorter-mut-ref.rs +++ b/src/test/compile-fail/regions-reborrow-from-shorter-mut-ref.rs @@ -12,7 +12,7 @@ // pointer which is backed by another `&'a mut` can only be done // for `'a` (which must be a sublifetime of `'b`). -fn copy_borrowed_ptr<'a, 'b>(p: &'a mut &'b mut int) -> &'b mut int { +fn copy_borrowed_ptr<'a, 'b>(p: &'a mut &'b mut isize) -> &'b mut isize { &mut **p //~ ERROR cannot infer } 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 e47fddbdc36..13a903bf2b5 100644 --- a/src/test/compile-fail/regions-ref-in-fn-arg.rs +++ b/src/test/compile-fail/regions-ref-in-fn-arg.rs @@ -10,13 +10,13 @@ #![feature(box_syntax)] -fn arg_item(box ref x: Box<int>) -> &'static int { +fn arg_item(box ref x: Box<isize>) -> &'static isize { x //~^ ERROR borrowed value does not live long enough } -fn with<R, F>(f: F) -> R where F: FnOnce(Box<int>) -> R { f(box 3) } +fn with<R, F>(f: F) -> R where F: FnOnce(Box<isize>) -> R { f(box 3) } -fn arg_closure() -> &'static int { +fn arg_closure() -> &'static isize { with(|box ref x| x) //~ ERROR borrowed value does not live long enough } diff --git a/src/test/compile-fail/regions-ret-borrowed-1.rs b/src/test/compile-fail/regions-ret-borrowed-1.rs index bd14d31217e..b8cebe66518 100644 --- a/src/test/compile-fail/regions-ret-borrowed-1.rs +++ b/src/test/compile-fail/regions-ret-borrowed-1.rs @@ -12,11 +12,11 @@ // some point regions-ret-borrowed reported an error but this file did // not, due to special hardcoding around the anonymous region. -fn with<R, F>(f: F) -> R where F: for<'a> FnOnce(&'a int) -> R { +fn with<R, F>(f: F) -> R where F: for<'a> FnOnce(&'a isize) -> R { f(&3) } -fn return_it<'a>() -> &'a int { +fn return_it<'a>() -> &'a isize { with(|o| o) //~^ ERROR cannot infer } diff --git a/src/test/compile-fail/regions-ret-borrowed.rs b/src/test/compile-fail/regions-ret-borrowed.rs index 4dfd4f1709a..40909ddd4ad 100644 --- a/src/test/compile-fail/regions-ret-borrowed.rs +++ b/src/test/compile-fail/regions-ret-borrowed.rs @@ -10,16 +10,16 @@ // Ensure that you cannot use generic types to return a region outside // of its bound. Here, in the `return_it()` fn, we call with() but -// with R bound to &int from the return_it. Meanwhile, with() +// with R bound to &isize from the return_it. Meanwhile, with() // provides a value that is only good within its own stack frame. This // used to successfully compile because we failed to account for the -// fact that fn(x: &int) rebound the region &. +// fact that fn(x: &isize) rebound the region &. -fn with<R, F>(f: F) -> R where F: FnOnce(&int) -> R { +fn with<R, F>(f: F) -> R where F: FnOnce(&isize) -> R { f(&3) } -fn return_it<'a>() -> &'a int { +fn return_it<'a>() -> &'a isize { with(|o| o) //~^ ERROR cannot infer } diff --git a/src/test/compile-fail/regions-ret.rs b/src/test/compile-fail/regions-ret.rs index 4986771c793..61c98d69d80 100644 --- a/src/test/compile-fail/regions-ret.rs +++ b/src/test/compile-fail/regions-ret.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -fn f(_x: &int) -> &int { +fn f(_x: &isize) -> &isize { return &3; //~ ERROR borrowed value does not live long enough } diff --git a/src/test/compile-fail/regions-return-ref-to-upvar-issue-17403.rs b/src/test/compile-fail/regions-return-ref-to-upvar-issue-17403.rs index d7b2a45cc63..21586f78db3 100644 --- a/src/test/compile-fail/regions-return-ref-to-upvar-issue-17403.rs +++ b/src/test/compile-fail/regions-return-ref-to-upvar-issue-17403.rs @@ -15,7 +15,7 @@ fn main() { // Unboxed closure case { - let mut x = 0u; + let mut x = 0us; let mut f = |&mut:| &mut x; //~ ERROR cannot infer let x = f(); let y = f(); diff --git a/src/test/compile-fail/regions-return-stack-allocated-vec.rs b/src/test/compile-fail/regions-return-stack-allocated-vec.rs index 3c5423c44d0..b5d4e07d04b 100644 --- a/src/test/compile-fail/regions-return-stack-allocated-vec.rs +++ b/src/test/compile-fail/regions-return-stack-allocated-vec.rs @@ -10,7 +10,7 @@ // Test that we cannot return a stack allocated slice -fn function(x: int) -> &'static [int] { +fn function(x: isize) -> &'static [isize] { &[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 12f5f295499..583d9695be4 100644 --- a/src/test/compile-fail/regions-steal-closure.rs +++ b/src/test/compile-fail/regions-steal-closure.rs @@ -21,7 +21,7 @@ fn box_it<'r>(x: Box<FnMut() + 'r>) -> closure_box<'r> { fn main() { let cl_box = { - let mut i = 3i; + let mut i = 3is; box_it(box || i += 1) //~ ERROR cannot infer }; cl_box.cl.call_mut(()); diff --git a/src/test/compile-fail/regions-trait-1.rs b/src/test/compile-fail/regions-trait-1.rs index 32d89607e4b..63052580dc2 100644 --- a/src/test/compile-fail/regions-trait-1.rs +++ b/src/test/compile-fail/regions-trait-1.rs @@ -10,7 +10,7 @@ #![feature(box_syntax)] -struct ctxt { v: uint } +struct ctxt { v: usize } trait get_ctxt { // Here the `&` is bound in the method definition: @@ -29,12 +29,12 @@ impl<'a> get_ctxt for has_ctxt<'a> { } -fn get_v(gc: Box<get_ctxt>) -> uint { +fn get_v(gc: Box<get_ctxt>) -> usize { gc.get_ctxt().v } fn main() { - let ctxt = ctxt { v: 22u }; + let ctxt = ctxt { v: 22us }; let hc = has_ctxt { c: &ctxt }; - assert_eq!(get_v(box hc as Box<get_ctxt>), 22u); + assert_eq!(get_v(box hc as Box<get_ctxt>), 22us); } diff --git a/src/test/compile-fail/regions-trait-2.rs b/src/test/compile-fail/regions-trait-2.rs index 92c1849c15b..8b36e87db3e 100644 --- a/src/test/compile-fail/regions-trait-2.rs +++ b/src/test/compile-fail/regions-trait-2.rs @@ -13,7 +13,7 @@ // Test that you cannot escape a reference // into a trait. -struct ctxt { v: uint } +struct ctxt { v: usize } trait get_ctxt { fn get_ctxt(&self) -> &'a ctxt; @@ -26,7 +26,7 @@ impl<'a> get_ctxt for has_ctxt<'a> { } fn make_gc() -> @get_ctxt { - let ctxt = ctxt { v: 22u }; + let ctxt = ctxt { v: 22us }; let hc = has_ctxt { c: &ctxt }; return @hc as @get_ctxt; //~^ ERROR source contains reference diff --git a/src/test/compile-fail/regions-trait-3.rs b/src/test/compile-fail/regions-trait-3.rs index 78d84fb7c75..8943abb49ae 100644 --- a/src/test/compile-fail/regions-trait-3.rs +++ b/src/test/compile-fail/regions-trait-3.rs @@ -22,7 +22,7 @@ // except according to those terms. trait get_ctxt<'a> { - fn get_ctxt(self) -> &'a uint; + fn get_ctxt(self) -> &'a usize; } fn make_gc1(gc: @get_ctxt<'a>) -> @get_ctxt<'b> { @@ -30,11 +30,11 @@ fn make_gc1(gc: @get_ctxt<'a>) -> @get_ctxt<'b> { } struct Foo { - r: &'a uint + r: &'a usize } impl get_ctxt for Foo<'a> { - fn get_ctxt(&self) -> &'a uint { self.r } + fn get_ctxt(&self) -> &'a usize { self.r } } fn make_gc2<'a,'b>(foo: Foo<'a>) -> @get_ctxt<'b> { diff --git a/src/test/compile-fail/regions-trait-variance.rs b/src/test/compile-fail/regions-trait-variance.rs index 22e43c0bf89..9ba4ef4e358 100644 --- a/src/test/compile-fail/regions-trait-variance.rs +++ b/src/test/compile-fail/regions-trait-variance.rs @@ -13,15 +13,15 @@ // Issue #12470. trait X { - fn get_i(&self) -> int; + fn get_i(&self) -> isize; } struct B { - i: int + i: isize } impl X for B { - fn get_i(&self) -> int { + fn get_i(&self) -> isize { self.i } } diff --git a/src/test/compile-fail/regions-undeclared.rs b/src/test/compile-fail/regions-undeclared.rs index 2d1de23616b..31908751580 100644 --- a/src/test/compile-fail/regions-undeclared.rs +++ b/src/test/compile-fail/regions-undeclared.rs @@ -8,15 +8,15 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -static c_x: &'blk int = &22; //~ ERROR use of undeclared lifetime name `'blk` +static c_x: &'blk isize = &22; //~ ERROR use of undeclared lifetime name `'blk` enum EnumDecl { - Foo(&'a int), //~ ERROR use of undeclared lifetime name `'a` - Bar(&'a int), //~ ERROR use of undeclared lifetime name `'a` + Foo(&'a isize), //~ ERROR use of undeclared lifetime name `'a` + Bar(&'a isize), //~ ERROR use of undeclared lifetime name `'a` } -fn fnDecl(x: &'a int, //~ ERROR use of undeclared lifetime name `'a` - y: &'a int) //~ ERROR use of undeclared lifetime name `'a` +fn fnDecl(x: &'a isize, //~ ERROR use of undeclared lifetime name `'a` + y: &'a isize) //~ ERROR use of undeclared lifetime name `'a` {} fn main() { diff --git a/src/test/compile-fail/regions-var-type-out-of-scope.rs b/src/test/compile-fail/regions-var-type-out-of-scope.rs index a954b16699f..039de994ea3 100644 --- a/src/test/compile-fail/regions-var-type-out-of-scope.rs +++ b/src/test/compile-fail/regions-var-type-out-of-scope.rs @@ -14,8 +14,8 @@ fn foo(cond: bool) { let mut x; if cond { - x = &3i; //~ ERROR borrowed value does not live long enough - assert_eq!(*x, 3i); + x = &3is; //~ ERROR borrowed value does not live long enough + assert_eq!(*x, 3is); } } diff --git a/src/test/compile-fail/regions-variance-contravariant-use-covariant-in-second-position.rs b/src/test/compile-fail/regions-variance-contravariant-use-covariant-in-second-position.rs index 14ead8da158..a7ef3ec9ac1 100644 --- a/src/test/compile-fail/regions-variance-contravariant-use-covariant-in-second-position.rs +++ b/src/test/compile-fail/regions-variance-contravariant-use-covariant-in-second-position.rs @@ -16,13 +16,13 @@ // `S` is contravariant with respect to both parameters. struct S<'a, 'b> { - f: &'a int, - g: &'b int, + f: &'a isize, + g: &'b isize, } fn use_<'short,'long>(c: S<'long, 'short>, - s: &'short int, - l: &'long int, + s: &'short isize, + l: &'long isize, _where:Option<&'short &'long ()>) { let _: S<'long, 'short> = c; // OK diff --git a/src/test/compile-fail/regions-variance-contravariant-use-covariant.rs b/src/test/compile-fail/regions-variance-contravariant-use-covariant.rs index 3fc58071d2c..a79249ade4f 100644 --- a/src/test/compile-fail/regions-variance-contravariant-use-covariant.rs +++ b/src/test/compile-fail/regions-variance-contravariant-use-covariant.rs @@ -18,12 +18,12 @@ // Contravariant<'long> <: Contravariant<'short> iff // 'short <= 'long struct Contravariant<'a> { - f: &'a int + f: &'a isize } fn use_<'short,'long>(c: Contravariant<'short>, - s: &'short int, - l: &'long int, + s: &'short isize, + l: &'long isize, _where:Option<&'short &'long ()>) { // Test whether Contravariant<'short> <: Contravariant<'long>. Since diff --git a/src/test/compile-fail/regions-variance-covariant-use-contravariant.rs b/src/test/compile-fail/regions-variance-covariant-use-contravariant.rs index 844c8151a64..f42b7027d9e 100644 --- a/src/test/compile-fail/regions-variance-covariant-use-contravariant.rs +++ b/src/test/compile-fail/regions-variance-covariant-use-contravariant.rs @@ -18,12 +18,12 @@ // Covariant<'foo> <: Covariant<'static> because // 'foo <= 'static struct Covariant<'a> { - f: extern "Rust" fn(&'a int) + f: extern "Rust" fn(&'a isize) } fn use_<'short,'long>(c: Covariant<'long>, - s: &'short int, - l: &'long int, + s: &'short isize, + l: &'long isize, _where:Option<&'short &'long ()>) { // Test whether Covariant<'long> <: Covariant<'short>. Since diff --git a/src/test/compile-fail/regions-variance-invariant-use-contravariant.rs b/src/test/compile-fail/regions-variance-invariant-use-contravariant.rs index d09e6babe09..71023b26c27 100644 --- a/src/test/compile-fail/regions-variance-invariant-use-contravariant.rs +++ b/src/test/compile-fail/regions-variance-invariant-use-contravariant.rs @@ -15,12 +15,12 @@ // variance inference works in the first place. struct Invariant<'a> { - f: &'a mut &'a int + f: &'a mut &'a isize } fn use_<'short,'long>(c: Invariant<'long>, - s: &'short int, - l: &'long int, + s: &'short isize, + l: &'long isize, _where:Option<&'short &'long ()>) { // Test whether Invariant<'long> <: Invariant<'short>. Since diff --git a/src/test/compile-fail/regions-variance-invariant-use-covariant.rs b/src/test/compile-fail/regions-variance-invariant-use-covariant.rs index 861668ad50d..bd944a8b52c 100644 --- a/src/test/compile-fail/regions-variance-invariant-use-covariant.rs +++ b/src/test/compile-fail/regions-variance-invariant-use-covariant.rs @@ -15,7 +15,7 @@ // variance inference works in the first place. struct Invariant<'a> { - f: &'a mut &'a int + f: &'a mut &'a isize } fn use_<'b>(c: Invariant<'b>) { diff --git a/src/test/compile-fail/removed-syntax-enum-newtype.rs b/src/test/compile-fail/removed-syntax-enum-newtype.rs index ba1b5a616df..3b45fd81288 100644 --- a/src/test/compile-fail/removed-syntax-enum-newtype.rs +++ b/src/test/compile-fail/removed-syntax-enum-newtype.rs @@ -8,4 +8,4 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -enum e = int; //~ ERROR expected one of `<` or `{`, found `=` +enum e = isize; //~ ERROR expected one of `<` or `{`, found `=` diff --git a/src/test/compile-fail/removed-syntax-extern-const.rs b/src/test/compile-fail/removed-syntax-extern-const.rs index 2f98552a953..98eec0977e0 100644 --- a/src/test/compile-fail/removed-syntax-extern-const.rs +++ b/src/test/compile-fail/removed-syntax-extern-const.rs @@ -9,5 +9,5 @@ // except according to those terms. extern { - const i: int; //~ ERROR unexpected token: `const` + const i: isize; //~ ERROR unexpected token: `const` } diff --git a/src/test/compile-fail/removed-syntax-fixed-vec.rs b/src/test/compile-fail/removed-syntax-fixed-vec.rs index 6537e3ddd27..0ca2380ef68 100644 --- a/src/test/compile-fail/removed-syntax-fixed-vec.rs +++ b/src/test/compile-fail/removed-syntax-fixed-vec.rs @@ -8,4 +8,4 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -type v = [int * 3]; //~ ERROR expected one of `(`, `+`, `::`, `;`, or `]`, found `*` +type v = [isize * 3]; //~ ERROR expected one of `(`, `+`, `::`, `;`, or `]`, found `*` diff --git a/src/test/compile-fail/removed-syntax-mode.rs b/src/test/compile-fail/removed-syntax-mode.rs index d2ab1881b1a..b02de5ce08e 100644 --- a/src/test/compile-fail/removed-syntax-mode.rs +++ b/src/test/compile-fail/removed-syntax-mode.rs @@ -8,4 +8,4 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -fn f(+x: int) {} //~ ERROR unexpected token: `+` +fn f(+x: isize) {} //~ ERROR unexpected token: `+` diff --git a/src/test/compile-fail/removed-syntax-mut-vec-ty.rs b/src/test/compile-fail/removed-syntax-mut-vec-ty.rs index efde1f1b24d..0f67a1d04ee 100644 --- a/src/test/compile-fail/removed-syntax-mut-vec-ty.rs +++ b/src/test/compile-fail/removed-syntax-mut-vec-ty.rs @@ -8,6 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -type v = [mut int]; +type v = [mut isize]; //~^ ERROR expected identifier, found keyword `mut` - //~^^ ERROR expected one of `(`, `+`, `::`, `;`, or `]`, found `int` + //~^^ ERROR expected one of `(`, `+`, `::`, `;`, or `]`, found `isize` diff --git a/src/test/compile-fail/removed-syntax-ptr-lifetime.rs b/src/test/compile-fail/removed-syntax-ptr-lifetime.rs index 1a1c4c9b40a..d94f2ec1e07 100644 --- a/src/test/compile-fail/removed-syntax-ptr-lifetime.rs +++ b/src/test/compile-fail/removed-syntax-ptr-lifetime.rs @@ -8,4 +8,4 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -type bptr = &lifetime/int; //~ ERROR expected one of `(`, `+`, `::`, or `;`, found `/` +type bptr = &lifetime/isize; //~ ERROR expected one of `(`, `+`, `::`, or `;`, found `/` diff --git a/src/test/compile-fail/removed-syntax-uniq-mut-ty.rs b/src/test/compile-fail/removed-syntax-uniq-mut-ty.rs index 8c3db89bad2..c051059aee6 100644 --- a/src/test/compile-fail/removed-syntax-uniq-mut-ty.rs +++ b/src/test/compile-fail/removed-syntax-uniq-mut-ty.rs @@ -8,6 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -type mut_box = Box<mut int>; +type mut_box = Box<mut isize>; //~^ ERROR expected identifier, found keyword `mut` - //~^^ ERROR expected one of `(`, `+`, `,`, `::`, or `>`, found `int` + //~^^ ERROR expected one of `(`, `+`, `,`, `::`, or `>`, found `isize` diff --git a/src/test/compile-fail/repeat-to-run-dtor-twice.rs b/src/test/compile-fail/repeat-to-run-dtor-twice.rs index 762c976a943..c8457adb8d6 100644 --- a/src/test/compile-fail/repeat-to-run-dtor-twice.rs +++ b/src/test/compile-fail/repeat-to-run-dtor-twice.rs @@ -12,7 +12,7 @@ // literal syntax. struct Foo { - x: int, + x: isize, } diff --git a/src/test/compile-fail/repeat_count.rs b/src/test/compile-fail/repeat_count.rs index f851a8244f6..e94bf19955b 100644 --- a/src/test/compile-fail/repeat_count.rs +++ b/src/test/compile-fail/repeat_count.rs @@ -24,6 +24,6 @@ fn main() { //~^ ERROR: expected `usize`, found `&'static str` let f = [0; -4]; //~^ ERROR expected positive integer for repeat count, found negative integer - let f = [0u; -1]; + let f = [0us; -1]; //~^ ERROR expected positive integer for repeat count, found negative integer } diff --git a/src/test/compile-fail/resolve-inconsistent-binding-mode.rs b/src/test/compile-fail/resolve-inconsistent-binding-mode.rs index df54a66f0a2..cdb81279048 100644 --- a/src/test/compile-fail/resolve-inconsistent-binding-mode.rs +++ b/src/test/compile-fail/resolve-inconsistent-binding-mode.rs @@ -9,7 +9,7 @@ // except according to those terms. enum opts { - a(int), b(int), c(int) + a(isize), b(isize), c(isize) } fn matcher1(x: opts) { diff --git a/src/test/compile-fail/resolve-unknown-trait.rs b/src/test/compile-fail/resolve-unknown-trait.rs index 699a30ad4eb..0d0dc0a05d1 100644 --- a/src/test/compile-fail/resolve-unknown-trait.rs +++ b/src/test/compile-fail/resolve-unknown-trait.rs @@ -12,7 +12,7 @@ trait NewTrait : SomeNonExistentTrait {} //~^ ERROR attempt to derive a nonexistent trait `SomeNonExistentTrait` -impl SomeNonExistentTrait for int {} +impl SomeNonExistentTrait for isize {} //~^ ERROR attempt to implement a nonexistent trait `SomeNonExistentTrait` fn f<T:SomeNonExistentTrait>() {} diff --git a/src/test/compile-fail/ret-non-nil.rs b/src/test/compile-fail/ret-non-nil.rs index d0cb2d4e812..4ee3cf4abac 100644 --- a/src/test/compile-fail/ret-non-nil.rs +++ b/src/test/compile-fail/ret-non-nil.rs @@ -12,6 +12,6 @@ fn f() { return; } -fn g() -> int { return; } +fn g() -> isize { return; } fn main() { f(); g(); } diff --git a/src/test/compile-fail/shadowed-lifetime.rs b/src/test/compile-fail/shadowed-lifetime.rs index ff8ce7769d7..57a2744d8f8 100644 --- a/src/test/compile-fail/shadowed-lifetime.rs +++ b/src/test/compile-fail/shadowed-lifetime.rs @@ -10,27 +10,27 @@ // Test that shadowed lifetimes generate an error. -struct Foo<'a>(&'a int); +struct Foo<'a>(&'a isize); impl<'a> Foo<'a> { //~^ HELP shadowed lifetime `'a` declared here - fn shadow_in_method<'a>(&'a self) -> &'a int { + fn shadow_in_method<'a>(&'a self) -> &'a isize { //~^ WARNING lifetime name `'a` shadows another lifetime name that is already in scope //~| HELP deprecated self.0 } - fn shadow_in_type<'b>(&'b self) -> &'b int { + fn shadow_in_type<'b>(&'b self) -> &'b isize { //~^ HELP shadowed lifetime `'b` declared here - let x: for<'b> fn(&'b int) = panic!(); + let x: for<'b> fn(&'b isize) = panic!(); //~^ WARNING lifetime name `'b` shadows another lifetime name that is already in scope //~| HELP deprecated self.0 } fn not_shadow_in_item<'b>(&'b self) { - struct Bar<'a, 'b>(&'a int, &'b int); // not a shadow, separate item - fn foo<'a, 'b>(x: &'a int, y: &'b int) { } // same + struct Bar<'a, 'b>(&'a isize, &'b isize); // not a shadow, separate item + fn foo<'a, 'b>(x: &'a isize, y: &'b isize) { } // same } } @@ -39,5 +39,5 @@ fn main() { // just to ensure that this test fails to compile; when shadowed // lifetimes become either an error or a proper lint, this will // not be needed. - let x: int = 3u; //~ ERROR mismatched types + let x: isize = 3us; //~ ERROR mismatched types } diff --git a/src/test/compile-fail/shadowing-in-the-same-pattern.rs b/src/test/compile-fail/shadowing-in-the-same-pattern.rs index 0b78023d318..c29534128ae 100644 --- a/src/test/compile-fail/shadowing-in-the-same-pattern.rs +++ b/src/test/compile-fail/shadowing-in-the-same-pattern.rs @@ -10,7 +10,7 @@ // Test for issue #14581. -fn f((a, a): (int, int)) {} //~ ERROR identifier `a` is bound more than once +fn f((a, a): (isize, isize)) {} //~ ERROR identifier `a` is bound more than once fn main() { let (a, a) = (1, 1); //~ ERROR identifier `a` is bound more than once diff --git a/src/test/compile-fail/shift-various-bad-types.rs b/src/test/compile-fail/shift-various-bad-types.rs new file mode 100644 index 00000000000..41788584049 --- /dev/null +++ b/src/test/compile-fail/shift-various-bad-types.rs @@ -0,0 +1,43 @@ +// 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 we can do shifts by any integral type. + +struct Panolpy { + char: char, + str: &'static str, +} + +fn foo(p: &Panolpy) { + 22 >> p.char; + //~^ ERROR right-hand-side of a shift operation must have integral type + + 22 >> p.str; + //~^ ERROR right-hand-side of a shift operation must have integral type + + 22 >> p; + //~^ ERROR right-hand-side of a shift operation must have integral type + + // We could be more accepting in the case of a type not yet inferred, but not + // known to be an integer, but meh. + let x; + 22 >> x; + //~^ ERROR right-hand-side of a shift operation must have integral type + + 22 >> 1; + // Integer literal types are OK + + // Type of the result follows the LHS, not the RHS: + let _: i32 = 22_i64 >> 1_i32; + //~^ ERROR mismatched types: expected `i32`, found `i64` +} + +fn main() { +} diff --git a/src/test/compile-fail/simd-binop.rs b/src/test/compile-fail/simd-binop.rs index 9fbb7364054..0c2d8972ce7 100644 --- a/src/test/compile-fail/simd-binop.rs +++ b/src/test/compile-fail/simd-binop.rs @@ -10,7 +10,7 @@ // ignore-tidy-linelength -#![allow(experimental)] +#![allow(unstable)] use std::simd::f32x4; diff --git a/src/test/compile-fail/simd-experimental.rs b/src/test/compile-fail/simd-experimental.rs index 5f9f56bf3c0..aea970f90b2 100644 --- a/src/test/compile-fail/simd-experimental.rs +++ b/src/test/compile-fail/simd-experimental.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![deny(experimental)] +#![deny(unstable)] use std::simd; diff --git a/src/test/compile-fail/simd-type.rs b/src/test/compile-fail/simd-type.rs index 16be3941298..c47bc1747de 100644 --- a/src/test/compile-fail/simd-type.rs +++ b/src/test/compile-fail/simd-type.rs @@ -20,6 +20,6 @@ struct empty; //~ ERROR SIMD vector cannot be empty struct i64f64(i64, f64); //~ ERROR SIMD vector should be homogeneous #[simd] -struct int4(int, int, int, int); //~ ERROR SIMD vector element type should be machine type +struct int4(isize, isize, isize, isize); //~ ERROR SIMD vector element type should be machine type fn main() {} diff --git a/src/test/compile-fail/slice-borrow.rs b/src/test/compile-fail/slice-borrow.rs index 43c4326628d..0062f66ae22 100644 --- a/src/test/compile-fail/slice-borrow.rs +++ b/src/test/compile-fail/slice-borrow.rs @@ -13,7 +13,7 @@ fn main() { let y; { - let x: &[int] = &[1, 2, 3, 4, 5]; //~ ERROR borrowed value does not live long enough + let x: &[isize] = &[1, 2, 3, 4, 5]; //~ ERROR borrowed value does not live long enough y = &x[1..]; } } diff --git a/src/test/compile-fail/slice-mut-2.rs b/src/test/compile-fail/slice-mut-2.rs index 12f184d410c..e20e968a012 100644 --- a/src/test/compile-fail/slice-mut-2.rs +++ b/src/test/compile-fail/slice-mut-2.rs @@ -11,8 +11,8 @@ // Test mutability and slicing syntax. fn main() { - let x: &[int] = &[1, 2, 3, 4, 5]; + let x: &[isize] = &[1, 2, 3, 4, 5]; // Can't mutably slice an immutable slice - let slice: &mut [int] = &mut [0, 1]; - let _ = &mut x[2..4]; //~ERROR cannot borrow immutable dereference of `&`-pointer `*x` as mutabl + let slice: &mut [isize] = &mut [0, 1]; + let _ = &mut x[2..4]; //~ERROR cannot borrow immutable borrowed content `*x` as mutable } diff --git a/src/test/compile-fail/slice-mut.rs b/src/test/compile-fail/slice-mut.rs index 9bd9a752e4e..0e1dd0d8f6c 100644 --- a/src/test/compile-fail/slice-mut.rs +++ b/src/test/compile-fail/slice-mut.rs @@ -11,7 +11,7 @@ // Test mutability and slicing syntax. fn main() { - let x: &[int] = &[1, 2, 3, 4, 5]; + let x: &[isize] = &[1, 2, 3, 4, 5]; // Immutable slices are not mutable. - let y: &mut[_] = &x[2..4]; //~ ERROR cannot borrow immutable dereference of `&`-pointer as mutab + let y: &mut[_] = &x[2..4]; //~ ERROR cannot borrow immutable borrowed content as mutable } diff --git a/src/test/compile-fail/static-assert2.rs b/src/test/compile-fail/static-assert2.rs index 6adc3b0aaf8..e988cfb9097 100644 --- a/src/test/compile-fail/static-assert2.rs +++ b/src/test/compile-fail/static-assert2.rs @@ -11,6 +11,6 @@ #![allow(dead_code)] #[static_assert] -static E: bool = 1i == 2; //~ ERROR static assertion failed +static E: bool = 1is == 2; //~ ERROR static assertion failed fn main() {} diff --git a/src/test/compile-fail/static-items-cant-move.rs b/src/test/compile-fail/static-items-cant-move.rs index 14ad1b3041f..422e95338ed 100644 --- a/src/test/compile-fail/static-items-cant-move.rs +++ b/src/test/compile-fail/static-items-cant-move.rs @@ -13,7 +13,7 @@ use std::marker; struct Foo { - foo: int, + foo: isize, nocopy: marker::NoCopy } diff --git a/src/test/compile-fail/static-mut-bad-types.rs b/src/test/compile-fail/static-mut-bad-types.rs index 7aed3ce30bc..088c8ef3ab8 100644 --- a/src/test/compile-fail/static-mut-bad-types.rs +++ b/src/test/compile-fail/static-mut-bad-types.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -static mut a: int = 3; +static mut a: isize = 3; fn main() { unsafe { diff --git a/src/test/compile-fail/static-mut-not-constant.rs b/src/test/compile-fail/static-mut-not-constant.rs index fd05f05502e..7c228ce413f 100644 --- a/src/test/compile-fail/static-mut-not-constant.rs +++ b/src/test/compile-fail/static-mut-not-constant.rs @@ -10,7 +10,7 @@ #![feature(box_syntax)] -static mut a: Box<int> = box 3; +static mut a: Box<isize> = box 3; //~^ ERROR statics are not allowed to have custom pointers //~^^ ERROR mutable statics are not allowed to have owned pointers diff --git a/src/test/compile-fail/static-mut-not-pat.rs b/src/test/compile-fail/static-mut-not-pat.rs index de93422cd7a..bfdeff6ed70 100644 --- a/src/test/compile-fail/static-mut-not-pat.rs +++ b/src/test/compile-fail/static-mut-not-pat.rs @@ -12,14 +12,14 @@ // statics cannot. This ensures that there's some form of error if this is // attempted. -static mut a: int = 3; +static mut a: isize = 3; fn main() { // If they can't be matched against, then it's possible to capture the same // name as a variable, hence this should be an unreachable pattern situation // instead of spitting out a custom error about some identifier collisions // (we should allow shadowing) - match 4i { + match 4is { a => {} //~ ERROR static variables cannot be referenced in a pattern _ => {} } diff --git a/src/test/compile-fail/static-mut-requires-unsafe.rs b/src/test/compile-fail/static-mut-requires-unsafe.rs index 7337920cce6..f6ad46a0527 100644 --- a/src/test/compile-fail/static-mut-requires-unsafe.rs +++ b/src/test/compile-fail/static-mut-requires-unsafe.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -static mut a: int = 3; +static mut a: isize = 3; fn main() { a += 3; //~ ERROR: requires unsafe diff --git a/src/test/compile-fail/static-priv-by-default.rs b/src/test/compile-fail/static-priv-by-default.rs index 98b37242c03..14299a9b639 100644 --- a/src/test/compile-fail/static-priv-by-default.rs +++ b/src/test/compile-fail/static-priv-by-default.rs @@ -14,12 +14,12 @@ extern crate static_priv_by_default; mod child { pub mod childs_child { - static private: int = 0; - pub static public: int = 0; + static private: isize = 0; + pub static public: isize = 0; } } -fn foo(_: int) {} +fn foo(_: isize) {} fn full_ref() { foo(static_priv_by_default::private); //~ ERROR: static `private` is private diff --git a/src/test/compile-fail/static-priv-by-default2.rs b/src/test/compile-fail/static-priv-by-default2.rs index 2141099c7aa..577e4f7542d 100644 --- a/src/test/compile-fail/static-priv-by-default2.rs +++ b/src/test/compile-fail/static-priv-by-default2.rs @@ -14,8 +14,8 @@ extern crate static_priv_by_default; mod child { pub mod childs_child { - static private: int = 0; - pub static public: int = 0; + static private: isize = 0; + pub static public: isize = 0; } } diff --git a/src/test/compile-fail/static-reference-to-fn-1.rs b/src/test/compile-fail/static-reference-to-fn-1.rs index bce397c4793..cf8ee1ecb41 100644 --- a/src/test/compile-fail/static-reference-to-fn-1.rs +++ b/src/test/compile-fail/static-reference-to-fn-1.rs @@ -9,16 +9,16 @@ // except according to those terms. struct A<'a> { - func: &'a fn() -> Option<int> + func: &'a fn() -> Option<isize> } impl<'a> A<'a> { - fn call(&self) -> Option<int> { + fn call(&self) -> Option<isize> { (*self.func)() } } -fn foo() -> Option<int> { +fn foo() -> Option<isize> { None } diff --git a/src/test/compile-fail/static-region-bound.rs b/src/test/compile-fail/static-region-bound.rs index 42f9d24bc52..4c59e7a769f 100644 --- a/src/test/compile-fail/static-region-bound.rs +++ b/src/test/compile-fail/static-region-bound.rs @@ -13,8 +13,8 @@ fn f<T:'static>(_: T) {} fn main() { - let x = box 3i; + let x = box 3is; f(x); - let x = &3i; //~ ERROR borrowed value does not live long enough + let x = &3is; //~ ERROR borrowed value does not live long enough f(x); } diff --git a/src/test/compile-fail/static-vec-repeat-not-constant.rs b/src/test/compile-fail/static-vec-repeat-not-constant.rs index ff84ed5bf0c..7cb7615526a 100644 --- a/src/test/compile-fail/static-vec-repeat-not-constant.rs +++ b/src/test/compile-fail/static-vec-repeat-not-constant.rs @@ -8,9 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -fn foo() -> int { 23 } +fn foo() -> isize { 23 } -static a: [int; 2] = [foo(); 2]; +static a: [isize; 2] = [foo(); 2]; //~^ ERROR: function calls in constants are limited to struct and enum constructors fn main() {} diff --git a/src/test/compile-fail/staticness-mismatch.rs b/src/test/compile-fail/staticness-mismatch.rs index a6082d31480..bf4e46cace3 100644 --- a/src/test/compile-fail/staticness-mismatch.rs +++ b/src/test/compile-fail/staticness-mismatch.rs @@ -13,7 +13,7 @@ trait foo { fn bar(); } -impl foo for int { +impl foo for isize { fn bar(&self) {} //~^ ERROR method `bar` has a `&self` declaration in the impl, but not in the trait } diff --git a/src/test/compile-fail/std-uncopyable-atomics.rs b/src/test/compile-fail/std-uncopyable-atomics.rs index 5ebabc2e354..f27fa6470a6 100644 --- a/src/test/compile-fail/std-uncopyable-atomics.rs +++ b/src/test/compile-fail/std-uncopyable-atomics.rs @@ -16,11 +16,11 @@ use std::ptr; fn main() { let x = ATOMIC_BOOL_INIT; - let x = *&x; //~ ERROR: cannot move out of dereference + let x = *&x; //~ ERROR: cannot move out of borrowed content let x = ATOMIC_INT_INIT; - let x = *&x; //~ ERROR: cannot move out of dereference + let x = *&x; //~ ERROR: cannot move out of borrowed content let x = ATOMIC_UINT_INIT; - let x = *&x; //~ ERROR: cannot move out of dereference - let x: AtomicPtr<uint> = AtomicPtr::new(ptr::null_mut()); - let x = *&x; //~ ERROR: cannot move out of dereference + let x = *&x; //~ ERROR: cannot move out of borrowed content + let x: AtomicPtr<usize> = AtomicPtr::new(ptr::null_mut()); + let x = *&x; //~ ERROR: cannot move out of borrowed content } diff --git a/src/test/compile-fail/struct-base-wrong-type.rs b/src/test/compile-fail/struct-base-wrong-type.rs index af6fc645351..2bb8d32a7e3 100644 --- a/src/test/compile-fail/struct-base-wrong-type.rs +++ b/src/test/compile-fail/struct-base-wrong-type.rs @@ -8,8 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -struct Foo { a: int, b: int } -struct Bar { x: int } +struct Foo { a: isize, b: isize } +struct Bar { x: isize } static bar: Bar = Bar { x: 5 }; static foo: Foo = Foo { a: 2, ..bar }; //~ ERROR mismatched types: expected `Foo`, found `Bar` diff --git a/src/test/compile-fail/struct-field-assignability.rs b/src/test/compile-fail/struct-field-assignability.rs index 2c3d48e9bf7..685ce28d510 100644 --- a/src/test/compile-fail/struct-field-assignability.rs +++ b/src/test/compile-fail/struct-field-assignability.rs @@ -12,7 +12,7 @@ struct Foo<'a> { - x: &'a int + x: &'a isize } pub fn main() { diff --git a/src/test/compile-fail/struct-field-privacy.rs b/src/test/compile-fail/struct-field-privacy.rs index ae421815e4d..667e944f92c 100644 --- a/src/test/compile-fail/struct-field-privacy.rs +++ b/src/test/compile-fail/struct-field-privacy.rs @@ -13,17 +13,17 @@ extern crate "struct-field-privacy" as xc; struct A { - a: int, + a: isize, } mod inner { struct A { - a: int, - pub b: int, + a: isize, + pub b: isize, } pub struct B { - pub a: int, - b: int, + pub a: isize, + b: isize, } } diff --git a/src/test/compile-fail/struct-fields-decl-dupe.rs b/src/test/compile-fail/struct-fields-decl-dupe.rs index 78216d5f4af..049569e8a18 100644 --- a/src/test/compile-fail/struct-fields-decl-dupe.rs +++ b/src/test/compile-fail/struct-fields-decl-dupe.rs @@ -9,8 +9,8 @@ // except according to those terms. struct BuildData { - foo: int, - foo: int, //~ ERROR field `foo` is already declared + foo: isize, + foo: isize, //~ ERROR field `foo` is already declared } fn main() { diff --git a/src/test/compile-fail/struct-fields-dupe.rs b/src/test/compile-fail/struct-fields-dupe.rs index ffbfecdc48c..578091f5e9a 100644 --- a/src/test/compile-fail/struct-fields-dupe.rs +++ b/src/test/compile-fail/struct-fields-dupe.rs @@ -9,7 +9,7 @@ // except according to those terms. struct BuildData { - foo: int, + foo: isize, } fn main() { diff --git a/src/test/compile-fail/struct-fields-missing.rs b/src/test/compile-fail/struct-fields-missing.rs index 0afc84ee1b3..1fd9357cf2d 100644 --- a/src/test/compile-fail/struct-fields-missing.rs +++ b/src/test/compile-fail/struct-fields-missing.rs @@ -10,8 +10,8 @@ struct BuildData { - foo: int, - bar: Box<int>, + foo: isize, + bar: Box<isize>, } fn main() { diff --git a/src/test/compile-fail/struct-fields-too-many.rs b/src/test/compile-fail/struct-fields-too-many.rs index de58b5d110e..9244a9d4f9d 100644 --- a/src/test/compile-fail/struct-fields-too-many.rs +++ b/src/test/compile-fail/struct-fields-too-many.rs @@ -9,7 +9,7 @@ // except according to those terms. struct BuildData { - foo: int, + foo: isize, } fn main() { diff --git a/src/test/compile-fail/struct-like-enum-nonexhaustive.rs b/src/test/compile-fail/struct-like-enum-nonexhaustive.rs index 1115d78e560..a14e43f4c94 100644 --- a/src/test/compile-fail/struct-like-enum-nonexhaustive.rs +++ b/src/test/compile-fail/struct-like-enum-nonexhaustive.rs @@ -9,7 +9,7 @@ // except according to those terms. enum A { - B { x: Option<int> }, + B { x: Option<isize> }, C } diff --git a/src/test/compile-fail/struct-literal-in-for.rs b/src/test/compile-fail/struct-literal-in-for.rs index a37197b889d..4bb5d5e6aa1 100644 --- a/src/test/compile-fail/struct-literal-in-for.rs +++ b/src/test/compile-fail/struct-literal-in-for.rs @@ -9,7 +9,7 @@ // except according to those terms. struct Foo { - x: int, + x: isize, } impl Foo { diff --git a/src/test/compile-fail/struct-literal-in-if.rs b/src/test/compile-fail/struct-literal-in-if.rs index 9759e4f7bda..b2bc8a4901f 100644 --- a/src/test/compile-fail/struct-literal-in-if.rs +++ b/src/test/compile-fail/struct-literal-in-if.rs @@ -9,7 +9,7 @@ // except according to those terms. struct Foo { - x: int, + x: isize, } impl Foo { diff --git a/src/test/compile-fail/struct-literal-in-match-discriminant.rs b/src/test/compile-fail/struct-literal-in-match-discriminant.rs index 297d3f7347f..8f50940806a 100644 --- a/src/test/compile-fail/struct-literal-in-match-discriminant.rs +++ b/src/test/compile-fail/struct-literal-in-match-discriminant.rs @@ -9,7 +9,7 @@ // except according to those terms. struct Foo { - x: int, + x: isize, } fn main() { diff --git a/src/test/compile-fail/struct-literal-in-while.rs b/src/test/compile-fail/struct-literal-in-while.rs index 5b1679cf9a1..05fa3a8dd5f 100644 --- a/src/test/compile-fail/struct-literal-in-while.rs +++ b/src/test/compile-fail/struct-literal-in-while.rs @@ -9,7 +9,7 @@ // except according to those terms. struct Foo { - x: int, + x: isize, } impl Foo { diff --git a/src/test/compile-fail/struct-pat-derived-error.rs b/src/test/compile-fail/struct-pat-derived-error.rs index cafead3af0e..4b65292340f 100644 --- a/src/test/compile-fail/struct-pat-derived-error.rs +++ b/src/test/compile-fail/struct-pat-derived-error.rs @@ -9,8 +9,8 @@ // except according to those terms. struct a { - b: uint, - c: uint + b: usize, + c: usize } impl a { diff --git a/src/test/compile-fail/struct-pattern-match-useless.rs b/src/test/compile-fail/struct-pattern-match-useless.rs index b9c0be9276d..9f7ebc261ad 100644 --- a/src/test/compile-fail/struct-pattern-match-useless.rs +++ b/src/test/compile-fail/struct-pattern-match-useless.rs @@ -9,8 +9,8 @@ // except according to those terms. struct Foo { - x: int, - y: int, + x: isize, + y: isize, } pub fn main() { diff --git a/src/test/compile-fail/struct-variant-no-pub.rs b/src/test/compile-fail/struct-variant-no-pub.rs index 15ed69083e0..e62b39ad5aa 100644 --- a/src/test/compile-fail/struct-variant-no-pub.rs +++ b/src/test/compile-fail/struct-variant-no-pub.rs @@ -10,7 +10,7 @@ enum Foo { Bar { - pub a: int //~ ERROR: `pub` is not allowed here + pub a: isize //~ ERROR: `pub` is not allowed here } } diff --git a/src/test/compile-fail/struct-variant-privacy.rs b/src/test/compile-fail/struct-variant-privacy.rs index bf404c27648..f36862364e7 100644 --- a/src/test/compile-fail/struct-variant-privacy.rs +++ b/src/test/compile-fail/struct-variant-privacy.rs @@ -9,7 +9,7 @@ // except according to those terms. mod foo { enum Bar { - Baz { a: int } + Baz { a: isize } } } diff --git a/src/test/compile-fail/tag-variant-cast-non-nullary.rs b/src/test/compile-fail/tag-variant-cast-non-nullary.rs index 1d05c5d181d..b0106329126 100644 --- a/src/test/compile-fail/tag-variant-cast-non-nullary.rs +++ b/src/test/compile-fail/tag-variant-cast-non-nullary.rs @@ -12,10 +12,10 @@ enum non_nullary { nullary, - other(int), + other(isize), } fn main() { let v = non_nullary::nullary; - let val = v as int; + let val = v as isize; } diff --git a/src/test/compile-fail/tail-typeck.rs b/src/test/compile-fail/tail-typeck.rs index 786d1e12137..a934bbe61c4 100644 --- a/src/test/compile-fail/tail-typeck.rs +++ b/src/test/compile-fail/tail-typeck.rs @@ -10,8 +10,8 @@ // error-pattern: mismatched types -fn f() -> int { return g(); } +fn f() -> isize { return g(); } -fn g() -> uint { return 0u; } +fn g() -> usize { return 0us; } fn main() { let y = f(); } diff --git a/src/test/compile-fail/terr-in-field.rs b/src/test/compile-fail/terr-in-field.rs index 88da7bc8542..1e5422a798e 100644 --- a/src/test/compile-fail/terr-in-field.rs +++ b/src/test/compile-fail/terr-in-field.rs @@ -9,13 +9,13 @@ // except according to those terms. struct foo { - a: int, - b: int, + a: isize, + b: isize, } struct bar { - a: int, - b: uint, + a: isize, + b: usize, } fn want_foo(f: foo) {} diff --git a/src/test/compile-fail/terr-sorts.rs b/src/test/compile-fail/terr-sorts.rs index 53ebe1f9b5b..d1a37c99c47 100644 --- a/src/test/compile-fail/terr-sorts.rs +++ b/src/test/compile-fail/terr-sorts.rs @@ -10,8 +10,8 @@ struct foo { - a: int, - b: int, + a: isize, + b: isize, } type bar = Box<foo>; diff --git a/src/test/compile-fail/trailing-plus-in-bounds.rs b/src/test/compile-fail/trailing-plus-in-bounds.rs index b189acb685a..069c2e88793 100644 --- a/src/test/compile-fail/trailing-plus-in-bounds.rs +++ b/src/test/compile-fail/trailing-plus-in-bounds.rs @@ -11,7 +11,7 @@ use std::fmt::Show; fn main() { - let x: Box<Show+> = box 3i as Box<Show+>; + let x: Box<Show+> = box 3is as Box<Show+>; //~^ ERROR at least one type parameter bound must be specified //~^^ ERROR at least one type parameter bound must be specified } diff --git a/src/test/compile-fail/trait-bounds-on-structs-and-enums-locals.rs b/src/test/compile-fail/trait-bounds-on-structs-and-enums-locals.rs index 52035c09dd6..45a74a235e0 100644 --- a/src/test/compile-fail/trait-bounds-on-structs-and-enums-locals.rs +++ b/src/test/compile-fail/trait-bounds-on-structs-and-enums-locals.rs @@ -17,10 +17,10 @@ struct Foo<T:Trait> { fn main() { let foo = Foo { //~^ ERROR not implemented - x: 3i + x: 3is }; - let baz: Foo<uint> = panic!(); + let baz: Foo<usize> = panic!(); //~^ ERROR not implemented } diff --git a/src/test/compile-fail/trait-bounds-on-structs-and-enums-static.rs b/src/test/compile-fail/trait-bounds-on-structs-and-enums-static.rs index c26cccc8b14..d5369817e9a 100644 --- a/src/test/compile-fail/trait-bounds-on-structs-and-enums-static.rs +++ b/src/test/compile-fail/trait-bounds-on-structs-and-enums-static.rs @@ -14,7 +14,7 @@ struct Foo<T:Trait> { x: T, } -static X: Foo<uint> = Foo { +static X: Foo<usize> = Foo { //~^ ERROR not implemented x: 1, }; diff --git a/src/test/compile-fail/trait-bounds-on-structs-and-enums-xc.rs b/src/test/compile-fail/trait-bounds-on-structs-and-enums-xc.rs index d01f9d59fb4..ded75aa1d85 100644 --- a/src/test/compile-fail/trait-bounds-on-structs-and-enums-xc.rs +++ b/src/test/compile-fail/trait-bounds-on-structs-and-enums-xc.rs @@ -14,7 +14,7 @@ extern crate trait_bounds_on_structs_and_enums_xc; use trait_bounds_on_structs_and_enums_xc::{Bar, Foo, Trait}; -fn explode(x: Foo<uint>) {} +fn explode(x: Foo<usize>) {} //~^ ERROR not implemented fn kaboom(y: Bar<f32>) {} diff --git a/src/test/compile-fail/trait-bounds-on-structs-and-enums-xc1.rs b/src/test/compile-fail/trait-bounds-on-structs-and-enums-xc1.rs index d3689067aef..6179301c11d 100644 --- a/src/test/compile-fail/trait-bounds-on-structs-and-enums-xc1.rs +++ b/src/test/compile-fail/trait-bounds-on-structs-and-enums-xc1.rs @@ -17,7 +17,7 @@ use trait_bounds_on_structs_and_enums_xc::{Bar, Foo, Trait}; fn main() { let foo = Foo { //~^ ERROR not implemented - x: 3i + x: 3is }; let bar: Bar<f64> = return; //~^ ERROR not implemented diff --git a/src/test/compile-fail/trait-bounds-on-structs-and-enums.rs b/src/test/compile-fail/trait-bounds-on-structs-and-enums.rs index c11b5d22878..490ee0e8ad6 100644 --- a/src/test/compile-fail/trait-bounds-on-structs-and-enums.rs +++ b/src/test/compile-fail/trait-bounds-on-structs-and-enums.rs @@ -15,9 +15,9 @@ struct Foo<T:Trait> { } enum Bar<T:Trait> { - ABar(int), + ABar(isize), BBar(T), - CBar(uint), + CBar(usize), } fn explode(x: Foo<u32>) {} @@ -33,12 +33,12 @@ impl<T> Foo<T> { struct Baz { //~^ ERROR not implemented - a: Foo<int>, + a: Foo<isize>, } enum Boo { //~^ ERROR not implemented - Quux(Bar<uint>), + Quux(Bar<usize>), } struct Badness<U> { @@ -57,7 +57,7 @@ trait PolyTrait<T> { struct Struct; -impl PolyTrait<Foo<uint>> for Struct { +impl PolyTrait<Foo<usize>> for Struct { //~^ ERROR not implemented fn whatever() {} } diff --git a/src/test/compile-fail/trait-impl-1.rs b/src/test/compile-fail/trait-impl-1.rs index 44b478bfb15..1c7fa1e4263 100644 --- a/src/test/compile-fail/trait-impl-1.rs +++ b/src/test/compile-fail/trait-impl-1.rs @@ -18,7 +18,7 @@ impl<'a> T+'a { fn foo(&self) {} } -impl T for int {} +impl T for isize {} fn main() { let x = &42is; diff --git a/src/test/compile-fail/trait-impl-can-not-have-untraitful-methods.rs b/src/test/compile-fail/trait-impl-can-not-have-untraitful-methods.rs index 1471d9232b2..3538c7f1289 100644 --- a/src/test/compile-fail/trait-impl-can-not-have-untraitful-methods.rs +++ b/src/test/compile-fail/trait-impl-can-not-have-untraitful-methods.rs @@ -10,7 +10,7 @@ trait A { } -impl A for int { +impl A for isize { fn foo(&self) { } //~ ERROR method `foo` is not a member of trait `A` } diff --git a/src/test/compile-fail/trait-impl-different-num-params.rs b/src/test/compile-fail/trait-impl-different-num-params.rs index ea2062dd272..647dd4e05fa 100644 --- a/src/test/compile-fail/trait-impl-different-num-params.rs +++ b/src/test/compile-fail/trait-impl-different-num-params.rs @@ -9,10 +9,10 @@ // except according to those terms. trait foo { - fn bar(&self, x: uint) -> Self; + fn bar(&self, x: usize) -> Self; } -impl foo for int { - fn bar(&self) -> int { +impl foo for isize { + fn bar(&self) -> isize { //~^ ERROR method `bar` has 1 parameter but the declaration in trait `foo::bar` has 2 *self } diff --git a/src/test/compile-fail/trait-impl-method-mismatch.rs b/src/test/compile-fail/trait-impl-method-mismatch.rs index 73224c7b45c..4e2eb224213 100644 --- a/src/test/compile-fail/trait-impl-method-mismatch.rs +++ b/src/test/compile-fail/trait-impl-method-mismatch.rs @@ -10,12 +10,12 @@ trait Mumbo { - fn jumbo(&self, x: &uint) -> uint; + fn jumbo(&self, x: &usize) -> usize; } -impl Mumbo for uint { +impl Mumbo for usize { // Cannot have a larger effect than the trait: - unsafe fn jumbo(&self, x: &uint) { *self + *x; } + unsafe fn jumbo(&self, x: &usize) { *self + *x; } //~^ ERROR expected normal fn, found unsafe fn } diff --git a/src/test/compile-fail/trait-impl-of-supertrait-has-wrong-lifetime-parameters.rs b/src/test/compile-fail/trait-impl-of-supertrait-has-wrong-lifetime-parameters.rs index 716362415a6..44c53e70f86 100644 --- a/src/test/compile-fail/trait-impl-of-supertrait-has-wrong-lifetime-parameters.rs +++ b/src/test/compile-fail/trait-impl-of-supertrait-has-wrong-lifetime-parameters.rs @@ -13,26 +13,26 @@ // an impl of T1<'a>, but we have an impl of T1<'b>. trait T1<'x> { - fn x(&self) -> &'x int; + fn x(&self) -> &'x isize; } trait T2<'x, 'y> : T1<'x> { - fn y(&self) -> &'y int; + fn y(&self) -> &'y isize; } struct S<'a, 'b> { - a: &'a int, - b: &'b int + a: &'a isize, + b: &'b isize } impl<'a,'b> T1<'b> for S<'a, 'b> { - fn x(&self) -> &'b int { + fn x(&self) -> &'b isize { self.b } } impl<'a,'b> T2<'a, 'b> for S<'a, 'b> { //~ ERROR cannot infer an appropriate lifetime - fn y(&self) -> &'b int { + fn y(&self) -> &'b isize { self.b } } diff --git a/src/test/compile-fail/trait-matching-lifetimes.rs b/src/test/compile-fail/trait-matching-lifetimes.rs index 333730e0c4b..5ab80065572 100644 --- a/src/test/compile-fail/trait-matching-lifetimes.rs +++ b/src/test/compile-fail/trait-matching-lifetimes.rs @@ -12,8 +12,8 @@ // (Issue #15517.) struct Foo<'a,'b> { - x: &'a int, - y: &'b int, + x: &'a isize, + y: &'b isize, } trait Tr : Sized { diff --git a/src/test/compile-fail/trait-safety-fn-body.rs b/src/test/compile-fail/trait-safety-fn-body.rs index f894e2ee28e..499b58f70d7 100644 --- a/src/test/compile-fail/trait-safety-fn-body.rs +++ b/src/test/compile-fail/trait-safety-fn-body.rs @@ -15,7 +15,7 @@ unsafe trait UnsafeTrait : Sized { fn foo(self) { } } -unsafe impl UnsafeTrait for *mut int { +unsafe impl UnsafeTrait for *mut isize { fn foo(self) { // Unsafe actions are not made legal by taking place in an unsafe trait: *self += 1; //~ ERROR E0133 diff --git a/src/test/compile-fail/trait-safety-trait-impl-cc.rs b/src/test/compile-fail/trait-safety-trait-impl-cc.rs index 21dd5a237c5..032deb2e017 100644 --- a/src/test/compile-fail/trait-safety-trait-impl-cc.rs +++ b/src/test/compile-fail/trait-safety-trait-impl-cc.rs @@ -17,8 +17,8 @@ extern crate "trait-safety-lib" as lib; struct Bar; impl lib::Foo for Bar { //~ ERROR requires an `unsafe impl` declaration - fn foo(&self) -> int { - *self as int + fn foo(&self) -> isize { + *self as isize } } diff --git a/src/test/compile-fail/trait-test-2.rs b/src/test/compile-fail/trait-test-2.rs index f66034e395c..bdfc6dcda88 100644 --- a/src/test/compile-fail/trait-test-2.rs +++ b/src/test/compile-fail/trait-test-2.rs @@ -11,11 +11,11 @@ #![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) {} } -impl bar for uint { fn dup(&self) -> uint { *self } fn blah<X>(&self) {} } +impl bar for isize { fn dup(&self) -> isize { *self } fn blah<X>(&self) {} } +impl bar for usize { fn dup(&self) -> usize { *self } fn blah<X>(&self) {} } fn main() { - 10i.dup::<int>(); //~ ERROR does not take type parameters - 10i.blah::<int, int>(); //~ ERROR incorrect number of type parameters - (box 10i as Box<bar>).dup(); //~ ERROR cannot convert to a trait object + 10is.dup::<isize>(); //~ ERROR does not take type parameters + 10is.blah::<isize, isize>(); //~ ERROR incorrect number of type parameters + (box 10is as Box<bar>).dup(); //~ ERROR cannot convert to a trait object } diff --git a/src/test/compile-fail/trait-test.rs b/src/test/compile-fail/trait-test.rs index 1682e98fb23..d53e353d9d9 100644 --- a/src/test/compile-fail/trait-test.rs +++ b/src/test/compile-fail/trait-test.rs @@ -10,6 +10,6 @@ trait foo { fn foo(&self); } -impl int for uint { fn foo(&self) {} } //~ ERROR trait +impl isize for usize { fn foo(&self) {} } //~ ERROR trait fn main() {} diff --git a/src/test/compile-fail/traits-multidispatch-bad.rs b/src/test/compile-fail/traits-multidispatch-bad.rs index f5ce904a4bb..e9a4005b4b4 100644 --- a/src/test/compile-fail/traits-multidispatch-bad.rs +++ b/src/test/compile-fail/traits-multidispatch-bad.rs @@ -14,9 +14,9 @@ trait Convert<Target> { fn convert(&self) -> Target; } -impl Convert<uint> for int { - fn convert(&self) -> uint { - *self as uint +impl Convert<usize> for isize { + fn convert(&self) -> usize { + *self as usize } } @@ -26,7 +26,7 @@ where T : Convert<U> } fn a() { - test(22i, 44i); //~ ERROR not implemented + test(22is, 44is); //~ ERROR not implemented } fn main() {} diff --git a/src/test/compile-fail/transmute-impl.rs b/src/test/compile-fail/transmute-impl.rs index a68bba285df..a77a37a77e1 100644 --- a/src/test/compile-fail/transmute-impl.rs +++ b/src/test/compile-fail/transmute-impl.rs @@ -19,12 +19,12 @@ struct Foo<T: ?Sized> { } impl<T: ?Sized> Foo<T> { - fn m(x: &T) -> &int where T : Sized { + fn m(x: &T) -> &isize where T : Sized { // OK here, because T : Sized is in scope. unsafe { transmute(x) } } - fn n(x: &T) -> &int { + fn n(x: &T) -> &isize { // Not OK here, because T : Sized is not in scope. unsafe { transmute(x) } //~ ERROR transmute called on types with potentially different sizes } diff --git a/src/test/compile-fail/transmute-type-parameters.rs b/src/test/compile-fail/transmute-type-parameters.rs index 2286c0e75bd..b06966bd867 100644 --- a/src/test/compile-fail/transmute-type-parameters.rs +++ b/src/test/compile-fail/transmute-type-parameters.rs @@ -13,15 +13,15 @@ use std::mem::transmute; unsafe fn f<T>(x: T) { - let _: int = transmute(x); //~ ERROR cannot transmute + let _: isize = transmute(x); //~ ERROR cannot transmute } -unsafe fn g<T>(x: (T, int)) { - let _: int = transmute(x); //~ ERROR cannot transmute +unsafe fn g<T>(x: (T, isize)) { + let _: isize = transmute(x); //~ ERROR cannot transmute } unsafe fn h<T>(x: [T; 10]) { - let _: int = transmute(x); //~ ERROR cannot transmute + let _: isize = transmute(x); //~ ERROR cannot transmute } struct Bad<T> { @@ -29,7 +29,7 @@ struct Bad<T> { } unsafe fn i<T>(x: Bad<T>) { - let _: int = transmute(x); //~ ERROR cannot transmute + let _: isize = transmute(x); //~ ERROR cannot transmute } enum Worse<T> { @@ -38,11 +38,11 @@ enum Worse<T> { } unsafe fn j<T>(x: Worse<T>) { - let _: int = transmute(x); //~ ERROR cannot transmute + let _: isize = transmute(x); //~ ERROR cannot transmute } unsafe fn k<T>(x: Option<T>) { - let _: int = transmute(x); //~ ERROR cannot transmute + let _: isize = transmute(x); //~ ERROR cannot transmute } fn main() {} diff --git a/src/test/compile-fail/tuple-index-not-tuple.rs b/src/test/compile-fail/tuple-index-not-tuple.rs index 33aeebb3691..bf2a63abbfd 100644 --- a/src/test/compile-fail/tuple-index-not-tuple.rs +++ b/src/test/compile-fail/tuple-index-not-tuple.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -struct Point { x: int, y: int } +struct Point { x: isize, y: isize } struct Empty; fn main() { diff --git a/src/test/compile-fail/tuple-struct-nonexhaustive.rs b/src/test/compile-fail/tuple-struct-nonexhaustive.rs index 1f14fbb27ad..e4fda6dd534 100644 --- a/src/test/compile-fail/tuple-struct-nonexhaustive.rs +++ b/src/test/compile-fail/tuple-struct-nonexhaustive.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -struct Foo(int, int); +struct Foo(isize, isize); fn main() { let x = Foo(1, 2); diff --git a/src/test/compile-fail/tutorial-suffix-inference-test.rs b/src/test/compile-fail/tutorial-suffix-inference-test.rs index 85ad302f3ed..1b44c7e8128 100644 --- a/src/test/compile-fail/tutorial-suffix-inference-test.rs +++ b/src/test/compile-fail/tutorial-suffix-inference-test.rs @@ -23,7 +23,7 @@ fn main() { let a = 3is; - fn identity_i(n: isize) -> int { n } + fn identity_i(n: isize) -> isize { n } identity_i(a); // ok identity_u16(a); diff --git a/src/test/compile-fail/type-parameters-in-field-exprs.rs b/src/test/compile-fail/type-parameters-in-field-exprs.rs index 023f7d1c29f..54ddb3e19fa 100644 --- a/src/test/compile-fail/type-parameters-in-field-exprs.rs +++ b/src/test/compile-fail/type-parameters-in-field-exprs.rs @@ -9,8 +9,8 @@ // except according to those terms. struct Foo { - x: int, - y: int, + x: isize, + y: isize, } fn main() { @@ -18,7 +18,7 @@ fn main() { x: 1, y: 2, }; - f.x::<int>; + f.x::<isize>; //~^ ERROR field expressions may not have type parameters } diff --git a/src/test/compile-fail/type-recursive.rs b/src/test/compile-fail/type-recursive.rs index a2b4e8d9782..9dcb60628a9 100644 --- a/src/test/compile-fail/type-recursive.rs +++ b/src/test/compile-fail/type-recursive.rs @@ -10,7 +10,7 @@ // error-pattern:this type cannot be instantiated struct t1 { - foo: int, + foo: isize, foolish: t1 } diff --git a/src/test/compile-fail/type-shadow.rs b/src/test/compile-fail/type-shadow.rs index 50c8cf99d3c..6d8c0fe22bd 100644 --- a/src/test/compile-fail/type-shadow.rs +++ b/src/test/compile-fail/type-shadow.rs @@ -9,7 +9,7 @@ // except according to those terms. fn main() { - type X = int; + type X = isize; type Y = X; if true { type X = &'static str; diff --git a/src/test/compile-fail/typeck-unsafe-always-share.rs b/src/test/compile-fail/typeck-unsafe-always-share.rs index 5166a4e9654..a9113c6e99f 100644 --- a/src/test/compile-fail/typeck-unsafe-always-share.rs +++ b/src/test/compile-fail/typeck-unsafe-always-share.rs @@ -28,7 +28,7 @@ fn test<T: Sync>(s: T){ } fn main() { - let us = UnsafeCell::new(MySync{u: UnsafeCell::new(0i)}); + let us = UnsafeCell::new(MySync{u: UnsafeCell::new(0is)}); test(us); //~^ ERROR `core::marker::Sync` is not implemented diff --git a/src/test/compile-fail/typeck_type_placeholder_item.rs b/src/test/compile-fail/typeck_type_placeholder_item.rs index 723c5fda3a7..d69c0dc5d1f 100644 --- a/src/test/compile-fail/typeck_type_placeholder_item.rs +++ b/src/test/compile-fail/typeck_type_placeholder_item.rs @@ -14,7 +14,7 @@ fn test() -> _ { 5 } //~^ ERROR the type placeholder `_` is not allowed within types on item signatures -fn test2() -> (_, _) { (5u, 5u) } +fn test2() -> (_, _) { (5us, 5us) } //~^ ERROR the type placeholder `_` is not allowed within types on item signatures //~^^ ERROR the type placeholder `_` is not allowed within types on item signatures @@ -31,7 +31,7 @@ static TEST5: (_, _) = (1, 2); fn test6(_: _) { } //~^ ERROR the type placeholder `_` is not allowed within types on item signatures -fn test7(x: _) { let _x: uint = x; } +fn test7(x: _) { let _x: usize = x; } //~^ ERROR the type placeholder `_` is not allowed within types on item signatures fn test8(_f: fn() -> _) { } @@ -67,7 +67,7 @@ pub fn main() { fn fn_test() -> _ { 5 } //~^ ERROR the type placeholder `_` is not allowed within types on item signatures - fn fn_test2() -> (_, _) { (5u, 5u) } + fn fn_test2() -> (_, _) { (5us, 5us) } //~^ ERROR the type placeholder `_` is not allowed within types on item signatures //~^^ ERROR the type placeholder `_` is not allowed within types on item signatures @@ -84,7 +84,7 @@ pub fn main() { fn fn_test6(_: _) { } //~^ ERROR the type placeholder `_` is not allowed within types on item signatures - fn fn_test7(x: _) { let _x: uint = x; } + fn fn_test7(x: _) { let _x: usize = x; } //~^ ERROR the type placeholder `_` is not allowed within types on item signatures fn fn_test8(_f: fn() -> _) { } diff --git a/src/test/compile-fail/typeck_type_placeholder_lifetime_1.rs b/src/test/compile-fail/typeck_type_placeholder_lifetime_1.rs index 9694c1d9f98..e1d17e4fef7 100644 --- a/src/test/compile-fail/typeck_type_placeholder_lifetime_1.rs +++ b/src/test/compile-fail/typeck_type_placeholder_lifetime_1.rs @@ -16,6 +16,6 @@ struct Foo<'a, T:'a> { } pub fn main() { - let c: Foo<_, _> = Foo { r: &5u }; + let c: Foo<_, _> = Foo { r: &5us }; //~^ ERROR wrong number of type arguments: expected 1, found 2 } diff --git a/src/test/compile-fail/typeck_type_placeholder_lifetime_2.rs b/src/test/compile-fail/typeck_type_placeholder_lifetime_2.rs index 365b786cc1a..8178335de59 100644 --- a/src/test/compile-fail/typeck_type_placeholder_lifetime_2.rs +++ b/src/test/compile-fail/typeck_type_placeholder_lifetime_2.rs @@ -16,6 +16,6 @@ struct Foo<'a, T:'a> { } pub fn main() { - let c: Foo<_, uint> = Foo { r: &5 }; + let c: Foo<_, usize> = Foo { r: &5 }; //~^ ERROR wrong number of type arguments: expected 1, found 2 } diff --git a/src/test/compile-fail/ufcs-explicit-self-bad.rs b/src/test/compile-fail/ufcs-explicit-self-bad.rs index 5ba660495f7..6c323e8c1ae 100644 --- a/src/test/compile-fail/ufcs-explicit-self-bad.rs +++ b/src/test/compile-fail/ufcs-explicit-self-bad.rs @@ -11,11 +11,11 @@ #![feature(box_syntax)] struct Foo { - f: int, + f: isize, } impl Foo { - fn foo(self: int, x: int) -> int { //~ ERROR mismatched self type + fn foo(self: isize, x: isize) -> isize { //~ ERROR mismatched self type self.f + x } } @@ -25,10 +25,10 @@ struct Bar<T> { } impl<T> Bar<T> { - fn foo(self: Bar<int>, x: int) -> int { //~ ERROR mismatched self type + fn foo(self: Bar<isize>, x: isize) -> isize { //~ ERROR mismatched self type x } - fn bar(self: &Bar<uint>, x: int) -> int { //~ ERROR mismatched self type + fn bar(self: &Bar<usize>, x: isize) -> isize { //~ ERROR mismatched self type x } } diff --git a/src/test/compile-fail/unboxed-closure-feature-gate.rs b/src/test/compile-fail/unboxed-closure-feature-gate.rs index 9bb8037e2c3..5eb67a9bb71 100644 --- a/src/test/compile-fail/unboxed-closure-feature-gate.rs +++ b/src/test/compile-fail/unboxed-closure-feature-gate.rs @@ -15,11 +15,11 @@ trait Foo<A,R> { } fn main() { - let x: Box<Foo(int)>; + let x: Box<Foo(isize)>; //~^ ERROR parenthetical notation is only stable when used with the `Fn` family // No errors with these: - let x: Box<Fn(int)>; - let x: Box<FnMut(int)>; - let x: Box<FnOnce(int)>; + let x: Box<Fn(isize)>; + let x: Box<FnMut(isize)>; + let x: Box<FnOnce(isize)>; } diff --git a/src/test/compile-fail/unboxed-closure-illegal-move.rs b/src/test/compile-fail/unboxed-closure-illegal-move.rs index 4d6f04da026..d489c3a64fa 100644 --- a/src/test/compile-fail/unboxed-closure-illegal-move.rs +++ b/src/test/compile-fail/unboxed-closure-illegal-move.rs @@ -18,28 +18,28 @@ fn main() { // By-ref cases { - let x = box 0u; + let x = box 0us; let f = |&:| drop(x); //~ cannot move } { - let x = box 0u; + let x = box 0us; let f = |&mut:| drop(x); //~ cannot move } { - let x = box 0u; + let x = box 0us; let f = |:| drop(x); //~ cannot move } // By-value cases { - let x = box 0u; + let x = box 0us; let f = move |&:| drop(x); //~ cannot move } { - let x = box 0u; + let x = box 0us; let f = move |&mut:| drop(x); //~ cannot move } { - let x = box 0u; + let x = box 0us; let f = move |:| drop(x); // this one is ok } } diff --git a/src/test/compile-fail/unboxed-closure-immutable-capture.rs b/src/test/compile-fail/unboxed-closure-immutable-capture.rs index e28abaf2b1f..ebdd3c3107f 100644 --- a/src/test/compile-fail/unboxed-closure-immutable-capture.rs +++ b/src/test/compile-fail/unboxed-closure-immutable-capture.rs @@ -14,10 +14,10 @@ // environment cannot mutate captured variables that have not been // declared mutable (#18335) -fn set(x: &mut uint) { *x = 0; } +fn set(x: &mut usize) { *x = 0; } fn main() { - let x = 0u; + let x = 0us; move |&mut:| x = 1; //~ ERROR cannot assign move |&mut:| set(&mut x); //~ ERROR cannot borrow move |:| x = 1; //~ ERROR cannot assign diff --git a/src/test/compile-fail/unboxed-closure-region.rs b/src/test/compile-fail/unboxed-closure-region.rs index 2a71aeaca5f..9d966798694 100644 --- a/src/test/compile-fail/unboxed-closure-region.rs +++ b/src/test/compile-fail/unboxed-closure-region.rs @@ -14,7 +14,7 @@ // reference cannot escape the region of that variable. fn main() { let _f = { - let x = 0u; + let x = 0us; |:| x //~ ERROR cannot infer an appropriate lifetime due to conflicting requirements }; } diff --git a/src/test/compile-fail/unboxed-closure-sugar-default.rs b/src/test/compile-fail/unboxed-closure-sugar-default.rs index 82355ddf681..0d9e406b086 100644 --- a/src/test/compile-fail/unboxed-closure-sugar-default.rs +++ b/src/test/compile-fail/unboxed-closure-sugar-default.rs @@ -24,14 +24,14 @@ fn eq<A: ?Sized,B: ?Sized>() where A : Eq<B> { } fn test<'a,'b>() { // Parens are equivalent to omitting default in angle. - eq::< Foo<(int,),()>, Foo(int) >(); + eq::< Foo<(isize,),()>, Foo(isize) >(); // In angle version, we supply something other than the default - eq::< Foo<(int,),(),int>, Foo(int) >(); + eq::< Foo<(isize,),(),isize>, Foo(isize) >(); //~^ ERROR not implemented // Supply default explicitly. - eq::< Foo<(int,),(),(int,)>, Foo(int) >(); + eq::< Foo<(isize,),(),(isize,)>, Foo(isize) >(); } fn main() { } diff --git a/src/test/compile-fail/unboxed-closure-sugar-equiv.rs b/src/test/compile-fail/unboxed-closure-sugar-equiv.rs index f36fad30670..9dff0e9e01e 100644 --- a/src/test/compile-fail/unboxed-closure-sugar-equiv.rs +++ b/src/test/compile-fail/unboxed-closure-sugar-equiv.rs @@ -27,26 +27,26 @@ fn eq<A: ?Sized,B: ?Sized +Eq<A>>() { } fn test<'a,'b>() { // No errors expected: eq::< Foo<(),()>, Foo() >(); - eq::< Foo<(int,),()>, Foo(int) >(); - eq::< Foo<(int,uint),()>, Foo(int,uint) >(); - eq::< Foo<(int,uint),uint>, Foo(int,uint) -> uint >(); - eq::< Foo<(&'a int,&'b uint),uint>, Foo(&'a int,&'b uint) -> uint >(); + eq::< Foo<(isize,),()>, Foo(isize) >(); + eq::< Foo<(isize,usize),()>, Foo(isize,usize) >(); + eq::< Foo<(isize,usize),usize>, Foo(isize,usize) -> usize >(); + eq::< Foo<(&'a isize,&'b usize),usize>, Foo(&'a isize,&'b usize) -> usize >(); // Test that anonymous regions in `()` form are equivalent // to fresh bound regions, and that we can intermingle // named and anonymous as we choose: - eq::< for<'x,'y> Foo<(&'x int,&'y uint),uint>, - for<'x,'y> Foo(&'x int,&'y uint) -> uint >(); - eq::< for<'x,'y> Foo<(&'x int,&'y uint),uint>, - for<'x> Foo(&'x int,&uint) -> uint >(); - eq::< for<'x,'y> Foo<(&'x int,&'y uint),uint>, - for<'y> Foo(&int,&'y uint) -> uint >(); - eq::< for<'x,'y> Foo<(&'x int,&'y uint),uint>, - Foo(&int,&uint) -> uint >(); + eq::< for<'x,'y> Foo<(&'x isize,&'y usize),usize>, + for<'x,'y> Foo(&'x isize,&'y usize) -> usize >(); + eq::< for<'x,'y> Foo<(&'x isize,&'y usize),usize>, + for<'x> Foo(&'x isize,&usize) -> usize >(); + eq::< for<'x,'y> Foo<(&'x isize,&'y usize),usize>, + for<'y> Foo(&isize,&'y usize) -> usize >(); + eq::< for<'x,'y> Foo<(&'x isize,&'y usize),usize>, + Foo(&isize,&usize) -> usize >(); // lifetime elision - eq::< for<'x> Foo<(&'x int,), &'x int>, - Foo(&int) -> &int >(); + eq::< for<'x> Foo<(&'x isize,), &'x isize>, + Foo(&isize) -> &isize >(); // Errors expected: eq::< Foo<(),()>, Foo(char) >(); diff --git a/src/test/compile-fail/unboxed-closure-sugar-lifetime-elision.rs b/src/test/compile-fail/unboxed-closure-sugar-lifetime-elision.rs index 2617be295cd..29429c708d2 100644 --- a/src/test/compile-fail/unboxed-closure-sugar-lifetime-elision.rs +++ b/src/test/compile-fail/unboxed-closure-sugar-lifetime-elision.rs @@ -25,10 +25,10 @@ impl<X: ?Sized> Eq<X> for X { } fn eq<A: ?Sized,B: ?Sized +Eq<A>>() { } fn main() { - eq::< for<'a> Foo<(&'a int,), &'a int>, - Foo(&int) -> &int >(); - eq::< for<'a> Foo<(&'a int,), (&'a int, &'a int)>, - Foo(&int) -> (&int, &int) >(); + eq::< for<'a> Foo<(&'a isize,), &'a isize>, + Foo(&isize) -> &isize >(); + eq::< for<'a> Foo<(&'a isize,), (&'a isize, &'a isize)>, + Foo(&isize) -> (&isize, &isize) >(); - let _: Foo(&int, &uint) -> &uint; //~ ERROR missing lifetime specifier + let _: Foo(&isize, &usize) -> &usize; //~ ERROR missing lifetime specifier } diff --git a/src/test/compile-fail/unboxed-closure-sugar-nonexistent-trait.rs b/src/test/compile-fail/unboxed-closure-sugar-nonexistent-trait.rs index 23e2d2f4365..12f62d805e1 100644 --- a/src/test/compile-fail/unboxed-closure-sugar-nonexistent-trait.rs +++ b/src/test/compile-fail/unboxed-closure-sugar-nonexistent-trait.rs @@ -10,11 +10,11 @@ #![feature(unboxed_closures)] -fn f<F:Nonexist(int) -> int>(x: F) {} //~ ERROR nonexistent trait `Nonexist` +fn f<F:Nonexist(isize) -> isize>(x: F) {} //~ ERROR nonexistent trait `Nonexist` -type Typedef = int; +type Typedef = isize; -fn g<F:Typedef(int) -> int>(x: F) {} //~ ERROR `Typedef` is not a trait +fn g<F:Typedef(isize) -> isize>(x: F) {} //~ ERROR `Typedef` is not a trait fn main() {} diff --git a/src/test/compile-fail/unboxed-closure-sugar-region.rs b/src/test/compile-fail/unboxed-closure-sugar-region.rs index e0783b09cbd..c8dd33c11fd 100644 --- a/src/test/compile-fail/unboxed-closure-sugar-region.rs +++ b/src/test/compile-fail/unboxed-closure-sugar-region.rs @@ -29,14 +29,14 @@ fn same_type<A,B:Eq<A>>(a: A, b: B) { } fn test<'a,'b>() { // Parens are equivalent to omitting default in angle. - eq::< Foo<(int,),()>, Foo(int) >(); + eq::< Foo<(isize,),()>, Foo(isize) >(); // Here we specify 'static explicitly in angle-bracket version. // Parenthesized winds up getting inferred. - eq::< Foo<'static, (int,),()>, Foo(int) >(); + eq::< Foo<'static, (isize,),()>, Foo(isize) >(); } -fn test2(x: &Foo<(int,),()>, y: &Foo(int)) { +fn test2(x: &Foo<(isize,),()>, y: &Foo(isize)) { // Here, the omitted lifetimes are expanded to distinct things. same_type(x, y) //~ ERROR cannot infer } diff --git a/src/test/compile-fail/unboxed-closure-sugar-used-on-struct-3.rs b/src/test/compile-fail/unboxed-closure-sugar-used-on-struct-3.rs index 5e16adc4e42..d86f55d5368 100644 --- a/src/test/compile-fail/unboxed-closure-sugar-used-on-struct-3.rs +++ b/src/test/compile-fail/unboxed-closure-sugar-used-on-struct-3.rs @@ -19,7 +19,7 @@ impl<A,B> Bar<A,B> { } fn bar() { - let b = Box::Bar::<int,uint>::new(); // OK + let b = Box::Bar::<isize,usize>::new(); // OK let b = Box::Bar::()::new(); //~^ ERROR expected ident, found `(` diff --git a/src/test/compile-fail/unboxed-closure-sugar-wrong-trait.rs b/src/test/compile-fail/unboxed-closure-sugar-wrong-trait.rs index ba1e931ac64..b58e08355c1 100644 --- a/src/test/compile-fail/unboxed-closure-sugar-wrong-trait.rs +++ b/src/test/compile-fail/unboxed-closure-sugar-wrong-trait.rs @@ -12,7 +12,7 @@ trait Trait {} -fn f<F:Trait(int) -> int>(x: F) {} +fn f<F:Trait(isize) -> isize>(x: F) {} //~^ ERROR wrong number of type arguments: expected 0, found 2 fn main() {} diff --git a/src/test/compile-fail/unboxed-closures-borrow-conflict.rs b/src/test/compile-fail/unboxed-closures-borrow-conflict.rs index baf7f3f5e58..bb92e57d70c 100644 --- a/src/test/compile-fail/unboxed-closures-borrow-conflict.rs +++ b/src/test/compile-fail/unboxed-closures-borrow-conflict.rs @@ -14,7 +14,7 @@ // cause borrow conflicts. fn main() { - let mut x = 0u; + let mut x = 0us; let f = |:| x += 1; let _y = x; //~ ERROR cannot use `x` because it was mutably borrowed } diff --git a/src/test/compile-fail/unboxed-closures-fnmut-as-fn.rs b/src/test/compile-fail/unboxed-closures-fnmut-as-fn.rs index 9fbb8a18ae9..fc87ec9f959 100644 --- a/src/test/compile-fail/unboxed-closures-fnmut-as-fn.rs +++ b/src/test/compile-fail/unboxed-closures-fnmut-as-fn.rs @@ -18,13 +18,13 @@ use std::ops::{Fn,FnMut,FnOnce}; struct S; -impl FnMut<(int,),int> for S { - extern "rust-call" fn call_mut(&mut self, (x,): (int,)) -> int { +impl FnMut<(isize,),isize> for S { + extern "rust-call" fn call_mut(&mut self, (x,): (isize,)) -> isize { x * x } } -fn call_it<F:Fn(int)->int>(f: &F, x: int) -> int { +fn call_it<F:Fn(isize)->isize>(f: &F, x: isize) -> isize { f.call((x,)) } diff --git a/src/test/compile-fail/unboxed-closures-infer-argument-types-two-region-pointers.rs b/src/test/compile-fail/unboxed-closures-infer-argument-types-two-region-pointers.rs index 72109b22957..525d0b31995 100644 --- a/src/test/compile-fail/unboxed-closures-infer-argument-types-two-region-pointers.rs +++ b/src/test/compile-fail/unboxed-closures-infer-argument-types-two-region-pointers.rs @@ -23,7 +23,7 @@ fn doit<T,F>(val: T, f: &F) } pub fn main() { - doit(0i, &|&: x, y| { + doit(0is, &|&: x, y| { x.set(y); //~ ERROR cannot infer }); } diff --git a/src/test/compile-fail/unboxed-closures-static-call-wrong-trait.rs b/src/test/compile-fail/unboxed-closures-static-call-wrong-trait.rs index ddd2649a3fe..22bfabf040a 100644 --- a/src/test/compile-fail/unboxed-closures-static-call-wrong-trait.rs +++ b/src/test/compile-fail/unboxed-closures-static-call-wrong-trait.rs @@ -12,6 +12,6 @@ fn main() { let mut_ = |&mut: x| x; - mut_.call((0i, )); //~ ERROR does not implement any method in scope named `call` + mut_.call((0is, )); //~ ERROR does not implement any method in scope named `call` } diff --git a/src/test/compile-fail/unboxed-closures-type-mismatch.rs b/src/test/compile-fail/unboxed-closures-type-mismatch.rs index 61f13172832..f7ac2274ffb 100644 --- a/src/test/compile-fail/unboxed-closures-type-mismatch.rs +++ b/src/test/compile-fail/unboxed-closures-type-mismatch.rs @@ -13,7 +13,7 @@ use std::ops::FnMut; pub fn main() { - let mut f = |&mut: x: int, y: int| -> int { x + y }; - let z = f(1u, 2); //~ ERROR mismatched types + let mut f = |&mut: x: isize, y: isize| -> isize { x + y }; + let z = f(1us, 2); //~ ERROR mismatched types println!("{}", z); } diff --git a/src/test/compile-fail/unboxed-closures-unsafe-extern-fn.rs b/src/test/compile-fail/unboxed-closures-unsafe-extern-fn.rs index b0b37d077c1..ab909717cab 100644 --- a/src/test/compile-fail/unboxed-closures-unsafe-extern-fn.rs +++ b/src/test/compile-fail/unboxed-closures-unsafe-extern-fn.rs @@ -14,11 +14,11 @@ use std::ops::{Fn,FnMut,FnOnce}; -unsafe fn square(x: &int) -> int { (*x) * (*x) } +unsafe fn square(x: &isize) -> isize { (*x) * (*x) } -fn call_it<F:Fn(&int)->int>(_: &F, _: int) -> int { 0 } -fn call_it_mut<F:FnMut(&int)->int>(_: &mut F, _: int) -> int { 0 } -fn call_it_once<F:FnOnce(&int)->int>(_: F, _: int) -> int { 0 } +fn call_it<F:Fn(&isize)->isize>(_: &F, _: isize) -> isize { 0 } +fn call_it_mut<F:FnMut(&isize)->isize>(_: &mut F, _: isize) -> isize { 0 } +fn call_it_once<F:FnOnce(&isize)->isize>(_: F, _: isize) -> isize { 0 } fn a() { let x = call_it(&square, 22); //~ ERROR not implemented diff --git a/src/test/compile-fail/unboxed-closures-vtable-mismatch.rs b/src/test/compile-fail/unboxed-closures-vtable-mismatch.rs index 85b33f73bbc..95673a51319 100644 --- a/src/test/compile-fail/unboxed-closures-vtable-mismatch.rs +++ b/src/test/compile-fail/unboxed-closures-vtable-mismatch.rs @@ -12,12 +12,12 @@ use std::ops::FnMut; -fn call_it<F:FnMut<(int,int),int>>(y: int, mut f: F) -> int { +fn call_it<F:FnMut<(isize,isize),isize>>(y: isize, mut f: F) -> isize { f(2, y) } pub fn main() { - let f = |&mut: x: uint, y: int| -> int { (x as int) + y }; + let f = |&mut: x: usize, y: isize| -> isize { (x as isize) + y }; let z = call_it(3, f); //~ ERROR type mismatch println!("{}", z); } diff --git a/src/test/compile-fail/unboxed-closures-wrong-abi.rs b/src/test/compile-fail/unboxed-closures-wrong-abi.rs index 20a4ab85d7b..4a0b55558c0 100644 --- a/src/test/compile-fail/unboxed-closures-wrong-abi.rs +++ b/src/test/compile-fail/unboxed-closures-wrong-abi.rs @@ -14,11 +14,11 @@ use std::ops::{Fn,FnMut,FnOnce}; -extern "C" fn square(x: &int) -> int { (*x) * (*x) } +extern "C" fn square(x: &isize) -> isize { (*x) * (*x) } -fn call_it<F:Fn(&int)->int>(_: &F, _: int) -> int { 0 } -fn call_it_mut<F:FnMut(&int)->int>(_: &mut F, _: int) -> int { 0 } -fn call_it_once<F:FnOnce(&int)->int>(_: F, _: int) -> int { 0 } +fn call_it<F:Fn(&isize)->isize>(_: &F, _: isize) -> isize { 0 } +fn call_it_mut<F:FnMut(&isize)->isize>(_: &mut F, _: isize) -> isize { 0 } +fn call_it_once<F:FnOnce(&isize)->isize>(_: F, _: isize) -> isize { 0 } fn a() { let x = call_it(&square, 22); //~ ERROR not implemented diff --git a/src/test/compile-fail/unboxed-closures-wrong-arg-type-extern-fn.rs b/src/test/compile-fail/unboxed-closures-wrong-arg-type-extern-fn.rs index f08cff3cd68..b2fdf792630 100644 --- a/src/test/compile-fail/unboxed-closures-wrong-arg-type-extern-fn.rs +++ b/src/test/compile-fail/unboxed-closures-wrong-arg-type-extern-fn.rs @@ -14,12 +14,12 @@ use std::ops::{Fn,FnMut,FnOnce}; -unsafe fn square(x: int) -> int { x * x } -// note: argument type here is `int`, not `&int` +unsafe fn square(x: isize) -> isize { x * x } +// note: argument type here is `isize`, not `&isize` -fn call_it<F:Fn(&int)->int>(_: &F, _: int) -> int { 0 } -fn call_it_mut<F:FnMut(&int)->int>(_: &mut F, _: int) -> int { 0 } -fn call_it_once<F:FnOnce(&int)->int>(_: F, _: int) -> int { 0 } +fn call_it<F:Fn(&isize)->isize>(_: &F, _: isize) -> isize { 0 } +fn call_it_mut<F:FnMut(&isize)->isize>(_: &mut F, _: isize) -> isize { 0 } +fn call_it_once<F:FnOnce(&isize)->isize>(_: F, _: isize) -> isize { 0 } fn a() { let x = call_it(&square, 22); //~ ERROR not implemented diff --git a/src/test/compile-fail/unboxed-closures-wrong-trait.rs b/src/test/compile-fail/unboxed-closures-wrong-trait.rs index e15fe8ad049..e4255d0024f 100644 --- a/src/test/compile-fail/unboxed-closures-wrong-trait.rs +++ b/src/test/compile-fail/unboxed-closures-wrong-trait.rs @@ -10,13 +10,13 @@ #![feature(lang_items, overloaded_calls, unboxed_closures)] -fn c<F:Fn(int, int) -> int>(f: F) -> int { +fn c<F:Fn(isize, isize) -> isize>(f: F) -> isize { f(5, 6) } fn main() { - let z: int = 7; - assert_eq!(c(|&mut: x: int, y| x + y + z), 10); + let z: isize = 7; + assert_eq!(c(|&mut: x: isize, y| x + y + z), 10); //~^ ERROR not implemented } diff --git a/src/test/compile-fail/uninhabited-enum-cast.rs b/src/test/compile-fail/uninhabited-enum-cast.rs index 9f91337db9f..b4df5fb1e2a 100644 --- a/src/test/compile-fail/uninhabited-enum-cast.rs +++ b/src/test/compile-fail/uninhabited-enum-cast.rs @@ -11,7 +11,7 @@ enum E {} fn f(e: E) { - println!("{}", (e as int).to_string()); //~ ERROR non-scalar cast + println!("{}", (e as isize).to_string()); //~ ERROR non-scalar cast } fn main() {} diff --git a/src/test/compile-fail/unique-object-noncopyable.rs b/src/test/compile-fail/unique-object-noncopyable.rs index 2dde11ada28..5074d00ca15 100644 --- a/src/test/compile-fail/unique-object-noncopyable.rs +++ b/src/test/compile-fail/unique-object-noncopyable.rs @@ -15,7 +15,7 @@ trait Foo { } struct Bar { - x: int, + x: isize, } impl Drop for Bar { diff --git a/src/test/compile-fail/unique-unique-kind.rs b/src/test/compile-fail/unique-unique-kind.rs index ae354729b92..4b7f11b0560 100644 --- a/src/test/compile-fail/unique-unique-kind.rs +++ b/src/test/compile-fail/unique-unique-kind.rs @@ -16,7 +16,7 @@ fn f<T:Send>(_i: T) { } fn main() { - let i = box Rc::new(100i); + let i = box Rc::new(100is); f(i); //~^ ERROR `core::marker::Send` is not implemented //~^^ ERROR `core::marker::Send` is not implemented diff --git a/src/test/compile-fail/unique-vec-res.rs b/src/test/compile-fail/unique-vec-res.rs index b558989304f..4a84bb4c5ab 100644 --- a/src/test/compile-fail/unique-vec-res.rs +++ b/src/test/compile-fail/unique-vec-res.rs @@ -16,7 +16,7 @@ use std::cell::Cell; #[derive(Show)] struct r<'a> { - i: &'a Cell<int>, + i: &'a Cell<isize>, } #[unsafe_destructor] diff --git a/src/test/compile-fail/unnecessary-private.rs b/src/test/compile-fail/unnecessary-private.rs index abbb084dbc0..6e6ffd23c4a 100644 --- a/src/test/compile-fail/unnecessary-private.rs +++ b/src/test/compile-fail/unnecessary-private.rs @@ -19,7 +19,7 @@ fn main() { } struct D { - pub foo: int, //~ ERROR: visibility has no effect + pub foo: isize, //~ ERROR: visibility has no effect } pub fn foo() {} //~ ERROR: visibility has no effect pub mod bar {} //~ ERROR: visibility has no effect diff --git a/src/test/compile-fail/unop-move-semantics.rs b/src/test/compile-fail/unop-move-semantics.rs index f8cbdb4e160..94656667598 100644 --- a/src/test/compile-fail/unop-move-semantics.rs +++ b/src/test/compile-fail/unop-move-semantics.rs @@ -31,9 +31,9 @@ fn illegal_dereference<T: Not<Output=T>>(mut x: T, y: T) { let m = &mut x; let n = &y; - !*m; //~ ERROR: cannot move out of dereference of `&mut`-pointer + !*m; //~ ERROR: cannot move out of borrowed content - !*n; //~ ERROR: cannot move out of dereference of `&`-pointer + !*n; //~ ERROR: cannot move out of borrowed content } fn main() {} diff --git a/src/test/compile-fail/unreachable-arm.rs b/src/test/compile-fail/unreachable-arm.rs index 934ddb5f80b..f403457efbc 100644 --- a/src/test/compile-fail/unreachable-arm.rs +++ b/src/test/compile-fail/unreachable-arm.rs @@ -12,6 +12,6 @@ #![feature(box_syntax)] -enum foo { a(Box<foo>, int), b(uint), } +enum foo { a(Box<foo>, isize), b(usize), } -fn main() { match foo::b(1u) { foo::b(_) | foo::a(box _, 1) => { } foo::a(_, 1) => { } } } +fn main() { match foo::b(1us) { foo::b(_) | foo::a(box _, 1) => { } foo::a(_, 1) => { } } } diff --git a/src/test/compile-fail/unreachable-code.rs b/src/test/compile-fail/unreachable-code.rs index 87342352e9a..d96578f2df9 100644 --- a/src/test/compile-fail/unreachable-code.rs +++ b/src/test/compile-fail/unreachable-code.rs @@ -14,5 +14,5 @@ fn main() { loop{} - let a = 3i; //~ ERROR: unreachable statement + let a = 3is; //~ ERROR: unreachable statement } diff --git a/src/test/compile-fail/unsafe-fn-autoderef.rs b/src/test/compile-fail/unsafe-fn-autoderef.rs index 464abd57872..97a7bf14710 100644 --- a/src/test/compile-fail/unsafe-fn-autoderef.rs +++ b/src/test/compile-fail/unsafe-fn-autoderef.rs @@ -9,10 +9,10 @@ // except according to those terms. struct Rec { - f: int + f: isize } -fn f(p: *const Rec) -> int { +fn f(p: *const Rec) -> isize { // Test that * ptrs do not autoderef. There is a deeper reason for // prohibiting this, beyond making unsafe things annoying (which doesn't diff --git a/src/test/compile-fail/unsendable-class.rs b/src/test/compile-fail/unsendable-class.rs index 96f36af53aa..abd93fdfc6c 100644 --- a/src/test/compile-fail/unsendable-class.rs +++ b/src/test/compile-fail/unsendable-class.rs @@ -16,11 +16,11 @@ use std::sync::mpsc::channel; use std::rc::Rc; struct foo { - i: int, + i: isize, j: Rc<String>, } -fn foo(i:int, j: Rc<String>) -> foo { +fn foo(i:isize, j: Rc<String>) -> foo { foo { i: i, j: j diff --git a/src/test/compile-fail/unsized3.rs b/src/test/compile-fail/unsized3.rs index 2d330654881..9d4cfe0f4ac 100644 --- a/src/test/compile-fail/unsized3.rs +++ b/src/test/compile-fail/unsized3.rs @@ -55,12 +55,12 @@ fn f8<X: ?Sized>(x1: &S<X>, x2: &S<X>) { // Test some tuples. fn f9<X: ?Sized>(x1: Box<S<X>>, x2: Box<E<X>>) { - f5(&(*x1, 34i)); + f5(&(*x1, 34is)); //~^ ERROR the trait `core::marker::Sized` is not implemented } fn f10<X: ?Sized>(x1: Box<S<X>>, x2: Box<E<X>>) { - f5(&(32i, *x2)); + f5(&(32is, *x2)); //~^ ERROR the trait `core::marker::Sized` is not implemented } diff --git a/src/test/compile-fail/unsized5.rs b/src/test/compile-fail/unsized5.rs index 026d496aa43..dc10f795cd4 100644 --- a/src/test/compile-fail/unsized5.rs +++ b/src/test/compile-fail/unsized5.rs @@ -12,26 +12,26 @@ struct S1<X: ?Sized> { f1: X, //~ ERROR `core::marker::Sized` is not implemented - f2: int, + f2: isize, } struct S2<X: ?Sized> { - f: int, + f: isize, g: X, //~ ERROR `core::marker::Sized` is not implemented - h: int, + h: isize, } struct S3 { f: str, //~ ERROR `core::marker::Sized` is not implemented - g: [uint] + g: [usize] } struct S4 { f: str, //~ ERROR `core::marker::Sized` is not implemented - g: uint + g: usize } enum E<X: ?Sized> { - V1(X, int), //~ERROR `core::marker::Sized` is not implemented + V1(X, isize), //~ERROR `core::marker::Sized` is not implemented } enum F<X: ?Sized> { - V2{f1: X, f: int}, //~ERROR `core::marker::Sized` is not implemented + V2{f1: X, f: isize}, //~ERROR `core::marker::Sized` is not implemented } pub fn main() { diff --git a/src/test/compile-fail/unsized6.rs b/src/test/compile-fail/unsized6.rs index 02f3404b72b..21953d1bb09 100644 --- a/src/test/compile-fail/unsized6.rs +++ b/src/test/compile-fail/unsized6.rs @@ -15,24 +15,24 @@ trait T {} fn f1<X: ?Sized>(x: &X) { let _: X; // <-- this is OK, no bindings created, no initializer. - let _: (int, (X, int)); // same + let _: (isize, (X, isize)); // same let y: X; //~ERROR the trait `core::marker::Sized` is not implemented - let y: (int, (X, int)); //~ERROR the trait `core::marker::Sized` is not implemented + let y: (isize, (X, isize)); //~ERROR the trait `core::marker::Sized` is not implemented } fn f2<X: ?Sized + T>(x: &X) { let y: X; //~ERROR the trait `core::marker::Sized` is not implemented - let y: (int, (X, int)); //~ERROR the trait `core::marker::Sized` is not implemented + let y: (isize, (X, isize)); //~ERROR the trait `core::marker::Sized` is not implemented } fn f3<X: ?Sized>(x1: Box<X>, x2: Box<X>, x3: Box<X>) { let y: X = *x1; //~ERROR the trait `core::marker::Sized` is not implemented let y = *x2; //~ERROR the trait `core::marker::Sized` is not implemented - let (y, z) = (*x3, 4i); //~ERROR the trait `core::marker::Sized` is not implemented + let (y, z) = (*x3, 4is); //~ERROR the trait `core::marker::Sized` is not implemented } fn f4<X: ?Sized + T>(x1: Box<X>, x2: Box<X>, x3: Box<X>) { let y: X = *x1; //~ERROR the trait `core::marker::Sized` is not implemented let y = *x2; //~ERROR the trait `core::marker::Sized` is not implemented - let (y, z) = (*x3, 4i); //~ERROR the trait `core::marker::Sized` is not implemented + let (y, z) = (*x3, 4is); //~ERROR the trait `core::marker::Sized` is not implemented } fn g1<X: ?Sized>(x: X) {} //~ERROR the trait `core::marker::Sized` is not implemented diff --git a/src/test/compile-fail/unused-attr.rs b/src/test/compile-fail/unused-attr.rs index 786421c4ef9..635ceec73a3 100644 --- a/src/test/compile-fail/unused-attr.rs +++ b/src/test/compile-fail/unused-attr.rs @@ -44,7 +44,7 @@ fn bar(f: foo::Foo) { #[foo] //~ ERROR unused attribute struct Foo { #[foo] //~ ERROR unused attribute - a: int + a: isize } #[foo] //~ ERROR unused attribute diff --git a/src/test/compile-fail/unused-mut-warning-captured-var.rs b/src/test/compile-fail/unused-mut-warning-captured-var.rs index 2c000e03ce4..aa5adb6a6b0 100644 --- a/src/test/compile-fail/unused-mut-warning-captured-var.rs +++ b/src/test/compile-fail/unused-mut-warning-captured-var.rs @@ -11,7 +11,7 @@ #![forbid(unused_mut)] fn main() { - let mut x = 1i; + let mut x = 1is; //~^ ERROR: variable does not need to be mutable move|:| { println!("{}", x); }; } diff --git a/src/test/compile-fail/unused-result.rs b/src/test/compile-fail/unused-result.rs index 1263d7c5710..6ed3b081c97 100644 --- a/src/test/compile-fail/unused-result.rs +++ b/src/test/compile-fail/unused-result.rs @@ -19,30 +19,30 @@ enum MustUseMsg { Test2 } fn foo<T>() -> T { panic!() } -fn bar() -> int { return foo::<int>(); } +fn bar() -> isize { return foo::<isize>(); } fn baz() -> MustUse { return foo::<MustUse>(); } fn qux() -> MustUseMsg { return foo::<MustUseMsg>(); } #[allow(unused_results)] fn test() { - foo::<int>(); + foo::<isize>(); foo::<MustUse>(); //~ ERROR: unused result which must be used foo::<MustUseMsg>(); //~ ERROR: unused result which must be used: some message } #[allow(unused_results, unused_must_use)] fn test2() { - foo::<int>(); + foo::<isize>(); foo::<MustUse>(); foo::<MustUseMsg>(); } fn main() { - foo::<int>(); //~ ERROR: unused result + foo::<isize>(); //~ ERROR: unused result foo::<MustUse>(); //~ ERROR: unused result which must be used foo::<MustUseMsg>(); //~ ERROR: unused result which must be used: some message - let _ = foo::<int>(); + let _ = foo::<isize>(); let _ = foo::<MustUse>(); let _ = foo::<MustUseMsg>(); } diff --git a/src/test/compile-fail/use-after-move-self-based-on-type.rs b/src/test/compile-fail/use-after-move-self-based-on-type.rs index a1b7f83da2f..810fc68a0f4 100644 --- a/src/test/compile-fail/use-after-move-self-based-on-type.rs +++ b/src/test/compile-fail/use-after-move-self-based-on-type.rs @@ -9,7 +9,7 @@ // except according to those terms. struct S { - x: int, + x: isize, } impl Drop for S { @@ -17,7 +17,7 @@ impl Drop for S { } impl S { - pub fn foo(self) -> int { + pub fn foo(self) -> isize { self.bar(); return self.x; //~ ERROR use of moved value: `self.x` } diff --git a/src/test/compile-fail/use-after-move-self.rs b/src/test/compile-fail/use-after-move-self.rs index ce0f2808e33..e9ffb26aba5 100644 --- a/src/test/compile-fail/use-after-move-self.rs +++ b/src/test/compile-fail/use-after-move-self.rs @@ -11,11 +11,11 @@ #![feature(box_syntax)] struct S { - x: Box<int>, + x: Box<isize>, } impl S { - pub fn foo(self) -> int { + pub fn foo(self) -> isize { self.bar(); return *self.x; //~ ERROR use of moved value: `*self.x` } diff --git a/src/test/compile-fail/use-mod-3.rs b/src/test/compile-fail/use-mod-3.rs index 040674fd6d9..bd954272fcc 100644 --- a/src/test/compile-fail/use-mod-3.rs +++ b/src/test/compile-fail/use-mod-3.rs @@ -17,7 +17,7 @@ use foo::bar::{ }; mod foo { - mod bar { pub type Bar = int; } + mod bar { pub type Bar = isize; } } fn main() {} diff --git a/src/test/compile-fail/useless-priv.rs b/src/test/compile-fail/useless-priv.rs index bb39107463e..d8531f4543d 100644 --- a/src/test/compile-fail/useless-priv.rs +++ b/src/test/compile-fail/useless-priv.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -struct A { pub i: int } +struct A { pub i: isize } pub enum C { pub Variant } //~ ERROR: unnecessary `pub` pub trait E { diff --git a/src/test/compile-fail/utf8_idents.rs b/src/test/compile-fail/utf8_idents.rs index 9bd14305b9a..a5471e87f22 100644 --- a/src/test/compile-fail/utf8_idents.rs +++ b/src/test/compile-fail/utf8_idents.rs @@ -16,7 +16,7 @@ fn foo< >() {} struct X { - δ: uint //~ ERROR non-ascii idents are not fully supported + δ: usize //~ ERROR non-ascii idents are not fully supported } pub fn main() { diff --git a/src/test/compile-fail/variadic-ffi-1.rs b/src/test/compile-fail/variadic-ffi-1.rs index 93f702d8052..34846ab496d 100644 --- a/src/test/compile-fail/variadic-ffi-1.rs +++ b/src/test/compile-fail/variadic-ffi-1.rs @@ -10,7 +10,7 @@ extern { fn printf(...); //~ ERROR: variadic function must be declared with at least one named argument - fn printf(..., foo: int); //~ ERROR: `...` must be last in argument list for variadic function + fn printf(..., foo: isize); //~ ERROR: `...` must be last in argument list for variadic function } fn main() {} diff --git a/src/test/compile-fail/variadic-ffi-2.rs b/src/test/compile-fail/variadic-ffi-2.rs index 9e2b015f33d..1d519c978a3 100644 --- a/src/test/compile-fail/variadic-ffi-2.rs +++ b/src/test/compile-fail/variadic-ffi-2.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -fn baz(f: extern "stdcall" fn(uint, ...)) { +fn baz(f: extern "stdcall" fn(usize, ...)) { //~^ ERROR: variadic function must have C calling convention f(22, 44); } diff --git a/src/test/compile-fail/variadic-ffi-3.rs b/src/test/compile-fail/variadic-ffi-3.rs index f143e715450..331a4523934 100644 --- a/src/test/compile-fail/variadic-ffi-3.rs +++ b/src/test/compile-fail/variadic-ffi-3.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -fn foo(x: int, ...) { +fn foo(x: isize, ...) { //~^ ERROR: only foreign functions are allowed to be variadic } diff --git a/src/test/compile-fail/variadic-ffi-4.rs b/src/test/compile-fail/variadic-ffi-4.rs index d4c54dfffe0..62e985f44f7 100644 --- a/src/test/compile-fail/variadic-ffi-4.rs +++ b/src/test/compile-fail/variadic-ffi-4.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -extern "C" fn foo(x: int, ...) { +extern "C" fn foo(x: isize, ...) { //~^ ERROR: only foreign functions are allowed to be variadic } diff --git a/src/test/compile-fail/variance-cell-is-invariant.rs b/src/test/compile-fail/variance-cell-is-invariant.rs index 0efca74f3ce..b8a8f9ad91c 100644 --- a/src/test/compile-fail/variance-cell-is-invariant.rs +++ b/src/test/compile-fail/variance-cell-is-invariant.rs @@ -14,12 +14,12 @@ use std::cell::Cell; struct Foo<'a> { - x: Cell<Option<&'a int>>, + x: Cell<Option<&'a isize>>, } fn use_<'short,'long>(c: Foo<'short>, - s: &'short int, - l: &'long int, + s: &'short isize, + l: &'long isize, _where:Option<&'short &'long ()>) { let _: Foo<'long> = c; //~ ERROR mismatched types } diff --git a/src/test/compile-fail/variance-regions-direct.rs b/src/test/compile-fail/variance-regions-direct.rs index fa38482b21c..04389b67dba 100644 --- a/src/test/compile-fail/variance-regions-direct.rs +++ b/src/test/compile-fail/variance-regions-direct.rs @@ -15,8 +15,8 @@ #[rustc_variance] struct Test2<'a, 'b, 'c> { //~ ERROR regions=[[-, -, -];[];[]] - x: &'a int, - y: &'b [int], + x: &'a isize, + y: &'b [isize], c: &'c str } @@ -24,8 +24,8 @@ struct Test2<'a, 'b, 'c> { //~ ERROR regions=[[-, -, -];[];[]] #[rustc_variance] struct Test3<'a, 'b, 'c> { //~ ERROR regions=[[+, +, +];[];[]] - x: extern "Rust" fn(&'a int), - y: extern "Rust" fn(&'b [int]), + x: extern "Rust" fn(&'a isize), + y: extern "Rust" fn(&'b [isize]), c: extern "Rust" fn(&'c str), } @@ -33,7 +33,7 @@ struct Test3<'a, 'b, 'c> { //~ ERROR regions=[[+, +, +];[];[]] #[rustc_variance] struct Test4<'a, 'b:'a> { //~ ERROR regions=[[-, o];[];[]] - x: &'a mut &'b int, + x: &'a mut &'b isize, } // Mutability induces invariance, even when in a @@ -41,32 +41,32 @@ struct Test4<'a, 'b:'a> { //~ ERROR regions=[[-, o];[];[]] #[rustc_variance] struct Test5<'a, 'b> { //~ ERROR regions=[[+, o];[];[]] - x: extern "Rust" fn(&'a mut &'b int), + x: extern "Rust" fn(&'a mut &'b isize), } // Invariance is a trap from which NO ONE CAN ESCAPE. -// In other words, even though the `&'b int` occurs in +// In other words, even though the `&'b isize` occurs in // a argument list (which is contravariant), that // argument list occurs in an invariant context. #[rustc_variance] struct Test6<'a, 'b> { //~ ERROR regions=[[-, o];[];[]] - x: &'a mut extern "Rust" fn(&'b int), + x: &'a mut extern "Rust" fn(&'b isize), } // No uses at all is bivariant: #[rustc_variance] struct Test7<'a> { //~ ERROR regions=[[*];[];[]] - x: int + x: isize } // Try enums too. #[rustc_variance] enum Test8<'a, 'b, 'c:'b> { //~ ERROR regions=[[+, -, o];[];[]] - Test8A(extern "Rust" fn(&'a int)), - Test8B(&'b [int]), + Test8A(extern "Rust" fn(&'a isize)), + Test8B(&'b [isize]), Test8C(&'b mut &'c str), } diff --git a/src/test/compile-fail/variance-regions-indirect.rs b/src/test/compile-fail/variance-regions-indirect.rs index c049fbc0fed..e2c7958b31d 100644 --- a/src/test/compile-fail/variance-regions-indirect.rs +++ b/src/test/compile-fail/variance-regions-indirect.rs @@ -14,8 +14,8 @@ #[rustc_variance] enum Base<'a, 'b, 'c:'b, 'd> { //~ ERROR regions=[[+, -, o, *];[];[]] - Test8A(extern "Rust" fn(&'a int)), - Test8B(&'b [int]), + Test8A(extern "Rust" fn(&'a isize)), + Test8B(&'b [isize]), Test8C(&'b mut &'c str), } diff --git a/src/test/compile-fail/variance-trait-matching.rs b/src/test/compile-fail/variance-trait-matching.rs index 1644705222f..d4dab5f0ed0 100644 --- a/src/test/compile-fail/variance-trait-matching.rs +++ b/src/test/compile-fail/variance-trait-matching.rs @@ -11,18 +11,18 @@ // Issue #5781. Tests that subtyping is handled properly in trait matching. trait Make<'a> { - fn make(x: &'a mut int) -> Self; + fn make(x: &'a mut isize) -> Self; } -impl<'a> Make<'a> for &'a mut int { - fn make(x: &'a mut int) -> &'a mut int { +impl<'a> Make<'a> for &'a mut isize { + fn make(x: &'a mut isize) -> &'a mut isize { x } } -fn f() -> &'static mut int { +fn f() -> &'static mut isize { let mut x = 1; - let y: &'static mut int = Make::make(&mut x); //~ ERROR `x` does not live long enough + let y: &'static mut isize = Make::make(&mut x); //~ ERROR `x` does not live long enough y } diff --git a/src/test/compile-fail/vec-matching-obsolete-syntax.rs b/src/test/compile-fail/vec-matching-obsolete-syntax.rs index 6330aac2d8b..2715b31d196 100644 --- a/src/test/compile-fail/vec-matching-obsolete-syntax.rs +++ b/src/test/compile-fail/vec-matching-obsolete-syntax.rs @@ -9,7 +9,7 @@ // except according to those terms. fn main() { - let x = [1i, 2, 3]; + let x = [1is, 2, 3]; match x { [a, b, ..c] => { //~ ERROR obsolete syntax assert_eq!(a, 1); diff --git a/src/test/compile-fail/vec-mut-iter-borrow.rs b/src/test/compile-fail/vec-mut-iter-borrow.rs index c03956c42cb..59c490f2fff 100644 --- a/src/test/compile-fail/vec-mut-iter-borrow.rs +++ b/src/test/compile-fail/vec-mut-iter-borrow.rs @@ -9,9 +9,9 @@ // except according to those terms. fn main() { - let mut xs: Vec<int> = vec!(); + let mut xs: Vec<isize> = vec!(); for x in xs.iter_mut() { - xs.push(1i) //~ ERROR cannot borrow `xs` + xs.push(1is) //~ ERROR cannot borrow `xs` } } diff --git a/src/test/compile-fail/vec-res-add.rs b/src/test/compile-fail/vec-res-add.rs index dc166f9fd9d..97a684b2459 100644 --- a/src/test/compile-fail/vec-res-add.rs +++ b/src/test/compile-fail/vec-res-add.rs @@ -10,10 +10,10 @@ #[derive(Show)] struct r { - i:int + i:isize } -fn r(i:int) -> r { r { i: i } } +fn r(i:isize) -> r { r { i: i } } impl Drop for r { fn drop(&mut self) {} diff --git a/src/test/compile-fail/virtual-structs.rs b/src/test/compile-fail/virtual-structs.rs index 69125bab2ce..3b3c7d5a30f 100644 --- a/src/test/compile-fail/virtual-structs.rs +++ b/src/test/compile-fail/virtual-structs.rs @@ -12,7 +12,7 @@ #![feature(struct_inherit)] virtual struct SuperStruct { //~ ERROR `virtual` structs have been removed from the language - f1: int, + f1: isize, } struct Struct : SuperStruct; //~ ERROR `virtual` structs have been removed from the language diff --git a/src/test/compile-fail/vtable-res-trait-param.rs b/src/test/compile-fail/vtable-res-trait-param.rs index 12cfe9c20fa..bbe88379aa7 100644 --- a/src/test/compile-fail/vtable-res-trait-param.rs +++ b/src/test/compile-fail/vtable-res-trait-param.rs @@ -9,25 +9,25 @@ // except according to those terms. trait TraitA { - fn method_a(&self) -> int; + fn method_a(&self) -> isize; } trait TraitB { - fn gimme_an_a<A:TraitA>(&self, a: A) -> int; + fn gimme_an_a<A:TraitA>(&self, a: A) -> isize; } -impl TraitB for int { - fn gimme_an_a<A:TraitA>(&self, a: A) -> int { +impl TraitB for isize { + fn gimme_an_a<A:TraitA>(&self, a: A) -> isize { a.method_a() + *self } } -fn call_it<B:TraitB>(b: B) -> int { - let y = 4u; +fn call_it<B:TraitB>(b: B) -> isize { + let y = 4us; b.gimme_an_a(y) //~ ERROR the trait `TraitA` is not implemented } fn main() { - let x = 3i; + let x = 3is; assert_eq!(call_it(x), 22); } diff --git a/src/test/compile-fail/walk-struct-literal-with.rs b/src/test/compile-fail/walk-struct-literal-with.rs index bb3b310a68f..0f3754e09e4 100644 --- a/src/test/compile-fail/walk-struct-literal-with.rs +++ b/src/test/compile-fail/walk-struct-literal-with.rs @@ -10,7 +10,7 @@ struct Mine{ test: String, - other_val: int + other_val: isize } impl Mine{ diff --git a/src/test/compile-fail/warn-path-statement.rs b/src/test/compile-fail/warn-path-statement.rs index 8b6d160a6c5..304900df776 100644 --- a/src/test/compile-fail/warn-path-statement.rs +++ b/src/test/compile-fail/warn-path-statement.rs @@ -11,6 +11,6 @@ // compile-flags: -D path-statement fn main() { - let x = 10i; + let x = 10is; x; //~ ERROR path statement with no effect } diff --git a/src/test/compile-fail/where-clause-method-substituion.rs b/src/test/compile-fail/where-clause-method-substituion.rs index 40d2df45488..a5108f005dc 100644 --- a/src/test/compile-fail/where-clause-method-substituion.rs +++ b/src/test/compile-fail/where-clause-method-substituion.rs @@ -19,7 +19,7 @@ struct X; // Remove this impl causing the below resolution to fail // impl Foo<S> for X {} -impl Bar<X> for int { +impl Bar<X> for isize { fn method<U>(&self) where X: Foo<U> { } } diff --git a/src/test/compile-fail/where-clauses-not-parameter.rs b/src/test/compile-fail/where-clauses-not-parameter.rs index d8af859c081..5573464c5ab 100644 --- a/src/test/compile-fail/where-clauses-not-parameter.rs +++ b/src/test/compile-fail/where-clauses-not-parameter.rs @@ -35,11 +35,11 @@ trait Baz<T> where isize : Eq { //~^ ERROR cannot bound type `isize`, where clause } -impl Baz<int> for int where isize : Eq { +impl Baz<isize> for isize where isize : Eq { //~^ ERROR cannot bound type `isize`, where clause bounds fn baz() where String : Eq {} } fn main() { - equal(&0i, &0i); + equal(&0is, &0is); } diff --git a/src/test/compile-fail/while-let.rs b/src/test/compile-fail/while-let.rs index adb8ee6940d..45e0d0aaeab 100644 --- a/src/test/compile-fail/while-let.rs +++ b/src/test/compile-fail/while-let.rs @@ -20,16 +20,16 @@ fn macros() { }} } - foo!(a, 1i, { //~ ERROR irrefutable while-let + foo!(a, 1is, { //~ ERROR irrefutable while-let println!("irrefutable pattern"); }); - bar!(a, 1i, { //~ ERROR irrefutable while-let + bar!(a, 1is, { //~ ERROR irrefutable while-let println!("irrefutable pattern"); }); } pub fn main() { - while let a = 1i { //~ ERROR irrefutable while-let + while let a = 1is { //~ ERROR irrefutable while-let println!("irrefutable pattern"); } } diff --git a/src/test/compile-fail/writing-to-immutable-vec.rs b/src/test/compile-fail/writing-to-immutable-vec.rs index 4e9f1545f3a..09c9439b464 100644 --- a/src/test/compile-fail/writing-to-immutable-vec.rs +++ b/src/test/compile-fail/writing-to-immutable-vec.rs @@ -10,6 +10,6 @@ fn main() { - let v: Vec<int> = vec!(1, 2, 3); + let v: Vec<isize> = vec!(1, 2, 3); v[1] = 4; //~ ERROR cannot borrow immutable local variable `v` as mutable } diff --git a/src/test/compile-fail/wrong-ret-type.rs b/src/test/compile-fail/wrong-ret-type.rs index ba3f3df7990..6db11fcffd2 100644 --- a/src/test/compile-fail/wrong-ret-type.rs +++ b/src/test/compile-fail/wrong-ret-type.rs @@ -9,5 +9,5 @@ // except according to those terms. // error-pattern: mismatched types -fn mk_int() -> uint { let i: int = 3; return i; } +fn mk_int() -> usize { let i: isize = 3; return i; } fn main() { } diff --git a/src/test/debuginfo/simd.rs b/src/test/debuginfo/simd.rs index 288e7461dd5..4aaa3e0b75f 100644 --- a/src/test/debuginfo/simd.rs +++ b/src/test/debuginfo/simd.rs @@ -41,7 +41,7 @@ // gdb-command:continue -#![allow(experimental)] +#![allow(unstable)] #![allow(unused_variables)] #![omit_gdb_pretty_printer_section] diff --git a/src/test/run-make/graphviz-flowgraph/f01.rs b/src/test/run-make/graphviz-flowgraph/f01.rs index f1f1a1d5472..27b19807865 100644 --- a/src/test/run-make/graphviz-flowgraph/f01.rs +++ b/src/test/run-make/graphviz-flowgraph/f01.rs @@ -9,5 +9,5 @@ // except according to those terms. pub fn lit_1() { - 1i; + 1is; } diff --git a/src/test/run-make/graphviz-flowgraph/f02.dot-expected.dot b/src/test/run-make/graphviz-flowgraph/f02.dot-expected.dot index 230dcbaeb98..1f4a58ba0a3 100644 --- a/src/test/run-make/graphviz-flowgraph/f02.dot-expected.dot +++ b/src/test/run-make/graphviz-flowgraph/f02.dot-expected.dot @@ -2,8 +2,8 @@ digraph block { N0[label="entry"]; N1[label="exit"]; N2[label="local _x"]; - N3[label="stmt let _x: int;"]; - N4[label="block { let _x: int; }"]; + N3[label="stmt let _x: isize;"]; + N4[label="block { let _x: isize; }"]; N0 -> N2; N2 -> N3; N3 -> N4; diff --git a/src/test/run-make/graphviz-flowgraph/f02.rs b/src/test/run-make/graphviz-flowgraph/f02.rs index 3cdd73a49e1..f7fe1266198 100644 --- a/src/test/run-make/graphviz-flowgraph/f02.rs +++ b/src/test/run-make/graphviz-flowgraph/f02.rs @@ -9,5 +9,5 @@ // except according to those terms. pub fn decl_x_2() { - let _x : int; + let _x : isize; } diff --git a/src/test/run-make/graphviz-flowgraph/f03.rs b/src/test/run-make/graphviz-flowgraph/f03.rs index 051409a49b1..c95dbcbb31c 100644 --- a/src/test/run-make/graphviz-flowgraph/f03.rs +++ b/src/test/run-make/graphviz-flowgraph/f03.rs @@ -9,5 +9,5 @@ // except according to those terms. pub fn expr_add_3() { - 3i + 4; + 3is + 4; } diff --git a/src/test/run-make/graphviz-flowgraph/f04.rs b/src/test/run-make/graphviz-flowgraph/f04.rs index ed2f7e25dae..552cb24c750 100644 --- a/src/test/run-make/graphviz-flowgraph/f04.rs +++ b/src/test/run-make/graphviz-flowgraph/f04.rs @@ -9,5 +9,5 @@ // except according to those terms. pub fn pat_id_4() { - let _x = 4i; + let _x = 4is; } diff --git a/src/test/run-make/graphviz-flowgraph/f05.rs b/src/test/run-make/graphviz-flowgraph/f05.rs index b2591bdd08a..09a45c9bd21 100644 --- a/src/test/run-make/graphviz-flowgraph/f05.rs +++ b/src/test/run-make/graphviz-flowgraph/f05.rs @@ -9,5 +9,5 @@ // except according to those terms. pub fn pat_tup_5() { - let (_x, _y) = (5i, 55i); + let (_x, _y) = (5is, 55is); } diff --git a/src/test/run-make/graphviz-flowgraph/f06.rs b/src/test/run-make/graphviz-flowgraph/f06.rs index c914409629c..538ef2af898 100644 --- a/src/test/run-make/graphviz-flowgraph/f06.rs +++ b/src/test/run-make/graphviz-flowgraph/f06.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -struct S6 { val: int } +struct S6 { val: isize } pub fn pat_struct_6() { let S6 { val: _x } = S6{ val: 6 }; } diff --git a/src/test/run-make/graphviz-flowgraph/f07.rs b/src/test/run-make/graphviz-flowgraph/f07.rs index fb3f2d24cdd..8334f81c080 100644 --- a/src/test/run-make/graphviz-flowgraph/f07.rs +++ b/src/test/run-make/graphviz-flowgraph/f07.rs @@ -9,7 +9,7 @@ // except according to those terms. pub fn pat_vec_7() { - match [7i, 77i, 777i, 7777i] { + match [7is, 77is, 777is, 7777is] { [x, y, ..] => x + y }; } diff --git a/src/test/run-make/graphviz-flowgraph/f08.rs b/src/test/run-make/graphviz-flowgraph/f08.rs index 5d166e5ffcd..ad96f30073b 100644 --- a/src/test/run-make/graphviz-flowgraph/f08.rs +++ b/src/test/run-make/graphviz-flowgraph/f08.rs @@ -9,8 +9,8 @@ // except according to those terms. pub fn expr_if_onearm_8() { - let x = 8i; let _y; - if x > 88i { - _y = 888i; + let x = 8is; let _y; + if x > 88is { + _y = 888is; } } diff --git a/src/test/run-make/graphviz-flowgraph/f10.rs b/src/test/run-make/graphviz-flowgraph/f10.rs index af263f0cf10..456f740d468 100644 --- a/src/test/run-make/graphviz-flowgraph/f10.rs +++ b/src/test/run-make/graphviz-flowgraph/f10.rs @@ -9,8 +9,8 @@ // except according to those terms. pub fn expr_while_10() { - let mut x = 10i; - while x > 0i { - x -= 1i; + let mut x = 10is; + while x > 0is { + x -= 1is; } } diff --git a/src/test/run-make/graphviz-flowgraph/f11.rs b/src/test/run-make/graphviz-flowgraph/f11.rs index 95260c608ec..65262f249bc 100644 --- a/src/test/run-make/graphviz-flowgraph/f11.rs +++ b/src/test/run-make/graphviz-flowgraph/f11.rs @@ -10,9 +10,9 @@ #[allow(unreachable_code)] pub fn expr_loop_11() { - let mut _x = 11i; + let mut _x = 11is; loop { - _x -= 1i; + _x -= 1is; } "unreachable"; } diff --git a/src/test/run-make/graphviz-flowgraph/f12.rs b/src/test/run-make/graphviz-flowgraph/f12.rs index 625dd8cb03e..5651d73baff 100644 --- a/src/test/run-make/graphviz-flowgraph/f12.rs +++ b/src/test/run-make/graphviz-flowgraph/f12.rs @@ -10,9 +10,9 @@ #[allow(unreachable_code)] pub fn expr_loop_12() { - let mut x = 12i; + let mut x = 12is; loop { - x -= 1i; - if x == 2i { break; "unreachable"; } + x -= 1is; + if x == 2is { break; "unreachable"; } } } diff --git a/src/test/run-make/graphviz-flowgraph/f13.rs b/src/test/run-make/graphviz-flowgraph/f13.rs index fdda50b4312..babb283c734 100644 --- a/src/test/run-make/graphviz-flowgraph/f13.rs +++ b/src/test/run-make/graphviz-flowgraph/f13.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -enum E13 { E13a, E13b(int) } +enum E13 { E13a, E13b(isize) } pub fn expr_match_13() { let x = E13::E13b(13); let _y; match x { diff --git a/src/test/run-make/graphviz-flowgraph/f14.rs b/src/test/run-make/graphviz-flowgraph/f14.rs index 72616f31594..adb7b193d16 100644 --- a/src/test/run-make/graphviz-flowgraph/f14.rs +++ b/src/test/run-make/graphviz-flowgraph/f14.rs @@ -10,8 +10,8 @@ #[allow(unreachable_code)] pub fn expr_ret_14() { - let x = 14i; - if x > 1i { + let x = 14is; + if x > 1is { return; "unreachable"; } diff --git a/src/test/run-make/graphviz-flowgraph/f15.rs b/src/test/run-make/graphviz-flowgraph/f15.rs index 62233dcb7d8..a1141eb6768 100644 --- a/src/test/run-make/graphviz-flowgraph/f15.rs +++ b/src/test/run-make/graphviz-flowgraph/f15.rs @@ -10,21 +10,21 @@ #[allow(unreachable_code)] pub fn expr_break_label_15() { - let mut x = 15i; - let mut y = 151i; + let mut x = 15is; + let mut y = 151is; 'outer: loop { 'inner: loop { - if x == 1i { + if x == 1is { break 'outer; "unreachable"; } - if y >= 2i { + if y >= 2is { break; "unreachable"; } - y -= 3i; + y -= 3is; } - y -= 4i; - x -= 5i; + y -= 4is; + x -= 5is; } } diff --git a/src/test/run-make/graphviz-flowgraph/f16.rs b/src/test/run-make/graphviz-flowgraph/f16.rs index 2683d8bd06b..5d0e9f963a0 100644 --- a/src/test/run-make/graphviz-flowgraph/f16.rs +++ b/src/test/run-make/graphviz-flowgraph/f16.rs @@ -10,22 +10,22 @@ #[allow(unreachable_code)] pub fn expr_continue_label_16() { - let mut x = 16i; - let mut y = 16i; + let mut x = 16is; + let mut y = 16is; 'outer: loop { 'inner: loop { - if x == 1i { + if x == 1is { continue 'outer; "unreachable"; } - if y >= 1i { + if y >= 1is { break; "unreachable"; } - y -= 1i; + y -= 1is; } - y -= 1i; - x -= 1i; + y -= 1is; + x -= 1is; } "unreachable"; } diff --git a/src/test/run-make/graphviz-flowgraph/f17.rs b/src/test/run-make/graphviz-flowgraph/f17.rs index 23ce212c0af..de9b3bd5676 100644 --- a/src/test/run-make/graphviz-flowgraph/f17.rs +++ b/src/test/run-make/graphviz-flowgraph/f17.rs @@ -9,5 +9,5 @@ // except according to those terms. pub fn expr_vec_17() { - let _v = [1i, 7i, 17i]; + let _v = [1is, 7is, 17is]; } diff --git a/src/test/run-make/graphviz-flowgraph/f18.dot-expected.dot b/src/test/run-make/graphviz-flowgraph/f18.dot-expected.dot index c4a39a519ed..78120e9009e 100644 --- a/src/test/run-make/graphviz-flowgraph/f18.dot-expected.dot +++ b/src/test/run-make/graphviz-flowgraph/f18.dot-expected.dot @@ -1,14 +1,14 @@ digraph block { N0[label="entry"]; N1[label="exit"]; - N2[label="stmt fn inner(x: int) -> int { x + x }"]; + N2[label="stmt fn inner(x: isize) -> isize { x + x }"]; N3[label="expr inner"]; N4[label="expr inner"]; N5[label="expr 18"]; N6[label="expr inner(18)"]; N7[label="expr inner(inner(18))"]; N8[label="stmt inner(inner(18));"]; - N9[label="block {\l fn inner(x: int) -> int { x + x }\l inner(inner(18));\l}\l"]; + N9[label="block {\l fn inner(x: isize) -> isize { x + x }\l inner(inner(18));\l}\l"]; N0 -> N2; N2 -> N3; N3 -> N4; diff --git a/src/test/run-make/graphviz-flowgraph/f18.rs b/src/test/run-make/graphviz-flowgraph/f18.rs index 0ace542b8f5..cbf8aa5db43 100644 --- a/src/test/run-make/graphviz-flowgraph/f18.rs +++ b/src/test/run-make/graphviz-flowgraph/f18.rs @@ -9,6 +9,6 @@ // except according to those terms. pub fn expr_call_18() { - fn inner(x:int) -> int { x + x } + fn inner(x:isize) -> isize { x + x } inner(inner(18)); } diff --git a/src/test/run-make/graphviz-flowgraph/f19.dot-expected.dot b/src/test/run-make/graphviz-flowgraph/f19.dot-expected.dot index 8d21ef80917..4752eac3e28 100644 --- a/src/test/run-make/graphviz-flowgraph/f19.dot-expected.dot +++ b/src/test/run-make/graphviz-flowgraph/f19.dot-expected.dot @@ -1,7 +1,7 @@ digraph block { N0[label="entry"]; N1[label="exit"]; - N2[label="stmt struct S19 {\l x: int,\l}\l"]; + N2[label="stmt struct S19 {\l x: isize,\l}\l"]; N3[label="stmt impl S19 {\l fn inner(self) -> S19 { S19{x: self.x + self.x,} }\l}\l"]; N4[label="expr 19"]; N5[label="expr S19{x: 19,}"]; @@ -11,7 +11,7 @@ digraph block { N9[label="expr s.inner()"]; N10[label="expr s.inner().inner()"]; N11[label="stmt s.inner().inner();"]; - N12[label="block {\l struct S19 {\l x: int,\l }\l impl S19 {\l fn inner(self) -> S19 { S19{x: self.x + self.x,} }\l }\l let s = S19{x: 19,};\l s.inner().inner();\l}\l"]; + N12[label="block {\l struct S19 {\l x: isize,\l }\l impl S19 {\l fn inner(self) -> S19 { S19{x: self.x + self.x,} }\l }\l let s = S19{x: 19,};\l s.inner().inner();\l}\l"]; N0 -> N2; N2 -> N3; N3 -> N4; diff --git a/src/test/run-make/graphviz-flowgraph/f19.rs b/src/test/run-make/graphviz-flowgraph/f19.rs index 092f6890a15..78c15dd64ad 100644 --- a/src/test/run-make/graphviz-flowgraph/f19.rs +++ b/src/test/run-make/graphviz-flowgraph/f19.rs @@ -9,7 +9,7 @@ // except according to those terms. pub fn expr_method_call_19() { - struct S19 { x: int } + struct S19 { x: isize } impl S19 { fn inner(self) -> S19 { S19 { x: self.x + self.x } } } let s = S19 { x: 19 }; s.inner().inner(); diff --git a/src/test/run-make/graphviz-flowgraph/f20.rs b/src/test/run-make/graphviz-flowgraph/f20.rs index 7110ebe2b54..3ca55cb521b 100644 --- a/src/test/run-make/graphviz-flowgraph/f20.rs +++ b/src/test/run-make/graphviz-flowgraph/f20.rs @@ -9,6 +9,6 @@ // except according to those terms. pub fn expr_index_20() { - let v = [2u, 0u, 20u]; - v[20u]; + let v = [2us, 0us, 20us]; + v[20us]; } diff --git a/src/test/run-make/graphviz-flowgraph/f21.rs b/src/test/run-make/graphviz-flowgraph/f21.rs index bff2da25061..25e93f65110 100644 --- a/src/test/run-make/graphviz-flowgraph/f21.rs +++ b/src/test/run-make/graphviz-flowgraph/f21.rs @@ -10,20 +10,20 @@ #[allow(unreachable_code)] pub fn expr_break_label_21() { - let mut x = 15i; - let mut y = 151i; + let mut x = 15is; + let mut y = 151is; 'outer: loop { 'inner: loop { - if x == 1i { + if x == 1is { break 'outer; "unreachable"; } - if y >= 2i { + if y >= 2is { return; "unreachable"; } - y -= 3i; - x -= 5i; + y -= 3is; + x -= 5is; } "unreachable"; } diff --git a/src/test/run-make/graphviz-flowgraph/f22.rs b/src/test/run-make/graphviz-flowgraph/f22.rs index a6e3d571deb..6de703a42f6 100644 --- a/src/test/run-make/graphviz-flowgraph/f22.rs +++ b/src/test/run-make/graphviz-flowgraph/f22.rs @@ -10,20 +10,20 @@ #[allow(unreachable_code)] pub fn expr_break_label_21() { - let mut x = 15i; - let mut y = 151i; + let mut x = 15is; + let mut y = 151is; 'outer: loop { 'inner: loop { - if x == 1i { + if x == 1is { continue 'outer; "unreachable"; } - if y >= 2i { + if y >= 2is { return; "unreachable"; } - x -= 1i; - y -= 3i; + x -= 1is; + y -= 3is; } "unreachable"; } diff --git a/src/test/run-make/graphviz-flowgraph/f23.rs b/src/test/run-make/graphviz-flowgraph/f23.rs index 73bcc288ca7..6ffa1838903 100644 --- a/src/test/run-make/graphviz-flowgraph/f23.rs +++ b/src/test/run-make/graphviz-flowgraph/f23.rs @@ -10,19 +10,19 @@ #[allow(unreachable_code)] pub fn expr_while_23() { - let mut x = 23i; - let mut y = 23i; - let mut z = 23i; + let mut x = 23is; + let mut y = 23is; + let mut z = 23is; - while x > 0i { - x -= 1i; + while x > 0is { + x -= 1is; - while y > 0i { - y -= 1i; + while y > 0is { + y -= 1is; - while z > 0i { z -= 1i; } + while z > 0is { z -= 1is; } - if x > 10i { + if x > 10is { return; "unreachable"; } diff --git a/src/test/run-make/graphviz-flowgraph/f24.rs b/src/test/run-make/graphviz-flowgraph/f24.rs index afba1d202c9..ebaf7f28101 100644 --- a/src/test/run-make/graphviz-flowgraph/f24.rs +++ b/src/test/run-make/graphviz-flowgraph/f24.rs @@ -10,24 +10,24 @@ #[allow(unreachable_code)] pub fn expr_while_24() { - let mut x = 24i; - let mut y = 24i; - let mut z = 24i; + let mut x = 24is; + let mut y = 24is; + let mut z = 24is; loop { - if x == 0i { break; "unreachable"; } - x -= 1i; + if x == 0is { break; "unreachable"; } + x -= 1is; loop { - if y == 0i { break; "unreachable"; } - y -= 1i; + if y == 0is { break; "unreachable"; } + y -= 1is; loop { - if z == 0i { break; "unreachable"; } - z -= 1i; + if z == 0is { break; "unreachable"; } + z -= 1is; } - if x > 10i { + if x > 10is { return; "unreachable"; } diff --git a/src/test/run-make/graphviz-flowgraph/f25.rs b/src/test/run-make/graphviz-flowgraph/f25.rs index 933f95f228c..8896a854787 100644 --- a/src/test/run-make/graphviz-flowgraph/f25.rs +++ b/src/test/run-make/graphviz-flowgraph/f25.rs @@ -10,24 +10,24 @@ #[allow(unreachable_code)] pub fn expr_while_25() { - let mut x = 25i; - let mut y = 25i; - let mut z = 25i; + let mut x = 25is; + let mut y = 25is; + let mut z = 25is; 'a: loop { - if x == 0i { break; "unreachable"; } - x -= 1i; + if x == 0is { break; "unreachable"; } + x -= 1is; 'a: loop { - if y == 0i { break; "unreachable"; } - y -= 1i; + if y == 0is { break; "unreachable"; } + y -= 1is; 'a: loop { - if z == 0i { break; "unreachable"; } - z -= 1i; + if z == 0is { break; "unreachable"; } + z -= 1is; } - if x > 10i { + if x > 10is { continue 'a; "unreachable"; } diff --git a/src/test/run-pass/associated-type-doubleendediterator-object.rs b/src/test/run-pass/associated-types-doubleendediterator-object.rs index 7365e052171..7365e052171 100644 --- a/src/test/run-pass/associated-type-doubleendediterator-object.rs +++ b/src/test/run-pass/associated-types-doubleendediterator-object.rs diff --git a/src/test/run-pass/associated-types-nested-projections.rs b/src/test/run-pass/associated-types-nested-projections.rs new file mode 100644 index 00000000000..a907b9fcde5 --- /dev/null +++ b/src/test/run-pass/associated-types-nested-projections.rs @@ -0,0 +1,50 @@ +// 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 we can resolve nested projection types. Issue #20666. + +use std::slice; + +trait Bound {} + +impl<'a> Bound for &'a int {} + +trait IntoIterator { + type Iter: Iterator; + + fn into_iter(self) -> Self::Iter; +} + +impl<'a, T> IntoIterator for &'a [T; 3] { + type Iter = slice::Iter<'a, T>; + + fn into_iter(self) -> slice::Iter<'a, T> { + self.iter() + } +} + +fn foo<X>(x: X) where + X: IntoIterator, + <<X as IntoIterator>::Iter as Iterator>::Item: Bound, +{ +} + +fn bar<T, I, X>(x: X) where + T: Bound, + I: Iterator<Item=T>, + X: IntoIterator<Iter=I>, +{ + +} + +fn main() { + foo(&[0i, 1, 2]); + bar(&[0i, 1, 2]); +} diff --git a/src/test/run-pass/associated-types-projection-from-known-type-in-impl.rs b/src/test/run-pass/associated-types-projection-from-known-type-in-impl.rs new file mode 100644 index 00000000000..0a1a8589dec --- /dev/null +++ b/src/test/run-pass/associated-types-projection-from-known-type-in-impl.rs @@ -0,0 +1,44 @@ +// 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 where the impl self type uses a projection from a constant type. + +trait Int +{ + type T; +} + +trait NonZero +{ + fn non_zero(self) -> bool; +} + +impl Int for i32 { type T = i32; } +impl Int for i64 { type T = i64; } +impl Int for u32 { type T = u32; } +impl Int for u64 { type T = u64; } + +impl NonZero for <i32 as Int>::T { fn non_zero(self) -> bool { self != 0 } } +impl NonZero for <i64 as Int>::T { fn non_zero(self) -> bool { self != 0 } } +impl NonZero for <u32 as Int>::T { fn non_zero(self) -> bool { self != 0 } } +impl NonZero for <u64 as Int>::T { fn non_zero(self) -> bool { self != 0 } } + +fn main () +{ + assert!(NonZero::non_zero(22_i32)); + assert!(NonZero::non_zero(22_i64)); + assert!(NonZero::non_zero(22_u32)); + assert!(NonZero::non_zero(22_u64)); + + assert!(!NonZero::non_zero(0_i32)); + assert!(!NonZero::non_zero(0_i64)); + assert!(!NonZero::non_zero(0_u32)); + assert!(!NonZero::non_zero(0_u64)); +} diff --git a/src/test/run-pass/associated-types-projection-in-supertrait.rs b/src/test/run-pass/associated-types-projection-in-supertrait.rs new file mode 100644 index 00000000000..e6fec675b03 --- /dev/null +++ b/src/test/run-pass/associated-types-projection-in-supertrait.rs @@ -0,0 +1,50 @@ +// 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 we are handle to correctly handle a projection type +// that appears in a supertrait bound. Issue #20559. + +trait A +{ + type TA; +} + +trait B<TB> +{ + fn foo (&self, t : TB) -> String; +} + +trait C<TC : A> : B<<TC as A>::TA> { } + +struct X; + +impl A for X +{ + type TA = i32; +} + +struct Y; + +impl C<X> for Y { } + +// Both of these impls are required for successful compilation +impl B<i32> for Y +{ + fn foo (&self, t : i32) -> String + { + format!("First {}", t) + } +} + +fn main () +{ + let y = Y; + assert_eq!(y.foo(5), format!("First 5")); +} diff --git a/src/test/run-pass/opt-out-copy.rs b/src/test/run-pass/opt-out-copy.rs deleted file mode 100644 index 8c7072cfdf5..00000000000 --- a/src/test/run-pass/opt-out-copy.rs +++ /dev/null @@ -1,46 +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. - -#![feature(opt_out_copy)] - -// Test the opt-out-copy feature guard. This is the same as the -// "opt-in-copy.rs" test from compile-fail, except that it is using -// the feature guard, and hence the structureds in this file are -// implicitly copyable, and hence we get no errors. This test can be -// safely removed once the opt-out-copy "feature" is rejected. - -struct CantCopyThis; - -struct IWantToCopyThis { - but_i_cant: CantCopyThis, -} - -impl Copy for IWantToCopyThis {} - -enum CantCopyThisEither { - A, - B, -} - -enum IWantToCopyThisToo { - ButICant(CantCopyThisEither), -} - -impl Copy for IWantToCopyThisToo {} - -fn is_copy<T:Copy>() { } - -fn main() { - is_copy::<CantCopyThis>(); - is_copy::<CantCopyThisEither>(); - is_copy::<IWantToCopyThis>(); - is_copy::<IWantToCopyThisToo>(); -} - diff --git a/src/test/run-pass/shift-various-types.rs b/src/test/run-pass/shift-various-types.rs new file mode 100644 index 00000000000..2f56e09b2df --- /dev/null +++ b/src/test/run-pass/shift-various-types.rs @@ -0,0 +1,56 @@ +// 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 we can do shifts by any integral type. + +struct Panolpy { + i8: i8, + i16: i16, + i32: i32, + i64: i64, + isize: isize, + + u8: u8, + u16: u16, + u32: u32, + u64: u64, + usize: usize, +} + +fn foo(p: &Panolpy) { + assert_eq!(22_i32 >> p.i8, 11_i32); + assert_eq!(22_i32 >> p.i16, 11_i32); + assert_eq!(22_i32 >> p.i32, 11_i32); + assert_eq!(22_i32 >> p.i64, 11_i32); + assert_eq!(22_i32 >> p.isize, 11_i32); + + assert_eq!(22_i32 >> p.u8, 11_i32); + assert_eq!(22_i32 >> p.u16, 11_i32); + assert_eq!(22_i32 >> p.u32, 11_i32); + assert_eq!(22_i32 >> p.u64, 11_i32); + assert_eq!(22_i32 >> p.usize, 11_i32); +} + +fn main() { + let p = Panolpy { + i8: 1, + i16: 1, + i32: 1, + i64: 1, + isize: 1, + + u8: 1, + u16: 1, + u32: 1, + u64: 1, + usize: 1, + }; + foo(&p) +} diff --git a/src/test/run-pass/simd-binop.rs b/src/test/run-pass/simd-binop.rs index 7f9be78d583..690ad351247 100644 --- a/src/test/run-pass/simd-binop.rs +++ b/src/test/run-pass/simd-binop.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![allow(experimental)] +#![allow(unstable)] use std::simd::{i32x4, f32x4, u32x4}; diff --git a/src/test/run-pass/simd-issue-10604.rs b/src/test/run-pass/simd-issue-10604.rs index 966db25a128..6f0db23e2a6 100644 --- a/src/test/run-pass/simd-issue-10604.rs +++ b/src/test/run-pass/simd-issue-10604.rs @@ -9,7 +9,7 @@ // except according to those terms. -#![allow(experimental)] +#![allow(unstable)] #![feature(simd)] pub fn main() { diff --git a/src/test/run-pass/tcp-connect-timeouts.rs b/src/test/run-pass/tcp-connect-timeouts.rs index 4ab089b6eaa..56044289fba 100644 --- a/src/test/run-pass/tcp-connect-timeouts.rs +++ b/src/test/run-pass/tcp-connect-timeouts.rs @@ -16,7 +16,7 @@ // one test task to ensure that errors are timeouts, not file descriptor // exhaustion. -#![allow(experimental)] +#![allow(unstable)] #![reexport_test_harness_main = "test_main"] #![allow(unused_imports)] |