[rust]: https://www.rust-lang.org
-“The Rust Programming Language” is split into sections. This introduction
+“The Rust Programming Language” is split into chapters. This introduction
is the first. After this:
* [Getting started][gs] - Set up your computer for Rust development.
```
Our distance calculation works regardless of our `Edge` type, so the `E` stuff in
-this signature is just a distraction.
+this signature is a distraction.
What we really want to say is that a certain `E`dge and `N`ode type come together
to form each kind of `Graph`. We can do that with associated types:
This silly implementation always returns `true` and an empty `Vec<Edge>`, but it
gives you an idea of how to implement this kind of thing. We first need three
`struct`s, one for the graph, one for the node, and one for the edge. If it made
-more sense to use a different type, that would work as well, we’re just going to
+more sense to use a different type, that would work as well, we’re going to
use `struct`s for all three here.
-Next is the `impl` line, which is just like implementing any other trait.
+Next is the `impl` line, which is an implementation like any other trait.
From here, we use `=` to define our associated types. The name the trait uses
goes on the left of the `=`, and the concrete type we’re `impl`ementing this
The `transmute` function is provided by a [compiler intrinsic][intrinsics], and
what it does is very simple, but very scary. It tells Rust to treat a value of
one type as though it were another type. It does this regardless of the
-typechecking system, and just completely trusts you.
+typechecking system, and completely trusts you.
[intrinsics]: intrinsics.html
## `*const T` and `*mut T`
-These are C-like raw pointers with no lifetime or ownership attached to them. They just point to
+These are C-like raw pointers with no lifetime or ownership attached to them. They point to
some location in memory with no other restrictions. The only guarantee that these provide is that
they cannot be dereferenced except in code marked `unsafe`.
## `Arc<T>`
-[`Arc<T>`][arc] is just a version of `Rc<T>` that uses an atomic reference count (hence, "Arc").
+[`Arc<T>`][arc] is a version of `Rc<T>` that uses an atomic reference count (hence, "Arc").
This can be sent freely between threads.
C++'s `shared_ptr` is similar to `Arc`, however in the case of C++ the inner data is always mutable.
Rust’s implementation of closures is a bit different than other languages. They
are effectively syntax sugar for traits. You’ll want to make sure to have read
-the [traits chapter][traits] before this one, as well as the chapter on [trait
+the [traits][traits] section before this one, as well as the section on [trait
objects][trait-objects].
[traits]: traits.html
# Taking closures as arguments
Now that we know that closures are traits, we already know how to accept and
-return closures: just like any other trait!
+return closures: the same as any other trait!
This also means that we can choose static vs dynamic dispatch as well. First,
let’s write a function which takes something callable, calls it, and returns
assert_eq!(3, answer);
```
-We pass our closure, `|x| x + 2`, to `call_with_one`. It just does what it
+We pass our closure, `|x| x + 2`, to `call_with_one`. It does what it
suggests: it calls the closure, giving it `1` as an argument.
Let’s examine the signature of `call_with_one` in more depth:
we have a `[closure@<anon>:7:9: 7:20]`. Wait, what?
Because each closure generates its own environment `struct` and implementation
-of `Fn` and friends, these types are anonymous. They exist just solely for
+of `Fn` and friends, these types are anonymous. They exist solely for
this closure. So Rust shows them as `closure@<anon>`, rather than some
autogenerated name.
}
```
-We use the `mpsc::channel()` method to construct a new channel. We just `send`
+We use the `mpsc::channel()` method to construct a new channel. We `send`
a simple `()` down the channel, and then wait for ten of them to come back.
-While this channel is just sending a generic signal, we can send any data that
+While this channel is sending a generic signal, we can send any data that
is `Send` over the channel!
```rust
}
```
-Of course, you can copy and paste this from this web page, or just type
+Of course, you can copy and paste this from this web page, or type
something else. It’s not important that you actually put ‘konnichiwa’ to learn
about the module system.
Rust allows you to precisely control which aspects of your interface are
public, and so private is the default. To make things public, you use the `pub`
keyword. Let’s focus on the `english` module first, so let’s reduce our `src/main.rs`
-to just this:
+to only this:
```rust,ignore
extern crate phrases;
## Re-exporting with `pub use`
-You don’t just use `use` to shorten identifiers. You can also use it inside of your crate
+You don’t only use `use` to shorten identifiers. You can also use it inside of your crate
to re-export a function inside another module. This allows you to present an external
interface that may not directly map to your internal code organization.
```
As you can see, the curly brackets compress `use` statements for several items
-under the same path, and in this context `self` just refers back to that path.
+under the same path, and in this context `self` refers back to that path.
Note: The curly brackets cannot be nested or mixed with star globbing.
The compiler currently ships two default allocators: `alloc_system` and
`alloc_jemalloc` (some targets don't have jemalloc, however). These allocators
-are just normal Rust crates and contain an implementation of the routines to
+are normal Rust crates and contain an implementation of the routines to
allocate and deallocate memory. The standard library is not compiled assuming
either one, and the compiler will decide which allocator is in use at
compile-time depending on the type of output artifact being produced.
size
}
-# // just needed to get rustdoc to test this
+# // only needed to get rustdoc to test this
# fn main() {}
# #[lang = "panic_fmt"] fn panic_fmt() {}
# #[lang = "eh_personality"] fn eh_personality() {}
```
This will highlight according to whatever language you're showing off.
-If you're just showing plain text, choose `text`.
+If you're only showing plain text, choose `text`.
It's important to choose the correct annotation here, because `rustdoc` uses it
in an interesting way: It can be used to actually test your examples in a
can use this to your advantage. In this case, documentation comments need
to apply to some kind of function, so if I want to show you just a
documentation comment, I need to add a little function definition below
-it. At the same time, it's just there to satisfy the compiler, so hiding
+it. At the same time, it's only there to satisfy the compiler, so hiding
it makes the example more clear. You can use this technique to explain
longer examples in detail, while still preserving the testability of your
documentation.
# fn foo() {}
```
-is just
+is:
~~~markdown
# Examples
So you’ve learned how to write some Rust code. But there’s a difference between
writing *any* Rust code and writing *good* Rust code.
-This section consists of relatively independent tutorials which show you how to
+This chapter consists of relatively independent tutorials which show you how to
take your Rust to the next level. Common patterns and standard library features
will be introduced. Read these sections in any order of your choosing.
equality yet, but we’ll find out in the [`traits`][traits] section.
[match]: match.html
-[if-let]: if-let.html
[traits]: traits.html
# Constructors as functions
two broad categories: exceptions and return values. Rust opts for return
values.
-In this chapter, we intend to provide a comprehensive treatment of how to deal
+In this section, we intend to provide a comprehensive treatment of how to deal
with errors in Rust. More than that, we will attempt to introduce error handling
one piece at a time so that you'll come away with a solid working knowledge of
how everything fits together.
When done naïvely, error handling in Rust can be verbose and annoying. This
-chapter will explore those stumbling blocks and demonstrate how to use the
+section will explore those stumbling blocks and demonstrate how to use the
standard library to make error handling concise and ergonomic.
# Table of Contents
-This chapter is very long, mostly because we start at the very beginning with
+This section is very long, mostly because we start at the very beginning with
sum types and combinators, and try to motivate the way Rust does error handling
incrementally. As such, programmers with experience in other expressive type
systems may want to jump around.
panic is embedded in the calls to `unwrap`.
To “unwrap” something in Rust is to say, “Give me the result of the
-computation, and if there was an error, just panic and stop the program.”
-It would be better if we just showed the code for unwrapping because it is so
+computation, and if there was an error, panic and stop the program.”
+It would be better if we showed the code for unwrapping because it is so
simple, but to do that, we will first need to explore the `Option` and `Result`
types. Both of these types have a method called `unwrap` defined on them.
}
```
-Notice that when this function finds a matching character, it doesn't just
+Notice that when this function finds a matching character, it doesn't only
return the `offset`. Instead, it returns `Some(offset)`. `Some` is a variant or
a *value constructor* for the `Option` type. You can think of it as a function
with the type `fn<T>(value: T) -> Option<T>`. Correspondingly, `None` is also a
not all file names have a `.` in them, so it's possible that the file name has
no extension. This *possibility of absence* is encoded into the types using
`Option<T>`. In other words, the compiler will force us to address the
-possibility that an extension does not exist. In our case, we just print out a
+possibility that an extension does not exist. In our case, we only print out a
message saying as such.
Getting the extension of a file name is a pretty common operation, so it makes
In fact, the case analysis in `extension_explicit` follows a very common
pattern: *map* a function on to the value inside of an `Option<T>`, unless the
-option is `None`, in which case, just return `None`.
+option is `None`, in which case, return `None`.
Rust has parametric polymorphism, so it is very easy to define a combinator
that abstracts this pattern:
}
```
-You might think that we could just use the `map` combinator to reduce the case
+You might think that we could use the `map` combinator to reduce the case
analysis, but its type doesn't quite fit. Namely, `map` takes a function that
does something only with the inner value. The result of that function is then
*always* [rewrapped with `Some`](#code-option-map). Instead, we need something
`Option` and a `Result`? Or what if you have a `Result<T, Error1>` and a
`Result<T, Error2>`? Handling *composition of distinct error types* is the next
challenge in front of us, and it will be the major theme throughout the rest of
-this chapter.
+this section.
## Composing `Option` and `Result`
mix of `Option` and `Result` types. Must we resort to explicit case analysis,
or can we continue using combinators?
-For now, let's revisit one of the first examples in this chapter:
+For now, let's revisit one of the first examples in this section:
```rust,should_panic
use std::env;
with both an `Option` and a `Result`, the solution is *usually* to convert the
`Option` to a `Result`. In our case, the absence of a command line parameter
(from `env::args()`) means the user didn't invoke the program correctly. We
-could just use a `String` to describe the error. Let's try:
+could use a `String` to describe the error. Let's try:
<span id="code-error-double-string"></span>
The other new combinator used here is
[`Result::map_err`](../std/result/enum.Result.html#method.map_err).
-This is just like `Result::map`, except it maps a function on to the *error*
+This is like `Result::map`, except it maps a function on to the *error*
portion of a `Result` value. If the `Result` is an `Ok(...)` value, then it is
returned unmodified.
an `i32`) by `2`. If an error had occurred before that point, this operation
would have been skipped because of how `map` is defined.
-`map_err` is the trick that makes all of this work. `map_err` is just like
+`map_err` is the trick that makes all of this work. `map_err` is like
`map`, except it applies a function to the `Err(...)` value of a `Result`. In
this case, we want to convert all of our errors to one type: `String`. Since
both `io::Error` and `num::ParseIntError` implement `ToString`, we can call the
## The `try!` macro
A cornerstone of error handling in Rust is the `try!` macro. The `try!` macro
-abstracts case analysis just like combinators, but unlike combinators, it also
+abstracts case analysis like combinators, but unlike combinators, it also
abstracts *control flow*. Namely, it can abstract the *early return* pattern
seen above.
limitation remains: `Box<Error>` is opaque. (N.B. This isn't entirely
true because Rust does have runtime reflection, which is useful in
some scenarios that are [beyond the scope of this
-chapter](https://crates.io/crates/error).)
+section](https://crates.io/crates/error).)
It's time to revisit our custom `CliError` type and tie everything together.
[`ErrorKind`](../std/io/enum.ErrorKind.html)) or keep it hidden (like
[`ParseIntError`](../std/num/struct.ParseIntError.html)). Regardless
of how you do it, it's usually good practice to at least provide some
-information about the error beyond just its `String`
+information about the error beyond its `String`
representation. But certainly, this will vary depending on use cases.
At a minimum, you should probably implement the
# Case study: A program to read population data
-This chapter was long, and depending on your background, it might be
+This section was long, and depending on your background, it might be
rather dense. While there is plenty of example code to go along with
the prose, most of it was specifically designed to be pedagogical. So,
we're going to do something new: a case study.
The data we'll be using comes from the [Data Science
Toolkit][11]. I've prepared some data from it for this exercise. You
can either grab the [world population data][12] (41MB gzip compressed,
-145MB uncompressed) or just the [US population data][13] (2.2MB gzip
+145MB uncompressed) or only the [US population data][13] (2.2MB gzip
compressed, 7.2MB uncompressed).
Up until now, we've kept the code limited to Rust's standard library. For a real
We're not going to spend a lot of time on setting up a project with
Cargo because it is already covered well in [the Cargo
-chapter](../book/hello-cargo.html) and [Cargo's documentation][14].
+section](../book/hello-cargo.html) and [Cargo's documentation][14].
To get started from scratch, run `cargo new --bin city-pop` and make sure your
`Cargo.toml` looks something like this:
[Previously](#the-limits-of-combinators) we started refactoring our code by
changing the type of our function from `T` to `Result<T, OurErrorType>`. In
-this case, `OurErrorType` is just `Box<Error>`. But what's `T`? And can we add
+this case, `OurErrorType` is only `Box<Error>`. But what's `T`? And can we add
a return type to `main`?
The answer to the second question is no, we can't. That means we'll need to
But how can we use the same code over both types? There's actually a
couple ways we could go about this. One way is to write `search` such
that it is generic on some type parameter `R` that satisfies
-`io::Read`. Another way is to just use trait objects:
+`io::Read`. Another way is to use trait objects:
```rust,ignore
fn search<P: AsRef<Path>>
...
```
-Now we just need to implement our “quiet” functionality. This requires us to
+Now we only need to implement our “quiet” functionality. This requires us to
tweak the case analysis in `main`:
```rust,ignore
# The Short Story
-Since this chapter is long, it is useful to have a quick summary for error
+Since this section is long, it is useful to have a quick summary for error
handling in Rust. These are some good “rules of thumb." They are emphatically
*not* commandments. There are probably good reasons to break every one of these
heuristics!
* If you're writing short example code that would be overburdened by error
- handling, it's probably just fine to use `unwrap` (whether that's
+ handling, it's probably fine to use `unwrap` (whether that's
[`Result::unwrap`](../std/result/enum.Result.html#method.unwrap),
[`Option::unwrap`](../std/option/enum.Option.html#method.unwrap)
or preferably
A few examples of how this model can be used are:
* A native build dependency. Sometimes some C/C++ glue is needed when writing
- some Rust code, but distribution of the C/C++ code in a library format is just
+ some Rust code, but distribution of the C/C++ code in a library format is
a burden. In this case, the code will be archived into `libfoo.a` and then the
Rust crate would declare a dependency via `#[link(name = "foo", kind =
"static")]`.
architecture, this means that the abi used would be `stdcall`. On x86_64,
however, windows uses the `C` calling convention, so `C` would be used. This
means that in our previous example, we could have used `extern "system" { ... }`
-to define a block for all windows systems, not just x86 ones.
+to define a block for all windows systems, not only x86 ones.
# Interoperability with foreign code
Rust: ‘declaration statements’ and ‘expression statements’. Everything else is
an expression. Let’s talk about declaration statements first.
-In some languages, variable bindings can be written as expressions, not just
+In some languages, variable bindings can be written as expressions, not
statements. Like Ruby:
```ruby
expression, although its value is not particularly useful. Unlike other
languages where an assignment evaluates to the assigned value (e.g. `5` in the
previous example), in Rust the value of an assignment is an empty tuple `()`
-because the assigned value can have [just one owner](ownership.html), and any
+because the assigned value can have [only one owner](ownership.html), and any
other returned value would be too surprising:
```rust
// found `core::option::Option<_>` (expected f64 but found integral variable)
```
-That doesn’t mean we can’t make `Option<T>`s that hold an `f64`! They just have
+That doesn’t mean we can’t make `Option<T>`s that hold an `f64`! They have
to match up:
```rust
Similar to functions, the `<T>` is where we declare the generic parameters,
and we then use `x: T` in the type declaration, too.
-When you want to add an implementation for the generic `struct`, you just
+When you want to add an implementation for the generic `struct`, you
declare the type parameter after the `impl`:
```rust
% Getting Started
-This first section of the book will get us going with Rust and its tooling.
+This first chapter of the book will get us going with Rust and its tooling.
First, we’ll install Rust. Then, the classic ‘Hello World’ program. Finally,
we’ll talk about Cargo, Rust’s build system and package manager.
# Installing Rust
The first step to using Rust is to install it. Generally speaking, you’ll need
-an Internet connection to run the commands in this chapter, as we’ll be
+an Internet connection to run the commands in this section, as we’ll be
downloading Rust from the internet.
We’ll be showing off a number of commands using a terminal, and those lines all
## Uninstalling
-Uninstalling Rust is as easy as installing it. On Linux or Mac, just run
+Uninstalling Rust is as easy as installing it. On Linux or Mac, run
the uninstall script:
```bash
The nice thing about starting with such a simple program is that you can
quickly verify that your compiler is installed, and that it's working properly.
-Printing information to the screen is also just a pretty common thing to do, so
+Printing information to the screen is also a pretty common thing to do, so
practicing it early on is good.
> Note: This book assumes basic familiarity with the command line. Rust itself
Hello, world!
```
-In Windows, just replace `main` with `main.exe`. Regardless of your operating
+In Windows, replace `main` with `main.exe`. Regardless of your operating
system, you should see the string `Hello, world!` print to the terminal. If you
did, then congratulations! You've officially written a Rust program. That makes
you a Rust programmer! Welcome.
The second important part is the `println!()` line. This is calling a Rust
*[macro]*, which is how metaprogramming is done in Rust. If it were calling a
function instead, it would look like this: `println()` (without the !). We'll
-discuss Rust macros in more detail later, but for now you just need to
+discuss Rust macros in more detail later, but for now you only need to
know that when you see a `!` that means that you’re calling a macro instead of
a normal function.
The first line, `[package]`, indicates that the following statements are
configuring a package. As we add more information to this file, we’ll add other
-sections, but for now, we just have the package configuration.
+sections, but for now, we only have the package configuration.
The other three lines set the three bits of configuration that Cargo needs to
know to compile your program: its name, what version it is, and who wrote it.
With simple projects, Cargo doesn't bring a whole lot over just using `rustc`,
but it will become useful in future. With complex projects composed of multiple
crates, it’s much easier to let Cargo coordinate the build. With Cargo, you can
-just run `cargo build`, and it should work the right way.
+run `cargo build`, and it should work the right way.
## Building for Release
too low or too high. Once we guess correctly, it will congratulate us. Sounds
good?
-Along the way, we’ll learn a little bit about Rust. The next section, ‘Syntax
+Along the way, we’ll learn a little bit about Rust. The next chapter, ‘Syntax
and Semantics’, will dive deeper into each part.
# Set up
```
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
+project. Our game is such a project, we need to quickly test each
iteration before moving on to the next one.
# Processing a Guess
Rust warns us that we haven’t used the `Result` value. This warning comes from
a special annotation that `io::Result` has. Rust is trying to tell you that
you haven’t handled a possible error. The right way to suppress the error is
-to actually write error handling. Luckily, if we just want to crash if there’s
+to actually write error handling. Luckily, if we want to crash if there’s
a problem, we can use these two little methods. If we can recover from the
error somehow, we’d do something else, but we’ll save that for a future
project.
-There’s just one line of this first example left:
+There’s only one line of this first example left:
```rust,ignore
println!("You guessed: {}", guess);
That’s right, no output! Cargo knows that our project has been built, and that
all of its dependencies are built, and so there’s no reason to do all that
stuff. With nothing to do, it simply exits. If we open up `src/main.rs` again,
-make a trivial change, and then save it again, we’ll just see one line:
+make a trivial change, and then save it again, we’ll only see one line:
```bash
$ cargo build
[concurrency]: concurrency.html
-The second line just prints out the secret number. This is useful while
+The second line prints out the secret number. This is useful while
we’re developing our program, so we can easily test it out. But we’ll be
deleting it for the final version. It’s not much of a game if it prints out
the answer when you start it up!
the beginning and end of our string. This is important, as we had to press the
‘return’ key to satisfy `read_line()`. This means that if we type `5` and hit
return, `guess` looks like this: `5\n`. The `\n` represents ‘newline’, the
-enter key. `trim()` gets rid of this, leaving our string with just the `5`. The
+enter key. `trim()` gets rid of this, leaving our string with only the `5`. The
[`parse()` method on strings][parse] parses a string into some kind of number.
Since it can parse a variety of numbers, we need to give Rust a hint as to the
exact type of number we want. Hence, `let guess: u32`. The colon (`:`) after
By adding the `break` line after the `You win!`, we’ll exit the loop when we
win. Exiting the loop also means exiting the program, since it’s the last
-thing in `main()`. 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. We can do that
+thing in `main()`. We have only one more tweak to make: when someone inputs a
+non-number, we don’t want to quit, we want to ignore it. We can do that
like this:
```rust,ignore
```
This is how you generally move from ‘crash on error’ to ‘actually handle the
-returned by `parse()` is an `enum` just like `Ordering`, but in this case, each
+returned by `parse()` is an `enum` like `Ordering`, but in this case, each
variant has some data associated with it: `Ok` is a success, and `Err` is a
failure. Each contains more information: the successfully parsed integer, or an
error type. In this case, we `match` on `Ok(num)`, which sets the inner value
-of the `Ok` to the name `num`, and then we just return it on the right-hand
-side. In the `Err` case, we don’t care what kind of error it is, so we just
+of the `Ok` to the name `num`, and then we return it on the right-hand
+side. In the `Err` case, we don’t care what kind of error it is, so we
use `_` instead of a name. This ignores the error, and `continue` causes us
to go to the next iteration of the `loop`.
`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.
+loop is 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
references? Firstly, because we explicitly asked it to with
`&`. Secondly, 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 move.
+copy. With references, we're only borrowing a reference to the data,
+and so it's only passing a reference, without needing to do the move.
So, now that we've established that ranges are often not what you want, let's
talk about what you do want instead.
```
If you are trying to execute a closure on an iterator for its side effects,
-just use `for` instead.
+use `for` instead.
There are tons of interesting iterator adaptors. `take(n)` will return an
iterator over the next `n` elements of the original iterator. Let's try it out
% Learn Rust
-Welcome! This section has a few tutorials that teach you Rust through building
+Welcome! This chapter has a few tutorials that teach you Rust through building
projects. You’ll get a high-level overview, but we’ll skim over the details.
If you’d prefer a more ‘from the ground up’-style experience, check
discuss the `<>`s after a function’s name. A function can have ‘generic
parameters’ between the `<>`s, of which lifetimes are one kind. We’ll discuss
other kinds of generics [later in the book][generics], but for now, let’s
-just focus on the lifetimes aspect.
+focus on the lifetimes aspect.
[functions]: functions.html
[generics]: generics.html
...(x: &'a mut i32)
```
-If you compare `&mut i32` to `&'a mut i32`, they’re the same, it’s just that
+If you compare `&mut i32` to `&'a mut i32`, they’re the same, it’s that
the lifetime `'a` has snuck in between the `&` and the `mut i32`. We read `&mut
i32` as ‘a mutable reference to an `i32`’ and `&'a mut i32` as ‘a mutable
reference to an `i32` with the lifetime `'a`’.
```
As you can see, we need to declare a lifetime for `Foo` in the `impl` line. We repeat
-`'a` twice, just like on functions: `impl<'a>` defines a lifetime `'a`, and `Foo<'a>`
+`'a` twice, like on functions: `impl<'a>` defines a lifetime `'a`, and `Foo<'a>`
uses it.
## Multiple lifetimes
Methods take a special first parameter, of which there are three variants:
`self`, `&self`, and `&mut self`. You can think of this first parameter as
being the `foo` in `foo.bar()`. The three variants correspond to the three
-kinds of things `foo` could be: `self` if it’s just a value on the stack,
+kinds of things `foo` could be: `self` if it’s a value on the stack,
`&self` if it’s a reference, and `&mut self` if it’s a mutable reference.
-Because we took the `&self` parameter to `area`, we can use it just like any
+Because we took the `&self` parameter to `area`, we can use it like any
other parameter. Because we know it’s a `Circle`, we can access the `radius`
-just like we would with any other `struct`.
+like we would with any other `struct`.
We should default to using `&self`, as you should prefer borrowing over taking
ownership, as well as taking immutable references over mutable ones. Here’s an
# Circle } }
```
-We just say we’re returning a `Circle`. With this method, we can grow a new
+We say we’re returning a `Circle`. With this method, we can grow a new
`Circle` to any arbitrary size.
# Associated functions
$ sudo /usr/local/lib/rustlib/uninstall.sh
```
-If you used the Windows installer, just re-run the `.msi` and it will give you
+If you used the Windows installer, re-run the `.msi` and it will give you
an uninstall option.
Some people, and somewhat rightfully so, get very upset when we tell you to
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.
+commit is tested against Windows like any other platform.
If you've got Rust installed, you can open up a shell, and type this:
The core library has very few dependencies and is much more portable than the
standard library itself. Additionally, the core library has most of the
necessary functionality for writing idiomatic and effective Rust code. When
-using `#![no_std]`, Rust will automatically inject the `core` crate, just like
+using `#![no_std]`, Rust will automatically inject the `core` crate, like
we do for `std` when we’re using it.
As an example, here is a program that will calculate the dot product of two
}
```
-For `HasArea` and `Square`, we just declare a type parameter `T` and replace
+For `HasArea` and `Square`, we declare a type parameter `T` and replace
`f64` with it. The `impl` needs more involved modifications:
```ignore
}
```
-When `v` comes into scope, a new [`Vec<T>`][vect] is created. In this case, the
-vector also allocates space on [the heap][heap], for the three elements. When
-`v` goes out of scope at the end of `foo()`, Rust will clean up everything
-related to the vector, even the heap-allocated memory. This happens
-deterministically, at the end of the scope.
+When `v` comes into scope, a new [vector] is created, and it allocates space on
+[the heap][heap] for each of its elements. When `v` goes out of scope at the
+end of `foo()`, Rust will clean up everything related to the vector, even the
+heap-allocated memory. This happens deterministically, at the end of the scope.
-[vect]: ../std/vec/struct.Vec.html
+We'll cover [vectors] in detail later in this chapter; we only use them
+here as an example of a type that allocates space on the heap at runtime. They
+behave like [arrays], except their size may change by `push()`ing more
+elements onto them.
+
+Vectors have a [generic type][generics] `Vec<T>`, so in this example `v` will have type
+`Vec<i32>`. We'll cover generics in detail later in this chapter.
+
+[arrays]: primitive-types.html#arrays
+[vectors]: vectors.html
[heap]: the-stack-and-the-heap.html
[bindings]: variable-bindings.html
+[generics]: generics.html
# Move semantics
This prints `x is 0`.
-You can do this kind of match on any member, not just the first:
+You can do this kind of match on any member, not only the first:
```rust
struct Point {
```
In the first arm, we bind the value inside the `Ok` variant to `value`. But
-in the `Err` arm, we use `_` to disregard the specific error, and just print
+in the `Err` arm, we use `_` to disregard the specific error, and print
a general error message.
`_` is valid in any pattern that creates a binding. This can be useful to
```
This prints `no`, because the `if` applies to the whole of `4 | 5`, and not to
-just the `5`. In other words, the precedence of `if` behaves like this:
+only the `5`. In other words, the precedence of `if` behaves like this:
```text
(4 | 5) if y => ...
A ‘slice’ is a reference to (or “view” into) another data structure. 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
+copying. For example, you might want to reference only one line of a file read
into memory. By nature, a slice is not created directly, but from an existing
variable binding. Slices have a defined length, can be mutable or immutable.
## Slicing syntax
You can use a combo of `&` and `[]` to create a slice from various things. The
-`&` indicates that slices are similar to references, and the `[]`s, with a
-range, let you define the length of the slice:
+`&` indicates that slices are similar to [references], which we will cover in
+detail later in this section. The `[]`s, with a range, let you define the
+length of the slice:
+
+[references]: references-and-borrowing.html
```rust
let a = [0, 1, 2, 3, 4];
let complete = &a[..]; // A slice containing all of the elements in a
-let middle = &a[1..4]; // A slice of a: just the elements 1, 2, and 3
+let middle = &a[1..4]; // A slice of a: only the elements 1, 2, and 3
```
Slices have type `&[T]`. We’ll talk about that `T` when we cover
# `str`
Rust’s `str` type is the most primitive string type. As an [unsized type][dst],
-it’s not very useful by itself, but becomes useful when placed behind a reference,
-like [`&str`][strings]. As such, we’ll just leave it at that.
+it’s not very useful by itself, but becomes useful when placed behind a
+reference, like `&str`. We'll elaborate further when we cover
+[Strings][strings] and [references].
[dst]: unsized-types.html
[strings]: strings.html
+[references]: references-and-borrowing.html
You can find more documentation for `str` [in the standard library
documentation][str].
let x: (i32, &str) = (1, "hello");
```
-As you can see, the type of a tuple looks just like the tuple, but with each
+As you can see, the type of a tuple looks 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.
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
+languages. For now, read `&str` as a *string slice*, and we’ll learn more
soon.
You can assign one tuple into another, if they have the same contained types
```
Remember [before][let] 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
+powerful than 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.
resource when it goes out of scope. This means that after the call to `foo()`,
we can use our original bindings again.
-References are immutable, just like bindings. This means that inside of `foo()`,
+References are immutable, like bindings. This means that inside of `foo()`,
the vectors can’t be changed at all:
```rust,ignore
this is because `y` is a `&mut` reference. You'll also need to use them for
accessing the contents of a reference as well.
-Otherwise, `&mut` references are just like references. There _is_ a large
+Otherwise, `&mut` references are like references. There _is_ a large
difference between the two, and how they interact, though. You can tell
something is fishy in the above example, because we need that extra scope, with
the `{` and `}`. If we remove them, we get an error:
assert_eq!("foobar", s);
```
-Rust has more than just `&str`s though. A `String`, is a heap-allocated string.
+Rust has more than only `&str`s though. A `String`, is a heap-allocated string.
This string is growable, and is also guaranteed to be UTF-8. `String`s are
commonly created by converting from a string slice using the `to_string`
method.
```
As you can see here, you can extract the inner integer type through a
-destructuring `let`, just as with regular tuples. In this case, the
+destructuring `let`, as with regular tuples. In this case, the
`let Inches(integer_length)` assigns `10` to `integer_length`.
# Unit-like structs
marker type), but in combination with other features, it can become
useful. For instance, a library may ask you to create a structure that
implements a certain [trait][trait] to handle events. If you don’t have
-any data you need to store in the structure, you can just create a
+any data you need to store in the structure, you can create a
unit-like `struct`.
[trait]: traits.html
% Syntax and Semantics
-This section breaks Rust down into small chunks, one for each concept.
+This chapter breaks Rust down into small chunks, one for each concept.
If you’d like to learn Rust from the bottom up, reading this in order is a
great way to do that.
It works!
The current convention is to use the `tests` module to hold your "unit-style"
-tests. Anything that just tests one small bit of functionality makes sense to
+tests. Anything that tests one small bit of functionality makes sense to
go here. But what about "integration-style" tests instead? For that, we have
the `tests` directory.
Well, when a function gets called, some memory gets allocated for all of its
local variables and some other information. This is called a ‘stack frame’, and
for the purpose of this tutorial, we’re going to ignore the extra information
-and just consider the local variables we’re allocating. So in this case, when
+and only consider the local variables we’re allocating. So in this case, when
`main()` is run, we’ll allocate a single 32-bit integer for our stack frame.
This is automatically handled for you, as you can see; we didn’t have to write
any special Rust code or anything.
| 0 | x | 42 |
Whew! Our stack is growing tall.
-After `italic()` is over, its frame is deallocated, leaving just `bold()` and
+After `italic()` is over, its frame is deallocated, leaving only `bold()` and
`main()`:
| Address | Name | Value |
| **1** | **a**| **5** |
| 0 | x | 42 |
-And then `bold()` ends, leaving just `main()`:
+And then `bold()` ends, leaving only `main()`:
| Address | Name | Value |
|---------|------|-------|
We haven’t really talked too much about what it actually means to allocate and
deallocate memory in these contexts. Getting into very deep detail is out of
the scope of this tutorial, but what’s important to point out here is that
-the heap isn’t just a stack that grows from the opposite end. We’ll have an
+the heap isn’t a stack that grows from the opposite end. We’ll have an
example of this later in the book, but because the heap can be allocated and
freed in any order, it can end up with ‘holes’. Here’s a diagram of the memory
layout of a program which has been running for a while now:
| 1 | y | → 0 |
| 0 | x | 5 |
-Stack frames aren’t just for local bindings, they’re for arguments too. So in
+Stack frames aren’t only for local bindings, they’re for arguments too. So in
this case, we need to have both `i`, our argument, and `z`, our local variable
binding. `i` is a copy of the argument, `y`. Since `y`’s value is `0`, so is
`i`’s.
This is one reason why borrowing a variable doesn’t deallocate any memory: the
-value of a reference is just a pointer to a memory location. If we got rid of
+value of a reference is a pointer to a memory location. If we got rid of
the underlying memory, things wouldn’t work very well.
# A complex example
| 0 | h | 3 |
We end up allocating another value on the heap, and so we have to subtract one
-from (2<sup>30</sup>) - 1. It’s easier to just write that than `1,073,741,822`. In any
+from (2<sup>30</sup>) - 1. It’s easier to write that than `1,073,741,822`. In any
case, we set up the variables as usual.
At the end of `bar()`, it calls `baz()`:
## Runtime Efficiency
-Managing the memory for the stack is trivial: The machine just
+Managing the memory for the stack is trivial: The machine
increments or decrements a single value, the so-called “stack pointer”.
Managing memory for the heap is non-trivial: heap-allocated memory is freed at
arbitrary points, and each block of heap-allocated memory can be of arbitrary
Suppose we’ve got some values that implement `Foo`. The explicit form of
construction and use of `Foo` trait objects might look a bit like (ignoring the
-type mismatches: they’re all just pointers anyway):
+type mismatches: they’re all pointers anyway):
```rust,ignore
let a: String = "foo".to_string();
```
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`.
+but we don’t define a body, only a type signature. When we `impl` a trait,
+we use `impl Trait for Item`, rather than only `impl Item`.
## Trait bounds on generic functions
That’s it. It’s important that `unsafe` does not, for example, ‘turn off the
borrow checker’. Adding `unsafe` to some random Rust code doesn’t change its
-semantics, it won’t just start accepting anything. But it will let you write
+semantics, it won’t start accepting anything. But it will let you write
things that _do_ break some of the rules.
You will also encounter the `unsafe` keyword when writing bindings to foreign
are three:
1. We can only manipulate an instance of an unsized type via a pointer. An
- `&[T]` works just fine, but a `[T]` does not.
+ `&[T]` works fine, but a `[T]` does not.
2. Variables and arguments cannot have dynamically sized types.
3. Only the last field in a `struct` may have a dynamically sized type; the
other fields must not. Enum variants must not have dynamically sized types as
Virtually every non-'Hello World’ Rust program uses *variable bindings*. They
bind some value to a name, so it can be used later. `let` is
-used to introduce a binding, just like this:
+used to introduce a binding, like this:
```rust
fn main() {
In many languages, a variable binding would be called a *variable*, but Rust’s
variable bindings have a few tricks up their sleeves. For example the
-left-hand side of a `let` expression is a ‘[pattern][pattern]’, not just a
+left-hand side of a `let` expression is a ‘[pattern][pattern]’, not a
variable name. This means we can do things like:
```rust
After this expression is evaluated, `x` will be one, and `y` will be two.
Patterns are really powerful, and have [their own section][pattern] in the
-book. We don’t need those features for now, so we’ll just keep this in the back
+book. We don’t need those features for now, so we’ll keep this in the back
of our minds as we go forward.
[pattern]: patterns.html
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
+When you 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][format].
-For now, we'll just stick to the default: integers aren't very complicated to
+For now, we'll stick to the default: integers aren't very complicated to
print.
[format]: ../std/fmt/index.html
// ptr::copy(src, dest, len): "copy from source to dest len elems"
ptr::copy(self.ptr.offset(index as isize),
self.ptr.offset(index as isize + 1),
- len - index);
+ self.len - index);
}
ptr::write(self.ptr.offset(index as isize), elem);
self.len += 1;
let result = ptr::read(self.ptr.offset(index as isize));
ptr::copy(self.ptr.offset(index as isize + 1),
self.ptr.offset(index as isize),
- len - index);
+ self.len - index);
result
}
}
}
}
+ /// Attempts to double the size of the type's backing allocation in place. This is common
+ /// enough to want to do that it's easiest to just have a dedicated method. Slightly
+ /// more efficient logic can be provided for this than the general case.
+ ///
+ /// Returns true if the reallocation attempt has succeeded, or false otherwise.
+ ///
+ /// # Panics
+ ///
+ /// * Panics if T is zero-sized on the assumption that you managed to exhaust
+ /// all `usize::MAX` slots in your imaginary buffer.
+ /// * Panics on 32-bit platforms if the requested capacity exceeds
+ /// `isize::MAX` bytes.
+ #[inline(never)]
+ #[cold]
+ pub fn double_in_place(&mut self) -> bool {
+ unsafe {
+ let elem_size = mem::size_of::<T>();
+ let align = mem::align_of::<T>();
+
+ // since we set the capacity to usize::MAX when elem_size is
+ // 0, getting to here necessarily means the RawVec is overfull.
+ assert!(elem_size != 0, "capacity overflow");
+
+ // Since we guarantee that we never allocate more than isize::MAX bytes,
+ // `elem_size * self.cap <= isize::MAX` as a precondition, so this can't overflow
+ let new_cap = 2 * self.cap;
+ let new_alloc_size = new_cap * elem_size;
+
+ alloc_guard(new_alloc_size);
+ let size = heap::reallocate_inplace(self.ptr() as *mut _,
+ self.cap * elem_size,
+ new_alloc_size,
+ align);
+ if size >= new_alloc_size {
+ // We can't directly divide `size`.
+ self.cap = new_cap;
+ }
+ size >= new_alloc_size
+ }
+ }
+
/// Ensures that the buffer contains at least enough space to hold
/// `used_cap + needed_extra_cap` elements. If it doesn't already,
/// will reallocate the minimum possible amount of memory necessary.
}
}
+ /// Calculates the buffer's new size given that it'll hold `used_cap +
+ /// needed_extra_cap` elements. This logic is used in amortized reserve methods.
+ /// Returns `(new_capacity, new_alloc_size)`.
+ fn amortized_new_size(&self, used_cap: usize, needed_extra_cap: usize) -> (usize, usize) {
+ let elem_size = mem::size_of::<T>();
+ // Nothing we can really do about these checks :(
+ let required_cap = used_cap.checked_add(needed_extra_cap)
+ .expect("capacity overflow");
+ // Cannot overflow, because `cap <= isize::MAX`, and type of `cap` is `usize`.
+ let double_cap = self.cap * 2;
+ // `double_cap` guarantees exponential growth.
+ let new_cap = cmp::max(double_cap, required_cap);
+ let new_alloc_size = new_cap.checked_mul(elem_size).expect("capacity overflow");
+ (new_cap, new_alloc_size)
+ }
+
/// Ensures that the buffer contains at least enough space to hold
/// `used_cap + needed_extra_cap` elements. If it doesn't already have
/// enough capacity, will reallocate enough space plus comfortable slack
return;
}
- // Nothing we can really do about these checks :(
- let required_cap = used_cap.checked_add(needed_extra_cap)
- .expect("capacity overflow");
-
- // Cannot overflow, because `cap <= isize::MAX`, and type of `cap` is `usize`.
- let double_cap = self.cap * 2;
-
- // `double_cap` guarantees exponential growth.
- let new_cap = cmp::max(double_cap, required_cap);
-
- let new_alloc_size = new_cap.checked_mul(elem_size).expect("capacity overflow");
+ let (new_cap, new_alloc_size) = self.amortized_new_size(used_cap, needed_extra_cap);
// FIXME: may crash and burn on over-reserve
alloc_guard(new_alloc_size);
}
}
+ /// Attempts to ensure that the buffer contains at least enough space to hold
+ /// `used_cap + needed_extra_cap` elements. If it doesn't already have
+ /// enough capacity, will reallocate in place enough space plus comfortable slack
+ /// space to get amortized `O(1)` behaviour. Will limit this behaviour
+ /// if it would needlessly cause itself to panic.
+ ///
+ /// If `used_cap` exceeds `self.cap()`, this may fail to actually allocate
+ /// the requested space. This is not really unsafe, but the unsafe
+ /// code *you* write that relies on the behaviour of this function may break.
+ ///
+ /// Returns true if the reallocation attempt has succeeded, or false otherwise.
+ ///
+ /// # Panics
+ ///
+ /// * Panics if the requested capacity exceeds `usize::MAX` bytes.
+ /// * Panics on 32-bit platforms if the requested capacity exceeds
+ /// `isize::MAX` bytes.
+ pub fn reserve_in_place(&mut self, used_cap: usize, needed_extra_cap: usize) -> bool {
+ unsafe {
+ let elem_size = mem::size_of::<T>();
+ let align = mem::align_of::<T>();
+
+ // NOTE: we don't early branch on ZSTs here because we want this
+ // to actually catch "asking for more than usize::MAX" in that case.
+ // If we make it past the first branch then we are guaranteed to
+ // panic.
+
+ // Don't actually need any more capacity. If the current `cap` is 0, we can't
+ // reallocate in place.
+ // Wrapping in case they give a bad `used_cap`
+ if self.cap().wrapping_sub(used_cap) >= needed_extra_cap || self.cap == 0 {
+ return false;
+ }
+
+ let (_, new_alloc_size) = self.amortized_new_size(used_cap, needed_extra_cap);
+ // FIXME: may crash and burn on over-reserve
+ alloc_guard(new_alloc_size);
+
+ let size = heap::reallocate_inplace(self.ptr() as *mut _,
+ self.cap * elem_size,
+ new_alloc_size,
+ align);
+ if size >= new_alloc_size {
+ self.cap = new_alloc_size / elem_size;
+ }
+ size >= new_alloc_size
+ }
+ }
+
/// Shrinks the allocation down to the specified amount. If the given amount
/// is 0, actually completely deallocates.
///
test(no_crate_inject, attr(deny(warnings))))]
#![feature(alloc)]
-#![feature(box_syntax)]
#![feature(core_intrinsics)]
+#![feature(drop_in_place)]
#![feature(heap_api)]
-#![feature(oom)]
-#![feature(ptr_as_ref)]
#![feature(raw)]
+#![feature(heap_api)]
#![feature(staged_api)]
#![feature(dropck_parametricity)]
#![cfg_attr(test, feature(test))]
+#![allow(deprecated)]
+
extern crate alloc;
use std::cell::{Cell, RefCell};
use std::cmp;
use std::intrinsics;
-use std::marker;
+use std::marker::{PhantomData, Send};
use std::mem;
use std::ptr;
-use std::rc::Rc;
+use std::slice;
-use alloc::heap::{allocate, deallocate};
+use alloc::heap;
+use alloc::raw_vec::RawVec;
-// The way arena uses arrays is really deeply awful. The arrays are
-// allocated, and have capacities reserved, but the fill for the array
-// will always stay at 0.
-#[derive(Clone, PartialEq)]
struct Chunk {
- data: Rc<RefCell<Vec<u8>>>,
+ data: RawVec<u8>,
+ /// Index of the first unused byte.
fill: Cell<usize>,
+ /// Indicates whether objects with destructors are stored in this chunk.
is_copy: Cell<bool>,
}
impl Chunk {
+ fn new(size: usize, is_copy: bool) -> Chunk {
+ Chunk {
+ data: RawVec::with_capacity(size),
+ fill: Cell::new(0),
+ is_copy: Cell::new(is_copy),
+ }
+ }
+
fn capacity(&self) -> usize {
- self.data.borrow().capacity()
+ self.data.cap()
}
unsafe fn as_ptr(&self) -> *const u8 {
- self.data.borrow().as_ptr()
+ self.data.ptr()
+ }
+
+ // Walk down a chunk, running the destructors for any objects stored
+ // in it.
+ unsafe fn destroy(&self) {
+ let mut idx = 0;
+ let buf = self.as_ptr();
+ let fill = self.fill.get();
+
+ while idx < fill {
+ let tydesc_data = buf.offset(idx as isize) as *const usize;
+ let (tydesc, is_done) = un_bitpack_tydesc_ptr(*tydesc_data);
+ let (size, align) = ((*tydesc).size, (*tydesc).align);
+
+ let after_tydesc = idx + mem::size_of::<*const TyDesc>();
+
+ let start = round_up(after_tydesc, align);
+
+ if is_done {
+ ((*tydesc).drop_glue)(buf.offset(start as isize) as *const i8);
+ }
+
+ // Find where the next tydesc lives
+ idx = round_up(start + size, mem::align_of::<*const TyDesc>());
+ }
}
}
/// A slower reflection-based arena that can allocate objects of any type.
///
-/// This arena uses `Vec<u8>` as a backing store to allocate objects from. For
-/// each allocated object, the arena stores a pointer to the type descriptor
+/// This arena uses `RawVec<u8>` as a backing store to allocate objects from.
+/// For each allocated object, the arena stores a pointer to the type descriptor
/// followed by the object (potentially with alignment padding after each
/// element). When the arena is destroyed, it iterates through all of its
/// chunks, and uses the tydesc information to trace through the objects,
/// than objects without destructors. This reduces overhead when initializing
/// plain-old-data (`Copy` types) and means we don't need to waste time running
/// their destructors.
+#[unstable(feature = "rustc_private",
+ reason = "Private to rustc", issue = "0")]
+#[rustc_deprecated(since = "1.6.0-dev", reason =
+"The reflection-based arena is superseded by the any-arena crate")]
pub struct Arena<'longer_than_self> {
- // The head is separated out from the list as a unbenchmarked
- // microoptimization, to avoid needing to case on the list to access the
- // head.
+ // The heads are separated out from the list as a unbenchmarked
+ // microoptimization, to avoid needing to case on the list to access a head.
head: RefCell<Chunk>,
copy_head: RefCell<Chunk>,
chunks: RefCell<Vec<Chunk>>,
- _marker: marker::PhantomData<*mut &'longer_than_self ()>,
+ _marker: PhantomData<*mut &'longer_than_self ()>,
}
impl<'a> Arena<'a> {
/// Allocates a new Arena with `initial_size` bytes preallocated.
pub fn new_with_size(initial_size: usize) -> Arena<'a> {
Arena {
- head: RefCell::new(chunk(initial_size, false)),
- copy_head: RefCell::new(chunk(initial_size, true)),
+ head: RefCell::new(Chunk::new(initial_size, false)),
+ copy_head: RefCell::new(Chunk::new(initial_size, true)),
chunks: RefCell::new(Vec::new()),
- _marker: marker::PhantomData,
+ _marker: PhantomData,
}
}
}
-fn chunk(size: usize, is_copy: bool) -> Chunk {
- Chunk {
- data: Rc::new(RefCell::new(Vec::with_capacity(size))),
- fill: Cell::new(0),
- is_copy: Cell::new(is_copy),
- }
-}
-
impl<'longer_than_self> Drop for Arena<'longer_than_self> {
fn drop(&mut self) {
unsafe {
- destroy_chunk(&*self.head.borrow());
+ self.head.borrow().destroy();
for chunk in self.chunks.borrow().iter() {
if !chunk.is_copy.get() {
- destroy_chunk(chunk);
+ chunk.destroy();
}
}
}
(base.checked_add(align - 1)).unwrap() & !(align - 1)
}
-// Walk down a chunk, running the destructors for any objects stored
-// in it.
-unsafe fn destroy_chunk(chunk: &Chunk) {
- let mut idx = 0;
- let buf = chunk.as_ptr();
- let fill = chunk.fill.get();
-
- while idx < fill {
- let tydesc_data = buf.offset(idx as isize) as *const usize;
- let (tydesc, is_done) = un_bitpack_tydesc_ptr(*tydesc_data);
- let (size, align) = ((*tydesc).size, (*tydesc).align);
-
- let after_tydesc = idx + mem::size_of::<*const TyDesc>();
-
- let start = round_up(after_tydesc, align);
-
- // debug!("freeing object: idx = {}, size = {}, align = {}, done = {}",
- // start, size, align, is_done);
- if is_done {
- ((*tydesc).drop_glue)(buf.offset(start as isize) as *const i8);
- }
-
- // Find where the next tydesc lives
- idx = round_up(start + size, mem::align_of::<*const TyDesc>());
- }
-}
-
// We encode whether the object a tydesc describes has been
// initialized in the arena in the low bit of the tydesc pointer. This
// is necessary in order to properly do cleanup if a panic occurs
// HACK(eddyb) TyDesc replacement using a trait object vtable.
// This could be replaced in the future with a custom DST layout,
// or `&'static (drop_glue, size, align)` created by a `const fn`.
+// Requirements:
+// * rvalue promotion (issue #1056)
+// * mem::{size_of, align_of} must be const fns
struct TyDesc {
drop_glue: fn(*const i8),
size: usize,
unsafe fn get_tydesc<T>() -> *const TyDesc {
use std::raw::TraitObject;
- let ptr = &*(1 as *const T);
+ let ptr = &*(heap::EMPTY as *const T);
// Can use any trait that is implemented for all types.
let obj = mem::transmute::<&AllTypes, TraitObject>(ptr);
}
impl<'longer_than_self> Arena<'longer_than_self> {
- fn chunk_size(&self) -> usize {
- self.copy_head.borrow().capacity()
+ // Grows a given chunk and returns `false`, or replaces it with a bigger
+ // chunk and returns `true`.
+ // This method is shared by both parts of the arena.
+ #[cold]
+ fn alloc_grow(&self, head: &mut Chunk, used_cap: usize, n_bytes: usize) -> bool {
+ if head.data.reserve_in_place(used_cap, n_bytes) {
+ // In-place reallocation succeeded.
+ false
+ } else {
+ // Allocate a new chunk.
+ let new_min_chunk_size = cmp::max(n_bytes, head.capacity());
+ let new_chunk = Chunk::new((new_min_chunk_size + 1).next_power_of_two(), false);
+ let old_chunk = mem::replace(head, new_chunk);
+ if old_chunk.fill.get() != 0 {
+ self.chunks.borrow_mut().push(old_chunk);
+ }
+ true
+ }
}
- // Functions for the POD part of the arena
- fn alloc_copy_grow(&self, n_bytes: usize, align: usize) -> *const u8 {
- // Allocate a new chunk.
- let new_min_chunk_size = cmp::max(n_bytes, self.chunk_size());
- self.chunks.borrow_mut().push(self.copy_head.borrow().clone());
-
- *self.copy_head.borrow_mut() = chunk((new_min_chunk_size + 1).next_power_of_two(), true);
-
- self.alloc_copy_inner(n_bytes, align)
- }
+ // Functions for the copyable part of the arena.
#[inline]
fn alloc_copy_inner(&self, n_bytes: usize, align: usize) -> *const u8 {
- let start = round_up(self.copy_head.borrow().fill.get(), align);
-
- let end = start + n_bytes;
- if end > self.chunk_size() {
- return self.alloc_copy_grow(n_bytes, align);
+ let mut copy_head = self.copy_head.borrow_mut();
+ let fill = copy_head.fill.get();
+ let mut start = round_up(fill, align);
+ let mut end = start + n_bytes;
+
+ if end > copy_head.capacity() {
+ if self.alloc_grow(&mut *copy_head, fill, end - fill) {
+ // Continuing with a newly allocated chunk
+ start = 0;
+ end = n_bytes;
+ copy_head.is_copy.set(true);
+ }
}
- let copy_head = self.copy_head.borrow();
copy_head.fill.set(end);
unsafe { copy_head.as_ptr().offset(start as isize) }
}
}
- // Functions for the non-POD part of the arena
- fn alloc_noncopy_grow(&self, n_bytes: usize, align: usize) -> (*const u8, *const u8) {
- // Allocate a new chunk.
- let new_min_chunk_size = cmp::max(n_bytes, self.chunk_size());
- self.chunks.borrow_mut().push(self.head.borrow().clone());
-
- *self.head.borrow_mut() = chunk((new_min_chunk_size + 1).next_power_of_two(), false);
-
- self.alloc_noncopy_inner(n_bytes, align)
- }
+ // Functions for the non-copyable part of the arena.
#[inline]
fn alloc_noncopy_inner(&self, n_bytes: usize, align: usize) -> (*const u8, *const u8) {
- // Be careful to not maintain any `head` borrows active, because
- // `alloc_noncopy_grow` borrows it mutably.
- let (start, end, tydesc_start, head_capacity) = {
- let head = self.head.borrow();
- let fill = head.fill.get();
-
- let tydesc_start = fill;
- let after_tydesc = fill + mem::size_of::<*const TyDesc>();
- let start = round_up(after_tydesc, align);
- let end = start + n_bytes;
-
- (start, end, tydesc_start, head.capacity())
- };
-
- if end > head_capacity {
- return self.alloc_noncopy_grow(n_bytes, align);
+ let mut head = self.head.borrow_mut();
+ let fill = head.fill.get();
+
+ let mut tydesc_start = fill;
+ let after_tydesc = fill + mem::size_of::<*const TyDesc>();
+ let mut start = round_up(after_tydesc, align);
+ let mut end = round_up(start + n_bytes, mem::align_of::<*const TyDesc>());
+
+ if end > head.capacity() {
+ if self.alloc_grow(&mut *head, tydesc_start, end - tydesc_start) {
+ // Continuing with a newly allocated chunk
+ tydesc_start = 0;
+ start = round_up(mem::size_of::<*const TyDesc>(), align);
+ end = round_up(start + n_bytes, mem::align_of::<*const TyDesc>());
+ }
}
- let head = self.head.borrow();
- head.fill.set(round_up(end, mem::align_of::<*const TyDesc>()));
+ head.fill.set(end);
unsafe {
let buf = head.as_ptr();
}
}
}
-}
-#[test]
-fn test_arena_destructors() {
- let arena = Arena::new();
- for i in 0..10 {
- // Arena allocate something with drop glue to make sure it
- // doesn't leak.
- arena.alloc(|| Rc::new(i));
- // Allocate something with funny size and alignment, to keep
- // things interesting.
- arena.alloc(|| [0u8, 1u8, 2u8]);
+ /// Allocates a slice of bytes of requested length. The bytes are not guaranteed to be zero
+ /// if the arena has previously been cleared.
+ ///
+ /// # Panics
+ ///
+ /// Panics if the requested length is too large and causes overflow.
+ pub fn alloc_bytes(&self, len: usize) -> &mut [u8] {
+ unsafe {
+ // Check for overflow.
+ self.copy_head.borrow().fill.get().checked_add(len).expect("length overflow");
+ let ptr = self.alloc_copy_inner(len, 1);
+ intrinsics::assume(!ptr.is_null());
+ slice::from_raw_parts_mut(ptr as *mut _, len)
+ }
}
-}
-#[test]
-#[should_panic]
-fn test_arena_destructors_fail() {
- let arena = Arena::new();
- // Put some stuff in the arena.
- for i in 0..10 {
- // Arena allocate something with drop glue to make sure it
- // doesn't leak.
- arena.alloc(|| Rc::new(i));
- // Allocate something with funny size and alignment, to keep
- // things interesting.
- arena.alloc(|| [0u8, 1, 2]);
- }
- // Now, panic while allocating
- arena.alloc::<Rc<i32>, _>(|| {
- panic!();
- });
+ /// Clears the arena. Deallocates all but the longest chunk which may be reused.
+ pub fn clear(&mut self) {
+ unsafe {
+ self.head.borrow().destroy();
+ self.head.borrow().fill.set(0);
+ self.copy_head.borrow().fill.set(0);
+ for chunk in self.chunks.borrow().iter() {
+ if !chunk.is_copy.get() {
+ chunk.destroy();
+ }
+ }
+ self.chunks.borrow_mut().clear();
+ }
+ }
}
/// A faster arena that can hold objects of only one type.
pub struct TypedArena<T> {
/// A pointer to the next object to be allocated.
- ptr: Cell<*const T>,
+ ptr: Cell<*mut T>,
/// A pointer to the end of the allocated area. When this pointer is
/// reached, a new chunk is allocated.
- end: Cell<*const T>,
+ end: Cell<*mut T>,
- /// A pointer to the first arena segment.
- first: RefCell<*mut TypedArenaChunk<T>>,
+ /// A vector arena segments.
+ chunks: RefCell<Vec<TypedArenaChunk<T>>>,
/// Marker indicating that dropping the arena causes its owned
/// instances of `T` to be dropped.
- _own: marker::PhantomData<T>,
+ _own: PhantomData<T>,
}
struct TypedArenaChunk<T> {
- marker: marker::PhantomData<T>,
-
/// Pointer to the next arena segment.
- next: *mut TypedArenaChunk<T>,
-
- /// The number of elements that this chunk can hold.
- capacity: usize,
-
- // Objects follow here, suitably aligned.
-}
-
-fn calculate_size<T>(capacity: usize) -> usize {
- let mut size = mem::size_of::<TypedArenaChunk<T>>();
- size = round_up(size, mem::align_of::<T>());
- let elem_size = mem::size_of::<T>();
- let elems_size = elem_size.checked_mul(capacity).unwrap();
- size = size.checked_add(elems_size).unwrap();
- size
+ storage: RawVec<T>,
}
impl<T> TypedArenaChunk<T> {
#[inline]
- unsafe fn new(next: *mut TypedArenaChunk<T>, capacity: usize) -> *mut TypedArenaChunk<T> {
- let size = calculate_size::<T>(capacity);
- let chunk =
- allocate(size, mem::align_of::<TypedArenaChunk<T>>()) as *mut TypedArenaChunk<T>;
- if chunk.is_null() {
- alloc::oom()
- }
- (*chunk).next = next;
- (*chunk).capacity = capacity;
- chunk
+ unsafe fn new(capacity: usize) -> TypedArenaChunk<T> {
+ TypedArenaChunk { storage: RawVec::with_capacity(capacity) }
}
- /// Destroys this arena chunk. If the type descriptor is supplied, the
- /// drop glue is called; otherwise, drop glue is not called.
+ /// Destroys this arena chunk.
#[inline]
unsafe fn destroy(&mut self, len: usize) {
- // Destroy all the allocated objects.
+ // The branch on needs_drop() is an -O1 performance optimization.
+ // Without the branch, dropping TypedArena<u8> takes linear time.
if intrinsics::needs_drop::<T>() {
let mut start = self.start();
+ // Destroy all allocated objects.
for _ in 0..len {
- ptr::read(start as *const T); // run the destructor on the pointer
- start = start.offset(mem::size_of::<T>() as isize)
+ ptr::drop_in_place(start);
+ start = start.offset(1);
}
}
-
- // Destroy the next chunk.
- let next = self.next;
- let size = calculate_size::<T>(self.capacity);
- let self_ptr: *mut TypedArenaChunk<T> = self;
- deallocate(self_ptr as *mut u8,
- size,
- mem::align_of::<TypedArenaChunk<T>>());
- if !next.is_null() {
- let capacity = (*next).capacity;
- (*next).destroy(capacity);
- }
}
// Returns a pointer to the first allocated object.
#[inline]
- fn start(&self) -> *const u8 {
- let this: *const TypedArenaChunk<T> = self;
- unsafe { round_up(this.offset(1) as usize, mem::align_of::<T>()) as *const u8 }
+ fn start(&self) -> *mut T {
+ self.storage.ptr()
}
// Returns a pointer to the end of the allocated space.
#[inline]
- fn end(&self) -> *const u8 {
+ fn end(&self) -> *mut T {
unsafe {
- let size = mem::size_of::<T>().checked_mul(self.capacity).unwrap();
- self.start().offset(size as isize)
+ if mem::size_of::<T>() == 0 {
+ // A pointer as large as possible for zero-sized elements.
+ !0 as *mut T
+ } else {
+ self.start().offset(self.storage.cap() as isize)
+ }
}
}
}
+const PAGE: usize = 4096;
+
impl<T> TypedArena<T> {
- /// Creates a new `TypedArena` with preallocated space for eight objects.
+ /// Creates a new `TypedArena` with preallocated space for many objects.
#[inline]
pub fn new() -> TypedArena<T> {
- TypedArena::with_capacity(8)
+ // Reserve at least one page.
+ let elem_size = cmp::max(1, mem::size_of::<T>());
+ TypedArena::with_capacity(PAGE / elem_size)
}
/// Creates a new `TypedArena` with preallocated space for the given number of
#[inline]
pub fn with_capacity(capacity: usize) -> TypedArena<T> {
unsafe {
- let chunk = TypedArenaChunk::<T>::new(ptr::null_mut(), capacity);
+ let chunk = TypedArenaChunk::<T>::new(cmp::max(1, capacity));
TypedArena {
- ptr: Cell::new((*chunk).start() as *const T),
- end: Cell::new((*chunk).end() as *const T),
- first: RefCell::new(chunk),
- _own: marker::PhantomData,
+ ptr: Cell::new(chunk.start()),
+ end: Cell::new(chunk.end()),
+ chunks: RefCell::new(vec![chunk]),
+ _own: PhantomData,
}
}
}
}
unsafe {
- let ptr: &mut T = &mut *(self.ptr.get() as *mut T);
- ptr::write(ptr, object);
- self.ptr.set(self.ptr.get().offset(1));
- ptr
+ if mem::size_of::<T>() == 0 {
+ self.ptr.set(intrinsics::arith_offset(self.ptr.get() as *mut u8, 1) as *mut T);
+ let ptr = heap::EMPTY as *mut T;
+ // Don't drop the object. This `write` is equivalent to `forget`.
+ ptr::write(ptr, object);
+ &mut *ptr
+ } else {
+ let ptr = self.ptr.get();
+ // Advance the pointer.
+ self.ptr.set(self.ptr.get().offset(1));
+ // Write into uninitialized memory.
+ ptr::write(ptr, object);
+ &mut *ptr
+ }
}
}
/// Grows the arena.
#[inline(never)]
+ #[cold]
fn grow(&self) {
unsafe {
- let chunk = *self.first.borrow_mut();
- let new_capacity = (*chunk).capacity.checked_mul(2).unwrap();
- let chunk = TypedArenaChunk::<T>::new(chunk, new_capacity);
- self.ptr.set((*chunk).start() as *const T);
- self.end.set((*chunk).end() as *const T);
- *self.first.borrow_mut() = chunk
+ let mut chunks = self.chunks.borrow_mut();
+ let prev_capacity = chunks.last().unwrap().storage.cap();
+ let new_capacity = prev_capacity.checked_mul(2).unwrap();
+ if chunks.last_mut().unwrap().storage.double_in_place() {
+ self.end.set(chunks.last().unwrap().end());
+ } else {
+ let chunk = TypedArenaChunk::<T>::new(new_capacity);
+ self.ptr.set(chunk.start());
+ self.end.set(chunk.end());
+ chunks.push(chunk);
+ }
+ }
+ }
+ /// Clears the arena. Deallocates all but the longest chunk which may be reused.
+ pub fn clear(&mut self) {
+ unsafe {
+ // Clear the last chunk, which is partially filled.
+ let mut chunks_borrow = self.chunks.borrow_mut();
+ let last_idx = chunks_borrow.len() - 1;
+ self.clear_last_chunk(&mut chunks_borrow[last_idx]);
+ // If `T` is ZST, code below has no effect.
+ for mut chunk in chunks_borrow.drain(..last_idx) {
+ let cap = chunk.storage.cap();
+ chunk.destroy(cap);
+ }
+ }
+ }
+
+ // Drops the contents of the last chunk. The last chunk is partially empty, unlike all other
+ // chunks.
+ fn clear_last_chunk(&self, last_chunk: &mut TypedArenaChunk<T>) {
+ // Determine how much was filled.
+ let start = last_chunk.start() as usize;
+ // We obtain the value of the pointer to the first uninitialized element.
+ let end = self.ptr.get() as usize;
+ // We then calculate the number of elements to be dropped in the last chunk,
+ // which is the filled area's length.
+ let diff = if mem::size_of::<T>() == 0 {
+ // `T` is ZST. It can't have a drop flag, so the value here doesn't matter. We get
+ // the number of zero-sized values in the last and only chunk, just out of caution.
+ // Recall that `end` was incremented for each allocated value.
+ end - start
+ } else {
+ (end - start) / mem::size_of::<T>()
+ };
+ // Pass that to the `destroy` method.
+ unsafe {
+ last_chunk.destroy(diff);
}
+ // Reset the chunk.
+ self.ptr.set(last_chunk.start());
}
}
fn drop(&mut self) {
unsafe {
// Determine how much was filled.
- let start = self.first.borrow().as_ref().unwrap().start() as usize;
- let end = self.ptr.get() as usize;
- let diff = (end - start) / mem::size_of::<T>();
-
- // Pass that to the `destroy` method.
- (**self.first.borrow_mut()).destroy(diff)
+ let mut chunks_borrow = self.chunks.borrow_mut();
+ let mut last_chunk = chunks_borrow.pop().unwrap();
+ // Drop the contents of the last chunk.
+ self.clear_last_chunk(&mut last_chunk);
+ // The last chunk will be dropped. Destroy all other chunks.
+ for chunk in chunks_borrow.iter_mut() {
+ let cap = chunk.storage.cap();
+ chunk.destroy(cap);
+ }
+ // RawVec handles deallocation of `last_chunk` and `self.chunks`.
}
}
}
+unsafe impl<T: Send> Send for TypedArena<T> {}
+
#[cfg(test)]
mod tests {
extern crate test;
use self::test::Bencher;
use super::{Arena, TypedArena};
+ use std::cell::Cell;
+ use std::rc::Rc;
#[allow(dead_code)]
+ #[derive(Debug, Eq, PartialEq)]
struct Point {
x: i32,
y: i32,
#[bench]
pub fn bench_copy_nonarena(b: &mut Bencher) {
b.iter(|| {
- let _: Box<_> = box Point { x: 1, y: 2, z: 3 };
+ let _: Box<_> = Box::new(Point { x: 1, y: 2, z: 3 });
})
}
}
}
+ #[test]
+ pub fn test_typed_arena_zero_sized() {
+ let arena = TypedArena::new();
+ for _ in 0..100000 {
+ arena.alloc(());
+ }
+ }
+
+ #[test]
+ pub fn test_arena_zero_sized() {
+ let arena = Arena::new();
+ let mut points = vec![];
+ for _ in 0..1000 {
+ for _ in 0..100 {
+ arena.alloc(|| ());
+ }
+ let point = arena.alloc(|| Point { x: 1, y: 2, z: 3 });
+ points.push(point);
+ }
+ for point in &points {
+ assert_eq!(**point, Point { x: 1, y: 2, z: 3 });
+ }
+ }
+
+ #[test]
+ pub fn test_typed_arena_clear() {
+ let mut arena = TypedArena::new();
+ for _ in 0..10 {
+ arena.clear();
+ for _ in 0..10000 {
+ arena.alloc(Point { x: 1, y: 2, z: 3 });
+ }
+ }
+ }
+
+ #[test]
+ pub fn test_arena_clear() {
+ let mut arena = Arena::new();
+ for _ in 0..10 {
+ arena.clear();
+ for _ in 0..10000 {
+ arena.alloc(|| Point { x: 1, y: 2, z: 3 });
+ arena.alloc(|| {
+ Noncopy {
+ string: "hello world".to_string(),
+ array: vec![],
+ }
+ });
+ }
+ }
+ }
+
+ #[test]
+ pub fn test_arena_alloc_bytes() {
+ let arena = Arena::new();
+ for i in 0..10000 {
+ arena.alloc(|| Point { x: 1, y: 2, z: 3 });
+ for byte in arena.alloc_bytes(i % 42).iter_mut() {
+ *byte = i as u8;
+ }
+ }
+ }
+
+ #[test]
+ fn test_arena_destructors() {
+ let arena = Arena::new();
+ for i in 0..10 {
+ // Arena allocate something with drop glue to make sure it
+ // doesn't leak.
+ arena.alloc(|| Rc::new(i));
+ // Allocate something with funny size and alignment, to keep
+ // things interesting.
+ arena.alloc(|| [0u8, 1u8, 2u8]);
+ }
+ }
+
+ #[test]
+ #[should_panic]
+ fn test_arena_destructors_fail() {
+ let arena = Arena::new();
+ // Put some stuff in the arena.
+ for i in 0..10 {
+ // Arena allocate something with drop glue to make sure it
+ // doesn't leak.
+ arena.alloc(|| Rc::new(i));
+ // Allocate something with funny size and alignment, to keep
+ // things interesting.
+ arena.alloc(|| [0u8, 1, 2]);
+ }
+ // Now, panic while allocating
+ arena.alloc::<Rc<i32>, _>(|| {
+ panic!();
+ });
+ }
+
+ // Drop tests
+
+ struct DropCounter<'a> {
+ count: &'a Cell<u32>,
+ }
+
+ impl<'a> Drop for DropCounter<'a> {
+ fn drop(&mut self) {
+ self.count.set(self.count.get() + 1);
+ }
+ }
+
+ #[test]
+ fn test_arena_drop_count() {
+ let counter = Cell::new(0);
+ {
+ let arena = Arena::new();
+ for _ in 0..100 {
+ // Allocate something with drop glue to make sure it doesn't leak.
+ arena.alloc(|| DropCounter { count: &counter });
+ // Allocate something with funny size and alignment, to keep
+ // things interesting.
+ arena.alloc(|| [0u8, 1u8, 2u8]);
+ }
+ // dropping
+ };
+ assert_eq!(counter.get(), 100);
+ }
+
+ #[test]
+ fn test_arena_drop_on_clear() {
+ let counter = Cell::new(0);
+ for i in 0..10 {
+ let mut arena = Arena::new();
+ for _ in 0..100 {
+ // Allocate something with drop glue to make sure it doesn't leak.
+ arena.alloc(|| DropCounter { count: &counter });
+ // Allocate something with funny size and alignment, to keep
+ // things interesting.
+ arena.alloc(|| [0u8, 1u8, 2u8]);
+ }
+ arena.clear();
+ assert_eq!(counter.get(), i * 100 + 100);
+ }
+ }
+
+ #[test]
+ fn test_typed_arena_drop_count() {
+ let counter = Cell::new(0);
+ {
+ let arena: TypedArena<DropCounter> = TypedArena::new();
+ for _ in 0..100 {
+ // Allocate something with drop glue to make sure it doesn't leak.
+ arena.alloc(DropCounter { count: &counter });
+ }
+ };
+ assert_eq!(counter.get(), 100);
+ }
+
+ #[test]
+ fn test_typed_arena_drop_on_clear() {
+ let counter = Cell::new(0);
+ let mut arena: TypedArena<DropCounter> = TypedArena::new();
+ for i in 0..10 {
+ for _ in 0..100 {
+ // Allocate something with drop glue to make sure it doesn't leak.
+ arena.alloc(DropCounter { count: &counter });
+ }
+ arena.clear();
+ assert_eq!(counter.get(), i * 100 + 100);
+ }
+ }
+
+ thread_local! {
+ static DROP_COUNTER: Cell<u32> = Cell::new(0)
+ }
+
+ struct SmallDroppable;
+
+ impl Drop for SmallDroppable {
+ fn drop(&mut self) {
+ DROP_COUNTER.with(|c| c.set(c.get() + 1));
+ }
+ }
+
+ #[test]
+ fn test_arena_drop_small_count() {
+ DROP_COUNTER.with(|c| c.set(0));
+ {
+ let arena = Arena::new();
+ for _ in 0..10 {
+ for _ in 0..10 {
+ // Allocate something with drop glue to make sure it doesn't leak.
+ arena.alloc(|| SmallDroppable);
+ }
+ // Allocate something with funny size and alignment, to keep
+ // things interesting.
+ arena.alloc(|| [0u8, 1u8, 2u8]);
+ }
+ // dropping
+ };
+ assert_eq!(DROP_COUNTER.with(|c| c.get()), 100);
+ }
+
+ #[test]
+ fn test_typed_arena_drop_small_count() {
+ DROP_COUNTER.with(|c| c.set(0));
+ {
+ let arena: TypedArena<SmallDroppable> = TypedArena::new();
+ for _ in 0..100 {
+ // Allocate something with drop glue to make sure it doesn't leak.
+ arena.alloc(SmallDroppable);
+ }
+ // dropping
+ };
+ assert_eq!(DROP_COUNTER.with(|c| c.get()), 100);
+ }
+
#[bench]
pub fn bench_noncopy(b: &mut Bencher) {
let arena = TypedArena::new();
#[bench]
pub fn bench_noncopy_nonarena(b: &mut Bencher) {
b.iter(|| {
- let _: Box<_> = box Noncopy {
+ let _: Box<_> = Box::new(Noncopy {
string: "hello world".to_string(),
array: vec![1, 2, 3, 4, 5],
- };
+ });
})
}
* configure.ac: Add --enable-host-shared.
* configure: Regenerate.
-
+\f
Copyright (C) 2013-2014 Free Software Foundation, Inc.
Copying and distribution of this file, with or without modification,
# met:
# (1) Redistributions of source code must retain the above copyright
-# notice, this list of conditions and the following disclaimer.
+# notice, this list of conditions and the following disclaimer.
# (2) Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
-# distribution.
+# distribution.
# (3) The name of the author may not be used to
# endorse or promote products derived from this software without
# met:
# (1) Redistributions of source code must retain the above copyright
-# notice, this list of conditions and the following disclaimer.
+# notice, this list of conditions and the following disclaimer.
# (2) Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
-# distribution.
+# distribution.
# (3) The name of the author may not be used to
# endorse or promote products derived from this software without
$(LDFLAGS) -o $@
SOURCES = $(libbacktrace_la_SOURCES) $(EXTRA_libbacktrace_la_SOURCES) \
$(btest_SOURCES) $(stest_SOURCES)
-MULTISRCTOP =
-MULTIBUILDTOP =
-MULTIDIRS =
-MULTISUBDIR =
+MULTISRCTOP =
+MULTIBUILDTOP =
+MULTIDIRS =
+MULTISUBDIR =
MULTIDO = true
MULTICLEAN = true
am__can_run_installinfo = \
stamp-h1: $(srcdir)/config.h.in $(top_builddir)/config.status
@rm -f stamp-h1
cd $(top_builddir) && $(SHELL) ./config.status config.h
-$(srcdir)/config.h.in: @MAINTAINER_MODE_TRUE@ $(am__configure_deps)
+$(srcdir)/config.h.in: @MAINTAINER_MODE_TRUE@ $(am__configure_deps)
($(am__cd) $(top_srcdir) && $(AUTOHEADER))
rm -f stamp-h1
touch $@
echo "rm -f \"$${dir}/so_locations\""; \
rm -f "$${dir}/so_locations"; \
done
-libbacktrace.la: $(libbacktrace_la_OBJECTS) $(libbacktrace_la_DEPENDENCIES) $(EXTRA_libbacktrace_la_DEPENDENCIES)
+libbacktrace.la: $(libbacktrace_la_OBJECTS) $(libbacktrace_la_DEPENDENCIES) $(EXTRA_libbacktrace_la_DEPENDENCIES)
$(LINK) $(libbacktrace_la_OBJECTS) $(libbacktrace_la_LIBADD) $(LIBS)
clean-checkPROGRAMS:
list=`for p in $$list; do echo "$$p"; done | sed 's/$(EXEEXT)$$//'`; \
echo " rm -f" $$list; \
rm -f $$list
-btest$(EXEEXT): $(btest_OBJECTS) $(btest_DEPENDENCIES) $(EXTRA_btest_DEPENDENCIES)
+btest$(EXEEXT): $(btest_OBJECTS) $(btest_DEPENDENCIES) $(EXTRA_btest_DEPENDENCIES)
@rm -f btest$(EXEEXT)
$(btest_LINK) $(btest_OBJECTS) $(btest_LDADD) $(LIBS)
-stest$(EXEEXT): $(stest_OBJECTS) $(stest_DEPENDENCIES) $(EXTRA_stest_DEPENDENCIES)
+stest$(EXEEXT): $(stest_OBJECTS) $(stest_DEPENDENCIES) $(EXTRA_stest_DEPENDENCIES)
@rm -f stest$(EXEEXT)
$(LINK) $(stest_OBJECTS) $(stest_LDADD) $(LIBS)
met:
(1) Redistributions of source code must retain the above copyright
- notice, this list of conditions and the following disclaimer.
+ notice, this list of conditions and the following disclaimer.
(2) Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in
the documentation and/or other materials provided with the
- distribution.
-
+ distribution.
+
(3) The name of the author may not be used to
endorse or promote products derived from this software without
specific prior written permission.
met:
(1) Redistributions of source code must retain the above copyright
- notice, this list of conditions and the following disclaimer.
+ notice, this list of conditions and the following disclaimer.
(2) Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in
the documentation and/or other materials provided with the
- distribution.
-
+ distribution.
+
(3) The name of the author may not be used to
endorse or promote products derived from this software without
specific prior written permission.
met:
(1) Redistributions of source code must retain the above copyright
- notice, this list of conditions and the following disclaimer.
+ notice, this list of conditions and the following disclaimer.
(2) Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in
the documentation and/or other materials provided with the
- distribution.
-
+ distribution.
+
(3) The name of the author may not be used to
endorse or promote products derived from this software without
specific prior written permission.
met:
(1) Redistributions of source code must retain the above copyright
- notice, this list of conditions and the following disclaimer.
+ notice, this list of conditions and the following disclaimer.
(2) Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in
the documentation and/or other materials provided with the
- distribution.
-
+ distribution.
+
(3) The name of the author may not be used to
endorse or promote products derived from this software without
specific prior written permission.
met:
(1) Redistributions of source code must retain the above copyright
- notice, this list of conditions and the following disclaimer.
+ notice, this list of conditions and the following disclaimer.
(2) Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in
the documentation and/or other materials provided with the
- distribution.
-
+ distribution.
+
(3) The name of the author may not be used to
endorse or promote products derived from this software without
specific prior written permission.
met:
(1) Redistributions of source code must retain the above copyright
- notice, this list of conditions and the following disclaimer.
+ notice, this list of conditions and the following disclaimer.
(2) Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in
the documentation and/or other materials provided with the
- distribution.
-
+ distribution.
+
(3) The name of the author may not be used to
endorse or promote products derived from this software without
specific prior written permission.
(unsigned int) bdata.index, j + 1);
bdata.failed = 1;
}
- }
+ }
check ("test3", 0, all, f3line, "f23", &bdata.failed);
check ("test3", 1, all, f2line, "f22", &bdata.failed);
# met:
# (1) Redistributions of source code must retain the above copyright
-# notice, this list of conditions and the following disclaimer.
+# notice, this list of conditions and the following disclaimer.
# (2) Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
-# distribution.
-
+# distribution.
+
# (3) The name of the author may not be used to
# endorse or promote products derived from this software without
# specific prior written permission.
met:
(1) Redistributions of source code must retain the above copyright
- notice, this list of conditions and the following disclaimer.
+ notice, this list of conditions and the following disclaimer.
(2) Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in
the documentation and/or other materials provided with the
- distribution.
-
+ distribution.
+
(3) The name of the author may not be used to
endorse or promote products derived from this software without
specific prior written permission.
static int
find_address_ranges (struct backtrace_state *state, uintptr_t base_address,
- struct dwarf_buf *unit_buf,
+ struct dwarf_buf *unit_buf,
const unsigned char *dwarf_str, size_t dwarf_str_size,
const unsigned char *dwarf_ranges,
size_t dwarf_ranges_size,
if (!advance (line_buf, hdrlen))
return 0;
-
+
hdr->min_insn_len = read_byte (&hdr_buf);
if (hdr->version < 4)
hdr->max_ops_per_insn = 1;
/* We don't care about default_is_stmt. */
read_byte (&hdr_buf);
-
+
hdr->line_base = read_sbyte (&hdr_buf);
hdr->line_range = read_byte (&hdr_buf);
/* This file declares various DWARF-related constants using a set of
macros which can be redefined by the including file.
-
+
The macros are in sections. Each section corresponds to a single
set of DWARF constants and has a corresponding key. The key is
used in all the macro names.
-
+
The sections are TAG (for DW_TAG_ constants), FORM (DW_FORM_), AT
(DW_AT_), OP (DW_OP_), ATE (DW_ATE_), and CFA (DW_CFA_).
-
+
Using TAG as an example, the following macros may be used for each
key:
-
+
DW_FIRST_TAG(name, value) - Introduce the first DW_TAG constant.
-
+
DW_TAG(name, value) - Define a subsequent constant.
-
+
DW_TAG_DUP(name, value) - Define a subsequent constant whose value
is a duplicate of some other constant. Not all keys use the _DUP
macro form. If more than one name shares a value, then the base
(DW_TAG) form will be the preferred name and DW_TAG_DUP will hold
any alternate names.
-
+
DW_END_TAG - Invoked at the end of the DW_TAG constants. */
DW_FIRST_TAG (DW_TAG_padding, 0x00)
DW_MACRO_GNU_lo_user = 0xe0,
DW_MACRO_GNU_hi_user = 0xff
};
-
+\f
/* @@@ For use with GNU frame unwind information. */
#define DW_EH_PE_absptr 0x00
met:
(1) Redistributions of source code must retain the above copyright
- notice, this list of conditions and the following disclaimer.
+ notice, this list of conditions and the following disclaimer.
(2) Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in
the documentation and/or other materials provided with the
- distribution.
-
+ distribution.
+
(3) The name of the author may not be used to
endorse or promote products derived from this software without
specific prior written permission.
met:
(1) Redistributions of source code must retain the above copyright
- notice, this list of conditions and the following disclaimer.
+ notice, this list of conditions and the following disclaimer.
(2) Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in
the documentation and/or other materials provided with the
- distribution.
-
+ distribution.
+
(3) The name of the author may not be used to
endorse or promote products derived from this software without
specific prior written permission.
met:
(1) Redistributions of source code must retain the above copyright
- notice, this list of conditions and the following disclaimer.
+ notice, this list of conditions and the following disclaimer.
(2) Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in
the documentation and/or other materials provided with the
- distribution.
-
+ distribution.
+
(3) The name of the author may not be used to
endorse or promote products derived from this software without
specific prior written permission.
met:
(1) Redistributions of source code must retain the above copyright
- notice, this list of conditions and the following disclaimer.
+ notice, this list of conditions and the following disclaimer.
(2) Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in
the documentation and/or other materials provided with the
- distribution.
-
+ distribution.
+
(3) The name of the author may not be used to
endorse or promote products derived from this software without
specific prior written permission.
met:
(1) Redistributions of source code must retain the above copyright
- notice, this list of conditions and the following disclaimer.
+ notice, this list of conditions and the following disclaimer.
(2) Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in
the documentation and/or other materials provided with the
- distribution.
-
+ distribution.
+
(3) The name of the author may not be used to
endorse or promote products derived from this software without
specific prior written permission.
met:
(1) Redistributions of source code must retain the above copyright
- notice, this list of conditions and the following disclaimer.
+ notice, this list of conditions and the following disclaimer.
(2) Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in
the documentation and/or other materials provided with the
- distribution.
-
+ distribution.
+
(3) The name of the author may not be used to
endorse or promote products derived from this software without
specific prior written permission.
met:
(1) Redistributions of source code must retain the above copyright
- notice, this list of conditions and the following disclaimer.
+ notice, this list of conditions and the following disclaimer.
(2) Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in
the documentation and/or other materials provided with the
- distribution.
-
+ distribution.
+
(3) The name of the author may not be used to
endorse or promote products derived from this software without
specific prior written permission.
met:
(1) Redistributions of source code must retain the above copyright
- notice, this list of conditions and the following disclaimer.
+ notice, this list of conditions and the following disclaimer.
(2) Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in
the documentation and/or other materials provided with the
- distribution.
-
+ distribution.
+
(3) The name of the author may not be used to
endorse or promote products derived from this software without
specific prior written permission.
met:
(1) Redistributions of source code must retain the above copyright
- notice, this list of conditions and the following disclaimer.
+ notice, this list of conditions and the following disclaimer.
(2) Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in
the documentation and/or other materials provided with the
- distribution.
-
+ distribution.
+
(3) The name of the author may not be used to
endorse or promote products derived from this software without
specific prior written permission.
met:
(1) Redistributions of source code must retain the above copyright
- notice, this list of conditions and the following disclaimer.
+ notice, this list of conditions and the following disclaimer.
(2) Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in
the documentation and/or other materials provided with the
- distribution.
-
+ distribution.
+
(3) The name of the author may not be used to
endorse or promote products derived from this software without
specific prior written permission.
met:
(1) Redistributions of source code must retain the above copyright
- notice, this list of conditions and the following disclaimer.
+ notice, this list of conditions and the following disclaimer.
(2) Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in
the documentation and/or other materials provided with the
- distribution.
-
+ distribution.
+
(3) The name of the author may not be used to
endorse or promote products derived from this software without
specific prior written permission.
met:
(1) Redistributions of source code must retain the above copyright
- notice, this list of conditions and the following disclaimer.
+ notice, this list of conditions and the following disclaimer.
(2) Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in
the documentation and/or other materials provided with the
- distribution.
-
+ distribution.
+
(3) The name of the author may not be used to
endorse or promote products derived from this software without
specific prior written permission.
met:
(1) Redistributions of source code must retain the above copyright
- notice, this list of conditions and the following disclaimer.
+ notice, this list of conditions and the following disclaimer.
(2) Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in
the documentation and/or other materials provided with the
- distribution.
-
+ distribution.
+
(3) The name of the author may not be used to
endorse or promote products derived from this software without
specific prior written permission.
met:
(1) Redistributions of source code must retain the above copyright
- notice, this list of conditions and the following disclaimer.
+ notice, this list of conditions and the following disclaimer.
(2) Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in
the documentation and/or other materials provided with the
- distribution.
-
+ distribution.
+
(3) The name of the author may not be used to
endorse or promote products derived from this software without
specific prior written permission.
/// even though it does not. This allows you to inform the compiler about certain safety properties
/// of your code.
///
+/// For a more in-depth explanation of how to use `PhantomData<T>`, please see [the Nomicon].
+///
+/// [the Nomicon]: ../../nomicon/phantom-data.html
+///
/// # A ghastly note 👻👻👻
///
/// Though they both have scary names, `PhantomData<T>` and 'phantom types' are related, but not
"type parameter default erroneously allowed in invalid location"
}
+declare_lint! {
+ pub MATCH_OF_UNIT_VARIANT_VIA_PAREN_DOTDOT,
+ Warn,
+ "unit struct or enum variant erroneously allowed to match via path::ident(..)"
+}
+
/// Does nothing as a lint pass, but registers some `Lint`s
/// which are used by other parts of the compiler.
#[derive(Copy, Clone)]
TRIVIAL_NUMERIC_CASTS,
PRIVATE_IN_PUBLIC,
INVALID_TYPE_PARAM_DEFAULT,
+ MATCH_OF_UNIT_VARIANT_VIA_PAREN_DOTDOT,
CONST_ERR
)
}
b_def_id,
util::fresh_type_vars_for_impl);
- debug!("overlap: a_trait_ref={:?}", a_trait_ref);
+ debug!("overlap: a_trait_ref={:?} a_obligations={:?}", a_trait_ref, a_obligations);
- debug!("overlap: b_trait_ref={:?}", b_trait_ref);
+ debug!("overlap: b_trait_ref={:?} b_obligations={:?}", b_trait_ref, b_obligations);
// Do `a` and `b` unify? If not, no overlap.
if let Err(_) = infer::mk_eq_trait_refs(selcx.infcx(),
tt.principal_def_id().is_local()
}
- ty::TyClosure(..) |
ty::TyError => {
+ true
+ }
+
+ ty::TyClosure(..) => {
tcx.sess.bug(
&format!("ty_is_local invoked on unexpected type: {:?}",
ty))
}
}
-/// in various error cases, we just set TyError and return an obligation
-/// that, when fulfilled, will lead to an error.
+/// If we are projecting `<T as Trait>::Item`, but `T: Trait` does not
+/// hold. In various error cases, we cannot generate a valid
+/// normalized projection. Therefore, we create an inference variable
+/// return an associated obligation that, when fulfilled, will lead to
+/// an error.
///
-/// FIXME: the TyError created here can enter the obligation we create,
-/// leading to error messages involving TyError.
+/// Note that we used to return `TyError` here, but that was quite
+/// dubious -- the premise was that an error would *eventually* be
+/// reported, when the obligation was processed. But in general once
+/// you see a `TyError` you are supposed to be able to assume that an
+/// error *has been* reported, so that you can take whatever heuristic
+/// paths you want to take. To make things worse, it was possible for
+/// cycles to arise, where you basically had a setup like `<MyType<$0>
+/// as Trait>::Foo == $0`. Here, normalizing `<MyType<$0> as
+/// Trait>::Foo> to `[type error]` would lead to an obligation of
+/// `<MyType<[type error]> as Trait>::Foo`. We are supposed to report
+/// an error for this obligation, but we legitimately should not,
+/// because it contains `[type error]`. Yuck! (See issue #29857 for
+/// one case where this arose.)
fn normalize_to_error<'a,'tcx>(selcx: &mut SelectionContext<'a,'tcx>,
projection_ty: ty::ProjectionTy<'tcx>,
cause: ObligationCause<'tcx>,
let trait_obligation = Obligation { cause: cause,
recursion_depth: depth,
predicate: trait_ref.to_predicate() };
+ let new_value = selcx.infcx().next_ty_var();
Normalized {
- value: selcx.tcx().types.err,
+ value: new_value,
obligations: vec!(trait_obligation)
}
}
BuiltinObjectCandidate,
BuiltinUnsizeCandidate,
-
- ErrorCandidate,
}
struct SelectionCandidateSet<'tcx> {
stack: &TraitObligationStack<'o, 'tcx>)
-> SelectionResult<'tcx, SelectionCandidate<'tcx>>
{
- if stack.obligation.predicate.0.self_ty().references_error() {
- return Ok(Some(ErrorCandidate));
+ if stack.obligation.predicate.references_error() {
+ // If we encounter a `TyError`, we generally prefer the
+ // most "optimistic" result in response -- that is, the
+ // one least likely to report downstream errors. But
+ // because this routine is shared by coherence and by
+ // trait selection, there isn't an obvious "right" choice
+ // here in that respect, so we opt to just return
+ // ambiguity and let the upstream clients sort it out.
+ return Ok(None);
}
if !self.is_knowable(stack) {
true
},
&ParamCandidate(..) => false,
- &ErrorCandidate => false // propagate errors
},
_ => false
}
try!(self.confirm_builtin_candidate(obligation, builtin_bound))))
}
- ErrorCandidate => {
- Ok(VtableBuiltin(VtableBuiltinData { nested: vec![] }))
- }
-
ParamCandidate(param) => {
let obligations = self.confirm_param_candidate(obligation, param);
Ok(VtableParam(obligations))
use std::borrow::{Cow, IntoCow};
use std::fmt::{self, Debug, Formatter, Write};
use std::{iter, u32};
+use std::ops::{Index, IndexMut};
/// Lowered representation of a single function.
#[derive(RustcEncodable, RustcDecodable)]
}
}
+impl<'tcx> Index<BasicBlock> for Mir<'tcx> {
+ type Output = BasicBlockData<'tcx>;
+
+ #[inline]
+ fn index(&self, index: BasicBlock) -> &BasicBlockData<'tcx> {
+ self.basic_block_data(index)
+ }
+}
+
+impl<'tcx> IndexMut<BasicBlock> for Mir<'tcx> {
+ #[inline]
+ fn index_mut(&mut self, index: BasicBlock) -> &mut BasicBlockData<'tcx> {
+ self.basic_block_data_mut(index)
+ }
+}
+
///////////////////////////////////////////////////////////////////////////
// Mutability and borrow kinds
Vec => write!(fmt, "{:?}", lvs),
Tuple => {
- if lvs.len() == 1 {
- write!(fmt, "({:?},)", lvs[0])
- } else {
- fmt_tuple(fmt, "", lvs)
+ match lvs.len() {
+ 0 => write!(fmt, "()"),
+ 1 => write!(fmt, "({:?},)", lvs[0]),
+ _ => fmt_tuple(fmt, "", lvs),
}
}
use rustc_data_structures::tuple_slice::TupleSlice;
use syntax::codemap::Span;
-pub trait Visitor<'tcx> {
- // Override these, and call `self.super_xxx` to revert back to the
- // default behavior.
+macro_rules! make_mir_visitor {
+ ($visitor_trait_name:ident, $($mutability:ident)*) => {
+ pub trait $visitor_trait_name<'tcx> {
+ // Override these, and call `self.super_xxx` to revert back to the
+ // default behavior.
- fn visit_mir(&mut self, mir: &Mir<'tcx>) {
- self.super_mir(mir);
- }
-
- fn visit_basic_block_data(&mut self, block: BasicBlock, data: &BasicBlockData<'tcx>) {
- self.super_basic_block_data(block, data);
- }
-
- fn visit_statement(&mut self, block: BasicBlock, statement: &Statement<'tcx>) {
- self.super_statement(block, statement);
- }
-
- fn visit_assign(&mut self, block: BasicBlock, lvalue: &Lvalue<'tcx>, rvalue: &Rvalue<'tcx>) {
- self.super_assign(block, lvalue, rvalue);
- }
-
- fn visit_terminator(&mut self, block: BasicBlock, terminator: &Terminator<'tcx>) {
- self.super_terminator(block, terminator);
- }
-
- fn visit_rvalue(&mut self, rvalue: &Rvalue<'tcx>) {
- self.super_rvalue(rvalue);
- }
-
- fn visit_operand(&mut self, operand: &Operand<'tcx>) {
- self.super_operand(operand);
- }
-
- fn visit_lvalue(&mut self, lvalue: &Lvalue<'tcx>, context: LvalueContext) {
- self.super_lvalue(lvalue, context);
- }
-
- fn visit_branch(&mut self, source: BasicBlock, target: BasicBlock) {
- self.super_branch(source, target);
- }
-
- fn visit_constant(&mut self, constant: &Constant<'tcx>) {
- self.super_constant(constant);
- }
-
- fn visit_literal(&mut self, literal: &Literal<'tcx>) {
- self.super_literal(literal);
- }
-
- fn visit_def_id(&mut self, def_id: DefId) {
- self.super_def_id(def_id);
- }
-
- fn visit_span(&mut self, span: Span) {
- self.super_span(span);
- }
-
- // The `super_xxx` methods comprise the default behavior and are
- // not meant to be overidden.
-
- fn super_mir(&mut self, mir: &Mir<'tcx>) {
- for block in mir.all_basic_blocks() {
- let data = mir.basic_block_data(block);
- self.visit_basic_block_data(block, data);
- }
- }
-
- fn super_basic_block_data(&mut self, block: BasicBlock, data: &BasicBlockData<'tcx>) {
- for statement in &data.statements {
- self.visit_statement(block, statement);
- }
- data.terminator.as_ref().map(|r| self.visit_terminator(block, r));
- }
-
- fn super_statement(&mut self, block: BasicBlock, statement: &Statement<'tcx>) {
- self.visit_span(statement.span);
-
- match statement.kind {
- StatementKind::Assign(ref lvalue, ref rvalue) => {
- self.visit_assign(block, lvalue, rvalue);
+ fn visit_mir(&mut self, mir: & $($mutability)* Mir<'tcx>) {
+ self.super_mir(mir);
}
- StatementKind::Drop(_, ref lvalue) => {
- self.visit_lvalue(lvalue, LvalueContext::Drop);
- }
- }
- }
- fn super_assign(&mut self, _block: BasicBlock, lvalue: &Lvalue<'tcx>, rvalue: &Rvalue<'tcx>) {
- self.visit_lvalue(lvalue, LvalueContext::Store);
- self.visit_rvalue(rvalue);
- }
-
- fn super_terminator(&mut self, block: BasicBlock, terminator: &Terminator<'tcx>) {
- match *terminator {
- Terminator::Goto { target } => {
- self.visit_branch(block, target);
+ fn visit_basic_block_data(&mut self,
+ block: BasicBlock,
+ data: & $($mutability)* BasicBlockData<'tcx>) {
+ self.super_basic_block_data(block, data);
}
- Terminator::If { ref cond, ref targets } => {
- self.visit_operand(cond);
- for &target in targets.as_slice() {
- self.visit_branch(block, target);
- }
+ fn visit_statement(&mut self,
+ block: BasicBlock,
+ statement: & $($mutability)* Statement<'tcx>) {
+ self.super_statement(block, statement);
}
- Terminator::Switch { ref discr, adt_def: _, ref targets } => {
- self.visit_lvalue(discr, LvalueContext::Inspect);
- for &target in targets {
- self.visit_branch(block, target);
- }
+ fn visit_assign(&mut self,
+ block: BasicBlock,
+ lvalue: & $($mutability)* Lvalue<'tcx>,
+ rvalue: & $($mutability)* Rvalue<'tcx>) {
+ self.super_assign(block, lvalue, rvalue);
}
- Terminator::SwitchInt { ref discr, switch_ty: _, values: _, ref targets } => {
- self.visit_lvalue(discr, LvalueContext::Inspect);
- for &target in targets {
- self.visit_branch(block, target);
- }
+ fn visit_terminator(&mut self,
+ block: BasicBlock,
+ terminator: & $($mutability)* Terminator<'tcx>) {
+ self.super_terminator(block, terminator);
}
- Terminator::Resume |
- Terminator::Return => {
+ fn visit_rvalue(&mut self,
+ rvalue: & $($mutability)* Rvalue<'tcx>) {
+ self.super_rvalue(rvalue);
}
- Terminator::Call { ref func, ref args, ref kind } => {
- if let Some(ref destination) = kind.destination() {
- self.visit_lvalue(destination, LvalueContext::Store);
- }
- self.visit_operand(func);
- for arg in args {
- self.visit_operand(arg);
- }
- for &target in kind.successors() {
- self.visit_branch(block, target);
- }
+ fn visit_operand(&mut self,
+ operand: & $($mutability)* Operand<'tcx>) {
+ self.super_operand(operand);
}
- }
- }
- fn super_rvalue(&mut self, rvalue: &Rvalue<'tcx>) {
- match *rvalue {
- Rvalue::Use(ref operand) => {
- self.visit_operand(operand);
+ fn visit_lvalue(&mut self,
+ lvalue: & $($mutability)* Lvalue<'tcx>,
+ context: LvalueContext) {
+ self.super_lvalue(lvalue, context);
}
- Rvalue::Repeat(ref value, ref len) => {
- self.visit_operand(value);
- self.visit_constant(len);
+ fn visit_branch(&mut self,
+ source: BasicBlock,
+ target: BasicBlock) {
+ self.super_branch(source, target);
}
- Rvalue::Ref(r, bk, ref path) => {
- self.visit_lvalue(path, LvalueContext::Borrow {
- region: r,
- kind: bk
- });
+ fn visit_constant(&mut self,
+ constant: & $($mutability)* Constant<'tcx>) {
+ self.super_constant(constant);
}
- Rvalue::Len(ref path) => {
- self.visit_lvalue(path, LvalueContext::Inspect);
+ fn visit_literal(&mut self,
+ literal: & $($mutability)* Literal<'tcx>) {
+ self.super_literal(literal);
}
- Rvalue::Cast(_, ref operand, _) => {
- self.visit_operand(operand);
+ fn visit_def_id(&mut self,
+ def_id: & $($mutability)* DefId) {
+ self.super_def_id(def_id);
}
- Rvalue::BinaryOp(_, ref lhs, ref rhs) => {
- self.visit_operand(lhs);
- self.visit_operand(rhs);
+ fn visit_span(&mut self,
+ span: & $($mutability)* Span) {
+ self.super_span(span);
}
- Rvalue::UnaryOp(_, ref op) => {
- self.visit_operand(op);
- }
+ // The `super_xxx` methods comprise the default behavior and are
+ // not meant to be overidden.
- Rvalue::Box(_) => {
+ fn super_mir(&mut self,
+ mir: & $($mutability)* Mir<'tcx>) {
+ for block in mir.all_basic_blocks() {
+ let data = & $($mutability)* mir[block];
+ self.visit_basic_block_data(block, data);
+ }
}
- Rvalue::Aggregate(_, ref operands) => {
- for operand in operands {
- self.visit_operand(operand);
+ fn super_basic_block_data(&mut self,
+ block: BasicBlock,
+ data: & $($mutability)* BasicBlockData<'tcx>) {
+ for statement in & $($mutability)* data.statements {
+ self.visit_statement(block, statement);
}
- }
- Rvalue::Slice { ref input, from_start, from_end } => {
- self.visit_lvalue(input, LvalueContext::Slice {
- from_start: from_start,
- from_end: from_end,
- });
+ if let Some(ref $($mutability)* terminator) = data.terminator {
+ self.visit_terminator(block, terminator);
+ }
}
- Rvalue::InlineAsm(_) => {
- }
- }
- }
+ fn super_statement(&mut self,
+ block: BasicBlock,
+ statement: & $($mutability)* Statement<'tcx>) {
+ self.visit_span(& $($mutability)* statement.span);
- fn super_operand(&mut self, operand: &Operand<'tcx>) {
- match *operand {
- Operand::Consume(ref lvalue) => {
- self.visit_lvalue(lvalue, LvalueContext::Consume);
- }
- Operand::Constant(ref constant) => {
- self.visit_constant(constant);
- }
- }
- }
-
- fn super_lvalue(&mut self, lvalue: &Lvalue<'tcx>, _context: LvalueContext) {
- match *lvalue {
- Lvalue::Var(_) |
- Lvalue::Temp(_) |
- Lvalue::Arg(_) |
- Lvalue::Static(_) |
- Lvalue::ReturnPointer => {
- }
- Lvalue::Projection(ref proj) => {
- self.visit_lvalue(&proj.base, LvalueContext::Projection);
+ match statement.kind {
+ StatementKind::Assign(ref $($mutability)* lvalue,
+ ref $($mutability)* rvalue) => {
+ self.visit_assign(block, lvalue, rvalue);
+ }
+ StatementKind::Drop(_, ref $($mutability)* lvalue) => {
+ self.visit_lvalue(lvalue, LvalueContext::Drop);
+ }
+ }
}
- }
- }
-
- fn super_branch(&mut self, _source: BasicBlock, _target: BasicBlock) {
- }
-
- fn super_constant(&mut self, constant: &Constant<'tcx>) {
- self.visit_span(constant.span);
- self.visit_literal(&constant.literal);
- }
- fn super_literal(&mut self, literal: &Literal<'tcx>) {
- match *literal {
- Literal::Item { def_id, .. } => {
- self.visit_def_id(def_id);
- },
- Literal::Value { .. } => {
- // Nothing to do
+ fn super_assign(&mut self,
+ _block: BasicBlock,
+ lvalue: &$($mutability)* Lvalue<'tcx>,
+ rvalue: &$($mutability)* Rvalue<'tcx>) {
+ self.visit_lvalue(lvalue, LvalueContext::Store);
+ self.visit_rvalue(rvalue);
}
- }
- }
-
- fn super_def_id(&mut self, _def_id: DefId) {
- }
-
- fn super_span(&mut self, _span: Span) {
- }
-}
-
-#[derive(Copy, Clone, Debug)]
-pub enum LvalueContext {
- // Appears as LHS of an assignment or as dest of a call
- Store,
-
- // Being dropped
- Drop,
-
- // Being inspected in some way, like loading a len
- Inspect,
-
- // Being borrowed
- Borrow { region: Region, kind: BorrowKind },
-
- // Being sliced -- this should be same as being borrowed, probably
- Slice { from_start: usize, from_end: usize },
-
- // Used as base for another lvalue, e.g. `x` in `x.y`
- Projection,
-
- // Consumed as part of an operand
- Consume,
-}
-
-pub trait MutVisitor<'tcx> {
- // Override these, and call `self.super_xxx` to revert back to the
- // default behavior.
-
- fn visit_mir(&mut self, mir: &mut Mir<'tcx>) {
- self.super_mir(mir);
- }
-
- fn visit_basic_block_data(&mut self,
- block: BasicBlock,
- data: &mut BasicBlockData<'tcx>) {
- self.super_basic_block_data(block, data);
- }
- fn visit_statement(&mut self,
- block: BasicBlock,
- statement: &mut Statement<'tcx>) {
- self.super_statement(block, statement);
- }
-
- fn visit_assign(&mut self,
- block: BasicBlock,
- lvalue: &mut Lvalue<'tcx>,
- rvalue: &mut Rvalue<'tcx>) {
- self.super_assign(block, lvalue, rvalue);
- }
-
- fn visit_terminator(&mut self,
- block: BasicBlock,
- terminator: &mut Terminator<'tcx>) {
- self.super_terminator(block, terminator);
- }
-
- fn visit_rvalue(&mut self, rvalue: &mut Rvalue<'tcx>) {
- self.super_rvalue(rvalue);
- }
+ fn super_terminator(&mut self,
+ block: BasicBlock,
+ terminator: &$($mutability)* Terminator<'tcx>) {
+ match *terminator {
+ Terminator::Goto { target } => {
+ self.visit_branch(block, target);
+ }
- fn visit_operand(&mut self, operand: &mut Operand<'tcx>) {
- self.super_operand(operand);
- }
+ Terminator::If { ref $($mutability)* cond,
+ ref $($mutability)* targets } => {
+ self.visit_operand(cond);
+ for &target in targets.as_slice() {
+ self.visit_branch(block, target);
+ }
+ }
- fn visit_lvalue(&mut self,
- lvalue: &mut Lvalue<'tcx>,
- context: LvalueContext) {
- self.super_lvalue(lvalue, context);
- }
+ Terminator::Switch { ref $($mutability)* discr,
+ adt_def: _,
+ ref targets } => {
+ self.visit_lvalue(discr, LvalueContext::Inspect);
+ for &target in targets {
+ self.visit_branch(block, target);
+ }
+ }
- fn visit_branch(&mut self, source: BasicBlock, target: BasicBlock) {
- self.super_branch(source, target);
- }
+ Terminator::SwitchInt { ref $($mutability)* discr,
+ switch_ty: _,
+ values: _,
+ ref targets } => {
+ self.visit_lvalue(discr, LvalueContext::Inspect);
+ for &target in targets {
+ self.visit_branch(block, target);
+ }
+ }
- fn visit_constant(&mut self, constant: &mut Constant<'tcx>) {
- self.super_constant(constant);
- }
+ Terminator::Resume |
+ Terminator::Return => {
+ }
- fn visit_literal(&mut self, literal: &mut Literal<'tcx>) {
- self.super_literal(literal);
- }
+ Terminator::Call { ref $($mutability)* func,
+ ref $($mutability)* args,
+ ref $($mutability)* kind } => {
+ self.visit_operand(func);
+ for arg in args {
+ self.visit_operand(arg);
+ }
+ match *kind {
+ CallKind::Converging {
+ ref $($mutability)* destination,
+ ..
+ } |
+ CallKind::ConvergingCleanup {
+ ref $($mutability)* destination,
+ ..
+ } => {
+ self.visit_lvalue(destination, LvalueContext::Store);
+ }
+ CallKind::Diverging |
+ CallKind::DivergingCleanup(_) => {}
+ }
+ for &target in kind.successors() {
+ self.visit_branch(block, target);
+ }
+ }
+ }
+ }
- fn visit_def_id(&mut self, def_id: &mut DefId) {
- self.super_def_id(def_id);
- }
+ fn super_rvalue(&mut self,
+ rvalue: & $($mutability)* Rvalue<'tcx>) {
+ match *rvalue {
+ Rvalue::Use(ref $($mutability)* operand) => {
+ self.visit_operand(operand);
+ }
- fn visit_span(&mut self, span: &mut Span) {
- self.super_span(span);
- }
+ Rvalue::Repeat(ref $($mutability)* value,
+ ref $($mutability)* len) => {
+ self.visit_operand(value);
+ self.visit_constant(len);
+ }
- // The `super_xxx` methods comprise the default behavior and are
- // not meant to be overidden.
+ Rvalue::Ref(r, bk, ref $($mutability)* path) => {
+ self.visit_lvalue(path, LvalueContext::Borrow {
+ region: r,
+ kind: bk
+ });
+ }
- fn super_mir(&mut self, mir: &mut Mir<'tcx>) {
- for block in mir.all_basic_blocks() {
- let data = mir.basic_block_data_mut(block);
- self.visit_basic_block_data(block, data);
- }
- }
+ Rvalue::Len(ref $($mutability)* path) => {
+ self.visit_lvalue(path, LvalueContext::Inspect);
+ }
- fn super_basic_block_data(&mut self,
- block: BasicBlock,
- data: &mut BasicBlockData<'tcx>) {
- for statement in &mut data.statements {
- self.visit_statement(block, statement);
- }
- data.terminator.as_mut().map(|r| self.visit_terminator(block, r));
- }
+ Rvalue::Cast(_, ref $($mutability)* operand, _) => {
+ self.visit_operand(operand);
+ }
- fn super_statement(&mut self,
- block: BasicBlock,
- statement: &mut Statement<'tcx>) {
- self.visit_span(&mut statement.span);
+ Rvalue::BinaryOp(_,
+ ref $($mutability)* lhs,
+ ref $($mutability)* rhs) => {
+ self.visit_operand(lhs);
+ self.visit_operand(rhs);
+ }
- match statement.kind {
- StatementKind::Assign(ref mut lvalue, ref mut rvalue) => {
- self.visit_assign(block, lvalue, rvalue);
- }
- StatementKind::Drop(_, ref mut lvalue) => {
- self.visit_lvalue(lvalue, LvalueContext::Drop);
- }
- }
- }
+ Rvalue::UnaryOp(_, ref $($mutability)* op) => {
+ self.visit_operand(op);
+ }
- fn super_assign(&mut self,
- _block: BasicBlock,
- lvalue: &mut Lvalue<'tcx>,
- rvalue: &mut Rvalue<'tcx>) {
- self.visit_lvalue(lvalue, LvalueContext::Store);
- self.visit_rvalue(rvalue);
- }
+ Rvalue::Box(_) => {
+ }
- fn super_terminator(&mut self,
- block: BasicBlock,
- terminator: &mut Terminator<'tcx>) {
- match *terminator {
- Terminator::Goto { target } => {
- self.visit_branch(block, target);
- }
+ Rvalue::Aggregate(ref $($mutability)* kind,
+ ref $($mutability)* operands) => {
+ match *kind {
+ AggregateKind::Closure(ref $($mutability)* def_id, _) => {
+ self.visit_def_id(def_id);
+ }
+ _ => { /* nothing to do */ }
+ }
+
+ for operand in & $($mutability)* operands[..] {
+ self.visit_operand(operand);
+ }
+ }
- Terminator::If { ref mut cond, ref mut targets } => {
- self.visit_operand(cond);
- for &target in targets.as_slice() {
- self.visit_branch(block, target);
- }
- }
+ Rvalue::Slice { ref $($mutability)* input,
+ from_start,
+ from_end } => {
+ self.visit_lvalue(input, LvalueContext::Slice {
+ from_start: from_start,
+ from_end: from_end,
+ });
+ }
- Terminator::Switch { ref mut discr, adt_def: _, ref targets } => {
- self.visit_lvalue(discr, LvalueContext::Inspect);
- for &target in targets {
- self.visit_branch(block, target);
+ Rvalue::InlineAsm(_) => {
+ }
}
}
- Terminator::SwitchInt { ref mut discr, switch_ty: _, values: _, ref targets } => {
- self.visit_lvalue(discr, LvalueContext::Inspect);
- for &target in targets {
- self.visit_branch(block, target);
+ fn super_operand(&mut self,
+ operand: & $($mutability)* Operand<'tcx>) {
+ match *operand {
+ Operand::Consume(ref $($mutability)* lvalue) => {
+ self.visit_lvalue(lvalue, LvalueContext::Consume);
+ }
+ Operand::Constant(ref $($mutability)* constant) => {
+ self.visit_constant(constant);
+ }
}
}
- Terminator::Resume |
- Terminator::Return => {
- }
-
- Terminator::Call { ref mut func, ref mut args, ref mut kind } => {
- if let Some(ref mut destination) = kind.destination() {
- self.visit_lvalue(destination, LvalueContext::Store);
- }
- self.visit_operand(func);
- for arg in args {
- self.visit_operand(arg);
- }
- for &target in kind.successors() {
- self.visit_branch(block, target);
+ fn super_lvalue(&mut self,
+ lvalue: & $($mutability)* Lvalue<'tcx>,
+ _context: LvalueContext) {
+ match *lvalue {
+ Lvalue::Var(_) |
+ Lvalue::Temp(_) |
+ Lvalue::Arg(_) |
+ Lvalue::ReturnPointer => {
+ }
+ Lvalue::Static(ref $($mutability)* def_id) => {
+ self.visit_def_id(def_id);
+ }
+ Lvalue::Projection(ref $($mutability)* proj) => {
+ self.visit_lvalue(& $($mutability)* proj.base,
+ LvalueContext::Projection);
+ }
}
}
- }
- }
-
- fn super_rvalue(&mut self, rvalue: &mut Rvalue<'tcx>) {
- match *rvalue {
- Rvalue::Use(ref mut operand) => {
- self.visit_operand(operand);
- }
-
- Rvalue::Repeat(ref mut value, ref mut len) => {
- self.visit_operand(value);
- self.visit_constant(len);
- }
-
- Rvalue::Ref(r, bk, ref mut path) => {
- self.visit_lvalue(path, LvalueContext::Borrow {
- region: r,
- kind: bk
- });
- }
-
- Rvalue::Len(ref mut path) => {
- self.visit_lvalue(path, LvalueContext::Inspect);
- }
-
- Rvalue::Cast(_, ref mut operand, _) => {
- self.visit_operand(operand);
- }
-
- Rvalue::BinaryOp(_, ref mut lhs, ref mut rhs) => {
- self.visit_operand(lhs);
- self.visit_operand(rhs);
- }
- Rvalue::UnaryOp(_, ref mut op) => {
- self.visit_operand(op);
+ fn super_branch(&mut self,
+ _source: BasicBlock,
+ _target: BasicBlock) {
}
- Rvalue::Box(_) => {
+ fn super_constant(&mut self,
+ constant: & $($mutability)* Constant<'tcx>) {
+ self.visit_span(& $($mutability)* constant.span);
+ self.visit_literal(& $($mutability)* constant.literal);
}
- Rvalue::Aggregate(ref mut kind, ref mut operands) => {
- match *kind {
- AggregateKind::Closure(ref mut def_id, _) => {
+ fn super_literal(&mut self,
+ literal: & $($mutability)* Literal<'tcx>) {
+ match *literal {
+ Literal::Item { ref $($mutability)* def_id, .. } => {
self.visit_def_id(def_id);
+ },
+ Literal::Value { .. } => {
+ // Nothing to do
}
- _ => { /* nothing to do */ }
- }
-
- for operand in &mut operands[..] {
- self.visit_operand(operand);
}
}
- Rvalue::Slice { ref mut input, from_start, from_end } => {
- self.visit_lvalue(input, LvalueContext::Slice {
- from_start: from_start,
- from_end: from_end,
- });
+ fn super_def_id(&mut self, _def_id: & $($mutability)* DefId) {
}
- Rvalue::InlineAsm(_) => {
+ fn super_span(&mut self, _span: & $($mutability)* Span) {
}
}
}
+}
- fn super_operand(&mut self, operand: &mut Operand<'tcx>) {
- match *operand {
- Operand::Consume(ref mut lvalue) => {
- self.visit_lvalue(lvalue, LvalueContext::Consume);
- }
- Operand::Constant(ref mut constant) => {
- self.visit_constant(constant);
- }
- }
- }
+make_mir_visitor!(Visitor,);
+make_mir_visitor!(MutVisitor,mut);
- fn super_lvalue(&mut self,
- lvalue: &mut Lvalue<'tcx>,
- _context: LvalueContext) {
- match *lvalue {
- Lvalue::Var(_) |
- Lvalue::Temp(_) |
- Lvalue::Arg(_) |
- Lvalue::ReturnPointer => {
- }
- Lvalue::Static(ref mut def_id) => {
- self.visit_def_id(def_id);
- }
- Lvalue::Projection(ref mut proj) => {
- self.visit_lvalue(&mut proj.base, LvalueContext::Projection);
- }
- }
- }
+#[derive(Copy, Clone, Debug)]
+pub enum LvalueContext {
+ // Appears as LHS of an assignment or as dest of a call
+ Store,
- fn super_branch(&mut self, _source: BasicBlock, _target: BasicBlock) {
- }
+ // Being dropped
+ Drop,
- fn super_constant(&mut self, constant: &mut Constant<'tcx>) {
- self.visit_span(&mut constant.span);
- self.visit_literal(&mut constant.literal);
- }
+ // Being inspected in some way, like loading a len
+ Inspect,
- fn super_literal(&mut self, literal: &mut Literal<'tcx>) {
- match *literal {
- Literal::Item { ref mut def_id, .. } => {
- self.visit_def_id(def_id);
- },
- Literal::Value { .. } => {
- // Nothing to do
- }
- }
- }
+ // Being borrowed
+ Borrow { region: Region, kind: BorrowKind },
- fn super_def_id(&mut self, _def_id: &mut DefId) {
- }
+ // Being sliced -- this should be same as being borrowed, probably
+ Slice { from_start: usize, from_end: usize },
- fn super_span(&mut self, _span: &mut Span) {
- }
+ // Used as base for another lvalue, e.g. `x` in `x.y`
+ Projection,
+
+ // Consumed as part of an operand
+ Consume,
}
#![feature(staged_api)]
#![feature(str_char)]
+#[macro_use]
extern crate syntax;
#[macro_use]
extern crate rustc;
UNUSED_UNSAFE, PATH_STATEMENTS, UNUSED_ATTRIBUTES);
add_lint_group!(sess, FUTURE_INCOMPATIBLE,
- PRIVATE_IN_PUBLIC, INVALID_TYPE_PARAM_DEFAULT);
+ PRIVATE_IN_PUBLIC, INVALID_TYPE_PARAM_DEFAULT,
+ MATCH_OF_UNIT_VARIANT_VIA_PAREN_DOTDOT);
// We have one lint pass defined specially
store.register_late_pass(sess, false, box lint::GatherNodeLevels);
store.register_renamed("unknown_features", "unused_features");
store.register_removed("unsigned_negation", "replaced by negate_unsigned feature gate");
+ store.register_removed("negate_unsigned", "cast a signed value instead");
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#![allow(non_snake_case)]
+
use middle::{infer};
use middle::def_id::DefId;
use middle::subst::Substs;
use syntax::{abi, ast};
use syntax::attr::{self, AttrMetaMethods};
use syntax::codemap::{self, Span};
-use syntax::feature_gate::{emit_feature_err, GateIssue};
use syntax::ast::{TyIs, TyUs, TyI8, TyU8, TyI16, TyU16, TyI32, TyU32, TyI64, TyU64};
use rustc_front::hir;
use rustc_front::intravisit::{self, Visitor};
use rustc_front::util::is_shift_binop;
+register_long_diagnostics! {
+E0519: r##"
+It is not allowed to negate an unsigned integer.
+You can negate a signed integer and cast it to an
+unsigned integer or use the `!` operator.
+
+```
+let x: usize = -1isize as usize;
+let y: usize = !0;
+assert_eq!(x, y);
+```
+
+Alternatively you can use the `Wrapping` newtype
+or the `wrapping_neg` operation that all
+integral types support:
+
+```
+use std::num::Wrapping;
+let x: Wrapping<usize> = -Wrapping(1);
+let Wrapping(x) = x;
+let y: usize = 1.wrapping_neg();
+assert_eq!(x, y);
+```
+
+"##
+}
+
declare_lint! {
UNUSED_COMPARISONS,
Warn,
fn check_expr(&mut self, cx: &LateContext, e: &hir::Expr) {
match e.node {
hir::ExprUnary(hir::UnNeg, ref expr) => {
- match expr.node {
- hir::ExprLit(ref lit) => {
- match lit.node {
- ast::LitInt(_, ast::UnsignedIntLit(_)) => {
- check_unsigned_negation_feature(cx, e.span);
- },
- ast::LitInt(_, ast::UnsuffixedIntLit(_)) => {
- if let ty::TyUint(_) = cx.tcx.node_id_to_type(e.id).sty {
- check_unsigned_negation_feature(cx, e.span);
- }
- },
- _ => ()
- }
- },
- _ => {
- let t = cx.tcx.node_id_to_type(expr.id);
- match t.sty {
- ty::TyUint(_) => {
- check_unsigned_negation_feature(cx, e.span);
- },
- _ => ()
- }
+ if let hir::ExprLit(ref lit) = expr.node {
+ match lit.node {
+ ast::LitInt(_, ast::UnsignedIntLit(_)) => {
+ forbid_unsigned_negation(cx, e.span);
+ },
+ ast::LitInt(_, ast::UnsuffixedIntLit(_)) => {
+ if let ty::TyUint(_) = cx.tcx.node_id_to_type(e.id).sty {
+ forbid_unsigned_negation(cx, e.span);
+ }
+ },
+ _ => ()
}
- };
+ } else {
+ let t = cx.tcx.node_id_to_type(expr.id);
+ if let ty::TyUint(_) = t.sty {
+ forbid_unsigned_negation(cx, e.span);
+ }
+ }
// propagate negation, if the negation itself isn't negated
if self.negated_expr_id != e.id {
self.negated_expr_id = expr.id;
}
}
- fn check_unsigned_negation_feature(cx: &LateContext, span: Span) {
- if !cx.sess().features.borrow().negate_unsigned {
- emit_feature_err(
- &cx.sess().parse_sess.span_diagnostic,
- "negate_unsigned",
- span,
- GateIssue::Language,
- "unary negation of unsigned integers may be removed in the future");
- }
+ fn forbid_unsigned_negation(cx: &LateContext, span: Span) {
+ cx.sess()
+ .struct_span_err_with_code(span, "unary negation of unsigned integer", "E0519")
+ .span_help(span, "use a cast or the `!` operator")
+ .emit();
}
}
}
}
// Terminator at the bottom.
- try!(writeln!(w, "{0}{0}{1:?};", INDENT, data.terminator));
+ try!(writeln!(w, "{0}{0}{1:?};", INDENT, data.terminator()));
writeln!(w, "{}}}", INDENT)
}
debug!("(build reduced graph for item) found extern `{}`",
module_to_string(&*external_module));
- self.check_for_conflicts_between_external_crates(&**parent, name, sp);
+ self.check_for_conflicts_for_external_crate(&parent, name, sp);
parent.external_module_children
.borrow_mut()
.insert(name, external_module.clone());
use rustc_front::hir;
use rustc_front::hir::{Arm, BindByRef, BindByValue, BindingMode, Block};
use rustc_front::hir::Crate;
-use rustc_front::hir::{Expr, ExprAgain, ExprBreak, ExprField};
+use rustc_front::hir::{Expr, ExprAgain, ExprBreak, ExprCall, ExprField};
use rustc_front::hir::{ExprLoop, ExprWhile, ExprMethodCall};
use rustc_front::hir::{ExprPath, ExprStruct, FnDecl};
use rustc_front::hir::{ForeignItemFn, ForeignItemStatic, Generics};
}
pub enum ResolutionError<'a> {
+ /// error E0260: name conflicts with an extern crate
+ NameConflictsWithExternCrate(Name),
/// error E0401: can't use type parameters from outer function
TypeParametersFromOuterFunction,
/// error E0402: cannot use an outer type parameter in this context
}
match resolution_error {
+ ResolutionError::NameConflictsWithExternCrate(name) => {
+ struct_span_err!(resolver.session,
+ span,
+ E0260,
+ "the name `{}` conflicts with an external crate \
+ that has been imported into this module",
+ name)
+ }
ResolutionError::TypeParametersFromOuterFunction => {
struct_span_err!(resolver.session,
span,
msg);
match context {
- UnresolvedNameContext::Other => {} // no help available
+ UnresolvedNameContext::Other => { } // no help available
UnresolvedNameContext::PathIsMod(id) => {
let mut help_msg = String::new();
let parent_id = resolver.ast_map.get_parent_node(id);
module = &*path,
ident = ident.node);
}
-
ExprMethodCall(ident, _, _) => {
help_msg = format!("To call a function from the \
`{module}` module, use \
module = &*path,
ident = ident.node);
}
-
- _ => {} // no help available
+ ExprCall(_, _) => {
+ help_msg = format!("No function corresponds to `{module}(..)`",
+ module = &*path);
+ }
+ _ => { } // no help available
}
+ } else {
+ help_msg = format!("Module `{module}` cannot be the value of an expression",
+ module = &*path);
}
if !help_msg.is_empty() {
}
}
- /// Checks that the names of external crates don't collide with other
- /// external crates.
- fn check_for_conflicts_between_external_crates(&self,
- module: &Module,
- name: Name,
- span: Span) {
+ /// Check that an external crate doesn't collide with items or other external crates.
+ fn check_for_conflicts_for_external_crate(&self, module: &Module, name: Name, span: Span) {
if module.external_module_children.borrow().contains_key(&name) {
span_err!(self.session,
span,
"an external crate named `{}` has already been imported into this module",
name);
}
+ match module.children.borrow().get(&name) {
+ Some(name_bindings) if name_bindings.type_ns.defined() => {
+ resolve_error(self,
+ name_bindings.type_ns.span().unwrap_or(codemap::DUMMY_SP),
+ ResolutionError::NameConflictsWithExternCrate(name));
+ }
+ _ => {},
+ }
}
/// Checks that the names of items don't collide with external crates.
name: Name,
span: Span) {
if module.external_module_children.borrow().contains_key(&name) {
- span_err!(self.session,
- span,
- E0260,
- "the name `{}` conflicts with an external crate that has been imported \
- into this module",
- name);
+ resolve_error(self, span, ResolutionError::NameConflictsWithExternCrate(name));
}
}
use check::{check_expr_coercable_to_type, demand, FnCtxt, Expectation};
use check::{check_expr_with_lvalue_pref};
use check::{instantiate_path, resolve_ty_and_def_ufcs, structurally_resolved_type};
+use lint;
use require_same_types;
use util::nodemap::FnvHashMap;
use session::Session;
if pat_is_resolved_const(&tcx.def_map.borrow(), pat) => {
if let hir::PatEnum(ref path, ref subpats) = pat.node {
if !(subpats.is_some() && subpats.as_ref().unwrap().is_empty()) {
- bad_struct_kind_err(tcx.sess, pat.span, path, false);
+ bad_struct_kind_err(tcx.sess, pat, path, false);
return;
}
}
}
// This function exists due to the warning "diagnostic code E0164 already used"
-fn bad_struct_kind_err(sess: &Session, span: Span, path: &hir::Path, is_warning: bool) {
+fn bad_struct_kind_err(sess: &Session, pat: &hir::Pat, path: &hir::Path, lint: bool) {
let name = pprust::path_to_string(path);
- span_err_or_warn!(is_warning, sess, span, E0164,
- "`{}` does not name a tuple variant or a tuple struct", name);
+ let msg = format!("`{}` does not name a tuple variant or a tuple struct", name);
+ if lint {
+ let expanded_msg =
+ format!("{}; RFC 218 disallowed matching of unit variants or unit structs via {}(..)",
+ msg,
+ name);
+ sess.add_lint(lint::builtin::MATCH_OF_UNIT_VARIANT_VIA_PAREN_DOTDOT,
+ pat.id,
+ pat.span,
+ expanded_msg);
+ } else {
+ span_err!(sess, pat.span, E0164, "{}", msg);
+ }
}
pub fn check_pat_enum<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>,
opt_ty, def, pat.span, pat.id);
let report_bad_struct_kind = |is_warning| {
- bad_struct_kind_err(tcx.sess, pat.span, path, is_warning);
- if is_warning {
- return;
- }
-
+ bad_struct_kind_err(tcx.sess, pat, path, is_warning);
+ if is_warning { return; }
fcx.write_error(pat.id);
if let Some(subpats) = subpats {
for pat in subpats {
report_bad_struct_kind(is_special_case);
if !is_special_case {
return
- } else {
- // Boo! Too painful to attach this to the actual warning,
- // it should go away at some point though.
- tcx.sess.span_note_without_error(pat.span,
- "this warning will become a HARD ERROR in a future release. \
- See RFC 218 for details.");
}
}
(variant.fields
ty::TyStruct(struct_def, expected_substs) => {
let variant = struct_def.struct_variant();
if is_tuple_struct_pat && variant.kind() != ty::VariantKind::Tuple {
- report_bad_struct_kind(false);
+ // Matching unit structs with tuple variant patterns (`UnitVariant(..)`)
+ // is allowed for backward compatibility.
+ let is_special_case = variant.kind() == ty::VariantKind::Unit;
+ report_bad_struct_kind(is_special_case);
return;
}
(variant.fields
use middle::ty::adjustment::{AutoPtr, AutoUnsafe, AdjustReifyFnPointer};
use middle::ty::adjustment::{AdjustUnsafeFnPointer};
use middle::ty::{self, LvaluePreference, TypeAndMut, Ty};
+use middle::ty::fold::TypeFoldable;
use middle::ty::error::TypeError;
use middle::ty::relate::RelateResult;
use util::common::indent;
a,
b);
+ let a = self.fcx.infcx().shallow_resolve(a);
+
+ // Just ignore error types.
+ if a.references_error() || b.references_error() {
+ return Ok(None);
+ }
+
// Consider coercing the subtype to a DST
- let unsize = self.unpack_actual_value(a, |a| {
- self.coerce_unsized(a, b)
- });
+ let unsize = self.coerce_unsized(a, b);
if unsize.is_ok() {
return unsize;
}
// See above for details.
match b.sty {
ty::TyRawPtr(mt_b) => {
- return self.unpack_actual_value(a, |a| {
- self.coerce_unsafe_ptr(a, b, mt_b.mutbl)
- });
+ return self.coerce_unsafe_ptr(a, b, mt_b.mutbl);
}
ty::TyRef(_, mt_b) => {
- return self.unpack_actual_value(a, |a| {
- self.coerce_borrowed_pointer(expr_a, a, b, mt_b.mutbl)
- });
+ return self.coerce_borrowed_pointer(expr_a, a, b, mt_b.mutbl);
}
_ => {}
}
- self.unpack_actual_value(a, |a| {
- match a.sty {
- ty::TyBareFn(Some(_), a_f) => {
- // Function items are coercible to any closure
- // type; function pointers are not (that would
- // require double indirection).
- self.coerce_from_fn_item(a, a_f, b)
- }
- ty::TyBareFn(None, a_f) => {
- // We permit coercion of fn pointers to drop the
- // unsafe qualifier.
- self.coerce_from_fn_pointer(a, a_f, b)
- }
- _ => {
- // Otherwise, just use subtyping rules.
- self.subtype(a, b)
- }
+ match a.sty {
+ ty::TyBareFn(Some(_), a_f) => {
+ // Function items are coercible to any closure
+ // type; function pointers are not (that would
+ // require double indirection).
+ self.coerce_from_fn_item(a, a_f, b)
}
- })
+ ty::TyBareFn(None, a_f) => {
+ // We permit coercion of fn pointers to drop the
+ // unsafe qualifier.
+ self.coerce_from_fn_pointer(a, a_f, b)
+ }
+ _ => {
+ // Otherwise, just use subtyping rules.
+ self.subtype(a, b)
+ }
+ }
}
/// Reborrows `&mut A` to `&mut B` and `&(mut) A` to `&B`.
t_cast: Ty<'tcx>,
t_expr: Ty<'tcx>,
id: ast::NodeId) {
+ if t_cast.references_error() || t_expr.references_error() {
+ return;
+ }
let tstr = fcx.infcx().ty_to_string(t_cast);
let mut err = fcx.type_error_struct(span, |actual| {
format!("cast to unsized type: `{}` as `{}`", actual, tstr)
let t_cast = structurally_resolved_type(fcx, expr.span, t_cast);
check_expr_with_expectation(fcx, e, ExpectCastableToType(t_cast));
let t_expr = fcx.expr_ty(e);
+ let t_cast = fcx.infcx().resolve_type_vars_if_possible(&t_cast);
// Eagerly check for some obvious errors.
- if t_expr.references_error() {
+ if t_expr.references_error() || t_cast.references_error() {
fcx.write_error(id);
} else if !fcx.type_is_known_to_be_sized(t_cast, expr.span) {
report_cast_to_unsized_type(fcx, expr.span, t.span, e.span, t_cast, t_expr, id);
trait_ref,
item.name);
+ // Skip impls where one of the self type is an error type.
+ // This occurs with e.g. resolve failures (#30589).
+ if trait_ref.references_error() {
+ return;
+ }
+
enforce_trait_manually_implementable(self.crate_context.tcx,
item.span,
trait_ref.def_id);
self.add_trait_impl(trait_ref, impl_did);
} else {
+ // Skip inherent impls where the self type is an error
+ // type. This occurs with e.g. resolve failures (#30589).
+ if self_type.ty.references_error() {
+ return;
+ }
+
// Add the implementation to the mapping from implementation to base
// type def ID, if there is a base type for this implementation and
// the implementation does not have any associated traits.
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-//! A type that can represent all platform-native strings, but is cheaply
-//! interconvertable with Rust strings.
-//!
-//! The need for this type arises from the fact that:
-//!
-//! * On Unix systems, strings are often arbitrary sequences of non-zero
-//! bytes, in many cases interpreted as UTF-8.
-//!
-//! * On Windows, strings are often arbitrary sequences of non-zero 16-bit
-//! values, interpreted as UTF-16 when it is valid to do so.
-//!
-//! * In Rust, strings are always valid UTF-8, but may contain zeros.
-//!
-//! The types in this module bridge this gap by simultaneously representing Rust
-//! and platform-native string values, and in particular allowing a Rust string
-//! to be converted into an "OS" string with no cost.
-//!
-//! **Note**: At the moment, these types are extremely bare-bones, usable only
-//! for conversion to/from various other string types. Eventually these types
-//! will offer a full-fledged string API.
-
use borrow::{Borrow, Cow, ToOwned};
use ffi::CString;
use fmt::{self, Debug};
use sys::os_str::{Buf, Slice};
use sys_common::{AsInner, IntoInner, FromInner};
-/// Owned, mutable OS strings.
+/// A type that can represent owned, mutable platform-native strings, but is
+/// cheaply interconvertable with Rust strings.
+///
+/// The need for this type arises from the fact that:
+///
+/// * On Unix systems, strings are often arbitrary sequences of non-zero
+/// bytes, in many cases interpreted as UTF-8.
+///
+/// * On Windows, strings are often arbitrary sequences of non-zero 16-bit
+/// values, interpreted as UTF-16 when it is valid to do so.
+///
+/// * In Rust, strings are always valid UTF-8, but may contain zeros.
+///
+/// `OsString` and `OsStr` bridge this gap by simultaneously representing Rust
+/// and platform-native string values, and in particular allowing a Rust string
+/// to be converted into an "OS" string with no cost.
#[derive(Clone)]
#[stable(feature = "rust1", since = "1.0.0")]
pub struct OsString {
inner: Buf
}
-/// Slices into OS strings.
+/// Slices into OS strings (see `OsString`).
#[stable(feature = "rust1", since = "1.0.0")]
pub struct OsStr {
inner: Slice
unsafe { libc::_exit(1) }
}
+ // Make sure that the source descriptors are not an stdio descriptor,
+ // otherwise the order which we set the child's descriptors may blow
+ // away a descriptor which we are hoping to save. For example,
+ // suppose we want the child's stderr to be the parent's stdout, and
+ // the child's stdout to be the parent's stderr. No matter which we
+ // dup first, the second will get overwritten prematurely.
+ let maybe_migrate = |src: Stdio, output: &mut AnonPipe| {
+ match src {
+ Stdio::Raw(fd @ libc::STDIN_FILENO) |
+ Stdio::Raw(fd @ libc::STDOUT_FILENO) |
+ Stdio::Raw(fd @ libc::STDERR_FILENO) => {
+ let fd = match cvt_r(|| libc::dup(fd)) {
+ Ok(fd) => fd,
+ Err(_) => fail(output),
+ };
+ let fd = FileDesc::new(fd);
+ fd.set_cloexec();
+ Stdio::Raw(fd.into_raw())
+ },
+
+ s @ Stdio::None |
+ s @ Stdio::Inherit |
+ s @ Stdio::Raw(_) => s,
+ }
+ };
+
let setup = |src: Stdio, dst: c_int| {
match src {
Stdio::Inherit => true,
}
};
+ // Make sure we migrate all source descriptors before
+ // we start overwriting them
+ let in_fd = maybe_migrate(in_fd, &mut output);
+ let out_fd = maybe_migrate(out_fd, &mut output);
+ let err_fd = maybe_migrate(err_fd, &mut output);
+
if !setup(in_fd, libc::STDIN_FILENO) { fail(&mut output) }
if !setup(out_fd, libc::STDOUT_FILENO) { fail(&mut output) }
if !setup(err_fd, libc::STDERR_FILENO) { fail(&mut output) }
("slice_patterns", "1.0.0", Some(23121), Active),
// Allows use of unary negate on unsigned integers, e.g. -e for e: u8
- ("negate_unsigned", "1.0.0", Some(29645), Active),
+ ("negate_unsigned", "1.0.0", Some(29645), Removed),
// Allows the definition of associated constants in `trait` or `impl`
// blocks.
pub allow_pushpop_unsafe: bool,
pub simd_ffi: bool,
pub unmarked_api: bool,
- pub negate_unsigned: bool,
/// spans of #![feature] attrs for stable language features. for error reporting
pub declared_stable_lang_features: Vec<Span>,
/// #![feature] attrs for non-language (library) features
allow_pushpop_unsafe: false,
simd_ffi: false,
unmarked_api: false,
- negate_unsigned: false,
declared_stable_lang_features: Vec::new(),
declared_lib_features: Vec::new(),
const_fn: false,
allow_pushpop_unsafe: cx.has_feature("pushpop_unsafe"),
simd_ffi: cx.has_feature("simd_ffi"),
unmarked_api: cx.has_feature("unmarked_api"),
- negate_unsigned: cx.has_feature("negate_unsigned"),
declared_stable_lang_features: accepted_features,
declared_lib_features: unknown_features,
const_fn: cx.has_feature("const_fn"),
--- /dev/null
+// Copyright 2016 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(rustc_attrs)]
+
+// Here we expect a coherence conflict because, even though `i32` does
+// not implement `Iterator`, we cannot rely on that negative reasoning
+// due to the orphan rules. Therefore, `A::Item` may yet turn out to
+// be `i32`.
+
+pub trait Foo<P> {}
+
+pub trait Bar {
+ type Output: 'static;
+}
+
+impl Foo<i32> for i32 { } //~ ERROR E0119
+
+impl<A:Iterator> Foo<A::Item> for A { }
+
+fn main() {}
--- /dev/null
+// Copyright 2016 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.
+
+// Coherence error results because we do not know whether `T: Foo<P>` or not
+// for the second impl.
+
+use std::marker::PhantomData;
+
+pub trait Foo<P> {}
+
+impl <P, T: Foo<P>> Foo<P> for Option<T> {} //~ ERROR E0119
+
+impl<T, U> Foo<T> for Option<U> { }
+
+fn main() {}
--- /dev/null
+// Copyright 2016 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::marker::PhantomData;
+
+pub trait Foo<P> {}
+
+pub trait Bar {
+ type Output: 'static;
+}
+
+impl Foo<i32> for i32 { } //~ ERROR E0119
+
+impl<A:Bar> Foo<A::Output> for A { }
+
+impl Bar for i32 {
+ type Output = i32;
+}
+
+fn main() {}
--- /dev/null
+// Copyright 2016 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(rustc_attrs)]
+#![allow(dead_code)]
+
+// Here we do not get a coherence conflict because `Baz: Iterator`
+// does not hold and (due to the orphan rules), we can rely on that.
+
+pub trait Foo<P> {}
+
+pub trait Bar {
+ type Output: 'static;
+}
+
+struct Baz;
+impl Foo<i32> for Baz { }
+
+impl<A:Iterator> Foo<A::Item> for A { }
+
+#[rustc_error]
+fn main() {} //~ ERROR compilation successful
--- /dev/null
+// Copyright 2016 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(rustc_attrs)]
+
+pub trait Foo<P> {}
+
+pub trait Bar {
+ type Output: 'static;
+}
+
+impl Foo<i32> for i32 { }
+
+impl<A:Bar> Foo<A::Output> for A { }
+
+impl Bar for i32 {
+ type Output = u32;
+}
+
+#[rustc_error]
+fn main() {} //~ ERROR compilation successful
const A_I8_T
: [u32; (i8::MAX as i8 + 1u8) as usize]
//~^ ERROR mismatched types
- //~| the trait `core::ops::Add<u8>` is not implemented for the type `i8`
+ //~| ERROR the trait `core::ops::Add<u8>` is not implemented for the type `i8`
= [0; (i8::MAX as usize) + 1];
fn main() {
// except according to those terms.
#![allow(unused_imports)]
-#![feature(negate_unsigned)]
// Note: the relevant lint pass here runs before some of the constant
// evaluation below (e.g. that performed by trans and llvm), so if you
);
const VALS_U8: (u8, u8, u8, u8) =
- (-u8::MIN,
+ (-(u8::MIN as i8) as u8,
u8::MIN - 1,
//~^ ERROR attempted to sub with overflow
u8::MAX + 1,
);
const VALS_U16: (u16, u16, u16, u16) =
- (-u16::MIN,
+ (-(u16::MIN as i16) as u16,
u16::MIN - 1,
//~^ ERROR attempted to sub with overflow
u16::MAX + 1,
);
const VALS_U32: (u32, u32, u32, u32) =
- (-u32::MIN,
+ (-(u32::MIN as i32) as u32,
u32::MIN - 1,
//~^ ERROR attempted to sub with overflow
u32::MAX + 1,
);
const VALS_U64: (u64, u64, u64, u64) =
- (-u64::MIN,
+ (-(u64::MIN as i64) as u64,
u64::MIN - 1,
//~^ ERROR attempted to sub with overflow
u64::MAX + 1,
--- /dev/null
+// 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(unused_imports)]
+
+// Note: the relevant lint pass here runs before some of the constant
+// evaluation below (e.g. that performed by trans and llvm), so if you
+// change this warn to a deny, then the compiler will exit before
+// those errors are detected.
+
+use std::fmt;
+use std::{i8, i16, i32, i64, isize};
+use std::{u8, u16, u32, u64, usize};
+
+const VALS_I8: (i8, i8, i8, i8) =
+ (-i8::MIN,
+ i8::MIN - 1,
+ i8::MAX + 1,
+ i8::MIN * 2,
+ );
+
+const VALS_I16: (i16, i16, i16, i16) =
+ (-i16::MIN,
+ i16::MIN - 1,
+ i16::MAX + 1,
+ i16::MIN * 2,
+ );
+
+const VALS_I32: (i32, i32, i32, i32) =
+ (-i32::MIN,
+ i32::MIN - 1,
+ i32::MAX + 1,
+ i32::MIN * 2,
+ );
+
+const VALS_I64: (i64, i64, i64, i64) =
+ (-i64::MIN,
+ i64::MIN - 1,
+ i64::MAX + 1,
+ i64::MAX * 2,
+ );
+
+const VALS_U8: (u8, u8, u8, u8) =
+ (-u8::MIN,
+ //~^ ERROR unary negation of unsigned integer
+ //~| HELP use a cast or the `!` operator
+ u8::MIN - 1,
+ u8::MAX + 1,
+ u8::MAX * 2,
+ );
+
+const VALS_U16: (u16, u16, u16, u16) =
+ (-u16::MIN,
+ //~^ ERROR unary negation of unsigned integer
+ //~| HELP use a cast or the `!` operator
+ u16::MIN - 1,
+ u16::MAX + 1,
+ u16::MAX * 2,
+ );
+
+const VALS_U32: (u32, u32, u32, u32) =
+ (-u32::MIN,
+ //~^ ERROR unary negation of unsigned integer
+ //~| HELP use a cast or the `!` operator
+ u32::MIN - 1,
+ u32::MAX + 1,
+ u32::MAX * 2,
+ );
+
+const VALS_U64: (u64, u64, u64, u64) =
+ (-u64::MIN,
+ //~^ ERROR unary negation of unsigned integer
+ //~| HELP use a cast or the `!` operator
+ u64::MIN - 1,
+ u64::MAX + 1,
+ u64::MAX * 2,
+ );
+
+fn main() {
+ foo(VALS_I8);
+ foo(VALS_I16);
+ foo(VALS_I32);
+ foo(VALS_I64);
+
+ foo(VALS_U8);
+ foo(VALS_U16);
+ foo(VALS_U32);
+ foo(VALS_U64);
+}
+
+fn foo<T:fmt::Debug>(x: T) {
+ println!("{:?}", x);
+}
// Can't use unit struct as enum pattern
+#![feature(rustc_attrs)]
+// remove prior feature after warning cycle and promoting warnings to errors
#![feature(braced_empty_structs)]
struct Empty1;
Empty2
}
-fn main() {
+// remove attribute after warning cycle and promoting warnings to errors
+#[rustc_error]
+fn main() { //~ ERROR: compilation successful
let e1 = Empty1;
let e2 = E::Empty2;
// Empty1() => () // ERROR `Empty1` does not name a tuple variant or a tuple struct
// }
match e1 {
- Empty1(..) => () //~ ERROR `Empty1` does not name a tuple variant or a tuple struct
+ Empty1(..) => () //~ WARN `Empty1` does not name a tuple variant or a tuple struct
}
// Rejected by parser as yet
// match e2 {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-#![feature(negate_unsigned)]
#[repr(u8)] //~ NOTE discriminant type specified here
enum Eu8 {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// Test that negating unsigned integers is gated by `negate_unsigned` feature
-// gate
+// Test that negating unsigned integers doesn't compile
struct S;
impl std::ops::Neg for S {
}
const _MAX: usize = -1;
-//~^ ERROR unary negation of unsigned integers may be removed in the future
+//~^ ERROR unary negation of unsigned integer
+//~| HELP use a cast or the `!` operator
fn main() {
let a = -1;
- //~^ ERROR unary negation of unsigned integers may be removed in the future
+ //~^ ERROR unary negation of unsigned integer
+ //~| HELP use a cast or the `!` operator
let _b : u8 = a; // for infering variable a to u8.
-a;
- //~^ ERROR unary negation of unsigned integers may be removed in the future
+ //~^ ERROR unary negation of unsigned integer
+ //~| HELP use a cast or the `!` operator
let _d = -1u8;
- //~^ ERROR unary negation of unsigned integers may be removed in the future
+ //~^ ERROR unary negation of unsigned integer
+ //~| HELP use a cast or the `!` operator
for _ in -10..10u8 {}
- //~^ ERROR unary negation of unsigned integers may be removed in the future
+ //~^ ERROR unary negation of unsigned integer
+ //~| HELP use a cast or the `!` operator
-S; // should not trigger the gate; issue 26840
}
fn akemi(homura: Homura) {
let Some(ref madoka) = Some(homura.kaname()); //~ ERROR no method named `kaname` found
- madoka.clone(); //~ ERROR the type of this value must be known in this context
+ madoka.clone(); //~ ERROR the type of this value must be known
}
fn main() { }
let x = &10 as
&Add;
//~^ ERROR the type parameter `RHS` must be explicitly specified in an object type because its default value `Self` references the type `Self`
- //~^^ ERROR the value of the associated type `Output` (from the trait `core::ops::Add`) must be specified
+ //~| ERROR the value of the associated type `Output` (from the trait `core::ops::Add`) must be specified
}
// except according to those terms.
fn main() {
- "".chars().fold(|_, _| (), ()); //~ ERROR is not implemented for the type `()`
+ "".chars().fold(|_, _| (), ());
+ //~^ ERROR E0277
+ //~| ERROR E0277
}
fn main() {
1.0f64 - 1.0;
- 1.0f64 - 1 //~ ERROR: is not implemented
+ 1.0f64 - 1 //~ ERROR E0277
}
--- /dev/null
+// Copyright 2016 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(rustc_attrs)]
+
+use std::marker::PhantomData;
+
+pub trait Foo<P> {}
+
+impl <P, T: Foo<P>> Foo<P> for Option<T> {}
+
+pub struct Qux<T> (PhantomData<*mut T>);
+
+impl<T> Foo<*mut T> for Option<Qux<T>> {}
+
+pub trait Bar {
+ type Output: 'static;
+}
+
+impl<T: 'static, W: Bar<Output = T>> Foo<*mut T> for W {}
+
+#[rustc_error]
+fn main() {} //~ ERROR compilation successful
--- /dev/null
+// Copyright 2016 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::fmt;
+
+impl fmt::Display for DecoderError { //~ ERROR E0412
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ write!(f, "Missing data: {}", self.0)
+ }
+}
+fn main() {
+}
fn main() {
let p = Point::new(0.0, 0.0);
//~^ ERROR no associated item named `new` found for type `Point` in the current scope
- println!("{}", p.to_string());
- //~^ ERROR the type of this value must be known in this context
+ println!("{}", p.to_string()); //~ ERROR type of this value must be known
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-#![feature(negate_unsigned)]
#![allow(dead_code)]
-#![feature(negate_unsigned)]
// compile-flags: -D unused-comparisons
fn main() { }
color::cmyk(_, _, _, _) => { }
color::no_color(_) => { }
//~^ ERROR this pattern has 1 field, but the corresponding variant has no fields
- //~^^ WARN `color::no_color` does not name a tuple variant or a tuple struct
}
}
}
match A::B(1, 2) {
A::B(_, _, _) => (), //~ ERROR this pattern has 3 fields, but
A::D(_) => (), //~ ERROR this pattern has 1 field, but
- //~^ WARN `A::D` does not name a tuple variant or a tuple struct
_ => ()
}
match 'c' {
//~^ ERROR E0425
//~| HELP To call a function from the `a::b` module, use `a::b::f(..)`
}
+
+fn h7() {
+ a::b
+ //~^ ERROR E0425
+ //~| HELP Module `a::b` cannot be the value of an expression
+}
+
+fn h8() -> i32 {
+ a::b()
+ //~^ ERROR E0425
+ //~| HELP No function corresponds to `a::b(..)`
+}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-#![feature(negate_unsigned)]
-
#[cfg(any(target_arch = "x86", target_arch = "arm"))]
fn target() {
- assert_eq!(-1000 as usize >> 3_usize, 536870787_usize);
+ assert_eq!(-1000isize as usize >> 3_usize, 536870787_usize);
}
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))]
fn target() {
- assert_eq!(-1000 as usize >> 3_usize, 2305843009213693827_usize);
+ assert_eq!(-1000isize as usize >> 3_usize, 2305843009213693827_usize);
}
fn general() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-
-#![feature(negate_unsigned)]
#![feature(intrinsics)]
mod rusti {
assert_eq!(ctpop(100u32), 3); assert_eq!(ctpop(100i32), 3);
assert_eq!(ctpop(100u64), 3); assert_eq!(ctpop(100i64), 3);
- assert_eq!(ctpop(-1u8), 8); assert_eq!(ctpop(-1i8), 8);
- assert_eq!(ctpop(-1u16), 16); assert_eq!(ctpop(-1i16), 16);
- assert_eq!(ctpop(-1u32), 32); assert_eq!(ctpop(-1i32), 32);
- assert_eq!(ctpop(-1u64), 64); assert_eq!(ctpop(-1i64), 64);
+ assert_eq!(ctpop(-1i8 as u8), 8); assert_eq!(ctpop(-1i8), 8);
+ assert_eq!(ctpop(-1i16 as u16), 16); assert_eq!(ctpop(-1i16), 16);
+ assert_eq!(ctpop(-1i32 as u32), 32); assert_eq!(ctpop(-1i32), 32);
+ assert_eq!(ctpop(-1i64 as u64), 64); assert_eq!(ctpop(-1i64), 64);
assert_eq!(ctlz(0u8), 8); assert_eq!(ctlz(0i8), 8);
assert_eq!(ctlz(0u16), 16); assert_eq!(ctlz(0i16), 16);
assert_eq!(ctlz(100u32), 25); assert_eq!(ctlz(100i32), 25);
assert_eq!(ctlz(100u64), 57); assert_eq!(ctlz(100i64), 57);
- assert_eq!(cttz(-1u8), 0); assert_eq!(cttz(-1i8), 0);
- assert_eq!(cttz(-1u16), 0); assert_eq!(cttz(-1i16), 0);
- assert_eq!(cttz(-1u32), 0); assert_eq!(cttz(-1i32), 0);
- assert_eq!(cttz(-1u64), 0); assert_eq!(cttz(-1i64), 0);
+ assert_eq!(cttz(-1i8 as u8), 0); assert_eq!(cttz(-1i8), 0);
+ assert_eq!(cttz(-1i16 as u16), 0); assert_eq!(cttz(-1i16), 0);
+ assert_eq!(cttz(-1i32 as u32), 0); assert_eq!(cttz(-1i32), 0);
+ assert_eq!(cttz(-1i64 as u64), 0); assert_eq!(cttz(-1i64), 0);
assert_eq!(cttz(0u8), 8); assert_eq!(cttz(0i8), 8);
assert_eq!(cttz(0u16), 16); assert_eq!(cttz(0i16), 16);
--- /dev/null
+// 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.
+
+// Previously libstd would set stdio descriptors of a child process
+// by `dup`ing the requested descriptors to inherit directly into the
+// stdio descriptors. This, however, would incorrectly handle cases
+// where the descriptors to inherit were already stdio descriptors.
+// This test checks to avoid that regression.
+
+#![cfg_attr(unix, feature(libc))]
+#![cfg_attr(windows, allow(unused_imports))]
+
+#[cfg(unix)]
+extern crate libc;
+
+use std::fs::File;
+use std::io::{Read, Write};
+use std::io::{stdout, stderr};
+use std::process::{Command, Stdio};
+
+#[cfg(unix)]
+use std::os::unix::io::FromRawFd;
+
+#[cfg(not(unix))]
+fn main() {
+ // Bug not present in Windows
+}
+
+#[cfg(unix)]
+fn main() {
+ let mut args = std::env::args();
+ let name = args.next().unwrap();
+ let args: Vec<String> = args.collect();
+ if let Some("--child") = args.get(0).map(|s| &**s) {
+ return child();
+ } else if !args.is_empty() {
+ panic!("unknown options");
+ }
+
+ let stdout_backup = unsafe { libc::dup(libc::STDOUT_FILENO) };
+ let stderr_backup = unsafe { libc::dup(libc::STDERR_FILENO) };
+ assert!(stdout_backup > -1);
+ assert!(stderr_backup > -1);
+
+ let (stdout_reader, stdout_writer) = pipe();
+ let (stderr_reader, stderr_writer) = pipe();
+ assert!(unsafe { libc::dup2(stdout_writer, libc::STDOUT_FILENO) } > -1);
+ assert!(unsafe { libc::dup2(stderr_writer, libc::STDERR_FILENO) } > -1);
+
+ // Make sure we close any duplicates of the writer end of the pipe,
+ // otherwise we can get stuck reading from the pipe which has open
+ // writers but no one supplying any input
+ assert_eq!(unsafe { libc::close(stdout_writer) }, 0);
+ assert_eq!(unsafe { libc::close(stderr_writer) }, 0);
+
+ stdout().write_all("parent stdout\n".as_bytes()).expect("failed to write to stdout");
+ stderr().write_all("parent stderr\n".as_bytes()).expect("failed to write to stderr");
+
+ let child = {
+ Command::new(name)
+ .arg("--child")
+ .stdin(Stdio::inherit())
+ .stdout(unsafe { FromRawFd::from_raw_fd(libc::STDERR_FILENO) })
+ .stderr(unsafe { FromRawFd::from_raw_fd(libc::STDOUT_FILENO) })
+ .spawn()
+ };
+
+ // The Stdio passed into the Command took over (and closed) std{out, err}
+ // so we should restore them as they were.
+ assert!(unsafe { libc::dup2(stdout_backup, libc::STDOUT_FILENO) } > -1);
+ assert!(unsafe { libc::dup2(stderr_backup, libc::STDERR_FILENO) } > -1);
+
+ // Using File as a shim around the descriptor
+ let mut read = String::new();
+ let mut f: File = unsafe { FromRawFd::from_raw_fd(stdout_reader) };
+ f.read_to_string(&mut read).expect("failed to read from stdout file");
+ assert_eq!(read, "parent stdout\nchild stderr\n");
+
+ // Using File as a shim around the descriptor
+ read.clear();
+ let mut f: File = unsafe { FromRawFd::from_raw_fd(stderr_reader) };
+ f.read_to_string(&mut read).expect("failed to read from stderr file");
+ assert_eq!(read, "parent stderr\nchild stdout\n");
+
+ assert!(child.expect("failed to execute child process").wait().unwrap().success());
+}
+
+#[cfg(unix)]
+fn child() {
+ stdout().write_all("child stdout\n".as_bytes()).expect("child failed to write to stdout");
+ stderr().write_all("child stderr\n".as_bytes()).expect("child failed to write to stderr");
+}
+
+#[cfg(unix)]
+/// Returns a pipe (reader, writer combo)
+fn pipe() -> (i32, i32) {
+ let mut fds = [0; 2];
+ assert_eq!(unsafe { libc::pipe(fds.as_mut_ptr()) }, 0);
+ (fds[0], fds[1])
+}
x.extension_method(a)
}
-// FIXME #30661: Although this function has the #[rustc_mir] attribute it never
-// was translated via the MIR implementation because attributes
-// where not passed along to trans::base::trans_fn() for generic
-// functions.
-// Uncomment this test once the thing it tests is fixed.
-// #[rustc_mir]
-// fn test6<T: Bar>(x: &T, a: isize) -> isize {
-// // Test calling extension method on generic callee
-// x.extension_method(a)
-// }
+#[rustc_mir]
+fn test6<T: Bar>(x: &T, a: isize) -> isize {
+ // Test calling extension method on generic callee
+ x.extension_method(a)
+}
trait One<T = Self> {
fn one() -> T;
assert_eq!(test3(&Foo, 42), 42);
assert_eq!(test4(&Foo, 970), 970);
assert_eq!(test5(&Foo, 8576), 8576);
- // see definition of test6() above
- // assert_eq!(test6(&Foo, 12367), 12367);
+ assert_eq!(test6(&Foo, 12367), 12367);
assert_eq!(test7(), 1);
assert_eq!(test8(), 2);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-#![feature(negate_unsigned)]
-
pub fn main() {
let a = 1;
let a_neg: i8 = -a;
let e = 1;
let e_neg: isize = -e;
println!("{}", e_neg);
-
- // intentional overflows
-
- let f = 1;
- let f_neg: u8 = -f;
- println!("{}", f_neg);
-
- let g = 1;
- let g_neg: u16 = -g;
- println!("{}", g_neg);
-
- let h = 1;
- let h_neg: u32 = -h;
- println!("{}", h_neg);
-
- let i = 1;
- let i_neg: u64 = -i;
- println!("{}", i_neg);
-
- let j = 1;
- let j_neg: usize = -j;
- println!("{}", j_neg);
}