- Make punctuation/formatting consistent with the changes made to *The Rust Programming Language* in #20782.
- Use title casing for "Safety and Speed" section.
- Reword some phrases to improve clarity.
# make check-stage1-std RUST_TEST_TASKS=1
#
# This is hardly all there is to know of The Rust Build System's
-# mysteries. The tale continues on the wiki[1][2].
+# mysteries. The tale continues on the wiki[1].
#
-# [1]: https://github.com/rust-lang/rust/wiki/Note-getting-started-developing-Rust
-# [2]: https://github.com/rust-lang/rust/wiki/Note-testsuite
+# [1]: https://github.com/rust-lang/rust/wiki/Note-testsuite
#
# If you really feel like getting your hands dirty, then:
#
### Building on Windows
-To easily build on windows we can use [MSYS2](http://sourceforge.net/projects/msys2/):
+To easily build on windows we can use [MSYS2](http://msys2.github.io/):
1. Grab the latest MSYS2 installer and go through the installer.
2. Now from the MSYS2 terminal we want to install the mingw64 toolchain and the other
tools we need.
- $ pacman -S mingw-w64-i686-toolchain
- $ pacman -S base-devel
+```bash
+# choose one based on platform
+$ pacman -S mingw-w64-i686-toolchain
+$ pacman -S mingw-w64-x86_64-toolchain
-3. With that now start `mingw32_shell.bat` from where you installed MSYS2 (i.e. `C:\msys`).
+$ pacman -S base-devel
+```
+
+3. With that now start `mingw32_shell.bat` or `mingw64_shell.bat`
+ from where you installed MSYS2 (i.e. `C:\msys`). Which one you
+ choose depends on if you want 32 or 64 bit Rust.
4. From there just navigate to where you have Rust's source code, configure and build it:
$ ./configure
CFG_CPUTYPE=aarch64
;;
+ powerpc)
+ CFG_CPUTYPE=powerpc
+ ;;
+
x86_64 | x86-64 | x64 | amd64)
CFG_CPUTYPE=x86_64
;;
make_dir $t/rt/jemalloc
for i in \
isaac sync test \
- arch/i386 arch/x86_64 arch/arm arch/aarch64 arch/mips
+ arch/i386 arch/x86_64 arch/arm arch/aarch64 arch/mips arch/powerpc
do
make_dir $t/rt/stage$s/$i
done
msg "configuring LLVM for $gnu_t"
- LLVM_TARGETS="--enable-targets=x86,x86_64,arm,aarch64,mips"
+ LLVM_TARGETS="--enable-targets=x86,x86_64,arm,aarch64,mips,powerpc"
LLVM_BUILD="--build=$gnu_t"
LLVM_HOST="--host=$gnu_t"
LLVM_TARGET="--target=$gnu_t"
endif
CFG_LIB_NAME_aarch64-apple-ios = lib$(1).a
CFG_LIB_GLOB_aarch64-apple-ios = lib$(1)-*.a
-CFG_LIB_SKIP_INSTALL_aarch64-apple-ios = 1 #lib$(1)-*.a
+CFG_INSTALL_ONLY_RLIB_aarch64-apple-ios = 1
CFG_STATIC_LIB_NAME_aarch64-apple-ios=lib$(1).a
CFG_LIB_DSYM_GLOB_aarch64-apple-ios = lib$(1)-*.a.dSYM
CFG_CFLAGS_aarch64-apple-ios := $(CFG_IOS_SDK_FLAGS_aarch64-apple-ios)
endif
CFG_LIB_NAME_armv7-apple-ios = lib$(1).a
CFG_LIB_GLOB_armv7-apple-ios = lib$(1)-*.a
-CFG_LIB_SKIP_INSTALL_armv7-apple-ios = 1 #lib$(1)-*.a
+CFG_INSTALL_ONLY_RLIB_armv7-apple-ios = 1
CFG_STATIC_LIB_NAME_armv7-apple-ios=lib$(1).a
CFG_LIB_DSYM_GLOB_armv7-apple-ios = lib$(1)-*.a.dSYM
CFG_JEMALLOC_CFLAGS_armv7-apple-ios := -arch armv7 -mfpu=vfp3 $(CFG_IOS_SDK_FLAGS_armv7-apple-ios)
endif
CFG_LIB_NAME_armv7s-apple-ios = lib$(1).a
CFG_LIB_GLOB_armv7s-apple-ios = lib$(1)-*.a
-CFG_LIB_SKIP_INSTALL_armv7s-apple-ios = 1 #lib$(1)-*.a
+CFG_INSTALL_ONLY_RLIB_armv7s-apple-ios = 1
CFG_STATIC_LIB_NAME_armv7s-apple-ios=lib$(1).a
CFG_LIB_DSYM_GLOB_armv7s-apple-ios = lib$(1)-*.a.dSYM
CFG_JEMALLOC_CFLAGS_armv7s-apple-ios := -arch armv7s -mfpu=vfp4 $(CFG_IOS_SDK_FLAGS_armv7s-apple-ios)
endif
CFG_LIB_NAME_i386-apple-ios = lib$(1).a
CFG_LIB_GLOB_i386-apple-ios = lib$(1)-*.dylib
+CFG_INSTALL_ONLY_RLIB_i386-apple-ios = 1
CFG_STATIC_LIB_NAME_i386-apple-ios=lib$(1).a
CFG_LIB_DSYM_GLOB_i386-apple-ios = lib$(1)-*.dylib.dSYM
CFG_GCCISH_CFLAGS_i386-apple-ios := -Wall -Werror -g -fPIC -m32 $(CFG_IOSSIM_FLAGS_i386-apple-ios)
--- /dev/null
+# powerpc-unknown-linux-gnu configuration
+CROSS_PREFIX_powerpc-unknown-linux-gnu=powerpc-linux-gnu-
+CC_powerpc-unknown-linux-gnu=$(CC)
+CXX_powerpc-unknown-linux-gnu=$(CXX)
+CPP_powerpc-unknown-linux-gnu=$(CPP)
+AR_powerpc-unknown-linux-gnu=$(AR)
+CFG_LIB_NAME_powerpc-unknown-linux-gnu=lib$(1).so
+CFG_STATIC_LIB_NAME_powerpc-unknown-linux-gnu=lib$(1).a
+CFG_LIB_GLOB_powerpc-unknown-linux-gnu=lib$(1)-*.so
+CFG_LIB_DSYM_GLOB_powerpc-unknown-linux-gnu=lib$(1)-*.dylib.dSYM
+CFG_CFLAGS_powerpc-unknown-linux-gnu := -m32 $(CFLAGS)
+CFG_GCCISH_CFLAGS_powerpc-unknown-linux-gnu := -Wall -Werror -g -fPIC -m32 $(CFLAGS)
+CFG_GCCISH_CXXFLAGS_powerpc-unknown-linux-gnu := -fno-rtti $(CXXFLAGS)
+CFG_GCCISH_LINK_FLAGS_powerpc-unknown-linux-gnu := -shared -fPIC -ldl -pthread -lrt -g -m32
+CFG_GCCISH_DEF_FLAG_powerpc-unknown-linux-gnu := -Wl,--export-dynamic,--dynamic-list=
+CFG_GCCISH_PRE_LIB_FLAGS_powerpc-unknown-linux-gnu := -Wl,-whole-archive
+CFG_GCCISH_POST_LIB_FLAGS_powerpc-unknown-linux-gnu := -Wl,-no-whole-archive
+CFG_DEF_SUFFIX_powerpc-unknown-linux-gnu := .linux.def
+CFG_LLC_FLAGS_powerpc-unknown-linux-gnu :=
+CFG_INSTALL_NAME_powerpc-unknown-linux-gnu =
+CFG_EXE_SUFFIX_powerpc-unknown-linux-gnu =
+CFG_WINDOWSY_powerpc-unknown-linux-gnu :=
+CFG_UNIXY_powerpc-unknown-linux-gnu := 1
+CFG_PATH_MUNGE_powerpc-unknown-linux-gnu := true
+CFG_LDPATH_powerpc-unknown-linux-gnu :=
+CFG_RUN_powerpc-unknown-linux-gnu=$(2)
+CFG_RUN_TARG_powerpc-unknown-linux-gnu=$(call CFG_RUN_powerpc-unknown-linux-gnu,,$(2))
+CFG_GNU_TRIPLE_powerpc-unknown-linux-gnu := powerpc-unknown-linux-gnu
endif
CFG_LIB_NAME_x86_64-apple-ios = lib$(1).a
CFG_LIB_GLOB_x86_64-apple-ios = lib$(1)-*.a
-CFG_LIB_SKIP_INSTALL_x86_64-apple-ios = 1 #lib$(1)-*.a
+CFG_INSTALL_ONLY_RLIB_x86_64-apple-ios = 1
CFG_STATIC_LIB_NAME_x86_64-apple-ios=lib$(1).a
CFG_LIB_DSYM_GLOB_x86_64-apple-ios = lib$(1)-*.a.dSYM
CFG_CFLAGS_x86_64-apple-ios := $(CFG_IOSSIM_FLAGS_x86_64-apple-ios)
######################################################################
# FIXME: x86-ism
-LLVM_COMPONENTS=x86 arm aarch64 mips ipo bitreader bitwriter linker asmparser mcjit \
+LLVM_COMPONENTS=x86 arm aarch64 mips powerpc ipo bitreader bitwriter linker asmparser mcjit \
interpreter instrumentation
# Only build these LLVM tools
$$(CFG_GCCISH_DEF_FLAG_$(1))$$(3) $$(2) \
$$(call CFG_INSTALL_NAME_$(1),$$(4))
- ifeq ($$(findstring $(HOST_$(1)),arm aarch64 mips mipsel),)
+ ifeq ($$(findstring $(HOST_$(1)),arm aarch64 mips mipsel powerpc),)
# We're using llvm-mc as our assembler because it supports
# .cfi pseudo-ops on mac
-o=$$(1)
else
- # For the ARM, AARCH64 and MIPS crosses, use the toolchain assembler
+ # For the ARM, AARCH64, MIPS and POWER crosses, use the toolchain assembler
# FIXME: We should be able to use the LLVM assembler
CFG_ASSEMBLE_$(1)=$$(CC_$(1)) $$(CFG_GCCISH_CFLAGS_$(1)) \
$$(CFG_DEPEND_FLAGS) $$(2) -c -o $$(1)
$$(if $$(findstring $(3), $$(PREPARE_HOST)), \
$$(call PREPARE_DIR,$$(PREPARE_WORKING_DEST_LIB_DIR)) \
$$(foreach crate,$$(TARGET_CRATES), \
- $$(if $$(findstring 1, $$(ONLY_RLIB_$$(crate))),, \
+ $$(if $$(or $$(findstring 1, $$(ONLY_RLIB_$$(crate))),$$(findstring 1,$$(CFG_INSTALL_ONLY_RLIB_$(2)))),, \
$$(call PREPARE_LIB,$$(call CFG_LIB_GLOB_$(2),$$(crate)))) \
$$(call PREPARE_LIB,$$(call CFG_RLIB_GLOB,$$(crate)))) \
$$(if $$(findstring $(2),$$(CFG_HOST)), \
line.starts_with( prefix )
}
+ // A multi-line error will have followup lines which will always
+ // start with one of these strings.
+ fn continuation( line: &str) -> bool {
+ line.starts_with(" expected") ||
+ line.starts_with(" found") ||
+ // 1234
+ // Should have 4 spaces: see issue 18946
+ line.starts_with("(")
+ }
+
// Scan and extract our error/warning messages,
// which look like:
// filename:line1:col1: line2:col2: *error:* msg
ee.kind,
ee.msg,
line);
- if prefix_matches(line, prefixes[i].as_slice()) &&
+ if (prefix_matches(line, prefixes[i].as_slice()) || continuation(line)) &&
line.contains(ee.kind.as_slice()) &&
line.contains(ee.msg.as_slice()) {
found_flags[i] = true;
fn main() {
assert!(Version::parse("1.2.3") == Ok(Version {
- major: 1u,
- minor: 2u,
- patch: 3u,
+ major: 1u64,
+ minor: 2u64,
+ patch: 3u64,
pre: vec!(),
build: vec!(),
}));
use std::thread::Thread;
fn main() {
- for _ in range(0u, 10u) {
- Thread::spawn(move || {
+ let guards: Vec<_> = (0..10).map(|_| {
+ Thread::scoped(|| {
println!("Hello, world!");
- });
- }
+ })
+ }).collect();
}
```
-This program creates ten threads, who all print `Hello, world!`. The
-`spawn` function takes one argument, a closure, indicated by the
-double bars `||`. (The `move` keyword indicates that the closure takes
-ownership of any data it uses; we'll have more on the significance of
-this shortly.) This closure is executed in a new thread created by
-`spawn`.
+This program creates ten threads, which all print `Hello, world!`. The `scoped`
+function takes one argument, a closure, indicated by the double bars `||`. This
+closure is executed in a new thread created by `scoped`. The method is called
+`scoped` because it returns a 'join guard', which will automatically join the
+child thread when it goes out of scope. Because we `collect` these guards into
+a `Vec<T>`, and that vector goes out of scope at the end of our program, our
+program will wait for every thread to finish before finishing.
One common form of problem in concurrent programs is a *data race*.
This occurs when two different threads attempt to access the same
Some things that might be helpful to you though:
## Search
+
* <form action="https://duckduckgo.com/">
<input type="text" id="site-search" name="q" size="80"></input>
<input type="submit" value="Search DuckDuckGo">
* Rust doc search: <span id="core-search"></span>
## Reference
+
* [The Rust official site](http://rust-lang.org)
-* [The Rust reference](http://doc.rust-lang.org/reference.html) (* [PDF](http://doc.rust-lang.org/reference.pdf))
+* [The Rust reference](http://doc.rust-lang.org/reference.html)
## Docs
+
* [The standard library](http://doc.rust-lang.org/std/)
<script>
```
* Paths starting with the keyword `super` begin resolution relative to the
- parent module. Each further identifier must resolve to an item
+ parent module. Each further identifier must resolve to an item.
```rust
mod a {
Use declarations support a number of convenient shortcuts:
-* Rebinding the target name as a new local name, using the syntax `use p::q::r as x;`.
+* Rebinding the target name as a new local name, using the syntax `use p::q::r as x;`
* Simultaneously binding a list of paths differing only in their final element,
using the glob-like brace syntax `use a::b::{c,d,e,f};`
* Binding all paths matching a given prefix, using the asterisk wildcard syntax
passes arguments into the function, and an *output* [*slot*](#memory-slots)
through which the function passes results back to the caller.
-A function may also be copied into a first class *value*, in which case the
+A function may also be copied into a first-class *value*, in which case the
value has the corresponding [*function type*](#function-types), and can be used
otherwise exactly as a function item (with a minor additional cost of calling
the function indirectly).
* A value other than `false` (0) or `true` (1) in a `bool`
* A discriminant in an `enum` not included in the type definition
* A value in a `char` which is a surrogate or above `char::MAX`
- * non-UTF-8 byte sequences in a `str`
+ * Non-UTF-8 byte sequences in a `str`
* Unwinding into Rust from foreign code or unwinding from Rust into foreign
code. Rust's failure system is not compatible with exception handling in
other languages. Unwinding must be caught and handled at FFI boundaries.
These two cases are surprisingly powerful for creating module hierarchies
exposing public APIs while hiding internal implementation details. To help
-explain, here's a few use cases and what they would entail.
+explain, here's a few use cases and what they would entail:
* A library developer needs to expose functionality to crates which link
against their library. As a consequence of the first case, this means that
scope.
Here's an example of a program which exemplifies the three cases outlined
-above.
+above:
```
// This module is private, meaning that no external crate can access this
destructors from being run twice. Destructors might be run multiple times on
the same object with this attribute.
- `doc` - Doc comments such as `/// foo` are equivalent to `#[doc = "foo"]`.
+- `rustc_on_unimplemented` - Write a custom note to be shown along with the error
+ when the trait is found to be unimplemented on a type.
+ You may use format arguments like `{T}`, `{A}` to correspond to the
+ types at the point of use corresponding to the type parameters of the
+ trait of the same name. `{Self}` will be replaced with the type that is supposed
+ to implement the trait but doesn't. To use this, the `on_unimplemented` feature gate
+ must be enabled.
### Conditional compilation
The following configurations must be defined by the implementation:
* `target_arch = "..."`. Target CPU architecture, such as `"x86"`, `"x86_64"`
- `"mips"`, `"arm"`, or `"aarch64"`.
+ `"mips"`, `"powerpc"`, `"arm"`, or `"aarch64"`.
* `target_endian = "..."`. Endianness of the target CPU, either `"little"` or
`"big"`.
* `target_family = "..."`. Operating system family of the target, e. g.
```
This example shows how one can use `allow` and `warn` to toggle a particular
-check on and off.
+check on and off:
```{.ignore}
#[warn(missing_docs)]
```
This example shows how one can use `forbid` to disallow uses of `allow` for
-that lint check.
+that lint check:
```{.ignore}
#[forbid(missing_docs)]
* `ord`
: Elements have a partial ordering.
* `deref`
- : `*` can be applied, yielding a reference to another type
+ : `*` can be applied, yielding a reference to another type.
* `deref_mut`
- : `*` can be applied, yielding a mutable reference to another type
+ : `*` can be applied, yielding a mutable reference to another type.
These are functions:
* `type_id`
: The type returned by the `type_id` intrinsic.
* `unsafe`
- : A type whose contents can be mutated through an immutable reference
+ : A type whose contents can be mutated through an immutable reference.
#### Marker types
* `begin_unwind`
: ___Needs filling in___
* `no_copy_bound`
- : This type does not implement "copy", even if eligible
+ : This type does not implement "copy", even if eligible.
* `no_send_bound`
- : This type does not implement "send", even if eligible
+ : This type does not implement "send", even if eligible.
* `no_sync_bound`
- : This type does not implement "sync", even if eligible
+ : This type does not implement "sync", even if eligible.
* `eh_personality`
: ___Needs filling in___
* `exchange_free`
* `iterator`
: ___Needs filling in___
* `contravariant_lifetime`
- : The lifetime parameter should be considered contravariant
+ : The lifetime parameter should be considered contravariant.
* `covariant_lifetime`
- : The lifetime parameter should be considered covariant
+ : The lifetime parameter should be considered covariant.
* `invariant_lifetime`
- : The lifetime parameter should be considered invariant
+ : The lifetime parameter should be considered invariant.
* `malloc`
: Allocate memory on the managed heap.
* `owned_box`
* `start`
: ___Needs filling in___
* `contravariant_type`
- : The type parameter should be considered contravariant
+ : The type parameter should be considered contravariant.
* `covariant_type`
- : The type parameter should be considered covariant
+ : The type parameter should be considered covariant.
* `invariant_type`
- : The type parameter should be considered invariant
+ : The type parameter should be considered invariant.
* `ty_desc`
: ___Needs filling in___
* `#[inline(always)]` asks the compiler to always perform an inline expansion.
* `#[inline(never)]` asks the compiler to never perform an inline expansion.
-### Deriving
+### Derive
-The `deriving` attribute allows certain traits to be automatically implemented
+The `derive` attribute allows certain traits to be automatically implemented
for data structures. For example, the following will create an `impl` for the
`PartialEq` and `Clone` traits for `Foo`, the type parameter `T` will be given
the `PartialEq` or `Clone` constraints for the appropriate `impl`:
```
-#[deriving(PartialEq, Clone)]
+#[derive(PartialEq, Clone)]
struct Foo<T> {
a: int,
b: T
}
```
-Supported traits for `deriving` are:
+Supported traits for `derive` are:
* Comparison traits: `PartialEq`, `Eq`, `PartialOrd`, `Ord`.
* Serialization: `Encodable`, `Decodable`. These require `serialize`.
```{.ebnf .gram}
array_expr : '[' "mut" ? vec_elems? ']' ;
-array_elems : [expr [',' expr]*] | [expr ',' ".." expr] ;
+array_elems : [expr [',' expr]*] | [expr ';' expr] ;
```
An [array](#array,-and-slice-types) _expression_ is written by enclosing zero
or more comma-separated expressions of uniform type in square brackets.
-In the `[expr ',' ".." expr]` form, the expression after the `".."` must be a
+In the `[expr ';' expr]` form, the expression after the `';'` must be a
constant expression that can be evaluated at compile time, such as a
[literal](#literals) or a [static item](#static-items).
### Unary operator expressions
-Rust defines six symbolic unary operators. They are all written as prefix
-operators, before the expression they apply to.
+Rust defines three unary operators. They are all written as prefix operators,
+before the expression they apply to.
* `-`
: Negation. May only be applied to numeric types.
: Logical negation. On the boolean type, this flips between `true` and
`false`. On integer types, this inverts the individual bits in the
two's complement representation of the value.
-* `box`
- : [Boxing](#pointer-types) operators. Allocate a box to hold the value they
- are applied to, and store the value in it. `box` creates a box.
-* `&`
- : Borrow operator. Returns a reference, pointing to its operand. The operand
- of a borrow is statically proven to outlive the resulting pointer. If the
- borrow-checker cannot prove this, it is a compilation error.
### Binary operator expressions
the lambda expression captures its environment by reference, effectively
borrowing pointers to all outer variables mentioned inside the function.
Alternately, the compiler may infer that a lambda expression should copy or
-move values (depending on their type.) from the environment into the lambda
+move values (depending on their type) from the environment into the lambda
expression's captured environment.
In this example, we define a function `ten_times` that takes a higher-order
-function argument, and call it with a lambda expression as an argument.
+function argument, and call it with a lambda expression as an argument:
```
fn ten_times<F>(f: F) where F: Fn(int) {
The types `char` and `str` hold textual data.
A value of type `char` is a [Unicode scalar value](
-http://www.unicode.org/glossary/#unicode_scalar_value) (ie. a code point that
+http://www.unicode.org/glossary/#unicode_scalar_value) (i.e. a code point that
is not a surrogate), represented as a 32-bit unsigned word in the 0x0000 to
0xD7FF or 0xE000 to 0x10FFFF range. A `[char]` array is effectively an UCS-4 /
UTF-32 string.
A value of type `str` is a Unicode string, represented as an array of 8-bit
unsigned bytes holding a sequence of UTF-8 codepoints. Since `str` is of
-unknown size, it is not a _first class_ type, but can only be instantiated
+unknown size, it is not a _first-class_ type, but can only be instantiated
through a pointer type, such as `&str` or `String`.
### Tuple types
Rust has two different types for a list of items:
-* `[T ..N]`, an 'array'
+* `[T; N]`, an 'array'.
* `&[T]`, a 'slice'.
An array has a fixed size, and can be allocated on either the stack or the
An example of each kind:
```{rust}
-let vec: Vec<int> = vec![1, 2, 3];
-let arr: [int; 3] = [1, 2, 3];
-let s: &[int] = vec.as_slice();
+let vec: Vec<i32> = vec![1, 2, 3];
+let arr: [i32; 3] = [1, 2, 3];
+let s: &[i32] = vec.as_slice();
```
As you can see, the `vec!` macro allows you to create a `Vec<T>` easily. The
Cons(T, Box<List<T>>)
}
-let a: List<int> = List::Cons(7, Box::new(List::Cons(13, Box::new(List::Nil))));
+let a: List<i32> = List::Cons(7, Box::new(List::Cons(13, Box::new(List::Nil))));
```
### Pointer types
documentation examples. If a line is prefixed with `# `, then the line
will not show up in the HTML documentation, but it will be used when
testing the code block (NB. the space after the `#` is required, so
-that one can still write things like `#[deriving(Eq)]`).
+that one can still write things like `#[derive(Eq)]`).
~~~md
```
The documentation online would look like `spawn(move || { fib(200); })`, but when
testing this code, the `fib` function will be included (so it can compile).
+Rustdoc will automatically add a `main()` wrapper around your code, and in the right
+place. For example:
+
+```
+/// ```
+/// use std::rc::Rc;
+///
+/// let five = Rc::new(5);
+/// ```
+# fn foo() {}
+```
+
+This will end up testing:
+
+```
+fn main() {
+ use std::rc::Rc;
+ let five = Rc::new(5);
+}
+```
+
+Here's the full algorithm:
+
+1. Given a code block, if it does not contain `fn main`, it is wrapped in `fn main() { your_code }`
+2. Given that result, if it contains no `extern crate` directives but it also
+ contains the name of the crate being tested, then `extern crate <name>` is
+ injected at the top.
+3. Some common `allow` attributes are added for documentation examples at the top.
+
## Running tests (advanced)
Running tests often requires some special configuration to filter tests, find
"The Rust Programming Language" is split into three sections, which you can
navigate through the menu on the left.
-## Basics
+<h2 class="section-header"><a href="basic.html">Basics</a></h2>
This section is a linear introduction to the basic syntax and semantics of
Rust. It has individual sections on each part of Rust's syntax, and culminates
After reading "Basics," you will have a good foundation to learn more about
Rust, and can write very simple programs.
-## Intermediate
+<h2 class="section-header"><a href="intermediate.html">Intermediate</a></h2>
This section contains individual chapters, which are self-contained. They focus
on specific topics, and can be read in any order.
After reading "Intermediate," you will have a solid understanding of Rust,
and will be able to understand most Rust code and write more complex programs.
-## Advanced
+<h2 class="section-header"><a href="advanced.html">Advanced</a></h2>
In a similar fashion to "Intermediate," this section is full of individual,
deep-dive chapters, which stand alone and can be read in any order. These
* [Iterators](iterators.md)
* [Generics](generics.md)
* [Traits](traits.md)
- * [Tasks](tasks.md)
+ * [Threads](threads.md)
* [Error Handling](error-handling.md)
* [III: Advanced Topics](advanced.md)
* [FFI](ffi.md)
```{rust}
let a = [0, 1, 2, 3, 4];
-let middle = a.slice(1, 4); // A slice of a: just the elements [1,2,3]
+let middle = &a[1..4]; // A slice of a: just the elements 1, 2, and 3
for e in middle.iter() {
println!("{}", e); // Prints 1, 2, 3
generics.
We have now learned all of the most basic Rust concepts. We're ready to start
-building our guessing game, we just need to know one last thing: how to get
-input from the keyboard. You can't have a guessing game without the ability to
-guess!
+building ourselves a guessing game, we just need to know one last thing: how to
+get input from the keyboard. You can't have a guessing game without the ability
+to guess!
Next, let's look at how `twice` is defined:
```{rust,ignore}
-fn twice(x: i32, f: |i32| -> i32) -> i32 {
+fn twice<F: Fn(i32) -> i32>(x: i32, f: F) -> i32 {
```
`twice` takes two arguments, `x` and `f`. That's why we called it with two
arguments. `x` is an `i32`, we've done that a ton of times. `f` is a function,
-though, and that function takes an `i32` and returns an `i32`. Notice
-how the `|i32| -> i32` syntax looks a lot like our definition of `square`
-above, if we added the return type in:
-
-```{rust}
-let square = |&: x: i32| -> i32 { x * x };
-// |i32| -> i32
-```
-
-This function takes an `i32` and returns an `i32`.
+though, and that function takes an `i32` and returns an `i32`. This is
+what the requirement `Fn(i32) -> i32` for the type parameter `F` says.
+You might ask yourself: why do we need to introduce a type parameter here?
+That is because in Rust each closure has its own unique type.
+So, not only do closures with different signatures have different types,
+but different closures with the *same* signature have *different* types!
+You can think of it this way: the behaviour of a closure is part of its type.
+And since we want to support many different closures that all take
+an `i32` and return an `i32` we introduced a type parameter that is able
+to represent all these closures.
This is the most complicated function signature we've seen yet! Give it a read
a few times until you can see how it works. It takes a teeny bit of practice, and
-then it's easy.
+then it's easy. The good news is that this kind of passing a closure around
+can be very efficient. With all the type information available at compile-time
+the compiler can do wonders.
Finally, `twice` returns an `i32` as well.
```
When writing doc comments, adding sections for any arguments, return values,
-and providing some examples of usage is very, very helpful.
+and providing some examples of usage is very, very helpful. Don't worry about
+the `&str`, we'll get to it soon.
You can use the [`rustdoc`](../rustdoc.html) tool to generate HTML documentation
from these doc comments.
As you can see, the type of a tuple looks just like the tuple, but with each
position having a type name rather than the value. Careful readers will also
note that tuples are heterogeneous: we have an `i32` and a `&str` in this tuple.
-You haven't seen `&str` as a type before, and we'll discuss the details of
-strings later. In systems programming languages, strings are a bit more complex
-than in other languages. For now, just read `&str` as a *string slice*, and
-we'll learn more soon.
+You have briefly seen `&str` used as a type before, and we'll discuss the
+details of strings later. In systems programming languages, strings are a bit
+more complex than in other languages. For now, just read `&str` as a *string
+slice*, and we'll learn more soon.
You can access the fields in a tuple through a *destructuring let*. Here's
an example:
There _is_ one case when a tuple struct is very useful, though, and that's a
tuple struct with only one element. We call this a *newtype*, because it lets
-you create a new type that's a synonym for another one:
+you create a new type that's similar to another one:
```{rust}
struct Inches(i32);
```
As you can see here, you can extract the inner integer type through a
-destructuring `let`.
+destructuring `let`, as we discussed previously in 'tuples.' In this case, the
+`let Inches(integer_length)` assigns `10` to `integer_length`.
## Enums
}
```
-(This is "Sayoonara", if you're curious.)
+(This is "Sayōnara", if you're curious.)
Now that we have our some functionality in our crate, let's try to use it from
another crate.
This will build and run:
```bash
-$ cargo build
+$ cargo run
Compiling phrases v0.0.1 (file:///home/you/projects/phrases)
Running `target/phrases`
Hello in English: Hello!
% Error Handling in Rust
-> The best-laid plans of mice and men
+> The best-laid plans of mice and men
> Often go awry
>
> "Tae a Moose", Robert Burns
# Non-recoverable errors with `panic!`
In the case of an error that is unexpected and not recoverable, the `panic!`
-macro will induce a panic. This will crash the current task, and give an error:
+macro will induce a panic. This will crash the current thread, and give an error:
```{rust,ignore}
panic!("boom");
gives
```text
-task '<main>' panicked at 'boom', hello.rs:2
+thread '<main>' panicked at 'boom', hello.rs:2
```
when you run it.
# Stack management
-Rust tasks by default run on a *large stack*. This is actually implemented as a
+Rust threads by default run on a *large stack*. This is actually implemented as a
reserving a large segment of the address space and then lazily mapping in pages
as they are needed. When calling an external C function, the code is invoked on
the same stack as the rust stack. This means that there is no extra
stack-switching mechanism in place because it is assumed that the large stack
-for the rust task is plenty for the C function to have.
+for the rust thread is plenty for the C function to have.
A planned future improvement (not yet implemented at the time of this writing)
is to have a guard page at the end of every rust stack. No rust function will
need for any extra effort on a user's perspective. The C stack naturally
interleaves with the rust stack, and it's "large enough" for both to
interoperate. If, however, it is determined that a larger stack is necessary,
-there are appropriate functions in the task spawning API to control the size of
-the stack of the task which is spawned.
+there are appropriate functions in the thread spawning API to control the size of
+the stack of the thread which is spawned.
# Destructors
to a function call to the external C library.
The control over the current thread is switched from Rust to C to Rust for the
execution of the callback, but in the end the callback is executed on the
-same thread (and Rust task) that lead called the function which triggered
-the callback.
+same thread that called the function which triggered the callback.
Things get more complicated when the external library spawns its own threads
and invokes callbacks from there.
especially unsafe and proper synchronization mechanisms must be used.
Besides classical synchronization mechanisms like mutexes, one possibility in
Rust is to use channels (in `std::comm`) to forward data from the C thread
-that invoked the callback into a Rust task.
+that invoked the callback into a Rust thread.
If an asynchronous callback targets a special object in the Rust address space
it is also absolutely necessary that no more callbacks are performed by the
not work:
```{ignore}
-fn print_number(x, y) {
+fn print_sum(x, y) {
println!("x is: {}", x + y);
}
```
You get this error:
```text
-hello.rs:5:18: 5:19 error: expected `:` but found `,`
+hello.rs:5:18: 5:19 expected one of `!`, `:`, or `@`, found `)`
hello.rs:5 fn print_number(x, y) {
```
fn main() {
println!("Guess the number!");
- let secret_number = (rand::random::<uint>() % 100u) + 1u;
+ let secret_number = (rand::random::<u32>() % 100) + 1;
println!("The secret number is: {}", secret_number);
fn main() {
println!("Guess the number!");
- let secret_number = (rand::random::<uint>() % 100u) + 1u;
+ let secret_number = (rand::random::<u32>() % 100) + 1;
println!("The secret number is: {}", secret_number);
src/main.rs:20:15: 20:20 error: mismatched types: expected `i32` but found `collections::string::String` (expected i32 but found struct collections::string::String)
src/main.rs:20 match cmp(input, secret_number) {
^~~~~
-src/main.rs:20:22: 20:35 error: mismatched types: expected `i32` but found `uint` (expected i32 but found uint)
+src/main.rs:20:22: 20:35 error: mismatched types: expected `i32` but found `u32` (expected i32 but found u32)
src/main.rs:20 match cmp(input, secret_number) {
^~~~~~~~~~~~~
error: aborting due to 2 previous errors
strengths. You try out some code, see if it compiles, and Rust tells you that
you've done something wrong. In this case, our `cmp` function works on integers,
but we've given it unsigned integers. In this case, the fix is easy, because
-we wrote the `cmp` function! Let's change it to take `uint`s:
+we wrote the `cmp` function! Let's change it to take `u32`s:
```{rust,ignore}
use std::io;
fn main() {
println!("Guess the number!");
- let secret_number = (rand::random::<uint>() % 100u) + 1u;
+ let secret_number = (rand::random::<u32>() % 100) + 1;
println!("The secret number is: {}", secret_number);
}
}
-fn cmp(a: uint, b: uint) -> Ordering {
+fn cmp(a: u32, b: u32) -> Ordering {
if a < b { Ordering::Less }
else if a > b { Ordering::Greater }
else { Ordering::Equal }
```bash
$ cargo build
Compiling guessing_game v0.0.1 (file:///home/you/projects/guessing_game)
-src/main.rs:20:15: 20:20 error: mismatched types: expected `uint` but found `collections::string::String` (expected uint but found struct collections::string::String)
+src/main.rs:20:15: 20:20 error: mismatched types: expected `u32` but found `collections::string::String` (expected u32 but found struct collections::string::String)
src/main.rs:20 match cmp(input, secret_number) {
^~~~~
error: aborting due to previous error
```
-This error is similar to the last one: we expected to get a `uint`, but we got
+This error is similar to the last one: we expected to get a `u32`, but we got
a `String` instead! That's because our `input` variable is coming from the
standard input, and you can guess anything. Try it:
This works because the older version we did successfully compile was still lying
around. Gotta be careful!
-Anyway, we have a `String`, but we need a `uint`. What to do? Well, there's
+Anyway, we have a `String`, but we need a `u32`. What to do? Well, there's
a function for that:
```{rust,ignore}
let input = io::stdin().read_line()
.ok()
.expect("Failed to read line");
-let input_num: Option<uint> = input.parse();
+let input_num: Option<u32> = input.parse();
```
The `parse` function takes in a `&str` value and converts it into something.
`random()`? It looked like this:
```{rust,ignore}
-rand::random::<uint>();
+rand::random::<u32>();
```
There's an alternate way of providing a hint too, and that's declaring the type
in a `let`:
```{rust,ignore}
-let x: uint = rand::random();
+let x: u32 = rand::random();
```
-In this case, we say `x` is a `uint` explicitly, so Rust is able to properly
+In this case, we say `x` is a `u32` explicitly, so Rust is able to properly
tell `random()` what to generate. In a similar fashion, both of these work:
```{rust,ignore}
-let input_num = "5".parse::<uint>(); // input_num: Option<uint>
-let input_num: Option<uint> = "5".parse(); // input_num: Option<uint>
+let input_num = "5".parse::<u32>(); // input_num: Option<u32>
+let input_num: Option<u32> = "5".parse(); // input_num: Option<u32>
```
Anyway, with us now converting our input to a number, our code looks like this:
fn main() {
println!("Guess the number!");
- let secret_number = (rand::random::<uint>() % 100u) + 1u;
+ let secret_number = (rand::random::<u32>() % 100) + 1;
println!("The secret number is: {}", secret_number);
let input = io::stdin().read_line()
.ok()
.expect("Failed to read line");
- let input_num: Option<uint> = input.parse();
+ let input_num: Option<u32> = input.parse();
println!("You guessed: {}", input_num);
}
}
-fn cmp(a: uint, b: uint) -> Ordering {
+fn cmp(a: u32, b: u32) -> Ordering {
if a < b { Ordering::Less }
else if a > b { Ordering::Greater }
else { Ordering::Equal }
```bash
$ cargo build
Compiling guessing_game v0.0.1 (file:///home/you/projects/guessing_game)
-src/main.rs:22:15: 22:24 error: mismatched types: expected `uint` but found `core::option::Option<uint>` (expected uint but found enum core::option::Option)
+src/main.rs:22:15: 22:24 error: mismatched types: expected `u32` but found `core::option::Option<u32>` (expected u32 but found enum core::option::Option)
src/main.rs:22 match cmp(input_num, secret_number) {
^~~~~~~~~
error: aborting due to previous error
```
-Oh yeah! Our `input_num` has the type `Option<uint>`, rather than `uint`. We
+Oh yeah! Our `input_num` has the type `Option<u32>`, rather than `u32`. We
need to unwrap the Option. If you remember from before, `match` is a great way
to do that. Try this code:
fn main() {
println!("Guess the number!");
- let secret_number = (rand::random::<uint>() % 100u) + 1u;
+ let secret_number = (rand::random::<u32>() % 100) + 1;
println!("The secret number is: {}", secret_number);
let input = io::stdin().read_line()
.ok()
.expect("Failed to read line");
- let input_num: Option<uint> = input.parse();
+ let input_num: Option<u32> = input.parse();
let num = match input_num {
Some(num) => num,
}
}
-fn cmp(a: uint, b: uint) -> Ordering {
+fn cmp(a: u32, b: u32) -> Ordering {
if a < b { Ordering::Less }
else if a > b { Ordering::Greater }
else { Ordering::Equal }
}
```
-We use a `match` to either give us the `uint` inside of the `Option`, or else
+We use a `match` to either give us the `u32` inside of the `Option`, or else
print an error message and return. Let's give this a shot:
```bash
fn main() {
println!("Guess the number!");
- let secret_number = (rand::random::<uint>() % 100u) + 1u;
+ let secret_number = (rand::random::<u32>() % 100) + 1;
println!("The secret number is: {}", secret_number);
let input = io::stdin().read_line()
.ok()
.expect("Failed to read line");
- let input_num: Option<uint> = input.trim().parse();
+ let input_num: Option<u32> = input.trim().parse();
let num = match input_num {
Some(num) => num,
}
}
-fn cmp(a: uint, b: uint) -> Ordering {
+fn cmp(a: u32, b: u32) -> Ordering {
if a < b { Ordering::Less }
else if a > b { Ordering::Greater }
else { Ordering::Equal }
fn main() {
println!("Guess the number!");
- let secret_number = (rand::random::<uint>() % 100u) + 1u;
+ let secret_number = (rand::random::<u32>() % 100) + 1;
println!("The secret number is: {}", secret_number);
let input = io::stdin().read_line()
.ok()
.expect("Failed to read line");
- let input_num: Option<uint> = input.trim().parse();
+ let input_num: Option<u32> = input.trim().parse();
let num = match input_num {
Some(num) => num,
}
}
-fn cmp(a: uint, b: uint) -> Ordering {
+fn cmp(a: u32, b: u32) -> Ordering {
if a < b { Ordering::Less }
else if a > b { Ordering::Greater }
else { Ordering::Equal }
fn main() {
println!("Guess the number!");
- let secret_number = (rand::random::<uint>() % 100u) + 1u;
+ let secret_number = (rand::random::<u32>() % 100) + 1;
println!("The secret number is: {}", secret_number);
let input = io::stdin().read_line()
.ok()
.expect("Failed to read line");
- let input_num: Option<uint> = input.trim().parse();
+ let input_num: Option<u32> = input.trim().parse();
let num = match input_num {
Some(num) => num,
}
}
-fn cmp(a: uint, b: uint) -> Ordering {
+fn cmp(a: u32, b: u32) -> Ordering {
if a < b { Ordering::Less }
else if a > b { Ordering::Greater }
else { Ordering::Equal }
fn main() {
println!("Guess the number!");
- let secret_number = (rand::random::<uint>() % 100u) + 1u;
+ let secret_number = (rand::random::<u32>() % 100) + 1;
println!("The secret number is: {}", secret_number);
let input = io::stdin().read_line()
.ok()
.expect("Failed to read line");
- let input_num: Option<uint> = input.trim().parse();
+ let input_num: Option<u32> = input.trim().parse();
let num = match input_num {
Some(num) => num,
}
}
-fn cmp(a: uint, b: uint) -> Ordering {
+fn cmp(a: u32, b: u32) -> Ordering {
if a < b { Ordering::Less }
else if a > b { Ordering::Greater }
else { Ordering::Equal }
fn main() {
println!("Guess the number!");
- let secret_number = (rand::random::<uint>() % 100u) + 1u;
+ let secret_number = (rand::random::<u32>() % 100) + 1;
loop {
let input = io::stdin().read_line()
.ok()
.expect("Failed to read line");
- let input_num: Option<uint> = input.trim().parse();
+ let input_num: Option<u32> = input.trim().parse();
let num = match input_num {
Some(num) => num,
}
}
-fn cmp(a: uint, b: uint) -> Ordering {
+fn cmp(a: u32, b: u32) -> Ordering {
if a < b { Ordering::Less }
else if a > b { Ordering::Greater }
else { Ordering::Equal }
it's the beginning of every Rust program. The first line says "I'm declaring a
function named `main`, which takes no arguments and returns nothing." If there
were arguments, they would go inside the parentheses (`(` and `)`), and because
-we aren't returning anything from this function, we've dropped that notation
-entirely. We'll get to it later.
+we aren't returning anything from this function, we can omit the return type
+entirely. We'll get to it later.
You'll also note that the function is wrapped in curly braces (`{` and `}`).
Rust requires these around all function bodies. It is also considered good
Note the semicolons after the 10 and 15. Rust will give us the following error:
```text
-error: mismatched types: expected `i32` but found `()` (expected i32 but found ())
+error: mismatched types: expected `i32`, found `()` (expected i32, found ())
```
We expected an integer, but we got `()`. `()` is pronounced *unit*, and is a
Instead, it looks like this:
```{rust}
-for x in range(0, 10) {
+for x in 0..10 {
println!("{}", x); // x: i32
}
```
the iterator, and we loop another time. When there are no more values, the
`for` loop is over.
-In our example, `range` is a function that takes a start and an end position,
+In our example, `0..10` is an expression that takes a start and an end position,
and gives an iterator over those values. The upper bound is exclusive, though,
so our loop will print `0` through `9`, not `10`.
this:
```{rust}
-let mut x = 5u; // mut x: uint
+let mut x = 5u32; // mut x: u32
let mut done = false; // mut done: bool
while !done {
Let's take a look at that `while` loop we had earlier:
```{rust}
-let mut x = 5u;
+let mut x = 5u32;
let mut done = false;
while !done {
In this case, we can write the loop in a better way with `break`:
```{rust}
-let mut x = 5u;
+let mut x = 5u32;
loop {
x += x - 3;
iteration. This will only print the odd numbers:
```{rust}
-for x in range(0, 10) {
+for x in 0..10 {
if x % 2 == 0 { continue; }
println!("{}", x);
# let input_1 = T::SpecialA(0);
# let input_2 = T::SpecialA(0);
macro_rules! early_return {
- ($inp:expr, $sp:path) => ( // invoke it like `(input_5 SpecialE)`
+ ($inp:expr, $sp:path) => ( // invoke it like `(input_5, SpecialE)`
match $inp {
$sp(x) => { return x; }
_ => {}
~~~~
Macros are defined in pattern-matching style: in the above example, the text
-`($inp:expr $sp:ident)` that appears on the left-hand side of the `=>` is the
+`($inp:expr, $sp:path)` that appears on the left-hand side of the `=>` is the
*macro invocation syntax*, a pattern denoting how to write a call to the
macro. The text on the right-hand side of the `=>`, beginning with `match
$inp`, is the *macro transcription syntax*: what the macro expands to.
2. `$` has special meaning (described below).
3. The `()`s, `[]`s, and `{}`s it contains must balance. For example, `([)` is
forbidden.
+4. Some arguments can be followed only by a limited set of separators, to
+avoid ambiguity (described below).
Otherwise, the invocation syntax is free-form.
`foo`.)
* `expr` (an expression. Examples: `2 + 2`; `if true then { 1 } else { 2 }`;
`f(42)`.)
-* `ty` (a type. Examples: `int`, `Vec<(char, String)>`, `&T`.)
+* `ty` (a type. Examples: `i32`, `Vec<(char, String)>`, `&T`.)
+* `path` (a path to struct or enum variant. Example: `T::SpecialA`)
* `pat` (a pattern, usually appearing in a `match` or on the left-hand side of
a declaration. Examples: `Some(t)`; `(17, 'a')`; `_`.)
* `block` (a sequence of actions. Example: `{ log(error, "hi"); return 12; }`)
So `($x:ident -> (($e:expr)))`, though excessively fancy, would designate a macro
that could be invoked like: `my_macro!(i->(( 2+2 )))`.
+To avoid ambiguity, macro invocation syntax must conform to the following rules:
+* `expr` must be followed by `=>`, `,` or `;`.
+* `ty` and `path` must be followed by `=>`, `,`, `:`, `=`, `>` or `as`.
+* `pat` must be followed by `=>`, `,` or `=`.
+* `ident` and `block` can be followed by any token.
+
## Invocation location
A macro invocation may take the place of (and therefore expand to) an
Rust:
```rust
-# use std::boxed::Box;
{
- let x = Box::new(5i);
+ let x = Box::new(5);
}
```
-The `Box::new` function creates a `Box<T>` (specifically `Box<int>` in this
+The `Box::new` function creates a `Box<T>` (specifically `Box<i32>` in this
case) by allocating a small segment of memory on the heap with enough space to
-fit an `int`. But where in the code is the box deallocated? We said before that
+fit an `i32`. But where in the code is the box deallocated? We said before that
we must have a deallocation for each allocation. Rust handles this for you. It
knows that our handle, `x`, is the owning reference to our box. Rust knows that
`x` will go out of scope at the end of the block, and so it inserts a call to
to a function? Let's look at some code:
```rust
-# use std::boxed::Box;
fn main() {
- let x = Box::new(5i);
+ let x = Box::new(5);
add_one(x);
}
-fn add_one(mut num: Box<int>) {
+fn add_one(mut num: Box<i32>) {
*num += 1;
}
```
code, where we print out the value of `x`:
```{rust,ignore}
-# use std::boxed::Box;
fn main() {
- let x = Box::new(5i);
+ let x = Box::new(5);
add_one(x);
println!("{}", x);
}
-fn add_one(mut num: Box<int>) {
+fn add_one(mut num: Box<i32>) {
*num += 1;
}
```
box:
```rust
-# use std::boxed::Box;
fn main() {
- let x = Box::new(5i);
+ let x = Box::new(5);
let y = add_one(x);
println!("{}", y);
}
-fn add_one(mut num: Box<int>) -> Box<int> {
+fn add_one(mut num: Box<i32>) -> Box<i32> {
*num += 1;
num
Here's the current state of our `add_one` function:
```rust
-fn add_one(mut num: Box<int>) -> Box<int> {
+fn add_one(mut num: Box<i32>) -> Box<i32> {
*num += 1;
num
borrows its argument rather than taking ownership:
```rust
-fn add_one(num: &mut int) {
+fn add_one(num: &mut i32) {
*num += 1;
}
```
-This function borrows an `int` from its caller, and then increments it. When
+This function borrows an `i32` from its caller, and then increments it. When
the function is over, and `num` goes out of scope, the borrow is over.
+We have to change our `main` a bit too:
+
+```rust
+fn main() {
+ let mut x = 5;
+
+ add_one(&mut x);
+
+ println!("{}", x);
+}
+
+fn add_one(num: &mut i32) {
+ *num += 1;
+}
+```
+
+We don't need to assign the result of `add_one()` anymore, because it doesn't
+return anything anymore. This is because we're not passing ownership back,
+since we just borrow, not take ownership.
+
# Lifetimes
Lending out a reference to a resource that someone else owns can be
three. The ownership system in Rust does this through a concept called
*lifetimes*, which describe the scope that a reference is valid for.
-Let's look at that function which borrows an `int` again:
+Remember the function that borrowed an `i32`? Let's look at it again.
```rust
-fn add_one(num: &int) -> int {
+fn add_one(num: &i32) -> i32 {
*num + 1
}
```
this:
```rust
-fn add_one<'a>(num: &'a int) -> int {
+fn add_one<'a>(num: &'a i32) -> i32 {
*num + 1
}
```
Then in our parameter list, we use the lifetimes we've named:
```{rust,ignore}
-...(num: &'a int) -> ...
+...(num: &'a i32) -> ...
```
-If you compare `&int` to `&'a int`, they're the same, it's just that the
-lifetime `'a` has snuck in between the `&` and the `int`. We read `&int` as "a
-reference to an int" and `&'a int` as "a reference to an int with the lifetime 'a.'"
+If you compare `&i32` to `&'a i32`, they're the same, it's just that the
+lifetime `'a` has snuck in between the `&` and the `i32`. We read `&i32` as "a
+reference to an i32" and `&'a i32` as "a reference to an i32 with the lifetime 'a.'"
Why do lifetimes matter? Well, for example, here's some code:
```rust
struct Foo<'a> {
- x: &'a int,
+ x: &'a i32,
}
fn main() {
- let y = &5i; // this is the same as `let _y = 5; let y = &_y;
+ let y = &5; // this is the same as `let _y = 5; let y = &_y;
let f = Foo { x: y };
println!("{}", f.x);
```{rust}
struct Foo<'a> {
-# x: &'a int,
+# x: &'a i32,
# }
```
```rust
# struct Foo<'a> {
-x: &'a int,
+x: &'a i32,
# }
```
uses it. So why do we need a lifetime here? We need to ensure that any reference
-to a `Foo` cannot outlive the reference to an `int` it contains.
+to a `Foo` cannot outlive the reference to an `i32` it contains.
## Thinking in scopes
```rust
fn main() {
- let y = &5i; // -+ y goes into scope
+ let y = &5; // -+ y goes into scope
// |
// stuff // |
// |
```rust
struct Foo<'a> {
- x: &'a int,
+ x: &'a i32,
}
fn main() {
- let y = &5i; // -+ y goes into scope
+ let y = &5; // -+ y goes into scope
let f = Foo { x: y }; // -+ f goes into scope
// stuff // |
// |
```{rust,ignore}
struct Foo<'a> {
- x: &'a int,
+ x: &'a i32,
}
fn main() {
let x; // -+ x goes into scope
// |
{ // |
- let y = &5i; // ---+ y goes into scope
+ let y = &5; // ---+ y goes into scope
let f = Foo { x: y }; // ---+ f goes into scope
x = &f.x; // | | error here
} // ---+ f and y go out of scope
example are globals:
```rust
-static FOO: int = 5i;
-let x: &'static int = &FOO;
+static FOO: i32 = 5;
+let x: &'static i32 = &FOO;
```
-This adds an `int` to the data segment of the binary, and FOO is a reference to
-it.
+This adds an `i32` to the data segment of the binary, and `FOO` is a reference
+to it.
# Shared Ownership
}
struct Wheel {
- size: int,
+ size: i32,
owner: Car,
}
}
struct Wheel {
- size: int,
+ size: i32,
owner: Rc<Car>,
}
fn print(s: &str); // elided
fn print<'a>(s: &'a str); // expanded
-fn debug(lvl: uint, s: &str); // elided
-fn debug<'a>(lvl: uint, s: &'a str); // expanded
+fn debug(lvl: u32, s: &str); // elided
+fn debug<'a>(lvl: u32, s: &'a str); // expanded
// In the preceeding example, `lvl` doesn't need a lifetime because it's not a
// reference (`&`). Only things relating to references (such as a `struct`
// which contains a reference) need lifetimes.
-fn substr(s: &str, until: uint) -> &str; // elided
-fn substr<'a>(s: &'a str, until: uint) -> &'a str; // expanded
+fn substr(s: &str, until: u32) -> &str; // elided
+fn substr<'a>(s: &'a str, until: u32) -> &'a str; // expanded
fn get_str() -> &str; // ILLEGAL, no inputs
a way to define new literal syntax for any data type.
In addition to procedural macros, you can define new
-[`deriving`](../reference.html#deriving)-like attributes and other kinds of
+[`derive`](../reference.html#derive)-like attributes and other kinds of
extensions. See
[`Registry::register_syntax_extension`](../rustc/plugin/registry/struct.Registry.html#method.register_syntax_extension)
and the [`SyntaxExtension`
This gives you flexibility without sacrificing performance.
You may think that this gives us terrible performance: return a value and then
-immediately box it up ?! Isn't that the worst of both worlds? Rust is smarter
-than that. There is no copy in this code. `main` allocates enough room for the
-`box`, passes a pointer to that memory into `foo` as `x`, and then `foo` writes
-the value straight into that pointer. This writes the return value directly into
-the allocated box.
+immediately box it up ?! Isn't this pattern the worst of both worlds? Rust is
+smarter than that. There is no copy in this code. `main` allocates enough room
+for the `box`, passes a pointer to that memory into `foo` as `x`, and then
+`foo` writes the value straight into the `Box<T>`.
This is important enough that it bears repeating: pointers are not for
optimizing returning values from your code. Allow the caller to choose how they
+++ /dev/null
-% The Rust Threads and Communication Guide
-
-**NOTE** This guide is badly out of date and needs to be rewritten.
-
-# Introduction
-
-Rust provides safe concurrent abstractions through a number of core library
-primitives. This guide will describe the concurrency model in Rust, how it
-relates to the Rust type system, and introduce the fundamental library
-abstractions for constructing concurrent programs.
-
-Threads provide failure isolation and recovery. When a fatal error occurs in Rust
-code as a result of an explicit call to `panic!()`, an assertion failure, or
-another invalid operation, the runtime system destroys the entire thread. Unlike
-in languages such as Java and C++, there is no way to `catch` an exception.
-Instead, threads may monitor each other to see if they panic.
-
-Threads use Rust's type system to provide strong memory safety guarantees. In
-particular, the type system guarantees that threads cannot induce a data race
-from shared mutable state.
-
-# Basics
-
-At its simplest, creating a thread is a matter of calling the `spawn` function
-with a closure argument. `spawn` executes the closure in the new thread.
-
-```{rust,ignore}
-# use std::thread::spawn;
-
-// Print something profound in a different thread using a named function
-fn print_message() { println!("I am running in a different thread!"); }
-spawn(print_message);
-
-// Alternatively, use a `move ||` expression instead of a named function.
-// `||` expressions evaluate to an unnamed closure. The `move` keyword
-// indicates that the closure should take ownership of any variables it
-// touches.
-spawn(move || println!("I am also running in a different thread!"));
-```
-
-In Rust, a thread is not a concept that appears in the language semantics.
-Instead, Rust's type system provides all the tools necessary to implement safe
-concurrency: particularly, ownership. The language leaves the implementation
-details to the standard library.
-
-The `spawn` function has the type signature: `fn
-spawn<F:FnOnce()+Send>(f: F)`. This indicates that it takes as
-argument a closure (of type `F`) that it will run exactly once. This
-closure is limited to capturing `Send`-able data from its environment
-(that is, data which is deeply owned). Limiting the closure to `Send`
-ensures that `spawn` can safely move the entire closure and all its
-associated state into an entirely different thread for execution.
-
-```{rust,ignore}
-# use std::thread::spawn;
-# fn generate_thread_number() -> int { 0 }
-// Generate some state locally
-let child_thread_number = generate_thread_number();
-
-spawn(move || {
- // Capture it in the remote thread. The `move` keyword indicates
- // that this closure should move `child_thread_number` into its
- // environment, rather than capturing a reference into the
- // enclosing stack frame.
- println!("I am child number {}", child_thread_number);
-});
-```
-
-## Communication
-
-Now that we have spawned a new thread, it would be nice if we could communicate
-with it. For this, we use *channels*. A channel is simply a pair of endpoints:
-one for sending messages and another for receiving messages.
-
-The simplest way to create a channel is to use the `channel` function to create a
-`(Sender, Receiver)` pair. In Rust parlance, a *sender* is a sending endpoint
-of a channel, and a *receiver* is the receiving endpoint. Consider the following
-example of calculating two results concurrently:
-
-```{rust,ignore}
-# use std::thread::spawn;
-
-let (tx, rx): (Sender<int>, Receiver<int>) = channel();
-
-spawn(move || {
- let result = some_expensive_computation();
- tx.send(result);
-});
-
-some_other_expensive_computation();
-let result = rx.recv();
-# fn some_expensive_computation() -> int { 42 }
-# fn some_other_expensive_computation() {}
-```
-
-Let's examine this example in detail. First, the `let` statement creates a
-stream for sending and receiving integers (the left-hand side of the `let`,
-`(tx, rx)`, is an example of a destructuring let: the pattern separates a tuple
-into its component parts).
-
-```{rust,ignore}
-let (tx, rx): (Sender<int>, Receiver<int>) = channel();
-```
-
-The child thread will use the sender to send data to the parent thread, which will
-wait to receive the data on the receiver. The next statement spawns the child
-thread.
-
-```{rust,ignore}
-# use std::thread::spawn;
-# fn some_expensive_computation() -> int { 42 }
-# let (tx, rx) = channel();
-spawn(move || {
- let result = some_expensive_computation();
- tx.send(result);
-});
-```
-
-Notice that the creation of the thread closure transfers `tx` to the child thread
-implicitly: the closure captures `tx` in its environment. Both `Sender` and
-`Receiver` are sendable types and may be captured into threads or otherwise
-transferred between them. In the example, the child thread runs an expensive
-computation, then sends the result over the captured channel.
-
-Finally, the parent continues with some other expensive computation, then waits
-for the child's result to arrive on the receiver:
-
-```{rust,ignore}
-# fn some_other_expensive_computation() {}
-# let (tx, rx) = channel::<int>();
-# tx.send(0);
-some_other_expensive_computation();
-let result = rx.recv();
-```
-
-The `Sender` and `Receiver` pair created by `channel` enables efficient
-communication between a single sender and a single receiver, but multiple
-senders cannot use a single `Sender` value, and multiple receivers cannot use a
-single `Receiver` value. What if our example needed to compute multiple
-results across a number of threads? The following program is ill-typed:
-
-```{rust,ignore}
-# fn some_expensive_computation() -> int { 42 }
-let (tx, rx) = channel();
-
-spawn(move || {
- tx.send(some_expensive_computation());
-});
-
-// ERROR! The previous spawn statement already owns the sender,
-// so the compiler will not allow it to be captured again
-spawn(move || {
- tx.send(some_expensive_computation());
-});
-```
-
-Instead we can clone the `tx`, which allows for multiple senders.
-
-```{rust,ignore}
-let (tx, rx) = channel();
-
-for init_val in range(0u, 3) {
- // Create a new channel handle to distribute to the child thread
- let child_tx = tx.clone();
- spawn(move || {
- child_tx.send(some_expensive_computation(init_val));
- });
-}
-
-let result = rx.recv() + rx.recv() + rx.recv();
-# fn some_expensive_computation(_i: uint) -> int { 42 }
-```
-
-Cloning a `Sender` produces a new handle to the same channel, allowing multiple
-threads to send data to a single receiver. It upgrades the channel internally in
-order to allow this functionality, which means that channels that are not
-cloned can avoid the overhead required to handle multiple senders. But this
-fact has no bearing on the channel's usage: the upgrade is transparent.
-
-Note that the above cloning example is somewhat contrived since you could also
-simply use three `Sender` pairs, but it serves to illustrate the point. For
-reference, written with multiple streams, it might look like the example below.
-
-```{rust,ignore}
-# use std::thread::spawn;
-
-// Create a vector of ports, one for each child thread
-let rxs = Vec::from_fn(3, |init_val| {
- let (tx, rx) = channel();
- spawn(move || {
- tx.send(some_expensive_computation(init_val));
- });
- rx
-});
-
-// Wait on each port, accumulating the results
-let result = rxs.iter().fold(0, |accum, rx| accum + rx.recv() );
-# fn some_expensive_computation(_i: uint) -> int { 42 }
-```
-
-## Backgrounding computations: Futures
-
-With `sync::Future`, rust has a mechanism for requesting a computation and
-getting the result later.
-
-The basic example below illustrates this.
-
-```{rust,ignore}
-# #![allow(deprecated)]
-use std::sync::Future;
-
-# fn main() {
-# fn make_a_sandwich() {};
-fn fib(n: u64) -> u64 {
- // lengthy computation returning an uint
- 12586269025
-}
-
-let mut delayed_fib = Future::spawn(move || fib(50));
-make_a_sandwich();
-println!("fib(50) = {}", delayed_fib.get())
-# }
-```
-
-The call to `future::spawn` immediately returns a `future` object regardless of
-how long it takes to run `fib(50)`. You can then make yourself a sandwich while
-the computation of `fib` is running. The result of the execution of the method
-is obtained by calling `get` on the future. This call will block until the
-value is available (*i.e.* the computation is complete). Note that the future
-needs to be mutable so that it can save the result for next time `get` is
-called.
-
-Here is another example showing how futures allow you to background
-computations. The workload will be distributed on the available cores.
-
-```{rust,ignore}
-# #![allow(deprecated)]
-# use std::num::Float;
-# use std::sync::Future;
-fn partial_sum(start: uint) -> f64 {
- let mut local_sum = 0f64;
- for num in range(start*100000, (start+1)*100000) {
- local_sum += (num as f64 + 1.0).powf(-2.0);
- }
- local_sum
-}
-
-fn main() {
- let mut futures = Vec::from_fn(200, |ind| Future::spawn(move || partial_sum(ind)));
-
- let mut final_res = 0f64;
- for ft in futures.iter_mut() {
- final_res += ft.get();
- }
- println!("π^2/6 is not far from : {}", final_res);
-}
-```
-
-## Sharing without copying: Arc
-
-To share data between threads, a first approach would be to only use channel as
-we have seen previously. A copy of the data to share would then be made for
-each thread. In some cases, this would add up to a significant amount of wasted
-memory and would require copying the same data more than necessary.
-
-To tackle this issue, one can use an Atomically Reference Counted wrapper
-(`Arc`) as implemented in the `sync` library of Rust. With an Arc, the data
-will no longer be copied for each thread. The Arc acts as a reference to the
-shared data and only this reference is shared and cloned.
-
-Here is a small example showing how to use Arcs. We wish to run concurrently
-several computations on a single large vector of floats. Each thread needs the
-full vector to perform its duty.
-
-```{rust,ignore}
-use std::num::Float;
-use std::rand;
-use std::sync::Arc;
-
-fn pnorm(nums: &[f64], p: uint) -> f64 {
- nums.iter().fold(0.0, |a, b| a + b.powf(p as f64)).powf(1.0 / (p as f64))
-}
-
-fn main() {
- let numbers = Vec::from_fn(1000000, |_| rand::random::<f64>());
- let numbers_arc = Arc::new(numbers);
-
- for num in range(1u, 10) {
- let thread_numbers = numbers_arc.clone();
-
- spawn(move || {
- println!("{}-norm = {}", num, pnorm(thread_numbers.as_slice(), num));
- });
- }
-}
-```
-
-The function `pnorm` performs a simple computation on the vector (it computes
-the sum of its items at the power given as argument and takes the inverse power
-of this value). The Arc on the vector is created by the line:
-
-```{rust,ignore}
-# use std::rand;
-# use std::sync::Arc;
-# fn main() {
-# let numbers = Vec::from_fn(1000000, |_| rand::random::<f64>());
-let numbers_arc = Arc::new(numbers);
-# }
-```
-
-and a clone is captured for each thread via a procedure. This only copies
-the wrapper and not its contents. Within the thread's procedure, the captured
-Arc reference can be used as a shared reference to the underlying vector as
-if it were local.
-
-```{rust,ignore}
-# use std::rand;
-# use std::sync::Arc;
-# fn pnorm(nums: &[f64], p: uint) -> f64 { 4.0 }
-# fn main() {
-# let numbers=Vec::from_fn(1000000, |_| rand::random::<f64>());
-# let numbers_arc = Arc::new(numbers);
-# let num = 4;
-let thread_numbers = numbers_arc.clone();
-spawn(move || {
- // Capture thread_numbers and use it as if it was the underlying vector
- println!("{}-norm = {}", num, pnorm(thread_numbers.as_slice(), num));
-});
-# }
-```
-
-# Handling thread panics
-
-Rust has a built-in mechanism for raising exceptions. The `panic!()` macro
-(which can also be written with an error string as an argument: `panic!(
-~reason)`) and the `assert!` construct (which effectively calls `panic!()` if a
-boolean expression is false) are both ways to raise exceptions. When a thread
-raises an exception, the thread unwinds its stack—running destructors and
-freeing memory along the way—and then exits. Unlike exceptions in C++,
-exceptions in Rust are unrecoverable within a single thread: once a thread panics,
-there is no way to "catch" the exception.
-
-While it isn't possible for a thread to recover from panicking, threads may notify
-each other if they panic. The simplest way of handling a panic is with the
-`try` function, which is similar to `spawn`, but immediately blocks and waits
-for the child thread to finish. `try` returns a value of type
-`Result<T, Box<Any + Send>>`. `Result` is an `enum` type with two variants:
-`Ok` and `Err`. In this case, because the type arguments to `Result` are `int`
-and `()`, callers can pattern-match on a result to check whether it's an `Ok`
-result with an `int` field (representing a successful result) or an `Err` result
-(representing termination with an error).
-
-```{rust,ignore}
-# use std::thread::Thread;
-# fn some_condition() -> bool { false }
-# fn calculate_result() -> int { 0 }
-let result: Result<int, Box<std::any::Any + Send>> = Thread::spawn(move || {
- if some_condition() {
- calculate_result()
- } else {
- panic!("oops!");
- }
-}).join();
-assert!(result.is_err());
-```
-
-Unlike `spawn`, the function spawned using `try` may return a value, which
-`try` will dutifully propagate back to the caller in a [`Result`] enum. If the
-child thread terminates successfully, `try` will return an `Ok` result; if the
-child thread panics, `try` will return an `Error` result.
-
-[`Result`]: ../std/result/index.html
-
-> *Note:* A panicked thread does not currently produce a useful error
-> value (`try` always returns `Err(())`). In the
-> future, it may be possible for threads to intercept the value passed to
-> `panic!()`.
-
-But not all panics are created equal. In some cases you might need to abort
-the entire program (perhaps you're writing an assert which, if it trips,
-indicates an unrecoverable logic error); in other cases you might want to
-contain the panic at a certain boundary (perhaps a small piece of input from
-the outside world, which you happen to be processing in parallel, is malformed
-such that the processing thread cannot proceed).
failures:
---- it_works stdout ----
- task 'it_works' panicked at 'assertion failed: false', /home/steve/tmp/adder/src/lib.rs:3
+ thread 'it_works' panicked at 'assertion failed: false', /home/steve/tmp/adder/src/lib.rs:3
test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured
-task '<main>' panicked at 'Some tests failed', /home/steve/src/rust/src/libtest/lib.rs:247
+thread '<main>' panicked at 'Some tests failed', /home/steve/src/rust/src/libtest/lib.rs:247
```
Rust indicates that our test failed:
our `src/lib.rs` to make use of it:
```{rust,ignore}
-#![feature(globs)]
pub fn add_two(a: i32) -> i32 {
a + 2
}
```
-Note the `feature` attribute, as well as the different `use` line. Now we run
-our tests:
+Note the different `use` line. Now we run our tests:
```bash
$ cargo test
//! assert_eq!(4, adder::add_two(2));
//! ```
-#![feature(globs)]
-
/// This function adds two to its argument.
///
/// # Examples
code. Let's make our `src/lib.rs` look like this (comments elided):
```{rust,ignore}
-#![feature(globs)]
-
extern crate test;
pub fn add_two(a: i32) -> i32 {
--- /dev/null
+% The Rust Threads and Communication Guide
+
+**NOTE** This guide is badly out of date and needs to be rewritten.
+
+# Introduction
+
+Rust provides safe concurrent abstractions through a number of core library
+primitives. This guide will describe the concurrency model in Rust, how it
+relates to the Rust type system, and introduce the fundamental library
+abstractions for constructing concurrent programs.
+
+Threads provide failure isolation and recovery. When a fatal error occurs in Rust
+code as a result of an explicit call to `panic!()`, an assertion failure, or
+another invalid operation, the runtime system destroys the entire thread. Unlike
+in languages such as Java and C++, there is no way to `catch` an exception.
+Instead, threads may monitor each other to see if they panic.
+
+Threads use Rust's type system to provide strong memory safety guarantees. In
+particular, the type system guarantees that threads cannot induce a data race
+from shared mutable state.
+
+# Basics
+
+At its simplest, creating a thread is a matter of calling the `spawn` function
+with a closure argument. `spawn` executes the closure in the new thread.
+
+```{rust,ignore}
+# use std::thread::spawn;
+
+// Print something profound in a different thread using a named function
+fn print_message() { println!("I am running in a different thread!"); }
+spawn(print_message);
+
+// Alternatively, use a `move ||` expression instead of a named function.
+// `||` expressions evaluate to an unnamed closure. The `move` keyword
+// indicates that the closure should take ownership of any variables it
+// touches.
+spawn(move || println!("I am also running in a different thread!"));
+```
+
+In Rust, a thread is not a concept that appears in the language semantics.
+Instead, Rust's type system provides all the tools necessary to implement safe
+concurrency: particularly, ownership. The language leaves the implementation
+details to the standard library.
+
+The `spawn` function has the type signature: `fn
+spawn<F:FnOnce()+Send>(f: F)`. This indicates that it takes as
+argument a closure (of type `F`) that it will run exactly once. This
+closure is limited to capturing `Send`-able data from its environment
+(that is, data which is deeply owned). Limiting the closure to `Send`
+ensures that `spawn` can safely move the entire closure and all its
+associated state into an entirely different thread for execution.
+
+```{rust,ignore}
+# use std::thread::spawn;
+# fn generate_thread_number() -> int { 0 }
+// Generate some state locally
+let child_thread_number = generate_thread_number();
+
+spawn(move || {
+ // Capture it in the remote thread. The `move` keyword indicates
+ // that this closure should move `child_thread_number` into its
+ // environment, rather than capturing a reference into the
+ // enclosing stack frame.
+ println!("I am child number {}", child_thread_number);
+});
+```
+
+## Communication
+
+Now that we have spawned a new thread, it would be nice if we could communicate
+with it. For this, we use *channels*. A channel is simply a pair of endpoints:
+one for sending messages and another for receiving messages.
+
+The simplest way to create a channel is to use the `channel` function to create a
+`(Sender, Receiver)` pair. In Rust parlance, a *sender* is a sending endpoint
+of a channel, and a *receiver* is the receiving endpoint. Consider the following
+example of calculating two results concurrently:
+
+```{rust,ignore}
+# use std::thread::spawn;
+
+let (tx, rx): (Sender<int>, Receiver<int>) = channel();
+
+spawn(move || {
+ let result = some_expensive_computation();
+ tx.send(result);
+});
+
+some_other_expensive_computation();
+let result = rx.recv();
+# fn some_expensive_computation() -> int { 42 }
+# fn some_other_expensive_computation() {}
+```
+
+Let's examine this example in detail. First, the `let` statement creates a
+stream for sending and receiving integers (the left-hand side of the `let`,
+`(tx, rx)`, is an example of a destructuring let: the pattern separates a tuple
+into its component parts).
+
+```{rust,ignore}
+let (tx, rx): (Sender<int>, Receiver<int>) = channel();
+```
+
+The child thread will use the sender to send data to the parent thread, which will
+wait to receive the data on the receiver. The next statement spawns the child
+thread.
+
+```{rust,ignore}
+# use std::thread::spawn;
+# fn some_expensive_computation() -> int { 42 }
+# let (tx, rx) = channel();
+spawn(move || {
+ let result = some_expensive_computation();
+ tx.send(result);
+});
+```
+
+Notice that the creation of the thread closure transfers `tx` to the child thread
+implicitly: the closure captures `tx` in its environment. Both `Sender` and
+`Receiver` are sendable types and may be captured into threads or otherwise
+transferred between them. In the example, the child thread runs an expensive
+computation, then sends the result over the captured channel.
+
+Finally, the parent continues with some other expensive computation, then waits
+for the child's result to arrive on the receiver:
+
+```{rust,ignore}
+# fn some_other_expensive_computation() {}
+# let (tx, rx) = channel::<int>();
+# tx.send(0);
+some_other_expensive_computation();
+let result = rx.recv();
+```
+
+The `Sender` and `Receiver` pair created by `channel` enables efficient
+communication between a single sender and a single receiver, but multiple
+senders cannot use a single `Sender` value, and multiple receivers cannot use a
+single `Receiver` value. What if our example needed to compute multiple
+results across a number of threads? The following program is ill-typed:
+
+```{rust,ignore}
+# fn some_expensive_computation() -> int { 42 }
+let (tx, rx) = channel();
+
+spawn(move || {
+ tx.send(some_expensive_computation());
+});
+
+// ERROR! The previous spawn statement already owns the sender,
+// so the compiler will not allow it to be captured again
+spawn(move || {
+ tx.send(some_expensive_computation());
+});
+```
+
+Instead we can clone the `tx`, which allows for multiple senders.
+
+```{rust,ignore}
+let (tx, rx) = channel();
+
+for init_val in range(0u, 3) {
+ // Create a new channel handle to distribute to the child thread
+ let child_tx = tx.clone();
+ spawn(move || {
+ child_tx.send(some_expensive_computation(init_val));
+ });
+}
+
+let result = rx.recv() + rx.recv() + rx.recv();
+# fn some_expensive_computation(_i: uint) -> int { 42 }
+```
+
+Cloning a `Sender` produces a new handle to the same channel, allowing multiple
+threads to send data to a single receiver. It upgrades the channel internally in
+order to allow this functionality, which means that channels that are not
+cloned can avoid the overhead required to handle multiple senders. But this
+fact has no bearing on the channel's usage: the upgrade is transparent.
+
+Note that the above cloning example is somewhat contrived since you could also
+simply use three `Sender` pairs, but it serves to illustrate the point. For
+reference, written with multiple streams, it might look like the example below.
+
+```{rust,ignore}
+# use std::thread::spawn;
+
+// Create a vector of ports, one for each child thread
+let rxs = Vec::from_fn(3, |init_val| {
+ let (tx, rx) = channel();
+ spawn(move || {
+ tx.send(some_expensive_computation(init_val));
+ });
+ rx
+});
+
+// Wait on each port, accumulating the results
+let result = rxs.iter().fold(0, |accum, rx| accum + rx.recv() );
+# fn some_expensive_computation(_i: uint) -> int { 42 }
+```
+
+## Backgrounding computations: Futures
+
+With `sync::Future`, rust has a mechanism for requesting a computation and
+getting the result later.
+
+The basic example below illustrates this.
+
+```{rust,ignore}
+# #![allow(deprecated)]
+use std::sync::Future;
+
+# fn main() {
+# fn make_a_sandwich() {};
+fn fib(n: u64) -> u64 {
+ // lengthy computation returning an uint
+ 12586269025
+}
+
+let mut delayed_fib = Future::spawn(move || fib(50));
+make_a_sandwich();
+println!("fib(50) = {}", delayed_fib.get())
+# }
+```
+
+The call to `future::spawn` immediately returns a `future` object regardless of
+how long it takes to run `fib(50)`. You can then make yourself a sandwich while
+the computation of `fib` is running. The result of the execution of the method
+is obtained by calling `get` on the future. This call will block until the
+value is available (*i.e.* the computation is complete). Note that the future
+needs to be mutable so that it can save the result for next time `get` is
+called.
+
+Here is another example showing how futures allow you to background
+computations. The workload will be distributed on the available cores.
+
+```{rust,ignore}
+# #![allow(deprecated)]
+# use std::num::Float;
+# use std::sync::Future;
+fn partial_sum(start: uint) -> f64 {
+ let mut local_sum = 0f64;
+ for num in range(start*100000, (start+1)*100000) {
+ local_sum += (num as f64 + 1.0).powf(-2.0);
+ }
+ local_sum
+}
+
+fn main() {
+ let mut futures = Vec::from_fn(200, |ind| Future::spawn(move || partial_sum(ind)));
+
+ let mut final_res = 0f64;
+ for ft in futures.iter_mut() {
+ final_res += ft.get();
+ }
+ println!("π^2/6 is not far from : {}", final_res);
+}
+```
+
+## Sharing without copying: Arc
+
+To share data between threads, a first approach would be to only use channel as
+we have seen previously. A copy of the data to share would then be made for
+each thread. In some cases, this would add up to a significant amount of wasted
+memory and would require copying the same data more than necessary.
+
+To tackle this issue, one can use an Atomically Reference Counted wrapper
+(`Arc`) as implemented in the `sync` library of Rust. With an Arc, the data
+will no longer be copied for each thread. The Arc acts as a reference to the
+shared data and only this reference is shared and cloned.
+
+Here is a small example showing how to use Arcs. We wish to run concurrently
+several computations on a single large vector of floats. Each thread needs the
+full vector to perform its duty.
+
+```{rust,ignore}
+use std::num::Float;
+use std::rand;
+use std::sync::Arc;
+
+fn pnorm(nums: &[f64], p: uint) -> f64 {
+ nums.iter().fold(0.0, |a, b| a + b.powf(p as f64)).powf(1.0 / (p as f64))
+}
+
+fn main() {
+ let numbers = Vec::from_fn(1000000, |_| rand::random::<f64>());
+ let numbers_arc = Arc::new(numbers);
+
+ for num in range(1u, 10) {
+ let thread_numbers = numbers_arc.clone();
+
+ spawn(move || {
+ println!("{}-norm = {}", num, pnorm(thread_numbers.as_slice(), num));
+ });
+ }
+}
+```
+
+The function `pnorm` performs a simple computation on the vector (it computes
+the sum of its items at the power given as argument and takes the inverse power
+of this value). The Arc on the vector is created by the line:
+
+```{rust,ignore}
+# use std::rand;
+# use std::sync::Arc;
+# fn main() {
+# let numbers = Vec::from_fn(1000000, |_| rand::random::<f64>());
+let numbers_arc = Arc::new(numbers);
+# }
+```
+
+and a clone is captured for each thread via a procedure. This only copies
+the wrapper and not its contents. Within the thread's procedure, the captured
+Arc reference can be used as a shared reference to the underlying vector as
+if it were local.
+
+```{rust,ignore}
+# use std::rand;
+# use std::sync::Arc;
+# fn pnorm(nums: &[f64], p: uint) -> f64 { 4.0 }
+# fn main() {
+# let numbers=Vec::from_fn(1000000, |_| rand::random::<f64>());
+# let numbers_arc = Arc::new(numbers);
+# let num = 4;
+let thread_numbers = numbers_arc.clone();
+spawn(move || {
+ // Capture thread_numbers and use it as if it was the underlying vector
+ println!("{}-norm = {}", num, pnorm(thread_numbers.as_slice(), num));
+});
+# }
+```
+
+# Handling thread panics
+
+Rust has a built-in mechanism for raising exceptions. The `panic!()` macro
+(which can also be written with an error string as an argument: `panic!(
+~reason)`) and the `assert!` construct (which effectively calls `panic!()` if a
+boolean expression is false) are both ways to raise exceptions. When a thread
+raises an exception, the thread unwinds its stack—running destructors and
+freeing memory along the way—and then exits. Unlike exceptions in C++,
+exceptions in Rust are unrecoverable within a single thread: once a thread panics,
+there is no way to "catch" the exception.
+
+While it isn't possible for a thread to recover from panicking, threads may notify
+each other if they panic. The simplest way of handling a panic is with the
+`try` function, which is similar to `spawn`, but immediately blocks and waits
+for the child thread to finish. `try` returns a value of type
+`Result<T, Box<Any + Send>>`. `Result` is an `enum` type with two variants:
+`Ok` and `Err`. In this case, because the type arguments to `Result` are `int`
+and `()`, callers can pattern-match on a result to check whether it's an `Ok`
+result with an `int` field (representing a successful result) or an `Err` result
+(representing termination with an error).
+
+```{rust,ignore}
+# use std::thread::Thread;
+# fn some_condition() -> bool { false }
+# fn calculate_result() -> int { 0 }
+let result: Result<int, Box<std::any::Any + Send>> = Thread::spawn(move || {
+ if some_condition() {
+ calculate_result()
+ } else {
+ panic!("oops!");
+ }
+}).join();
+assert!(result.is_err());
+```
+
+Unlike `spawn`, the function spawned using `try` may return a value, which
+`try` will dutifully propagate back to the caller in a [`Result`] enum. If the
+child thread terminates successfully, `try` will return an `Ok` result; if the
+child thread panics, `try` will return an `Error` result.
+
+[`Result`]: ../std/result/index.html
+
+> *Note:* A panicked thread does not currently produce a useful error
+> value (`try` always returns `Err(())`). In the
+> future, it may be possible for threads to intercept the value passed to
+> `panic!()`.
+
+But not all panics are created equal. In some cases you might need to abort
+the entire program (perhaps you're writing an assert which, if it trips,
+indicates an unrecoverable logic error); in other cases you might want to
+contain the panic at a certain boundary (perhaps a small piece of input from
+the outside world, which you happen to be processing in parallel, is malformed
+such that the processing thread cannot proceed).
- implement the `Drop` for resource clean-up via a destructor, and use
RAII (Resource Acquisition Is Initialization). This reduces the need
for any manual memory management by users, and automatically ensures
- that clean-up is always run, even when the task panics.
+ that clean-up is always run, even when the thread panics.
- ensure that any data stored behind a raw pointer is destroyed at the
appropriate time.
The first of these three functions, `stack_exhausted`, is invoked whenever stack
overflow is detected. This function has a number of restrictions about how it
can be called and what it must do, but if the stack limit register is not being
-maintained then a task always has an "infinite stack" and this function
+maintained then a thread always has an "infinite stack" and this function
shouldn't get triggered.
The second of these three functions, `eh_personality`, is used by the
```
#![no_std]
-#![feature(globs)]
#![feature(lang_items)]
# extern crate libc;
Let's get back to bindings. Rust variable bindings have one more aspect that
differs from other languages: bindings are required to be initialized with a
-value before you're allowed to use them. If we try...
-
-```{ignore}
-let x;
-```
-
-...we'll get an error:
-
-```text
-src/main.rs:2:9: 2:10 error: cannot determine a type for this local variable: unconstrained type
-src/main.rs:2 let x;
- ^
-```
-
-Giving it a type will compile, though:
-
-```{rust}
-let x: i32;
-```
+value before you're allowed to use them.
Let's try it out. Change your `src/main.rs` file to look like this:
(modify-syntax-entry ?\" "\"" table)
(modify-syntax-entry ?\\ "\\" table)
+ ;; mark _ as a word constituent so that identifiers
+ ;; such as xyz_type don't cause type to be highlighted
+ ;; as a keyword
+ (modify-syntax-entry ?_ "w" table)
+
;; Comments
(modify-syntax-entry ?/ ". 124b" table)
(modify-syntax-entry ?* ". 23" table)
syn keyword rustReservedKeyword alignof be do offsetof priv pure sizeof typeof unsized yield abstract final override macro
" Built-in types {{{2
-syn keyword rustType int isize uint usize float char bool u8 u16 u32 u64 f32
+syn keyword rustType isize usize float char bool u8 u16 u32 u64 f32
syn keyword rustType f64 i8 i16 i32 i64 str Self
" Things from the prelude (src/libstd/prelude.rs) {{{2
syn keyword rustTrait Path GenericPath
" FIXME: remove when I/O reform lands
syn keyword rustTrait Buffer Writer Reader Seek BufferPrelude
-" FIXME: remove when range syntax lands
-syn keyword rustFunction range
" Other syntax {{{2
syn keyword rustSelf self
syn region rustDerive start="derive(" end=")" contained contains=rustTrait
" Number literals
-syn match rustDecNumber display "\<[0-9][0-9_]*\%([iu]\%(8\|16\|32\|64\)\=\)\="
-syn match rustHexNumber display "\<0x[a-fA-F0-9_]\+\%([iu]\%(8\|16\|32\|64\)\=\)\="
-syn match rustOctNumber display "\<0o[0-7_]\+\%([iu]\%(8\|16\|32\|64\)\=\)\="
-syn match rustBinNumber display "\<0b[01_]\+\%([iu]\%(8\|16\|32\|64\)\=\)\="
+syn match rustDecNumber display "\<[0-9][0-9_]*\%([iu]\%(s\|8\|16\|32\|64\)\)\="
+syn match rustHexNumber display "\<0x[a-fA-F0-9_]\+\%([iu]\%(s\|8\|16\|32\|64\)\)\="
+syn match rustOctNumber display "\<0o[0-7_]\+\%([iu]\%(s\|8\|16\|32\|64\)\)\="
+syn match rustBinNumber display "\<0b[01_]\+\%([iu]\%(s\|8\|16\|32\|64\)\)\="
" Special case for numbers of the form "1." which are float literals, unless followed by
" an identifier, which makes them integer literals with a method call or field access,
unsafe impl<T: Sync + Send> Sync for Weak<T> { }
struct ArcInner<T> {
- strong: atomic::AtomicUint,
- weak: atomic::AtomicUint,
+ strong: atomic::AtomicUsize,
+ weak: atomic::AtomicUsize,
data: T,
}
// Start the weak pointer count as 1 which is the weak pointer that's
// held by all the strong pointers (kinda), see std/rc.rs for more info
let x = box ArcInner {
- strong: atomic::AtomicUint::new(1),
- weak: atomic::AtomicUint::new(1),
+ strong: atomic::AtomicUsize::new(1),
+ weak: atomic::AtomicUsize::new(1),
data: data,
};
Arc { _ptr: unsafe { NonZero::new(mem::transmute(x)) } }
use super::{Arc, Weak, weak_count, strong_count};
use std::sync::Mutex;
- struct Canary(*mut atomic::AtomicUint);
+ struct Canary(*mut atomic::AtomicUsize);
impl Drop for Canary
{
#[test]
fn drop_arc() {
- let mut canary = atomic::AtomicUint::new(0);
- let x = Arc::new(Canary(&mut canary as *mut atomic::AtomicUint));
+ let mut canary = atomic::AtomicUsize::new(0);
+ let x = Arc::new(Canary(&mut canary as *mut atomic::AtomicUsize));
drop(x);
assert!(canary.load(Acquire) == 1);
}
#[test]
fn drop_arc_weak() {
- let mut canary = atomic::AtomicUint::new(0);
- let arc = Arc::new(Canary(&mut canary as *mut atomic::AtomicUint));
+ let mut canary = atomic::AtomicUsize::new(0);
+ let arc = Arc::new(Canary(&mut canary as *mut atomic::AtomicUsize));
let arc_weak = arc.downgrade();
assert!(canary.load(Acquire) == 0);
drop(arc);
not(feature = "external_crate"),
any(target_arch = "arm",
target_arch = "mips",
- target_arch = "mipsel")))]
+ target_arch = "mipsel",
+ target_arch = "powerpc")))]
const MIN_ALIGN: uint = 8;
#[cfg(all(not(feature = "external_funcs"),
not(feature = "external_crate"),
for _ in range(0u, 100) {
bitv |= 1 << ((r.next_u32() as uint) % u32::BITS);
}
- black_box(&bitv)
+ black_box(&bitv);
});
}
for _ in range(0u, 100) {
bitv.set((r.next_u32() as uint) % BENCH_BITS, true);
}
- black_box(&bitv)
+ black_box(&bitv);
});
}
#[cfg(test)]
mod test {
use prelude::*;
- use std::borrow::BorrowFrom;
use super::{BTreeMap, Occupied, Vacant};
#[test]
fn test_slice_from() {
let vec: &[int] = &[1, 2, 3, 4];
- assert_eq!(&vec[0..], vec);
+ assert_eq!(&vec[], vec);
let b: &[int] = &[3, 4];
assert_eq!(&vec[2..], b);
let b: &[int] = &[];
#[test]
fn test_slice_to() {
let vec: &[int] = &[1, 2, 3, 4];
- assert_eq!(&vec[0..4], vec);
+ assert_eq!(&vec[..4], vec);
let b: &[int] = &[1, 2];
- assert_eq!(&vec[0..2], b);
+ assert_eq!(&vec[..2], b);
let b: &[int] = &[];
- assert_eq!(&vec[0..0], b);
+ assert_eq!(&vec[..0], b);
}
let (left, right) = values.split_at_mut(2);
{
let left: &[_] = left;
- assert!(left[0..left.len()] == [1, 2][]);
+ assert!(left[..left.len()] == [1, 2][]);
}
for p in left.iter_mut() {
*p += 1;
{
let right: &[_] = right;
- assert!(right[0..right.len()] == [3, 4, 5][]);
+ assert!(right[..right.len()] == [3, 4, 5][]);
}
for p in right.iter_mut() {
*p += 2;
/// out of bounds.
///
/// See also `slice`, `slice_from` and `slice_chars`.
- #[unstable = "use slice notation [0..a] instead"]
+ #[unstable = "use slice notation [..a] instead"]
fn slice_to(&self, end: uint) -> &str {
core_str::StrExt::slice_to(&self[], end)
}
let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";
b.iter(|| {
- for ch in s.chars() { black_box(ch) }
+ for ch in s.chars() { black_box(ch); }
});
}
let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";
b.iter(|| {
- for ch in s.chars().rev() { black_box(ch) }
+ for ch in s.chars().rev() { black_box(ch); }
});
}
if i > 0 {
unsafe {
- res.as_mut_vec().push_all(&v[0..i])
+ res.as_mut_vec().push_all(&v[..i])
};
}
end: *const T
}
+unsafe impl<T: Send> Send for IntoIter<T> { }
+unsafe impl<T: Sync> Sync for IntoIter<T> { }
+
impl<T> IntoIter<T> {
#[inline]
/// Drops all items that have not yet been moved and returns the empty vector.
#[test]
fn test_map_in_place_zero_drop_count() {
- use std::sync::atomic::{AtomicUint, Ordering, ATOMIC_UINT_INIT};
+ use std::sync::atomic::{AtomicUsize, Ordering, ATOMIC_USIZE_INIT};
#[derive(Clone, PartialEq, Show)]
struct Nothing;
}
}
const NUM_ELEMENTS: uint = 2;
- static DROP_COUNTER: AtomicUint = ATOMIC_UINT_INIT;
+ static DROP_COUNTER: AtomicUsize = ATOMIC_USIZE_INIT;
let v = repeat(Nothing).take(NUM_ELEMENTS).collect::<Vec<_>>();
//! types.
//!
//! This module defines atomic versions of a select number of primitive
-//! types, including `AtomicBool`, `AtomicInt`, `AtomicUint`, and `AtomicOption`.
+//! types, including `AtomicBool`, `AtomicIsize`, `AtomicUsize`, and `AtomicOption`.
//! Atomic types present operations that, when used correctly, synchronize
//! updates between threads.
//!
//!
//! ```
//! use std::sync::Arc;
-//! use std::sync::atomic::{AtomicUint, Ordering};
+//! use std::sync::atomic::{AtomicUsize, Ordering};
//! use std::thread::Thread;
//!
//! fn main() {
-//! let spinlock = Arc::new(AtomicUint::new(1));
+//! let spinlock = Arc::new(AtomicUsize::new(1));
//!
//! let spinlock_clone = spinlock.clone();
//! Thread::spawn(move|| {
//! Keep a global count of live tasks:
//!
//! ```
-//! use std::sync::atomic::{AtomicUint, Ordering, ATOMIC_UINT_INIT};
+//! use std::sync::atomic::{AtomicUsize, Ordering, ATOMIC_USIZE_INIT};
//!
-//! static GLOBAL_TASK_COUNT: AtomicUint = ATOMIC_UINT_INIT;
+//! static GLOBAL_TASK_COUNT: AtomicUsize = ATOMIC_USIZE_INIT;
//!
//! let old_task_count = GLOBAL_TASK_COUNT.fetch_add(1, Ordering::SeqCst);
//! println!("live tasks: {}", old_task_count + 1);
/// A boolean type which can be safely shared between threads.
#[stable]
pub struct AtomicBool {
- v: UnsafeCell<uint>,
+ v: UnsafeCell<usize>,
}
unsafe impl Sync for AtomicBool {}
/// A signed integer type which can be safely shared between threads.
-#[unstable = "awaiting int/uint conventions, may be renamed"]
-pub struct AtomicInt {
- v: UnsafeCell<int>,
+#[stable]
+pub struct AtomicIsize {
+ v: UnsafeCell<isize>,
}
-unsafe impl Sync for AtomicInt {}
+unsafe impl Sync for AtomicIsize {}
/// An unsigned integer type which can be safely shared between threads.
-#[unstable = "awaiting int/uint conventions, may be renamed"]
-pub struct AtomicUint {
- v: UnsafeCell<uint>,
+#[stable]
+pub struct AtomicUsize {
+ v: UnsafeCell<usize>,
}
-unsafe impl Sync for AtomicUint {}
+unsafe impl Sync for AtomicUsize {}
/// A raw pointer type which can be safely shared between threads.
#[stable]
pub struct AtomicPtr<T> {
- p: UnsafeCell<uint>,
+ p: UnsafeCell<usize>,
}
unsafe impl<T> Sync for AtomicPtr<T> {}
#[stable]
pub const ATOMIC_BOOL_INIT: AtomicBool =
AtomicBool { v: UnsafeCell { value: 0 } };
-/// An `AtomicInt` initialized to `0`.
-#[unstable = "awaiting int/uint conventions, may be renamed"]
-pub const ATOMIC_INT_INIT: AtomicInt =
- AtomicInt { v: UnsafeCell { value: 0 } };
-/// An `AtomicUint` initialized to `0`.
-#[unstable = "awaiting int/uint conventions, may be renamed"]
-pub const ATOMIC_UINT_INIT: AtomicUint =
- AtomicUint { v: UnsafeCell { value: 0, } };
+/// An `AtomicIsize` initialized to `0`.
+#[stable]
+pub const ATOMIC_ISIZE_INIT: AtomicIsize =
+ AtomicIsize { v: UnsafeCell { value: 0 } };
+/// An `AtomicUsize` initialized to `0`.
+#[stable]
+pub const ATOMIC_USIZE_INIT: AtomicUsize =
+ AtomicUsize { v: UnsafeCell { value: 0, } };
// NB: Needs to be -1 (0b11111111...) to make fetch_nand work correctly
-const UINT_TRUE: uint = -1;
+const UINT_TRUE: usize = -1;
impl AtomicBool {
/// Creates a new `AtomicBool`.
#[inline]
#[stable]
pub fn load(&self, order: Ordering) -> bool {
- unsafe { atomic_load(self.v.get() as *const uint, order) > 0 }
+ unsafe { atomic_load(self.v.get() as *const usize, order) > 0 }
}
/// Stores a value into the bool.
///
/// let foo = AtomicBool::new(true);
/// assert_eq!(true, foo.fetch_nand(true, Ordering::SeqCst));
- /// assert_eq!(0, foo.load(Ordering::SeqCst) as int);
+ /// assert_eq!(0, foo.load(Ordering::SeqCst) as usize);
/// assert_eq!(false, foo.load(Ordering::SeqCst));
///
/// let foo = AtomicBool::new(false);
}
}
-#[unstable = "awaiting int/uint conventions, types may change"]
-impl AtomicInt {
- /// Creates a new `AtomicInt`.
+#[stable]
+impl AtomicIsize {
+ /// Creates a new `AtomicIsize`.
///
/// # Examples
///
/// ```
- /// use std::sync::atomic::AtomicInt;
+ /// use std::sync::atomic::AtomicIsize;
///
- /// let atomic_forty_two = AtomicInt::new(42);
+ /// let atomic_forty_two = AtomicIsize::new(42);
/// ```
#[inline]
- pub fn new(v: int) -> AtomicInt {
- AtomicInt {v: UnsafeCell::new(v)}
+ pub fn new(v: isize) -> AtomicIsize {
+ AtomicIsize {v: UnsafeCell::new(v)}
}
- /// Loads a value from the int.
+ /// Loads a value from the isize.
///
/// `load` takes an `Ordering` argument which describes the memory ordering of this operation.
///
/// # Examples
///
/// ```
- /// use std::sync::atomic::{AtomicInt, Ordering};
+ /// use std::sync::atomic::{AtomicIsize, Ordering};
///
- /// let some_int = AtomicInt::new(5);
+ /// let some_isize = AtomicIsize::new(5);
///
- /// let value = some_int.load(Ordering::Relaxed);
+ /// let value = some_isize.load(Ordering::Relaxed);
/// ```
#[inline]
- pub fn load(&self, order: Ordering) -> int {
- unsafe { atomic_load(self.v.get() as *const int, order) }
+ pub fn load(&self, order: Ordering) -> isize {
+ unsafe { atomic_load(self.v.get() as *const isize, order) }
}
- /// Stores a value into the int.
+ /// Stores a value into the isize.
///
/// `store` takes an `Ordering` argument which describes the memory ordering of this operation.
///
/// # Examples
///
/// ```
- /// use std::sync::atomic::{AtomicInt, Ordering};
+ /// use std::sync::atomic::{AtomicIsize, Ordering};
///
- /// let some_int = AtomicInt::new(5);
+ /// let some_isize = AtomicIsize::new(5);
///
- /// some_int.store(10, Ordering::Relaxed);
+ /// some_isize.store(10, Ordering::Relaxed);
/// ```
///
/// # Panics
///
/// Panics if `order` is `Acquire` or `AcqRel`.
#[inline]
- pub fn store(&self, val: int, order: Ordering) {
+ pub fn store(&self, val: isize, order: Ordering) {
unsafe { atomic_store(self.v.get(), val, order); }
}
- /// Stores a value into the int, returning the old value.
+ /// Stores a value into the isize, returning the old value.
///
/// `swap` takes an `Ordering` argument which describes the memory ordering of this operation.
///
/// # Examples
///
/// ```
- /// use std::sync::atomic::{AtomicInt, Ordering};
+ /// use std::sync::atomic::{AtomicIsize, Ordering};
///
- /// let some_int = AtomicInt::new(5);
+ /// let some_isize = AtomicIsize::new(5);
///
- /// let value = some_int.swap(10, Ordering::Relaxed);
+ /// let value = some_isize.swap(10, Ordering::Relaxed);
/// ```
#[inline]
- pub fn swap(&self, val: int, order: Ordering) -> int {
+ pub fn swap(&self, val: isize, order: Ordering) -> isize {
unsafe { atomic_swap(self.v.get(), val, order) }
}
- /// Stores a value into the int if the current value is the same as the expected value.
+ /// Stores a value into the isize if the current value is the same as the expected value.
///
/// If the return value is equal to `old` then the value was updated.
///
/// # Examples
///
/// ```
- /// use std::sync::atomic::{AtomicInt, Ordering};
+ /// use std::sync::atomic::{AtomicIsize, Ordering};
///
- /// let some_int = AtomicInt::new(5);
+ /// let some_isize = AtomicIsize::new(5);
///
- /// let value = some_int.compare_and_swap(5, 10, Ordering::Relaxed);
+ /// let value = some_isize.compare_and_swap(5, 10, Ordering::Relaxed);
/// ```
#[inline]
- pub fn compare_and_swap(&self, old: int, new: int, order: Ordering) -> int {
+ pub fn compare_and_swap(&self, old: isize, new: isize, order: Ordering) -> isize {
unsafe { atomic_compare_and_swap(self.v.get(), old, new, order) }
}
- /// Add an int to the current value, returning the previous value.
+ /// Add an isize to the current value, returning the previous value.
///
/// # Examples
///
/// ```
- /// use std::sync::atomic::{AtomicInt, Ordering};
+ /// use std::sync::atomic::{AtomicIsize, Ordering};
///
- /// let foo = AtomicInt::new(0);
+ /// let foo = AtomicIsize::new(0);
/// assert_eq!(0, foo.fetch_add(10, Ordering::SeqCst));
/// assert_eq!(10, foo.load(Ordering::SeqCst));
/// ```
#[inline]
- pub fn fetch_add(&self, val: int, order: Ordering) -> int {
+ pub fn fetch_add(&self, val: isize, order: Ordering) -> isize {
unsafe { atomic_add(self.v.get(), val, order) }
}
- /// Subtract an int from the current value, returning the previous value.
+ /// Subtract an isize from the current value, returning the previous value.
///
/// # Examples
///
/// ```
- /// use std::sync::atomic::{AtomicInt, Ordering};
+ /// use std::sync::atomic::{AtomicIsize, Ordering};
///
- /// let foo = AtomicInt::new(0);
+ /// let foo = AtomicIsize::new(0);
/// assert_eq!(0, foo.fetch_sub(10, Ordering::SeqCst));
/// assert_eq!(-10, foo.load(Ordering::SeqCst));
/// ```
#[inline]
- pub fn fetch_sub(&self, val: int, order: Ordering) -> int {
+ pub fn fetch_sub(&self, val: isize, order: Ordering) -> isize {
unsafe { atomic_sub(self.v.get(), val, order) }
}
- /// Bitwise and with the current int, returning the previous value.
+ /// Bitwise and with the current isize, returning the previous value.
///
/// # Examples
///
/// ```
- /// use std::sync::atomic::{AtomicInt, Ordering};
+ /// use std::sync::atomic::{AtomicIsize, Ordering};
///
- /// let foo = AtomicInt::new(0b101101);
+ /// let foo = AtomicIsize::new(0b101101);
/// assert_eq!(0b101101, foo.fetch_and(0b110011, Ordering::SeqCst));
/// assert_eq!(0b100001, foo.load(Ordering::SeqCst));
#[inline]
- pub fn fetch_and(&self, val: int, order: Ordering) -> int {
+ pub fn fetch_and(&self, val: isize, order: Ordering) -> isize {
unsafe { atomic_and(self.v.get(), val, order) }
}
- /// Bitwise or with the current int, returning the previous value.
+ /// Bitwise or with the current isize, returning the previous value.
///
/// # Examples
///
/// ```
- /// use std::sync::atomic::{AtomicInt, Ordering};
+ /// use std::sync::atomic::{AtomicIsize, Ordering};
///
- /// let foo = AtomicInt::new(0b101101);
+ /// let foo = AtomicIsize::new(0b101101);
/// assert_eq!(0b101101, foo.fetch_or(0b110011, Ordering::SeqCst));
/// assert_eq!(0b111111, foo.load(Ordering::SeqCst));
#[inline]
- pub fn fetch_or(&self, val: int, order: Ordering) -> int {
+ pub fn fetch_or(&self, val: isize, order: Ordering) -> isize {
unsafe { atomic_or(self.v.get(), val, order) }
}
- /// Bitwise xor with the current int, returning the previous value.
+ /// Bitwise xor with the current isize, returning the previous value.
///
/// # Examples
///
/// ```
- /// use std::sync::atomic::{AtomicInt, Ordering};
+ /// use std::sync::atomic::{AtomicIsize, Ordering};
///
- /// let foo = AtomicInt::new(0b101101);
+ /// let foo = AtomicIsize::new(0b101101);
/// assert_eq!(0b101101, foo.fetch_xor(0b110011, Ordering::SeqCst));
/// assert_eq!(0b011110, foo.load(Ordering::SeqCst));
#[inline]
- pub fn fetch_xor(&self, val: int, order: Ordering) -> int {
+ pub fn fetch_xor(&self, val: isize, order: Ordering) -> isize {
unsafe { atomic_xor(self.v.get(), val, order) }
}
}
-#[unstable = "awaiting int/uint conventions, types may change"]
-impl AtomicUint {
- /// Creates a new `AtomicUint`.
+#[stable]
+impl AtomicUsize {
+ /// Creates a new `AtomicUsize`.
///
/// # Examples
///
/// ```
- /// use std::sync::atomic::AtomicUint;
+ /// use std::sync::atomic::AtomicUsize;
///
- /// let atomic_forty_two = AtomicUint::new(42u);
+ /// let atomic_forty_two = AtomicUsize::new(42u);
/// ```
#[inline]
- pub fn new(v: uint) -> AtomicUint {
- AtomicUint { v: UnsafeCell::new(v) }
+ pub fn new(v: usize) -> AtomicUsize {
+ AtomicUsize { v: UnsafeCell::new(v) }
}
- /// Loads a value from the uint.
+ /// Loads a value from the usize.
///
/// `load` takes an `Ordering` argument which describes the memory ordering of this operation.
///
/// # Examples
///
/// ```
- /// use std::sync::atomic::{AtomicUint, Ordering};
+ /// use std::sync::atomic::{AtomicUsize, Ordering};
///
- /// let some_uint = AtomicUint::new(5);
+ /// let some_usize = AtomicUsize::new(5);
///
- /// let value = some_uint.load(Ordering::Relaxed);
+ /// let value = some_usize.load(Ordering::Relaxed);
/// ```
#[inline]
- pub fn load(&self, order: Ordering) -> uint {
- unsafe { atomic_load(self.v.get() as *const uint, order) }
+ pub fn load(&self, order: Ordering) -> usize {
+ unsafe { atomic_load(self.v.get() as *const usize, order) }
}
- /// Stores a value into the uint.
+ /// Stores a value into the usize.
///
/// `store` takes an `Ordering` argument which describes the memory ordering of this operation.
///
/// # Examples
///
/// ```
- /// use std::sync::atomic::{AtomicUint, Ordering};
+ /// use std::sync::atomic::{AtomicUsize, Ordering};
///
- /// let some_uint = AtomicUint::new(5);
+ /// let some_usize = AtomicUsize::new(5);
///
- /// some_uint.store(10, Ordering::Relaxed);
+ /// some_usize.store(10, Ordering::Relaxed);
/// ```
///
/// # Panics
///
/// Panics if `order` is `Acquire` or `AcqRel`.
#[inline]
- pub fn store(&self, val: uint, order: Ordering) {
+ pub fn store(&self, val: usize, order: Ordering) {
unsafe { atomic_store(self.v.get(), val, order); }
}
- /// Stores a value into the uint, returning the old value.
+ /// Stores a value into the usize, returning the old value.
///
/// `swap` takes an `Ordering` argument which describes the memory ordering of this operation.
///
/// # Examples
///
/// ```
- /// use std::sync::atomic::{AtomicUint, Ordering};
+ /// use std::sync::atomic::{AtomicUsize, Ordering};
///
- /// let some_uint = AtomicUint::new(5);
+ /// let some_usize= AtomicUsize::new(5);
///
- /// let value = some_uint.swap(10, Ordering::Relaxed);
+ /// let value = some_usize.swap(10, Ordering::Relaxed);
/// ```
#[inline]
- pub fn swap(&self, val: uint, order: Ordering) -> uint {
+ pub fn swap(&self, val: usize, order: Ordering) -> usize {
unsafe { atomic_swap(self.v.get(), val, order) }
}
- /// Stores a value into the uint if the current value is the same as the expected value.
+ /// Stores a value into the usize if the current value is the same as the expected value.
///
/// If the return value is equal to `old` then the value was updated.
///
/// # Examples
///
/// ```
- /// use std::sync::atomic::{AtomicUint, Ordering};
+ /// use std::sync::atomic::{AtomicUsize, Ordering};
///
- /// let some_uint = AtomicUint::new(5);
+ /// let some_usize = AtomicUsize::new(5);
///
- /// let value = some_uint.compare_and_swap(5, 10, Ordering::Relaxed);
+ /// let value = some_usize.compare_and_swap(5, 10, Ordering::Relaxed);
/// ```
#[inline]
- pub fn compare_and_swap(&self, old: uint, new: uint, order: Ordering) -> uint {
+ pub fn compare_and_swap(&self, old: usize, new: usize, order: Ordering) -> usize {
unsafe { atomic_compare_and_swap(self.v.get(), old, new, order) }
}
- /// Add to the current uint, returning the previous value.
+ /// Add to the current usize, returning the previous value.
///
/// # Examples
///
/// ```
- /// use std::sync::atomic::{AtomicUint, Ordering};
+ /// use std::sync::atomic::{AtomicUsize, Ordering};
///
- /// let foo = AtomicUint::new(0);
+ /// let foo = AtomicUsize::new(0);
/// assert_eq!(0, foo.fetch_add(10, Ordering::SeqCst));
/// assert_eq!(10, foo.load(Ordering::SeqCst));
/// ```
#[inline]
- pub fn fetch_add(&self, val: uint, order: Ordering) -> uint {
+ pub fn fetch_add(&self, val: usize, order: Ordering) -> usize {
unsafe { atomic_add(self.v.get(), val, order) }
}
- /// Subtract from the current uint, returning the previous value.
+ /// Subtract from the current usize, returning the previous value.
///
/// # Examples
///
/// ```
- /// use std::sync::atomic::{AtomicUint, Ordering};
+ /// use std::sync::atomic::{AtomicUsize, Ordering};
///
- /// let foo = AtomicUint::new(10);
+ /// let foo = AtomicUsize::new(10);
/// assert_eq!(10, foo.fetch_sub(10, Ordering::SeqCst));
/// assert_eq!(0, foo.load(Ordering::SeqCst));
/// ```
#[inline]
- pub fn fetch_sub(&self, val: uint, order: Ordering) -> uint {
+ pub fn fetch_sub(&self, val: usize, order: Ordering) -> usize {
unsafe { atomic_sub(self.v.get(), val, order) }
}
- /// Bitwise and with the current uint, returning the previous value.
+ /// Bitwise and with the current usize, returning the previous value.
///
/// # Examples
///
/// ```
- /// use std::sync::atomic::{AtomicUint, Ordering};
+ /// use std::sync::atomic::{AtomicUsize, Ordering};
///
- /// let foo = AtomicUint::new(0b101101);
+ /// let foo = AtomicUsize::new(0b101101);
/// assert_eq!(0b101101, foo.fetch_and(0b110011, Ordering::SeqCst));
/// assert_eq!(0b100001, foo.load(Ordering::SeqCst));
#[inline]
- pub fn fetch_and(&self, val: uint, order: Ordering) -> uint {
+ pub fn fetch_and(&self, val: usize, order: Ordering) -> usize {
unsafe { atomic_and(self.v.get(), val, order) }
}
- /// Bitwise or with the current uint, returning the previous value.
+ /// Bitwise or with the current usize, returning the previous value.
///
/// # Examples
///
/// ```
- /// use std::sync::atomic::{AtomicUint, Ordering};
+ /// use std::sync::atomic::{AtomicUsize, Ordering};
///
- /// let foo = AtomicUint::new(0b101101);
+ /// let foo = AtomicUsize::new(0b101101);
/// assert_eq!(0b101101, foo.fetch_or(0b110011, Ordering::SeqCst));
/// assert_eq!(0b111111, foo.load(Ordering::SeqCst));
#[inline]
- pub fn fetch_or(&self, val: uint, order: Ordering) -> uint {
+ pub fn fetch_or(&self, val: usize, order: Ordering) -> usize {
unsafe { atomic_or(self.v.get(), val, order) }
}
- /// Bitwise xor with the current uint, returning the previous value.
+ /// Bitwise xor with the current usize, returning the previous value.
///
/// # Examples
///
/// ```
- /// use std::sync::atomic::{AtomicUint, Ordering};
+ /// use std::sync::atomic::{AtomicUsize, Ordering};
///
- /// let foo = AtomicUint::new(0b101101);
+ /// let foo = AtomicUsize::new(0b101101);
/// assert_eq!(0b101101, foo.fetch_xor(0b110011, Ordering::SeqCst));
/// assert_eq!(0b011110, foo.load(Ordering::SeqCst));
#[inline]
- pub fn fetch_xor(&self, val: uint, order: Ordering) -> uint {
+ pub fn fetch_xor(&self, val: usize, order: Ordering) -> usize {
unsafe { atomic_xor(self.v.get(), val, order) }
}
}
#[inline]
#[stable]
pub fn new(p: *mut T) -> AtomicPtr<T> {
- AtomicPtr { p: UnsafeCell::new(p as uint) }
+ AtomicPtr { p: UnsafeCell::new(p as usize) }
}
/// Loads a value from the pointer.
#[inline]
#[stable]
pub fn store(&self, ptr: *mut T, order: Ordering) {
- unsafe { atomic_store(self.p.get(), ptr as uint, order); }
+ unsafe { atomic_store(self.p.get(), ptr as usize, order); }
}
/// Stores a value into the pointer, returning the old value.
#[inline]
#[stable]
pub fn swap(&self, ptr: *mut T, order: Ordering) -> *mut T {
- unsafe { atomic_swap(self.p.get(), ptr as uint, order) as *mut T }
+ unsafe { atomic_swap(self.p.get(), ptr as usize, order) as *mut T }
}
/// Stores a value into the pointer if the current value is the same as the expected value.
#[stable]
pub fn compare_and_swap(&self, old: *mut T, new: *mut T, order: Ordering) -> *mut T {
unsafe {
- atomic_compare_and_swap(self.p.get(), old as uint,
- new as uint, order) as *mut T
+ atomic_compare_and_swap(self.p.get(), old as usize,
+ new as usize, order) as *mut T
}
}
}
}
}
}
+
+#[deprecated="renamed to AtomicIsize"]
+#[allow(missing_docs)]
+pub struct AtomicInt {
+ v: UnsafeCell<int>,
+}
+
+unsafe impl Sync for AtomicInt {}
+
+#[deprecated="renamed to AtomicUsize"]
+#[allow(missing_docs)]
+pub struct AtomicUint {
+ v: UnsafeCell<uint>,
+}
+
+unsafe impl Sync for AtomicUint {}
+
+#[deprecated="use ATOMIC_ISIZE_INIT instead"]
+#[allow(missing_docs, deprecated)]
+pub const ATOMIC_INT_INIT: AtomicInt =
+ AtomicInt { v: UnsafeCell { value: 0 } };
+#[deprecated="use ATOMIC_USIZE_INIT instead"]
+#[allow(missing_docs, deprecated)]
+pub const ATOMIC_UINT_INIT: AtomicUint =
+ AtomicUint { v: UnsafeCell { value: 0, } };
+
+#[allow(missing_docs, deprecated)]
+impl AtomicInt {
+ #[inline]
+ pub fn new(v: int) -> AtomicInt {
+ AtomicInt {v: UnsafeCell::new(v)}
+ }
+
+ #[inline]
+ pub fn load(&self, order: Ordering) -> int {
+ unsafe { atomic_load(self.v.get() as *const int, order) }
+ }
+
+ #[inline]
+ pub fn store(&self, val: int, order: Ordering) {
+ unsafe { atomic_store(self.v.get(), val, order); }
+ }
+
+ #[inline]
+ pub fn swap(&self, val: int, order: Ordering) -> int {
+ unsafe { atomic_swap(self.v.get(), val, order) }
+ }
+
+ #[inline]
+ pub fn compare_and_swap(&self, old: int, new: int, order: Ordering) -> int {
+ unsafe { atomic_compare_and_swap(self.v.get(), old, new, order) }
+ }
+
+ #[inline]
+ pub fn fetch_add(&self, val: int, order: Ordering) -> int {
+ unsafe { atomic_add(self.v.get(), val, order) }
+ }
+
+ #[inline]
+ pub fn fetch_sub(&self, val: int, order: Ordering) -> int {
+ unsafe { atomic_sub(self.v.get(), val, order) }
+ }
+
+ #[inline]
+ pub fn fetch_and(&self, val: int, order: Ordering) -> int {
+ unsafe { atomic_and(self.v.get(), val, order) }
+ }
+
+ #[inline]
+ pub fn fetch_or(&self, val: int, order: Ordering) -> int {
+ unsafe { atomic_or(self.v.get(), val, order) }
+ }
+
+ #[inline]
+ pub fn fetch_xor(&self, val: int, order: Ordering) -> int {
+ unsafe { atomic_xor(self.v.get(), val, order) }
+ }
+}
+
+#[allow(missing_docs, deprecated)]
+impl AtomicUint {
+ #[inline]
+ pub fn new(v: uint) -> AtomicUint {
+ AtomicUint { v: UnsafeCell::new(v) }
+ }
+
+ #[inline]
+ pub fn load(&self, order: Ordering) -> uint {
+ unsafe { atomic_load(self.v.get() as *const uint, order) }
+ }
+
+ #[inline]
+ pub fn store(&self, val: uint, order: Ordering) {
+ unsafe { atomic_store(self.v.get(), val, order); }
+ }
+
+ #[inline]
+ pub fn swap(&self, val: uint, order: Ordering) -> uint {
+ unsafe { atomic_swap(self.v.get(), val, order) }
+ }
+
+ #[inline]
+ pub fn compare_and_swap(&self, old: uint, new: uint, order: Ordering) -> uint {
+ unsafe { atomic_compare_and_swap(self.v.get(), old, new, order) }
+ }
+
+ #[inline]
+ pub fn fetch_add(&self, val: uint, order: Ordering) -> uint {
+ unsafe { atomic_add(self.v.get(), val, order) }
+ }
+
+ #[inline]
+ pub fn fetch_sub(&self, val: uint, order: Ordering) -> uint {
+ unsafe { atomic_sub(self.v.get(), val, order) }
+ }
+
+ #[inline]
+ pub fn fetch_and(&self, val: uint, order: Ordering) -> uint {
+ unsafe { atomic_and(self.v.get(), val, order) }
+ }
+
+ #[inline]
+ pub fn fetch_or(&self, val: uint, order: Ordering) -> uint {
+ unsafe { atomic_or(self.v.get(), val, order) }
+ }
+
+ #[inline]
+ pub fn fetch_xor(&self, val: uint, order: Ordering) -> uint {
+ unsafe { atomic_xor(self.v.get(), val, order) }
+ }
+}
//! # }
//! ```
-#![unstable]
+#![deprecated = "It is unclear if this module is more robust than implementing \
+ Drop on a custom type, and this module is being removed with no \
+ replacement. Use a custom Drop implementation to regain existing \
+ functionality."]
+#![allow(deprecated)]
use ops::{Drop, FnMut, FnOnce};
}
}
- f(unsafe { str::from_utf8_unchecked(&buf[0..end]) })
+ f(unsafe { str::from_utf8_unchecked(&buf[..end]) })
}
for c in sign.into_iter() {
let mut b = [0; 4];
let n = c.encode_utf8(&mut b).unwrap_or(0);
- let b = unsafe { str::from_utf8_unchecked(&b[0..n]) };
+ let b = unsafe { str::from_utf8_unchecked(&b[..n]) };
try!(f.buf.write_str(b));
}
if prefixed { f.buf.write_str(prefix) }
fn fmt(&self, f: &mut Formatter) -> Result {
let mut utf8 = [0u8; 4];
let amt = self.encode_utf8(&mut utf8).unwrap_or(0);
- let s: &str = unsafe { mem::transmute(&utf8[0..amt]) };
+ let s: &str = unsafe { mem::transmute(&utf8[..amt]) };
String::fmt(s, f)
}
}
/// Conversion from an `Iterator`
#[stable]
+#[rustc_on_unimplemented="a collection of type `{Self}` cannot be \
+ built from an iterator over elements of type `{A}`"]
pub trait FromIterator<A> {
/// Build a container with elements from an external iterator.
fn from_iter<T: Iterator<Item=A>>(iterator: T) -> Self;
#![feature(simd, unsafe_destructor, slicing_syntax)]
#![feature(unboxed_closures)]
#![allow(unknown_features)] #![feature(int_uint)]
+#![feature(on_unimplemented)]
#![deny(missing_docs)]
#[macro_use]
}
macro_rules! shl_impl {
- ($($t:ty)*) => ($(
+ ($t:ty, $f:ty) => (
#[stable]
- impl Shl<uint> for $t {
+ impl Shl<$f> for $t {
type Output = $t;
#[inline]
- fn shl(self, other: uint) -> $t {
+ fn shl(self, other: $f) -> $t {
self << other
}
}
+ )
+}
+
+// SNAP 9e4e524e0
+#[cfg(not(stage0))]
+macro_rules! shl_impl_all {
+ ($($t:ty)*) => ($(
+ shl_impl! { $t, u8 }
+ shl_impl! { $t, u16 }
+ shl_impl! { $t, u32 }
+ shl_impl! { $t, u64 }
+ shl_impl! { $t, usize }
+
+ shl_impl! { $t, i8 }
+ shl_impl! { $t, i16 }
+ shl_impl! { $t, i32 }
+ shl_impl! { $t, i64 }
+ shl_impl! { $t, isize }
)*)
}
-shl_impl! { uint u8 u16 u32 u64 int i8 i16 i32 i64 }
+#[cfg(stage0)]
+macro_rules! shl_impl_all {
+ ($($t:ty)*) => ($(
+ shl_impl! { $t, usize }
+ )*)
+}
+
+shl_impl_all! { u8 u16 u32 u64 usize i8 i16 i32 i64 isize }
/// The `Shr` trait is used to specify the functionality of `>>`.
///
}
macro_rules! shr_impl {
- ($($t:ty)*) => ($(
- impl Shr<uint> for $t {
+ ($t:ty, $f:ty) => (
+ impl Shr<$f> for $t {
type Output = $t;
#[inline]
- fn shr(self, other: uint) -> $t { self >> other }
+ fn shr(self, other: $f) -> $t {
+ self >> other
+ }
}
+ )
+}
+
+// SNAP 9e4e524e0
+#[cfg(not(stage0))]
+macro_rules! shr_impl_all {
+ ($($t:ty)*) => ($(
+ shr_impl! { $t, u8 }
+ shr_impl! { $t, u16 }
+ shr_impl! { $t, u32 }
+ shr_impl! { $t, u64 }
+ shr_impl! { $t, usize }
+
+ shr_impl! { $t, i8 }
+ shr_impl! { $t, i16 }
+ shr_impl! { $t, i32 }
+ shr_impl! { $t, i64 }
+ shr_impl! { $t, isize }
+ )*)
+}
+
+#[cfg(stage0)]
+macro_rules! shr_impl_all {
+ ($($t:ty)*) => ($(
+ shr_impl! { $t, usize }
)*)
}
-shr_impl! { uint u8 u16 u32 u64 int i8 i16 i32 i64 }
+shr_impl_all! { u8 u16 u32 u64 usize i8 i16 i32 i64 isize }
/// The `Index` trait is used to specify the functionality of indexing operations
/// like `arr[idx]` when used in an immutable context.
#[inline]
fn split_at(&self, mid: uint) -> (&[T], &[T]) {
- (&self[0..mid], &self[mid..])
+ (&self[..mid], &self[mid..])
}
#[inline]
#[inline]
fn init(&self) -> &[T] {
- &self[0..(self.len() - 1)]
+ &self[..(self.len() - 1)]
}
#[inline]
#[inline]
fn starts_with(&self, needle: &[T]) -> bool where T: PartialEq {
let n = needle.len();
- self.len() >= n && needle == &self[0..n]
+ self.len() >= n && needle == &self[..n]
}
#[inline]
match self.v.iter().position(|x| (self.pred)(x)) {
None => self.finish(),
Some(idx) => {
- let ret = Some(&self.v[0..idx]);
+ let ret = Some(&self.v[..idx]);
self.v = &self.v[(idx + 1)..];
ret
}
None => self.finish(),
Some(idx) => {
let ret = Some(&self.v[(idx + 1)..]);
- self.v = &self.v[0..idx];
+ self.v = &self.v[..idx];
ret
}
}
if self.size > self.v.len() {
None
} else {
- let ret = Some(&self.v[0..self.size]);
+ let ret = Some(&self.v[..self.size]);
self.v = &self.v[1..];
ret
}
//
// What's going on is we have some critical factorization (u, v) of the
// needle, and we want to determine whether u is a suffix of
- // &v[0..period]. If it is, we use "Algorithm CP1". Otherwise we use
+ // &v[..period]. If it is, we use "Algorithm CP1". Otherwise we use
// "Algorithm CP2", which is optimized for when the period of the needle
// is large.
- if &needle[0..crit_pos] == &needle[period.. period + crit_pos] {
+ if &needle[..crit_pos] == &needle[period.. period + crit_pos] {
TwoWaySearcher {
crit_pos: crit_pos,
period: period,
#[inline]
fn starts_with(&self, needle: &str) -> bool {
let n = needle.len();
- self.len() >= n && needle.as_bytes() == &self.as_bytes()[0..n]
+ self.len() >= n && needle.as_bytes() == &self.as_bytes()[..n]
}
#[inline]
#[test]
fn uint_and() {
- let x = AtomicUint::new(0xf731);
+ let x = AtomicUsize::new(0xf731);
assert_eq!(x.fetch_and(0x137f, SeqCst), 0xf731);
assert_eq!(x.load(SeqCst), 0xf731 & 0x137f);
}
#[test]
fn uint_or() {
- let x = AtomicUint::new(0xf731);
+ let x = AtomicUsize::new(0xf731);
assert_eq!(x.fetch_or(0x137f, SeqCst), 0xf731);
assert_eq!(x.load(SeqCst), 0xf731 | 0x137f);
}
#[test]
fn uint_xor() {
- let x = AtomicUint::new(0xf731);
+ let x = AtomicUsize::new(0xf731);
assert_eq!(x.fetch_xor(0x137f, SeqCst), 0xf731);
assert_eq!(x.load(SeqCst), 0xf731 ^ 0x137f);
}
#[test]
fn int_and() {
- let x = AtomicInt::new(0xf731);
+ let x = AtomicIsize::new(0xf731);
assert_eq!(x.fetch_and(0x137f, SeqCst), 0xf731);
assert_eq!(x.load(SeqCst), 0xf731 & 0x137f);
}
#[test]
fn int_or() {
- let x = AtomicInt::new(0xf731);
+ let x = AtomicIsize::new(0xf731);
assert_eq!(x.fetch_or(0x137f, SeqCst), 0xf731);
assert_eq!(x.load(SeqCst), 0xf731 | 0x137f);
}
#[test]
fn int_xor() {
- let x = AtomicInt::new(0xf731);
+ let x = AtomicIsize::new(0xf731);
assert_eq!(x.fetch_xor(0x137f, SeqCst), 0xf731);
assert_eq!(x.load(SeqCst), 0xf731 ^ 0x137f);
}
static S_BOOL : AtomicBool = ATOMIC_BOOL_INIT;
-static S_INT : AtomicInt = ATOMIC_INT_INIT;
-static S_UINT : AtomicUint = ATOMIC_UINT_INIT;
+static S_INT : AtomicIsize = ATOMIC_ISIZE_INIT;
+static S_UINT : AtomicUsize = ATOMIC_USIZE_INIT;
#[test]
fn static_init() {
fn check(input: char, expect: &[u8]) {
let mut buf = [0u8; 4];
let n = input.encode_utf8(buf.as_mut_slice()).unwrap_or(0);
- assert_eq!(&buf[0..n], expect);
+ assert_eq!(&buf[..n], expect);
}
check('x', &[0x78]);
fn check(input: char, expect: &[u16]) {
let mut buf = [0u16; 2];
let n = input.encode_utf16(buf.as_mut_slice()).unwrap_or(0);
- assert_eq!(&buf[0..n], expect);
+ assert_eq!(&buf[..n], expect);
}
check('x', &[0x0078]);
let v: &[_] = &[0i, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
assert_eq!(v[..4].iter().count(), 4);
assert_eq!(v[..10].iter().count(), 10);
- assert_eq!(v[0..0].iter().count(), 0);
+ assert_eq!(v[..0].iter().count(), 0);
}
#[test]
let v: &[_] = &[0i, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
assert_eq!(v[..4].iter().map(|&x| x).sum(), 6);
assert_eq!(v.iter().map(|&x| x).sum(), 55);
- assert_eq!(v[0..0].iter().map(|&x| x).sum(), 0);
+ assert_eq!(v[..0].iter().map(|&x| x).sum(), 0);
}
#[test]
fn test_iterator_product() {
let v: &[_] = &[0i, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
- assert_eq!(v[0..4].iter().map(|&x| x).product(), 0);
+ assert_eq!(v[..4].iter().map(|&x| x).product(), 0);
assert_eq!(v[1..5].iter().map(|&x| x).product(), 24);
- assert_eq!(v[0..0].iter().map(|&x| x).product(), 1);
+ assert_eq!(v[..0].iter().map(|&x| x).product(), 1);
}
#[test]
fn test_iterator_max() {
let v: &[_] = &[0i, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
- assert_eq!(v[0..4].iter().map(|&x| x).max(), Some(3));
+ assert_eq!(v[..4].iter().map(|&x| x).max(), Some(3));
assert_eq!(v.iter().map(|&x| x).max(), Some(10));
- assert_eq!(v[0..0].iter().map(|&x| x).max(), None);
+ assert_eq!(v[..0].iter().map(|&x| x).max(), None);
}
#[test]
fn test_iterator_min() {
let v: &[_] = &[0i, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
- assert_eq!(v[0..4].iter().map(|&x| x).min(), Some(0));
+ assert_eq!(v[..4].iter().map(|&x| x).min(), Some(0));
assert_eq!(v.iter().map(|&x| x).min(), Some(0));
- assert_eq!(v[0..0].iter().map(|&x| x).min(), None);
+ assert_eq!(v[..0].iter().map(|&x| x).min(), None);
}
#[test]
assert!(v.iter().all(|&x| x < 10));
assert!(!v.iter().all(|&x| x % 2 == 0));
assert!(!v.iter().all(|&x| x > 100));
- assert!(v[0..0].iter().all(|_| panic!()));
+ assert!(v[..0].iter().all(|_| panic!()));
}
#[test]
assert!(v.iter().any(|&x| x < 10));
assert!(v.iter().any(|&x| x % 2 == 0));
assert!(!v.iter().any(|&x| x > 100));
- assert!(!v[0..0].iter().any(|_| panic!()));
+ assert!(!v[..0].iter().any(|_| panic!()));
}
#[test]
}
#[test]
-#[cfg(any(target_arch = "x86",
- target_arch = "arm",
- target_arch = "mips",
- target_arch = "mipsel"))]
+#[cfg(target_pointer_width = "32")]
fn size_of_32() {
assert_eq!(size_of::<uint>(), 4u);
assert_eq!(size_of::<*const uint>(), 4u);
}
#[test]
-#[cfg(any(target_arch = "x86_64",
- target_arch = "aarch64"))]
+#[cfg(target_pointer_width = "64")]
fn size_of_64() {
assert_eq!(size_of::<uint>(), 8u);
assert_eq!(size_of::<*const uint>(), 8u);
}
#[test]
-#[cfg(any(target_arch = "x86",
- target_arch = "arm",
- target_arch = "mips",
- target_arch = "mipsel"))]
+#[cfg(target_pointer_width = "32")]
fn align_of_32() {
assert_eq!(align_of::<uint>(), 4u);
assert_eq!(align_of::<*const uint>(), 4u);
}
#[test]
-#[cfg(any(target_arch = "x86_64",
- target_arch = "aarch64"))]
+#[cfg(target_pointer_width = "64")]
fn align_of_64() {
assert_eq!(align_of::<uint>(), 8u);
assert_eq!(align_of::<*const uint>(), 8u);
flags: 0,
precision: CountImplied,
width: CountImplied,
- ty: &self.input[0..0],
+ ty: &self.input[..0],
};
if !self.consume(':') { return spec }
self.cur.next();
pos
}
- Some(..) | None => { return &self.input[0..0]; }
+ Some(..) | None => { return &self.input[..0]; }
};
let mut end;
loop {
#[cfg(any(target_arch = "x86",
target_arch = "arm",
target_arch = "mips",
- target_arch = "mipsel"))]
+ target_arch = "mipsel",
+ target_arch = "powerpc"))]
pub mod arch {
pub mod c95 {
pub type c_char = i8;
}
#[cfg(any(target_arch = "x86",
target_arch = "mips",
- target_arch = "mipsel"))]
+ target_arch = "mipsel",
+ target_arch = "powerpc"))]
pub mod posix88 {
pub type off_t = i32;
pub type dev_t = u64;
pub __size: [u32; 9]
}
}
- #[cfg(any(target_arch = "mips", target_arch = "mipsel"))]
+ #[cfg(any(target_arch = "mips",
+ target_arch = "mipsel",
+ target_arch = "powerpc"))]
pub mod posix01 {
use types::os::arch::c95::{c_long, c_ulong, time_t};
use types::os::arch::posix88::{gid_t, ino_t};
pub const EHWPOISON: c_int = 133;
}
- #[cfg(any(target_arch = "mips", target_arch = "mipsel"))]
+ #[cfg(any(target_arch = "mips",
+ target_arch = "mipsel",
+ target_arch = "powerpc"))]
pub mod posix88 {
use types::os::arch::c95::c_int;
use types::common::c95::c_void;
#[cfg(all(target_os = "linux",
any(target_arch = "mips",
target_arch = "mipsel",
- target_arch = "aarch64")))]
+ target_arch = "aarch64",
+ target_arch = "powerpc")))]
pub const PTHREAD_STACK_MIN: size_t = 131072;
pub const CLOCK_REALTIME: c_int = 0;
pub const SHUT_WR: c_int = 1;
pub const SHUT_RDWR: c_int = 2;
}
- #[cfg(any(target_arch = "mips", target_arch = "mipsel"))]
+ #[cfg(any(target_arch = "mips",
+ target_arch = "mipsel",
+ target_arch = "powerpc"))]
pub mod bsd44 {
use types::os::arch::c95::c_int;
pub const MAP_NONBLOCK : c_int = 0x010000;
pub const MAP_STACK : c_int = 0x020000;
}
- #[cfg(any(target_arch = "mips", target_arch = "mipsel"))]
+ #[cfg(any(target_arch = "mips",
+ target_arch = "mipsel",
+ target_arch = "powerpc"))]
pub mod extra {
use types::os::arch::c95::c_int;
/// let choices = [1i, 2, 4, 8, 16, 32];
/// let mut rng = thread_rng();
/// println!("{:?}", rng.choose(&choices));
- /// # // uncomment when slicing syntax is stable
- /// //assert_eq!(rng.choose(&choices[0..0]), None);
+ /// assert_eq!(rng.choose(&choices[..0]), None);
/// ```
fn choose<'a, T>(&mut self, values: &'a [T]) -> Option<&'a T> {
if values.is_empty() {
// there (left), and what will be appended on the end (right)
let cap = self.buf.len() - self.pos;
let (left, right) = if cap <= buf.len() {
- (&buf[0..cap], &buf[cap..])
+ (&buf[..cap], &buf[cap..])
} else {
let result: (_, &[_]) = (buf, &[]);
result
lib - bindings to LLVM
The entry-point for the compiler is main() in the librustc_trans
-crate. But the
+crate.
The 3 central data structures:
------------------------------
extern crate arena;
extern crate flate;
+extern crate fmt_macros;
extern crate getopts;
extern crate graphviz;
extern crate libc;
+extern crate regex;
extern crate rustc_llvm;
extern crate rustc_back;
extern crate serialize;
"must_use",
"stable",
"unstable",
+ "rustc_on_unimplemented",
// FIXME: #19470 this shouldn't be needed forever
"old_orphan_check",
warned |= check_must_use(cx, &it.attrs[], s.span);
}
} else {
- csearch::get_item_attrs(&cx.sess().cstore, did, |attrs| {
- warned |= check_must_use(cx, &attrs[], s.span);
- });
+ let attrs = csearch::get_item_attrs(&cx.sess().cstore, did);
+ warned |= check_must_use(cx, &attrs[], s.span);
}
}
_ => {}
let mut span = e.span;
let id = match e.node {
- ast::ExprPath(..) | ast::ExprStruct(..) => {
+ ast::ExprPath(..) | ast::ExprQPath(..) | ast::ExprStruct(..) => {
match cx.tcx.def_map.borrow().get(&e.id) {
Some(&def) => def.def_id(),
None => return
decoder::get_methods_if_impl(cstore.intr.clone(), &*cdata, def.node)
}
-pub fn get_item_attrs<F>(cstore: &cstore::CStore,
- def_id: ast::DefId,
- f: F) where
- F: FnOnce(Vec<ast::Attribute>),
-{
+pub fn get_item_attrs(cstore: &cstore::CStore,
+ def_id: ast::DefId)
+ -> Vec<ast::Attribute> {
let cdata = cstore.get_crate_data(def_id.krate);
- decoder::get_item_attrs(&*cdata, def_id.node, f)
+ decoder::get_item_attrs(&*cdata, def_id.node)
}
pub fn get_struct_fields(cstore: &cstore::CStore,
ret
}
-pub fn get_item_attrs<F>(cdata: Cmd,
- orig_node_id: ast::NodeId,
- f: F) where
- F: FnOnce(Vec<ast::Attribute>),
-{
+pub fn get_item_attrs(cdata: Cmd,
+ orig_node_id: ast::NodeId)
+ -> Vec<ast::Attribute> {
// The attributes for a tuple struct are attached to the definition, not the ctor;
// we assume that someone passing in a tuple struct ctor is actually wanting to
// look at the definition
let node_id = get_tuple_struct_definition_if_ctor(cdata, orig_node_id);
let node_id = node_id.map(|x| x.node).unwrap_or(orig_node_id);
let item = lookup_item(node_id, cdata.data());
- f(get_attributes(item));
+ get_attributes(item)
}
pub fn get_struct_field_attrs(cdata: Cmd) -> HashMap<ast::NodeId, Vec<ast::Attribute>> {
debug!("filesearch: searching lib path");
let tlib_path = make_target_lib_path(self.sysroot,
- self.triple);
+ self.triple);
if !visited_dirs.contains(tlib_path.as_vec()) {
match f(&tlib_path) {
FileMatches => found = true,
ast::ExprMac(..) |
ast::ExprClosure(..) |
ast::ExprLit(..) |
- ast::ExprPath(..) => {
+ ast::ExprPath(..) |
+ ast::ExprQPath(..) => {
self.straightline(expr, pred, None::<ast::Expr>.iter())
}
}
expression");
}
}
- ast::ExprPath(_) => {
+ ast::ExprPath(_) | ast::ExprQPath(_) => {
match v.tcx.def_map.borrow()[e.id] {
DefStatic(..) | DefConst(..) |
DefFn(..) | DefStaticMethod(..) | DefMethod(..) |
}
};
head.map(|mut head| {
- head.push_all(&r[0..col]);
+ head.push_all(&r[..col]);
head.push_all(&r[(col + 1)..]);
head
})
"{} are not allowed to have custom pointers",
self.msg());
}
- ast::ExprPath(..) => {
+ ast::ExprPath(_) | ast::ExprQPath(_) => {
match ty::resolve_expr(self.tcx, e) {
def::DefStatic(..) if self.mode == InConstant => {
let msg = "constants cannot refer to other statics, \
fn visit_expr(&mut self, e: &ast::Expr) {
match e.node {
- ast::ExprPath(..) => {
+ ast::ExprPath(_) | ast::ExprQPath(_) => {
match self.def_map.borrow().get(&e.id) {
Some(&DefStatic(def_id, _)) |
Some(&DefConst(def_id)) if
// FIXME: (#3728) we can probably do something CCI-ish
// surrounding nonlocal constants. But we don't yet.
- ast::ExprPath(_) => self.lookup_constness(e),
+ ast::ExprPath(_) | ast::ExprQPath(_) => self.lookup_constness(e),
ast::ExprRepeat(..) => general_const,
}
}
+ ast::ExprQPath(_) => {
+ match lookup_const(tcx, expr) {
+ Some(actual) => return const_expr_to_pat(tcx, actual),
+ _ => unreachable!()
+ }
+ }
+
_ => ast::PatLit(P(expr.clone()))
};
P(ast::Pat { id: expr.id, node: pat, span: expr.span })
ty::ty_float(ast::TyF64) => (f64, const_float, f64)
}))
}
- ast::ExprPath(_) => {
+ ast::ExprPath(_) | ast::ExprQPath(_) => {
match lookup_const(tcx, e) {
Some(actual_e) => eval_const_expr_partial(tcx, &*actual_e),
None => Err("non-constant path in constant expr".to_string())
ast::ExprInlineAsm(..) => {
self.require_unsafe(expr.span, "use of inline assembly");
}
- ast::ExprPath(..) => {
+ ast::ExprPath(_) | ast::ExprQPath(_) => {
if let def::DefStatic(_, true) = ty::resolve_expr(self.tcx, expr) {
self.require_unsafe(expr.span, "use of mutable static");
}
self.walk_expr(&**subexpr)
}
- ast::ExprPath(..) => { }
+ ast::ExprPath(_) | ast::ExprQPath(_) => { }
ast::ExprUnary(ast::UnDeref, ref base) => { // *base
if !self.walk_overloaded_operator(expr, &**base, Vec::new(), PassArgs::ByRef) {
self.commit_unconditionally(move || self.try(move |_| f()))
}
+ /// Execute `f` and commit only the region bindings if successful.
+ /// The function f must be very careful not to leak any non-region
+ /// variables that get created.
+ pub fn commit_regions_if_ok<T, E, F>(&self, f: F) -> Result<T, E> where
+ F: FnOnce() -> Result<T, E>
+ {
+ debug!("commit_regions_if_ok()");
+ let CombinedSnapshot { type_snapshot,
+ int_snapshot,
+ float_snapshot,
+ region_vars_snapshot } = self.start_snapshot();
+
+ let r = self.try(move |_| f());
+
+ // Roll back any non-region bindings - they should be resolved
+ // inside `f`, with, e.g. `resolve_type_vars_if_possible`.
+ self.type_variables
+ .borrow_mut()
+ .rollback_to(type_snapshot);
+ self.int_unification_table
+ .borrow_mut()
+ .rollback_to(int_snapshot);
+ self.float_unification_table
+ .borrow_mut()
+ .rollback_to(float_snapshot);
+
+ // Commit region vars that may escape through resolved types.
+ self.region_vars
+ .commit(region_vars_snapshot);
+
+ r
+ }
+
/// Execute `f`, unroll bindings on panic
pub fn try<T, E, F>(&self, f: F) -> Result<T, E> where
F: FnOnce(&CombinedSnapshot) -> Result<T, E>
fn visit_expr(ir: &mut IrMaps, expr: &Expr) {
match expr.node {
// live nodes required for uses or definitions of variables:
- ast::ExprPath(_) => {
+ ast::ExprPath(_) | ast::ExprQPath(_) => {
let def = ir.tcx.def_map.borrow()[expr.id].clone();
debug!("expr {}: path that leads to {:?}", expr.id, def);
if let DefLocal(..) = def {
match expr.node {
// Interesting cases with control flow or which gen/kill
- ast::ExprPath(_) => {
+ ast::ExprPath(_) | ast::ExprQPath(_) => {
self.access_path(expr, succ, ACC_READ | ACC_USE)
}
// just ignore such cases and treat them as reads.
match expr.node {
- ast::ExprPath(_) => succ,
+ ast::ExprPath(_) | ast::ExprQPath(_) => succ,
ast::ExprField(ref e, _) => self.propagate_through_expr(&**e, succ),
ast::ExprTupField(ref e, _) => self.propagate_through_expr(&**e, succ),
_ => self.propagate_through_expr(expr, succ)
fn write_lvalue(&mut self, expr: &Expr, succ: LiveNode, acc: uint)
-> LiveNode {
match expr.node {
- ast::ExprPath(_) => self.access_path(expr, succ, acc),
+ ast::ExprPath(_) | ast::ExprQPath(_) => {
+ self.access_path(expr, succ, acc)
+ }
// We do not track other lvalues, so just propagate through
// to their subcomponents. Also, it may happen that
ast::ExprBlock(..) | ast::ExprMac(..) | ast::ExprAddrOf(..) |
ast::ExprStruct(..) | ast::ExprRepeat(..) | ast::ExprParen(..) |
ast::ExprClosure(..) | ast::ExprPath(..) | ast::ExprBox(..) |
- ast::ExprRange(..) => {
+ ast::ExprRange(..) | ast::ExprQPath(..) => {
visit::walk_expr(this, expr);
}
ast::ExprIfLet(..) => {
fn check_lvalue(&mut self, expr: &Expr) {
match expr.node {
- ast::ExprPath(_) => {
+ ast::ExprPath(_) | ast::ExprQPath(_) => {
if let DefLocal(nid) = self.ir.tcx.def_map.borrow()[expr.id].clone() {
// Assignment to an immutable variable or argument: only legal
// if there is no later assignment. If this local is actually
}
}
- ast::ExprPath(_) => {
+ ast::ExprPath(_) | ast::ExprQPath(_) => {
let def = (*self.tcx().def_map.borrow())[expr.id];
self.cat_def(expr.id, expr.span, expr_ty, def)
}
struct type?!"),
}
}
- ast::ExprPath(..) => {
+ ast::ExprPath(_) | ast::ExprQPath(_) => {
let guard = |&: did: ast::DefId| {
let fields = ty::lookup_struct_fields(self.tcx, did);
let any_priv = fields.iter().any(|f| {
fn visit_expr(&mut self, expr: &ast::Expr) {
match expr.node {
- ast::ExprPath(_) => {
+ ast::ExprPath(_) | ast::ExprQPath(_) => {
let def = match self.tcx.def_map.borrow().get(&expr.id) {
Some(&def) => def,
None => {
//
// There are various parts of the compiler that must impose arbitrary limits
// on how deeply they recurse to prevent stack overflow. Users can override
-// this via an attribute on the crate like `#![recursion_limit(22)]`. This pass
+// this via an attribute on the crate like `#![recursion_limit="22"]`. This pass
// just peeks and looks for that attribute.
use session::Session;
}
sess.span_err(attr.span, "malformed recursion limit attribute, \
- expected #![recursion_limit(\"N\")]");
+ expected #![recursion_limit=\"N\"]");
}
}
use std::fmt;
use std::slice::Iter;
-use std::vec::Vec;
+use std::vec::{Vec, IntoIter};
use syntax::codemap::{Span, DUMMY_SP};
///////////////////////////////////////////////////////////////////////////
self.content.iter()
}
+ pub fn into_iter(self) -> IntoIter<T> {
+ self.content.into_iter()
+ }
+
pub fn iter_enumerated<'a>(&'a self) -> EnumeratedItems<'a,T> {
EnumeratedItems::new(self)
}
SelectionError,
};
+use fmt_macros::{Parser, Piece, Position};
use middle::infer::InferCtxt;
-use middle::ty::{self, AsPredicate, ReferencesError, ToPolyTraitRef};
-use syntax::codemap::Span;
+use middle::ty::{self, AsPredicate, ReferencesError, ToPolyTraitRef, TraitRef};
+use std::collections::HashMap;
+use syntax::codemap::{DUMMY_SP, Span};
+use syntax::attr::{AttributeMethods, AttrMetaMethods};
use util::ppaux::{Repr, UserString};
pub fn report_fulfillment_errors<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>,
}
}
+fn report_on_unimplemented<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>,
+ trait_ref: &TraitRef<'tcx>,
+ span: Span) -> Option<String> {
+ let def_id = trait_ref.def_id;
+ let mut report = None;
+ for item in ty::get_attrs(infcx.tcx, def_id).iter() {
+ if item.check_name("rustc_on_unimplemented") {
+ let err_sp = if item.meta().span == DUMMY_SP {
+ span
+ } else {
+ item.meta().span
+ };
+ let def = ty::lookup_trait_def(infcx.tcx, def_id);
+ let trait_str = def.trait_ref.user_string(infcx.tcx);
+ if let Some(ref istring) = item.value_str() {
+ let mut generic_map = def.generics.types.iter_enumerated()
+ .map(|(param, i, gen)| {
+ (gen.name.as_str().to_string(),
+ trait_ref.substs.types.get(param, i)
+ .user_string(infcx.tcx))
+ }).collect::<HashMap<String, String>>();
+ generic_map.insert("Self".to_string(),
+ trait_ref.self_ty().user_string(infcx.tcx));
+ let parser = Parser::new(istring.get());
+ let mut errored = false;
+ let err: String = parser.filter_map(|p| {
+ match p {
+ Piece::String(s) => Some(s),
+ Piece::NextArgument(a) => match a.position {
+ Position::ArgumentNamed(s) => match generic_map.get(s) {
+ Some(val) => Some(val.as_slice()),
+ None => {
+ infcx.tcx.sess
+ .span_err(err_sp,
+ format!("the #[rustc_on_unimplemented] \
+ attribute on \
+ trait definition for {} refers to \
+ non-existent type parameter {}",
+ trait_str, s)
+ .as_slice());
+ errored = true;
+ None
+ }
+ },
+ _ => {
+ infcx.tcx.sess
+ .span_err(err_sp,
+ format!("the #[rustc_on_unimplemented] \
+ attribute on \
+ trait definition for {} must have named \
+ format arguments, \
+ eg `#[rustc_on_unimplemented = \
+ \"foo {{T}}\"]`",
+ trait_str).as_slice());
+ errored = true;
+ None
+ }
+ }
+ }
+ }).collect();
+ // Report only if the format string checks out
+ if !errored {
+ report = Some(err);
+ }
+ } else {
+ infcx.tcx.sess.span_err(err_sp,
+ format!("the #[rustc_on_unimplemented] attribute on \
+ trait definition for {} must have a value, \
+ eg `#[rustc_on_unimplemented = \"foo\"]`",
+ trait_str).as_slice());
+ }
+ break;
+ }
+ }
+ report
+}
+
pub fn report_selection_error<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>,
obligation: &PredicateObligation<'tcx>,
error: &SelectionError<'tcx>)
note_obligation_cause(infcx, obligation);
}
- SelectionError::Unimplemented => {
- match obligation.predicate {
- ty::Predicate::Trait(ref trait_predicate) => {
- let trait_predicate =
- infcx.resolve_type_vars_if_possible(trait_predicate);
- if !trait_predicate.references_error() {
- let trait_ref = trait_predicate.to_poly_trait_ref();
- infcx.tcx.sess.span_err(
- obligation.cause.span,
- format!(
- "the trait `{}` is not implemented for the type `{}`",
- trait_ref.user_string(infcx.tcx),
- trait_ref.self_ty().user_string(infcx.tcx)).as_slice());
- }
- }
- ty::Predicate::Equate(ref predicate) => {
- let predicate = infcx.resolve_type_vars_if_possible(predicate);
- let err = infcx.equality_predicate(obligation.cause.span,
- &predicate).unwrap_err();
+ SelectionError::Unimplemented => {
+ match &obligation.cause.code {
+ &ObligationCauseCode::CompareImplMethodObligation => {
infcx.tcx.sess.span_err(
obligation.cause.span,
format!(
- "the requirement `{}` is not satisfied (`{}`)",
- predicate.user_string(infcx.tcx),
- ty::type_err_to_str(infcx.tcx, &err)).as_slice());
+ "the requirement `{}` appears on the impl \
+ method but not on the corresponding trait method",
+ obligation.predicate.user_string(infcx.tcx)).as_slice());
}
+ _ => {
+ match obligation.predicate {
+ ty::Predicate::Trait(ref trait_predicate) => {
+ let trait_predicate =
+ infcx.resolve_type_vars_if_possible(trait_predicate);
- ty::Predicate::RegionOutlives(ref predicate) => {
- let predicate = infcx.resolve_type_vars_if_possible(predicate);
- let err = infcx.region_outlives_predicate(obligation.cause.span,
- &predicate).unwrap_err();
- infcx.tcx.sess.span_err(
- obligation.cause.span,
- format!(
- "the requirement `{}` is not satisfied (`{}`)",
- predicate.user_string(infcx.tcx),
- ty::type_err_to_str(infcx.tcx, &err)).as_slice());
- }
+ if !trait_predicate.references_error() {
+ let trait_ref = trait_predicate.to_poly_trait_ref();
+ infcx.tcx.sess.span_err(
+ obligation.cause.span,
+ format!(
+ "the trait `{}` is not implemented for the type `{}`",
+ trait_ref.user_string(infcx.tcx),
+ trait_ref.self_ty().user_string(infcx.tcx)).as_slice());
+ // Check if it has a custom "#[rustc_on_unimplemented]"
+ // error message, report with that message if it does
+ let custom_note = report_on_unimplemented(infcx, &*trait_ref.0,
+ obligation.cause.span);
+ if let Some(s) = custom_note {
+ infcx.tcx.sess.span_note(obligation.cause.span,
+ s.as_slice());
+ }
+ }
+ }
- ty::Predicate::Projection(..) |
- ty::Predicate::TypeOutlives(..) => {
- let predicate =
- infcx.resolve_type_vars_if_possible(&obligation.predicate);
- infcx.tcx.sess.span_err(
- obligation.cause.span,
- format!(
- "the requirement `{}` is not satisfied",
- predicate.user_string(infcx.tcx)).as_slice());
+ ty::Predicate::Equate(ref predicate) => {
+ let predicate = infcx.resolve_type_vars_if_possible(predicate);
+ let err = infcx.equality_predicate(obligation.cause.span,
+ &predicate).unwrap_err();
+ infcx.tcx.sess.span_err(
+ obligation.cause.span,
+ format!(
+ "the requirement `{}` is not satisfied (`{}`)",
+ predicate.user_string(infcx.tcx),
+ ty::type_err_to_str(infcx.tcx, &err)).as_slice());
+ }
+
+ ty::Predicate::RegionOutlives(ref predicate) => {
+ let predicate = infcx.resolve_type_vars_if_possible(predicate);
+ let err = infcx.region_outlives_predicate(obligation.cause.span,
+ &predicate).unwrap_err();
+ infcx.tcx.sess.span_err(
+ obligation.cause.span,
+ format!(
+ "the requirement `{}` is not satisfied (`{}`)",
+ predicate.user_string(infcx.tcx),
+ ty::type_err_to_str(infcx.tcx, &err)).as_slice());
+ }
+
+ ty::Predicate::Projection(..) | ty::Predicate::TypeOutlives(..) => {
+ let predicate =
+ infcx.resolve_type_vars_if_possible(&obligation.predicate);
+ infcx.tcx.sess.span_err(
+ obligation.cause.span,
+ format!(
+ "the requirement `{}` is not satisfied",
+ predicate.user_string(infcx.tcx)).as_slice());
+ }
+ }
}
}
}
+
OutputTypeParameterMismatch(ref expected_trait_ref, ref actual_trait_ref, ref e) => {
let expected_trait_ref = infcx.resolve_type_vars_if_possible(&*expected_trait_ref);
let actual_trait_ref = infcx.resolve_type_vars_if_possible(&*actual_trait_ref);
obligation.cause.span,
format!(
"type mismatch: the type `{}` implements the trait `{}`, \
- but the trait `{}` is required ({})",
+ but the trait `{}` is required ({})",
expected_trait_ref.self_ty().user_string(infcx.tcx),
expected_trait_ref.user_string(infcx.tcx),
actual_trait_ref.user_string(infcx.tcx),
ty::type_err_to_str(infcx.tcx, e)).as_slice());
- note_obligation_cause(infcx, obligation);
+ note_obligation_cause(infcx, obligation);
}
}
}
}
fn note_obligation_cause_code<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>,
- _predicate: &ty::Predicate<'tcx>,
+ predicate: &ty::Predicate<'tcx>,
cause_span: Span,
cause_code: &ObligationCauseCode<'tcx>)
{
let parent_predicate = parent_trait_ref.as_predicate();
note_obligation_cause_code(infcx, &parent_predicate, cause_span, &*data.parent_code);
}
+ ObligationCauseCode::CompareImplMethodObligation => {
+ span_note!(tcx.sess, cause_span,
+ "the requirement `{}` appears on the impl method\
+ but not on the corresponding trait method",
+ predicate.user_string(infcx.tcx));
+ }
}
}
// static items must have `Sync` type
SharedStatic,
+
BuiltinDerivedObligation(DerivedObligationCause<'tcx>),
ImplDerivedObligation(DerivedObligationCause<'tcx>),
+
+ CompareImplMethodObligation,
}
#[derive(Clone)]
VtableImpl(VtableImplData<'tcx, N>),
/// Successful resolution to an obligation provided by the caller
- /// for some type parameter.
- VtableParam,
+ /// for some type parameter. The `Vec<N>` represents the
+ /// obligations incurred from normalizing the where-clause (if
+ /// any).
+ VtableParam(Vec<N>),
/// Virtual calls through an object
VtableObject(VtableObjectData<'tcx>),
VtableImpl(ref i) => i.iter_nested(),
VtableFnPointer(..) => (&[]).iter(),
VtableUnboxedClosure(..) => (&[]).iter(),
- VtableParam => (&[]).iter(),
+ VtableParam(ref n) => n.iter(),
VtableObject(_) => (&[]).iter(),
VtableBuiltin(ref i) => i.iter_nested(),
}
VtableImpl(ref i) => VtableImpl(i.map_nested(op)),
VtableFnPointer(ref sig) => VtableFnPointer((*sig).clone()),
VtableUnboxedClosure(d, ref s) => VtableUnboxedClosure(d, s.clone()),
- VtableParam => VtableParam,
+ VtableParam(ref n) => VtableParam(n.iter().map(op).collect()),
VtableObject(ref p) => VtableObject(p.clone()),
VtableBuiltin(ref b) => VtableBuiltin(b.map_nested(op)),
}
VtableImpl(i) => VtableImpl(i.map_move_nested(op)),
VtableFnPointer(sig) => VtableFnPointer(sig),
VtableUnboxedClosure(d, s) => VtableUnboxedClosure(d, s),
- VtableParam => VtableParam,
+ VtableParam(n) => VtableParam(n.into_iter().map(op).collect()),
VtableObject(p) => VtableObject(p),
VtableBuiltin(no) => VtableBuiltin(no.map_move_nested(op)),
}
}
self.assemble_candidates_from_projected_tys(obligation, &mut candidates);
- try!(self.assemble_candidates_from_caller_bounds(obligation, &mut candidates));
+ try!(self.assemble_candidates_from_caller_bounds(stack, &mut candidates));
debug!("candidate list size: {}", candidates.vec.len());
Ok(candidates)
}
/// supplied to find out whether it is listed among them.
///
/// Never affects inference environment.
- fn assemble_candidates_from_caller_bounds(&mut self,
- obligation: &TraitObligation<'tcx>,
- candidates: &mut SelectionCandidateSet<'tcx>)
- -> Result<(),SelectionError<'tcx>>
+ fn assemble_candidates_from_caller_bounds<'o>(&mut self,
+ stack: &TraitObligationStack<'o, 'tcx>,
+ candidates: &mut SelectionCandidateSet<'tcx>)
+ -> Result<(),SelectionError<'tcx>>
{
debug!("assemble_candidates_from_caller_bounds({})",
- obligation.repr(self.tcx()));
+ stack.obligation.repr(self.tcx()));
let caller_trait_refs: Vec<_> =
self.param_env().caller_bounds.predicates.iter()
let matching_bounds =
all_bounds.filter(
- |bound| self.infcx.probe(
- |_| self.match_poly_trait_ref(obligation, bound.clone())).is_ok());
+ |bound| self.evaluate_where_clause(stack, bound.clone()).may_apply());
let param_candidates =
matching_bounds.map(|bound| ParamCandidate(bound));
Ok(())
}
+ fn evaluate_where_clause<'o>(&mut self,
+ stack: &TraitObligationStack<'o, 'tcx>,
+ where_clause_trait_ref: ty::PolyTraitRef<'tcx>)
+ -> EvaluationResult<'tcx>
+ {
+ self.infcx().probe(move |_| {
+ match self.match_where_clause_trait_ref(stack.obligation, where_clause_trait_ref) {
+ Ok(obligations) => {
+ self.evaluate_predicates_recursively(Some(stack), obligations.iter())
+ }
+ Err(()) => {
+ EvaluatedToErr(Unimplemented)
+ }
+ }
+ })
+ }
+
/// Check for the artificial impl that the compiler will create for an obligation like `X :
/// FnMut<..>` where `X` is an unboxed closure type.
///
candidate_j: &SelectionCandidate<'tcx>)
-> bool
{
+ if candidate_i == candidate_j {
+ return true;
+ }
+
match (candidate_i, candidate_j) {
(&ImplCandidate(impl_def_id), &ParamCandidate(ref bound)) => {
debug!("Considering whether to drop param {} in favor of impl {}",
.is_ok()
})
}
+ (&BuiltinCandidate(_), &ParamCandidate(_)) => {
+ // If we have a where-clause like `Option<K> : Send`,
+ // then we wind up in a situation where there is a
+ // default rule (`Option<K>:Send if K:Send) and the
+ // where-clause that both seem applicable. Just take
+ // the where-clause in that case.
+ true
+ }
(&ProjectionCandidate, &ParamCandidate(_)) => {
// FIXME(#20297) -- this gives where clauses precedent
// over projections. Really these are just two means
// the where clauses are in scope.
true
}
+ (&ParamCandidate(ref bound1), &ParamCandidate(ref bound2)) => {
+ self.infcx.probe(|_| {
+ let bound1 =
+ project::normalize_with_depth(self,
+ stack.obligation.cause.clone(),
+ stack.obligation.recursion_depth+1,
+ bound1);
+ let bound2 =
+ project::normalize_with_depth(self,
+ stack.obligation.cause.clone(),
+ stack.obligation.recursion_depth+1,
+ bound2);
+ let origin =
+ infer::RelateOutputImplTypes(stack.obligation.cause.span);
+ self.infcx
+ .sub_poly_trait_refs(false, origin, bound1.value, bound2.value)
+ .is_ok()
+ })
+ }
_ => {
- *candidate_i == *candidate_j
+ false
}
}
}
}
ParamCandidate(param) => {
- self.confirm_param_candidate(obligation, param);
- Ok(VtableParam)
+ let obligations = self.confirm_param_candidate(obligation, param);
+ Ok(VtableParam(obligations))
}
ImplCandidate(impl_def_id) => {
ProjectionCandidate => {
self.confirm_projection_candidate(obligation);
- Ok(VtableParam)
+ Ok(VtableParam(Vec::new()))
}
}
}
fn confirm_param_candidate(&mut self,
obligation: &TraitObligation<'tcx>,
param: ty::PolyTraitRef<'tcx>)
+ -> Vec<PredicateObligation<'tcx>>
{
debug!("confirm_param_candidate({},{})",
obligation.repr(self.tcx()),
// where-clause trait-ref could be unified with the obligation
// trait-ref. Repeat that unification now without any
// transactional boundary; it should not fail.
- match self.confirm_poly_trait_refs(obligation.cause.clone(),
- obligation.predicate.to_poly_trait_ref(),
- param.clone()) {
- Ok(()) => { }
- Err(_) => {
+ match self.match_where_clause_trait_ref(obligation, param.clone()) {
+ Ok(obligations) => obligations,
+ Err(()) => {
self.tcx().sess.bug(
format!("Where clause `{}` was applicable to `{}` but now is not",
param.repr(self.tcx()),
})
}
+ /// Normalize `where_clause_trait_ref` and try to match it against
+ /// `obligation`. If successful, return any predicates that
+ /// result from the normalization. Normalization is necessary
+ /// because where-clauses are stored in the parameter environment
+ /// unnormalized.
+ fn match_where_clause_trait_ref(&mut self,
+ obligation: &TraitObligation<'tcx>,
+ where_clause_trait_ref: ty::PolyTraitRef<'tcx>)
+ -> Result<Vec<PredicateObligation<'tcx>>,()>
+ {
+ let where_clause_trait_ref =
+ project::normalize_with_depth(self,
+ obligation.cause.clone(),
+ obligation.recursion_depth+1,
+ &where_clause_trait_ref);
+
+ let () =
+ try!(self.match_poly_trait_ref(obligation, where_clause_trait_ref.value.clone()));
+
+ Ok(where_clause_trait_ref.obligations)
+ }
+
+ /// Returns `Ok` if `poly_trait_ref` being true implies that the
+ /// obligation is satisfied.
fn match_poly_trait_ref(&mut self,
obligation: &TraitObligation<'tcx>,
- where_clause_trait_ref: ty::PolyTraitRef<'tcx>)
+ poly_trait_ref: ty::PolyTraitRef<'tcx>)
-> Result<(),()>
{
- debug!("match_poly_trait_ref: obligation={} where_clause_trait_ref={}",
+ debug!("match_poly_trait_ref: obligation={} poly_trait_ref={}",
obligation.repr(self.tcx()),
- where_clause_trait_ref.repr(self.tcx()));
+ poly_trait_ref.repr(self.tcx()));
let origin = infer::RelateOutputImplTypes(obligation.cause.span);
match self.infcx.sub_poly_trait_refs(false,
origin,
- where_clause_trait_ref,
+ poly_trait_ref,
obligation.predicate.to_poly_trait_ref()) {
Ok(()) => Ok(()),
Err(_) => Err(()),
format!("VtableObject({})",
d.repr(tcx)),
- super::VtableParam =>
- format!("VtableParam"),
+ super::VtableParam(ref n) =>
+ format!("VtableParam({})",
+ n.repr(tcx)),
super::VtableBuiltin(ref d) =>
d.repr(tcx)
use util::nodemap::{FnvHashMap};
use arena::TypedArena;
-use std::borrow::BorrowFrom;
+use std::borrow::{BorrowFrom, Cow};
use std::cell::{Cell, RefCell};
use std::cmp::{self, Ordering};
use std::fmt::{self, Show};
use std::mem;
use std::ops;
use std::rc::Rc;
+use std::vec::CowVec;
use collections::enum_set::{EnumSet, CLike};
use std::collections::{HashMap, HashSet};
use syntax::abi;
/// normal trait predicate (`T : TraitRef<...>`) and one of these
/// predicates. Form #2 is a broader form in that it also permits
/// equality between arbitrary types. Processing an instance of Form
-/// #2 eventually yields one of these `ProjectionPredicate`
+/// \#2 eventually yields one of these `ProjectionPredicate`
/// instances to normalize the LHS.
#[derive(Clone, PartialEq, Eq, Hash, Show)]
pub struct ProjectionPredicate<'tcx> {
}
match expr.node {
- ast::ExprPath(..) => {
+ ast::ExprPath(_) | ast::ExprQPath(_) => {
match resolve_expr(tcx, expr) {
def::DefVariant(tid, vid, _) => {
let variant_info = enum_variant_with_id(tcx, tid, vid);
}
ty_tup(ref tys) if tys.is_empty() => ::util::ppaux::ty_to_string(cx, ty),
- ty_enum(id, _) => format!("enum {}", item_path_str(cx, id)),
+ ty_enum(id, _) => format!("enum `{}`", item_path_str(cx, id)),
ty_uniq(_) => "box".to_string(),
ty_vec(_, Some(n)) => format!("array of {} elements", n),
ty_vec(_, None) => "slice".to_string(),
format!("trait {}", item_path_str(cx, inner.principal_def_id()))
}
ty_struct(id, _) => {
- format!("struct {}", item_path_str(cx, id))
+ format!("struct `{}`", item_path_str(cx, id))
}
ty_unboxed_closure(..) => "closure".to_string(),
ty_tup(_) => "tuple".to_string(),
vec
}
-/// Iterate over attributes of a definition.
-// (This should really be an iterator, but that would require csearch and
-// decoder to use iterators instead of higher-order functions.)
-pub fn each_attr<F>(tcx: &ctxt, did: DefId, mut f: F) -> bool where
- F: FnMut(&ast::Attribute) -> bool,
-{
+/// Get the attributes of a definition.
+pub fn get_attrs<'tcx>(tcx: &'tcx ctxt, did: DefId)
+ -> CowVec<'tcx, ast::Attribute> {
if is_local(did) {
let item = tcx.map.expect_item(did.node);
- item.attrs.iter().all(|attr| f(attr))
+ Cow::Borrowed(&item.attrs[])
} else {
- info!("getting foreign attrs");
- let mut cont = true;
- csearch::get_item_attrs(&tcx.sess.cstore, did, |attrs| {
- if cont {
- cont = attrs.iter().all(|attr| f(attr));
- }
- });
- info!("done");
- cont
+ Cow::Owned(csearch::get_item_attrs(&tcx.sess.cstore, did))
}
}
/// Determine whether an item is annotated with an attribute
pub fn has_attr(tcx: &ctxt, did: DefId, attr: &str) -> bool {
- let mut found = false;
- each_attr(tcx, did, |item| {
- if item.check_name(attr) {
- found = true;
- false
- } else {
- true
- }
- });
- found
+ get_attrs(tcx, did).iter().any(|item| item.check_name(attr))
}
/// Determine whether an item is annotated with `#[repr(packed)]`
pub fn lookup_repr_hints(tcx: &ctxt, did: DefId) -> Rc<Vec<attr::ReprAttr>> {
memoized(&tcx.repr_hint_cache, did, |did: DefId| {
Rc::new(if did.krate == LOCAL_CRATE {
- let mut acc = Vec::new();
- ty::each_attr(tcx, did, |meta| {
- acc.extend(attr::find_repr_attrs(tcx.sess.diagnostic(),
- meta).into_iter());
- true
- });
- acc
+ get_attrs(tcx, did).iter().flat_map(|meta| {
+ attr::find_repr_attrs(tcx.sess.diagnostic(), meta).into_iter()
+ }).collect()
} else {
csearch::get_repr_attrs(&tcx.sess.cstore, did)
})
self.mt.repr(tcx))
}
}
+
+impl<'a, 'tcx> Repr<'tcx> for ParameterEnvironment<'a, 'tcx> {
+ fn repr(&self, tcx: &ctxt<'tcx>) -> String {
+ format!("ParameterEnvironment(\
+ free_substs={}, \
+ implicit_region_bound={}, \
+ caller_bounds={})",
+ self.free_substs.repr(tcx),
+ self.implicit_region_bound.repr(tcx),
+ self.caller_bounds.repr(tcx))
+ }
+ }
traits::VtableFnPointer(ref d) => {
traits::VtableFnPointer(d.fold_with(folder))
}
- traits::VtableParam => traits::VtableParam,
+ traits::VtableParam(ref n) => traits::VtableParam(n.fold_with(folder)),
traits::VtableBuiltin(ref d) => traits::VtableBuiltin(d.fold_with(folder)),
traits::VtableObject(ref d) => traits::VtableObject(d.fold_with(folder)),
}
}
}
+impl<'a, 'tcx> TypeFoldable<'tcx> for ty::ParameterEnvironment<'a, 'tcx> where 'tcx: 'a {
+ fn fold_with<F:TypeFolder<'tcx>>(&self, folder: &mut F) -> ty::ParameterEnvironment<'a, 'tcx> {
+ ty::ParameterEnvironment {
+ tcx: self.tcx,
+ free_substs: self.free_substs.fold_with(folder),
+ implicit_region_bound: self.implicit_region_bound.fold_with(folder),
+ caller_bounds: self.caller_bounds.fold_with(folder),
+ selection_cache: traits::SelectionCache::new(),
+ }
+ }
+}
+
///////////////////////////////////////////////////////////////////////////
// "super" routines: these are the default implementations for TypeFolder.
//
use session::Session;
use syntax::ext::base::{SyntaxExtension, NamedSyntaxExtension, NormalTT};
-use syntax::ext::base::{IdentTT, Decorator, Modifier, MacroRulesTT};
+use syntax::ext::base::{IdentTT, Decorator, Modifier, MultiModifier, MacroRulesTT};
use syntax::ext::base::{MacroExpanderFn};
use syntax::codemap::Span;
use syntax::parse::token;
IdentTT(ext, _) => IdentTT(ext, Some(self.krate_span)),
Decorator(ext) => Decorator(ext),
Modifier(ext) => Modifier(ext),
-
+ MultiModifier(ext) => MultiModifier(ext),
MacroRulesTT => {
self.sess.err("plugin tried to register a new MacroRulesTT");
return;
use session::search_paths::PathKind;
use util::nodemap::NodeMap;
+use regex::Regex;
+
use syntax::ast::NodeId;
use syntax::codemap::Span;
use syntax::diagnostic::{self, Emitter};
self.diagnostic().handler().fatal(msg)
}
pub fn span_err(&self, sp: Span, msg: &str) {
- self.diagnostic().span_err(sp, msg)
+ // Conditions for enabling multi-line errors:
+ if !msg.contains("mismatched types") &&
+ !msg.contains("type mismatch resolving") &&
+ !msg.contains("if and else have incompatible types") &&
+ !msg.contains("if may be missing an else clause") &&
+ !msg.contains("match arms have incompatible types") &&
+ !msg.contains("structure constructor specifies a structure of type") {
+ return self.diagnostic().span_err(sp, msg);
+ }
+
+ let first = Regex::new(r"[( ]expected").unwrap();
+ let second = Regex::new(r" found").unwrap();
+ let third = Regex::new(
+ r"\((values differ|lifetime|cyclic type of infinite size)").unwrap();
+
+ let mut new_msg = String::new();
+ let mut head = 0u;
+
+ // Insert `\n` before expected and found.
+ for (pos1, pos2) in first.find_iter(msg).zip(
+ second.find_iter(msg)) {
+ new_msg = new_msg +
+ // A `(` may be preceded by a space and it should be trimmed
+ msg[head..pos1.0].trim_right() + // prefix
+ "\n" + // insert before first
+ &msg[pos1.0..pos1.1] + // insert what first matched
+ &msg[pos1.1..pos2.0] + // between matches
+ "\n " + // insert before second
+ // 123
+ // `expected` is 3 char longer than `found`. To align the types, `found` gets
+ // 3 spaces prepended.
+ &msg[pos2.0..pos2.1]; // insert what second matched
+
+ head = pos2.1;
+ }
+
+ let mut tail = &msg[head..];
+ // Insert `\n` before any remaining messages which match.
+ for pos in third.find_iter(tail).take(1) {
+ // The end of the message may just be wrapped in `()` without `expected`/`found`.
+ // Push this also to a new line and add the final tail after.
+ new_msg = new_msg +
+ // `(` is usually preceded by a space and should be trimmed.
+ tail[..pos.0].trim_right() + // prefix
+ "\n" + // insert before paren
+ &tail[pos.0..]; // append the tail
+
+ tail = "";
+ }
+
+ new_msg.push_str(tail);
+ self.diagnostic().span_err(sp, &new_msg[])
}
pub fn span_err_with_code(&self, sp: Span, msg: &str, code: &str) {
self.diagnostic().span_err_with_code(sp, msg, code)
use std::slice;
-#[derive(Clone)]
+#[derive(Clone, Show)]
pub struct SearchPaths {
paths: Vec<(PathKind, Path)>,
}
iter: slice::Iter<'a, (PathKind, Path)>,
}
-#[derive(Eq, PartialEq, Clone, Copy)]
+#[derive(Eq, PartialEq, Clone, Copy, Show)]
pub enum PathKind {
Native,
Crate,
0
};
- for t in tps[0..(tps.len() - num_defaults)].iter() {
+ for t in tps[..(tps.len() - num_defaults)].iter() {
strs.push(ty_to_string(cx, *t))
}
if input.len() >= buffer_remaining {
copy_memory(
self.buffer.slice_mut(self.buffer_idx, size),
- &input[0..buffer_remaining]);
+ &input[..buffer_remaining]);
self.buffer_idx = 0;
func(&self.buffer);
i += buffer_remaining;
fn full_buffer<'s>(&'s mut self) -> &'s [u8] {
assert!(self.buffer_idx == 64);
self.buffer_idx = 0;
- return &self.buffer[0..64];
+ return &self.buffer[..64];
}
fn position(&self) -> uint { self.buffer_idx }
SawExprIndex,
SawExprRange,
SawExprPath,
+ SawExprQPath,
SawExprAddrOf(ast::Mutability),
SawExprRet,
SawExprInlineAsm(&'a ast::InlineAsm),
ExprIndex(..) => SawExprIndex,
ExprRange(..) => SawExprRange,
ExprPath(..) => SawExprPath,
+ ExprQPath(..) => SawExprQPath,
ExprAddrOf(m, _) => SawExprAddrOf(m),
ExprBreak(id) => SawExprBreak(id.map(content)),
ExprAgain(id) => SawExprAgain(id.map(content)),
use self::Arch::*;
#[allow(non_camel_case_types)]
+#[derive(Copy)]
pub enum Arch {
Armv7,
Armv7s,
"-Wl,-syslibroot".to_string(), get_sdk_root(sdk_name)]
}
+fn target_cpu(arch: Arch) -> String {
+ match arch {
+ X86_64 => "x86-64",
+ _ => "generic",
+ }.to_string()
+}
+
pub fn opts(arch: Arch) -> TargetOptions {
TargetOptions {
+ cpu: target_cpu(arch),
dynamic_linking: false,
executables: true,
// Although there is an experimental implementation of LLVM which
mod i686_unknown_linux_gnu;
mod mips_unknown_linux_gnu;
mod mipsel_unknown_linux_gnu;
+mod powerpc_unknown_linux_gnu;
mod x86_64_apple_darwin;
mod x86_64_apple_ios;
mod x86_64_pc_windows_gnu;
/// OS name to use for conditional compilation.
pub target_os: String,
/// Architecture to use for ABI considerations. Valid options: "x86", "x86_64", "arm",
- /// "aarch64", and "mips". "mips" includes "mipsel".
+ /// "aarch64", "mips", and "powerpc". "mips" includes "mipsel".
pub arch: String,
/// Optional settings with defaults.
pub options: TargetOptions,
i686_unknown_linux_gnu,
mips_unknown_linux_gnu,
mipsel_unknown_linux_gnu,
+ powerpc_unknown_linux_gnu,
arm_linux_androideabi,
arm_unknown_linux_gnueabi,
arm_unknown_linux_gnueabihf,
--- /dev/null
+// Copyright 2012 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 target::Target;
+
+pub fn target() -> Target {
+ let mut base = super::linux_base::opts();
+ base.pre_link_args.push("-m32".to_string());
+
+ Target {
+ data_layout: "E-S8-p:32:32-f64:32:64-i64:32:64-f80:32:32-n8:16:32".to_string(),
+ llvm_target: "powerpc-unknown-linux-gnu".to_string(),
+ target_endian: "big".to_string(),
+ target_pointer_width: "32".to_string(),
+ arch: "powerpc".to_string(),
+ target_os: "linux".to_string(),
+ options: base,
+ }
+}
pub fn target() -> Target {
let mut base = super::apple_base::opts();
+ base.cpu = "x86-64".to_string();
base.eliminate_frame_pointer = false;
base.pre_link_args.push("-m64".to_string());
pub fn target() -> Target {
let mut base = super::windows_base::opts();
+ base.cpu = "x86-64".to_string();
// On Win64 unwinding is handled by the OS, so we can link libgcc statically.
base.pre_link_args.push("-static-libgcc".to_string());
base.pre_link_args.push("-m64".to_string());
pub fn target() -> Target {
let mut base = super::dragonfly_base::opts();
+ base.cpu = "x86-64".to_string();
base.pre_link_args.push("-m64".to_string());
Target {
pub fn target() -> Target {
let mut base = super::freebsd_base::opts();
+ base.cpu = "x86-64".to_string();
base.pre_link_args.push("-m64".to_string());
Target {
pub fn target() -> Target {
let mut base = super::linux_base::opts();
+ base.cpu = "x86-64".to_string();
base.pre_link_args.push("-m64".to_string());
Target {
use rustc_resolve as resolve;
use rustc_trans::back::link;
use rustc_trans::back::write;
-use rustc_trans::save;
use rustc_trans::trans;
use rustc_typeck as typeck;
input: &Input,
outdir: &Option<Path>,
output: &Option<Path>,
- addl_plugins: Option<Vec<String>>) {
+ addl_plugins: Option<Vec<String>>,
+ control: CompileController) {
+ macro_rules! controller_entry_point{($point: ident, $make_state: expr) => ({
+ {
+ let state = $make_state;
+ (control.$point.callback)(state);
+ }
+ if control.$point.stop {
+ return;
+ }
+ })}
+
// We need nested scopes here, because the intermediate results can keep
// large chunks of memory alive and we want to free them as soon as
// possible to keep the peak memory usage low
let (outputs, trans, sess) = {
let (outputs, expanded_crate, id) = {
let krate = phase_1_parse_input(&sess, cfg, input);
- if stop_after_phase_1(&sess) { return; }
+
+ controller_entry_point!(after_parse,
+ CompileState::state_after_parse(input,
+ &sess,
+ outdir,
+ &krate));
+
let outputs = build_output_filenames(input,
outdir,
output,
&krate.attrs[],
&sess);
- let id = link::find_crate_name(Some(&sess), &krate.attrs[],
+ let id = link::find_crate_name(Some(&sess),
+ &krate.attrs[],
input);
let expanded_crate
- = match phase_2_configure_and_expand(&sess, krate, &id[],
+ = match phase_2_configure_and_expand(&sess,
+ krate,
+ &id[],
addl_plugins) {
None => return,
Some(k) => k
(outputs, expanded_crate, id)
};
+ controller_entry_point!(after_expand,
+ CompileState::state_after_expand(input,
+ &sess,
+ outdir,
+ &expanded_crate,
+ &id[]));
+
let mut forest = ast_map::Forest::new(expanded_crate);
let ast_map = assign_node_ids_and_map(&sess, &mut forest);
write_out_deps(&sess, input, &outputs, &id[]);
- if stop_after_phase_2(&sess) { return; }
-
let arenas = ty::CtxtArenas::new();
- let analysis = phase_3_run_analysis_passes(sess, ast_map, &arenas, id);
- phase_save_analysis(&analysis.ty_cx.sess, analysis.ty_cx.map.krate(), &analysis, outdir);
+ let analysis = phase_3_run_analysis_passes(sess,
+ ast_map,
+ &arenas,
+ id,
+ control.make_glob_map);
+
+ controller_entry_point!(after_analysis,
+ CompileState::state_after_analysis(input,
+ &analysis.ty_cx.sess,
+ outdir,
+ analysis.ty_cx.map.krate(),
+ &analysis,
+ &analysis.ty_cx));
if log_enabled!(::log::INFO) {
println!("Pre-trans");
analysis.ty_cx.print_debug_stats();
}
-
- if stop_after_phase_3(&analysis.ty_cx.sess) { return; }
let (tcx, trans) = phase_4_translate_to_llvm(analysis);
if log_enabled!(::log::INFO) {
(outputs, trans, tcx.sess)
};
phase_5_run_llvm_passes(&sess, &trans, &outputs);
- if stop_after_phase_5(&sess) { return; }
+
+ controller_entry_point!(after_llvm,
+ CompileState::state_after_llvm(input,
+ &sess,
+ outdir,
+ &trans));
+
phase_6_link_output(&sess, &trans, &outputs);
}
}
}
+/// CompileController is used to customise compilation, it allows compilation to
+/// be stopped and/or to call arbitrary code at various points in compilation.
+/// It also allows for various flags to be set to influence what information gets
+/// colelcted during compilation.
+///
+/// This is a somewhat higher level controller than a Session - the Session
+/// controls what happens in each phase, whereas the CompileController controls
+/// whether a phase is run at all and whether other code (from outside the
+/// the compiler) is run between phases.
+///
+/// Note that if compilation is set to stop and a callback is provided for a
+/// given entry point, the callback is called before compilation is stopped.
+///
+/// Expect more entry points to be added in the future.
+pub struct CompileController<'a> {
+ pub after_parse: PhaseController<'a>,
+ pub after_expand: PhaseController<'a>,
+ pub after_analysis: PhaseController<'a>,
+ pub after_llvm: PhaseController<'a>,
+
+ pub make_glob_map: resolve::MakeGlobMap,
+}
+
+impl<'a> CompileController<'a> {
+ pub fn basic() -> CompileController<'a> {
+ CompileController {
+ after_parse: PhaseController::basic(),
+ after_expand: PhaseController::basic(),
+ after_analysis: PhaseController::basic(),
+ after_llvm: PhaseController::basic(),
+ make_glob_map: resolve::MakeGlobMap::No,
+ }
+ }
+}
+
+pub struct PhaseController<'a> {
+ pub stop: bool,
+ pub callback: Box<Fn(CompileState) -> () + 'a>,
+}
+
+impl<'a> PhaseController<'a> {
+ pub fn basic() -> PhaseController<'a> {
+ PhaseController {
+ stop: false,
+ callback: box |&: _| {},
+ }
+ }
+}
+
+/// State that is passed to a callback. What state is available depends on when
+/// during compilation the callback is made. See the various constructor methods
+/// (`state_*`) in the impl to see which data is provided for any given entry point.
+pub struct CompileState<'a, 'ast: 'a, 'tcx: 'a> {
+ pub input: &'a Input,
+ pub session: &'a Session,
+ pub cfg: Option<&'a ast::CrateConfig>,
+ pub krate: Option<&'a ast::Crate>,
+ pub crate_name: Option<&'a str>,
+ pub output_filenames: Option<&'a OutputFilenames>,
+ pub out_dir: Option<&'a Path>,
+ pub expanded_crate: Option<&'a ast::Crate>,
+ pub ast_map: Option<&'a ast_map::Map<'ast>>,
+ pub analysis: Option<&'a ty::CrateAnalysis<'tcx>>,
+ pub tcx: Option<&'a ty::ctxt<'tcx>>,
+ pub trans: Option<&'a trans::CrateTranslation>,
+}
+
+impl<'a, 'ast, 'tcx> CompileState<'a, 'ast, 'tcx> {
+ fn empty(input: &'a Input,
+ session: &'a Session,
+ out_dir: &'a Option<Path>)
+ -> CompileState<'a, 'ast, 'tcx> {
+ CompileState {
+ input: input,
+ session: session,
+ out_dir: out_dir.as_ref(),
+ cfg: None,
+ krate: None,
+ crate_name: None,
+ output_filenames: None,
+ expanded_crate: None,
+ ast_map: None,
+ analysis: None,
+ tcx: None,
+ trans: None,
+ }
+ }
+
+ fn state_after_parse(input: &'a Input,
+ session: &'a Session,
+ out_dir: &'a Option<Path>,
+ krate: &'a ast::Crate)
+ -> CompileState<'a, 'ast, 'tcx> {
+ CompileState {
+ krate: Some(krate),
+ .. CompileState::empty(input, session, out_dir)
+ }
+ }
+
+ fn state_after_expand(input: &'a Input,
+ session: &'a Session,
+ out_dir: &'a Option<Path>,
+ expanded_crate: &'a ast::Crate,
+ crate_name: &'a str)
+ -> CompileState<'a, 'ast, 'tcx> {
+ CompileState {
+ crate_name: Some(crate_name),
+ expanded_crate: Some(expanded_crate),
+ .. CompileState::empty(input, session, out_dir)
+ }
+ }
+
+ fn state_after_analysis(input: &'a Input,
+ session: &'a Session,
+ out_dir: &'a Option<Path>,
+ krate: &'a ast::Crate,
+ analysis: &'a ty::CrateAnalysis<'tcx>,
+ tcx: &'a ty::ctxt<'tcx>)
+ -> CompileState<'a, 'ast, 'tcx> {
+ CompileState {
+ analysis: Some(analysis),
+ tcx: Some(tcx),
+ krate: Some(krate),
+ .. CompileState::empty(input, session, out_dir)
+ }
+ }
+
+
+ fn state_after_llvm(input: &'a Input,
+ session: &'a Session,
+ out_dir: &'a Option<Path>,
+ trans: &'a trans::CrateTranslation)
+ -> CompileState<'a, 'ast, 'tcx> {
+ CompileState {
+ trans: Some(trans),
+ .. CompileState::empty(input, session, out_dir)
+ }
+ }
+}
+
pub fn phase_1_parse_input(sess: &Session, cfg: ast::CrateConfig, input: &Input)
-> ast::Crate {
// These may be left in an incoherent state after a previous compile.
pub fn phase_3_run_analysis_passes<'tcx>(sess: Session,
ast_map: ast_map::Map<'tcx>,
arenas: &'tcx ty::CtxtArenas<'tcx>,
- name: String) -> ty::CrateAnalysis<'tcx> {
+ name: String,
+ make_glob_map: resolve::MakeGlobMap)
+ -> ty::CrateAnalysis<'tcx> {
let time_passes = sess.time_passes();
let krate = ast_map.krate();
let lang_items = time(time_passes, "language item collection", (), |_|
middle::lang_items::collect_language_items(krate, &sess));
- let make_glob_map = if save_analysis(&sess) {
- resolve::MakeGlobMap::Yes
- } else {
- resolve::MakeGlobMap::No
- };
let resolve::CrateMap {
def_map,
freevars,
}
}
-fn save_analysis(sess: &Session) -> bool {
- sess.opts.debugging_opts.save_analysis
-}
-
-pub fn phase_save_analysis(sess: &Session,
- krate: &ast::Crate,
- analysis: &ty::CrateAnalysis,
- odir: &Option<Path>) {
- if !save_analysis(sess) {
- return;
- }
- time(sess.time_passes(), "save analysis", krate, |krate|
- save::process_crate(sess, krate, analysis, odir));
-}
-
/// Run the translation phase to LLVM, after which the AST and analysis can
/// be discarded.
pub fn phase_4_translate_to_llvm<'tcx>(analysis: ty::CrateAnalysis<'tcx>)
os::setenv("PATH", old_path);
}
-pub fn stop_after_phase_3(sess: &Session) -> bool {
- if sess.opts.no_trans {
- debug!("invoked with --no-trans, returning early from compile_input");
- return true;
- }
- return false;
-}
-
-pub fn stop_after_phase_1(sess: &Session) -> bool {
- if sess.opts.parse_only {
- debug!("invoked with --parse-only, returning early from compile_input");
- return true;
- }
- if sess.opts.show_span.is_some() {
- return true;
- }
- return sess.opts.debugging_opts.ast_json_noexpand;
-}
-
-pub fn stop_after_phase_2(sess: &Session) -> bool {
- if sess.opts.no_analysis {
- debug!("invoked with --no-analysis, returning early from compile_input");
- return true;
- }
- return sess.opts.debugging_opts.ast_json;
-}
-
-pub fn stop_after_phase_5(sess: &Session) -> bool {
- if !sess.opts.output_types.iter().any(|&i| i == config::OutputTypeExe) {
- debug!("not building executable, returning early from compile_input");
- return true;
- }
- return false;
-}
-
fn escape_dep_filename(filename: &str) -> String {
// Apparently clang and gcc *only* escape spaces:
// http://llvm.org/klaus/clang/commit/9d50634cfc268ecc9a7250226dd5ca0e945240d4
pub use syntax::diagnostic;
+use driver::CompileController;
+
+use rustc_resolve as resolve;
use rustc_trans::back::link;
+use rustc_trans::save;
use rustc::session::{config, Session, build_session};
use rustc::session::config::{Input, PrintRequest, UnstableFeatures};
use rustc::lint::Lint;
use rustc::metadata;
use rustc::metadata::creader::CrateOrString::Str;
use rustc::DIAGNOSTICS;
+use rustc::util::common::time;
use std::cmp::Ordering::Equal;
use std::io;
list_metadata(&sess, &(*ifile), &mut stdout).unwrap();
}
Input::Str(_) => {
- early_error("can not list metadata for stdin");
+ early_error("cannot list metadata for stdin");
}
}
return;
}
let plugins = sess.opts.debugging_opts.extra_plugins.clone();
- driver::compile_input(sess, cfg, &input, &odir, &ofile, Some(plugins));
+ let control = build_controller(&sess);
+ driver::compile_input(sess, cfg, &input, &odir, &ofile, Some(plugins), control);
+}
+
+fn build_controller<'a>(sess: &Session) -> CompileController<'a> {
+ let mut control = CompileController::basic();
+
+ if sess.opts.parse_only ||
+ sess.opts.show_span.is_some() ||
+ sess.opts.debugging_opts.ast_json_noexpand {
+ control.after_parse.stop = true;
+ }
+
+ if sess.opts.no_analysis || sess.opts.debugging_opts.ast_json {
+ control.after_expand.stop = true;
+ }
+
+ if sess.opts.no_trans {
+ control.after_analysis.stop = true;
+ }
+
+ if !sess.opts.output_types.iter().any(|&i| i == config::OutputTypeExe) {
+ control.after_llvm.stop = true;
+ }
+
+ if sess.opts.debugging_opts.save_analysis {
+ control.after_analysis.callback = box |state| {
+ time(state.session.time_passes(), "save analysis", state.krate.unwrap(), |krate|
+ save::process_crate(state.session,
+ krate,
+ state.analysis.unwrap(),
+ state.out_dir));
+ };
+ control.make_glob_map = resolve::MakeGlobMap::Yes;
+ }
+
+ control
}
pub fn get_unstable_features_setting() -> UnstableFeatures {
use rustc::util::ppaux;
use rustc_borrowck as borrowck;
use rustc_borrowck::graphviz as borrowck_dot;
+use rustc_resolve as resolve;
use syntax::ast;
use syntax::ast_map::{self, blocks, NodePrinter};
}
PpmTyped => {
let ast_map = ast_map.expect("--pretty=typed missing ast_map");
- let analysis = driver::phase_3_run_analysis_passes(sess, ast_map, arenas, id);
+ let analysis = driver::phase_3_run_analysis_passes(sess,
+ ast_map,
+ arenas,
+ id,
+ resolve::MakeGlobMap::No);
let annotation = TypedAnnotation { analysis: analysis };
f(&annotation, payload)
}
match code {
Some(code) => {
let variants = gather_flowgraph_variants(&sess);
- let analysis = driver::phase_3_run_analysis_passes(sess, ast_map, &arenas, id);
+ let analysis = driver::phase_3_run_analysis_passes(sess,
+ ast_map,
+ &arenas,
+ id,
+ resolve::MakeGlobMap::No);
print_flowgraph(variants, analysis, code, out)
}
None => {
pub fn LLVMInitializeMipsTargetMC();
pub fn LLVMInitializeMipsAsmPrinter();
pub fn LLVMInitializeMipsAsmParser();
+ pub fn LLVMInitializePowerPCTargetInfo();
+ pub fn LLVMInitializePowerPCTarget();
+ pub fn LLVMInitializePowerPCTargetMC();
+ pub fn LLVMInitializePowerPCAsmPrinter();
+ pub fn LLVMInitializePowerPCAsmParser();
pub fn LLVMRustAddPass(PM: PassManagerRef, Pass: *const c_char) -> bool;
pub fn LLVMRustCreateTargetMachine(Triple: *const c_char,
LLVMInitializeMipsAsmPrinter();
LLVMInitializeMipsAsmParser();
+ LLVMInitializePowerPCTargetInfo();
+ LLVMInitializePowerPCTarget();
+ LLVMInitializePowerPCTargetMC();
+ LLVMInitializePowerPCAsmPrinter();
+ LLVMInitializePowerPCAsmParser();
+
LLVMRustSetLLVMOptions(0 as c_int,
0 as *const _);
use syntax::ast::{Arm, BindByRef, BindByValue, BindingMode, Block, Crate, CrateNum};
use syntax::ast::{DefId, Expr, ExprAgain, ExprBreak, ExprField};
use syntax::ast::{ExprClosure, ExprForLoop, ExprLoop, ExprWhile, ExprMethodCall};
-use syntax::ast::{ExprPath, ExprStruct, FnDecl};
+use syntax::ast::{ExprPath, ExprQPath, ExprStruct, FnDecl};
use syntax::ast::{ForeignItemFn, ForeignItemStatic, Generics};
use syntax::ast::{Ident, ImplItem, Item, ItemConst, ItemEnum, ItemFn};
use syntax::ast::{ItemForeignMod, ItemImpl, ItemMac, ItemMod, ItemStatic};
// idx +- 1 to account for the
// colons on either side
&mpath[(idx + 1)..],
- &mpath[0..(idx - 1)]);
+ &mpath[..(idx - 1)]);
return Failed(Some((span, msg)));
},
None => {
TraitImplementation => "implement",
TraitDerivation => "derive",
TraitObject => "reference",
- TraitQPath => "extract an associated type from",
+ TraitQPath => "extract an associated item from",
};
let msg = format!("attempt to {} a nonexistent trait `{}`", usage_str, path_str);
}
}
- match result_def {
- None => {
- match self.resolve_path(ty.id, path, TypeNS, true) {
- Some(def) => {
- debug!("(resolving type) resolved `{:?}` to \
- type {:?}",
- token::get_ident(path.segments.last().unwrap() .identifier),
- def);
- result_def = Some(def);
- }
- None => {
- result_def = None;
- }
- }
- }
- Some(_) => {} // Continue.
+ if let None = result_def {
+ result_def = self.resolve_path(ty.id, path, TypeNS, true);
}
match result_def {
Some(def) => {
// Write the result into the def map.
debug!("(resolving type) writing resolution for `{}` \
- (id {})",
+ (id {}) = {:?}",
self.path_names_to_string(path),
- path_id);
+ path_id, def);
self.record_def(path_id, def);
}
None => {
TyQPath(ref qpath) => {
self.resolve_type(&*qpath.self_type);
self.resolve_trait_reference(ty.id, &*qpath.trait_ref, TraitQPath);
+ for ty in qpath.item_path.parameters.types().into_iter() {
+ self.resolve_type(&**ty);
+ }
+ for binding in qpath.item_path.parameters.bindings().into_iter() {
+ self.resolve_type(&*binding.ty);
+ }
}
TyPolyTraitRef(ref bounds) => {
// The interpretation of paths depends on whether the path has
// multiple elements in it or not.
- ExprPath(ref path) => {
+ ExprPath(_) | ExprQPath(_) => {
+ let mut path_from_qpath;
+ let path = match expr.node {
+ ExprPath(ref path) => path,
+ ExprQPath(ref qpath) => {
+ self.resolve_type(&*qpath.self_type);
+ self.resolve_trait_reference(expr.id, &*qpath.trait_ref, TraitQPath);
+ path_from_qpath = qpath.trait_ref.path.clone();
+ path_from_qpath.segments.push(qpath.item_path.clone());
+ &path_from_qpath
+ }
+ _ => unreachable!()
+ };
// This is a local path in the value namespace. Walk through
// scopes looking for it.
-
- let path_name = self.path_names_to_string(path);
-
match self.resolve_path(expr.id, path, ValueNS, true) {
// Check if struct variant
Some((DefVariant(_, _, true), _)) => {
+ let path_name = self.path_names_to_string(path);
self.resolve_error(expr.span,
format!("`{}` is a struct variant name, but \
this expression \
Some(def) => {
// Write the result into the def map.
debug!("(resolving expr) resolved `{}`",
- path_name);
+ self.path_names_to_string(path));
self.record_def(expr.id, def);
}
// (The pattern matching def_tys where the id is in self.structs
// matches on regular structs while excluding tuple- and enum-like
// structs, which wouldn't result in this error.)
+ let path_name = self.path_names_to_string(path);
match self.with_no_errors(|this|
this.resolve_path(expr.id, path, TypeNS, false)) {
Some((DefTy(struct_id, _), _))
fn is_versioned_bytecode_format(bc: &[u8]) -> bool {
let magic_id_byte_count = link::RLIB_BYTECODE_OBJECT_MAGIC.len();
return bc.len() > magic_id_byte_count &&
- &bc[0..magic_id_byte_count] == link::RLIB_BYTECODE_OBJECT_MAGIC;
+ &bc[..magic_id_byte_count] == link::RLIB_BYTECODE_OBJECT_MAGIC;
}
fn extract_bytecode_format_version(bc: &[u8]) -> u32 {
llvm::LLVMInitializeMipsAsmPrinter();
llvm::LLVMInitializeMipsAsmParser();
+ llvm::LLVMInitializePowerPCTargetInfo();
+ llvm::LLVMInitializePowerPCTarget();
+ llvm::LLVMInitializePowerPCTargetMC();
+ llvm::LLVMInitializePowerPCAsmPrinter();
+ llvm::LLVMInitializePowerPCAsmParser();
+
llvm::LLVMRustSetLLVMOptions(llvm_args.len() as c_int,
llvm_args.as_ptr());
});
if len <= 2 {
return;
}
- let sub_paths = &sub_paths[0..(len-2)];
+ let sub_paths = &sub_paths[..(len-2)];
for &(ref span, ref qualname) in sub_paths.iter() {
self.fmt.sub_mod_ref_str(path.span,
*span,
span: Span,
path: &ast::Path,
ref_kind: Option<recorder::Row>) {
- if generated_code(path.span) {
+ if generated_code(span) {
return
}
visit::walk_expr(self, ex);
},
ast::ExprPath(ref path) => {
- self.process_path(ex.id, ex.span, path, None);
+ self.process_path(ex.id, path.span, path, None);
visit::walk_path(self, path);
}
+ ast::ExprQPath(ref qpath) => {
+ let mut path = qpath.trait_ref.path.clone();
+ path.segments.push(qpath.item_path.clone());
+ self.process_path(ex.id, ex.span, &path, None);
+ visit::walk_qpath(self, ex.span, &**qpath);
+ }
ast::ExprStruct(ref path, ref fields, ref base) =>
self.process_struct_lit(ex, path, fields, base),
ast::ExprMethodCall(_, _, ref args) => self.process_method_call(ex, args),
"")
}
def::DefVariant(..) => {
- paths_to_process.push((id, p.span, p.clone(), Some(ref_kind)))
+ paths_to_process.push((id, p.clone(), Some(ref_kind)))
}
// FIXME(nrc) what are these doing here?
def::DefStatic(_, _) => {}
*def)
}
}
- for &(id, span, ref path, ref_kind) in paths_to_process.iter() {
- self.process_path(id, span, path, ref_kind);
+ for &(id, ref path, ref_kind) in paths_to_process.iter() {
+ self.process_path(id, path.span, path, ref_kind);
}
self.collecting = false;
self.collected_paths.clear();
pub fn process_crate(sess: &Session,
krate: &ast::Crate,
analysis: &ty::CrateAnalysis,
- odir: &Option<Path>) {
+ odir: Option<&Path>) {
if generated_code(krate.span) {
return;
}
// find a path to dump our data to
let mut root_path = match os::getenv("DXR_RUST_TEMP_FOLDER") {
Some(val) => Path::new(val),
- None => match *odir {
- Some(ref val) => val.join("dxr"),
+ None => match odir {
+ Some(val) => val.join("dxr"),
None => Path::new("dxr-temp"),
},
};
let values = values.iter().map(|s| {
// Never take more than 1020 chars
if s.len() > 1020 {
- &s[0..1020]
+ &s[..1020]
} else {
&s[]
}
// Collect all of the matches that can match against anything.
enter_match(bcx, dm, m, col, val, |pats| {
if pat_is_binding_or_wild(dm, &*pats[col]) {
- let mut r = pats[0..col].to_vec();
+ let mut r = pats[..col].to_vec();
r.push_all(&pats[(col + 1)..]);
Some(r)
} else {
/// Checks whether the binding in `discr` is assigned to anywhere in the expression `body`
fn is_discr_reassigned(bcx: Block, discr: &ast::Expr, body: &ast::Expr) -> bool {
let (vid, field) = match discr.node {
- ast::ExprPath(..) => match bcx.def(discr.id) {
+ ast::ExprPath(_) | ast::ExprQPath(_) => match bcx.def(discr.id) {
def::DefLocal(vid) | def::DefUpvar(vid, _, _) => (vid, None),
_ => return false
},
// Default per-arch clobbers
// Basically what clang does
-#[cfg(any(target_arch = "arm",
- target_arch = "aarch64",
- target_arch = "mips",
- target_arch = "mipsel"))]
+#[cfg(not(any(target_arch = "x86", target_arch = "x86_64")))]
fn get_clobbers() -> String {
"".to_string()
}
let f = decl_rust_fn(ccx, fn_ty, name);
- csearch::get_item_attrs(&ccx.sess().cstore, did, |attrs| {
- set_llvm_fn_attrs(ccx, &attrs[], f)
- });
+ let attrs = csearch::get_item_attrs(&ccx.sess().cstore, did);
+ set_llvm_fn_attrs(ccx, &attrs[], f);
ccx.externs().borrow_mut().insert(name.to_string(), f);
f
// don't do this then linker errors can be generated where the linker
// complains that one object files has a thread local version of the
// symbol and another one doesn't.
- ty::each_attr(ccx.tcx(), did, |attr| {
+ for attr in ty::get_attrs(ccx.tcx(), did).iter() {
if attr.check_name("thread_local") {
llvm::set_thread_local(c, true);
}
- true
- });
+ }
ccx.externs().borrow_mut().insert(name.to_string(), c);
return c;
}
let mut cx = cx;
for (i, &arg) in variant.args.iter().enumerate() {
- cx = (*f)(cx,
- adt::trans_field_ptr(cx, repr, av, variant.disr_val, i),
- arg.subst(tcx, substs));
+ let arg = monomorphize::apply_param_substs(tcx, substs, &arg);
+ cx = f(cx, adt::trans_field_ptr(cx, repr, av, variant.disr_val, i), arg);
}
return cx;
}
for (small_vec_e, &ix) in small_vec.iter_mut().zip(ixs.iter()) {
*small_vec_e = C_i32(self.ccx, ix as i32);
}
- self.inbounds_gep(base, &small_vec[0..ixs.len()])
+ self.inbounds_gep(base, &small_vec[..ixs.len()])
} else {
let v = ixs.iter().map(|i| C_i32(self.ccx, *i as i32)).collect::<Vec<ValueRef>>();
self.count_insn("gepi");
use trans::cabi_x86_win64;
use trans::cabi_arm;
use trans::cabi_aarch64;
+use trans::cabi_powerpc;
use trans::cabi_mips;
use trans::type_::Type;
cabi_arm::compute_abi_info(ccx, atys, rty, ret_def, flavor)
},
"mips" => cabi_mips::compute_abi_info(ccx, atys, rty, ret_def),
+ "powerpc" => cabi_powerpc::compute_abi_info(ccx, atys, rty, ret_def),
a => ccx.sess().fatal(&format!("unrecognized arch \"{}\" in target specification", a)
[]),
}
--- /dev/null
+// Copyright 2014-2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use libc::c_uint;
+use llvm;
+use llvm::{Integer, Pointer, Float, Double, Struct, Array};
+use llvm::{StructRetAttribute, ZExtAttribute};
+use trans::cabi::{FnType, ArgType};
+use trans::context::CrateContext;
+use trans::type_::Type;
+
+use std::cmp;
+
+fn align_up_to(off: uint, a: uint) -> uint {
+ return (off + a - 1u) / a * a;
+}
+
+fn align(off: uint, ty: Type) -> uint {
+ let a = ty_align(ty);
+ return align_up_to(off, a);
+}
+
+fn ty_align(ty: Type) -> uint {
+ match ty.kind() {
+ Integer => {
+ unsafe {
+ ((llvm::LLVMGetIntTypeWidth(ty.to_ref()) as uint) + 7) / 8
+ }
+ }
+ Pointer => 4,
+ Float => 4,
+ Double => 8,
+ Struct => {
+ if ty.is_packed() {
+ 1
+ } else {
+ let str_tys = ty.field_types();
+ str_tys.iter().fold(1, |a, t| cmp::max(a, ty_align(*t)))
+ }
+ }
+ Array => {
+ let elt = ty.element_type();
+ ty_align(elt)
+ }
+ _ => panic!("ty_size: unhandled type")
+ }
+}
+
+fn ty_size(ty: Type) -> uint {
+ match ty.kind() {
+ Integer => {
+ unsafe {
+ ((llvm::LLVMGetIntTypeWidth(ty.to_ref()) as uint) + 7) / 8
+ }
+ }
+ Pointer => 4,
+ Float => 4,
+ Double => 8,
+ Struct => {
+ if ty.is_packed() {
+ let str_tys = ty.field_types();
+ str_tys.iter().fold(0, |s, t| s + ty_size(*t))
+ } else {
+ let str_tys = ty.field_types();
+ let size = str_tys.iter().fold(0, |s, t| align(s, *t) + ty_size(*t));
+ align(size, ty)
+ }
+ }
+ Array => {
+ let len = ty.array_length();
+ let elt = ty.element_type();
+ let eltsz = ty_size(elt);
+ len * eltsz
+ }
+ _ => panic!("ty_size: unhandled type")
+ }
+}
+
+fn classify_ret_ty(ccx: &CrateContext, ty: Type) -> ArgType {
+ if is_reg_ty(ty) {
+ let attr = if ty == Type::i1(ccx) { Some(ZExtAttribute) } else { None };
+ ArgType::direct(ty, None, None, attr)
+ } else {
+ ArgType::indirect(ty, Some(StructRetAttribute))
+ }
+}
+
+fn classify_arg_ty(ccx: &CrateContext, ty: Type, offset: &mut uint) -> ArgType {
+ let orig_offset = *offset;
+ let size = ty_size(ty) * 8;
+ let mut align = ty_align(ty);
+
+ align = cmp::min(cmp::max(align, 4), 8);
+ *offset = align_up_to(*offset, align);
+ *offset += align_up_to(size, align * 8) / 8;
+
+ if is_reg_ty(ty) {
+ let attr = if ty == Type::i1(ccx) { Some(ZExtAttribute) } else { None };
+ ArgType::direct(ty, None, None, attr)
+ } else {
+ ArgType::direct(
+ ty,
+ Some(struct_ty(ccx, ty)),
+ padding_ty(ccx, align, orig_offset),
+ None
+ )
+ }
+}
+
+fn is_reg_ty(ty: Type) -> bool {
+ return match ty.kind() {
+ Integer
+ | Pointer
+ | Float
+ | Double => true,
+ _ => false
+ };
+}
+
+fn padding_ty(ccx: &CrateContext, align: uint, offset: uint) -> Option<Type> {
+ if ((align - 1 ) & offset) > 0 {
+ Some(Type::i32(ccx))
+ } else {
+ None
+ }
+}
+
+fn coerce_to_int(ccx: &CrateContext, size: uint) -> Vec<Type> {
+ let int_ty = Type::i32(ccx);
+ let mut args = Vec::new();
+
+ let mut n = size / 32;
+ while n > 0 {
+ args.push(int_ty);
+ n -= 1;
+ }
+
+ let r = size % 32;
+ if r > 0 {
+ unsafe {
+ args.push(Type::from_ref(llvm::LLVMIntTypeInContext(ccx.llcx(), r as c_uint)));
+ }
+ }
+
+ args
+}
+
+fn struct_ty(ccx: &CrateContext, ty: Type) -> Type {
+ let size = ty_size(ty) * 8;
+ Type::struct_(ccx, coerce_to_int(ccx, size).as_slice(), false)
+}
+
+pub fn compute_abi_info(ccx: &CrateContext,
+ atys: &[Type],
+ rty: Type,
+ ret_def: bool) -> FnType {
+ let ret_ty = if ret_def {
+ classify_ret_ty(ccx, rty)
+ } else {
+ ArgType::direct(Type::void(ccx), None, None, None)
+ };
+
+ let sret = ret_ty.is_indirect();
+ let mut arg_tys = Vec::new();
+ let mut offset = if sret { 4 } else { 0 };
+
+ for aty in atys.iter() {
+ let ty = classify_arg_ty(ccx, *aty, &mut offset);
+ arg_tys.push(ty);
+ };
+
+ return FnType {
+ arg_tys: arg_tys,
+ ret_ty: ret_ty,
+ };
+}
debug!("callee::trans(expr={})", expr.repr(bcx.tcx()));
// pick out special kinds of expressions that can be called:
- if let ast::ExprPath(_) = expr.node {
- return trans_def(bcx, bcx.def(expr.id), expr);
+ match expr.node {
+ ast::ExprPath(_) | ast::ExprQPath(_) => {
+ return trans_def(bcx, bcx.def(expr.id), expr);
+ }
+ _ => {}
}
// any other expressions are closures:
C_array(llunitty, &vs[])
}
}
- ast::ExprPath(_) => {
+ ast::ExprPath(_) | ast::ExprQPath(_) => {
let def = cx.tcx().def_map.borrow()[e.id];
match def {
def::DefFn(..) | def::DefStaticMethod(..) | def::DefMethod(..) => {
fn get_unique_type_id_of_type<'a>(&mut self, cx: &CrateContext<'a, 'tcx>,
type_: Ty<'tcx>) -> UniqueTypeId {
- // basic type -> {:name of the type:}
- // tuple -> {tuple_(:param-uid:)*}
- // struct -> {struct_:svh: / :node-id:_<(:param-uid:),*> }
- // enum -> {enum_:svh: / :node-id:_<(:param-uid:),*> }
- // enum variant -> {variant_:variant-name:_:enum-uid:}
- // reference (&) -> {& :pointee-uid:}
- // mut reference (&mut) -> {&mut :pointee-uid:}
- // ptr (*) -> {* :pointee-uid:}
- // mut ptr (*mut) -> {*mut :pointee-uid:}
- // unique ptr (~) -> {~ :pointee-uid:}
- // @-ptr (@) -> {@ :pointee-uid:}
- // sized vec ([T; x]) -> {[:size:] :element-uid:}
- // unsized vec ([T]) -> {[] :element-uid:}
- // trait (T) -> {trait_:svh: / :node-id:_<(:param-uid:),*> }
- // closure -> {<unsafe_> <once_> :store-sigil: |(:param-uid:),* <,_...>| -> \
- // :return-type-uid: : (:bounds:)*}
- // function -> {<unsafe_> <abi_> fn( (:param-uid:)* <,_...> ) -> \
- // :return-type-uid:}
- // unique vec box (~[]) -> {HEAP_VEC_BOX<:pointee-uid:>}
- // gc box -> {GC_BOX<:pointee-uid:>}
+ // basic type -> {:name of the type:}
+ // tuple -> {tuple_(:param-uid:)*}
+ // struct -> {struct_:svh: / :node-id:_<(:param-uid:),*> }
+ // enum -> {enum_:svh: / :node-id:_<(:param-uid:),*> }
+ // enum variant -> {variant_:variant-name:_:enum-uid:}
+ // reference (&) -> {& :pointee-uid:}
+ // mut reference (&mut) -> {&mut :pointee-uid:}
+ // ptr (*) -> {* :pointee-uid:}
+ // mut ptr (*mut) -> {*mut :pointee-uid:}
+ // unique ptr (~) -> {~ :pointee-uid:}
+ // @-ptr (@) -> {@ :pointee-uid:}
+ // sized vec ([T; x]) -> {[:size:] :element-uid:}
+ // unsized vec ([T]) -> {[] :element-uid:}
+ // trait (T) -> {trait_:svh: / :node-id:_<(:param-uid:),*> }
+ // closure -> {<unsafe_> <once_> :store-sigil:
+ // |(:param-uid:),* <,_...>| -> \
+ // :return-type-uid: : (:bounds:)*}
+ // function -> {<unsafe_> <abi_> fn( (:param-uid:)* <,_...> ) -> \
+ // :return-type-uid:}
+ // unique vec box (~[]) -> {HEAP_VEC_BOX<:pointee-uid:>}
+ // gc box -> {GC_BOX<:pointee-uid:>}
+ // projection (<T as U>::V) -> {<:ty-uid: as :trait-uid:> :: :name-uid: }
match self.type_to_unique_id.get(&type_).cloned() {
Some(unique_type_id) => return unique_type_id,
principal.substs,
&mut unique_type_id);
},
+ ty::ty_projection(ref projection) => {
+ unique_type_id.push_str("<");
+
+ let self_ty = projection.trait_ref.self_ty();
+ let self_type_id = self.get_unique_type_id_of_type(cx, self_ty);
+ let self_type_id = self.get_unique_type_id_as_string(self_type_id);
+ unique_type_id.push_str(&self_type_id[]);
+
+ unique_type_id.push_str(" as ");
+
+ from_def_id_and_substs(self,
+ cx,
+ projection.trait_ref.def_id,
+ projection.trait_ref.substs,
+ &mut unique_type_id);
+
+ unique_type_id.push_str(">::");
+ unique_type_id.push_str(token::get_name(projection.item_name).get());
+ },
ty::ty_bare_fn(_, &ty::BareFnTy{ unsafety, abi, ref sig } ) => {
if unsafety == ast::Unsafety::Unsafe {
unique_type_id.push_str("unsafe ");
closure_ty,
&mut unique_type_id);
},
- _ => {
+ ty::ty_err |
+ ty::ty_infer(_) |
+ ty::ty_open(_) |
+ ty::ty_param(_) => {
cx.sess().bug(&format!("get_unique_type_id_of_type() - unexpected type: {}, {:?}",
&ppaux::ty_to_string(cx.tcx(), type_)[],
type_.sty)[])
let variable_access = IndirectVariable {
alloca: env_pointer,
- address_operations: &address_operations[0..address_op_count]
+ address_operations: &address_operations[..address_op_count]
};
declare_local(bcx,
ast::ExprLit(_) |
ast::ExprBreak(_) |
ast::ExprAgain(_) |
- ast::ExprPath(_) => {}
+ ast::ExprPath(_) |
+ ast::ExprQPath(_) => {}
ast::ExprCast(ref sub_exp, _) |
ast::ExprAddrOf(_, ref sub_exp) |
ty::ty_unboxed_closure(..) => {
output.push_str("closure");
}
+ ty::ty_projection(ref projection) => {
+ output.push_str("<");
+ let self_ty = projection.trait_ref.self_ty();
+ push_debuginfo_type_name(cx, self_ty, true, output);
+
+ output.push_str(" as ");
+
+ push_item_name(cx, projection.trait_ref.def_id, false, output);
+ push_type_params(cx, projection.trait_ref.substs, output);
+
+ output.push_str(">::");
+ output.push_str(token::get_name(projection.item_name).get());
+ }
ty::ty_err |
ty::ty_infer(_) |
ty::ty_open(_) |
- ty::ty_projection(..) |
ty::ty_param(_) => {
cx.sess().bug(&format!("debuginfo: Trying to create type name for \
unexpected type: {}", ppaux::ty_to_string(cx.tcx(), t))[]);
ast::ExprParen(ref e) => {
trans(bcx, &**e)
}
- ast::ExprPath(_) => {
+ ast::ExprPath(_) | ast::ExprQPath(_) => {
trans_def(bcx, expr, bcx.def(expr.id))
}
ast::ExprField(ref base, ident) => {
ast::ExprParen(ref e) => {
trans_into(bcx, &**e, dest)
}
- ast::ExprPath(_) => {
+ ast::ExprPath(_) | ast::ExprQPath(_) => {
trans_def_dps_unadjusted(bcx, expr, bcx.def(expr.id), dest)
}
ast::ExprIf(ref cond, ref thn, ref els) => {
format!("cannot get vtable for an object type: {}",
data.repr(bcx.tcx())).as_slice());
}
- traits::VtableParam => {
+ traits::VtableParam(..) => {
bcx.sess().bug(
&format!("resolved vtable for {} to bad vtable {} in trans",
trait_ref.repr(bcx.tcx()),
mod cabi_arm;
mod cabi_aarch64;
mod cabi_mips;
+mod cabi_powerpc;
mod foreign;
mod intrinsic;
mod debuginfo;
ast_map::NodeArg(..) |
ast_map::NodeBlock(..) |
ast_map::NodePat(..) |
+ ast_map::NodeViewItem(..) |
ast_map::NodeLocal(..) => {
ccx.sess().bug(&format!("can't monomorphize a {:?}",
map_node)[])
debug!("qpath_to_ty: trait_ref={}", trait_ref.repr(this.tcx()));
+ // `<T as Trait>::U<V>` shouldn't parse right now.
+ assert!(qpath.item_path.parameters.is_empty());
+
return this.projected_ty(ast_ty.span,
trait_ref,
- qpath.item_name.name);
+ qpath.item_path.identifier.name);
}
// Parses the programmer's textual representation of a type into our
};
instantiate_path(pcx.fcx, path, ty::lookup_item_type(tcx, enum_def_id),
- def, pat.span, pat.id);
+ None, def, pat.span, pat.id);
let pat_ty = fcx.node_ty(pat.id);
demand::eqtype(fcx, pat.span, expected, pat_ty);
} else {
ctor_scheme
};
- instantiate_path(pcx.fcx, path, path_scheme, def, pat.span, pat.id);
+ instantiate_path(pcx.fcx, path, path_scheme, None, def, pat.span, pat.id);
let pat_ty = fcx.node_ty(pat.id);
demand::eqtype(fcx, pat.span, expected, pat_ty);
}
};
+ let field_type = pcx.fcx.normalize_associated_types_in(span, &field_type);
+
check_pat(pcx, &*field.pat, field_type);
}
use super::check_expr;
use super::check_method_argument_types;
use super::err_args;
+use super::Expectation;
+use super::expected_types_for_fn_args;
use super::FnCtxt;
use super::LvaluePreference;
use super::method;
pub fn check_call<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
call_expr: &ast::Expr,
callee_expr: &ast::Expr,
- arg_exprs: &[P<ast::Expr>])
+ arg_exprs: &[P<ast::Expr>],
+ expected: Expectation<'tcx>)
{
check_expr(fcx, callee_expr);
let original_callee_ty = fcx.expr_ty(callee_expr);
match result {
None => {
// this will report an error since original_callee_ty is not a fn
- confirm_builtin_call(fcx, call_expr, original_callee_ty, arg_exprs);
+ confirm_builtin_call(fcx, call_expr, original_callee_ty, arg_exprs, expected);
}
Some(CallStep::Builtin) => {
- confirm_builtin_call(fcx, call_expr, callee_ty, arg_exprs);
+ confirm_builtin_call(fcx, call_expr, callee_ty, arg_exprs, expected);
}
Some(CallStep::Overloaded(method_callee)) => {
- confirm_overloaded_call(fcx, call_expr, arg_exprs, method_callee);
+ confirm_overloaded_call(fcx, call_expr, arg_exprs, method_callee, expected);
}
}
}
fn confirm_builtin_call<'a,'tcx>(fcx: &FnCtxt<'a,'tcx>,
call_expr: &ast::Expr,
callee_ty: Ty<'tcx>,
- arg_exprs: &[P<ast::Expr>])
+ arg_exprs: &[P<ast::Expr>],
+ expected: Expectation<'tcx>)
{
let error_fn_sig;
fcx.normalize_associated_types_in(call_expr.span, &fn_sig);
// Call the generic checker.
- let arg_exprs: Vec<_> = arg_exprs.iter().collect(); // for some weird reason we take &[&P<...>].
+ let expected_arg_tys = expected_types_for_fn_args(fcx,
+ call_expr.span,
+ expected,
+ fn_sig.output,
+ fn_sig.inputs.as_slice());
check_argument_types(fcx,
call_expr.span,
fn_sig.inputs.as_slice(),
- arg_exprs.as_slice(),
+ &expected_arg_tys[],
+ arg_exprs,
AutorefArgs::No,
fn_sig.variadic,
TupleArgumentsFlag::DontTupleArguments);
fn confirm_overloaded_call<'a,'tcx>(fcx: &FnCtxt<'a, 'tcx>,
call_expr: &ast::Expr,
arg_exprs: &[P<ast::Expr>],
- method_callee: ty::MethodCallee<'tcx>)
+ method_callee: ty::MethodCallee<'tcx>,
+ expected: Expectation<'tcx>)
{
- let arg_exprs: Vec<_> = arg_exprs.iter().collect(); // for some weird reason we take &[&P<...>].
let output_type = check_method_argument_types(fcx,
call_expr.span,
method_callee.ty,
call_expr,
- arg_exprs.as_slice(),
+ arg_exprs,
AutorefArgs::No,
- TupleArgumentsFlag::TupleArguments);
+ TupleArgumentsFlag::TupleArguments,
+ expected);
let method_call = ty::MethodCall::expr(call_expr.id);
fcx.inh.method_map.borrow_mut().insert(method_call, method_callee);
write_call(fcx, call_expr, output_type);
expr.repr(fcx.tcx()),
expected.repr(fcx.tcx()));
- let expected_sig_and_kind = expected.map_to_option(fcx, |ty| {
+ let expected_sig_and_kind = expected.to_option(fcx).and_then(|ty| {
deduce_unboxed_closure_expectations_from_expected_type(fcx, ty)
});
--- /dev/null
+// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use middle::infer;
+use middle::traits;
+use middle::ty::{self};
+use middle::subst::{self, Subst, Substs, VecPerParamSpace};
+use util::ppaux::{self, Repr};
+
+use syntax::ast;
+use syntax::codemap::{Span};
+use syntax::parse::token;
+
+use super::assoc;
+
+/// Checks that a method from an impl conforms to the signature of
+/// the same method as declared in the trait.
+///
+/// # Parameters
+///
+/// - impl_m: type of the method we are checking
+/// - impl_m_span: span to use for reporting errors
+/// - impl_m_body_id: id of the method body
+/// - trait_m: the method in the trait
+/// - impl_trait_ref: the TraitRef corresponding to the trait implementation
+
+pub fn compare_impl_method<'tcx>(tcx: &ty::ctxt<'tcx>,
+ impl_m: &ty::Method<'tcx>,
+ impl_m_span: Span,
+ impl_m_body_id: ast::NodeId,
+ trait_m: &ty::Method<'tcx>,
+ impl_trait_ref: &ty::TraitRef<'tcx>) {
+ debug!("compare_impl_method(impl_trait_ref={})",
+ impl_trait_ref.repr(tcx));
+
+ debug!("compare_impl_method: impl_trait_ref (liberated) = {}",
+ impl_trait_ref.repr(tcx));
+
+ let infcx = infer::new_infer_ctxt(tcx);
+ let mut fulfillment_cx = traits::FulfillmentContext::new();
+
+ let trait_to_impl_substs = &impl_trait_ref.substs;
+
+ // Try to give more informative error messages about self typing
+ // mismatches. Note that any mismatch will also be detected
+ // below, where we construct a canonical function type that
+ // includes the self parameter as a normal parameter. It's just
+ // that the error messages you get out of this code are a bit more
+ // inscrutable, particularly for cases where one method has no
+ // self.
+ match (&trait_m.explicit_self, &impl_m.explicit_self) {
+ (&ty::StaticExplicitSelfCategory,
+ &ty::StaticExplicitSelfCategory) => {}
+ (&ty::StaticExplicitSelfCategory, _) => {
+ tcx.sess.span_err(
+ impl_m_span,
+ format!("method `{}` has a `{}` declaration in the impl, \
+ but not in the trait",
+ token::get_name(trait_m.name),
+ ppaux::explicit_self_category_to_str(
+ &impl_m.explicit_self)).as_slice());
+ return;
+ }
+ (_, &ty::StaticExplicitSelfCategory) => {
+ tcx.sess.span_err(
+ impl_m_span,
+ format!("method `{}` has a `{}` declaration in the trait, \
+ but not in the impl",
+ token::get_name(trait_m.name),
+ ppaux::explicit_self_category_to_str(
+ &trait_m.explicit_self)).as_slice());
+ return;
+ }
+ _ => {
+ // Let the type checker catch other errors below
+ }
+ }
+
+ let num_impl_m_type_params = impl_m.generics.types.len(subst::FnSpace);
+ let num_trait_m_type_params = trait_m.generics.types.len(subst::FnSpace);
+ if num_impl_m_type_params != num_trait_m_type_params {
+ span_err!(tcx.sess, impl_m_span, E0049,
+ "method `{}` has {} type parameter{} \
+ but its trait declaration has {} type parameter{}",
+ token::get_name(trait_m.name),
+ num_impl_m_type_params,
+ if num_impl_m_type_params == 1 {""} else {"s"},
+ num_trait_m_type_params,
+ if num_trait_m_type_params == 1 {""} else {"s"});
+ return;
+ }
+
+ if impl_m.fty.sig.0.inputs.len() != trait_m.fty.sig.0.inputs.len() {
+ span_err!(tcx.sess, impl_m_span, E0050,
+ "method `{}` has {} parameter{} \
+ but the declaration in trait `{}` has {}",
+ token::get_name(trait_m.name),
+ impl_m.fty.sig.0.inputs.len(),
+ if impl_m.fty.sig.0.inputs.len() == 1 {""} else {"s"},
+ ty::item_path_str(tcx, trait_m.def_id),
+ trait_m.fty.sig.0.inputs.len());
+ return;
+ }
+
+ // This code is best explained by example. Consider a trait:
+ //
+ // trait Trait<'t,T> {
+ // fn method<'a,M>(t: &'t T, m: &'a M) -> Self;
+ // }
+ //
+ // And an impl:
+ //
+ // impl<'i, 'j, U> Trait<'j, &'i U> for Foo {
+ // fn method<'b,N>(t: &'j &'i U, m: &'b N) -> Foo;
+ // }
+ //
+ // We wish to decide if those two method types are compatible.
+ //
+ // We start out with trait_to_impl_substs, that maps the trait
+ // type parameters to impl type parameters. This is taken from the
+ // impl trait reference:
+ //
+ // trait_to_impl_substs = {'t => 'j, T => &'i U, Self => Foo}
+ //
+ // We create a mapping `dummy_substs` that maps from the impl type
+ // parameters to fresh types and regions. For type parameters,
+ // this is the identity transform, but we could as well use any
+ // skolemized types. For regions, we convert from bound to free
+ // regions (Note: but only early-bound regions, i.e., those
+ // declared on the impl or used in type parameter bounds).
+ //
+ // impl_to_skol_substs = {'i => 'i0, U => U0, N => N0 }
+ //
+ // Now we can apply skol_substs to the type of the impl method
+ // to yield a new function type in terms of our fresh, skolemized
+ // types:
+ //
+ // <'b> fn(t: &'i0 U0, m: &'b) -> Foo
+ //
+ // We now want to extract and substitute the type of the *trait*
+ // method and compare it. To do so, we must create a compound
+ // substitution by combining trait_to_impl_substs and
+ // impl_to_skol_substs, and also adding a mapping for the method
+ // type parameters. We extend the mapping to also include
+ // the method parameters.
+ //
+ // trait_to_skol_substs = { T => &'i0 U0, Self => Foo, M => N0 }
+ //
+ // Applying this to the trait method type yields:
+ //
+ // <'a> fn(t: &'i0 U0, m: &'a) -> Foo
+ //
+ // This type is also the same but the name of the bound region ('a
+ // vs 'b). However, the normal subtyping rules on fn types handle
+ // this kind of equivalency just fine.
+ //
+ // We now use these subsititions to ensure that all declared bounds are
+ // satisfied by the implementation's method.
+ //
+ // We do this by creating a parameter environment which contains a
+ // substition corresponding to impl_to_skol_substs. We then build
+ // trait_to_skol_substs and use it to convert the predicates contained
+ // in the trait_m.generics to the skolemized form.
+ //
+ // Finally we register each of these predicates as an obligation in
+ // a fresh FulfillmentCtxt, and invoke select_all_or_error.
+
+ // Create a parameter environment that represents the implementation's
+ // method.
+ let impl_param_env =
+ ty::ParameterEnvironment::for_item(tcx, impl_m.def_id.node);
+
+ // Create mapping from impl to skolemized.
+ let impl_to_skol_substs = &impl_param_env.free_substs;
+
+ // Create mapping from trait to skolemized.
+ let trait_to_skol_substs =
+ trait_to_impl_substs
+ .subst(tcx, impl_to_skol_substs)
+ .with_method(impl_to_skol_substs.types.get_slice(subst::FnSpace).to_vec(),
+ impl_to_skol_substs.regions().get_slice(subst::FnSpace).to_vec());
+ debug!("compare_impl_method: trait_to_skol_substs={}",
+ trait_to_skol_substs.repr(tcx));
+
+ // Check region bounds. FIXME(@jroesch) refactor this away when removing
+ // ParamBounds.
+ if !check_region_bounds_on_impl_method(tcx,
+ impl_m_span,
+ impl_m,
+ &trait_m.generics,
+ &impl_m.generics,
+ &trait_to_skol_substs,
+ impl_to_skol_substs) {
+ return;
+ }
+
+ // Create obligations for each predicate declared by the impl
+ // definition in the context of the trait's parameter
+ // environment. We can't just use `impl_env.caller_bounds`,
+ // however, because we want to replace all late-bound regions with
+ // region variables.
+ let impl_bounds =
+ impl_m.generics.to_bounds(tcx, impl_to_skol_substs);
+
+ let (impl_bounds, _) =
+ infcx.replace_late_bound_regions_with_fresh_var(
+ impl_m_span,
+ infer::HigherRankedType,
+ &ty::Binder(impl_bounds));
+ debug!("compare_impl_method: impl_bounds={}",
+ impl_bounds.repr(tcx));
+
+ // // Normalize the associated types in the impl_bounds.
+ // let traits::Normalized { value: impl_bounds, .. } =
+ // traits::normalize(&mut selcx, normalize_cause.clone(), &impl_bounds);
+
+ // Normalize the associated types in the trait_bounds.
+ let trait_bounds = trait_m.generics.to_bounds(tcx, &trait_to_skol_substs);
+ // let traits::Normalized { value: trait_bounds, .. } =
+ // traits::normalize(&mut selcx, normalize_cause, &trait_bounds);
+
+ // Obtain the predicate split predicate sets for each.
+ let trait_pred = trait_bounds.predicates.split();
+ let impl_pred = impl_bounds.predicates.split();
+
+ // This is the only tricky bit of the new way we check implementation methods
+ // We need to build a set of predicates where only the FnSpace bounds
+ // are from the trait and we assume all other bounds from the implementation
+ // to be previously satisfied.
+ //
+ // We then register the obligations from the impl_m and check to see
+ // if all constraints hold.
+ let hybrid_preds = VecPerParamSpace::new(
+ impl_pred.types,
+ impl_pred.selfs,
+ trait_pred.fns
+ );
+
+ // Construct trait parameter environment and then shift it into the skolemized viewpoint.
+ let mut trait_param_env = impl_param_env.clone();
+ // The key step here is to update the caller_bounds's predicates to be
+ // the new hybrid bounds we computed.
+ trait_param_env.caller_bounds.predicates = hybrid_preds;
+
+ debug!("compare_impl_method: trait_bounds={}",
+ trait_param_env.caller_bounds.repr(tcx));
+
+ let mut selcx = traits::SelectionContext::new(&infcx, &trait_param_env);
+
+ let normalize_cause =
+ traits::ObligationCause::misc(impl_m_span, impl_m_body_id);
+
+ for predicate in impl_pred.fns.into_iter() {
+ let traits::Normalized { value: predicate, .. } =
+ traits::normalize(&mut selcx, normalize_cause.clone(), &predicate);
+
+ let cause = traits::ObligationCause {
+ span: impl_m_span,
+ body_id: impl_m_body_id,
+ code: traits::ObligationCauseCode::CompareImplMethodObligation
+ };
+
+ fulfillment_cx.register_predicate_obligation(
+ &infcx,
+ traits::Obligation::new(cause, predicate));
+ }
+
+ // We now need to check that the signature of the impl method is
+ // compatible with that of the trait method. We do this by
+ // checking that `impl_fty <: trait_fty`.
+ //
+ // FIXME. Unfortunately, this doesn't quite work right now because
+ // associated type normalization is not integrated into subtype
+ // checks. For the comparison to be valid, we need to
+ // normalize the associated types in the impl/trait methods
+ // first. However, because function types bind regions, just
+ // calling `normalize_associated_types_in` would have no effect on
+ // any associated types appearing in the fn arguments or return
+ // type.
+
+ // Compute skolemized form of impl and trait method tys.
+ let impl_fty = ty::mk_bare_fn(tcx, None, tcx.mk_bare_fn(impl_m.fty.clone()));
+ let impl_fty = impl_fty.subst(tcx, impl_to_skol_substs);
+ let trait_fty = ty::mk_bare_fn(tcx, None, tcx.mk_bare_fn(trait_m.fty.clone()));
+ let trait_fty = trait_fty.subst(tcx, &trait_to_skol_substs);
+
+ let err = infcx.try(|snapshot| {
+ let origin = infer::MethodCompatCheck(impl_m_span);
+
+ let (impl_sig, _) =
+ infcx.replace_late_bound_regions_with_fresh_var(impl_m_span,
+ infer::HigherRankedType,
+ &impl_m.fty.sig);
+ let impl_sig =
+ impl_sig.subst(tcx, impl_to_skol_substs);
+ let impl_sig =
+ assoc::normalize_associated_types_in(&infcx,
+ &impl_param_env,
+ &mut fulfillment_cx,
+ impl_m_span,
+ impl_m_body_id,
+ &impl_sig);
+ let impl_fty =
+ ty::mk_bare_fn(tcx,
+ None,
+ tcx.mk_bare_fn(ty::BareFnTy { unsafety: impl_m.fty.unsafety,
+ abi: impl_m.fty.abi,
+ sig: ty::Binder(impl_sig) }));
+ debug!("compare_impl_method: impl_fty={}",
+ impl_fty.repr(tcx));
+
+ let (trait_sig, skol_map) =
+ infcx.skolemize_late_bound_regions(&trait_m.fty.sig, snapshot);
+ let trait_sig =
+ trait_sig.subst(tcx, &trait_to_skol_substs);
+ let trait_sig =
+ assoc::normalize_associated_types_in(&infcx,
+ &impl_param_env,
+ &mut fulfillment_cx,
+ impl_m_span,
+ impl_m_body_id,
+ &trait_sig);
+ let trait_fty =
+ ty::mk_bare_fn(tcx,
+ None,
+ tcx.mk_bare_fn(ty::BareFnTy { unsafety: trait_m.fty.unsafety,
+ abi: trait_m.fty.abi,
+ sig: ty::Binder(trait_sig) }));
+
+ debug!("compare_impl_method: trait_fty={}",
+ trait_fty.repr(tcx));
+
+ try!(infer::mk_subty(&infcx, false, origin, impl_fty, trait_fty));
+
+ infcx.leak_check(&skol_map, snapshot)
+ });
+
+ match err {
+ Ok(()) => { }
+ Err(terr) => {
+ debug!("checking trait method for compatibility: impl ty {}, trait ty {}",
+ impl_fty.repr(tcx),
+ trait_fty.repr(tcx));
+ span_err!(tcx.sess, impl_m_span, E0053,
+ "method `{}` has an incompatible type for trait: {}",
+ token::get_name(trait_m.name),
+ ty::type_err_to_str(tcx, &terr));
+ return;
+ }
+ }
+
+ // Check that all obligations are satisfied by the implementation's
+ // version.
+ match fulfillment_cx.select_all_or_error(&infcx, &trait_param_env) {
+ Err(ref errors) => { traits::report_fulfillment_errors(&infcx, errors) }
+ Ok(_) => {}
+ }
+
+ // Finally, resolve all regions. This catches wily misuses of lifetime
+ // parameters.
+ infcx.resolve_regions_and_report_errors(impl_m_body_id);
+
+ fn check_region_bounds_on_impl_method<'tcx>(tcx: &ty::ctxt<'tcx>,
+ span: Span,
+ impl_m: &ty::Method<'tcx>,
+ trait_generics: &ty::Generics<'tcx>,
+ impl_generics: &ty::Generics<'tcx>,
+ trait_to_skol_substs: &Substs<'tcx>,
+ impl_to_skol_substs: &Substs<'tcx>)
+ -> bool
+ {
+
+ let trait_params = trait_generics.regions.get_slice(subst::FnSpace);
+ let impl_params = impl_generics.regions.get_slice(subst::FnSpace);
+
+ debug!("check_region_bounds_on_impl_method: \
+ trait_generics={} \
+ impl_generics={} \
+ trait_to_skol_substs={} \
+ impl_to_skol_substs={}",
+ trait_generics.repr(tcx),
+ impl_generics.repr(tcx),
+ trait_to_skol_substs.repr(tcx),
+ impl_to_skol_substs.repr(tcx));
+
+ // Must have same number of early-bound lifetime parameters.
+ // Unfortunately, if the user screws up the bounds, then this
+ // will change classification between early and late. E.g.,
+ // if in trait we have `<'a,'b:'a>`, and in impl we just have
+ // `<'a,'b>`, then we have 2 early-bound lifetime parameters
+ // in trait but 0 in the impl. But if we report "expected 2
+ // but found 0" it's confusing, because it looks like there
+ // are zero. Since I don't quite know how to phrase things at
+ // the moment, give a kind of vague error message.
+ if trait_params.len() != impl_params.len() {
+ tcx.sess.span_err(
+ span,
+ &format!("lifetime parameters or bounds on method `{}` do \
+ not match the trait declaration",
+ token::get_name(impl_m.name))[]);
+ return false;
+ }
+
+ return true;
+ }
+}
pub use self::LvaluePreference::*;
pub use self::Expectation::*;
+pub use self::compare_method::compare_impl_method;
use self::IsBinopAssignment::*;
use self::TupleArgumentsFlag::*;
use astconv::{self, ast_region_to_region, ast_ty_to_ty, AstConv};
use check::_match::pat_ctxt;
+use fmt_macros::{Parser, Piece, Position};
use middle::{const_eval, def};
use middle::infer;
use middle::lang_items::IteratorItem;
use middle::lang_items::TypeIdLangItem;
use lint;
use util::common::{block_query, indenter, loop_query};
-use util::ppaux::{self, UserString, Repr};
+use util::ppaux::{self, Repr};
use util::nodemap::{DefIdMap, FnvHashMap, NodeMap};
use std::cell::{Cell, Ref, RefCell};
use std::mem::replace;
use std::rc::Rc;
use std::iter::repeat;
+use std::slice;
use syntax::{self, abi, attr};
+use syntax::attr::AttrMetaMethods;
use syntax::ast::{self, ProvidedMethod, RequiredMethod, TypeTraitItem, DefId};
use syntax::ast_util::{self, local_def, PostExpansionMethod};
use syntax::codemap::{self, Span};
pub mod wf;
mod closure;
mod callee;
+mod compare_method;
-/// Fields that are part of a `FnCtxt` which are inherited by
/// closures defined within the function. For example:
///
/// fn foo() {
}
}
- ast::ItemTrait(_, _, _, ref trait_methods) => {
+ ast::ItemTrait(_, ref generics, _, ref trait_methods) => {
+ check_trait_on_unimplemented(ccx, generics, it);
let trait_def = ty::lookup_trait_def(ccx.tcx, local_def(it.id));
for trait_method in trait_methods.iter() {
match *trait_method {
}
}
+fn check_trait_on_unimplemented<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>,
+ generics: &ast::Generics,
+ item: &ast::Item) {
+ if let Some(ref attr) = item.attrs.iter().find(|&: a| {
+ a.check_name("rustc_on_unimplemented")
+ }) {
+ if let Some(ref istring) = attr.value_str() {
+ let mut parser = Parser::new(istring.get());
+ let types = generics.ty_params.as_slice();
+ for token in parser {
+ match token {
+ Piece::String(_) => (), // Normal string, no need to check it
+ Piece::NextArgument(a) => match a.position {
+ // `{Self}` is allowed
+ Position::ArgumentNamed(s) if s == "Self" => (),
+ // So is `{A}` if A is a type parameter
+ Position::ArgumentNamed(s) => match types.iter().find(|t| {
+ t.ident.as_str() == s
+ }) {
+ Some(_) => (),
+ None => {
+ ccx.tcx.sess.span_err(attr.span,
+ format!("there is no type parameter \
+ {} on trait {}",
+ s, item.ident.as_str())
+ .as_slice());
+ }
+ },
+ // `{:1}` and `{}` are not to be used
+ Position::ArgumentIs(_) | Position::ArgumentNext => {
+ ccx.tcx.sess.span_err(attr.span,
+ "only named substitution \
+ parameters are allowed");
+ }
+ }
+ }
+ }
+ } else {
+ ccx.tcx.sess.span_err(attr.span,
+ "this attribute must have a value, \
+ eg `#[rustc_on_unimplemented = \"foo\"]`")
+ }
+ }
+}
+
/// Type checks a method body.
///
/// # Parameters
}
}
-/// Checks that a method from an impl conforms to the signature of
-/// the same method as declared in the trait.
-///
-/// # Parameters
-///
-/// - impl_generics: the generics declared on the impl itself (not the method!)
-/// - impl_m: type of the method we are checking
-/// - impl_m_span: span to use for reporting errors
-/// - impl_m_body_id: id of the method body
-/// - trait_m: the method in the trait
-/// - trait_to_impl_substs: the substitutions used on the type of the trait
-fn compare_impl_method<'tcx>(tcx: &ty::ctxt<'tcx>,
- impl_m: &ty::Method<'tcx>,
- impl_m_span: Span,
- impl_m_body_id: ast::NodeId,
- trait_m: &ty::Method<'tcx>,
- impl_trait_ref: &ty::TraitRef<'tcx>) {
- debug!("compare_impl_method(impl_trait_ref={})",
- impl_trait_ref.repr(tcx));
-
- debug!("impl_trait_ref (liberated) = {}",
- impl_trait_ref.repr(tcx));
-
- let infcx = infer::new_infer_ctxt(tcx);
- let mut fulfillment_cx = traits::FulfillmentContext::new();
-
- let trait_to_impl_substs = &impl_trait_ref.substs;
-
- // Try to give more informative error messages about self typing
- // mismatches. Note that any mismatch will also be detected
- // below, where we construct a canonical function type that
- // includes the self parameter as a normal parameter. It's just
- // that the error messages you get out of this code are a bit more
- // inscrutable, particularly for cases where one method has no
- // self.
- match (&trait_m.explicit_self, &impl_m.explicit_self) {
- (&ty::StaticExplicitSelfCategory,
- &ty::StaticExplicitSelfCategory) => {}
- (&ty::StaticExplicitSelfCategory, _) => {
- tcx.sess.span_err(
- impl_m_span,
- &format!("method `{}` has a `{}` declaration in the impl, \
- but not in the trait",
- token::get_name(trait_m.name),
- ppaux::explicit_self_category_to_str(
- &impl_m.explicit_self))[]);
- return;
- }
- (_, &ty::StaticExplicitSelfCategory) => {
- tcx.sess.span_err(
- impl_m_span,
- &format!("method `{}` has a `{}` declaration in the trait, \
- but not in the impl",
- token::get_name(trait_m.name),
- ppaux::explicit_self_category_to_str(
- &trait_m.explicit_self))[]);
- return;
- }
- _ => {
- // Let the type checker catch other errors below
- }
- }
-
- let num_impl_m_type_params = impl_m.generics.types.len(subst::FnSpace);
- let num_trait_m_type_params = trait_m.generics.types.len(subst::FnSpace);
- if num_impl_m_type_params != num_trait_m_type_params {
- span_err!(tcx.sess, impl_m_span, E0049,
- "method `{}` has {} type parameter{} \
- but its trait declaration has {} type parameter{}",
- token::get_name(trait_m.name),
- num_impl_m_type_params,
- if num_impl_m_type_params == 1 {""} else {"s"},
- num_trait_m_type_params,
- if num_trait_m_type_params == 1 {""} else {"s"});
- return;
- }
-
- if impl_m.fty.sig.0.inputs.len() != trait_m.fty.sig.0.inputs.len() {
- span_err!(tcx.sess, impl_m_span, E0050,
- "method `{}` has {} parameter{} \
- but the declaration in trait `{}` has {}",
- token::get_name(trait_m.name),
- impl_m.fty.sig.0.inputs.len(),
- if impl_m.fty.sig.0.inputs.len() == 1 {""} else {"s"},
- ty::item_path_str(tcx, trait_m.def_id),
- trait_m.fty.sig.0.inputs.len());
- return;
- }
-
- // This code is best explained by example. Consider a trait:
- //
- // trait Trait<'t,T> {
- // fn method<'a,M>(t: &'t T, m: &'a M) -> Self;
- // }
- //
- // And an impl:
- //
- // impl<'i, 'j, U> Trait<'j, &'i U> for Foo {
- // fn method<'b,N>(t: &'j &'i U, m: &'b N) -> Foo;
- // }
- //
- // We wish to decide if those two method types are compatible.
- //
- // We start out with trait_to_impl_substs, that maps the trait
- // type parameters to impl type parameters. This is taken from the
- // impl trait reference:
- //
- // trait_to_impl_substs = {'t => 'j, T => &'i U, Self => Foo}
- //
- // We create a mapping `dummy_substs` that maps from the impl type
- // parameters to fresh types and regions. For type parameters,
- // this is the identity transform, but we could as well use any
- // skolemized types. For regions, we convert from bound to free
- // regions (Note: but only early-bound regions, i.e., those
- // declared on the impl or used in type parameter bounds).
- //
- // impl_to_skol_substs = {'i => 'i0, U => U0, N => N0 }
- //
- // Now we can apply skol_substs to the type of the impl method
- // to yield a new function type in terms of our fresh, skolemized
- // types:
- //
- // <'b> fn(t: &'i0 U0, m: &'b) -> Foo
- //
- // We now want to extract and substitute the type of the *trait*
- // method and compare it. To do so, we must create a compound
- // substitution by combining trait_to_impl_substs and
- // impl_to_skol_substs, and also adding a mapping for the method
- // type parameters. We extend the mapping to also include
- // the method parameters.
- //
- // trait_to_skol_substs = { T => &'i0 U0, Self => Foo, M => N0 }
- //
- // Applying this to the trait method type yields:
- //
- // <'a> fn(t: &'i0 U0, m: &'a) -> Foo
- //
- // This type is also the same but the name of the bound region ('a
- // vs 'b). However, the normal subtyping rules on fn types handle
- // this kind of equivalency just fine.
-
- // Create mapping from impl to skolemized.
- let impl_param_env = ty::construct_parameter_environment(tcx, &impl_m.generics, impl_m_body_id);
- let impl_to_skol_substs = &impl_param_env.free_substs;
-
- // Create mapping from trait to skolemized.
- let trait_to_skol_substs =
- trait_to_impl_substs
- .subst(tcx, impl_to_skol_substs)
- .with_method(impl_to_skol_substs.types.get_slice(subst::FnSpace).to_vec(),
- impl_to_skol_substs.regions().get_slice(subst::FnSpace).to_vec());
-
- // Check region bounds.
- if !check_region_bounds_on_impl_method(tcx,
- impl_m_span,
- impl_m,
- &trait_m.generics,
- &impl_m.generics,
- &trait_to_skol_substs,
- impl_to_skol_substs) {
- return;
- }
-
- // Check bounds. Note that the bounds from the impl may reference
- // late-bound regions declared on the impl, so liberate those.
- // This requires two artificial binding scopes -- one for the impl,
- // and one for the method.
- //
- // An example would be:
- //
- // trait Foo<T> { fn method<U:Bound<T>>() { ... } }
- //
- // impl<'a> Foo<&'a T> for &'a U {
- // fn method<U:Bound<&'a T>>() { ... }
- // }
- //
- // Here, the region parameter `'a` is late-bound, so in the bound
- // `Bound<&'a T>`, the lifetime `'a` will be late-bound with a
- // depth of 3 (it is nested within 3 binders: the impl, method,
- // and trait-ref itself). So when we do the liberation, we have
- // two introduce two `ty::Binder` scopes, one for the impl and one
- // the method.
- //
- // The only late-bounded regions that can possibly appear here are
- // from the impl, not the method. This is because region
- // parameters declared on the method which appear in a type bound
- // would be early bound. On the trait side, there can be no
- // late-bound lifetimes because trait definitions do not introduce
- // a late region binder.
- let trait_bounds =
- trait_m.generics.types.get_slice(subst::FnSpace).iter()
- .map(|trait_param_def| &trait_param_def.bounds);
- let impl_bounds =
- impl_m.generics.types.get_slice(subst::FnSpace).iter()
- .map(|impl_param_def| &impl_param_def.bounds);
- for (i, (trait_param_bounds, impl_param_bounds)) in
- trait_bounds.zip(impl_bounds).enumerate()
- {
- // Check that the impl does not require any builtin-bounds
- // that the trait does not guarantee:
- let extra_bounds =
- impl_param_bounds.builtin_bounds -
- trait_param_bounds.builtin_bounds;
- if !extra_bounds.is_empty() {
- span_err!(tcx.sess, impl_m_span, E0051,
- "in method `{}`, type parameter {} requires `{}`, \
- which is not required by the corresponding type parameter \
- in the trait declaration",
- token::get_name(trait_m.name),
- i,
- extra_bounds.user_string(tcx));
- return;
- }
-
- // Check that the trait bounds of the trait imply the bounds of its
- // implementation.
- //
- // FIXME(pcwalton): We could be laxer here regarding sub- and super-
- // traits, but I doubt that'll be wanted often, so meh.
- for impl_trait_bound in impl_param_bounds.trait_bounds.iter() {
- debug!("compare_impl_method(): impl-trait-bound subst");
- let impl_trait_bound =
- impl_trait_bound.subst(tcx, impl_to_skol_substs);
-
- // There may be late-bound regions from the impl in the
- // impl's bound, so "liberate" those. Note that the
- // trait_to_skol_substs is derived from the impl's
- // trait-ref, and the late-bound regions appearing there
- // have already been liberated, so the result should match
- // up.
-
- let found_match_in_trait =
- trait_param_bounds.trait_bounds.iter().any(|trait_bound| {
- debug!("compare_impl_method(): trait-bound subst");
- let trait_bound =
- trait_bound.subst(tcx, &trait_to_skol_substs);
- infer::mk_sub_poly_trait_refs(&infcx,
- true,
- infer::Misc(impl_m_span),
- trait_bound,
- impl_trait_bound.clone()).is_ok()
- });
-
- if !found_match_in_trait {
- span_err!(tcx.sess, impl_m_span, E0052,
- "in method `{}`, type parameter {} requires bound `{}`, which is not \
- required by the corresponding type parameter in the trait declaration",
- token::get_name(trait_m.name),
- i,
- impl_trait_bound.user_string(tcx));
- }
- }
- }
-
- // We now need to check that the signature of the impl method is
- // compatible with that of the trait method. We do this by
- // checking that `impl_fty <: trait_fty`.
- //
- // FIXME. Unfortunately, this doesn't quite work right now because
- // associated type normalization is not integrated into subtype
- // checks. For the comparison to be valid, we need to
- // normalize the associated types in the impl/trait methods
- // first. However, because function types bind regions, just
- // calling `normalize_associated_types_in` would have no effect on
- // any associated types appearing in the fn arguments or return
- // type.
-
-
- // Compute skolemized form of impl and trait method tys.
- let impl_fty = ty::mk_bare_fn(tcx, None, tcx.mk_bare_fn(impl_m.fty.clone()));
- let impl_fty = impl_fty.subst(tcx, impl_to_skol_substs);
- let trait_fty = ty::mk_bare_fn(tcx, None, tcx.mk_bare_fn(trait_m.fty.clone()));
- let trait_fty = trait_fty.subst(tcx, &trait_to_skol_substs);
-
- let err = infcx.try(|snapshot| {
- let origin = infer::MethodCompatCheck(impl_m_span);
-
- let (impl_sig, _) =
- infcx.replace_late_bound_regions_with_fresh_var(impl_m_span,
- infer::HigherRankedType,
- &impl_m.fty.sig);
- let impl_sig =
- impl_sig.subst(tcx, impl_to_skol_substs);
- let impl_sig =
- assoc::normalize_associated_types_in(&infcx,
- &impl_param_env,
- &mut fulfillment_cx,
- impl_m_span,
- impl_m_body_id,
- &impl_sig);
- let impl_fty =
- ty::mk_bare_fn(tcx,
- None,
- tcx.mk_bare_fn(ty::BareFnTy { unsafety: impl_m.fty.unsafety,
- abi: impl_m.fty.abi,
- sig: ty::Binder(impl_sig) }));
- debug!("compare_impl_method: impl_fty={}",
- impl_fty.repr(tcx));
-
- let (trait_sig, skol_map) =
- infcx.skolemize_late_bound_regions(&trait_m.fty.sig, snapshot);
- let trait_sig =
- trait_sig.subst(tcx, &trait_to_skol_substs);
- let trait_sig =
- assoc::normalize_associated_types_in(&infcx,
- &impl_param_env,
- &mut fulfillment_cx,
- impl_m_span,
- impl_m_body_id,
- &trait_sig);
- let trait_fty =
- ty::mk_bare_fn(tcx,
- None,
- tcx.mk_bare_fn(ty::BareFnTy { unsafety: trait_m.fty.unsafety,
- abi: trait_m.fty.abi,
- sig: ty::Binder(trait_sig) }));
-
- debug!("compare_impl_method: trait_fty={}",
- trait_fty.repr(tcx));
-
- try!(infer::mk_subty(&infcx, false, origin, impl_fty, trait_fty));
-
- infcx.leak_check(&skol_map, snapshot)
- });
-
- match err {
- Ok(()) => { }
- Err(terr) => {
- debug!("checking trait method for compatibility: impl ty {}, trait ty {}",
- impl_fty.repr(tcx),
- trait_fty.repr(tcx));
- span_err!(tcx.sess, impl_m_span, E0053,
- "method `{}` has an incompatible type for trait: {}",
- token::get_name(trait_m.name),
- ty::type_err_to_str(tcx, &terr));
- return;
- }
- }
-
- // Run the fulfillment context to completion to accommodate any
- // associated type normalizations that may have occurred.
- match fulfillment_cx.select_all_or_error(&infcx, &impl_param_env) {
- Ok(()) => { }
- Err(errors) => {
- traits::report_fulfillment_errors(&infcx, &errors);
- }
- }
-
- // Finally, resolve all regions. This catches wily misuses of lifetime
- // parameters.
- infcx.resolve_regions_and_report_errors(impl_m_body_id);
-
- /// Check that region bounds on impl method are the same as those on the trait. In principle,
- /// it could be ok for there to be fewer region bounds on the impl method, but this leads to an
- /// annoying corner case that is painful to handle (described below), so for now we can just
- /// forbid it.
- ///
- /// Example (see `src/test/compile-fail/regions-bound-missing-bound-in-impl.rs`):
- ///
- /// ```
- /// trait Foo<'a> {
- /// fn method1<'b>();
- /// fn method2<'b:'a>();
- /// }
- ///
- /// impl<'a> Foo<'a> for ... {
- /// fn method1<'b:'a>() { .. case 1, definitely bad .. }
- /// fn method2<'b>() { .. case 2, could be ok .. }
- /// }
- /// ```
- ///
- /// The "definitely bad" case is case #1. Here, the impl adds an extra constraint not present
- /// in the trait.
- ///
- /// The "maybe bad" case is case #2. Here, the impl adds an extra constraint not present in the
- /// trait. We could in principle allow this, but it interacts in a complex way with early/late
- /// bound resolution of lifetimes. Basically the presence or absence of a lifetime bound
- /// affects whether the lifetime is early/late bound, and right now the code breaks if the
- /// trait has an early bound lifetime parameter and the method does not.
- fn check_region_bounds_on_impl_method<'tcx>(tcx: &ty::ctxt<'tcx>,
- span: Span,
- impl_m: &ty::Method<'tcx>,
- trait_generics: &ty::Generics<'tcx>,
- impl_generics: &ty::Generics<'tcx>,
- trait_to_skol_substs: &Substs<'tcx>,
- impl_to_skol_substs: &Substs<'tcx>)
- -> bool
- {
-
- let trait_params = trait_generics.regions.get_slice(subst::FnSpace);
- let impl_params = impl_generics.regions.get_slice(subst::FnSpace);
-
- debug!("check_region_bounds_on_impl_method: \
- trait_generics={} \
- impl_generics={} \
- trait_to_skol_substs={} \
- impl_to_skol_substs={}",
- trait_generics.repr(tcx),
- impl_generics.repr(tcx),
- trait_to_skol_substs.repr(tcx),
- impl_to_skol_substs.repr(tcx));
-
- // Must have same number of early-bound lifetime parameters.
- // Unfortunately, if the user screws up the bounds, then this
- // will change classification between early and late. E.g.,
- // if in trait we have `<'a,'b:'a>`, and in impl we just have
- // `<'a,'b>`, then we have 2 early-bound lifetime parameters
- // in trait but 0 in the impl. But if we report "expected 2
- // but found 0" it's confusing, because it looks like there
- // are zero. Since I don't quite know how to phrase things at
- // the moment, give a kind of vague error message.
- if trait_params.len() != impl_params.len() {
- tcx.sess.span_err(
- span,
- &format!("lifetime parameters or bounds on method `{}` do \
- not match the trait declaration",
- token::get_name(impl_m.name))[]);
- return false;
- }
-
- // Each parameter `'a:'b+'c+'d` in trait should have the same
- // set of bounds in the impl, after subst.
- for (trait_param, impl_param) in
- trait_params.iter().zip(
- impl_params.iter())
- {
- let trait_bounds =
- trait_param.bounds.subst(tcx, trait_to_skol_substs);
- let impl_bounds =
- impl_param.bounds.subst(tcx, impl_to_skol_substs);
-
- debug!("check_region_bounds_on_impl_method: \
- trait_param={} \
- impl_param={} \
- trait_bounds={} \
- impl_bounds={}",
- trait_param.repr(tcx),
- impl_param.repr(tcx),
- trait_bounds.repr(tcx),
- impl_bounds.repr(tcx));
-
- // Collect the set of bounds present in trait but not in
- // impl.
- let missing: Vec<ty::Region> =
- trait_bounds.iter()
- .filter(|&b| !impl_bounds.contains(b))
- .map(|&b| b)
- .collect();
-
- // Collect set present in impl but not in trait.
- let extra: Vec<ty::Region> =
- impl_bounds.iter()
- .filter(|&b| !trait_bounds.contains(b))
- .map(|&b| b)
- .collect();
-
- debug!("missing={} extra={}",
- missing.repr(tcx), extra.repr(tcx));
-
- let err = if missing.len() != 0 || extra.len() != 0 {
- tcx.sess.span_err(
- span,
- &format!(
- "the lifetime parameter `{}` declared in the impl \
- has a distinct set of bounds \
- from its counterpart `{}` \
- declared in the trait",
- impl_param.name.user_string(tcx),
- trait_param.name.user_string(tcx))[]);
- true
- } else {
- false
- };
-
- if missing.len() != 0 {
- tcx.sess.span_note(
- span,
- &format!("the impl is missing the following bounds: `{}`",
- missing.user_string(tcx))[]);
- }
-
- if extra.len() != 0 {
- tcx.sess.span_note(
- span,
- &format!("the impl has the following extra bounds: `{}`",
- extra.user_string(tcx))[]);
- }
-
- if err {
- return false;
- }
- }
-
- return true;
- }
-}
-
fn check_cast(fcx: &FnCtxt,
cast_expr: &ast::Expr,
e: &ast::Expr,
pub fn node_ty(&self, id: ast::NodeId) -> Ty<'tcx> {
match self.inh.node_types.borrow().get(&id) {
Some(&t) => t,
+ None if self.err_count_since_creation() != 0 => self.tcx().types.err,
None => {
self.tcx().sess.bug(
&format!("no type for node {}: {} in fcx {}",
obligations.map_move(|o| self.register_predicate(o));
}
+
+ // Only for fields! Returns <none> for methods>
+ // Indifferent to privacy flags
+ pub fn lookup_field_ty(&self,
+ span: Span,
+ class_id: ast::DefId,
+ items: &[ty::field_ty],
+ fieldname: ast::Name,
+ substs: &subst::Substs<'tcx>)
+ -> Option<Ty<'tcx>>
+ {
+ let o_field = items.iter().find(|f| f.name == fieldname);
+ o_field.map(|f| ty::lookup_field_type(self.tcx(), class_id, f.id, substs))
+ .map(|t| self.normalize_associated_types_in(span, &t))
+ }
+
+ pub fn lookup_tup_field_ty(&self,
+ span: Span,
+ class_id: ast::DefId,
+ items: &[ty::field_ty],
+ idx: uint,
+ substs: &subst::Substs<'tcx>)
+ -> Option<Ty<'tcx>>
+ {
+ let o_field = if idx < items.len() { Some(&items[idx]) } else { None };
+ o_field.map(|f| ty::lookup_field_type(self.tcx(), class_id, f.id, substs))
+ .map(|t| self.normalize_associated_types_in(span, &t))
+ }
}
impl<'a, 'tcx> RegionScope for FnCtxt<'a, 'tcx> {
iterator_expr,
&[],
AutorefArgs::No,
- DontTupleArguments);
+ DontTupleArguments,
+ NoExpectation);
match method {
Some(method) => {
sp: Span,
method_fn_ty: Ty<'tcx>,
callee_expr: &ast::Expr,
- args_no_rcvr: &[
&P<ast::Expr>],
+ args_no_rcvr: &[P<ast::Expr>],
autoref_args: AutorefArgs,
- tuple_arguments: TupleArgumentsFlag)
+ tuple_arguments: TupleArgumentsFlag,
+ expected: Expectation<'tcx>)
-> ty::FnOutput<'tcx> {
if ty::type_is_error(method_fn_ty) {
let err_inputs = err_args(fcx.tcx(), args_no_rcvr.len());
check_argument_types(fcx,
sp,
&err_inputs[],
+ &[],
args_no_rcvr,
autoref_args,
false,
match method_fn_ty.sty {
ty::ty_bare_fn(_, ref fty) => {
// HACK(eddyb) ignore self in the definition (see above).
+ let expected_arg_tys = expected_types_for_fn_args(fcx,
+ sp,
+ expected,
+ fty.sig.0.output,
+ &fty.sig.0.inputs[1..]);
check_argument_types(fcx,
sp,
- fty.sig.0.inputs.slice_from(1),
+ &fty.sig.0.inputs[1..],
+ &expected_arg_tys[],
args_no_rcvr,
autoref_args,
fty.sig.0.variadic,
fn check_argument_types<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
sp: Span,
fn_inputs: &[Ty<'tcx>],
- args: &[&P<ast::Expr>],
+ expected_arg_tys: &[Ty<'tcx>],
+ args: &[P<ast::Expr>],
autoref_args: AutorefArgs,
variadic: bool,
tuple_arguments: TupleArgumentsFlag) {
1
};
+ let mut expected_arg_tys = expected_arg_tys;
let expected_arg_count = fn_inputs.len();
let formal_tys = if tuple_arguments == TupleArguments {
let tuple_type = structurally_resolved_type(fcx, sp, fn_inputs[0]);
if arg_types.len() == 1 {""} else {"s"},
args.len(),
if args.len() == 1 {" was"} else {"s were"});
+ expected_arg_tys = &[][];
err_args(fcx.tcx(), args.len())
} else {
+ expected_arg_tys = match expected_arg_tys.get(0) {
+ Some(&ty) => match ty.sty {
+ ty::ty_tup(ref tys) => &**tys,
+ _ => &[]
+ },
+ None => &[]
+ };
(*arg_types).clone()
}
}
span_err!(tcx.sess, sp, E0059,
"cannot use call notation; the first type parameter \
for the function trait is neither a tuple nor unit");
+ expected_arg_tys = &[][];
err_args(fcx.tcx(), args.len())
}
}
} else if expected_arg_count == supplied_arg_count {
- fn_inputs.iter().map(|a| *a).collect()
+ fn_inputs.to_vec()
} else if variadic {
if supplied_arg_count >= expected_arg_count {
- fn_inputs.iter().map(|a| *a).collect()
+ fn_inputs.to_vec()
} else {
span_err!(tcx.sess, sp, E0060,
"this function takes at least {} parameter{} \
if expected_arg_count == 1 {""} else {"s"},
supplied_arg_count,
if supplied_arg_count == 1 {" was"} else {"s were"});
+ expected_arg_tys = &[][];
err_args(fcx.tcx(), supplied_arg_count)
}
} else {
if expected_arg_count == 1 {""} else {"s"},
supplied_arg_count,
if supplied_arg_count == 1 {" was"} else {"s were"});
+ expected_arg_tys = &[][];
err_args(fcx.tcx(), supplied_arg_count)
};
AutorefArgs::No => {}
}
- check_expr_coercable_to_type(fcx, &***arg, formal_ty);
+ // The special-cased logic below has three functions:
+ // 1. Provide as good of an expected type as possible.
+ let expected = expected_arg_tys.get(i).map(|&ty| {
+ Expectation::rvalue_hint(ty)
+ });
+
+ check_expr_with_unifier(fcx, &**arg,
+ expected.unwrap_or(ExpectHasType(formal_ty)),
+ NoPreference, || {
+ // 2. Coerce to the most detailed type that could be coerced
+ // to, which is `expected_ty` if `rvalue_hint` returns an
+ // `ExprHasType(expected_ty)`, or the `formal_ty` otherwise.
+ let coerce_ty = expected.and_then(|e| e.only_has_type(fcx));
+ demand::coerce(fcx, arg.span, coerce_ty.unwrap_or(formal_ty), &**arg);
+
+ // 3. Relate the expected type and the formal one,
+ // if the expected type was used for the coercion.
+ coerce_ty.map(|ty| demand::suptype(fcx, arg.span, formal_ty, ty));
+ });
}
}
}
// arguments which we skipped above.
if variadic {
for arg in args.iter().skip(expected_arg_count) {
- check_expr(fcx, &***arg);
+ check_expr(fcx, &**arg);
// There are a few types which get autopromoted when passed via varargs
// in C but we just error out instead and require explicit casts.
let arg_ty = structurally_resolved_type(fcx, arg.span,
- fcx.expr_ty(&***arg));
+ fcx.expr_ty(&**arg));
match arg_ty.sty {
ty::ty_float(ast::TyF32) => {
fcx.type_error_message(arg.span,
ast::LitInt(_, ast::SignedIntLit(t, _)) => ty::mk_mach_int(tcx, t),
ast::LitInt(_, ast::UnsignedIntLit(t)) => ty::mk_mach_uint(tcx, t),
ast::LitInt(_, ast::UnsuffixedIntLit(_)) => {
- let opt_ty = expected.map_to_option(fcx, |ty| {
+ let opt_ty = expected.to_option(fcx).and_then(|ty| {
match ty.sty {
ty::ty_int(_) | ty::ty_uint(_) => Some(ty),
ty::ty_char => Some(tcx.types.u8),
}
ast::LitFloat(_, t) => ty::mk_mach_float(tcx, t),
ast::LitFloatUnsuffixed(_) => {
- let opt_ty = expected.map_to_option(fcx, |ty| {
+ let opt_ty = expected.to_option(fcx).and_then(|ty| {
match ty.sty {
ty::ty_float(_) => Some(ty),
_ => None
TypeAndSubsts { substs: substs, ty: substd_ty }
}
-// Only for fields! Returns <none> for methods>
-// Indifferent to privacy flags
-pub fn lookup_field_ty<'tcx>(tcx: &ty::ctxt<'tcx>,
- class_id: ast::DefId,
- items: &[ty::field_ty],
- fieldname: ast::Name,
- substs: &subst::Substs<'tcx>)
- -> Option<Ty<'tcx>> {
-
- let o_field = items.iter().find(|f| f.name == fieldname);
- o_field.map(|f| ty::lookup_field_type(tcx, class_id, f.id, substs))
-}
-
-pub fn lookup_tup_field_ty<'tcx>(tcx: &ty::ctxt<'tcx>,
- class_id: ast::DefId,
- items: &[ty::field_ty],
- idx: uint,
- substs: &subst::Substs<'tcx>)
- -> Option<Ty<'tcx>> {
-
- let o_field = if idx < items.len() { Some(&items[idx]) } else { None };
- o_field.map(|f| ty::lookup_field_type(tcx, class_id, f.id, substs))
-}
-
// Controls whether the arguments are automatically referenced. This is useful
// for overloaded binary and unary operators.
#[derive(Copy, PartialEq)]
TupleArguments,
}
+/// Unifies the return type with the expected type early, for more coercions
+/// and forward type information on the argument expressions.
+fn expected_types_for_fn_args<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
+ call_span: Span,
+ expected_ret: Expectation<'tcx>,
+ formal_ret: ty::FnOutput<'tcx>,
+ formal_args: &[Ty<'tcx>])
+ -> Vec<Ty<'tcx>> {
+ let expected_args = expected_ret.only_has_type(fcx).and_then(|ret_ty| {
+ if let ty::FnConverging(formal_ret_ty) = formal_ret {
+ fcx.infcx().commit_regions_if_ok(|| {
+ // Attempt to apply a subtyping relationship between the formal
+ // return type (likely containing type variables if the function
+ // is polymorphic) and the expected return type.
+ // No argument expectations are produced if unification fails.
+ let origin = infer::Misc(call_span);
+ let ures = fcx.infcx().sub_types(false, origin, formal_ret_ty, ret_ty);
+ // FIXME(#15760) can't use try! here, FromError doesn't default
+ // to identity so the resulting type is not constrained.
+ if let Err(e) = ures {
+ return Err(e);
+ }
+
+ // Record all the argument types, with the substitutions
+ // produced from the above subtyping unification.
+ Ok(formal_args.iter().map(|ty| {
+ fcx.infcx().resolve_type_vars_if_possible(ty)
+ }).collect())
+ }).ok()
+ } else {
+ None
+ }
+ }).unwrap_or(vec![]);
+ debug!("expected_types_for_fn_args(formal={} -> {}, expected={} -> {})",
+ formal_args.repr(fcx.tcx()), formal_ret.repr(fcx.tcx()),
+ expected_args.repr(fcx.tcx()), expected_ret.repr(fcx.tcx()));
+ expected_args
+}
+
/// Invariant:
/// If an expression has any sub-expressions that result in a type error,
/// inspecting that expression's type with `ty::type_is_error` will return
expr.repr(fcx.tcx()), expected.repr(fcx.tcx()));
// Checks a method call.
- fn check_method_call(fcx: &FnCtxt,
- expr: &ast::Expr,
- method_name: ast::SpannedIdent,
- args: &[P<ast::Expr>],
- tps: &[P<ast::Ty>],
- lvalue_pref: LvaluePreference) {
+ fn check_method_call<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
+ expr: &ast::Expr,
+ method_name: ast::SpannedIdent,
+ args: &[P<ast::Expr>],
+ tps: &[P<ast::Ty>],
+ expected: Expectation<'tcx>,
+ lvalue_pref: LvaluePreference) {
let rcvr = &*args[0];
check_expr_with_lvalue_pref(fcx, &*rcvr, lvalue_pref);
};
// Call the generic checker.
- let args: Vec<_> = args[1..].iter().map(|x| x).collect();
let ret_ty = check_method_argument_types(fcx,
method_name.span,
fn_ty,
expr,
- args.as_slice(),
+ &args[1..],
AutorefArgs::No,
- DontTupleArguments);
+ DontTupleArguments,
+ expected);
write_call(fcx, expr, ret_ty);
}
None => None
};
let args = match rhs {
- Some(rhs) => vec![rhs],
- None => vec![]
+ Some(rhs) => slice::ref_slice(rhs),
+ None => &[][]
};
match method {
Some(method) => {
let method_call = ::middle::ty::MethodCall::expr(op_ex.id);
fcx.inh.method_map.borrow_mut().insert(method_call, method);
match check_method_argument_types(fcx,
- op_ex.span,
- method_ty,
- op_ex,
- args.as_slice(),
- autoref_args,
- DontTupleArguments) {
+ op_ex.span,
+ method_ty,
+ op_ex,
+ args,
+ autoref_args,
+ DontTupleArguments,
+ NoExpectation) {
ty::FnConverging(result_type) => result_type,
ty::FnDiverging => fcx.tcx().types.err
}
op_ex.span,
expected_ty,
op_ex,
- args.as_slice(),
+ args,
autoref_args,
- DontTupleArguments);
+ DontTupleArguments,
+ NoExpectation);
fcx.tcx().types.err
}
}
ty::ty_struct(base_id, substs) => {
debug!("struct named {}", ppaux::ty_to_string(tcx, base_t));
let fields = ty::lookup_struct_fields(tcx, base_id);
- lookup_field_ty(tcx, base_id, &fields[],
- field.node.name, &(*substs))
+ fcx.lookup_field_ty(expr.span, base_id, &fields[],
+ field.node.name, &(*substs))
}
_ => None
}
if tuple_like {
debug!("tuple struct named {}", ppaux::ty_to_string(tcx, base_t));
let fields = ty::lookup_struct_fields(tcx, base_id);
- lookup_tup_field_ty(tcx, base_id, &fields[],
- idx.node, &(*substs))
+ fcx.lookup_tup_field_ty(expr.span, base_id, &fields[],
+ idx.node, &(*substs))
} else {
None
}
}
}
ast::ExprUnary(unop, ref oprnd) => {
- let expected_inner = expected.map(fcx, |ty| {
+ let expected_inner = expected.to_option(fcx).map_or(NoExpectation, |ty| {
match unop {
ast::UnUniq => match ty.sty {
ty::ty_uniq(ty) => {
fcx.write_ty(id, oprnd_t);
}
ast::ExprAddrOf(mutbl, ref oprnd) => {
- let expected = expected.only_has_type();
- let hint = expected.map(fcx, |ty| {
+ let hint = expected.only_has_type(fcx).map_or(NoExpectation, |ty| {
match ty.sty {
ty::ty_rptr(_, ref mt) | ty::ty_ptr(ref mt) => {
if ty::expr_is_lval(fcx.tcx(), &**oprnd) {
};
fcx.write_ty(id, oprnd_t);
}
- ast::ExprPath(ref pth) => {
- let defn = lookup_def(fcx, pth.span, id);
+ ast::ExprPath(ref path) => {
+ let defn = lookup_def(fcx, path.span, id);
let pty = type_scheme_for_def(fcx, expr.span, defn);
- instantiate_path(fcx, pth, pty, defn, expr.span, expr.id);
+ instantiate_path(fcx, path, pty, None, defn, expr.span, expr.id);
+
+ // We always require that the type provided as the value for
+ // a type parameter outlives the moment of instantiation.
+ constrain_path_type_parameters(fcx, expr);
+ }
+ ast::ExprQPath(ref qpath) => {
+ // Require explicit type params for the trait.
+ let self_ty = fcx.to_ty(&*qpath.self_type);
+ astconv::instantiate_trait_ref(fcx, fcx, &*qpath.trait_ref, Some(self_ty), None);
+
+ let defn = lookup_def(fcx, expr.span, id);
+ let pty = type_scheme_for_def(fcx, expr.span, defn);
+ let mut path = qpath.trait_ref.path.clone();
+ path.segments.push(qpath.item_path.clone());
+ instantiate_path(fcx, &path, pty, Some(self_ty), defn, expr.span, expr.id);
// We always require that the type provided as the value for
// a type parameter outlives the moment of instantiation.
fcx.write_ty(id, fcx.node_ty(b.id));
}
ast::ExprCall(ref callee, ref args) => {
- callee::check_call(fcx, expr, &**callee, args.as_slice());
+ callee::check_call(fcx, expr, &**callee, &args[], expected);
}
ast::ExprMethodCall(ident, ref tps, ref args) => {
- check_method_call(fcx, expr, ident, args.as_slice(), tps.as_slice(), lvalue_pref);
+ check_method_call(fcx, expr, ident, &args[], &tps[], expected, lvalue_pref);
let arg_tys = args.iter().map(|a| fcx.expr_ty(&**a));
let args_err = arg_tys.fold(false,
|rest_err, a| {
check_cast(fcx, expr, &**e, &**t);
}
ast::ExprVec(ref args) => {
- let uty = expected.map_to_option(fcx, |uty| {
+ let uty = expected.to_option(fcx).and_then(|uty| {
match uty.sty {
ty::ty_vec(ty, _) => Some(ty),
_ => None
}
}
ast::ExprTup(ref elts) => {
- let expected = expected.only_has_type();
- let flds = expected.map_to_option(fcx, |ty| {
+ let flds = expected.only_has_type(fcx).and_then(|ty| {
match ty.sty {
ty::ty_tup(ref flds) => Some(&flds[]),
_ => None
}
}
- fn only_has_type(self) -> Expectation<'tcx> {
- match self {
- ExpectHasType(t) => ExpectHasType(t),
- _ => NoExpectation
- }
- }
-
// Resolves `expected` by a single level if it is a variable. If
// there is no expected type or resolution is not possible (e.g.,
// no constraints yet present), just returns `None`.
}
}
- fn map<'a, F>(self, fcx: &FnCtxt<'a, 'tcx>, unpack: F) -> Expectation<'tcx> where
- F: FnOnce(Ty<'tcx>) -> Expectation<'tcx>
- {
+ fn to_option<'a>(self, fcx: &FnCtxt<'a, 'tcx>) -> Option<Ty<'tcx>> {
match self.resolve(fcx) {
- NoExpectation => NoExpectation,
+ NoExpectation => None,
ExpectCastableToType(ty) |
ExpectHasType(ty) |
- ExpectRvalueLikeUnsized(ty) => unpack(ty),
+ ExpectRvalueLikeUnsized(ty) => Some(ty),
}
}
- fn map_to_option<'a, O, F>(self, fcx: &FnCtxt<'a, 'tcx>, unpack: F) -> Option<O> where
- F: FnOnce(Ty<'tcx>) -> Option<O>,
- {
+ fn only_has_type<'a>(self, fcx: &FnCtxt<'a, 'tcx>) -> Option<Ty<'tcx>> {
match self.resolve(fcx) {
- NoExpectation => None,
- ExpectCastableToType(ty) |
- ExpectHasType(ty) |
- ExpectRvalueLikeUnsized(ty) => unpack(ty),
+ ExpectHasType(ty) => Some(ty),
+ _ => None
}
}
}
pub fn instantiate_path<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
path: &ast::Path,
type_scheme: TypeScheme<'tcx>,
+ opt_self_ty: Option<Ty<'tcx>>,
def: def::Def,
span: Span,
node_id: ast::NodeId) {
}
}
}
+ if let Some(self_ty) = opt_self_ty {
+ // `<T as Trait>::foo` shouldn't have resolved to a `Self`-less item.
+ assert_eq!(type_defs.len(subst::SelfSpace), 1);
+ substs.types.push(subst::SelfSpace, self_ty);
+ }
// Now we have to compare the types that the user *actually*
// provided against the types that were *expected*. If the user
#[macro_use] extern crate syntax;
extern crate arena;
+extern crate fmt_macros;
extern crate rustc;
pub use rustc::lint;
pub fn load_attrs(cx: &DocContext, tcx: &ty::ctxt,
did: ast::DefId) -> Vec<clean::Attribute> {
- let mut attrs = Vec::new();
- csearch::get_item_attrs(&tcx.sess.cstore, did, |v| {
- attrs.extend(v.into_iter().map(|a| {
- a.clean(cx)
- }));
- });
- attrs
+ let attrs = csearch::get_item_attrs(&tcx.sess.cstore, did);
+ attrs.into_iter().map(|a| a.clean(cx)).collect()
}
/// Record an external fully qualified name in the external_paths cache.
}
}
+impl<T, U> Clean<U> for ty::Binder<T> where T: Clean<U> {
+ fn clean(&self, cx: &DocContext) -> U {
+ self.0.clean(cx)
+ }
+}
+
impl<T: Clean<U>, U> Clean<Vec<U>> for syntax::owned_slice::OwnedSlice<T> {
fn clean(&self, cx: &DocContext) -> Vec<U> {
self.iter().map(|x| x.clean(cx)).collect()
}
}
-impl<'tcx> Clean<Vec<TyParamBound>> for ty::ExistentialBounds<'tcx> {
- fn clean(&self, cx: &DocContext) -> Vec<TyParamBound> {
- let mut vec = vec![];
- self.region_bound.clean(cx).map(|b| vec.push(RegionBound(b)));
+impl<'tcx> Clean<(Vec<TyParamBound>, Vec<TypeBinding>)> for ty::ExistentialBounds<'tcx> {
+ fn clean(&self, cx: &DocContext) -> (Vec<TyParamBound>, Vec<TypeBinding>) {
+ let mut tp_bounds = vec![];
+ self.region_bound.clean(cx).map(|b| tp_bounds.push(RegionBound(b)));
for bb in self.builtin_bounds.iter() {
- vec.push(bb.clean(cx));
+ tp_bounds.push(bb.clean(cx));
}
- // FIXME(#20299) -- should do something with projection bounds
+ let mut bindings = vec![];
+ for &ty::Binder(ref pb) in self.projection_bounds.iter() {
+ bindings.push(TypeBinding {
+ name: pb.projection_ty.item_name.clean(cx),
+ ty: pb.ty.clean(cx)
+ });
+ }
- vec
+ (tp_bounds, bindings)
}
}
fn external_path_params(cx: &DocContext, trait_did: Option<ast::DefId>,
- substs: &subst::Substs) -> PathParameters {
+ bindings: Vec<TypeBinding>, substs: &subst::Substs) -> PathParameters {
use rustc::middle::ty::sty;
let lifetimes = substs.regions().get_slice(subst::TypeSpace)
.iter()
return PathParameters::AngleBracketed {
lifetimes: lifetimes,
types: types.clean(cx),
- bindings: vec![]
+ bindings: bindings
}
}
};
PathParameters::AngleBracketed {
lifetimes: lifetimes,
types: types.clean(cx),
- bindings: vec![] // FIXME(#20646)
+ bindings: bindings
}
}
}
// trait_did should be set to a trait's DefId if called on a TraitRef, in order to sugar
// from Fn<(A, B,), C> to Fn(A, B) -> C
fn external_path(cx: &DocContext, name: &str, trait_did: Option<ast::DefId>,
- substs: &subst::Substs) -> Path {
+ bindings: Vec<TypeBinding>, substs: &subst::Substs) -> Path {
Path {
global: false,
segments: vec![PathSegment {
name: name.to_string(),
- params: external_path_params(cx, trait_did, substs)
+ params: external_path_params(cx, trait_did, bindings, substs)
}],
}
}
let (did, path) = match *self {
ty::BoundSend =>
(tcx.lang_items.send_trait().unwrap(),
- external_path(cx, "Send", None, &empty)),
+ external_path(cx, "Send", None, vec![], &empty)),
ty::BoundSized =>
(tcx.lang_items.sized_trait().unwrap(),
- external_path(cx, "Sized", None, &empty)),
+ external_path(cx, "Sized", None, vec![], &empty)),
ty::BoundCopy =>
(tcx.lang_items.copy_trait().unwrap(),
- external_path(cx, "Copy", None, &empty)),
+ external_path(cx, "Copy", None, vec![], &empty)),
ty::BoundSync =>
(tcx.lang_items.sync_trait().unwrap(),
- external_path(cx, "Sync", None, &empty)),
+ external_path(cx, "Sync", None, vec![], &empty)),
};
let fqn = csearch::get_item_path(tcx, did);
let fqn = fqn.into_iter().map(|i| i.to_string()).collect();
}
}
-impl<'tcx> Clean<TyParamBound> for ty::PolyTraitRef<'tcx> {
- fn clean(&self, cx: &DocContext) -> TyParamBound {
- self.0.clean(cx)
- }
-}
-
impl<'tcx> Clean<TyParamBound> for ty::TraitRef<'tcx> {
fn clean(&self, cx: &DocContext) -> TyParamBound {
let tcx = match cx.tcx_opt() {
let fqn = fqn.into_iter().map(|i| i.to_string())
.collect::<Vec<String>>();
let path = external_path(cx, fqn.last().unwrap().as_slice(),
- Some(self.def_id), self.substs);
+ Some(self.def_id), vec![], self.substs);
cx.external_paths.borrow_mut().as_mut().unwrap().insert(self.def_id,
(fqn, TypeTrait));
pub enum WherePredicate {
BoundPredicate { ty: Type, bounds: Vec<TyParamBound> },
RegionPredicate { lifetime: Lifetime, bounds: Vec<Lifetime>},
- // FIXME (#20041)
- EqPredicate
+ EqPredicate { lhs: Type, rhs: Type }
}
impl Clean<WherePredicate> for ast::WherePredicate {
}
ast::WherePredicate::EqPredicate(_) => {
- WherePredicate::EqPredicate
+ unimplemented!() // FIXME(#20041)
}
}
}
}
+impl<'a> Clean<WherePredicate> for ty::Predicate<'a> {
+ fn clean(&self, cx: &DocContext) -> WherePredicate {
+ use rustc::middle::ty::Predicate;
+
+ match *self {
+ Predicate::Trait(ref pred) => pred.clean(cx),
+ Predicate::Equate(ref pred) => pred.clean(cx),
+ Predicate::RegionOutlives(ref pred) => pred.clean(cx),
+ Predicate::TypeOutlives(ref pred) => pred.clean(cx),
+ Predicate::Projection(ref pred) => pred.clean(cx)
+ }
+ }
+}
+
+impl<'a> Clean<WherePredicate> for ty::TraitPredicate<'a> {
+ fn clean(&self, cx: &DocContext) -> WherePredicate {
+ WherePredicate::BoundPredicate {
+ ty: self.trait_ref.substs.self_ty().clean(cx).unwrap(),
+ bounds: vec![self.trait_ref.clean(cx)]
+ }
+ }
+}
+
+impl<'tcx> Clean<WherePredicate> for ty::EquatePredicate<'tcx> {
+ fn clean(&self, cx: &DocContext) -> WherePredicate {
+ let ty::EquatePredicate(ref lhs, ref rhs) = *self;
+ WherePredicate::EqPredicate {
+ lhs: lhs.clean(cx),
+ rhs: rhs.clean(cx)
+ }
+ }
+}
+
+impl Clean<WherePredicate> for ty::OutlivesPredicate<ty::Region, ty::Region> {
+ fn clean(&self, cx: &DocContext) -> WherePredicate {
+ let ty::OutlivesPredicate(ref a, ref b) = *self;
+ WherePredicate::RegionPredicate {
+ lifetime: a.clean(cx).unwrap(),
+ bounds: vec![b.clean(cx).unwrap()]
+ }
+ }
+}
+
+impl<'tcx> Clean<WherePredicate> for ty::OutlivesPredicate<ty::Ty<'tcx>, ty::Region> {
+ fn clean(&self, cx: &DocContext) -> WherePredicate {
+ let ty::OutlivesPredicate(ref ty, ref lt) = *self;
+
+ WherePredicate::BoundPredicate {
+ ty: ty.clean(cx),
+ bounds: vec![TyParamBound::RegionBound(lt.clean(cx).unwrap())]
+ }
+ }
+}
+
+impl<'tcx> Clean<WherePredicate> for ty::ProjectionPredicate<'tcx> {
+ fn clean(&self, cx: &DocContext) -> WherePredicate {
+ WherePredicate::EqPredicate {
+ lhs: self.projection_ty.clean(cx),
+ rhs: self.ty.clean(cx)
+ }
+ }
+}
+
+impl<'tcx> Clean<Type> for ty::ProjectionTy<'tcx> {
+ fn clean(&self, cx: &DocContext) -> Type {
+ let trait_ = match self.trait_ref.clean(cx) {
+ TyParamBound::TraitBound(t, _) => t.trait_,
+ TyParamBound::RegionBound(_) => panic!("cleaning a trait got a region??"),
+ };
+ Type::QPath {
+ name: self.item_name.clean(cx),
+ self_type: box self.trait_ref.self_ty().clean(cx),
+ trait_: box trait_
+ }
+ }
+}
+
// maybe use a Generic enum and use ~[Generic]?
#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Show)]
pub struct Generics {
impl<'a, 'tcx> Clean<Generics> for (&'a ty::Generics<'tcx>, subst::ParamSpace) {
fn clean(&self, cx: &DocContext) -> Generics {
- let (me, space) = *self;
+ use std::collections::HashSet;
+ use syntax::ast::TraitBoundModifier as TBM;
+ use self::WherePredicate as WP;
+
+ fn has_sized_bound(bounds: &[TyParamBound], cx: &DocContext) -> bool {
+ if let Some(tcx) = cx.tcx_opt() {
+ let sized_did = match tcx.lang_items.sized_trait() {
+ Some(did) => did,
+ None => return false
+ };
+ for bound in bounds.iter() {
+ if let TyParamBound::TraitBound(PolyTrait {
+ trait_: Type::ResolvedPath { did, .. }, ..
+ }, TBM::None) = *bound {
+ if did == sized_did {
+ return true
+ }
+ }
+ }
+ }
+ false
+ }
+
+ let (gens, space) = *self;
+ // Bounds in the type_params and lifetimes fields are repeated in the predicates
+ // field (see rustc_typeck::collect::ty_generics), so remove them.
+ let stripped_typarams = gens.types.get_slice(space).iter().map(|tp| {
+ let mut stp = tp.clone();
+ stp.bounds = ty::ParamBounds::empty();
+ stp.clean(cx)
+ }).collect::<Vec<_>>();
+ let stripped_lifetimes = gens.regions.get_slice(space).iter().map(|rp| {
+ let mut srp = rp.clone();
+ srp.bounds = Vec::new();
+ srp.clean(cx)
+ }).collect::<Vec<_>>();
+
+ let where_predicates = gens.predicates.get_slice(space).to_vec().clean(cx);
+ // Type parameters have a Sized bound by default unless removed with ?Sized.
+ // Scan through the predicates and mark any type parameter with a Sized
+ // bound, removing the bounds as we find them.
+ let mut sized_params = HashSet::new();
+ let mut where_predicates = where_predicates.into_iter().filter_map(|pred| {
+ if let WP::BoundPredicate { ty: Type::Generic(ref g), ref bounds } = pred {
+ if has_sized_bound(&**bounds, cx) {
+ sized_params.insert(g.clone());
+ return None
+ }
+ }
+ Some(pred)
+ }).collect::<Vec<_>>();
+ // Finally, run through the type parameters again and insert a ?Sized unbound for
+ // any we didn't find to be Sized.
+ for tp in stripped_typarams.iter() {
+ if !sized_params.contains(&tp.name) {
+ let mut sized_bound = ty::BuiltinBound::BoundSized.clean(cx);
+ if let TyParamBound::TraitBound(_, ref mut tbm) = sized_bound {
+ *tbm = TBM::Maybe
+ };
+ where_predicates.push(WP::BoundPredicate {
+ ty: Type::Generic(tp.name.clone()),
+ bounds: vec![sized_bound]
+ })
+ }
+ }
+
+ // It would be nice to collect all of the bounds on a type and recombine
+ // them if possible, to avoid e.g. `where T: Foo, T: Bar, T: Sized, T: 'a`
+ // and instead see `where T: Foo + Bar + Sized + 'a`
+
Generics {
- type_params: me.types.get_slice(space).to_vec().clean(cx),
- lifetimes: me.regions.get_slice(space).to_vec().clean(cx),
- where_predicates: vec![]
+ type_params: stripped_typarams,
+ lifetimes: stripped_lifetimes,
+ where_predicates: where_predicates
}
}
}
}
}
-#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Show)]
-pub struct ClosureDecl {
- pub lifetimes: Vec<Lifetime>,
- pub decl: FnDecl,
- pub onceness: ast::Onceness,
- pub unsafety: ast::Unsafety,
- pub bounds: Vec<TyParamBound>,
-}
-
-impl Clean<ClosureDecl> for ast::ClosureTy {
- fn clean(&self, cx: &DocContext) -> ClosureDecl {
- ClosureDecl {
- lifetimes: self.lifetimes.clean(cx),
- decl: self.decl.clean(cx),
- onceness: self.onceness,
- unsafety: self.unsafety,
- bounds: self.bounds.clean(cx)
- }
- }
-}
-
#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Show)]
pub struct FnDecl {
pub inputs: Arguments,
Generic(String),
/// Primitives are just the fixed-size numeric types (plus int/uint/float), and char.
Primitive(PrimitiveType),
- Closure(Box<ClosureDecl>),
- Proc(Box<ClosureDecl>),
/// extern "ABI" fn
BareFunction(Box<BareFunctionDecl>),
Tuple(Vec<Type>),
_ => TypeEnum,
};
let path = external_path(cx, fqn.last().unwrap().to_string().as_slice(),
- None, substs);
+ None, vec![], substs);
cx.external_paths.borrow_mut().as_mut().unwrap().insert(did, (fqn, kind));
ResolvedPath {
path: path,
let did = principal.def_id();
let fqn = csearch::get_item_path(cx.tcx(), did);
let fqn: Vec<_> = fqn.into_iter().map(|i| i.to_string()).collect();
+ let (typarams, bindings) = bounds.clean(cx);
let path = external_path(cx, fqn.last().unwrap().to_string().as_slice(),
- Some(did), principal.substs());
+ Some(did), bindings, principal.substs());
cx.external_paths.borrow_mut().as_mut().unwrap().insert(did, (fqn, TypeTrait));
ResolvedPath {
path: path,
- typarams: Some(bounds.clean(cx)),
+ typarams: Some(typarams),
did: did,
}
}
impl Clean<Type> for ast::QPath {
fn clean(&self, cx: &DocContext) -> Type {
Type::QPath {
- name: self.item_name.clean(cx),
+ name: self.item_path.identifier.clean(cx),
self_type: box self.self_type.clean(cx),
trait_: box self.trait_ref.clean(cx)
}
use rustc::middle::{privacy, ty};
use rustc::lint;
use rustc_trans::back::link;
+use rustc_resolve as resolve;
use syntax::{ast, ast_map, codemap, diagnostic};
let arenas = ty::CtxtArenas::new();
let ty::CrateAnalysis {
exported_items, public_items, ty_cx, ..
- } = driver::phase_3_run_analysis_passes(sess, ast_map, &arenas, name);
+ } = driver::phase_3_run_analysis_passes(sess,
+ ast_map,
+ &arenas,
+ name,
+ resolve::MakeGlobMap::No);
let ctxt = DocContext {
krate: ty_cx.map.krate(),
try!(write!(f, "{}", lifetime));
}
}
- &clean::WherePredicate::EqPredicate => {
- unimplemented!()
+ &clean::WherePredicate::EqPredicate { ref lhs, ref rhs } => {
+ try!(write!(f, "{} == {}", lhs, rhs));
}
}
}
match rel_root {
Some(root) => {
let mut root = String::from_str(root.as_slice());
- for seg in path.segments[0..amt].iter() {
+ for seg in path.segments[..amt].iter() {
if "super" == seg.name ||
"self" == seg.name {
try!(write!(w, "{}::", seg.name));
}
}
None => {
- for seg in path.segments[0..amt].iter() {
+ for seg in path.segments[..amt].iter() {
try!(write!(w, "{}::", seg.name));
}
}
}
clean::Infer => write!(f, "_"),
clean::Primitive(prim) => primitive_link(f, prim, prim.to_string()),
- clean::Closure(ref decl) => {
- write!(f, "{style}{lifetimes}|{args}|{bounds}{arrow}",
- style = UnsafetySpace(decl.unsafety),
- lifetimes = if decl.lifetimes.len() == 0 {
- "".to_string()
- } else {
- format!("for <{}>",
- CommaSep(decl.lifetimes.as_slice()))
- },
- args = decl.decl.inputs,
- arrow = decl.decl.output,
- bounds = {
- let mut ret = String::new();
- for bound in decl.bounds.iter() {
- match *bound {
- clean::RegionBound(..) => {}
- clean::TraitBound(ref t, modifier) => {
- if ret.len() == 0 {
- ret.push_str(": ");
- } else {
- ret.push_str(" + ");
- }
- if modifier == ast::TraitBoundModifier::Maybe {
- ret.push_str("?");
- }
- ret.push_str(format!("{}",
- *t).as_slice());
- }
- }
- }
- ret
- })
- }
- clean::Proc(ref decl) => {
- write!(f, "{style}{lifetimes}proc({args}){bounds}{arrow}",
- style = UnsafetySpace(decl.unsafety),
- lifetimes = if decl.lifetimes.len() == 0 {
- "".to_string()
- } else {
- format!("for <{}>",
- CommaSep(decl.lifetimes.as_slice()))
- },
- args = decl.decl.inputs,
- bounds = if decl.bounds.len() == 0 {
- "".to_string()
- } else {
- let m = decl.bounds
- .iter()
- .map(|s| s.to_string());
- format!(
- ": {}",
- m.collect::<Vec<String>>().connect(" + "))
- },
- arrow = decl.decl.output)
- }
clean::BareFunction(ref decl) => {
write!(f, "{}{}fn{}{}",
UnsafetySpace(decl.unsafety),
use libc;
use std::ascii::AsciiExt;
use std::ffi::CString;
-use std::cell::{RefCell, Cell};
+use std::cell::RefCell;
use std::collections::HashMap;
use std::fmt;
use std::slice;
thread_local!(static USED_HEADER_MAP: RefCell<HashMap<String, uint>> = {
RefCell::new(HashMap::new())
});
-thread_local!(static TEST_IDX: Cell<uint> = Cell::new(0));
thread_local!(pub static PLAYGROUND_KRATE: RefCell<Option<Option<String>>> = {
RefCell::new(None)
if rendered { return }
PLAYGROUND_KRATE.with(|krate| {
let mut s = String::new();
- let id = krate.borrow().as_ref().map(|krate| {
- let idx = TEST_IDX.with(|slot| {
- let i = slot.get();
- slot.set(i + 1);
- i
- });
-
+ krate.borrow().as_ref().map(|krate| {
let test = origtext.lines().map(|l| {
stripped_filtered_line(l).unwrap_or(l)
}).collect::<Vec<&str>>().connect("\n");
let krate = krate.as_ref().map(|s| s.as_slice());
let test = test::maketest(test.as_slice(), krate, false, false);
- s.push_str(format!("<span id='rust-example-raw-{}' \
- class='rusttest'>{}</span>",
- idx, Escape(test.as_slice())).as_slice());
- format!("rust-example-rendered-{}", idx)
+ s.push_str(format!("<span class='rusttest'>{}</span>",
+ Escape(test.as_slice())).as_slice());
});
- let id = id.as_ref().map(|a| a.as_slice());
- s.push_str(highlight::highlight(text.as_slice(), None, id)
- .as_slice());
+ s.push_str(highlight::highlight(text.as_slice(),
+ None,
+ Some("rust-example-rendered"))
+ .as_slice());
let output = CString::from_vec(s.into_bytes());
hoedown_buffer_puts(ob, output.as_ptr());
})
/// previous state (if any).
pub fn reset_headers() {
USED_HEADER_MAP.with(|s| s.borrow_mut().clear());
- TEST_IDX.with(|s| s.set(0));
}
impl<'a> fmt::String for Markdown<'a> {
(function() {
if (window.playgroundUrl) {
$('pre.rust').hover(function() {
- if (!$(this).attr('id')) { return; }
- var id = '#' + $(this).attr('id').replace('rendered', 'raw');
var a = $('<a>').text('⇱').attr('class', 'test-arrow');
- var code = $(id).text();
+ var code = $(this).siblings(".rusttest").text();
a.attr('href', window.playgroundUrl + '?code=' +
encodeURIComponent(code));
a.attr('target', '_blank');
extern crate rustc;
extern crate rustc_trans;
extern crate rustc_driver;
+extern crate rustc_resolve;
extern crate serialize;
extern crate syntax;
extern crate "test" as testing;
<html lang="en">
<head>
<meta charset="utf-8">
+ <meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta name="generator" content="rustdoc">
<title>{title}</title>
search_paths: libs,
crate_types: vec!(config::CrateTypeExecutable),
output_types: vec!(config::OutputTypeExe),
- no_trans: no_run,
externs: externs,
cg: config::CodegenOptions {
prefer_dynamic: true,
diagnostic::mk_span_handler(diagnostic_handler, codemap);
let sess = session::build_session_(sessopts,
- None,
- span_diagnostic_handler);
+ None,
+ span_diagnostic_handler);
let outdir = TempDir::new("rustdoctest").ok().expect("rustdoc needs a tempdir");
let out = Some(outdir.path().clone());
let cfg = config::build_configuration(&sess);
let libdir = sess.target_filesearch(PathKind::All).get_lib_path();
- driver::compile_input(sess, cfg, &input, &out, &None, None);
+ let mut control = driver::CompileController::basic();
+ if no_run {
+ control.after_analysis.stop = true;
+ }
+ driver::compile_input(sess, cfg, &input, &out, &None, None, control);
if no_run { return }
fn escape_char(writer: &mut fmt::Writer, v: char) -> fmt::Result {
let mut buf = [0; 4];
let n = v.encode_utf8(&mut buf).unwrap();
- let buf = unsafe { str::from_utf8_unchecked(&buf[0..n]) };
+ let buf = unsafe { str::from_utf8_unchecked(&buf[..n]) };
escape_str(writer, buf)
}
}
if n > 0 {
- wr.write_str(&BUF[0..n])
+ wr.write_str(&BUF[..n])
} else {
Ok(())
}
use default::Default;
use fmt::{self, Show};
use hash::{self, Hash, SipHasher};
-use iter::{self, Iterator, IteratorExt, FromIterator, Extend, Map};
+use iter::{self, Iterator, ExactSizeIterator, IteratorExt, FromIterator, Extend, Map};
use marker::Sized;
use mem::{self, replace};
use num::{Int, UnsignedInt};
type Item = (&'a K, &'a V);
#[inline] fn next(&mut self) -> Option<(&'a K, &'a V)> { self.inner.next() }
- #[inline] fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
+ #[inline] fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }
+}
+#[stable]
+impl<'a, K, V> ExactSizeIterator for Iter<'a, K, V> {
+ #[inline] fn len(&self) -> usize { self.inner.len() }
}
#[stable]
type Item = (&'a K, &'a mut V);
#[inline] fn next(&mut self) -> Option<(&'a K, &'a mut V)> { self.inner.next() }
- #[inline] fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
+ #[inline] fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }
+}
+#[stable]
+impl<'a, K, V> ExactSizeIterator for IterMut<'a, K, V> {
+ #[inline] fn len(&self) -> usize { self.inner.len() }
}
#[stable]
type Item = (K, V);
#[inline] fn next(&mut self) -> Option<(K, V)> { self.inner.next() }
- #[inline] fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
+ #[inline] fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }
+}
+#[stable]
+impl<K, V> ExactSizeIterator for IntoIter<K, V> {
+ #[inline] fn len(&self) -> usize { self.inner.len() }
}
#[stable]
type Item = &'a K;
#[inline] fn next(&mut self) -> Option<(&'a K)> { self.inner.next() }
- #[inline] fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
+ #[inline] fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }
+}
+#[stable]
+impl<'a, K, V> ExactSizeIterator for Keys<'a, K, V> {
+ #[inline] fn len(&self) -> usize { self.inner.len() }
}
#[stable]
type Item = &'a V;
#[inline] fn next(&mut self) -> Option<(&'a V)> { self.inner.next() }
- #[inline] fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
+ #[inline] fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }
+}
+#[stable]
+impl<'a, K, V> ExactSizeIterator for Values<'a, K, V> {
+ #[inline] fn len(&self) -> usize { self.inner.len() }
}
#[stable]
-impl<'a, K: 'a, V: 'a> Iterator for Drain<'a, K, V> {
+impl<'a, K, V> Iterator for Drain<'a, K, V> {
type Item = (K, V);
- #[inline]
- fn next(&mut self) -> Option<(K, V)> {
- self.inner.next()
- }
- #[inline]
- fn size_hint(&self) -> (uint, Option<uint>) {
- self.inner.size_hint()
- }
+ #[inline] fn next(&mut self) -> Option<(K, V)> { self.inner.next() }
+ #[inline] fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }
+}
+#[stable]
+impl<'a, K, V> ExactSizeIterator for Drain<'a, K, V> {
+ #[inline] fn len(&self) -> usize { self.inner.len() }
}
#[unstable = "matches collection reform v2 specification, waiting for dust to settle"]
assert_eq!(iter.size_hint(), (3, Some(3)));
}
+ #[test]
+ fn test_iter_len() {
+ let xs = [(1i, 1i), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)];
+
+ let map: HashMap<int, int> = xs.iter().map(|&x| x).collect();
+
+ let mut iter = map.iter();
+
+ for _ in iter.by_ref().take(3) {}
+
+ assert_eq!(iter.len(), 3);
+ }
+
#[test]
fn test_mut_size_hint() {
let xs = [(1i, 1i), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)];
assert_eq!(iter.size_hint(), (3, Some(3)));
}
+ #[test]
+ fn test_iter_mut_len() {
+ let xs = [(1i, 1i), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)];
+
+ let mut map: HashMap<int, int> = xs.iter().map(|&x| x).collect();
+
+ let mut iter = map.iter_mut();
+
+ for _ in iter.by_ref().take(3) {}
+
+ assert_eq!(iter.len(), 3);
+ }
+
#[test]
fn test_index() {
let mut map: HashMap<int, int> = HashMap::new();
use fmt::Show;
use fmt;
use hash::{self, Hash};
-use iter::{Iterator, IteratorExt, FromIterator, Map, Chain, Extend};
+use iter::{Iterator, ExactSizeIterator, IteratorExt, FromIterator, Map, Chain, Extend};
use ops::{BitOr, BitAnd, BitXor, Sub};
use option::Option::{Some, None, self};
type Item = &'a K;
fn next(&mut self) -> Option<&'a K> { self.iter.next() }
- fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
+ fn size_hint(&self) -> (usize, Option<usize>) { self.iter.size_hint() }
+}
+#[stable]
+impl<'a, K> ExactSizeIterator for Iter<'a, K> {
+ fn len(&self) -> usize { self.iter.len() }
}
#[stable]
type Item = K;
fn next(&mut self) -> Option<K> { self.iter.next() }
- fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
+ fn size_hint(&self) -> (usize, Option<usize>) { self.iter.size_hint() }
+}
+#[stable]
+impl<K> ExactSizeIterator for IntoIter<K> {
+ fn len(&self) -> usize { self.iter.len() }
}
#[stable]
-impl<'a, K: 'a> Iterator for Drain<'a, K> {
+impl<'a, K> Iterator for Drain<'a, K> {
type Item = K;
fn next(&mut self) -> Option<K> { self.iter.next() }
- fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
+ fn size_hint(&self) -> (usize, Option<usize>) { self.iter.size_hint() }
+}
+#[stable]
+impl<'a, K> ExactSizeIterator for Drain<'a, K> {
+ fn len(&self) -> usize { self.iter.len() }
}
#[stable]
}
}
- fn size_hint(&self) -> (uint, Option<uint>) {
+ fn size_hint(&self) -> (usize, Option<usize>) {
let (_, upper) = self.iter.size_hint();
(0, upper)
}
}
}
- fn size_hint(&self) -> (uint, Option<uint>) {
+ fn size_hint(&self) -> (usize, Option<usize>) {
let (_, upper) = self.iter.size_hint();
(0, upper)
}
type Item = &'a T;
fn next(&mut self) -> Option<&'a T> { self.iter.next() }
- fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
+ fn size_hint(&self) -> (usize, Option<usize>) { self.iter.size_hint() }
}
#[stable]
type Item = &'a T;
fn next(&mut self) -> Option<&'a T> { self.iter.next() }
- fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
+ fn size_hint(&self) -> (usize, Option<usize>) { self.iter.size_hint() }
}
#[cfg(test)]
use clone::Clone;
use cmp;
use hash::{Hash, Hasher};
-use iter::{Iterator, count};
+use iter::{Iterator, ExactSizeIterator, count};
use marker::{Copy, Sized, self};
use mem::{min_align_of, size_of};
use mem;
})
}
- fn size_hint(&self) -> (uint, Option<uint>) {
+ fn size_hint(&self) -> (usize, Option<usize>) {
(self.elems_left, Some(self.elems_left))
}
}
+impl<'a, K, V> ExactSizeIterator for Iter<'a, K, V> {
+ fn len(&self) -> usize { self.elems_left }
+}
impl<'a, K, V> Iterator for IterMut<'a, K, V> {
type Item = (&'a K, &'a mut V);
})
}
- fn size_hint(&self) -> (uint, Option<uint>) {
+ fn size_hint(&self) -> (usize, Option<usize>) {
(self.elems_left, Some(self.elems_left))
}
}
+impl<'a, K, V> ExactSizeIterator for IterMut<'a, K, V> {
+ fn len(&self) -> usize { self.elems_left }
+}
impl<K, V> Iterator for IntoIter<K, V> {
type Item = (SafeHash, K, V);
})
}
- fn size_hint(&self) -> (uint, Option<uint>) {
+ fn size_hint(&self) -> (usize, Option<usize>) {
let size = self.table.size();
(size, Some(size))
}
}
+impl<K, V> ExactSizeIterator for IntoIter<K, V> {
+ fn len(&self) -> usize { self.table.size() }
+}
-impl<'a, K: 'a, V: 'a> Iterator for Drain<'a, K, V> {
+impl<'a, K, V> Iterator for Drain<'a, K, V> {
type Item = (SafeHash, K, V);
#[inline]
})
}
- fn size_hint(&self) -> (uint, Option<uint>) {
+ fn size_hint(&self) -> (usize, Option<usize>) {
let size = self.table.size();
(size, Some(size))
}
}
+impl<'a, K, V> ExactSizeIterator for Drain<'a, K, V> {
+ fn len(&self) -> usize { self.table.size() }
+}
#[unsafe_destructor]
impl<'a, K: 'a, V: 'a> Drop for Drain<'a, K, V> {
use cmp;
use fmt;
use io::{Reader, Writer, Stream, Buffer, DEFAULT_BUF_SIZE, IoResult};
-use iter::{IteratorExt, ExactSizeIterator};
+use iter::{IteratorExt, ExactSizeIterator, repeat};
use ops::Drop;
use option::Option;
use option::Option::{Some, None};
impl<R: Reader> BufferedReader<R> {
/// Creates a new `BufferedReader` with the specified buffer capacity
pub fn with_capacity(cap: uint, inner: R) -> BufferedReader<R> {
- // It's *much* faster to create an uninitialized buffer than it is to
- // fill everything in with 0. This buffer is entirely an implementation
- // detail and is never exposed, so we're safe to not initialize
- // everything up-front. This allows creation of BufferedReader instances
- // to be very cheap (large mallocs are not nearly as expensive as large
- // callocs).
- let mut buf = Vec::with_capacity(cap);
- unsafe { buf.set_len(cap); }
BufferedReader {
inner: inner,
- buf: buf,
+ // We can't use the same trick here as we do for BufferedWriter,
+ // since this memory is visible to the inner Reader.
+ buf: repeat(0).take(cap).collect(),
pos: 0,
cap: 0,
}
let nread = {
let available = try!(self.fill_buf());
let nread = cmp::min(available.len(), buf.len());
- slice::bytes::copy_memory(buf, &available[0..nread]);
+ slice::bytes::copy_memory(buf, &available[..nread]);
nread
};
self.pos += nread;
impl<W: Writer> BufferedWriter<W> {
/// Creates a new `BufferedWriter` with the specified buffer capacity
pub fn with_capacity(cap: uint, inner: W) -> BufferedWriter<W> {
- // See comments in BufferedReader for why this uses unsafe code.
+ // It's *much* faster to create an uninitialized buffer than it is to
+ // fill everything in with 0. This buffer is entirely an implementation
+ // detail and is never exposed, so we're safe to not initialize
+ // everything up-front. This allows creation of BufferedWriter instances
+ // to be very cheap (large mallocs are not nearly as expensive as large
+ // callocs).
let mut buf = Vec::with_capacity(cap);
unsafe { buf.set_len(cap); }
BufferedWriter {
fn flush_buf(&mut self) -> IoResult<()> {
if self.pos != 0 {
- let ret = self.inner.as_mut().unwrap().write(&self.buf[0..self.pos]);
+ let ret = self.inner.as_mut().unwrap().write(&self.buf[..self.pos]);
self.pos = 0;
ret
} else {
fn write(&mut self, buf: &[u8]) -> IoResult<()> {
match buf.iter().rposition(|&b| b == b'\n') {
Some(i) => {
- try!(self.inner.write(&buf[0..(i + 1)]));
+ try!(self.inner.write(&buf[..(i + 1)]));
try!(self.inner.flush());
try!(self.inner.write(&buf[(i + 1)..]));
Ok(())
Some(src) => {
let dst = buf.slice_from_mut(num_read);
let count = cmp::min(src.len(), dst.len());
- bytes::copy_memory(dst, &src[0..count]);
+ bytes::copy_memory(dst, &src[..count]);
count
},
None => 0,
let mut read_buf = [0; 1028];
let read_str = match check!(read_stream.read(&mut read_buf)) {
-1|0 => panic!("shouldn't happen"),
- n => str::from_utf8(&read_buf[0..n]).unwrap().to_string()
+ n => str::from_utf8(&read_buf[..n]).unwrap().to_string()
};
assert_eq!(read_str.as_slice(), message);
}
let write_len = min(buf.len(), self.len());
{
- let input = &self[0..write_len];
+ let input = &self[..write_len];
let output = buf.slice_to_mut(write_len);
slice::bytes::copy_memory(output, input);
}
Ok(())
} else {
- slice::bytes::copy_memory(dst, &src[0..dst_len]);
+ slice::bytes::copy_memory(dst, &src[..dst_len]);
self.pos += dst_len;
assert_eq!(buf, b);
assert_eq!(reader.read(&mut buf), Ok(3));
let b: &[_] = &[5, 6, 7];
- assert_eq!(&buf[0..3], b);
+ assert_eq!(&buf[..3], b);
assert!(reader.read(&mut buf).is_err());
let mut reader = MemReader::new(vec!(0, 1, 2, 3, 4, 5, 6, 7));
assert_eq!(reader.read_until(3).unwrap(), vec!(0, 1, 2, 3));
assert_eq!(buf.as_slice(), b);
assert_eq!(reader.read(&mut buf), Ok(3));
let b: &[_] = &[5, 6, 7];
- assert_eq!(&buf[0..3], b);
+ assert_eq!(&buf[..3], b);
assert!(reader.read(&mut buf).is_err());
let mut reader = &mut in_buf.as_slice();
assert_eq!(reader.read_until(3).unwrap(), vec!(0, 1, 2, 3));
assert_eq!(buf, b);
assert_eq!(reader.read(&mut buf), Ok(3));
let b: &[_] = &[5, 6, 7];
- assert_eq!(&buf[0..3], b);
+ assert_eq!(&buf[..3], b);
assert!(reader.read(&mut buf).is_err());
let mut reader = BufReader::new(in_buf.as_slice());
assert_eq!(reader.read_until(3).unwrap(), vec!(0, 1, 2, 3));
fn write_char(&mut self, c: char) -> IoResult<()> {
let mut buf = [0u8; 4];
let n = c.encode_utf8(buf.as_mut_slice()).unwrap_or(0);
- self.write(&buf[0..n])
+ self.write(&buf[..n])
}
/// Write the result of passing n through `int::to_str_bytes`.
};
match available.iter().position(|&b| b == byte) {
Some(i) => {
- res.push_all(&available[0..(i + 1)]);
+ res.push_all(&available[..(i + 1)]);
used = i + 1;
break
}
}
}
}
- match str::from_utf8(&buf[0..width]).ok() {
+ match str::from_utf8(&buf[..width]).ok() {
Some(s) => Ok(s.char_at(0)),
None => Err(standard_error(InvalidInput))
}
let mut tail = [0u16; 8];
let (tail_size, _) = read_groups(self, &mut tail, 8 - head_size);
- Some(ipv6_addr_from_head_tail(&head[0..head_size], &tail[0..tail_size]))
+ Some(ipv6_addr_from_head_tail(&head[..head_size], &tail[..tail_size]))
}
fn read_ipv6_addr(&mut self) -> Option<IpAddr> {
use libc;
use os;
use std::io::net::ip::*;
-use sync::atomic::{AtomicUint, ATOMIC_UINT_INIT, Ordering};
+use sync::atomic::{AtomicUsize, ATOMIC_USIZE_INIT, Ordering};
/// Get a port number, starting at 9600, for use in tests
pub fn next_test_port() -> u16 {
- static NEXT_OFFSET: AtomicUint = ATOMIC_UINT_INIT;
+ static NEXT_OFFSET: AtomicUsize = ATOMIC_USIZE_INIT;
base_port() + NEXT_OFFSET.fetch_add(1, Ordering::Relaxed) as u16
}
// iOS has a pretty long tmpdir path which causes pipe creation
// to like: invalid argument: path must be smaller than SUN_LEN
fn next_test_unix_socket() -> String {
- static COUNT: AtomicUint = ATOMIC_UINT_INIT;
+ static COUNT: AtomicUsize = ATOMIC_USIZE_INIT;
// base port and pid are an attempt to be unique between multiple
// test-runners of different configurations running on one
// buildbot, the count is to be unique within this executable.
impl<R: Buffer> Buffer for LimitReader<R> {
fn fill_buf<'a>(&'a mut self) -> io::IoResult<&'a [u8]> {
let amt = try!(self.inner.fill_buf());
- let buf = &amt[0..cmp::min(amt.len(), self.limit)];
+ let buf = &amt[..cmp::min(amt.len(), self.limit)];
if buf.len() == 0 {
Err(io::standard_error(io::EndOfFile))
} else {
impl<R: Reader, W: Writer> Reader for TeeReader<R, W> {
fn read(&mut self, buf: &mut [u8]) -> io::IoResult<uint> {
self.reader.read(buf).and_then(|len| {
- self.writer.write(&mut buf[0..len]).map(|()| len)
+ self.writer.write(&mut buf[..len]).map(|()| len)
})
}
}
Err(ref e) if e.kind == io::EndOfFile => return Ok(()),
Err(e) => return Err(e),
};
- try!(w.write(&buf[0..len]));
+ try!(w.write(&buf[..len]));
}
}
//!
//! ## Concurrency, I/O, and the runtime
//!
-//! The [`task`](task/index.html) module contains Rust's threading abstractions,
+//! The [`thread`](thread/index.html) module contains Rust's threading abstractions,
//! while [`comm`](comm/index.html) contains the channel types for message
//! passing. [`sync`](sync/index.html) contains further, primitive, shared
//! memory types, including [`atomic`](sync/atomic/index.html).
use slice::{AsSlice, SliceExt};
use str::{Str, StrExt};
use string::{String, ToString};
-use sync::atomic::{AtomicInt, ATOMIC_INT_INIT, Ordering};
+use sync::atomic::{AtomicIsize, ATOMIC_ISIZE_INIT, Ordering};
use vec::Vec;
#[cfg(unix)] use ffi::{self, CString};
error_string(errno() as uint)
}
-static EXIT_STATUS: AtomicInt = ATOMIC_INT_INIT;
+static EXIT_STATUS: AtomicIsize = ATOMIC_ISIZE_INIT;
/// Sets the process exit code
///
pub const ARCH: &'static str = "mipsel";
}
+#[cfg(target_arch = "powerpc")]
+mod arch_consts {
+ pub const ARCH: &'static str = "powerpc";
+}
+
#[cfg(test)]
mod tests {
use prelude::v1::*;
match name.rposition_elem(&dot) {
None | Some(0) => name,
Some(1) if name == b".." => name,
- Some(pos) => &name[0..pos]
+ Some(pos) => &name[..pos]
}
})
}
let extlen = extension.container_as_bytes().len();
match (name.rposition_elem(&dot), extlen) {
(None, 0) | (Some(0), 0) => None,
- (Some(idx), 0) => Some(name[0..idx].to_vec()),
+ (Some(idx), 0) => Some(name[..idx].to_vec()),
(idx, extlen) => {
let idx = match idx {
None | Some(0) => name.len(),
let mut v;
v = Vec::with_capacity(idx + extlen + 1);
- v.push_all(&name[0..idx]);
+ v.push_all(&name[..idx]);
v.push(dot);
v.push_all(extension.container_as_bytes());
Some(v)
}
Some(idx) => {
let mut v = Vec::with_capacity(idx + 1 + filename.len());
- v.push_all(&self.repr[0..(idx+1)]);
+ v.push_all(&self.repr[..(idx+1)]);
v.push_all(filename);
// FIXME: this is slow
self.repr = Path::normalize(v.as_slice());
match self.sepidx {
None if b".." == self.repr => self.repr.as_slice(),
None => dot_static,
- Some(0) => &self.repr[0..1],
+ Some(0) => &self.repr[..1],
Some(idx) if &self.repr[(idx+1)..] == b".." => self.repr.as_slice(),
- Some(idx) => &self.repr[0..idx]
+ Some(idx) => &self.repr[..idx]
}
}
}
Some((_,idxa,end)) if &self.repr[idxa..end] == ".." => {
let mut s = String::with_capacity(end + 1 + filename.len());
- s.push_str(&self.repr[0..end]);
+ s.push_str(&self.repr[..end]);
s.push(SEP);
s.push_str(filename);
self.update_normalized(&s[]);
}
Some((idxb,idxa,_)) if self.prefix == Some(DiskPrefix) && idxa == self.prefix_len() => {
let mut s = String::with_capacity(idxb + filename.len());
- s.push_str(&self.repr[0..idxb]);
+ s.push_str(&self.repr[..idxb]);
s.push_str(filename);
self.update_normalized(&s[]);
}
Some((idxb,_,_)) => {
let mut s = String::with_capacity(idxb + 1 + filename.len());
- s.push_str(&self.repr[0..idxb]);
+ s.push_str(&self.repr[..idxb]);
s.push(SEP);
s.push_str(filename);
self.update_normalized(&s[]);
Some((idxb,_,end)) if &self.repr[idxb..end] == "\\" => {
&self.repr[]
}
- Some((0,idxa,_)) => &self.repr[0..idxa],
+ Some((0,idxa,_)) => &self.repr[..idxa],
Some((idxb,idxa,_)) => {
match self.prefix {
Some(DiskPrefix) | Some(VerbatimDiskPrefix) if idxb == self.prefix_len() => {
- &self.repr[0..idxa]
+ &self.repr[..idxa]
}
- _ => &self.repr[0..idxb]
+ _ => &self.repr[..idxb]
}
}
})
if self.prefix.is_some() {
Some(Path::new(match self.prefix {
Some(DiskPrefix) if self.is_absolute() => {
- &self.repr[0..(self.prefix_len()+1)]
+ &self.repr[..(self.prefix_len()+1)]
}
Some(VerbatimDiskPrefix) => {
- &self.repr[0..(self.prefix_len()+1)]
+ &self.repr[..(self.prefix_len()+1)]
}
- _ => &self.repr[0..self.prefix_len()]
+ _ => &self.repr[..self.prefix_len()]
}))
} else if is_vol_relative(self) {
- Some(Path::new(&self.repr[0..1]))
+ Some(Path::new(&self.repr[..1]))
} else {
None
}
}
(None, None) => true,
(a, b) if a == b => {
- &s_repr[0..self.prefix_len()] == &o_repr[0..other.prefix_len()]
+ &s_repr[..self.prefix_len()] == &o_repr[..other.prefix_len()]
}
_ => false
}
match prefix.unwrap() {
DiskPrefix => {
let len = prefix_len(prefix) + is_abs as uint;
- let mut s = String::from_str(&s[0..len]);
+ let mut s = String::from_str(&s[..len]);
unsafe {
let v = s.as_mut_vec();
v[0] = (*v)[0].to_ascii_uppercase();
}
VerbatimDiskPrefix => {
let len = prefix_len(prefix) + is_abs as uint;
- let mut s = String::from_str(&s[0..len]);
+ let mut s = String::from_str(&s[..len]);
unsafe {
let v = s.as_mut_vec();
v[4] = (*v)[4].to_ascii_uppercase();
_ => {
let plen = prefix_len(prefix);
if s.len() > plen {
- Some(String::from_str(&s[0..plen]))
+ Some(String::from_str(&s[..plen]))
} else { None }
}
}
} else if is_abs && comps.is_empty() {
Some(repeat(SEP).take(1).collect())
} else {
- let prefix_ = &s[0..prefix_len(prefix)];
+ let prefix_ = &s[..prefix_len(prefix)];
let n = prefix_.len() +
if is_abs { comps.len() } else { comps.len() - 1} +
comps.iter().map(|v| v.len()).sum();
s.push(':');
}
Some(VerbatimDiskPrefix) => {
- s.push_str(&prefix_[0..4]);
+ s.push_str(&prefix_[..4]);
s.push(prefix_.as_bytes()[4].to_ascii_uppercase() as char);
s.push_str(&prefix_[5..]);
}
fn update_sepidx(&mut self) {
let s = if self.has_nonsemantic_trailing_slash() {
- &self.repr[0..(self.repr.len()-1)]
+ &self.repr[..(self.repr.len()-1)]
} else { &self.repr[] };
let sep_test: fn(char) -> bool = if !prefix_is_verbatim(self.prefix) {
is_sep
/// `random()` can generate various types of random things, and so may require
/// type hinting to generate the specific type you want.
///
+/// This function uses the thread local random number generator. This means
+/// that if you're calling `random()` in a loop, caching the generator can
+/// increase performance. An example is shown below.
+///
/// # Examples
///
-/// ```rust
+/// ```
/// use std::rand;
///
/// let x = rand::random();
/// println!("Better lucky than good!");
/// }
/// ```
+///
+/// Caching the thread local random number generator:
+///
+/// ```
+/// use std::rand;
+/// use std::rand::Rng;
+///
+/// let mut v = vec![1, 2, 3];
+///
+/// for x in v.iter_mut() {
+/// *x = rand::random()
+/// }
+///
+/// // would be faster as
+///
+/// let mut rng = rand::thread_rng();
+///
+/// for x in v.iter_mut() {
+/// *x = rng.gen();
+/// }
+/// ```
#[inline]
pub fn random<T: Rand>() -> T {
thread_rng().gen()
any(target_arch = "x86_64",
target_arch = "x86",
target_arch = "arm",
- target_arch = "aarch64")))]
+ target_arch = "aarch64",
+ target_arch = "powerpc")))]
fn getrandom(buf: &mut [u8]) -> libc::c_long {
extern "C" {
fn syscall(number: libc::c_long, ...) -> libc::c_long;
const NR_GETRANDOM: libc::c_long = 355;
#[cfg(any(target_arch = "arm", target_arch = "aarch64"))]
const NR_GETRANDOM: libc::c_long = 384;
+ #[cfg(target_arch = "powerpc")]
+ const NR_GETRANDOM: libc::c_long = 384;
unsafe {
syscall(NR_GETRANDOM, buf.as_mut_ptr(), buf.len(), 0u)
any(target_arch = "x86_64",
target_arch = "x86",
target_arch = "arm",
- target_arch = "aarch64"))))]
+ target_arch = "aarch64",
+ target_arch = "powerpc"))))]
fn getrandom(_buf: &mut [u8]) -> libc::c_long { -1 }
fn getrandom_fill_bytes(v: &mut [u8]) {
any(target_arch = "x86_64",
target_arch = "x86",
target_arch = "arm",
- target_arch = "aarch64")))]
+ target_arch = "aarch64",
+ target_arch = "powerpc")))]
fn is_getrandom_available() -> bool {
use sync::atomic::{AtomicBool, ATOMIC_BOOL_INIT, Ordering};
any(target_arch = "x86_64",
target_arch = "x86",
target_arch = "arm",
- target_arch = "aarch64"))))]
+ target_arch = "aarch64",
+ target_arch = "powerpc"))))]
fn is_getrandom_available() -> bool { false }
/// A random number generator that retrieves randomness straight from
// For now logging is turned off by default, and this function checks to see
// whether the magical environment variable is present to see if it's turned on.
pub fn log_enabled() -> bool {
- static ENABLED: atomic::AtomicInt = atomic::ATOMIC_INT_INIT;
+ static ENABLED: atomic::AtomicIsize = atomic::ATOMIC_ISIZE_INIT;
match ENABLED.load(Ordering::SeqCst) {
1 => return false,
2 => return true,
#[cfg(any(target_arch = "mips", target_arch = "mipsel"))]
pub const unwinder_private_data_size: uint = 2;
+#[cfg(target_arch = "powerpc")]
+pub const unwinder_private_data_size: uint = 2;
+
#[repr(C)]
pub struct _Unwind_Exception {
pub exception_class: _Unwind_Exception_Class,
//
// For more information, see below.
const MAX_CALLBACKS: uint = 16;
-static CALLBACKS: [atomic::AtomicUint; MAX_CALLBACKS] =
- [atomic::ATOMIC_UINT_INIT, atomic::ATOMIC_UINT_INIT,
- atomic::ATOMIC_UINT_INIT, atomic::ATOMIC_UINT_INIT,
- atomic::ATOMIC_UINT_INIT, atomic::ATOMIC_UINT_INIT,
- atomic::ATOMIC_UINT_INIT, atomic::ATOMIC_UINT_INIT,
- atomic::ATOMIC_UINT_INIT, atomic::ATOMIC_UINT_INIT,
- atomic::ATOMIC_UINT_INIT, atomic::ATOMIC_UINT_INIT,
- atomic::ATOMIC_UINT_INIT, atomic::ATOMIC_UINT_INIT,
- atomic::ATOMIC_UINT_INIT, atomic::ATOMIC_UINT_INIT];
-static CALLBACK_CNT: atomic::AtomicUint = atomic::ATOMIC_UINT_INIT;
+static CALLBACKS: [atomic::AtomicUsize; MAX_CALLBACKS] =
+ [atomic::ATOMIC_USIZE_INIT, atomic::ATOMIC_USIZE_INIT,
+ atomic::ATOMIC_USIZE_INIT, atomic::ATOMIC_USIZE_INIT,
+ atomic::ATOMIC_USIZE_INIT, atomic::ATOMIC_USIZE_INIT,
+ atomic::ATOMIC_USIZE_INIT, atomic::ATOMIC_USIZE_INIT,
+ atomic::ATOMIC_USIZE_INIT, atomic::ATOMIC_USIZE_INIT,
+ atomic::ATOMIC_USIZE_INIT, atomic::ATOMIC_USIZE_INIT,
+ atomic::ATOMIC_USIZE_INIT, atomic::ATOMIC_USIZE_INIT,
+ atomic::ATOMIC_USIZE_INIT, atomic::ATOMIC_USIZE_INIT];
+static CALLBACK_CNT: atomic::AtomicUsize = atomic::ATOMIC_USIZE_INIT;
thread_local! { static PANICKING: Cell<bool> = Cell::new(false) }
// MAX_CALLBACKS, so we're sure to clamp it as necessary.
let callbacks = {
let amt = CALLBACK_CNT.load(Ordering::SeqCst);
- &CALLBACKS[0..cmp::min(amt, MAX_CALLBACKS)]
+ &CALLBACKS[..cmp::min(amt, MAX_CALLBACKS)]
};
for cb in callbacks.iter() {
match cb.load(Ordering::SeqCst) {
}
pub fn min_stack() -> uint {
- static MIN: atomic::AtomicUint = atomic::ATOMIC_UINT_INIT;
+ static MIN: atomic::AtomicUsize = atomic::ATOMIC_USIZE_INIT;
match MIN.load(Ordering::SeqCst) {
0 => {}
n => return n - 1,
impl<'a> fmt::Writer for BufWriter<'a> {
fn write_str(&mut self, bytes: &str) -> fmt::Result {
let left = self.buf.slice_from_mut(self.pos);
- let to_write = &bytes.as_bytes()[0..cmp::min(bytes.len(), left.len())];
+ let to_write = &bytes.as_bytes()[..cmp::min(bytes.len(), left.len())];
slice::bytes::copy_memory(left, to_write);
self.pos += to_write.len();
Ok(())
let mut msg = [0u8; 512];
let mut w = BufWriter { buf: &mut msg, pos: 0 };
let _ = write!(&mut w, "{}", args);
- let msg = str::from_utf8(&w.buf[0..w.pos]).unwrap_or("aborted");
+ let msg = str::from_utf8(&w.buf[..w.pos]).unwrap_or("aborted");
let msg = if msg.is_empty() {"aborted"} else {msg};
-
- // Give some context to the message
- let hash = msg.bytes().fold(0, |accum, val| accum + (val as uint) );
- let quote = match hash % 10 {
- 0 => "
-It was from the artists and poets that the pertinent answers came, and I
-know that panic would have broken loose had they been able to compare notes.
-As it was, lacking their original letters, I half suspected the compiler of
-having asked leading questions, or of having edited the correspondence in
-corroboration of what he had latently resolved to see.",
- 1 => "
-There are not many persons who know what wonders are opened to them in the
-stories and visions of their youth; for when as children we listen and dream,
-we think but half-formed thoughts, and when as men we try to remember, we are
-dulled and prosaic with the poison of life. But some of us awake in the night
-with strange phantasms of enchanted hills and gardens, of fountains that sing
-in the sun, of golden cliffs overhanging murmuring seas, of plains that stretch
-down to sleeping cities of bronze and stone, and of shadowy companies of heroes
-that ride caparisoned white horses along the edges of thick forests; and then
-we know that we have looked back through the ivory gates into that world of
-wonder which was ours before we were wise and unhappy.",
- 2 => "
-Instead of the poems I had hoped for, there came only a shuddering blackness
-and ineffable loneliness; and I saw at last a fearful truth which no one had
-ever dared to breathe before — the unwhisperable secret of secrets — The fact
-that this city of stone and stridor is not a sentient perpetuation of Old New
-York as London is of Old London and Paris of Old Paris, but that it is in fact
-quite dead, its sprawling body imperfectly embalmed and infested with queer
-animate things which have nothing to do with it as it was in life.",
- 3 => "
-The ocean ate the last of the land and poured into the smoking gulf, thereby
-giving up all it had ever conquered. From the new-flooded lands it flowed
-again, uncovering death and decay; and from its ancient and immemorial bed it
-trickled loathsomely, uncovering nighted secrets of the years when Time was
-young and the gods unborn. Above the waves rose weedy remembered spires. The
-moon laid pale lilies of light on dead London, and Paris stood up from its damp
-grave to be sanctified with star-dust. Then rose spires and monoliths that were
-weedy but not remembered; terrible spires and monoliths of lands that men never
-knew were lands...",
- 4 => "
-There was a night when winds from unknown spaces whirled us irresistibly into
-limitless vacuum beyond all thought and entity. Perceptions of the most
-maddeningly untransmissible sort thronged upon us; perceptions of infinity
-which at the time convulsed us with joy, yet which are now partly lost to my
-memory and partly incapable of presentation to others.",
- _ => "You've met with a terrible fate, haven't you?"
- };
- rterrln!("{}", "");
- rterrln!("{}", quote);
- rterrln!("{}", "");
rterrln!("fatal runtime error: {}", msg);
unsafe { intrinsics::abort(); }
}
use prelude::v1::*;
-use sync::atomic::{AtomicUint, Ordering, ATOMIC_UINT_INIT};
+use sync::atomic::{AtomicUsize, Ordering, ATOMIC_USIZE_INIT};
use sync::poison::{self, LockResult};
use sys_common::condvar as sys;
use sys_common::mutex as sys_mutex;
#[unstable = "may be merged with Condvar in the future"]
pub struct StaticCondvar {
inner: sys::Condvar,
- mutex: AtomicUint,
+ mutex: AtomicUsize,
}
unsafe impl Send for StaticCondvar {}
#[unstable = "may be merged with Condvar in the future"]
pub const CONDVAR_INIT: StaticCondvar = StaticCondvar {
inner: sys::CONDVAR_INIT,
- mutex: ATOMIC_UINT_INIT,
+ mutex: ATOMIC_USIZE_INIT,
};
impl Condvar {
Condvar {
inner: box StaticCondvar {
inner: unsafe { sys::Condvar::new() },
- mutex: AtomicUint::new(0),
+ mutex: AtomicUsize::new(0),
}
}
}
use sync::mpsc::Receiver;
use sync::mpsc::blocking::{self, SignalToken};
use core::mem;
-use sync::atomic::{AtomicUint, Ordering};
+use sync::atomic::{AtomicUsize, Ordering};
// Various states you can find a port in.
const EMPTY: uint = 0; // initial state: no data, no blocked reciever
pub struct Packet<T> {
// Internal state of the chan/port pair (stores the blocked task as well)
- state: AtomicUint,
+ state: AtomicUsize,
// One-shot data slot location
data: Option<T>,
// when used for the second time, a oneshot channel must be upgraded, and
Packet {
data: None,
upgrade: NothingSent,
- state: AtomicUint::new(EMPTY),
+ state: AtomicUsize::new(EMPTY),
}
}
use core::cmp;
use core::int;
-use sync::atomic::{AtomicUint, AtomicInt, AtomicBool, Ordering};
+use sync::atomic::{AtomicUsize, AtomicIsize, AtomicBool, Ordering};
use sync::mpsc::blocking::{self, SignalToken};
use sync::mpsc::mpsc_queue as mpsc;
use sync::mpsc::select::StartResult::*;
pub struct Packet<T> {
queue: mpsc::Queue<T>,
- cnt: AtomicInt, // How many items are on this channel
+ cnt: AtomicIsize, // How many items are on this channel
steals: int, // How many times has a port received without blocking?
- to_wake: AtomicUint, // SignalToken for wake up
+ to_wake: AtomicUsize, // SignalToken for wake up
// The number of channels which are currently using this packet.
- channels: AtomicInt,
+ channels: AtomicIsize,
// See the discussion in Port::drop and the channel send methods for what
// these are used for
port_dropped: AtomicBool,
- sender_drain: AtomicInt,
+ sender_drain: AtomicIsize,
// this lock protects various portions of this implementation during
// select()
pub fn new() -> Packet<T> {
let p = Packet {
queue: mpsc::Queue::new(),
- cnt: AtomicInt::new(0),
+ cnt: AtomicIsize::new(0),
steals: 0,
- to_wake: AtomicUint::new(0),
- channels: AtomicInt::new(2),
+ to_wake: AtomicUsize::new(0),
+ channels: AtomicIsize::new(2),
port_dropped: AtomicBool::new(false),
- sender_drain: AtomicInt::new(0),
+ sender_drain: AtomicIsize::new(0),
select_lock: Mutex::new(()),
};
return p;
use core::mem;
use core::cell::UnsafeCell;
-use sync::atomic::{AtomicPtr, AtomicUint, Ordering};
+use sync::atomic::{AtomicPtr, AtomicUsize, Ordering};
// Node within the linked list queue of messages to send
struct Node<T> {
// Cache maintenance fields. Additions and subtractions are stored
// separately in order to allow them to use nonatomic addition/subtraction.
cache_bound: uint,
- cache_additions: AtomicUint,
- cache_subtractions: AtomicUint,
+ cache_additions: AtomicUsize,
+ cache_subtractions: AtomicUsize,
}
unsafe impl<T: Send> Send for Queue<T> { }
first: UnsafeCell::new(n1),
tail_copy: UnsafeCell::new(n1),
cache_bound: bound,
- cache_additions: AtomicUint::new(0),
- cache_subtractions: AtomicUint::new(0),
+ cache_additions: AtomicUsize::new(0),
+ cache_subtractions: AtomicUsize::new(0),
}
}
use core::int;
use thread::Thread;
-use sync::atomic::{AtomicInt, AtomicUint, Ordering, AtomicBool};
+use sync::atomic::{AtomicIsize, AtomicUsize, Ordering, AtomicBool};
use sync::mpsc::Receiver;
use sync::mpsc::blocking::{self, SignalToken};
use sync::mpsc::spsc_queue as spsc;
pub struct Packet<T> {
queue: spsc::Queue<Message<T>>, // internal queue for all message
- cnt: AtomicInt, // How many items are on this channel
+ cnt: AtomicIsize, // How many items are on this channel
steals: int, // How many times has a port received without blocking?
- to_wake: AtomicUint, // SignalToken for the blocked thread to wake up
+ to_wake: AtomicUsize, // SignalToken for the blocked thread to wake up
port_dropped: AtomicBool, // flag if the channel has been destroyed.
}
Packet {
queue: unsafe { spsc::Queue::new(128) },
- cnt: AtomicInt::new(0),
+ cnt: AtomicIsize::new(0),
steals: 0,
- to_wake: AtomicUint::new(0),
+ to_wake: AtomicUsize::new(0),
port_dropped: AtomicBool::new(false),
}
use vec::Vec;
use core::mem;
-use sync::atomic::{Ordering, AtomicUint};
+use sync::atomic::{Ordering, AtomicUsize};
use sync::mpsc::blocking::{self, WaitToken, SignalToken};
use sync::mpsc::select::StartResult::{self, Installed, Abort};
use sync::{Mutex, MutexGuard};
pub struct Packet<T> {
/// Only field outside of the mutex. Just done for kicks, but mainly because
/// the other shared channel already had the code implemented
- channels: AtomicUint,
+ channels: AtomicUsize,
lock: Mutex<State<T>>,
}
impl<T: Send> Packet<T> {
pub fn new(cap: uint) -> Packet<T> {
Packet {
- channels: AtomicUint::new(1),
+ channels: AtomicUsize::new(1),
lock: Mutex::new(State {
disconnected: false,
blocker: NoneBlocked,
use marker::Sync;
use mem::drop;
use ops::FnOnce;
-use sync::atomic::{AtomicInt, Ordering, ATOMIC_INT_INIT};
+use sync::atomic::{AtomicIsize, Ordering, ATOMIC_ISIZE_INIT};
use sync::{StaticMutex, MUTEX_INIT};
/// A synchronization primitive which can be used to run a one-time global
#[stable]
pub struct Once {
mutex: StaticMutex,
- cnt: AtomicInt,
- lock_cnt: AtomicInt,
+ cnt: AtomicIsize,
+ lock_cnt: AtomicIsize,
}
unsafe impl Sync for Once {}
#[stable]
pub const ONCE_INIT: Once = Once {
mutex: MUTEX_INIT,
- cnt: ATOMIC_INT_INIT,
- lock_cnt: ATOMIC_INT_INIT,
+ cnt: ATOMIC_ISIZE_INIT,
+ lock_cnt: ATOMIC_ISIZE_INIT,
};
impl Once {
unsafe fn target_record_sp_limit(_: uint) {
}
+ // powerpc - FIXME(POWERPC): missing...
+ #[cfg(target_arch = "powerpc")]
+ unsafe fn target_record_sp_limit(_: uint) {
+ }
+
+
// iOS segmented stack is disabled for now, see related notes
#[cfg(all(target_arch = "arm", target_os = "ios"))] #[inline(always)]
unsafe fn target_record_sp_limit(_: uint) {
1024
}
+ // powepc - FIXME(POWERPC): missing...
+ #[cfg(target_arch = "powerpc")]
+ unsafe fn target_get_sp_limit() -> uint {
+ 1024
+ }
+
// iOS doesn't support segmented stacks yet. This function might
// be called by runtime though so it is unsafe to mark it as
// unreachable, let's return a fixed constant.
use prelude::v1::*;
-use sync::atomic::{self, AtomicUint, Ordering};
+use sync::atomic::{self, AtomicUsize, Ordering};
use sync::{Mutex, Once, ONCE_INIT};
use sys::thread_local as imp;
/// Inner contents of `StaticKey`, created by the `INIT_INNER` constant.
pub struct StaticKeyInner {
- key: AtomicUint,
+ key: AtomicUsize,
}
/// A type for a safely managed OS-based TLS slot.
///
/// This value allows specific configuration of the destructor for a TLS key.
pub const INIT_INNER: StaticKeyInner = StaticKeyInner {
- key: atomic::ATOMIC_UINT_INIT,
+ key: atomic::ATOMIC_USIZE_INIT,
};
static INIT_KEYS: Once = ONCE_INIT;
target_os = "android"))]
pub const FIONBIO: libc::c_ulong = 0x5421;
#[cfg(all(target_os = "linux",
- any(target_arch = "mips", target_arch = "mipsel")))]
+ any(target_arch = "mips",
+ target_arch = "mipsel",
+ target_arch = "powerpc")))]
pub const FIONBIO: libc::c_ulong = 0x667e;
#[cfg(any(target_os = "macos",
target_os = "android"))]
pub const FIOCLEX: libc::c_ulong = 0x5451;
#[cfg(all(target_os = "linux",
- any(target_arch = "mips", target_arch = "mipsel")))]
+ any(target_arch = "mips",
+ target_arch = "mipsel",
+ target_arch = "powerpc")))]
pub const FIOCLEX: libc::c_ulong = 0x6601;
#[cfg(any(target_os = "macos",
}
#[cfg(all(target_os = "linux",
- any(target_arch = "mips", target_arch = "mipsel")))]
+ any(target_arch = "mips",
+ target_arch = "mipsel",
+ target_arch = "powerpc")))]
mod signal {
use libc;
all(target_os = "linux", target_arch = "aarch64"),
all(target_os = "linux", target_arch = "mips"), // may not match
all(target_os = "linux", target_arch = "mipsel"), // may not match
+ all(target_os = "linux", target_arch = "powerpc"), // may not match
target_os = "android"))] // may not match
mod signal {
use libc;
#[cfg(any(target_arch = "x86",
target_arch = "arm",
target_arch = "mips",
- target_arch = "mipsel"))]
+ target_arch = "mipsel",
+ target_arch = "powerpc"))]
const __SIZEOF_PTHREAD_MUTEX_T: uint = 24 - 8;
#[cfg(target_arch = "aarch64")]
const __SIZEOF_PTHREAD_MUTEX_T: uint = 48 - 8;
target_arch = "arm",
target_arch = "aarch64",
target_arch = "mips",
- target_arch = "mipsel"))]
+ target_arch = "mipsel",
+ target_arch = "powerpc"))]
const __SIZEOF_PTHREAD_COND_T: uint = 48 - 8;
#[cfg(any(target_arch = "x86_64",
#[cfg(any(target_arch = "x86",
target_arch = "arm",
target_arch = "mips",
- target_arch = "mipsel"))]
+ target_arch = "mipsel",
+ target_arch = "powerpc"))]
const __SIZEOF_PTHREAD_RWLOCK_T: uint = 32 - 8;
#[repr(C)]
PAGE_SIZE = psize as uint;
- let stackaddr = get_stack_start();
+ let mut stackaddr = get_stack_start();
+
+ // Ensure stackaddr is page aligned! A parent process might
+ // have reset RLIMIT_STACK to be non-page aligned. The
+ // pthread_attr_getstack() reports the usable stack area
+ // stackaddr < stackaddr + stacksize, so if stackaddr is not
+ // page-aligned, calculate the fix such that stackaddr <
+ // new_page_aligned_stackaddr < stackaddr + stacksize
+ let remainder = (stackaddr as usize) % (PAGE_SIZE as usize);
+ if remainder != 0 {
+ stackaddr = ((stackaddr as usize) + (PAGE_SIZE as usize) - remainder)
+ as *mut libc::c_void;
+ }
// Rellocate the last page of the stack.
// This ensures SIGBUS will be raised on
// instead of ()
HELPER.boot(|| {}, helper);
- static ID: atomic::AtomicUint = atomic::ATOMIC_UINT_INIT;
+ static ID: atomic::AtomicUsize = atomic::ATOMIC_USIZE_INIT;
let id = ID.fetch_add(1, Ordering::Relaxed);
Ok(Timer {
id: id,
#[inline]
pub unsafe fn wait(&self, mutex: &Mutex) {
- let r = ffi::SleepConditionVariableCS(self.inner.get(),
- mutex::raw(mutex),
- libc::INFINITE);
+ let r = ffi::SleepConditionVariableSRW(self.inner.get(),
+ mutex::raw(mutex),
+ libc::INFINITE,
+ 0);
debug_assert!(r != 0);
}
pub unsafe fn wait_timeout(&self, mutex: &Mutex, dur: Duration) -> bool {
- let r = ffi::SleepConditionVariableCS(self.inner.get(),
- mutex::raw(mutex),
- dur.num_milliseconds() as DWORD);
+ let r = ffi::SleepConditionVariableSRW(self.inner.get(),
+ mutex::raw(mutex),
+ dur.num_milliseconds() as DWORD,
+ 0);
if r == 0 {
const ERROR_TIMEOUT: DWORD = 0x5B4;
debug_assert_eq!(os::errno() as uint, ERROR_TIMEOUT as uint);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use prelude::v1::*;
-
-use sync::atomic::{AtomicUint, ATOMIC_UINT_INIT, Ordering};
-use alloc::{self, heap};
-
-use libc::DWORD;
+use marker::Sync;
+use cell::UnsafeCell;
use sys::sync as ffi;
-const SPIN_COUNT: DWORD = 4000;
+pub struct Mutex { inner: UnsafeCell<ffi::SRWLOCK> }
-pub struct Mutex { inner: AtomicUint }
-
-pub const MUTEX_INIT: Mutex = Mutex { inner: ATOMIC_UINT_INIT };
+pub const MUTEX_INIT: Mutex = Mutex {
+ inner: UnsafeCell { value: ffi::SRWLOCK_INIT }
+};
unsafe impl Sync for Mutex {}
#[inline]
-pub unsafe fn raw(m: &Mutex) -> ffi::LPCRITICAL_SECTION {
- m.get()
+pub unsafe fn raw(m: &Mutex) -> ffi::PSRWLOCK {
+ m.inner.get()
}
+// So you might be asking why we're using SRWLock instead of CriticalSection?
+//
+// 1. SRWLock is several times faster than CriticalSection according to benchmarks performed on both
+// Windows 8 and Windows 7.
+//
+// 2. CriticalSection allows recursive locking while SRWLock deadlocks. The Unix implementation
+// deadlocks so consistency is preferred. See #19962 for more details.
+//
+// 3. While CriticalSection is fair and SRWLock is not, the current Rust policy is there there are
+// no guarantees of fairness.
+
impl Mutex {
#[inline]
- pub unsafe fn new() -> Mutex {
- Mutex { inner: AtomicUint::new(init_lock() as uint) }
- }
+ pub unsafe fn new() -> Mutex { MUTEX_INIT }
#[inline]
pub unsafe fn lock(&self) {
- ffi::EnterCriticalSection(self.get())
+ ffi::AcquireSRWLockExclusive(self.inner.get())
}
#[inline]
pub unsafe fn try_lock(&self) -> bool {
- ffi::TryEnterCriticalSection(self.get()) != 0
+ ffi::TryAcquireSRWLockExclusive(self.inner.get()) != 0
}
#[inline]
pub unsafe fn unlock(&self) {
- ffi::LeaveCriticalSection(self.get())
+ ffi::ReleaseSRWLockExclusive(self.inner.get())
}
+ #[inline]
pub unsafe fn destroy(&self) {
- let lock = self.inner.swap(0, Ordering::SeqCst);
- if lock != 0 { free_lock(lock as ffi::LPCRITICAL_SECTION) }
- }
-
- unsafe fn get(&self) -> ffi::LPCRITICAL_SECTION {
- match self.inner.load(Ordering::SeqCst) {
- 0 => {}
- n => return n as ffi::LPCRITICAL_SECTION
- }
- let lock = init_lock();
- match self.inner.compare_and_swap(0, lock as uint, Ordering::SeqCst) {
- 0 => return lock as ffi::LPCRITICAL_SECTION,
- _ => {}
- }
- free_lock(lock);
- return self.inner.load(Ordering::SeqCst) as ffi::LPCRITICAL_SECTION;
+ // ...
}
}
-
-unsafe fn init_lock() -> ffi::LPCRITICAL_SECTION {
- let block = heap::allocate(ffi::CRITICAL_SECTION_SIZE, 8)
- as ffi::LPCRITICAL_SECTION;
- if block.is_null() { alloc::oom() }
- ffi::InitializeCriticalSectionAndSpinCount(block, SPIN_COUNT);
- return block;
-}
-
-unsafe fn free_lock(h: ffi::LPCRITICAL_SECTION) {
- ffi::DeleteCriticalSection(h);
- heap::deallocate(h as *mut _, ffi::CRITICAL_SECTION_SIZE, 8);
-}
pub fn truncate_utf16_at_nul<'a>(v: &'a [u16]) -> &'a [u16] {
match v.iter().position(|c| *c == 0) {
// don't include the 0
- Some(i) => &v[0..i],
+ Some(i) => &v[..i],
None => v
}
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use libc::{BOOL, DWORD, c_void, LPVOID};
+use libc::{BOOL, DWORD, c_void, LPVOID, c_ulong};
use libc::types::os::arch::extra::BOOLEAN;
-pub type LPCRITICAL_SECTION = *mut c_void;
-pub type LPCONDITION_VARIABLE = *mut CONDITION_VARIABLE;
-pub type LPSRWLOCK = *mut SRWLOCK;
-
-#[cfg(target_arch = "x86")]
-pub const CRITICAL_SECTION_SIZE: uint = 24;
-#[cfg(target_arch = "x86_64")]
-pub const CRITICAL_SECTION_SIZE: uint = 40;
+pub type PCONDITION_VARIABLE = *mut CONDITION_VARIABLE;
+pub type PSRWLOCK = *mut SRWLOCK;
+pub type ULONG = c_ulong;
#[repr(C)]
pub struct CONDITION_VARIABLE { pub ptr: LPVOID }
pub const SRWLOCK_INIT: SRWLOCK = SRWLOCK { ptr: 0 as *mut _ };
extern "system" {
- // critical sections
- pub fn InitializeCriticalSectionAndSpinCount(
- lpCriticalSection: LPCRITICAL_SECTION,
- dwSpinCount: DWORD) -> BOOL;
- pub fn DeleteCriticalSection(lpCriticalSection: LPCRITICAL_SECTION);
- pub fn EnterCriticalSection(lpCriticalSection: LPCRITICAL_SECTION);
- pub fn LeaveCriticalSection(lpCriticalSection: LPCRITICAL_SECTION);
- pub fn TryEnterCriticalSection(lpCriticalSection: LPCRITICAL_SECTION) -> BOOL;
-
// condition variables
- pub fn SleepConditionVariableCS(ConditionVariable: LPCONDITION_VARIABLE,
- CriticalSection: LPCRITICAL_SECTION,
- dwMilliseconds: DWORD) -> BOOL;
- pub fn WakeConditionVariable(ConditionVariable: LPCONDITION_VARIABLE);
- pub fn WakeAllConditionVariable(ConditionVariable: LPCONDITION_VARIABLE);
+ pub fn SleepConditionVariableSRW(ConditionVariable: PCONDITION_VARIABLE,
+ SRWLock: PSRWLOCK,
+ dwMilliseconds: DWORD,
+ Flags: ULONG) -> BOOL;
+ pub fn WakeConditionVariable(ConditionVariable: PCONDITION_VARIABLE);
+ pub fn WakeAllConditionVariable(ConditionVariable: PCONDITION_VARIABLE);
// slim rwlocks
- pub fn AcquireSRWLockExclusive(SRWLock: LPSRWLOCK);
- pub fn AcquireSRWLockShared(SRWLock: LPSRWLOCK);
- pub fn ReleaseSRWLockExclusive(SRWLock: LPSRWLOCK);
- pub fn ReleaseSRWLockShared(SRWLock: LPSRWLOCK);
- pub fn TryAcquireSRWLockExclusive(SRWLock: LPSRWLOCK) -> BOOLEAN;
- pub fn TryAcquireSRWLockShared(SRWLock: LPSRWLOCK) -> BOOLEAN;
+ pub fn AcquireSRWLockExclusive(SRWLock: PSRWLOCK);
+ pub fn AcquireSRWLockShared(SRWLock: PSRWLOCK);
+ pub fn ReleaseSRWLockExclusive(SRWLock: PSRWLOCK);
+ pub fn ReleaseSRWLockShared(SRWLock: PSRWLOCK);
+ pub fn TryAcquireSRWLockExclusive(SRWLock: PSRWLOCK) -> BOOLEAN;
+ pub fn TryAcquireSRWLockShared(SRWLock: PSRWLOCK) -> BOOLEAN;
}
-
/// Variable reference, possibly containing `::` and/or
/// type parameters, e.g. foo::bar::<baz>
ExprPath(Path),
+ /// A "qualified path", e.g. `<Vec<T> as SomeTrait>::SomeType`
+ ExprQPath(P<QPath>),
ExprAddrOf(Mutability, P<Expr>),
ExprBreak(Option<Ident>),
///
/// <Vec<T> as SomeTrait>::SomeAssociatedItem
/// ^~~~~ ^~~~~~~~~ ^~~~~~~~~~~~~~~~~~
-/// self_type trait_name item_name
+/// self_type trait_name item_path
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Show)]
pub struct QPath {
pub self_type: P<Ty>,
pub trait_ref: P<TraitRef>,
- pub item_name: Ident, // FIXME(#20301) -- should use Name
+ pub item_path: PathSegment,
}
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Show, Copy)]
pub enum Mac_ {
// NB: the additional ident for a macro_rules-style macro is actually
// stored in the enclosing item. Oog.
- MacInvocTT(Path, Vec<TokenTree> , SyntaxContext), // new macro-invocation
+ MacInvocTT(Path, Vec<TokenTree>, SyntaxContext), // new macro-invocation
}
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Show, Copy)]
pub span: Span,
}
+impl ViewItem {
+ pub fn id(&self) -> NodeId {
+ match self.node {
+ ViewItemExternCrate(_, _, id) => id,
+ ViewItemUse(ref vp) => match vp.node {
+ ViewPathSimple(_, _, id) => id,
+ ViewPathGlob(_, id) => id,
+ ViewPathList(_, _, id) => id,
+ }
+ }
+ }
+}
+
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Show)]
pub enum ViewItem_ {
/// Ident: name used to refer to this crate in the code
#[derive(Copy, Show)]
pub enum Node<'ast> {
NodeItem(&'ast Item),
+ NodeViewItem(&'ast ViewItem),
NodeForeignItem(&'ast ForeignItem),
NodeTraitItem(&'ast TraitItem),
NodeImplItem(&'ast ImplItem),
/// All the node types, with a parent ID.
EntryItem(NodeId, &'ast Item),
+ EntryViewItem(NodeId, &'ast ViewItem),
EntryForeignItem(NodeId, &'ast ForeignItem),
EntryTraitItem(NodeId, &'ast TraitItem),
EntryImplItem(NodeId, &'ast ImplItem),
fn from_node(p: NodeId, node: Node<'ast>) -> MapEntry<'ast> {
match node {
NodeItem(n) => EntryItem(p, n),
+ NodeViewItem(n) => EntryViewItem(p, n),
NodeForeignItem(n) => EntryForeignItem(p, n),
NodeTraitItem(n) => EntryTraitItem(p, n),
NodeImplItem(n) => EntryImplItem(p, n),
fn parent(self) -> Option<NodeId> {
Some(match self {
EntryItem(id, _) => id,
+ EntryViewItem(id, _) => id,
EntryForeignItem(id, _) => id,
EntryTraitItem(id, _) => id,
EntryImplItem(id, _) => id,
fn to_node(self) -> Option<Node<'ast>> {
Some(match self {
EntryItem(_, n) => NodeItem(n),
+ EntryViewItem(_, n) => NodeViewItem(n),
EntryForeignItem(_, n) => NodeForeignItem(n),
EntryTraitItem(_, n) => NodeTraitItem(n),
EntryImplItem(_, n) => NodeImplItem(n),
}
}
+ pub fn expect_view_item(&self, id: NodeId) -> &'ast ViewItem {
+ match self.find(id) {
+ Some(NodeViewItem(view_item)) => view_item,
+ _ => panic!("expected view item, found {}", self.node_to_string(id))
+ }
+ }
+
pub fn expect_struct(&self, id: NodeId) -> &'ast StructDef {
match self.find(id) {
Some(NodeItem(i)) => {
NodesMatchingSuffix {
map: self,
item_name: parts.last().unwrap(),
- in_which: &parts[0..(parts.len() - 1)],
+ in_which: &parts[..(parts.len() - 1)],
idx: 0,
}
}
pub fn opt_span(&self, id: NodeId) -> Option<Span> {
let sp = match self.find(id) {
Some(NodeItem(item)) => item.span,
+ Some(NodeViewItem(item)) => item.span,
Some(NodeForeignItem(foreign_item)) => foreign_item.span,
Some(NodeTraitItem(trait_method)) => {
match *trait_method {
self.parent = parent;
}
+ fn visit_view_item(&mut self, item: &'ast ViewItem) {
+ self.insert(item.id(), NodeViewItem(item));
+ visit::walk_view_item(self, item);
+ }
+
fn visit_pat(&mut self, pat: &'ast Pat) {
self.insert(pat.id, match pat.node {
// Note: this is at least *potentially* a pattern...
fn print_node(&mut self, node: &Node) -> IoResult<()> {
match *node {
NodeItem(a) => self.print_item(&*a),
+ NodeViewItem(a) => self.print_view_item(&*a),
NodeForeignItem(a) => self.print_foreign_item(&*a),
NodeTraitItem(a) => self.print_trait_method(&*a),
NodeImplItem(a) => self.print_impl_item(&*a),
};
format!("{} {}{}", item_str, path_str, id_str)
}
+ Some(NodeViewItem(item)) => {
+ format!("view item {}{}", pprust::view_item_to_string(&*item), id_str)
+ }
Some(NodeForeignItem(item)) => {
let path_str = map.path_to_str_with_ident(id, item.ident);
format!("foreign item {}{}", path_str, id_str)
let begin = begin.to_uint();
let slice = &self.src[begin..];
match slice.find('\n') {
- Some(e) => &slice[0..e],
+ Some(e) => &slice[..e],
None => slice
}.to_string()
})
// to be miscolored. We assume this is rare enough that we don't
// have to worry about it.
if msg.ends_with("\n") {
- try!(t.write_str(&msg[0..(msg.len()-1)]));
+ try!(t.write_str(&msg[..(msg.len()-1)]));
try!(t.reset());
try!(t.write_str("\n"));
} else {
}
}
+#[derive(Show,Clone)]
+pub enum Annotatable {
+ Item(P<ast::Item>),
+ TraitItem(ast::TraitItem),
+ ImplItem(ast::ImplItem),
+}
+
+impl Annotatable {
+ pub fn attrs(&self) -> &[ast::Attribute] {
+ match *self {
+ Annotatable::Item(ref i) => &i.attrs[],
+ Annotatable::TraitItem(ref i) => match *i {
+ ast::TraitItem::RequiredMethod(ref tm) => &tm.attrs[],
+ ast::TraitItem::ProvidedMethod(ref m) => &m.attrs[],
+ ast::TraitItem::TypeTraitItem(ref at) => &at.attrs[],
+ },
+ Annotatable::ImplItem(ref i) => match *i {
+ ast::ImplItem::MethodImplItem(ref m) => &m.attrs[],
+ ast::ImplItem::TypeImplItem(ref t) => &t.attrs[],
+ }
+ }
+ }
+
+ pub fn fold_attrs(self, attrs: Vec<ast::Attribute>) -> Annotatable {
+ match self {
+ Annotatable::Item(i) => Annotatable::Item(P(ast::Item {
+ attrs: attrs,
+ ..(*i).clone()
+ })),
+ Annotatable::TraitItem(i) => match i {
+ ast::TraitItem::RequiredMethod(tm) => Annotatable::TraitItem(
+ ast::TraitItem::RequiredMethod(
+ ast::TypeMethod { attrs: attrs, ..tm })),
+ ast::TraitItem::ProvidedMethod(m) => Annotatable::TraitItem(
+ ast::TraitItem::ProvidedMethod(P(
+ ast::Method { attrs: attrs, ..(*m).clone() }))),
+ ast::TraitItem::TypeTraitItem(at) => Annotatable::TraitItem(
+ ast::TraitItem::TypeTraitItem(P(
+ ast::AssociatedType { attrs: attrs, ..(*at).clone() }))),
+ },
+ Annotatable::ImplItem(i) => match i {
+ ast::ImplItem::MethodImplItem(m) => Annotatable::ImplItem(
+ ast::ImplItem::MethodImplItem(P(
+ ast::Method { attrs: attrs, ..(*m).clone() }))),
+ ast::ImplItem::TypeImplItem(t) => Annotatable::ImplItem(
+ ast::ImplItem::TypeImplItem(P(
+ ast::Typedef { attrs: attrs, ..(*t).clone() }))),
+ }
+ }
+ }
+
+ pub fn expect_item(self) -> P<ast::Item> {
+ match self {
+ Annotatable::Item(i) => i,
+ _ => panic!("expected Item")
+ }
+ }
+
+ pub fn expect_trait_item(self) -> ast::TraitItem {
+ match self {
+ Annotatable::TraitItem(i) => i,
+ _ => panic!("expected Item")
+ }
+ }
+
+ pub fn expect_impl_item(self) -> ast::ImplItem {
+ match self {
+ Annotatable::ImplItem(i) => i,
+ _ => panic!("expected Item")
+ }
+ }
+}
+
+// A more flexible ItemModifier (ItemModifier should go away, eventually, FIXME).
+// meta_item is the annotation, item is the item being modified, parent_item
+// is the impl or trait item is declared in if item is part of such a thing.
+// FIXME Decorators should follow the same pattern too.
+pub trait MultiItemModifier {
+ fn expand(&self,
+ ecx: &mut ExtCtxt,
+ span: Span,
+ meta_item: &ast::MetaItem,
+ item: Annotatable)
+ -> Annotatable;
+}
+
+impl<F> MultiItemModifier for F
+ where F: Fn(&mut ExtCtxt,
+ Span,
+ &ast::MetaItem,
+ Annotatable) -> Annotatable
+{
+ fn expand(&self,
+ ecx: &mut ExtCtxt,
+ span: Span,
+ meta_item: &ast::MetaItem,
+ item: Annotatable)
+ -> Annotatable {
+ (*self)(ecx, span, meta_item, item)
+ }
+}
+
/// Represents a thing that maps token trees to Macro Results
pub trait TTMacroExpander {
fn expand<'cx>(&self,
/// in-place.
Modifier(Box<ItemModifier + 'static>),
+ /// A syntax extension that is attached to an item and modifies it
+ /// in-place. More flexible version than Modifier.
+ MultiModifier(Box<MultiItemModifier + 'static>),
+
/// A normal, function-like syntax extension.
///
/// `bytes!` is a `NormalTT`.
//! (e.g. `Option<T>`), the parameters are automatically given the
//! current trait as a bound. (This includes separate type parameters
//! and lifetimes for methods.)
-//! - Additional bounds on the type parameters, e.g. the `Ord` instance
-//! requires an explicit `PartialEq` bound at the
-//! moment. (`TraitDef.additional_bounds`)
-//!
-//! Unsupported: FIXME #6257: calling methods on reference fields,
-//! e.g. derive Eq/Ord/Clone don't work on `struct A(&int)`,
-//! because of how the auto-dereferencing happens.
+//! - Additional bounds on the type parameters (`TraitDef.additional_bounds`)
//!
//! The most important thing for implementers is the `Substructure` and
//! `SubstructureFields` objects. The latter groups 5 possibilities of the
//! enums (one for each variant). For empty struct and empty enum
//! variants, it is represented as a count of 0.
//!
+//! # "`cs`" functions
+//!
+//! The `cs_...` functions ("combine substructure) are designed to
+//! make life easier by providing some pre-made recipes for common
+//! tasks; mostly calling the function being derived on all the
+//! arguments and then combining them back together in some way (or
+//! letting the user chose that). They are not meant to be the only
+//! way to handle the structures that this code creates.
+//!
//! # Examples
//!
//! The following simplified `PartialEq` is used for in-code examples:
//! When generating the `expr` for the `A` impl, the `SubstructureFields` is
//!
//! ```{.text}
-//! Struct(~[FieldInfo {
+//! Struct(vec![FieldInfo {
//! span: <span of x>
//! name: Some(<ident of x>),
//! self_: <expr for &self.x>,
-//! other: ~[<expr for &other.x]
+//! other: vec![<expr for &other.x]
//! }])
//! ```
//!
//! For the `B` impl, called with `B(a)` and `B(b)`,
//!
//! ```{.text}
-//! Struct(~[FieldInfo {
+//! Struct(vec![FieldInfo {
//! span: <span of `int`>,
//! name: None,
-//! <expr for &a>
-//! ~[<expr for &b>]
+//! self_: <expr for &a>
+//! other: vec![<expr for &b>]
//! }])
//! ```
//!
//!
//! ```{.text}
//! EnumMatching(0, <ast::Variant for C0>,
-//! ~[FieldInfo {
+//! vec![FieldInfo {
//! span: <span of int>
//! name: None,
//! self_: <expr for &a>,
-//! other: ~[<expr for &b>]
+//! other: vec![<expr for &b>]
//! }])
//! ```
//!
//!
//! ```{.text}
//! EnumMatching(1, <ast::Variant for C1>,
-//! ~[FieldInfo {
+//! vec![FieldInfo {
//! span: <span of x>
//! name: Some(<ident of x>),
//! self_: <expr for &self.x>,
-//! other: ~[<expr for &other.x>]
+//! other: vec![<expr for &other.x>]
//! }])
//! ```
//!
//!
//! ```{.text}
//! EnumNonMatchingCollapsed(
-//! ~[<ident of self>, <ident of __arg_1>],
+//! vec![<ident of self>, <ident of __arg_1>],
//! &[<ast::Variant for C0>, <ast::Variant for C1>],
//! &[<ident for self index value>, <ident of __arg_1 index value>])
//! ```
//!
//! ## Static
//!
-//! A static method on the above would result in,
+//! A static method on the types above would result in,
//!
//! ```{.text}
-//! StaticStruct(<ast::StructDef of A>, Named(~[(<ident of x>, <span of x>)]))
+//! StaticStruct(<ast::StructDef of A>, Named(vec![(<ident of x>, <span of x>)]))
//!
-//! StaticStruct(<ast::StructDef of B>, Unnamed(~[<span of x>]))
+//! StaticStruct(<ast::StructDef of B>, Unnamed(vec![<span of x>]))
//!
-//! StaticEnum(<ast::EnumDef of C>, ~[(<ident of C0>, <span of C0>, Unnamed(~[<span of int>])),
-//! (<ident of C1>, <span of C1>,
-//! Named(~[(<ident of x>, <span of x>)]))])
+//! StaticEnum(<ast::EnumDef of C>,
+//! vec![(<ident of C0>, <span of C0>, Unnamed(vec![<span of int>])),
+//! (<ident of C1>, <span of C1>, Named(vec![(<ident of x>, <span of x>)]))])
//! ```
pub use self::StaticFields::*;
/// process the collected results. i.e.
///
/// ```
-/// f(cx, span, ~[self_1.method(__arg_1_1, __arg_2_1),
-/// self_2.method(__arg_1_2, __arg_2_2)])
+/// f(cx, span, vec![self_1.method(__arg_1_1, __arg_2_1),
+/// self_2.method(__arg_1_2, __arg_2_2)])
/// ```
#[inline]
pub fn cs_same_method<F>(f: F,
-> SmallVector<P<ast::Item>> {
let it = expand_item_modifiers(it, fld);
- let mut decorator_items = SmallVector::zero();
- let mut new_attrs = Vec::new();
- for attr in it.attrs.iter() {
- let mname = attr.name();
-
- match fld.cx.syntax_env.find(&intern(mname.get())) {
- Some(rc) => match *rc {
- Decorator(ref dec) => {
- attr::mark_used(attr);
-
- fld.cx.bt_push(ExpnInfo {
- call_site: attr.span,
- callee: NameAndSpan {
- name: mname.get().to_string(),
- format: MacroAttribute,
- span: None
- }
- });
-
- // we'd ideally decorator_items.push_all(expand_item(item, fld)),
- // but that double-mut-borrows fld
- let mut items: SmallVector<P<ast::Item>> = SmallVector::zero();
- dec.expand(fld.cx, attr.span, &*attr.node.value, &*it,
- box |&mut : item| items.push(item));
- decorator_items.extend(items.into_iter()
- .flat_map(|item| expand_item(item, fld).into_iter()));
-
- fld.cx.bt_pop();
- }
- _ => new_attrs.push((*attr).clone()),
- },
- _ => new_attrs.push((*attr).clone()),
- }
- }
-
- let mut new_items = match it.node {
- ast::ItemMac(..) => expand_item_mac(it, fld),
- ast::ItemMod(_) | ast::ItemForeignMod(_) => {
- let valid_ident =
- it.ident.name != parse::token::special_idents::invalid.name;
-
- if valid_ident {
- fld.cx.mod_push(it.ident);
- }
- let macro_use = contains_macro_use(fld, &new_attrs[]);
- let result = with_exts_frame!(fld.cx.syntax_env,
- macro_use,
- noop_fold_item(it, fld));
- if valid_ident {
- fld.cx.mod_pop();
- }
- result
- },
- _ => {
- let it = P(ast::Item {
- attrs: new_attrs,
- ..(*it).clone()
- });
- noop_fold_item(it, fld)
- }
- };
-
- new_items.push_all(decorator_items);
- new_items
+ expand_annotatable(Annotatable::Item(it), fld)
+ .into_iter().map(|i| i.expect_item()).collect()
}
fn expand_item_modifiers(mut it: P<ast::Item>, fld: &mut MacroExpander)
-> P<ast::Item> {
// partition the attributes into ItemModifiers and others
- let (modifiers, other_attrs): (Vec<_>, _) = it.attrs.iter().cloned().partition(|attr| {
- match fld.cx.syntax_env.find(&intern(attr.name().get())) {
- Some(rc) => match *rc { Modifier(_) => true, _ => false },
- _ => false
- }
- });
+ let (modifiers, other_attrs) = modifiers(&it.attrs, fld);
+
// update the attrs, leave everything else alone. Is this mutation really a good idea?
it = P(ast::Item {
attrs: other_attrs,
});
if modifiers.is_empty() {
- return it;
+ let it = expand_item_multi_modifier(Annotatable::Item(it), fld);
+ return it.expect_item();
}
for attr in modifiers.iter() {
}
}
- // expansion may have added new ItemModifiers
+ // Expansion may have added new ItemModifiers.
+ // It is possible, that an item modifier could expand to a multi-modifier or
+ // vice versa. In this case we will expand all modifiers before multi-modifiers,
+ // which might give an odd ordering. However, I think it is unlikely that the
+ // two kinds will be mixed, and I old-style multi-modifiers should be deprecated
+ // anyway.
expand_item_modifiers(it, fld)
}
}
}
+fn expand_annotatable(a: Annotatable,
+ fld: &mut MacroExpander)
+ -> SmallVector<Annotatable> {
+ let a = expand_item_multi_modifier(a, fld);
+
+ let mut decorator_items = SmallVector::zero();
+ let mut new_attrs = Vec::new();
+ for attr in a.attrs().iter() {
+ let mname = attr.name();
+
+ match fld.cx.syntax_env.find(&intern(mname.get())) {
+ Some(rc) => match *rc {
+ Decorator(ref dec) => {
+ let it = match a {
+ Annotatable::Item(ref it) => it,
+ // ItemDecorators are only implemented for Items.
+ _ => break,
+ };
+
+ attr::mark_used(attr);
+
+ fld.cx.bt_push(ExpnInfo {
+ call_site: attr.span,
+ callee: NameAndSpan {
+ name: mname.get().to_string(),
+ format: MacroAttribute,
+ span: None
+ }
+ });
+
+ // we'd ideally decorator_items.push_all(expand_item(item, fld)),
+ // but that double-mut-borrows fld
+ let mut items: SmallVector<P<ast::Item>> = SmallVector::zero();
+ dec.expand(fld.cx, attr.span, &*attr.node.value, &**it,
+ box |&mut: item| items.push(item));
+ decorator_items.extend(items.into_iter()
+ .flat_map(|item| expand_item(item, fld).into_iter()));
+
+ fld.cx.bt_pop();
+ }
+ _ => new_attrs.push((*attr).clone()),
+ },
+ _ => new_attrs.push((*attr).clone()),
+ }
+ }
+
+ let mut new_items: SmallVector<Annotatable> = match a {
+ Annotatable::Item(it) => match it.node {
+ ast::ItemMac(..) => {
+ expand_item_mac(it, fld).into_iter().map(|i| Annotatable::Item(i)).collect()
+ }
+ ast::ItemMod(_) | ast::ItemForeignMod(_) => {
+ let valid_ident =
+ it.ident.name != parse::token::special_idents::invalid.name;
+
+ if valid_ident {
+ fld.cx.mod_push(it.ident);
+ }
+ let macro_use = contains_macro_use(fld, &new_attrs[]);
+ let result = with_exts_frame!(fld.cx.syntax_env,
+ macro_use,
+ noop_fold_item(it, fld));
+ if valid_ident {
+ fld.cx.mod_pop();
+ }
+ result.into_iter().map(|i| Annotatable::Item(i)).collect()
+ },
+ _ => {
+ let it = P(ast::Item {
+ attrs: new_attrs,
+ ..(*it).clone()
+ });
+ noop_fold_item(it, fld).into_iter().map(|i| Annotatable::Item(i)).collect()
+ }
+ },
+ Annotatable::TraitItem(it) => match it {
+ ast::TraitItem::ProvidedMethod(m) => {
+ expand_method(m, fld).into_iter().map(|m|
+ Annotatable::TraitItem(ast::TraitItem::ProvidedMethod(m))).collect()
+ }
+ ast::TraitItem::RequiredMethod(m) => {
+ SmallVector::one(Annotatable::TraitItem(
+ ast::TraitItem::RequiredMethod(fld.fold_type_method(m))))
+ }
+ ast::TraitItem::TypeTraitItem(t) => {
+ SmallVector::one(Annotatable::TraitItem(
+ ast::TraitItem::TypeTraitItem(P(fld.fold_associated_type((*t).clone())))))
+ }
+ },
+ Annotatable::ImplItem(it) => match it {
+ ast::ImplItem::MethodImplItem(m) => {
+ expand_method(m, fld).into_iter().map(|m|
+ Annotatable::ImplItem(ast::ImplItem::MethodImplItem(m))).collect()
+ }
+ ast::ImplItem::TypeImplItem(t) => {
+ SmallVector::one(Annotatable::ImplItem(
+ ast::ImplItem::TypeImplItem(P(fld.fold_typedef((*t).clone())))))
+ }
+ }
+ };
+
+ new_items.push_all(decorator_items.into_iter().map(|i| Annotatable::Item(i)).collect());
+ new_items
+}
+
+fn expand_trait_item(i: ast::TraitItem,
+ fld: &mut MacroExpander)
+ -> SmallVector<ast::TraitItem> {
+ expand_annotatable(Annotatable::TraitItem(i), fld)
+ .into_iter().map(|i| i.expect_trait_item()).collect()
+
+}
+
+fn expand_impl_item(i: ast::ImplItem,
+ fld: &mut MacroExpander)
+ -> SmallVector<ast::ImplItem> {
+ expand_annotatable(Annotatable::ImplItem(i), fld)
+ .into_iter().map(|i| i.expect_impl_item()).collect()
+}
+
+// partition the attributes into ItemModifiers and others
+fn modifiers(attrs: &Vec<ast::Attribute>,
+ fld: &MacroExpander)
+ -> (Vec<ast::Attribute>, Vec<ast::Attribute>) {
+ attrs.iter().cloned().partition(|attr| {
+ match fld.cx.syntax_env.find(&intern(attr.name().get())) {
+ Some(rc) => match *rc {
+ Modifier(_) => true,
+ _ => false
+ },
+ _ => false
+ }
+ })
+}
+
+// partition the attributes into MultiModifiers and others
+fn multi_modifiers(attrs: &[ast::Attribute],
+ fld: &MacroExpander)
+ -> (Vec<ast::Attribute>, Vec<ast::Attribute>) {
+ attrs.iter().cloned().partition(|attr| {
+ match fld.cx.syntax_env.find(&intern(attr.name().get())) {
+ Some(rc) => match *rc {
+ MultiModifier(_) => true,
+ _ => false
+ },
+ _ => false
+ }
+ })
+}
+
+fn expand_item_multi_modifier(mut it: Annotatable,
+ fld: &mut MacroExpander)
+ -> Annotatable {
+ let (modifiers, other_attrs) = multi_modifiers(it.attrs(), fld);
+
+ // Update the attrs, leave everything else alone. Is this mutation really a good idea?
+ it = it.fold_attrs(other_attrs);
+
+ if modifiers.is_empty() {
+ return it
+ }
+
+ for attr in modifiers.iter() {
+ let mname = attr.name();
+
+ match fld.cx.syntax_env.find(&intern(mname.get())) {
+ Some(rc) => match *rc {
+ MultiModifier(ref mac) => {
+ attr::mark_used(attr);
+ fld.cx.bt_push(ExpnInfo {
+ call_site: attr.span,
+ callee: NameAndSpan {
+ name: mname.get().to_string(),
+ format: MacroAttribute,
+ span: None,
+ }
+ });
+ it = mac.expand(fld.cx, attr.span, &*attr.node.value, it);
+ fld.cx.bt_pop();
+ }
+ _ => unreachable!()
+ },
+ _ => unreachable!()
+ }
+ }
+
+ // Expansion may have added new ItemModifiers.
+ expand_item_multi_modifier(it, fld)
+}
+
// expand a method
fn expand_method(m: P<ast::Method>, fld: &mut MacroExpander) -> SmallVector<P<ast::Method>> {
m.and_then(|m| match m.node {
vis) => {
let id = fld.new_id(m.id);
let (rewritten_fn_decl, rewritten_body)
- = expand_and_rename_fn_decl_and_block(decl,body,fld);
+ = expand_and_rename_fn_decl_and_block(decl, body, fld);
SmallVector::one(P(ast::Method {
attrs: m.attrs.move_map(|a| fld.fold_attribute(a)),
id: id,
expand_arm(arm, self)
}
+ fn fold_trait_item(&mut self, i: ast::TraitItem) -> SmallVector<ast::TraitItem> {
+ expand_trait_item(i, self)
+ }
+
+ fn fold_impl_item(&mut self, i: ast::ImplItem) -> SmallVector<ast::ImplItem> {
+ expand_impl_item(i, self)
+ }
+
fn fold_method(&mut self, method: P<ast::Method>) -> SmallVector<P<ast::Method>> {
expand_method(method, self)
}
("visible_private_types", Active),
("slicing_syntax", Active),
("box_syntax", Active),
+ ("on_unimplemented", Active),
("if_let", Accepted),
("while_let", Accepted),
self.gate_feature("linkage", i.span,
"the `linkage` attribute is experimental \
and not portable across platforms")
+ } else if attr.name() == "rustc_on_unimplemented" {
+ self.gate_feature("on_unimplemented", i.span,
+ "the `#[rustc_on_unimplemented]` attribute \
+ is an experimental feature")
}
}
match i.node {
noop_fold_item_underscore(i, self)
}
+ fn fold_trait_item(&mut self, i: TraitItem) -> SmallVector<TraitItem> {
+ noop_fold_trait_item(i, self)
+ }
+
+ fn fold_impl_item(&mut self, i: ImplItem) -> SmallVector<ImplItem> {
+ noop_fold_impl_item(i, self)
+ }
+
fn fold_fn_decl(&mut self, d: P<FnDecl>) -> P<FnDecl> {
noop_fold_fn_decl(d, self)
}
QPath {
self_type: fld.fold_ty(qpath.self_type),
trait_ref: qpath.trait_ref.map(|tr| fld.fold_trait_ref(tr)),
- item_name: fld.fold_ident(qpath.item_name),
+ item_path: PathSegment {
+ identifier: fld.fold_ident(qpath.item_path.identifier),
+ parameters: fld.fold_path_parameters(qpath.item_path.parameters),
+ }
}
})
}
ItemStruct(struct_def, folder.fold_generics(generics))
}
ItemImpl(unsafety, polarity, generics, ifce, ty, impl_items) => {
- let mut new_impl_items = Vec::new();
- for impl_item in impl_items.iter() {
- match *impl_item {
- MethodImplItem(ref x) => {
- for method in folder.fold_method((*x).clone())
- .into_iter() {
- new_impl_items.push(MethodImplItem(method))
- }
- }
- TypeImplItem(ref t) => {
- new_impl_items.push(TypeImplItem(
- P(folder.fold_typedef((**t).clone()))));
- }
- }
- }
+ let new_impl_items = impl_items.into_iter().flat_map(|item| {
+ folder.fold_impl_item(item).into_iter()
+ }).collect();
let ifce = match ifce {
None => None,
Some(ref trait_ref) => {
folder.fold_ty(ty),
new_impl_items)
}
- ItemTrait(unsafety, generics, bounds, methods) => {
+ ItemTrait(unsafety, generics, bounds, items) => {
let bounds = folder.fold_bounds(bounds);
- let methods = methods.into_iter().flat_map(|method| {
- let r = match method {
- RequiredMethod(m) => {
- SmallVector::one(RequiredMethod(
- folder.fold_type_method(m)))
- .into_iter()
- }
- ProvidedMethod(method) => {
- // the awkward collect/iter idiom here is because
- // even though an iter and a map satisfy the same
- // trait bound, they're not actually the same type, so
- // the method arms don't unify.
- let methods: SmallVector<ast::TraitItem> =
- folder.fold_method(method).into_iter()
- .map(|m| ProvidedMethod(m)).collect();
- methods.into_iter()
- }
- TypeTraitItem(at) => {
- SmallVector::one(TypeTraitItem(P(
- folder.fold_associated_type(
- (*at).clone()))))
- .into_iter()
- }
- };
- r
+ let items = items.into_iter().flat_map(|item| {
+ folder.fold_trait_item(item).into_iter()
}).collect();
ItemTrait(unsafety,
folder.fold_generics(generics),
bounds,
- methods)
+ items)
}
ItemMac(m) => ItemMac(folder.fold_mac(m)),
}
}
+pub fn noop_fold_trait_item<T: Folder>(i: TraitItem, folder: &mut T) -> SmallVector<TraitItem> {
+ match i {
+ RequiredMethod(m) => {
+ SmallVector::one(RequiredMethod(
+ folder.fold_type_method(m)))
+ }
+ ProvidedMethod(method) => {
+ folder.fold_method(method).into_iter()
+ .map(|m| ProvidedMethod(m)).collect()
+ }
+ TypeTraitItem(at) => {
+ SmallVector::one(TypeTraitItem(P(
+ folder.fold_associated_type(
+ (*at).clone()))))
+ }
+ }
+}
+
+pub fn noop_fold_impl_item<T: Folder>(i: ImplItem, folder: &mut T) -> SmallVector<ImplItem> {
+ match i {
+ MethodImplItem(ref x) => {
+ folder.fold_method((*x).clone()).into_iter().map(|m| MethodImplItem(m)).collect()
+ }
+ TypeImplItem(ref t) => {
+ SmallVector::one(TypeImplItem(
+ P(folder.fold_typedef((**t).clone()))))
+ }
+ }
+}
+
pub fn noop_fold_type_method<T: Folder>(m: TypeMethod, fld: &mut T) -> TypeMethod {
let TypeMethod {
id,
e2.map(|x| folder.fold_expr(x)))
}
ExprPath(pth) => ExprPath(folder.fold_path(pth)),
+ ExprQPath(qpath) => ExprQPath(folder.fold_qpath(qpath)),
ExprBreak(opt_ident) => ExprBreak(opt_ident.map(|x| folder.fold_ident(x))),
ExprAgain(opt_ident) => ExprAgain(opt_ident.map(|x| folder.fold_ident(x))),
ExprRet(e) => ExprRet(e.map(|x| folder.fold_expr(x))),
use ast::{ExprBreak, ExprCall, ExprCast};
use ast::{ExprField, ExprTupField, ExprClosure, ExprIf, ExprIfLet, ExprIndex};
use ast::{ExprLit, ExprLoop, ExprMac, ExprRange};
-use ast::{ExprMethodCall, ExprParen, ExprPath};
+use ast::{ExprMethodCall, ExprParen, ExprPath, ExprQPath};
use ast::{ExprRepeat, ExprRet, ExprStruct, ExprTup, ExprUnary};
use ast::{ExprVec, ExprWhile, ExprWhileLet, ExprForLoop, Field, FnDecl};
use ast::{FnUnboxedClosureKind, FnMutUnboxedClosureKind};
TyQPath(P(QPath {
self_type: self_type,
trait_ref: P(trait_ref),
- item_name: item_name,
+ item_path: ast::PathSegment {
+ identifier: item_name,
+ parameters: ast::PathParameters::none()
+ }
}))
} else if self.check(&token::ModSep) ||
self.token.is_ident() ||
if !self.eat(&token::ModSep) {
segments.push(ast::PathSegment {
identifier: identifier,
- parameters: ast::AngleBracketedParameters(ast::AngleBracketedParameterData {
- lifetimes: Vec::new(),
- types: OwnedSlice::empty(),
- bindings: OwnedSlice::empty(),
- })
+ parameters: ast::PathParameters::none()
});
return segments;
}
hi = self.last_span.hi;
}
_ => {
+ if self.eat_lt() {
+ // QUALIFIED PATH `<TYPE as TRAIT_REF>::item::<'a, T>`
+ let self_type = self.parse_ty_sum();
+ self.expect_keyword(keywords::As);
+ let trait_ref = self.parse_trait_ref();
+ self.expect(&token::Gt);
+ self.expect(&token::ModSep);
+ let item_name = self.parse_ident();
+ let parameters = if self.eat(&token::ModSep) {
+ self.expect_lt();
+ // Consumed `item::<`, go look for types
+ let (lifetimes, types, bindings) =
+ self.parse_generic_values_after_lt();
+ ast::AngleBracketedParameters(ast::AngleBracketedParameterData {
+ lifetimes: lifetimes,
+ types: OwnedSlice::from_vec(types),
+ bindings: OwnedSlice::from_vec(bindings),
+ })
+ } else {
+ ast::PathParameters::none()
+ };
+ let hi = self.span.hi;
+ return self.mk_expr(lo, hi, ExprQPath(P(QPath {
+ self_type: self_type,
+ trait_ref: P(trait_ref),
+ item_path: ast::PathSegment {
+ identifier: item_name,
+ parameters: parameters
+ }
+ })));
+ }
if self.eat_keyword(keywords::Move) {
return self.parse_lambda_expr(CaptureByValue);
}
try!(self.print_bounds("", &bounds[]));
}
ast::TyQPath(ref qpath) => {
- try!(word(&mut self.s, "<"));
- try!(self.print_type(&*qpath.self_type));
- try!(space(&mut self.s));
- try!(self.word_space("as"));
- try!(self.print_trait_ref(&*qpath.trait_ref));
- try!(word(&mut self.s, ">"));
- try!(word(&mut self.s, "::"));
- try!(self.print_ident(qpath.item_name));
+ try!(self.print_qpath(&**qpath, false))
}
ast::TyFixedLengthVec(ref ty, ref v) => {
try!(word(&mut self.s, "["));
}
}
ast::ExprPath(ref path) => try!(self.print_path(path, true)),
+ ast::ExprQPath(ref qpath) => try!(self.print_qpath(&**qpath, true)),
ast::ExprBreak(opt_ident) => {
try!(word(&mut self.s, "break"));
try!(space(&mut self.s));
Ok(())
}
+ fn print_qpath(&mut self,
+ qpath: &ast::QPath,
+ colons_before_params: bool)
+ -> IoResult<()>
+ {
+ try!(word(&mut self.s, "<"));
+ try!(self.print_type(&*qpath.self_type));
+ try!(space(&mut self.s));
+ try!(self.word_space("as"));
+ try!(self.print_trait_ref(&*qpath.trait_ref));
+ try!(word(&mut self.s, ">"));
+ try!(word(&mut self.s, "::"));
+ try!(self.print_ident(qpath.item_path.identifier));
+ self.print_path_parameters(&qpath.item_path.parameters, colons_before_params)
+ }
+
fn print_path_parameters(&mut self,
parameters: &ast::PathParameters,
colons_before_params: bool)
fn visit_path(&mut self, path: &'v Path, _id: ast::NodeId) {
walk_path(self, path)
}
+ fn visit_qpath(&mut self, qpath_span: Span, qpath: &'v QPath) {
+ walk_qpath(self, qpath_span, qpath)
+ }
fn visit_path_segment(&mut self, path_span: Span, path_segment: &'v PathSegment) {
walk_path_segment(self, path_span, path_segment)
}
walk_ty_param_bounds_helper(visitor, bounds);
}
TyQPath(ref qpath) => {
- visitor.visit_ty(&*qpath.self_type);
- visitor.visit_trait_ref(&*qpath.trait_ref);
- visitor.visit_ident(typ.span, qpath.item_name);
+ visitor.visit_qpath(typ.span, &**qpath);
}
TyFixedLengthVec(ref ty, ref expression) => {
visitor.visit_ty(&**ty);
}
}
+pub fn walk_qpath<'v, V: Visitor<'v>>(visitor: &mut V,
+ qpath_span: Span,
+ qpath: &'v QPath) {
+ visitor.visit_ty(&*qpath.self_type);
+ visitor.visit_trait_ref(&*qpath.trait_ref);
+ visitor.visit_path_segment(qpath_span, &qpath.item_path);
+}
+
pub fn walk_path_segment<'v, V: Visitor<'v>>(visitor: &mut V,
path_span: Span,
segment: &'v PathSegment) {
ExprPath(ref path) => {
visitor.visit_path(path, expression.id)
}
+ ExprQPath(ref qpath) => {
+ visitor.visit_qpath(expression.span, &**qpath)
+ }
ExprBreak(_) | ExprAgain(_) => {}
ExprRet(ref optional_expression) => {
walk_expr_opt(visitor, optional_expression)
/// elimination.
///
/// This function is a no-op, and does not even read from `dummy`.
-pub fn black_box<T>(dummy: T) {
+pub fn black_box<T>(dummy: T) -> T {
// we need to "use" the argument in some way LLVM can't
// introspect.
unsafe {asm!("" : : "r"(&dummy))}
+ dummy
}
#if defined(__APPLE__)
#define MORESTACK ___morestack
-#define STACK_EXHAUSTED _rust_stack_exhausted
+#define STACK_EXHAUSTED _rust_stack_exhausted@plt
#else
#define MORESTACK __morestack
#define STACK_EXHAUSTED rust_stack_exhausted
// FIXME(AARCH64): this might not be perfectly right but works for now
MORESTACK:
.cfi_startproc
- bl STACK_EXHAUSTED@plt
+ bl STACK_EXHAUSTED
// the above function ensures that it never returns
.cfi_endproc
--- /dev/null
+// Mark stack as non-executable
+#if defined(__linux__) && defined(__ELF__)
+.section .note.GNU-stack, "", %progbits
+#endif
+
+/* See i386/morestack.S for the lengthy, general explanation. */
+
+.global rust_stack_exhausted
+
+.hidden __morestack
+
+// FIXME(POWERPC): this might not be perfectly right but works for now
+__morestack:
+ .cfi_startproc
+ bl rust_stack_exhausted
+ // the above function ensures that it never returns
+ .cfi_endproc
+.end __morestack
--- /dev/null
+// Mark stack as non-executable
+#if defined(__linux__) && defined(__ELF__)
+.section .note.GNU-stack, "", %progbits
+#endif
use book;
use book::{Book, BookItem};
use css;
+use javascript;
use regex::Regex;
Ok(())
}
- try!(writeln!(out, "<div id='toc'>"));
+ try!(writeln!(out, "<div id='toc' class='mobile-hidden'>"));
try!(writeln!(out, "<ul class='chapter'>"));
try!(walk_items(&book.chapters[], "", path_to_root, out));
try!(writeln!(out, "</ul>"));
let prelude = tmp.path().join("prelude.html");
{
let mut toc = BufferedWriter::new(try!(File::create(&prelude)));
+ try!(writeln!(&mut toc, r#"<div id="nav">
+ <button id="toggle-nav">
+ <span class="sr-only">Toggle navigation</span>
+ <span class="bar"></span>
+ <span class="bar"></span>
+ <span class="bar"></span>
+ </button>
+ </div>"#));
let _ = write_toc(book, &item.path_to_root, &mut toc);
try!(writeln!(&mut toc, "<div id='page-wrapper'>"));
try!(writeln!(&mut toc, "<div id='page'>"));
let postlude = tmp.path().join("postlude.html");
{
let mut toc = BufferedWriter::new(try!(File::create(&postlude)));
+ try!(toc.write_str(javascript::JAVASCRIPT));
try!(writeln!(&mut toc, "</div></div>"));
}
#page {
margin-left: auto;
margin-right:auto;
- width: 750px;
+ max-width: 750px;
}
.chapter {
.chapter li a {
color: #000000;
}
+
+@media only screen and (max-width: 1060px) {
+ #toc {
+ width: 100%;
+ margin-right: 0;
+ top: 40px;
+ }
+ #page-wrapper {
+ top: 40px;
+ left: 15px;
+ padding-right: 15px;
+ }
+ .mobile-hidden {
+ display: none;
+ }
+}
+
+
+#toggle-nav {
+ height: 20px;
+ width: 30px;
+ padding: 3px 3px 0 3px;
+}
+
+#toggle-nav {
+ margin-top: 5px;
+ width: 30px;
+ height: 30px;
+ background-color: #FFF;
+ border: 1px solid #666;
+ border-radius: 3px 3px 3px 3px;
+}
+
+.sr-only {
+ position: absolute;
+ width: 1px;
+ height: 1px;
+ margin: -1px;
+ padding: 0;
+ overflow: hidden;
+ clip: rect(0, 0, 0, 0);
+ border: 0;
+}
+
+.bar {
+ display: block;
+ background-color: #000;
+ border-radius: 2px;
+ width: 100%;
+ height: 2px;
+ margin: 2px 0 3px;
+ padding: 0;
+}
+
"#;
--- /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.
+
+// The rust-book JavaScript in string form.
+
+pub static JAVASCRIPT: &'static str = r#"
+<script type="text/javascript">
+document.addEventListener("DOMContentLoaded", function(event) {
+ document.getElementById("toggle-nav").onclick = toggleNav;
+ function toggleNav() {
+ var toc = document.getElementById("toc");
+ var pagewrapper = document.getElementById("page-wrapper");
+ toggleClass(toc, "mobile-hidden");
+ toggleClass(pagewrapper, "mobile-hidden");
+ };
+
+ function toggleClass(el, className) {
+ // from http://youmightnotneedjquery.com/
+ if (el.classList) {
+ el.classList.toggle(className);
+ } else {
+ var classes = el.className.split(' ');
+ var existingIndex = classes.indexOf(className);
+
+ if (existingIndex >= 0) {
+ classes.splice(existingIndex, 1);
+ } else {
+ classes.push(className);
+ }
+
+ el.className = classes.join(' ');
+ }
+ }
+});
+</script>
+"#;
mod test;
mod css;
+mod javascript;
#[cfg(not(test))] // thanks #12327
fn main() {
# If this file is modified, then llvm will be forcibly cleaned and then rebuilt.
# The actual contents of this file do not matter, but to trigger a change on the
# build bots then the contents should be changed so git updates the mtime.
-2015-01-05
+2015-01-13
use std::sync::atomic;
pub const C1: uint = 1;
-pub const C2: atomic::AtomicUint = atomic::ATOMIC_UINT_INIT;
+pub const C2: atomic::AtomicUsize = atomic::ATOMIC_USIZE_INIT;
pub const C3: fn() = foo;
pub const C4: uint = C1 * C1 + C1 / C1;
pub const C5: &'static uint = &C4;
pub static S1: uint = 3;
-pub static S2: atomic::AtomicUint = atomic::ATOMIC_UINT_INIT;
+pub static S2: atomic::AtomicUsize = atomic::ATOMIC_USIZE_INIT;
fn foo() {}
-// Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2013-2015 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
extern crate syntax;
extern crate rustc;
-use syntax::ast::{TokenTree, Item, MetaItem};
+use syntax::ast::{TokenTree, Item, MetaItem, ImplItem, TraitItem, Method};
use syntax::codemap::Span;
use syntax::ext::base::*;
use syntax::parse::token;
reg.register_syntax_extension(
token::intern("into_foo"),
Modifier(box expand_into_foo));
+ reg.register_syntax_extension(
+ token::intern("into_multi_foo"),
+ MultiModifier(box expand_into_foo_multi));
}
fn expand_make_a_1(cx: &mut ExtCtxt, sp: Span, tts: &[TokenTree])
})
}
+fn expand_into_foo_multi(cx: &mut ExtCtxt,
+ sp: Span,
+ attr: &MetaItem,
+ it: Annotatable) -> Annotatable {
+ match it {
+ Annotatable::Item(it) => {
+ Annotatable::Item(P(Item {
+ attrs: it.attrs.clone(),
+ ..(*quote_item!(cx, enum Foo2 { Bar2, Baz2 }).unwrap()).clone()
+ }))
+ }
+ Annotatable::ImplItem(it) => {
+ Annotatable::ImplItem(ImplItem::MethodImplItem(
+ quote_method!(cx, fn foo(&self) -> i32 { 42 })
+ ))
+ }
+ Annotatable::TraitItem(it) => {
+ Annotatable::TraitItem(TraitItem::ProvidedMethod(
+ quote_method!(cx, fn foo(&self) -> i32 { 0 })
+ ))
+ }
+ }
+}
+
fn expand_forged_ident(cx: &mut ExtCtxt, sp: Span, tts: &[TokenTree]) -> Box<MacResult+'static> {
use syntax::ext::quote::rt::*;
copy_memory(buf.as_mut_slice(), alu);
let buf_len = buf.len();
copy_memory(buf.slice_mut(alu_len, buf_len),
- &alu[0..LINE_LEN]);
+ &alu[..LINE_LEN]);
let mut pos = 0;
let mut bytes;
for i in range(0u, chars_left) {
buf[i] = self.nextc();
}
- self.out.write(&buf[0..chars_left])
+ self.out.write(&buf[..chars_left])
}
}
use std::sync::mpsc::{channel, Sender, Receiver};
use std::thread::Thread;
-fn start(n_tasks: int, token: int) {
+fn start(n_tasks: i32, token: i32) {
let (tx, mut rx) = channel();
tx.send(token).unwrap();
- for i in range(2, n_tasks + 1) {
+ let mut guards = Vec::with_capacity(n_tasks as usize);
+ for i in 2 .. n_tasks + 1 {
let (tx, next_rx) = channel();
- Thread::spawn(move|| roundtrip(i, tx, rx));
- rx = next_rx;
+ let cur_rx = std::mem::replace(&mut rx, next_rx);
+ guards.push(Thread::scoped(move|| roundtrip(i, tx, cur_rx)));
}
- Thread::spawn(move|| roundtrip(1, tx, rx));
+ let guard = Thread::scoped(move|| roundtrip(1, tx, rx));
}
-fn roundtrip(id: int, tx: Sender<int>, rx: Receiver<int>) {
+fn roundtrip(id: i32, tx: Sender<i32>, rx: Receiver<i32>) {
for token in rx.iter() {
if token == 1 {
println!("{}", id);
fn main() {
let args = std::os::args();
- let args = args.as_slice();
let token = if std::os::getenv("RUST_BENCH").is_some() {
2000000
} else {
// except according to those terms.
fn main() {
- let _x: isize = [1is, 2, 3]; //~ ERROR expected isize, found array of 3 elements
+ let _x: isize = [1is, 2, 3];
+ //~^ ERROR mismatched types
+ //~| expected `isize`
+ //~| found `[isize; 3]`
+ //~| expected isize
+ //~| found array of 3 elements
let x: &[isize] = &[1, 2, 3];
- let _y: &isize = x; //~ ERROR expected isize, found slice
+ let _y: &isize = x;
+ //~^ ERROR mismatched types
+ //~| expected `&isize`
+ //~| found `&[isize]`
+ //~| expected isize
+ //~| found slice
}
}
fn foo2<I: Foo>(x: I) {
- let _: Bar = x.boo(); //~ERROR mismatched types
+ let _: Bar = x.boo();
+ //~^ ERROR mismatched types
+ //~| expected `Bar`
+ //~| found `<I as Foo>::A`
+ //~| expected struct `Bar`
+ //~| found associated type
}
pub fn main() {
let a = 42is;
- foo1(a); //~ERROR expected usize, found struct Bar
- baz(&a); //~ERROR expected usize, found struct Bar
+ foo1(a);
+ //~^ ERROR type mismatch resolving
+ //~| expected usize
+ //~| found struct `Bar`
+ baz(&a);
+ //~^ ERROR type mismatch resolving
+ //~| expected usize
+ //~| found struct `Bar`
}
pub fn f1_int_int() {
f1(2is, 4is);
- //~^ ERROR expected usize, found isize
+ //~^ ERROR type mismatch resolving
+ //~| expected usize
+ //~| found isize
}
pub fn f1_int_uint() {
pub fn f2_int() {
let _: isize = f2(2is);
- //~^ ERROR expected `isize`, found `usize`
+ //~^ ERROR mismatched types
+ //~| expected `isize`
+ //~| found `usize`
+ //~| expected isize
+ //~| found usize
}
pub fn main() { }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// error-pattern:expected `collections::string::String`, found `isize`
-
static i: String = 10is;
+//~^ ERROR mismatched types
+//~| expected `collections::string::String`
+//~| found `isize`
+//~| expected struct `collections::string::String`
+//~| found isize
fn main() { println!("{}", i); }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// error-pattern:mismatched types: expected `()`, found `bool`
-
fn main() {
loop {
- true
+ true //~ ERROR mismatched types
+ //~| expected ()
+ //~| found bool
+ //~| expected ()
+ //~| found bool
}
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// error-pattern:mismatched types: expected `()`, found `bool`
-
struct r;
impl Drop for r {
fn drop(&mut self) {
- true
+ true //~ ERROR mismatched types
+ //~| expected ()
+ //~| found bool
+ //~| expected ()
+ //~| found bool
}
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// error-pattern:mismatched types: expected `()`, found `bool`
-
fn main() {
while true {
- true
+ true //~ ERROR mismatched types
+ //~| expected `()`
+ //~| found `bool`
+ //~| expected ()
+ //~| found bool
}
}
// Tests that we forbid coercion from `[T; n]` to `&[T]`
fn main() {
- let _: &[isize] = [0is]; //~ERROR: mismatched types: expected `&[isize]`, found `[isize; 1]`
+ let _: &[isize] = [0is];
+ //~^ ERROR mismatched types
+ //~| expected `&[isize]`
+ //~| found `[isize; 1]`
+ //~| expected &-ptr
+ //~| found array of 1 elements
}
static a: &'static str = "foo";
static b: *const u8 = a as *const u8;
-//~^ ERROR mismatched types: expected `*const u8`, found `&'static str`
+//~^ ERROR mismatched types
+//~| expected *const u8
+//~| found &'static str
+//~| expected u8
+//~| found str
static c: *const u8 = &a as *const u8;
-//~^ ERROR mismatched types: expected `*const u8`, found `&&'static str`
+//~^ ERROR mismatched types
+//~| expected *const u8
+//~| found &&'static str
+//~| expected u8
+//~| found &-ptr
fn main() {
}
pub fn main() {
let x: Box<Trait> = box Foo;
- let _y: &Trait = x; //~ ERROR mismatched types: expected `&Trait`, found `Box<Trait>`
+ let _y: &Trait = x; //~ ERROR mismatched types
+ //~| expected `&Trait`
+ //~| found `Box<Trait>`
+ //~| expected &-ptr
+ //~| found box
}
let box x = box 1is as Box<T>; //~ ERROR type `Box<T>` cannot be dereferenced
// n > m
- let &&x = &1is as &T; //~ ERROR found &-ptr
- let &&&x = &(&1is as &T); //~ ERROR found &-ptr
- let box box x = box 1is as Box<T>; //~ ERROR found box
+ let &&x = &1is as &T;
+ //~^ ERROR mismatched types
+ //~| expected `T`
+ //~| found `&_`
+ //~| expected trait T
+ //~| found &-ptr
+ let &&&x = &(&1is as &T);
+ //~^ ERROR mismatched types
+ //~| expected `T`
+ //~| found `&_`
+ //~| expected trait T
+ //~| found &-ptr
+ let box box x = box 1is as Box<T>;
+ //~^ ERROR mismatched types
+ //~| expected `T`
+ //~| found `Box<_>`
+ //~| expected trait T
+ //~| found box
}
// Assignment.
let f5: &mut Fat<ToBar> = &mut Fat { f1: 5, f2: "some str", ptr: Bar1 {f :42} };
let z: Box<ToBar> = box Bar1 {f: 36};
- f5.ptr = Bar1 {f: 36}; //~ ERROR mismatched types: expected `ToBar`, found `Bar1`
- //~^ ERROR the trait `core::marker::Sized` is not implemented for the type `ToBar`
+ f5.ptr = Bar1 {f: 36};
+ //~^ ERROR mismatched types
+ //~| expected `ToBar`
+ //~| found `Bar1`
+ //~| expected trait ToBar
+ //~| found struct `Bar1`
+ //~| ERROR the trait `core::marker::Sized` is not implemented for the type `ToBar`
}
let f1 = Fat { ptr: [1, 2, 3] };
let f2: &Fat<[isize; 3]> = &f1;
let f3: &Fat<[usize]> = f2;
- //~^ ERROR mismatched types: expected `&Fat<[usize]>`, found `&Fat<[isize; 3]>`
+ //~^ ERROR mismatched types
+ //~| expected `&Fat<[usize]>`
+ //~| found `&Fat<[isize; 3]>`
+ //~| expected usize
+ //~| found isize
// With a trait.
let f1 = Fat { ptr: Foo };
// With a vec of isizes.
let f1: &Fat<[isize]> = &Fat { ptr: [1, 2, 3] };
let f2: &Fat<[isize; 3]> = f1;
- //~^ ERROR mismatched types: expected `&Fat<[isize; 3]>`, found `&Fat<[isize]>`
+ //~^ ERROR mismatched types
+ //~| expected `&Fat<[isize; 3]>`
+ //~| found `&Fat<[isize]>`
+ //~| expected array of 3 elements
+ //~| found slice
}
impl<'a,'b> Foo<'a,'b> {
fn bar(self: Foo<'b,'a>) {}
- //~^ ERROR mismatched types: expected `Foo<'a, 'b>`, found `Foo<'b, 'a>`
- //~^^ ERROR mismatched types: expected `Foo<'a, 'b>`, found `Foo<'b, 'a>`
+ //~^ ERROR mismatched types
+ //~| expected `Foo<'a, 'b>`
+ //~| found `Foo<'b, 'a>`
+ //~| lifetime mismatch
+ //~| ERROR mismatched types
+ //~| expected `Foo<'a, 'b>`
+ //~| found `Foo<'b, 'a>`
+ //~| lifetime mismatch
}
fn main() {}
fn main() {
let f = if true { foo } else { bar };
- //~^ ERROR expected fn item, found a different fn item
+ //~^ ERROR if and else have incompatible types
+ //~| expected `fn(isize) -> isize {foo}`
+ //~| found `fn(isize) -> isize {bar}`
+ //~| expected fn item,
+ //~| found a different fn item
eq(foo, bar);
- //~^ ERROR expected fn item, found a different fn item
+ //~^ ERROR mismatched types
+ //~| expected `fn(isize) -> isize {foo}`
+ //~| found `fn(isize) -> isize {bar}`
+ //~| expected fn item
+ //~| found a different fn item
}
fn needs_fn<F>(x: F) where F: Fn(isize) -> isize {}
fn main() {
- let _: () = (box |:_: isize| {}) as Box<FnOnce(isize)>; //~ ERROR object-safe
- //~^ ERROR Box<core::ops::FnOnce(isize)>
+ let _: () = (box |:_: isize| {}) as Box<FnOnce(isize)>;
+ //~^ ERROR object-safe
+ //~| ERROR mismatched types
+ //~| expected `()`
+ //~| found `Box<core::ops::FnOnce(isize)>`
+ //~| expected ()
+ //~| found box
let _: () = (box |&:_: isize, isize| {}) as Box<Fn(isize, isize)>;
- //~^ ERROR Box<core::ops::Fn(isize, isize)>
+ //~^ ERROR mismatched types
+ //~| expected `()`
+ //~| found `Box<core::ops::Fn(isize, isize)>`
+ //~| expected ()
+ //~| found box
let _: () = (box |&mut:| -> isize unimplemented!()) as Box<FnMut() -> isize>;
- //~^ ERROR Box<core::ops::FnMut() -> isize>
+ //~^ ERROR mismatched types
+ //~| expected `()`
+ //~| found `Box<core::ops::FnMut() -> isize>`
+ //~| expected ()
+ //~| found box
needs_fn(1is); //~ ERROR `core::ops::Fn(isize) -> isize`
}
fn main() {
let x: Option<usize>;
x = 5;
- //~^ ERROR mismatched types: expected `core::option::Option<usize>`
+ //~^ ERROR mismatched types
+ //~| expected `core::option::Option<usize>`
+ //~| found `_`
+ //~| expected enum `core::option::Option`
+ //~| found integral variable
}
fn bar(x: x::foo) -> y::foo {
return x;
- //~^ ERROR mismatched types: expected `y::foo`, found `x::foo`
+ //~^ ERROR mismatched types
+ //~| expected `y::foo`
+ //~| found `x::foo`
+ //~| expected enum `y::foo`
+ //~| found enum `x::foo`
}
fn main() {
fn bar(x: usize) -> Option<usize> {
return x;
- //~^ ERROR mismatched types: expected `core::option::Option<usize>`
+ //~^ ERROR mismatched types
+ //~| expected `core::option::Option<usize>`
+ //~| found `usize`
+ //~| expected enum `core::option::Option`
+ //~| found usize
}
fn main() {
fn main() {
// Ensure that the printed type doesn't include the default type params...
let _: Foo<isize> = ();
- //~^ ERROR mismatched types: expected `Foo<isize>`, found `()`
+ //~^ ERROR mismatched types
+ //~| expected `Foo<isize>`
+ //~| found `()`
+ //~| expected struct `Foo`
+ //~| found ()
// ...even when they're present, but the same types as the defaults.
let _: Foo<isize, B, C> = ();
- //~^ ERROR mismatched types: expected `Foo<isize>`, found `()`
+ //~^ ERROR mismatched types
+ //~| expected `Foo<isize>`
+ //~| found `()`
+ //~| expected struct `Foo`
+ //~| found ()
// Including cases where the default is using previous type params.
let _: HashMap<String, isize> = ();
- //~^ ERROR mismatched types: expected `HashMap<collections::string::String, isize>`, found `()`
+ //~^ ERROR mismatched types
+ //~| expected `HashMap<collections::string::String, isize>`
+ //~| found `()`
+ //~| expected struct `HashMap`
+ //~| found ()
let _: HashMap<String, isize, Hash<String>> = ();
- //~^ ERROR mismatched types: expected `HashMap<collections::string::String, isize>`, found `()`
+ //~^ ERROR mismatched types
+ //~| expected `HashMap<collections::string::String, isize>`
+ //~| found `()`
+ //~| expected struct `HashMap`
+ //~| found ()
// But not when there's a different type in between.
let _: Foo<A, isize, C> = ();
- //~^ ERROR mismatched types: expected `Foo<A, isize>`, found `()`
+ //~^ ERROR mismatched types
+ //~| expected `Foo<A, isize>`
+ //~| found `()`
+ //~| expected struct `Foo`
+ //~| found ()
// And don't print <> at all when there's just defaults.
let _: Foo<A, B, C> = ();
- //~^ ERROR mismatched types: expected `Foo`, found `()`
+ //~^ ERROR mismatched types
+ //~| expected `Foo`
+ //~| found `()`
+ //~| expected struct `Foo`
+ //~| found ()
}
fn main() {
let x = if true { 10is } else { 10us };
- //~^ ERROR if and else have incompatible types: expected `isize`, found `usize`
+ //~^ ERROR if and else have incompatible types
+ //~| expected `isize`
+ //~| found `usize`
+ //~| expected isize
+ //~| found usize
}
fn main() {
let a = if true { true };
-//~^ ERROR if may be missing an else clause: expected `()`, found `bool` (expected (), found bool)
+ //~^ ERROR if may be missing an else clause
+ //~| expected `()`
+ //~| found `bool`
+ //~| expected ()
+ //~| found bool
println!("{}", a);
}
fn id_u64(n: u64) -> u64 { n }
id_i8(a8); // ok
- id_i8(a16); //~ ERROR mismatched types: expected `i8`, found `i16`
- id_i8(a32); //~ ERROR mismatched types: expected `i8`, found `i32`
- id_i8(a64); //~ ERROR mismatched types: expected `i8`, found `i64`
+ id_i8(a16);
+ //~^ ERROR mismatched types
+ //~| expected `i8`
+ //~| found `i16`
+ //~| expected i8
+ //~| found i16
+ id_i8(a32);
+ //~^ ERROR mismatched types
+ //~| expected `i8`
+ //~| found `i32`
+ //~| expected i8
+ //~| found i32
+ id_i8(a64);
+ //~^ ERROR mismatched types
+ //~| expected `i8`
+ //~| found `i64`
+ //~| expected i8
+ //~| found i64
- id_i16(a8); //~ ERROR mismatched types: expected `i16`, found `i8`
+ id_i16(a8);
+ //~^ ERROR mismatched types
+ //~| expected `i16`
+ //~| found `i8`
+ //~| expected i16
+ //~| found i8
id_i16(a16); // ok
- id_i16(a32); //~ ERROR mismatched types: expected `i16`, found `i32`
- id_i16(a64); //~ ERROR mismatched types: expected `i16`, found `i64`
+ id_i16(a32);
+ //~^ ERROR mismatched types
+ //~| expected `i16`
+ //~| found `i32`
+ //~| expected i16
+ //~| found i32
+ id_i16(a64);
+ //~^ ERROR mismatched types
+ //~| expected `i16`
+ //~| found `i64`
+ //~| expected i16
+ //~| found i64
- id_i32(a8); //~ ERROR mismatched types: expected `i32`, found `i8`
- id_i32(a16); //~ ERROR mismatched types: expected `i32`, found `i16`
+ id_i32(a8);
+ //~^ ERROR mismatched types
+ //~| expected `i32`
+ //~| found `i8`
+ //~| expected i32
+ //~| found i8
+ id_i32(a16);
+ //~^ ERROR mismatched types
+ //~| expected `i32`
+ //~| found `i16`
+ //~| expected i32
+ //~| found i16
id_i32(a32); // ok
- id_i32(a64); //~ ERROR mismatched types: expected `i32`, found `i64`
+ id_i32(a64);
+ //~^ ERROR mismatched types
+ //~| expected `i32`
+ //~| found `i64`
+ //~| expected i32
+ //~| found i64
- id_i64(a8); //~ ERROR mismatched types: expected `i64`, found `i8`
- id_i64(a16); //~ ERROR mismatched types: expected `i64`, found `i16`
- id_i64(a32); //~ ERROR mismatched types: expected `i64`, found `i32`
+ id_i64(a8);
+ //~^ ERROR mismatched types
+ //~| expected `i64`
+ //~| found `i8`
+ //~| expected i64
+ //~| found i8
+ id_i64(a16);
+ //~^ ERROR mismatched types
+ //~| expected `i64`
+ //~| found `i16`
+ //~| expected i64
+ //~| found i16
+ id_i64(a32);
+ //~^ ERROR mismatched types
+ //~| expected `i64`
+ //~| found `i32`
+ //~| expected i64
+ //~| found i32
id_i64(a64); // ok
id_i8(c8); // ok
- id_i8(c16); //~ ERROR mismatched types: expected `i8`, found `i16`
- id_i8(c32); //~ ERROR mismatched types: expected `i8`, found `i32`
- id_i8(c64); //~ ERROR mismatched types: expected `i8`, found `i64`
+ id_i8(c16);
+ //~^ ERROR mismatched types
+ //~| expected `i8`
+ //~| found `i16`
+ //~| expected i8
+ //~| found i16
+ id_i8(c32);
+ //~^ ERROR mismatched types
+ //~| expected `i8`
+ //~| found `i32`
+ //~| expected i8
+ //~| found i32
+ id_i8(c64);
+ //~^ ERROR mismatched types
+ //~| expected `i8`
+ //~| found `i64`
+ //~| expected i8
+ //~| found i64
- id_i16(c8); //~ ERROR mismatched types: expected `i16`, found `i8`
+ id_i16(c8);
+ //~^ ERROR mismatched types
+ //~| expected `i16`
+ //~| found `i8`
+ //~| expected i16
+ //~| found i8
id_i16(c16); // ok
- id_i16(c32); //~ ERROR mismatched types: expected `i16`, found `i32`
- id_i16(c64); //~ ERROR mismatched types: expected `i16`, found `i64`
+ id_i16(c32);
+ //~^ ERROR mismatched types
+ //~| expected `i16`
+ //~| found `i32`
+ //~| expected i16
+ //~| found i32
+ id_i16(c64);
+ //~^ ERROR mismatched types
+ //~| expected `i16`
+ //~| found `i64`
+ //~| expected i16
+ //~| found i64
- id_i32(c8); //~ ERROR mismatched types: expected `i32`, found `i8`
- id_i32(c16); //~ ERROR mismatched types: expected `i32`, found `i16`
+ id_i32(c8);
+ //~^ ERROR mismatched types
+ //~| expected `i32`
+ //~| found `i8`
+ //~| expected i32
+ //~| found i8
+ id_i32(c16);
+ //~^ ERROR mismatched types
+ //~| expected `i32`
+ //~| found `i16`
+ //~| expected i32
+ //~| found i16
id_i32(c32); // ok
- id_i32(c64); //~ ERROR mismatched types: expected `i32`, found `i64`
+ id_i32(c64);
+ //~^ ERROR mismatched types
+ //~| expected `i32`
+ //~| found `i64`
+ //~| expected i32
+ //~| found i64
- id_i64(a8); //~ ERROR mismatched types: expected `i64`, found `i8`
- id_i64(a16); //~ ERROR mismatched types: expected `i64`, found `i16`
- id_i64(a32); //~ ERROR mismatched types: expected `i64`, found `i32`
+ id_i64(a8);
+ //~^ ERROR mismatched types
+ //~| expected `i64`
+ //~| found `i8`
+ //~| expected i64
+ //~| found i8
+ id_i64(a16);
+ //~^ ERROR mismatched types
+ //~| expected `i64`
+ //~| found `i16`
+ //~| expected i64
+ //~| found i16
+ id_i64(a32);
+ //~^ ERROR mismatched types
+ //~| expected `i64`
+ //~| found `i32`
+ //~| expected i64
+ //~| found i32
id_i64(a64); // ok
id_u8(b8); // ok
- id_u8(b16); //~ ERROR mismatched types: expected `u8`, found `u16`
- id_u8(b32); //~ ERROR mismatched types: expected `u8`, found `u32`
- id_u8(b64); //~ ERROR mismatched types: expected `u8`, found `u64`
+ id_u8(b16);
+ //~^ ERROR mismatched types
+ //~| expected `u8`
+ //~| found `u16`
+ //~| expected u8
+ //~| found u16
+ id_u8(b32);
+ //~^ ERROR mismatched types
+ //~| expected `u8`
+ //~| found `u32`
+ //~| expected u8
+ //~| found u32
+ id_u8(b64);
+ //~^ ERROR mismatched types
+ //~| expected `u8`
+ //~| found `u64`
+ //~| expected u8
+ //~| found u64
- id_u16(b8); //~ ERROR mismatched types: expected `u16`, found `u8`
+ id_u16(b8);
+ //~^ ERROR mismatched types
+ //~| expected `u16`
+ //~| found `u8`
+ //~| expected u16
+ //~| found u8
id_u16(b16); // ok
- id_u16(b32); //~ ERROR mismatched types: expected `u16`, found `u32`
- id_u16(b64); //~ ERROR mismatched types: expected `u16`, found `u64`
+ id_u16(b32);
+ //~^ ERROR mismatched types
+ //~| expected `u16`
+ //~| found `u32`
+ //~| expected u16
+ //~| found u32
+ id_u16(b64);
+ //~^ ERROR mismatched types
+ //~| expected `u16`
+ //~| found `u64`
+ //~| expected u16
+ //~| found u64
- id_u32(b8); //~ ERROR mismatched types: expected `u32`, found `u8`
- id_u32(b16); //~ ERROR mismatched types: expected `u32`, found `u16`
+ id_u32(b8);
+ //~^ ERROR mismatched types
+ //~| expected `u32`
+ //~| found `u8`
+ //~| expected u32
+ //~| found u8
+ id_u32(b16);
+ //~^ ERROR mismatched types
+ //~| expected `u32`
+ //~| found `u16`
+ //~| expected u32
+ //~| found u16
id_u32(b32); // ok
- id_u32(b64); //~ ERROR mismatched types: expected `u32`, found `u64`
+ id_u32(b64);
+ //~^ ERROR mismatched types
+ //~| expected `u32`
+ //~| found `u64`
+ //~| expected u32
+ //~| found u64
- id_u64(b8); //~ ERROR mismatched types: expected `u64`, found `u8`
- id_u64(b16); //~ ERROR mismatched types: expected `u64`, found `u16`
- id_u64(b32); //~ ERROR mismatched types: expected `u64`, found `u32`
+ id_u64(b8);
+ //~^ ERROR mismatched types
+ //~| expected `u64`
+ //~| found `u8`
+ //~| expected u64
+ //~| found u8
+ id_u64(b16);
+ //~^ ERROR mismatched types
+ //~| expected `u64`
+ //~| found `u16`
+ //~| expected u64
+ //~| found u16
+ id_u64(b32);
+ //~^ ERROR mismatched types
+ //~| expected `u64`
+ //~| found `u32`
+ //~| expected u64
+ //~| found u32
id_u64(b64); // ok
}
fn main() {
let mut x = 2;
x = 5.0;
-//~^ ERROR expected `_`, found `_` (expected integral variable, found floating-point variable)
+ //~^ ERROR mismatched types
+ //~| expected `_`
+ //~| found `_`
+ //~| expected integral variable
+ //~| found floating-point variable
}
fn f() -> isize {
(return 1, return 2)
-//~^ ERROR mismatched types: expected `isize`, found `(_, _)` (expected isize, found tuple)
+//~^ ERROR mismatched types
+//~| expected `isize`
+//~| found `(_, _)`
+//~| expected isize
+//~| found tuple
}
fn main() {}
fn main() {
match Some(10) {
- //~^ ERROR match arms have incompatible types: expected `bool`, found `()`
+ //~^ ERROR match arms have incompatible types:
+ //~| expected `bool`
+ //~| found `()`
+ //~| expected bool
+ //~| found ()
Some(5) => false,
Some(2) => true,
None => (), //~ NOTE match arm with an incompatible type
fn main() {
let x = ();
1 +
- x //~ ERROR mismatched types: expected `_`, found `()` (expected integral variable, found ())
+ x //~ ERROR mismatched types
+ //~| expected `_`
+ //~| found `()`
+ //~| expected integral variable
+ //~| found ()
;
let x: () = ();
1 +
- x //~ ERROR mismatched types: expected `_`, found `()` (expected integral variable, found ())
+ x //~ ERROR mismatched types
+ //~| expected `_`
+ //~| found `()`
+ //~| expected integral variable
+ //~| found ()
;
}
//! Test that makes sure wrongly-typed bench functions are rejected
-// error-pattern:expected &-ptr, found isize
#[bench]
fn bar(x: isize) { }
+//~^ ERROR mismatched types
+//~| expected `fn(&mut test::Bencher)`
+//~| found `fn(isize) {bar}`
+//~| expected &-ptr
+//~| found isize
fn main() {
check((3us, 5us));
-//~^ ERROR mismatched types: expected `&_`, found `(usize, usize)` (expected &-ptr, found tuple)
+//~^ ERROR mismatched types
+//~| expected `&_`
+//~| found `(usize, usize)`
+//~| expected &-ptr
+//~| found tuple
}
fn main() {
foo(1*(1 as isize));
- //~^ ERROR: mismatched types: expected `i16`, found `isize` (expected i16, found isize)
+ //~^ ERROR mismatched types
+ //~| expected `i16`
+ //~| found `isize`
+ //~| expected i16
+ //~| found isize
bar(1*(1 as usize));
- //~^ ERROR: mismatched types: expected `u32`, found `usize` (expected u32, found usize)
+ //~^ ERROR mismatched types
+ //~| expected `u32`
+ //~| found `usize`
+ //~| expected u32
+ //~| found usize
}
// the actual arm `Result<T, E>` has two. typeck should not be
// tricked into looking up a non-existing second type parameter.
let _x: usize = match Some(1us) {
- Ok(u) => u, //~ ERROR mismatched types: expected `core::option::Option<usize>`
- Err(e) => panic!(e) //~ ERROR mismatched types: expected `core::option::Option<usize>`
+ Ok(u) => u,
+ //~^ ERROR mismatched types
+ //~| expected `core::option::Option<usize>`
+ //~| found `core::result::Result<_, _>`
+ //~| expected enum `core::option::Option`
+ //~| found enum `core::result::Result`
+
+ Err(e) => panic!(e)
+ //~^ ERROR mismatched types
+ //~| expected `core::option::Option<usize>`
+ //~| found `core::result::Result<_, _>`
+ //~| expected enum `core::option::Option`
+ //~| found enum `core::result::Result`
};
}
let x = [1,2];
let y = match x {
[] => None,
- //~^ ERROR types: expected `[_#0i; 2]`, found `[_#7t; 0]`
- // (expected array of 2 elements, found array of 0 elements)
+//~^ ERROR mismatched types
+//~| expected `[_#0i; 2]`
+//~| found `[_#7t; 0]`
+//~| expected an array with a fixed size of 2 elements
+//~| found one with 0 elements
[a,_] => Some(a)
};
}
let x = [1,2];
let y = match x {
[] => None,
-//~^ ERROR types: expected `[_; 2]`, found `[_; 0]`
-// (expected array of 2 elements, found array of 0 elements)
+ //~^ ERROR mismatched types
+ //~| expected `[_; 2]`
+ //~| found `[_; 0]`
+ //~| expected array with a fixed size of 2 elements
[a,_] => Some(a)
};
}
pub fn get_enum_struct_variant() -> () {
Enum::EnumStructVariant { x: 1, y: 2, z: 3 }
-//~^ ERROR mismatched types: expected `()`, found `a::Enum` (expected (), found enum a::Enum)
+ //~^ ERROR mismatched types
+ //~| expected `()`
+ //~| found `a::Enum`
+ //~| expected ()
+ //~| found enum `a::Enum`
}
}
let enum_struct_variant = ::a::get_enum_struct_variant();
match enum_struct_variant {
a::Enum::EnumStructVariant { x, y, z } => {
- //~^ ERROR mismatched types: expected `()`, found `a::Enum`
- // (expected (), found enum a::Enum)
+ //~^ ERROR mismatched types
+ //~| expected `()`
+ //~| found `a::Enum`
+ //~| expected ()
+ // found enum `a::Enum`
}
}
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// error-pattern: expected `bool`, found `_` (expected bool, found integral variable)
+// error-pattern:mismatched types
+// error-pattern:expected `bool`
+// error-pattern:found `_`
+// error-pattern:expected bool
+// error-pattern:found integral variable
fn main(){assert!(1,1);}
fn make(v: vec2) {
let vec3 { y: _, z: _ } = v;
- //~^ ERROR mismatched types: expected `vec2`, found `vec3`
- // (expected struct vec2, found struct vec3)
+ //~^ ERROR mismatched types
+ //~| expected `vec2`
+ //~| found `vec3`
+ //~| expected struct `vec2`
+ //~| found struct `vec3`
}
fn main() { }
fn main() {
let x = X { a: [0] };
let _f = &x.a as *mut u8;
- //~^ ERROR mismatched types: expected `*mut u8`, found `&[u8; 1]`
+ //~^ ERROR mismatched types
+ //~| expected `*mut u8`
+ //~| found `&[u8; 1]`
+ //~| expected u8
+ //~| found array of 1 elements
let local = [0u8];
let _v = &local as *mut u8;
- //~^ ERROR mismatched types: expected `*mut u8`, found `&[u8; 1]`
+ //~^ ERROR mismatched types
+ //~| expected `*mut u8`
+ //~| found `&[u8; 1]`
+ //~| expected u8,
+ //~| found array of 1 elements
}
impl Something for X {
fn yay<T: Str>(_:Option<X>, thing: &[T]) {
-//~^ ERROR in method `yay`, type parameter 0 requires bound `Str`, which is not required
-
+ //~^ ERROR the requirement `T : Str` appears on the impl method
}
}
fn main() {
let name = "Foo";
- let msg = foo(Some(&[name.as_slice()]));
-//~^ ERROR mismatched types: expected `core::option::Option<&[&str]>`
+ let x = Some(&[name.as_slice()]);
+ let msg = foo(x);
+//~^ ERROR mismatched types
+//~| expected `core::option::Option<&[&str]>`
+//~| found `core::option::Option<&[&str; 1]>`
+//~| expected slice
+//~| found array of 1 elements
assert_eq!(msg, 3);
}
let u = match e {
E::B(
Tau{t: x},
- //~^ ERROR mismatched types: expected `main::R`, found `main::Tau`
- // (expected enum main::R, found struct main::Tau)
+ //~^ ERROR mismatched types
+ //~| expected `main::R`
+ //~| found `main::Tau`
+ //~| expected enum `main::R`
+ //~| found struct `main::Tau`
_) => x,
};
}
fn main() {
let Slice { data: data, len: len } = "foo";
- //~^ ERROR mismatched types: expected `&str`, found `core::raw::Slice<_>`
- // (expected &-ptr, found struct core::raw::Slice)
+ //~^ ERROR mismatched types
+ //~| expected `&str`
+ //~| found `core::raw::Slice<_>`
+ //~| expected &-ptr
+ //~| found struct `core::raw::Slice`
}
fn main() {
match () {
Slice { data: data, len: len } => (),
- //~^ ERROR mismatched types: expected `()`, found `core::raw::Slice<_>`
- // (expected (), found struct core::raw::Slice)
+ //~^ ERROR mismatched types
+ //~| expected `()`
+ //~| found `core::raw::Slice<_>`
+ //~| expected ()
+ //~| found struct `core::raw::Slice`
_ => unreachable!()
}
}
#![feature(overloaded_calls)]
fn f<'r>(p: &'r mut fn(p: &mut ())) {
- (*p)(()) //~ ERROR mismatched types: expected `&mut ()`, found `()`
+ (*p)(()) //~ ERROR mismatched types
+ //~| expected `&mut ()`
+ //~| found `()`
+ //~| expected &-ptr
+ //~| found ()
}
fn main() {}
// `x { ... }` should not be interpreted as a struct literal here
if x = x {
- //~^ ERROR mismatched types: expected `bool`, found `()` (expected bool, found ())
+ //~^ ERROR mismatched types
+ //~| expected `bool`
+ //~| found `()`
+ //~| expected bool
+ //~| found ()
println!("{}", x);
}
// Explicit parentheses on the left should match behavior of above
if (x = x) {
- //~^ ERROR mismatched types: expected `bool`, found `()` (expected bool, found ())
+ //~^ ERROR mismatched types
+ //~| expected `bool`
+ //~| found `()`
+ //~| expected bool
+ //~| found ()
println!("{}", x);
}
// The struct literal interpretation is fine with explicit parentheses on the right
if y = (Foo { foo: x }) {
- //~^ ERROR mismatched types: expected `bool`, found `()` (expected bool, found ())
+ //~^ ERROR mismatched types
+ //~| expected `bool`
+ //~| found `()`
+ //~| expected bool
+ //~| found ()
println!("{}", x);
}
}
impl <'a> Foo<'a>{
fn bar(self: &mut Foo) {
- //~^ mismatched types: expected `Foo<'a>`, found `Foo<'_>` (lifetime mismatch)
- //~| mismatched types: expected `Foo<'a>`, found `Foo<'_>` (lifetime mismatch)
+ //~^ mismatched types
+ //~| expected `Foo<'a>`
+ //~| found `Foo<'_>`
+ //~| lifetime mismatch
+ //~| mismatched types
+ //~| expected `Foo<'a>`
+ //~| found `Foo<'_>`
+ //~| lifetime mismatch
}
}
isize
> {
fn say(self: &Pair<&str, isize>) {
-//~^ ERROR mismatched types: expected `Pair<&'static str, isize>`, found `Pair<&str, isize>`
+//~^ ERROR mismatched types
+//~| expected `Pair<&'static str, isize>`
+//~| found `Pair<&str, isize>`
+//~| lifetime mismatch
println!("{}", self);
}
}
// clause does not exist, instead of the unsympathetic "match arms have incompatible types"
fn main() {
- if let Some(homura) = Some("madoka") { //~ ERROR missing an else clause: expected `()`
+ if let Some(homura) = Some("madoka") { //~ ERROR missing an else clause
+ //~| expected `()`
+ //~| found `i32`
+ //~| expected ()
+ //~| found i32
765i32
};
}
}
impl A for E {
- fn b<F: Sync, G>(_x: F) -> F { panic!() } //~ ERROR type parameter 0 requires `Sync`
+ fn b<F: Sync, G>(_x: F) -> F { panic!() }
+ //~^ ERROR `F : core::marker::Sync` appears on the impl method
}
fn main() {}
fn foo<T, U>(x: T, y: U) {
let mut xx = x;
- xx = y; //~ ERROR expected `T`, found `U`
+ xx = y;
+ //~^ ERROR mismatched types
+ //~| expected `T`
+ //~| found `U`
+ //~| expected type parameter
+ //~| found a different type parameter
}
fn main() {
// except according to those terms.
fn main() {
- let _p: char = 100; //~ ERROR mismatched types: expected `char`, found
+ let _p: char = 100;
+ //~^ ERROR mismatched types
+ //~| expected `char`
+ //~| found `u8`
+ //~| expected char
+ //~| found u8
}
trait A {
fn a(&self) {
- |&:| self.b() //~ ERROR type `&Self` does not implement any method in scope named `b`
- //~^ ERROR expected (), found closure
+ |&:| self.b()
+ //~^ ERROR type `&Self` does not implement any method in scope named `b`
+ //~| ERROR mismatched types
+ //~| expected `()`
+ //~| found closure
+ //~| expected ()
+ //~| found closure
}
}
fn main() {}
fn main() {
match None {
Err(_) => ()
- //~^ ERROR mismatched types: expected `core::option::Option<_>`
- // , found `core::result::Result<_, _>`
+ //~^ ERROR mismatched types
+ //~| expected `core::option::Option<_>`
+ //~| found `core::result::Result<_, _>`
+ //~| expected enum `core::option::Option`
+ //~| found enum `core::result::Result`
}
}
let a = if true {
0
} else if false {
-//~^ ERROR if may be missing an else clause: expected `()`, found `_`
+//~^ ERROR if may be missing an else clause
+//~| expected `()`
+//~| found `_`
+//~| expected ()
+//~| found integral variable
1
};
}
fn main() {
let foo: [u8; 4] = [1u8; 4us];
bar(foo);
- //~^ ERROR mismatched types: expected `usize`, found `[u8; 4]`
- // (expected usize, found vector)
+ //~^ ERROR mismatched types
+ //~| expected `usize`
+ //~| found `[u8; 4]`
+ //~| expected usize
+ //~| found array of 4 elements
}
const A: (isize,isize) = (4,2);
fn main() {
match 42 { A => () }
- //~^ ERROR mismatched types: expected `_`, found `(isize, isize)`
- // (expected integral variable, found tuple)
+ //~^ ERROR mismatched types
+ //~| expected `_`
+ //~| found `(isize, isize)`
+ //~| expected integral variable
+ //~| found tuple
}
fn main() {
match (true, false) {
A::B => (),
-//~^ ERROR mismatched types: expected `(bool, bool)`, found `A` (expected tuple, found enum A)
+//~^ ERROR mismatched types:
+//~| expected `(bool, bool)`
+//~| found `A`
+//~| expected tuple
+//~| found enum `A`
_ => ()
}
match (true, false) {
(true, false, false) => ()
-//~^ ERROR mismatched types: expected `(bool, bool)`, found `(_, _, _)`
+//~^ ERROR mismatched types
+//~| expected `(bool, bool)`
+//~| found `(_, _, _)`
+//~| expected a tuple with 2 elements
+//~| found one with 3 elements
}
match (true, false) {
(true, false, false) => ()
-//~^ ERROR (expected a tuple with 2 elements, found one with 3 elements)
+//~^ ERROR mismatched types
+//~| expected `(bool, bool)`
+//~| found `(_, _, _)`
+//~| expected a tuple with 2 elements
+//~| found one with 3 elements
}
match (true, false) {
box (true, false) => ()
-//~^ ERROR mismatched types: expected `(bool, bool)`, found `Box<_>` (expected tuple, found box)
+//~^ ERROR mismatched types
+//~| expected `(bool, bool)`
+//~| found `Box<_>`
+//~| expected tuple
+//~| found box
}
match (true, false) {
&(true, false) => ()
-//~^ ERROR mismatched types: expected `(bool, bool)`, found `&_` (expected tuple, found &-ptr)
+//~^ ERROR mismatched types
+//~| expected `(bool, bool)`
+//~| found `&_`
+//~| expected tuple
+//~| found &-ptr
}
for &(x,y) in v.iter() {} // should be OK
// Make sure none of the errors above were fatal
- let x: char = true; //~ ERROR expected `char`, found `bool`
+ let x: char = true; //~ ERROR mismatched types
+ //~| expected `char`
+ //~| found `bool`
+ //~| expected char
+ //~| found bool
}
fn main() {
match S(Either::Left(5)) {
- Either::Right(_) => {} //~ ERROR mismatched types: expected `S`, found `Either
+ Either::Right(_) => {}
+ //~^ ERROR mismatched types
+ //~| expected `S`
+ //~| found `Either<_, _>`
+ //~| expected struct `S`
+ //~| found enum `Either`
_ => {}
}
}
fn main() {
&panic!()
- //~^ ERROR mismatched types: expected `()`, found `&_` (expected (), found &-ptr)
+ //~^ ERROR mismatched types
+ //~| expected `()`
+ //~| found `&_`
+ //~| expected ()
+ //~| found &-ptr
}
impl<'a> BarStruct {
fn foo(&'a mut self) -> Box<BarStruct> { self }
- //~^ ERROR: error: mismatched types: expected `Box<BarStruct>`, found `&'a mut BarStruct
+ //~^ ERROR mismatched types
+ //~| expected `Box<BarStruct>`
+ //~| found `&'a mut BarStruct`
+ //~| expected box
+ //~| found &-ptr
}
fn main() {}
fn foo(x: Whatever) {
match x {
Some(field) =>
-//~^ ERROR: mismatched types: expected `Whatever`, found `core::option::Option<_>`
+//~^ ERROR mismatched types
+//~| expected `Whatever`
+//~| found `core::option::Option<_>`
+//~| expected enum `Whatever`
+//~| found enum `core::option::Option`
field.access(), //~ ERROR the type of this value must be known in this context
}
}
fn main() {
match (true, false) {
- A::B => (), //~ ERROR expected `(bool, bool)`, found `A` (expected tuple, found enum A)
+ A::B => (),
+ //~^ ERROR mismatched types
+ //~| expected `(bool, bool)`
+ //~| found `A`
+ //~| expected tuple
+ //~| found enum `A`
_ => ()
}
match &Some(42is) {
- Some(x) => (), //~ ERROR expected `&core::option::Option<isize>`,
- // found `core::option::Option<_>`
- None => () //~ ERROR expected `&core::option::Option<isize>`,
- // found `core::option::Option<_>`
+ Some(x) => (),
+ //~^ ERROR mismatched types
+ //~| expected `&core::option::Option<isize>`
+ //~| found `core::option::Option<_>`
+ //~| expected &-ptr
+ //~| found enum `core::option::Option`
+ None => ()
+ //~^ ERROR mismatched types
+ //~| expected `&core::option::Option<isize>`
+ //~| found `core::option::Option<_>`
+ //~| expected &-ptr
+ //~| found enum `core::option::Option`
}
}
enum Foo {
A = 1i64,
- //~^ ERROR mismatched types: expected `isize`, found `i64`
+ //~^ ERROR mismatched types
+ //~| expected `isize`
+ //~| found `i64`
+ //~| expected isize
+ //~| found i64
B = 2u8
- //~^ ERROR mismatched types: expected `isize`, found `u8`
+ //~^ ERROR mismatched types
+ //~| expected `isize`
+ //~| found `u8`
+ //~| expected isize
+ //~| found u8
}
fn main() {}
fn main() {
match (S { a: 1 }) {
- E::C(_) => (), //~ ERROR mismatched types: expected `S`, found `E`
+ E::C(_) => (),
+ //~^ ERROR mismatched types
+ //~| expected `S`
+ //~| found `E`
+ //~| expected struct `S`
+ //~| found enum `E`
_ => ()
}
}
fn main() {
match () {
[()] => { }
-//~^ ERROR mismatched types: expected `()`, found `&[_]` (expected (), found &-ptr)
+ //~^ ERROR mismatched types
+ //~| expected `()`
+ //~| found `&[_]`
+ //~| expected ()
+ //~| found &-ptr
}
}
fn main() {
let x = Foo;
- Foo::bar(x); //~ERROR mismatched types: expected `&Foo`, found `Foo`
- Foo::bar(&&x); //~ERROR mismatched types: expected `&Foo`, found `&&Foo`
- Foo::bar(&42is); //~ERROR mismatched types: expected `&Foo`, found `&isize`
+ Foo::bar(x); //~ ERROR mismatched types
+ //~| expected `&Foo`
+ //~| found `Foo`
+ //~| expected &-ptr
+ //~| found struct `Foo`
+ Foo::bar(&&x); //~ ERROR mismatched types
+ //~| expected `&Foo`
+ //~| found `&&Foo`
+ //~| expected struct `Foo`
+ //~| found &-ptr
+ Foo::bar(&42is); //~ ERROR mismatched types
+ //~| expected `&Foo`
+ //~| found `&isize`
+ //~| expected struct `Foo`
+ //~| found isize
}
// (separate lines to ensure the spans are accurate)
- let &_ //~ ERROR expected `&mut isize`, found `&_`
+ let &_ //~ ERROR mismatched types
+ //~| expected `&mut isize`
+ //~| found `&_`
+ //~| values differ in mutability
= foo;
let &mut _ = foo;
let bar = &1is;
let &_ = bar;
- let &mut _ //~ ERROR expected `&isize`, found `&mut _`
+ let &mut _ //~ ERROR mismatched types
+ //~| expected `&isize`
+ //~| found `&mut _`
+ //~| values differ in mutability
= bar;
}
--- /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.
+
+// Related issues: #20401, #20506, #20614, #20752, #20829, #20846, #20885, #20886
+
+fn main() {
+ "".homura[""]; //~ ERROR no field with that name was found
+}
// because the def_id associated with the type was
// not convertible to a path.
let x: isize = noexporttypelib::foo();
- //~^ ERROR expected `isize`, found `core::option::Option<isize>`
+ //~^ ERROR mismatched types
+ //~| expected `isize`
+ //~| found `core::option::Option<isize>`
+ //~| expected isize
+ //~| found enum `core::option::Option`
}
let f;
let g;
g = f;
- f = box g; //~ ERROR cyclic type of infinite size
+ f = box g;
+ //~^ ERROR mismatched types
+ //~| expected `_`
+ //~| found `Box<_>`
+ //~| cyclic type of infinite size
}
fn main() {
let f;
- f = box f; //~ ERROR cyclic type of infinite size
+ f = box f;
+ //~^ ERROR mismatched types
+ //~| expected `_`
+ //~| found `Box<_>`
+ //~| cyclic type of infinite size
}
--- /dev/null
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+// ignore-tidy-linelength
+
+#![feature(on_unimplemented)]
+
+#![allow(unused)]
+
+#[rustc_on_unimplemented = "test error `{Self}` with `{Bar}` `{Baz}` `{Quux}`"]
+trait Foo<Bar, Baz, Quux>{}
+
+#[rustc_on_unimplemented="a collection of type `{Self}` cannot be built from an iterator over elements of type `{A}`"]
+trait MyFromIterator<A> {
+ /// Build a container with elements from an external iterator.
+ fn my_from_iter<T: Iterator<Item=A>>(iterator: T) -> Self;
+}
+
+#[rustc_on_unimplemented] //~ ERROR this attribute must have a value
+trait BadAnnotation1 {}
+
+#[rustc_on_unimplemented = "Unimplemented trait error on `{Self}` with params `<{A},{B},{C}>`"]
+//~^ ERROR there is no type parameter C on trait BadAnnotation2
+trait BadAnnotation2<A,B> {}
+
+#[rustc_on_unimplemented = "Unimplemented trait error on `{Self}` with params `<{A},{B},{}>`"]
+//~^ only named substitution parameters are allowed
+trait BadAnnotation3<A,B> {}
+
+pub fn main() {
+}
--- /dev/null
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+// ignore-tidy-linelength
+
+#![feature(on_unimplemented)]
+
+#[rustc_on_unimplemented = "test error `{Self}` with `{Bar}` `{Baz}` `{Quux}`"]
+trait Foo<Bar, Baz, Quux>{}
+
+fn foobar<U: Clone, T: Foo<u8, U, u32>>() -> T {
+
+}
+
+#[rustc_on_unimplemented="a collection of type `{Self}` cannot be built from an iterator over elements of type `{A}`"]
+trait MyFromIterator<A> {
+ /// Build a container with elements from an external iterator.
+ fn my_from_iter<T: Iterator<Item=A>>(iterator: T) -> Self;
+}
+
+fn collect<A, I: Iterator<Item=A>, B: MyFromIterator<A>>(it: I) -> B {
+ MyFromIterator::my_from_iter(it)
+}
+
+pub fn main() {
+ let x = vec!(1u8, 2, 3, 4);
+ let y: Option<Vec<u8>> = collect(x.iter()); // this should give approximately the same error for x.iter().collect()
+ //~^ ERROR
+ //~^^ NOTE a collection of type `core::option::Option<collections::vec::Vec<u8>>` cannot be built from an iterator over elements of type `&u8`
+ let x: String = foobar(); //~ ERROR
+ //~^ NOTE test error `collections::string::String` with `u8` `_` `u32`
+}
}
match 'c' {
S { .. } => (),
- //~^ ERROR mismatched types: expected `char`, found `S` (expected char, found struct S)
+ //~^ ERROR mismatched types
+ //~| expected `char`
+ //~| found `S`
+ //~| expected char
+ //~| found struct `S`
_ => ()
}
- f(true); //~ ERROR mismatched types: expected `char`, found `bool`
+ f(true);
+ //~^ ERROR mismatched types
+ //~| expected `char`
+ //~| found `bool`
+ //~| expected char
+ //~| found bool
}
fn main() {
let_in(3us, |i| { assert!(i == 3is); });
- //~^ ERROR expected `usize`, found `isize`
+ //~^ ERROR mismatched types
+ //~| expected `usize`
+ //~| found `isize`
+ //~| expected usize
+ //~| found isize
let_in(3is, |i| { assert!(i == 3us); });
- //~^ ERROR expected `isize`, found `usize`
+ //~^ ERROR mismatched types
+ //~| expected `isize`
+ //~| found `usize`
+ //~| expected isize
+ //~| found usize
}
pub fn main() {
// *const -> *mut
let x: *const isize = &42is;
- let x: *mut isize = x; //~ERROR values differ in mutability
+ let x: *mut isize = x; //~ ERROR mismatched types
+ //~| expected `*mut isize`
+ //~| found `*const isize`
+ //~| values differ in mutability
// & -> *mut
- let x: *mut isize = &42; //~ERROR values differ in mutability
+ let x: *mut isize = &42; //~ ERROR mismatched types
+ //~| expected `*mut isize`
+ //~| found `&isize`
+ //~| values differ in mutability
let x: *const isize = &42;
- let x: *mut isize = x; //~ERROR values differ in mutability
+ let x: *mut isize = x; //~ ERROR mismatched types
+ //~| expected `*mut isize`
+ //~| found `*const isize`
+ //~| values differ in mutability
}
x: &'a mut &'a isize
}
-pub trait Foo<'a> {
+pub trait Foo<'a, 't> {
fn no_bound<'b>(self, b: Inv<'b>);
fn has_bound<'b:'a>(self, b: Inv<'b>);
fn wrong_bound1<'b,'c,'d:'a+'b>(self, b: Inv<'b>, c: Inv<'c>, d: Inv<'d>);
- fn wrong_bound2<'b,'c,'d:'a+'b+'c>(self, b: Inv<'b>, c: Inv<'c>, d: Inv<'d>);
+ fn okay_bound<'b,'c,'d:'a+'b+'c>(self, b: Inv<'b>, c: Inv<'c>, d: Inv<'d>);
+ fn another_bound<'x: 'a>(self, x: Inv<'x>);
}
-impl<'a> Foo<'a> for &'a isize {
+impl<'a, 't> Foo<'a, 't> for &'a isize {
fn no_bound<'b:'a>(self, b: Inv<'b>) {
//~^ ERROR lifetime parameters or bounds on method `no_bound` do not match
}
// cases.
}
- fn wrong_bound2<'b,'c,'e:'b+'c>(self, b: Inv<'b>, c: Inv<'c>, e: Inv<'e>) {
- //~^ ERROR distinct set of bounds from its counterpart
+ fn okay_bound<'b,'c,'e:'b+'c>(self, b: Inv<'b>, c: Inv<'c>, e: Inv<'e>) {
}
+
+ fn another_bound<'x: 't>(self, x: Inv<'x>) {}
}
fn main() { }
struct a_class<'a> { x:&'a isize }
fn a_fn1<'a,'b>(e: an_enum<'a>) -> an_enum<'b> {
- return e; //~ ERROR mismatched types: expected `an_enum<'b>`, found `an_enum<'a>`
+ return e; //~ ERROR mismatched types
+ //~| expected `an_enum<'b>`
+ //~| found `an_enum<'a>`
+ //~| lifetime mismatch
}
fn a_fn3<'a,'b>(e: a_class<'a>) -> a_class<'b> {
- return e; //~ ERROR mismatched types: expected `a_class<'b>`, found `a_class<'a>`
+ return e; //~ ERROR mismatched types
+ //~| expected `a_class<'b>`
+ //~| found `a_class<'a>`
+ //~| lifetime mismatch
}
fn main() { }
impl<'a> Box<'a> {
fn or<'b,G:GetRef<'b>>(&self, g2: G) -> &'a isize {
- g2.get() //~ ERROR cannot infer an appropriate lifetime for automatic coercion due to
+ g2.get()
+ //~^ ERROR cannot infer an appropriate lifetime for automatic coercion due to
+ //~| ERROR mismatched types
+ //~| expected `&'a isize`
+ //~| found `&'b isize`
+ //~| lifetime mismatch
+
}
}
}
fn get<'a,'b,G:GetRef<'a, isize>>(g1: G, b: &'b isize) -> &'b isize {
- g1.get() //~ ERROR cannot infer an appropriate lifetime for automatic coercion due to
+ g1.get()
+ //~^ ERROR cannot infer an appropriate lifetime for automatic coercion due to
+ //~| ERROR mismatched types
+ //~| expected `&'b isize`
+ //~| found `&'a isize`
+ //~| lifetime mismatch
}
fn main() {
fn supply_G() {
want_G(foo);
want_G(bar);
- want_G(baz); //~ ERROR expected concrete lifetime
+ want_G(baz);
+ //~^ ERROR mismatched types
+ //~| expected `fn(&'cx S) -> &'static S`
+ //~| found `fn(&S) -> &S {baz}`
+ //~| expected concrete lifetime
+ //~| found bound lifetime parameter 'cx
}
pub fn main() {
fn set_f_bad(&mut self, b: Box<b>) {
self.f = b;
- //~^ ERROR mismatched types: expected `Box<Box<&'a isize>>`, found `Box<Box<&isize>>`
+ //~^ ERROR mismatched types
+ //~| expected `Box<Box<&'a isize>>`
+ //~| found `Box<Box<&isize>>`
+ //~| lifetime mismatch
}
}
let n = 1;
let a = [0; n]; //~ ERROR expected constant integer for repeat count, found variable
let b = [0; ()];
-//~^ ERROR expected constant integer for repeat count, found non-constant expression
-//~^^ ERROR: expected `usize`, found `()`
- let c = [0; true]; //~ ERROR expected positive integer for repeat count, found boolean
- //~^ ERROR: expected `usize`, found `bool`
- let d = [0; 0.5]; //~ ERROR expected positive integer for repeat count, found float
- //~^ ERROR: expected `usize`, found `_`
- let e = [0; "foo"]; //~ ERROR expected positive integer for repeat count, found string
- //~^ ERROR: expected `usize`, found `&'static str`
+//~^ ERROR mismatched types
+//~| expected `usize`
+//~| found `()`
+//~| expected usize
+//~| found ()
+//~| ERROR expected constant integer for repeat count, found non-constant expression
+ let c = [0; true];
+ //~^ ERROR mismatched types
+ //~| expected `usize`
+ //~| found `bool`
+ //~| expected usize
+ //~| found bool
+ //~| ERROR expected positive integer for repeat count, found boolean
+ let d = [0; 0.5];
+ //~^ ERROR mismatched types
+ //~| expected `usize`
+ //~| found `_`
+ //~| expected usize
+ //~| found floating-point variable
+ //~| ERROR expected positive integer for repeat count, found float
+ let e = [0; "foo"];
+ //~^ ERROR mismatched types
+ //~| expected `usize`
+ //~| found `&'static str`
+ //~| expected usize
+ //~| found &-ptr
+ //~| ERROR expected positive integer for repeat count, found string
let f = [0; -4];
//~^ ERROR expected positive integer for repeat count, found negative integer
let f = [0us; -1];
// Type of the result follows the LHS, not the RHS:
let _: i32 = 22_i64 >> 1_i32;
- //~^ ERROR mismatched types: expected `i32`, found `i64`
+ //~^ ERROR mismatched types
+ //~| expected `i32`
+ //~| found `i64`
+ //~| expected i32
+ //~| found i64)
}
fn main() {
fn main() {
match Foo(1.1) {
1 => {}
- //~^ ERROR expected `Foo<_, _>`, found `_`
+ //~^ ERROR mismatched types
+ //~| expected `Foo<_, _>`
+ //~| found `_`
+ //~| expected struct `Foo`
+ //~| found integral variable
}
}
fn main() {
let x = ATOMIC_BOOL_INIT;
let x = *&x; //~ ERROR: cannot move out of borrowed content
- let x = ATOMIC_INT_INIT;
+ let x = ATOMIC_ISIZE_INIT;
let x = *&x; //~ ERROR: cannot move out of borrowed content
- let x = ATOMIC_UINT_INIT;
+ let x = ATOMIC_USIZE_INIT;
let x = *&x; //~ ERROR: cannot move out of borrowed content
let x: AtomicPtr<usize> = AtomicPtr::new(ptr::null_mut());
let x = *&x; //~ ERROR: cannot move out of borrowed content
struct Bar { x: isize }
static bar: Bar = Bar { x: 5 };
-static foo: Foo = Foo { a: 2, ..bar }; //~ ERROR mismatched types: expected `Foo`, found `Bar`
-static foo_i: Foo = Foo { a: 2, ..4 }; //~ ERROR mismatched types: expected `Foo`
+static foo: Foo = Foo { a: 2, ..bar }; //~ ERROR mismatched types
+ //~| expected `Foo`
+ //~| found `Bar`
+ //~| expected struct `Foo`
+ //~| found struct `Bar`
+static foo_i: Foo = Foo { a: 2, ..4 }; //~ ERROR mismatched types
+ //~| expected `Foo`
+ //~| found `_`
+ //~| expected struct `Foo`
+ //~| found integral variable
fn main() {
let b = Bar { x: 5 };
- let f = Foo { a: 2, ..b }; //~ ERROR mismatched types: expected `Foo`, found `Bar`
- let f_i = Foo { a: 2, ..4 }; //~ ERROR mismatched types: expected `Foo`
+ let f = Foo { a: 2, ..b }; //~ ERROR mismatched types
+ //~| expected `Foo`
+ //~| found `Bar`
+ //~| expected struct `Foo`
+ //~| found struct `Bar`
+ let f_i = Foo { a: 2, ..4 }; //~ ERROR mismatched types
+ //~| expected `Foo`
+ //~| found `_`
+ //~| expected struct `Foo`
+ //~| found integral variable
}
fn main() {
let pt = PointF {
- //~^ ERROR expected f32, found isize
+ //~^ ERROR structure constructor specifies a structure of type
+ //~| expected f32
+ //~| found isize
x: 1is,
y: 2is,
};
let pt2 = Point::<f32> {
- //~^ ERROR expected f32, found isize
+ //~^ ERROR structure constructor specifies a structure of type
+ //~| expected f32
+ //~| found isize
x: 3is,
y: 4is,
};
let pair = PairF {
- //~^ ERROR expected f32, found isize
+ //~^ ERROR structure constructor specifies a structure of type
+ //~| expected f32
+ //~| found isize
x: 5is,
y: 6is,
};
let pair2 = PairF::<isize> {
- //~^ ERROR expected f32, found isize
+ //~^ ERROR structure constructor specifies a structure of type
+ //~| expected f32
+ //~| found isize
x: 7is,
y: 8is,
};
fn main() {
let (x, y) = ();
-//~^ ERROR expected `()`, found `(_, _)` (expected (), found tuple)
+//~^ ERROR mismatched types
+//~| expected `()`
+//~| found `(_, _)`
+//~| expected ()
+//~| found tuple
return x;
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// error-pattern:mismatched types: expected `char`, found
// Issue #876
#![no_implicit_prelude]
fn main() {
let y;
let x : char = last(y);
+ //~^ ERROR mismatched types
+ //~| expected `char`
+ //~| found `core::option::Option<_>`
+ //~| expected char
+ //~| found enum `core::option::Option`
}
fn want_foo(f: foo) {}
fn have_bar(b: bar) {
- want_foo(b); //~ ERROR (expected struct foo, found struct bar)
+ want_foo(b); //~ ERROR mismatched types
+ //~| expected `foo`
+ //~| found `bar`
+ //~| expected struct `foo`
+ //~| found struct `bar`
}
fn main() {}
fn want_foo(f: foo) {}
fn have_bar(b: bar) {
- want_foo(b); //~ ERROR (expected struct foo, found box)
+ want_foo(b); //~ ERROR mismatched types
+ //~| expected `foo`
+ //~| found `Box<foo>`
+ //~| expected struct `foo`
+ //~| found box
}
fn main() {}
}
fn d(x: Box<Foo>) {
- a(x); //~ ERROR found no bounds
+ a(x); //~ ERROR mismatched types
+ //~| expected `Box<Foo + Send>`
+ //~| found `Box<Foo>`
+ //~| expected bounds `Send`
+ //~| found no bounds
}
fn main() { }
impl Foo for isize {
// invalid bound for T, was defined as Eq in trait
fn test_error1_fn<T: Ord>(&self) {}
- //~^ ERROR in method `test_error1_fn`, type parameter 0 requires bound `core::cmp::Ord`
+ //~^ ERROR the requirement `T : core::cmp::Ord` appears on the impl
// invalid bound for T, was defined as Eq + Ord in trait
fn test_error2_fn<T: Eq + B>(&self) {}
- //~^ ERROR in method `test_error2_fn`, type parameter 0 requires bound `B`
+ //~^ ERROR the requirement `T : B` appears on the impl
// invalid bound for T, was defined as Eq + Ord in trait
fn test_error3_fn<T: B + Eq>(&self) {}
- //~^ ERROR in method `test_error3_fn`, type parameter 0 requires bound `B`
+ //~^ ERROR the requirement `T : B` appears on the impl
// multiple bounds, same order as in trait
fn test3_fn<T: Ord + Eq>(&self) {}
// parameters in impls must be equal or more general than in the defining trait
fn test_error5_fn<T: B>(&self) {}
- //~^ ERROR in method `test_error5_fn`, type parameter 0 requires bound `B`
+ //~^ ERROR the requirement `T : B` appears on the impl
// bound `std::cmp::Eq` not enforced by this implementation, but this is OK
fn test6_fn<T: A>(&self) {}
fn test_error7_fn<T: A + Eq>(&self) {}
- //~^ ERROR in method `test_error7_fn`, type parameter 0 requires bound `core::cmp::Eq`
+ //~^ ERROR the requirement `T : core::cmp::Eq` appears on the impl
fn test_error8_fn<T: C>(&self) {}
- //~^ ERROR in method `test_error8_fn`, type parameter 0 requires bound `C`
+ //~^ ERROR the requirement `T : C` appears on the impl
}
impl Trait for usize {
fn method<G: Getter<usize>>() {}
- //~^ ERROR in method `method`, type parameter 0 requires bound `Getter<usize>`
+ //~^ G : Getter<usize>` appears on the impl method but not on the corresponding trait method
}
fn main() {}
-
impl<A, T: Iterator<A>> IteratorUtil<A> for T {
fn zip<B, U: Iterator<B>>(self, other: U) -> ZipIterator<T, U> {
- //~^ ERROR in method `zip`, type parameter 1 requires bound `Iterator<B>`
+ //~^ ERROR the requirement `U : Iterator<B>` appears on the impl method
ZipIterator{a: self, b: other}
}
}
fn main() {
let y = first ((1,2.0,3));
- //~^ ERROR expected a tuple with 2 elements, found one with 3 elements
+ //~^ ERROR mismatched types
+ //~| expected `(isize, f64)`
+ //~| found `(isize, f64, _)`
+ //~| expected a tuple with 2 elements
+ //~| found one with 3 elements
let y = first ((1,));
- //~^ ERROR expected `(isize, f64)`, found `(isize,)`
+ //~^ ERROR mismatched types
+ //~| expected `(isize, f64)`
+ //~| found `(isize,)`
+ //~| expected a tuple with 2 elements
+ //~| found one with 1 elements
}
identity_u8(x); // after this, `x` is assumed to have type `u8`
identity_u16(x);
- //~^ ERROR mismatched types: expected `u16`, found `u8`
+ //~^ ERROR mismatched types
+ //~| expected `u16`
+ //~| found `u8`
+ //~| expected u16
+ //~| found u8
identity_u16(y);
- //~^ ERROR mismatched types: expected `u16`, found `i32`
+ //~^ ERROR mismatched types
+ //~| expected `u16`
+ //~| found `i32`
+ //~| expected u16
+ //~| found i32
let a = 3is;
identity_i(a); // ok
identity_u16(a);
- //~^ ERROR mismatched types: expected `u16`, found `isize`
+ //~^ ERROR mismatched types
+ //~| expected `u16`
+ //~| found `isize`
+ //~| expected u16
+ //~| found isize
}
// except according to those terms.
// Checking that the compiler reports multiple type errors at once
-// error-pattern:mismatched types: expected `bool`
-// error-pattern:mismatched types: expected `isize`
fn main() { let a: bool = 1is; let b: isize = true; }
+//~^ ERROR mismatched types
+//~| expected `bool`
+//~| found `isize`
+//~| expected bool
+//~| found isize
+//~| ERROR mismatched types
+//~| expected `isize`
+//~| found `bool`
+//~| expected isize
+//~| found bool
fn foo<Foo, Bar>(x: Foo) -> Bar {
x
-//~^ ERROR expected `Bar`, found `Foo` (expected type parameter, found a different type parameter)
+//~^ ERROR mismatched types
+//~| expected `Bar`
+//~| found `Foo`
+//~| expected type parameter
+//~| found a different type parameter
}
fn main() {}
trait BrokenAdd: Int {
fn broken_add<T>(&self, rhs: T) -> Self {
- *self + rhs //~ ERROR expected `Self`, found `T`
+ *self + rhs //~ ERROR mismatched types
+ //~| expected `Self`
+ //~| found `T`
+ //~| expected Self
+ //~| found type parameter
}
}
fn test1() {
let x: Foo<_> = Bar::<usize>;
- //~^ ERROR mismatched types: expected `Foo<_>`, found `Bar<usize>`
+ //~^ ERROR mismatched types
+ //~| expected `Foo<_>`
+ //~| found `Bar<usize>`
+ //~| expected struct `Foo`
+ //~| found struct `Bar`
let y: Foo<usize> = x;
}
fn test2() {
let x: Foo<_> = Bar::<usize>;
- //~^ ERROR mismatched types: expected `Foo<_>`, found `Bar<usize>`
+ //~^ ERROR mismatched types
+ //~| expected `Foo<_>`
+ //~| found `Bar<usize>`
+ //~| expected struct `Foo`
+ //~| found struct `Bar`
}
impl<'a, T> SomeTrait for &'a Bar<T> {
fn dummy1(self: &&'a Bar<T>) { }
fn dummy2(self: &Bar<T>) {} //~ ERROR mismatched self type
- fn dummy3(self: &&Bar<T>) {} //~ ERROR lifetime mismatch
- //~^ ERROR lifetime mismatch
+ fn dummy3(self: &&Bar<T>) {}
+ //~^ ERROR mismatched types
+ //~| expected `&'a Bar<T>`
+ //~| found `&Bar<T>`
+ //~| lifetime mismatch
+ //~| ERROR mismatched types
+ //~| expected `&'a Bar<T>`
+ //~| found `&Bar<T>`
+ //~| lifetime mismatch
}
fn main() {
--- /dev/null
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::borrow::IntoCow;
+
+fn main() {
+ <String as IntoCow>::into_cow("foo".to_string());
+ //~^ ERROR wrong number of type arguments: expected 2, found 0
+}
+
--- /dev/null
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::ops::Add;
+
+fn main() {
+ <i32 as Add<u32>>::add(1, 2);
+ //~^ ERROR the trait `core::ops::Add<u32>` is not implemented for the type `i32`
+ <i32 as Add<i32>>::add(1u32, 2);
+ //~^ ERROR mismatched types
+ <i32 as Add<i32>>::add(1, 2u32);
+ //~^ ERROR mismatched types
+}
+
foo(1); //~ ERROR: this function takes at least 2 parameters but 1 parameter was supplied
let x: unsafe extern "C" fn(f: isize, x: u8) = foo;
- //~^ ERROR: mismatched types: expected `unsafe extern "C" fn(isize, u8)`
- // , found `unsafe extern "C" fn(isize, u8, ...)`
- // (expected non-variadic fn, found variadic function)
+ //~^ ERROR: mismatched types
+ //~| expected `unsafe extern "C" fn(isize, u8)`
+ //~| found `unsafe extern "C" fn(isize, u8, ...)`
+ //~| expected non-variadic fn
+ //~| found variadic function
let y: unsafe extern "C" fn(f: isize, x: u8, ...) = bar;
- //~^ ERROR: mismatched types: expected `unsafe extern "C" fn(isize, u8, ...)`
- // , found `extern "C" extern fn(isize, u8)`
- // (expected variadic fn, found non-variadic function)
+ //~^ ERROR: mismatched types
+ //~| expected `unsafe extern "C" fn(isize, u8, ...)`
+ //~| found `extern "C" fn(isize, u8) {bar}`
+ //~| expected variadic fn
+ //~| found non-variadic function
foo(1, 2, 3f32); //~ ERROR: can't pass an f32 to variadic function, cast to c_double
foo(1, 2, true); //~ ERROR: can't pass bool to variadic function, cast to c_int
type Output = Vec1;
fn mul(self, s: &f64) -> Vec1 {
- //~^ ERROR: method `mul` has an incompatible type for trait: expected f64, found &-ptr
+ //~^ ERROR method `mul` has an incompatible type for trait
Vec1 {
x: self.x * *s
}
type Output = f64;
fn mul(self, s: f64) -> Vec2 {
- //~^ ERROR: method `mul` has an incompatible type for trait: expected struct Vec2, found f64
+ //~^ ERROR method `mul` has an incompatible type for trait
Vec2 {
x: self.x * s,
y: self.y * s
type Output = i32;
fn mul(self, s: f64) -> f64 {
- //~^ ERROR: method `mul` has an incompatible type for trait: expected i32, found f64
+ //~^ ERROR method `mul` has an incompatible type for trait
s
}
}
let x: Vec2 = Vec2 { x: 1.0, y: 2.0 } * 2.0; // trait had reversed order
//~^ ERROR mismatched types
- //~^^ ERROR mismatched types
+ //~| expected `Vec2`
+ //~| found `_`
+ //~| expected struct `Vec2`
+ //~| found floating-point variable
+ //~| ERROR mismatched types
+ //~| expected `Vec2`
+ //~| found `f64`
+ //~| expected struct `Vec2`
+ //~| found f64
let x: i32 = Vec3 { x: 1.0, y: 2.0, z: 3.0 } * 2.0;
}
--- /dev/null
+// Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// ignore-android: FIXME(#10381)
+// min-lldb-version: 310
+
+// compile-flags:-g
+
+struct Peekable<I> where I: Iterator {
+ _iter: I,
+ _next: Option<<I as Iterator>::Item>,
+}
+
+fn main() {
+ let mut iter = Vec::<i32>::new().into_iter();
+ let next = iter.next();
+ let _v = Peekable {
+ _iter: iter,
+ _next : next,
+ };
+}
use rustc::session::{build_session, Session};
use rustc::session::config::{basic_options, build_configuration, Input, OutputTypeExe};
-use rustc_driver::driver::{compile_input};
+use rustc_driver::driver::{compile_input, CompileController};
use syntax::diagnostics::registry::Registry;
fn main() {
fn compile(code: String, output: Path, sysroot: Path) {
let sess = basic_sess(sysroot);
let cfg = build_configuration(&sess);
+ let control = CompileController::basic();
compile_input(sess,
cfg,
&Input::Str(code),
&None,
&Some(output),
- None);
+ None,
+ control);
}
-// Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2013-2015 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
#[derive(PartialEq, Clone, Show)]
fn foo() -> AFakeTypeThatHadBetterGoAway {}
+#[into_multi_foo]
+#[derive(PartialEq, Clone, Show)]
+fn foo() -> AnotherFakeTypeThatHadBetterGoAway {}
+
+trait Qux {
+ #[into_multi_foo]
+ fn bar();
+}
+
+impl Qux for i32 {
+ #[into_multi_foo]
+ fn bar() {}
+}
+
+impl Qux for u8 {}
+
pub fn main() {
assert_eq!(1, make_a_1!());
assert_eq!(2, exported_macro!());
assert_eq!(Foo::Bar, Foo::Bar);
test(None::<Foo>);
+
+ assert_eq!(Foo2::Bar2, Foo2::Bar2);
+ test(None::<Foo2>);
+
+ let x = 10i32;
+ assert_eq!(x.foo(), 42);
+ let x = 10u8;
+ assert_eq!(x.foo(), 0);
}
fn test<T: PartialEq+Clone>(_: Option<T>) {}
--- /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.
+
+// Test associated types appearing in struct-like enum variants.
+
+use self::VarValue::*;
+
+pub trait UnifyKey {
+ type Value;
+ fn to_index(&self) -> usize;
+}
+
+pub enum VarValue<K:UnifyKey> {
+ Redirect { to: K },
+ Root { value: K::Value, rank: usize },
+}
+
+fn get<'a,K:UnifyKey<Value=Option<V>>,V>(table: &'a Vec<VarValue<K>>, key: &K) -> &'a Option<V> {
+ match table[key.to_index()] {
+ VarValue::Redirect { to: ref k } => get(table, k),
+ VarValue::Root { value: ref v, rank: _ } => v,
+ }
+}
+
+impl UnifyKey for usize {
+ type Value = Option<char>;
+ fn to_index(&self) -> usize { *self }
+}
+
+fn main() {
+ let table = vec![/* 0 */ Redirect { to: 1 },
+ /* 1 */ Redirect { to: 3 },
+ /* 2 */ Root { value: Some('x'), rank: 0 },
+ /* 3 */ Redirect { to: 2 }];
+ assert_eq!(get(&table, &0), &Some('x'));
+}
--- /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.
+
+// Test associated types appearing in tuple-like enum variants.
+
+use self::VarValue::*;
+
+pub trait UnifyKey {
+ type Value;
+ fn to_index(&self) -> usize;
+}
+
+pub enum VarValue<K:UnifyKey> {
+ Redirect(K),
+ Root(K::Value, usize),
+}
+
+fn get<'a,K:UnifyKey<Value=Option<V>>,V>(table: &'a Vec<VarValue<K>>, key: &K) -> &'a Option<V> {
+ match table[key.to_index()] {
+ VarValue::Redirect(ref k) => get(table, k),
+ VarValue::Root(ref v, _) => v,
+ }
+}
+
+impl UnifyKey for usize {
+ type Value = Option<char>;
+ fn to_index(&self) -> usize { *self }
+}
+
+fn main() {
+ let table = vec![/* 0 */ Redirect(1),
+ /* 1 */ Redirect(3),
+ /* 2 */ Root(Some('x'), 0),
+ /* 3 */ Redirect(2)];
+ assert_eq!(get(&table, &0), &Some('x'));
+}
--- /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.
+
+// Test a where clause that uses a non-normalized projection type.
+
+trait Int
+{
+ type T;
+}
+
+trait NonZero
+{
+ fn non_zero(self) -> bool;
+}
+
+fn foo<I:Int<T=J>,J>(t: I) -> bool
+ where <I as Int>::T : NonZero
+ // ^~~~~~~~~~~~~ canonical form is just J
+{
+ bar::<J>()
+}
+
+fn bar<NZ:NonZero>() -> bool { true }
+
+fn main ()
+{
+}
--- /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.
+
+// Test that we correctly normalize the type of a struct field
+// which has an associated type.
+
+pub trait UnifyKey {
+ type Value;
+}
+
+pub struct Node<K:UnifyKey> {
+ pub key: K,
+ pub value: K::Value,
+}
+
+fn foo<K : UnifyKey<Value=Option<V>>,V : Clone>(node: &Node<K>) -> Option<V> {
+ node.value.clone()
+}
+
+impl UnifyKey for i32 {
+ type Value = Option<u32>;
+}
+
+impl UnifyKey for u32 {
+ type Value = Option<i32>;
+}
+
+pub fn main() {
+ let node: Node<i32> = Node { key: 1, value: Some(22) };
+ assert_eq!(foo(&node), Some(22_u32));
+
+ let node: Node<u32> = Node { key: 1, value: Some(22) };
+ assert_eq!(foo(&node), Some(22_i32));
+}
--- /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.
+
+// Test that we correctly normalize the type of a struct field
+// which has an associated type.
+
+pub trait UnifyKey {
+ type Value;
+}
+
+pub struct Node<K:UnifyKey>(K, K::Value);
+
+fn foo<K : UnifyKey<Value=Option<V>>,V : Clone>(node: &Node<K>) -> Option<V> {
+ node.1.clone()
+}
+
+impl UnifyKey for i32 {
+ type Value = Option<u32>;
+}
+
+impl UnifyKey for u32 {
+ type Value = Option<i32>;
+}
+
+pub fn main() {
+ let node: Node<i32> = Node(1, Some(22));
+ assert_eq!(foo(&node), Some(22_u32));
+
+ let node: Node<u32> = Node(1, Some(22));
+ assert_eq!(foo(&node), Some(22_i32));
+}
// ignore-windows FIXME #13259
#![feature(unboxed_closures)]
+#![feature(unsafe_destructor)]
use std::os;
use std::io::process::Command;
-use std::finally::Finally;
use std::str;
+use std::ops::{Drop, FnMut, FnOnce};
#[inline(never)]
fn foo() {
#[inline(never)]
fn double() {
- (|&mut:| {
- panic!("once");
- }).finally(|| {
- panic!("twice");
- })
+ struct Double;
+
+ impl Drop for Double {
+ fn drop(&mut self) { panic!("twice") }
+ }
+
+ let _d = Double;
+
+ panic!("once");
}
fn runtest(me: &str) {
let _: &Fn(int) -> _ = &{ |x| (x as u8) };
let _: &Show = &if true { false } else { true };
let _: &Show = &match true { true => 'a', false => 'b' };
+
+ let _: Box<[int]> = Box::new([1, 2, 3]);
+ let _: Box<Fn(int) -> _> = Box::new(|x| (x as u8));
}
--- /dev/null
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// Check that coercions unify the expected return type of a polymorphic
+// function call, instead of leaving the type variables as they were.
+
+struct Foo;
+impl Foo {
+ fn foo<T>(self, x: T) -> Option<T> { Some(x) }
+}
+
+pub fn main() {
+ let _: Option<fn()> = Some(main);
+ let _: Option<fn()> = Foo.foo(main);
+
+ // The same two cases, with implicit type variables made explicit.
+ let _: Option<fn()> = Some::<_>(main);
+ let _: Option<fn()> = Foo.foo::<_>(main);
+}
#![feature(macro_rules)]
+use std::borrow::{Cow, IntoCow};
use std::collections::Bitv;
use std::default::Default;
use std::iter::FromIterator;
+use std::ops::Add;
use std::option::IntoIter as OptionIter;
use std::rand::Rand;
use std::rand::XorShiftRng as DummyRng;
fn odd(x: uint) -> bool { x % 2 == 1 }
fn dummy_rng() -> DummyRng { DummyRng::new_unseeded() }
+trait Size: Sized {
+ fn size() -> uint { std::mem::size_of::<Self>() }
+}
+impl<T> Size for T {}
+
macro_rules! tests {
($($expr:expr, $ty:ty, ($($test:expr),*);)+) => (pub fn main() {$({
const C: $ty = $expr;
// , (vec![b'f', b'o', b'o'], u8_as_i8);
// Trait static methods.
- // FIXME qualified path expressions aka UFCS i.e. <T as Trait>::method.
+ <bool as Size>::size, fn() -> uint, ();
Default::default, fn() -> int, ();
+ <int as Default>::default, fn() -> int, ();
Rand::rand, fn(&mut DummyRng) -> int, (&mut dummy_rng());
+ <int as Rand>::rand, fn(&mut DummyRng) -> int, (&mut dummy_rng());
Rand::rand::<DummyRng>, fn(&mut DummyRng) -> int, (&mut dummy_rng());
+ <int as Rand>::rand::<DummyRng>, fn(&mut DummyRng) -> int, (&mut dummy_rng());
// Trait non-static methods.
Clone::clone, fn(&int) -> int, (&5);
+ <int as Clone>::clone, fn(&int) -> int, (&5);
FromIterator::from_iter, fn(OptionIter<int>) -> Vec<int>, (Some(5).into_iter());
- FromIterator::from_iter::<OptionIter<int>>, fn(OptionIter<int>) -> Vec<int>
- , (Some(5).into_iter());
+ <Vec<_> as FromIterator<_>>::from_iter, fn(OptionIter<int>) -> Vec<int>,
+ (Some(5).into_iter());
+ <Vec<int> as FromIterator<_>>::from_iter, fn(OptionIter<int>) -> Vec<int>,
+ (Some(5).into_iter());
+ FromIterator::from_iter::<OptionIter<int>>, fn(OptionIter<int>) -> Vec<int>,
+ (Some(5).into_iter());
+ <Vec<int> as FromIterator<_>>::from_iter::<OptionIter<int>>, fn(OptionIter<int>) -> Vec<int>,
+ (Some(5).into_iter());
+ Add::add, fn(i32, i32) -> i32, (5, 6);
+ <i32 as Add<_>>::add, fn(i32, i32) -> i32, (5, 6);
+ <i32 as Add<i32>>::add, fn(i32, i32) -> i32, (5, 6);
+ <String as IntoCow<_, _>>::into_cow, fn(String) -> Cow<'static, String, str>,
+ ("foo".to_string());
+ <String as IntoCow<'static, _, _>>::into_cow, fn(String) -> Cow<'static, String, str>,
+ ("foo".to_string());
}
let ss: &&[int] = &s;
let sss: &&&[int] = &ss;
- println!("{:?}", &s[0..3]);
+ println!("{:?}", &s[..3]);
println!("{:?}", &ss[3..]);
println!("{:?}", &sss[2..4]);
}
extern crate "issue-17718" as other;
-use std::sync::atomic::{AtomicUint, ATOMIC_UINT_INIT, Ordering};
+use std::sync::atomic::{AtomicUsize, ATOMIC_USIZE_INIT, Ordering};
const C1: uint = 1;
-const C2: AtomicUint = ATOMIC_UINT_INIT;
+const C2: AtomicUsize = ATOMIC_USIZE_INIT;
const C3: fn() = foo;
const C4: uint = C1 * C1 + C1 / C1;
const C5: &'static uint = &C4;
};
static S1: uint = 3;
-static S2: AtomicUint = ATOMIC_UINT_INIT;
+static S2: AtomicUsize = ATOMIC_USIZE_INIT;
mod test {
static A: uint = 4;
--- /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.
+
+// Test that overloaded calls work with zero arity closures
+
+#![feature(box_syntax)]
+
+fn main() {
+ let functions: [Box<Fn() -> Option<()>>; 1] = [box || None];
+
+ let _: Option<Vec<()>> = functions.iter().map(|f| (*f)()).collect();
+}
let abc = [1i, 2, 3];
let tf = [true, false];
let x = [(), ()];
- let slice = &x[0..1];
+ let slice = &x[..1];
assert_repr_eq(&abc[], "[1i, 2i, 3i]".to_string());
assert_repr_eq(&tf[], "[true, false]".to_string());
let cmp: &[int] = &[3, 4, 5];
assert!(&x[2..] == cmp);
let cmp: &[int] = &[1, 2, 3];
- assert!(&x[0..3] == cmp);
+ assert!(&x[..3] == cmp);
let cmp: &[int] = &[2, 3, 4];
assert!(&x[1..4] == cmp);
let cmp: &[int] = &[3, 4, 5];
assert!(&x[2..] == cmp);
let cmp: &[int] = &[1, 2, 3];
- assert!(&x[0..3] == cmp);
+ assert!(&x[..3] == cmp);
let cmp: &[int] = &[2, 3, 4];
assert!(&x[1..4] == cmp);
use std::io::{TcpListener, Listener, Acceptor, EndOfFile, TcpStream};
use std::sync::Arc;
-use std::sync::atomic::{AtomicUint, Ordering};
+use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::mpsc::channel;
use std::thread::Thread;
let mut l = TcpListener::bind("127.0.0.1:0").unwrap();
let addr = l.socket_name().unwrap();
let mut a = l.listen().unwrap();
- let cnt = Arc::new(AtomicUint::new(0));
+ let cnt = Arc::new(AtomicUsize::new(0));
let (srv_tx, srv_rx) = channel();
let (cli_tx, cli_rx) = channel();
--- /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.
+
+// Test that we do not error out because of a (False) ambiguity
+// between the builtin rules for Sized and the where clause. Issue
+// #20959.
+
+fn foo<K>(x: Option<K>)
+ where Option<K> : Sized
+{
+ let _y = x;
+}
+
+fn main() {
+ foo(Some(22));
+}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::sync::atomic::{AtomicUint, ATOMIC_UINT_INIT, Ordering};
+use std::sync::atomic::{AtomicUsize, ATOMIC_USIZE_INIT, Ordering};
use std::rand::{thread_rng, Rng, Rand};
use std::thread::Thread;
const REPEATS: uint = 5;
const MAX_LEN: uint = 32;
-static drop_counts: [AtomicUint; MAX_LEN] =
- // FIXME #5244: AtomicUint is not Copy.
+static drop_counts: [AtomicUsize; MAX_LEN] =
+ // FIXME #5244: AtomicUsize is not Copy.
[
- ATOMIC_UINT_INIT, ATOMIC_UINT_INIT, ATOMIC_UINT_INIT, ATOMIC_UINT_INIT,
- ATOMIC_UINT_INIT, ATOMIC_UINT_INIT, ATOMIC_UINT_INIT, ATOMIC_UINT_INIT,
- ATOMIC_UINT_INIT, ATOMIC_UINT_INIT, ATOMIC_UINT_INIT, ATOMIC_UINT_INIT,
- ATOMIC_UINT_INIT, ATOMIC_UINT_INIT, ATOMIC_UINT_INIT, ATOMIC_UINT_INIT,
-
- ATOMIC_UINT_INIT, ATOMIC_UINT_INIT, ATOMIC_UINT_INIT, ATOMIC_UINT_INIT,
- ATOMIC_UINT_INIT, ATOMIC_UINT_INIT, ATOMIC_UINT_INIT, ATOMIC_UINT_INIT,
- ATOMIC_UINT_INIT, ATOMIC_UINT_INIT, ATOMIC_UINT_INIT, ATOMIC_UINT_INIT,
- ATOMIC_UINT_INIT, ATOMIC_UINT_INIT, ATOMIC_UINT_INIT, ATOMIC_UINT_INIT,
+ ATOMIC_USIZE_INIT, ATOMIC_USIZE_INIT, ATOMIC_USIZE_INIT,
+ ATOMIC_USIZE_INIT, ATOMIC_USIZE_INIT, ATOMIC_USIZE_INIT,
+ ATOMIC_USIZE_INIT, ATOMIC_USIZE_INIT, ATOMIC_USIZE_INIT,
+ ATOMIC_USIZE_INIT, ATOMIC_USIZE_INIT, ATOMIC_USIZE_INIT,
+ ATOMIC_USIZE_INIT, ATOMIC_USIZE_INIT, ATOMIC_USIZE_INIT,
+ ATOMIC_USIZE_INIT, ATOMIC_USIZE_INIT, ATOMIC_USIZE_INIT,
+ ATOMIC_USIZE_INIT, ATOMIC_USIZE_INIT, ATOMIC_USIZE_INIT,
+ ATOMIC_USIZE_INIT, ATOMIC_USIZE_INIT, ATOMIC_USIZE_INIT,
+ ATOMIC_USIZE_INIT, ATOMIC_USIZE_INIT, ATOMIC_USIZE_INIT,
+ ATOMIC_USIZE_INIT, ATOMIC_USIZE_INIT, ATOMIC_USIZE_INIT,
+ ATOMIC_USIZE_INIT, ATOMIC_USIZE_INIT,
];
-static creation_count: AtomicUint = ATOMIC_UINT_INIT;
+static creation_count: AtomicUsize = ATOMIC_USIZE_INIT;
#[derive(Clone, PartialEq, PartialOrd, Eq, Ord)]
struct DropCounter { x: uint, creation_id: uint }
--- /dev/null
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+trait Bound {}
+
+trait Trait {
+ fn a<T>(&self, T) where T: Bound;
+ fn b<T>(&self, T) where T: Bound;
+ fn c<T: Bound>(&self, T);
+ fn d<T: Bound>(&self, T);
+}
+
+impl Trait for bool {
+ fn a<T: Bound>(&self, _: T) {}
+ //^~ This gets rejected but should be accepted
+ fn b<T>(&self, _: T) where T: Bound {}
+ fn c<T: Bound>(&self, _: T) {}
+ fn d<T>(&self, _: T) where T: Bound {}
+}
+
+fn main() {}
projects / rust.git / commitdiff