#
# * `VERBOSE=1` - Print all commands. Use this to see what's going on.
# * `RUSTFLAGS=...` - Add compiler flags to all `rustc` invocations
+# * `JEMALLOC_FLAGS=...` - Pass flags to jemalloc's configure script
#
# * `TESTNAME=...` - Specify the name of tests to run
# * `CHECK_IGNORED=1` - Run normally-ignored tests
| cut -d ' ' -f 2)
case $CFG_CLANG_VERSION in
- (3.0svn | 3.0 | 3.1* | 3.2* | 3.3* | 3.4* | 3.5* )
+ (3.0svn | 3.0 | 3.1* | 3.2* | 3.3* | 3.4* | 3.5* | 3.6*)
step_msg "found ok version of CLANG: $CFG_CLANG_VERSION"
if [ -z "$CC" ]
then
CFG_RUSTC_FLAGS := $(RUSTFLAGS)
CFG_GCCISH_CFLAGS :=
CFG_GCCISH_LINK_FLAGS :=
+CFG_JEMALLOC_FLAGS :=
ifdef CFG_DISABLE_OPTIMIZE
$(info cfg: disabling rustc optimization (CFG_DISABLE_OPTIMIZE))
CFG_RUSTC_FLAGS +=
+ CFG_JEMALLOC_FLAGS += --enable-debug
else
# The rtopt cfg turns off runtime sanity checks
CFG_RUSTC_FLAGS += -O --cfg rtopt
endif
+CFG_JEMALLOC_FLAGS += $(JEMALLOC_FLAGS)
+
ifdef CFG_DISABLE_DEBUG
CFG_RUSTC_FLAGS += --cfg ndebug
CFG_GCCISH_CFLAGS += -DRUST_NDEBUG
$$(JEMALLOC_LOCAL_$(1)): $$(JEMALLOC_DEPS) $$(MKFILE_DEPS)
@$$(call E, make: jemalloc)
cd "$$(JEMALLOC_BUILD_DIR_$(1))"; "$(S)src/jemalloc/configure" \
- $$(JEMALLOC_ARGS_$(1)) --with-jemalloc-prefix=je_ \
+ $$(JEMALLOC_ARGS_$(1)) --with-jemalloc-prefix=je_ $(CFG_JEMALLOC_FLAGS) \
--build=$(CFG_BUILD) --host=$(1) \
CC="$$(CC_$(1))" \
AR="$$(AR_$(1))" \
Could not compile `hello_world`.
```
-Rust will not let us use a value that has not been initialized. So why let us
-declare a binding without initializing it? You'd think our first example would
-have errored. Well, Rust is smarter than that. Before we get to that, let's talk
-about this stuff we've added to `println!`.
+Rust will not let us use a value that has not been initialized. Next, let's
+talk about this stuff we've added to `println!`.
If you include two curly braces (`{}`, some call them moustaches...) in your
string to print, Rust will interpret this as a request to interpolate some sort
available](std/fmt/index.html). For now, we'll just stick to the default:
integers aren't very complicated to print.
-So, we've cleared up all of the confusion around bindings, with one exception:
-why does Rust let us declare a variable binding without an initial value if we
-must initialize the binding before we use it? And how does it know that we have
-or have not initialized the binding? For that, we need to learn our next
-concept: `if`.
-
# If
Rust's take on `if` is not particularly complex, but it's much more like the
This is all pretty standard. However, you can also do this:
-
```
let x = 5i;
% Rust Documentation
-<!-- Completely hide the TOC and the section numbers -->
-<style type="text/css">
-#TOC { display: none; }
-.header-section-number { display: none; }
-li {list-style-type: none; }
-</style>
+Welcome to the Rust documentation! You can use the section headings above
+to jump to any particular section.
+
+# Getting Started
+
+If you haven't seen Rust at all yet, the first thing you should read is the [30
+minute intro](intro.html). It will give you an overview of the basic ideas of Rust
+at a high level.
+
+Once you know you really want to learn Rust, the next step is reading [the
+guide](guide.html). It is a lengthy explanation of Rust, its syntax, and its
+concepts. Upon completing the guide, you'll be an intermediate Rust developer,
+and will have a good grasp of the fundamental ideas behind Rust.
+
+# Community & Getting Help
+
+If you need help with something, or just want to talk about Rust with others,
+there's a few places you can do that:
+
+The Rust IRC channels on [irc.mozilla.org](http://irc.mozilla.org/) are the
+fastest way to get help.
+[`#rust`](http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust) is
+the general discussion channel, and you'll find people willing to help you with
+any questions you may have.
+
+There are also three specialty channels:
+[`#rust-gamedev`](http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-gamedev)
+and
+[`#rust-osdev`](http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-osdev)
+are for game development and operating system development, respectively.
+There's also
+[`#rust-internals`](http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-internals), which is for discussion of the development of Rust itself.
+
+You can also get help on [Stack
+Overflow](http://stackoverflow.com/questions/tagged/rust). Searching for your
+problem might reveal someone who has asked it before!
+
+There is an active [subreddit](http://reddit.com/r/rust) with lots of
+discussion about Rust.
+
+There is also a [developer forum](http://discuss.rust-lang.org/), where the
+development of Rust itself is discussed.
-* [A 30-minute Intro to Rust](intro.html)
-* [The Rust tutorial](tutorial.html) (* [PDF](tutorial.pdf))
-* [The Rust reference manual](rust.html) (* [PDF](rust.pdf))
# Guides
+Rust Guides are in-depth looks at a particular topic that's relevant to Rust
+development. If you're trying to figure out how to do something, there may be
+a guide that can help you out:
+
* [Strings](guide-strings.html)
* [Pointers](guide-pointers.html)
* [References and Lifetimes](guide-lifetimes.html)
* [Testing](guide-testing.html)
* [Rust's Runtime](guide-runtime.html)
+# Tools
+
+Rust's still a young language, so there isn't a ton of tooling yet, but the
+tools we have are really nice.
+
+[Cargo](http://crates.io) is Rust's package manager, and its website contains
+lots of good documentation.
+
+[The `rustdoc` manual](rustdoc.html) contains information about Rust's
+documentation tool.
+
# FAQs
+There are questions that are asked quite often, and so we've made FAQs for them:
+
* [Language Design FAQ](complement-design-faq.html)
* [Language FAQ](complement-lang-faq.html)
* [Project FAQ](complement-project-faq.html)
* [How to submit a bug report](complement-bugreport.html)
-# Libraries
-
-* [The standard library, `std`](std/index.html)
-
-<!-- force the two lists to be separate -->
-
-* [The `arena` allocation library](arena/index.html)
-* [The `collections` library](collections/index.html)
-* [The `flate` compression library](flate/index.html)
-* [The `fourcc` four-character code library](fourcc/index.html)
-* [The `getopts` argument parsing library](getopts/index.html)
-* [The `glob` file path matching library](glob/index.html)
-* [The `green` M:N runtime library](green/index.html)
-* [The `hexfloat` library for hexadecimal floating-point literals](hexfloat/index.html)
-* [The `libc` bindings](libc/index.html)
-* [The `native` 1:1 threading runtime](native/index.html)
-* [The `num` arbitrary precision numerics library](num/index.html)
-* [The `rand` library for random numbers and distributions](rand/index.html)
-* [The `regex` library for regular expressions](regex/index.html)
-* [The `rustc` compiler](rustc/index.html)
-* [The `rustuv` M:N I/O library](rustuv/index.html)
-* [The `semver` version collation library](semver/index.html)
-* [The `serialize` value encoding/decoding library](serialize/index.html)
-* [The `sync` library for concurrency-enabled mechanisms and primitives](sync/index.html)
-* [The `syntax` library, the Rust parser](syntax/index.html)
-* [The `term` terminal-handling library](term/index.html)
-* [The `test` library containing the unit-testing & micro-benchmark framework](test/index.html)
-* [The `time` library](time/index.html)
-* [The `uuid` 128-bit universally unique identifier library](uuid/index.html)
-* [The `url` library](url/index.html)
-* [The `log` library](log/index.html)
-
-# Tooling
-
-* [The `rustdoc` manual](rustdoc.html)
+# The standard library
+
+You can find function-level documentation for the entire standard library
+[here](std/index.html). There's a list of crates on the left with more specific
+sections, or you can use the search bar at the top to search for something if
+you know its name.
# External documentation
-*Note: While these are great resources for learning Rust, they may
-track a particular version of Rust that is likely not exactly the same
-as that for which this documentation was generated.*
+*Note: While these are great resources for learning Rust, they may track a
+particular version of Rust that is likely not exactly the same as that for
+which this documentation was generated.*
-* [Rust for Rubyists] - An excellent introduction for Rust; not just for Rubyists (tracks the most recent release).
-* [Rust by Example] - Short examples of common tasks in Rust (tracks the master branch).
-* [The Rust wiki](http://github.com/rust-lang/rust/wiki)
+* [Rust by Example] - Short examples of common tasks in Rust (tracks the master
+ branch).
+* [Rust for Rubyists] - The first community tutorial for Rust. Tracks the last
+ stable release. Not just for Ruby programmers.
-[Rust for Rubyists]: http://www.rustforrubyists.com/
[Rust by Example]: http://rustbyexample.com/
-
-# Community
-
-* [Reddit](http://reddit.com/r/rust)
-* [Stack Overflow](http://stackoverflow.com/questions/tagged/rust)
-* [Developer Forum](http://discuss.rust-lang.org/)
-* The Rust IRC channels on [irc.mozilla.org](http://irc.mozilla.org/):
- * [`#rust`](http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust) - general discussion
- * [`#rust-gamedev`](http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-gamedev) - game development
- * [`#rust-internals`](http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-internals) - compiler and libraries
- * [`#rust-osdev`](http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-osdev) - operating system development
-
+[Rust for Rubyists]: http://www.rustforrubyists.com/
exactly one argument, while the pattern `C(..)` is type-correct for any enum
variant `C`, regardless of how many arguments `C` has.
-Used inside a vector pattern, `..` stands for any number of elements. This
-wildcard can be used at most once for a given vector, which implies that it
-cannot be used to specifically match elements that are at an unknown distance
-from both ends of a vector, like `[.., 42, ..]`. If followed by a variable name,
-it will bind the corresponding slice to the variable. Example:
+Used inside a vector pattern, `..` stands for any number of elements, when the
+`advanced_slice_patterns` feature gate is turned on. This wildcard can be used
+at most once for a given vector, which implies that it cannot be used to
+specifically match elements that are at an unknown distance from both ends of a
+vector, like `[.., 42, ..]`. If followed by a variable name, it will bind the
+corresponding slice to the variable. Example:
~~~~
+# #![feature(advanced_slice_patterns)]
fn is_symmetric(list: &[uint]) -> bool {
match list {
[] | [_] => true,
- [x, ..inside, y] if x == y => is_symmetric(inside),
+ [x, inside.., y] if x == y => is_symmetric(inside),
_ => false
}
}
assert!(b != "world");
~~~~
-### Vector types
+### Vector, Array, and Slice types
-The vector type constructor represents a homogeneous array of values of a given type.
-A vector has a fixed size.
-(Operations like `vec.push` operate solely on owned vectors.)
-A vector type can be annotated with a _definite_ size, such as `[int, ..10]`.
-Such a definite-sized vector type is a first-class type, since its size is known statically.
-A vector without such a size is said to be of _indefinite_ size,
-and is therefore not a _first-class_ type.
-An indefinite-size vector can only be instantiated through a pointer type,
-such as `&[T]` or `Vec<T>`.
-The kind of a vector type depends on the kind of its element type,
-as with other simple structural types.
+Rust has three different types for a list of items:
-Expressions producing vectors of definite size cannot be evaluated in a
-context expecting a vector of indefinite size; one must copy the
-definite-sized vector contents into a distinct vector of indefinite size.
+* `Vec<T>`, a 'vector'
+* `[T ..N]`, an 'array'
+* `&[T]`, a 'slice'.
-An example of a vector type and its use:
+A vector is a heap-allocated list of `T`. A vector has ownership over the data
+inside of it. It is also able to grow and change in size. It's important to note
+that `Vec<T>` is a library type, it's not actually part of the core language.
-~~~~
-let v: &[int] = &[7, 5, 3];
-let i: int = v[2];
-assert!(i == 3);
-~~~~
+An array has a fixed size, and can be allocated on either the stack or the heap.
+
+A slice is a 'view' into a vector or array. It doesn't own the data it points
+to, it borrows it.
+
+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();
+```
+
+As you can see, the `vec!` macro allows you to create a `Vec<T>` easily. The
+`vec!` macro is also part of the standard library, rather than the language.
-All in-bounds elements of a vector are always initialized,
-and access to a vector is always bounds-checked.
+All in-bounds elements of vectors, arrays, and slices are always initialized,
+and access to a vector, array, or slice is always bounds-checked.
### Structure types
[] => 0,
[a] => a * 10,
[a, b] => a * 6 + b * 4,
- [a, b, c, ..rest] => a * 5 + b * 3 + c * 2 + rest.len() as int
+ [a, b, c, rest..] => a * 5 + b * 3 + c * 2 + rest.len() as int
};
~~~~
"libsync/mpmc_bounded_queue.rs", # BSD
"libsync/mpsc_intrusive.rs", # BSD
"test/bench/shootout-binarytrees.rs", # BSD
+ "test/bench/shootout-chameneos-redux.rs", # BSD
"test/bench/shootout-fannkuch-redux.rs", # BSD
"test/bench/shootout-k-nucleotide.rs", # BSD
"test/bench/shootout-mandelbrot.rs", # BSD
"test/bench/shootout-meteor.rs", # BSD
+ "test/bench/shootout-nbody.rs", # BSD
"test/bench/shootout-pidigits.rs", # BSD
"test/bench/shootout-regex-dna.rs", # BSD
+ "test/bench/shootout-reverse-complement.rs", # BSD
"test/bench/shootout-threadring.rs", # BSD
]
use self::test::Bencher;
use super::{Arena, TypedArena};
+ #[allow(dead_code)]
struct Point {
x: int,
y: int,
})
}
+ #[allow(dead_code)]
struct Noncopy {
string: String,
array: Vec<int>,
}
#[test]
+ #[allow(deprecated)]
fn test_tailn() {
let mut a = vec![11i, 12, 13];
let b: &[int] = &[11, 12, 13];
#[test]
#[should_fail]
+ #[allow(deprecated)]
fn test_tailn_empty() {
let a: Vec<int> = vec![];
a.tailn(2);
#[test]
#[should_fail]
+ #[allow(deprecated)]
fn test_initn_empty() {
let a: Vec<int> = vec![];
a.as_slice().initn(2);
}
#[test]
+ #[allow(deprecated)]
fn test_unshift() {
let mut x = vec![1i, 2, 3];
x.unshift(0);
}
#[test]
+ #[allow(deprecated)]
fn test_shift_ref() {
let mut x: &[int] = [1, 2, 3, 4, 5];
let h = x.shift_ref();
}
#[test]
+ #[allow(deprecated)]
fn test_pop_ref() {
let mut x: &[int] = [1, 2, 3, 4, 5];
let h = x.pop_ref();
}
#[test]
+ #[allow(deprecated)]
fn test_mut_shift_ref() {
let mut x: &mut [int] = [1, 2, 3, 4, 5];
let h = x.mut_shift_ref();
}
#[test]
+ #[allow(deprecated)]
fn test_mut_pop_ref() {
let mut x: &mut [int] = [1, 2, 3, 4, 5];
let h = x.mut_pop_ref();
b.iter(|| {
v.sort();
});
- b.bytes = (v.len() * mem::size_of_val(v.get(0))) as u64;
+ b.bytes = (v.len() * mem::size_of_val(&v[0])) as u64;
}
type BigSortable = (u64,u64,u64,u64);
b.iter(|| {
v.sort();
});
- b.bytes = (v.len() * mem::size_of_val(v.get(0))) as u64;
+ b.bytes = (v.len() * mem::size_of_val(&v[0])) as u64;
}
}
/// Creates a new iterator that produces an infinite sequence of
/// repeated applications of the given function `f`.
#[allow(visible_private_types)]
-pub fn iterate<'a, T: Clone>(f: |T|: 'a -> T, seed: T) -> Iterate<'a, T> {
+pub fn iterate<'a, T: Clone>(seed: T, f: |T|: 'a -> T) -> Iterate<'a, T> {
Unfold::new((f, Some(seed), true), |st| {
let &(ref mut f, ref mut val, ref mut first) = st;
if *first {
*
*/
+use kinds::Sized;
+
/**
*
* The `Drop` trait is used to run some code when a value goes out of scope. This
* ```
*/
#[lang="deref"]
-pub trait Deref<Result> {
+pub trait Deref<Sized? Result> {
/// The method called to dereference a value
fn deref<'a>(&'a self) -> &'a Result;
}
* ```
*/
#[lang="deref_mut"]
-pub trait DerefMut<Result>: Deref<Result> {
+pub trait DerefMut<Sized? Result>: Deref<Result> {
/// The method called to mutably dereference a value
fn deref_mut<'a>(&'a mut self) -> &'a mut Result;
}
}
#[test]
-fn any_as_ref() {
+fn any_downcast_ref() {
let a = &5u as &Any;
- match a.as_ref::<uint>() {
+ match a.downcast_ref::<uint>() {
Some(&5) => {}
x => fail!("Unexpected value {}", x)
}
- match a.as_ref::<Test>() {
+ match a.downcast_ref::<Test>() {
None => {}
x => fail!("Unexpected value {}", x)
}
}
#[test]
-fn any_as_mut() {
+fn any_downcast_mut() {
let mut a = 5u;
let mut b = box 7u;
let tmp: &mut uint = &mut *b;
let b_r = tmp as &mut Any;
- match a_r.as_mut::<uint>() {
+ match a_r.downcast_mut::<uint>() {
Some(x) => {
assert_eq!(*x, 5u);
*x = 612;
x => fail!("Unexpected value {}", x)
}
- match b_r.as_mut::<uint>() {
+ match b_r.downcast_mut::<uint>() {
Some(x) => {
assert_eq!(*x, 7u);
*x = 413;
x => fail!("Unexpected value {}", x)
}
- match a_r.as_mut::<Test>() {
+ match a_r.downcast_mut::<Test>() {
None => (),
x => fail!("Unexpected value {}", x)
}
- match b_r.as_mut::<Test>() {
+ match b_r.downcast_mut::<Test>() {
None => (),
x => fail!("Unexpected value {}", x)
}
- match a_r.as_mut::<uint>() {
+ match a_r.downcast_mut::<uint>() {
Some(&612) => {}
x => fail!("Unexpected value {}", x)
}
- match b_r.as_mut::<uint>() {
+ match b_r.downcast_mut::<uint>() {
Some(&413) => {}
x => fail!("Unexpected value {}", x)
}
#[bench]
-fn bench_as_ref(b: &mut Bencher) {
+fn bench_downcast_ref(b: &mut Bencher) {
b.iter(|| {
let mut x = 0i;
let mut y = &mut x as &mut Any;
test::black_box(&mut y);
- test::black_box(y.as_ref::<int>() == Some(&0));
+ test::black_box(y.downcast_ref::<int>() == Some(&0));
});
}
#[test]
fn test_iterate() {
- let mut it = iterate(|x| x * 2, 1u);
+ let mut it = iterate(1u, |x| x * 2);
assert_eq!(it.next(), Some(1u));
assert_eq!(it.next(), Some(2u));
assert_eq!(it.next(), Some(4u));
}
#[test]
+#[allow(deprecated)]
fn test_option_while_some() {
let mut i = 0i;
Some(10i).while_some(|j| {
}
#[test]
+#[allow(deprecated)]
fn test_filtered() {
let some_stuff = Some(42i);
let modified_stuff = some_stuff.filtered(|&x| {x < 10});
}
#[test]
+#[allow(deprecated)]
fn test_collect() {
let v: Option<Vec<int>> = collect(range(0i, 0)
.map(|_| Some(0i)));
}
#[test]
+#[allow(deprecated)]
fn test_collect() {
let v: Result<Vec<int>, ()> = collect(range(0i, 0).map(|_| Ok::<int, ()>(0)));
assert!(v == Ok(vec![]));
}
#[cfg(test)]
+#[allow(dead_code)]
struct P {a: int, b: f64}
#[test]
id_name(n)
}
fn node_label(&'a self, n: &Node) -> LabelText<'a> {
- match self.node_labels.get(*n) {
- &Some(ref l) => LabelStr(str::Slice(l.as_slice())),
- &None => LabelStr(id_name(n).name()),
+ match self.node_labels[*n] {
+ Some(ref l) => LabelStr(str::Slice(l.as_slice())),
+ None => LabelStr(id_name(n).name()),
}
}
fn edge_label(&'a self, e: & &'a Edge) -> LabelText<'a> {
// Regression test that the `start` task entrypoint can
// contain dtors that use task resources
run(proc() {
+ #[allow(dead_code)]
struct S { field: () }
impl Drop for S {
//! Blocking posix-based file I/O
use alloc::arc::Arc;
-use libc::{c_int, c_void};
-use libc;
+use libc::{mod, c_int, c_void};
use std::c_str::CString;
use std::mem;
-use std::rt::rtio;
-use std::rt::rtio::IoResult;
+use std::rt::rtio::{mod, IoResult};
use io::{retry, keep_going};
use io::util;
let ret = retry(|| unsafe {
libc::read(self.fd(),
buf.as_mut_ptr() as *mut libc::c_void,
- buf.len() as libc::size_t) as libc::c_int
+ buf.len() as libc::size_t)
});
if ret == 0 {
Err(util::eof())
match retry(|| unsafe {
libc::pread(self.fd(), buf.as_ptr() as *mut _,
buf.len() as libc::size_t,
- offset as libc::off_t) as libc::c_int
+ offset as libc::off_t)
}) {
-1 => Err(super::last_error()),
n => Ok(n as int)
super::mkerr_libc(retry(|| unsafe {
libc::pwrite(self.fd(), buf.as_ptr() as *const _,
buf.len() as libc::size_t, offset as libc::off_t)
- } as c_int))
+ }))
}
fn seek(&mut self, pos: i64, whence: rtio::SeekStyle) -> IoResult<u64> {
let whence = match whence {
#![allow(non_snake_case)]
-use libc::c_int;
-use libc;
+use libc::{mod, c_int};
use std::c_str::CString;
use std::os;
-use std::rt::rtio;
-use std::rt::rtio::{IoResult, IoError};
+use std::rt::rtio::{mod, IoResult, IoError};
+use std::num;
// Local re-exports
pub use self::file::FileDesc;
}
// unix has nonzero values as errors
-fn mkerr_libc(ret: libc::c_int) -> IoResult<()> {
- if ret != 0 {
+fn mkerr_libc <Int: num::Zero>(ret: Int) -> IoResult<()> {
+ if !ret.is_zero() {
Err(last_error())
} else {
Ok(())
#[cfg(windows)]
#[inline]
-fn retry(f: || -> libc::c_int) -> libc::c_int {
- loop {
- match f() {
- -1 if os::errno() as int == libc::WSAEINTR as int => {}
- n => return n,
- }
- }
-}
+fn retry<I> (f: || -> I) -> I { f() } // PR rust-lang/rust/#17020
#[cfg(unix)]
#[inline]
-fn retry(f: || -> libc::c_int) -> libc::c_int {
+fn retry<I: PartialEq + num::One + Neg<I>> (f: || -> I) -> I {
+ let minus_one = -num::one::<I>();
loop {
- match f() {
- -1 if os::errno() as int == libc::EINTR as int => {}
- n => return n,
- }
+ let n = f();
+ if n == minus_one && os::errno() == libc::EINTR as int { }
+ else { return n }
}
}
+
fn keep_going(data: &[u8], f: |*const u8, uint| -> i64) -> i64 {
let origamt = data.len();
let mut data = data.as_ptr();
let mut amt = origamt;
while amt > 0 {
- let ret = retry(|| f(data, amt) as libc::c_int);
+ let ret = retry(|| f(data, amt));
if ret == 0 {
break
} else if ret != -1 {
amt -= ret as uint;
data = unsafe { data.offset(ret as int) };
} else {
- return ret as i64;
+ return ret;
}
}
return (origamt - amt) as i64;
use std::mem;
use std::ptr;
use std::rt::mutex;
-use std::rt::rtio;
-use std::rt::rtio::{IoResult, IoError};
+use std::rt::rtio::{mod, IoResult, IoError};
use std::sync::atomic;
use super::{retry, keep_going};
write(false, inner, len)
});
} else {
- ret = retry(|| {
- write(false, buf.as_ptr(), buf.len()) as libc::c_int
- }) as i64;
+ ret = retry(|| { write(false, buf.as_ptr(), buf.len()) });
if ret > 0 { written = ret as uint; }
}
}
let _guard = lock();
let ptr = buf.slice_from(written).as_ptr();
let len = buf.len() - written;
- match retry(|| write(deadline.is_some(), ptr, len) as libc::c_int) {
+ match retry(|| write(deadline.is_some(), ptr, len)) {
-1 if util::wouldblock() => {}
-1 => return Err(os::last_error()),
n => { written += n as uint; }
#[test]
fn test_checked_add() {
for elm in sum_triples.iter() {
- let (aVec, bVec, cVec) = *elm;
- let a = BigUint::from_slice(aVec);
- let b = BigUint::from_slice(bVec);
- let c = BigUint::from_slice(cVec);
+ let (a_vec, b_vec, c_vec) = *elm;
+ let a = BigUint::from_slice(a_vec);
+ let b = BigUint::from_slice(b_vec);
+ let c = BigUint::from_slice(c_vec);
assert!(a.checked_add(&b).unwrap() == c);
assert!(b.checked_add(&a).unwrap() == c);
#[test]
fn test_checked_sub() {
for elm in sum_triples.iter() {
- let (aVec, bVec, cVec) = *elm;
- let a = BigUint::from_slice(aVec);
- let b = BigUint::from_slice(bVec);
- let c = BigUint::from_slice(cVec);
+ let (a_vec, b_vec, c_vec) = *elm;
+ let a = BigUint::from_slice(a_vec);
+ let b = BigUint::from_slice(b_vec);
+ let c = BigUint::from_slice(c_vec);
assert!(c.checked_sub(&a).unwrap() == b);
assert!(c.checked_sub(&b).unwrap() == a);
#[test]
fn test_checked_mul() {
for elm in mul_triples.iter() {
- let (aVec, bVec, cVec) = *elm;
- let a = BigUint::from_slice(aVec);
- let b = BigUint::from_slice(bVec);
- let c = BigUint::from_slice(cVec);
+ let (a_vec, b_vec, c_vec) = *elm;
+ let a = BigUint::from_slice(a_vec);
+ let b = BigUint::from_slice(b_vec);
+ let c = BigUint::from_slice(c_vec);
assert!(a.checked_mul(&b).unwrap() == c);
assert!(b.checked_mul(&a).unwrap() == c);
}
for elm in div_rem_quadruples.iter() {
- let (aVec, bVec, cVec, dVec) = *elm;
- let a = BigUint::from_slice(aVec);
- let b = BigUint::from_slice(bVec);
- let c = BigUint::from_slice(cVec);
- let d = BigUint::from_slice(dVec);
+ let (a_vec, b_vec, c_vec, d_vec) = *elm;
+ let a = BigUint::from_slice(a_vec);
+ let b = BigUint::from_slice(b_vec);
+ let c = BigUint::from_slice(c_vec);
+ let d = BigUint::from_slice(d_vec);
assert!(a == b.checked_mul(&c).unwrap() + d);
assert!(a == c.checked_mul(&b).unwrap() + d);
#[test]
fn test_checked_div() {
for elm in mul_triples.iter() {
- let (aVec, bVec, cVec) = *elm;
- let a = BigUint::from_slice(aVec);
- let b = BigUint::from_slice(bVec);
- let c = BigUint::from_slice(cVec);
+ let (a_vec, b_vec, c_vec) = *elm;
+ let a = BigUint::from_slice(a_vec);
+ let b = BigUint::from_slice(b_vec);
+ let c = BigUint::from_slice(c_vec);
if !a.is_zero() {
assert!(c.checked_div(&a).unwrap() == b);
#[test]
fn test_checked_add() {
for elm in sum_triples.iter() {
- let (aVec, bVec, cVec) = *elm;
- let a = BigInt::from_slice(Plus, aVec);
- let b = BigInt::from_slice(Plus, bVec);
- let c = BigInt::from_slice(Plus, cVec);
+ let (a_vec, b_vec, c_vec) = *elm;
+ let a = BigInt::from_slice(Plus, a_vec);
+ let b = BigInt::from_slice(Plus, b_vec);
+ let c = BigInt::from_slice(Plus, c_vec);
assert!(a.checked_add(&b).unwrap() == c);
assert!(b.checked_add(&a).unwrap() == c);
#[test]
fn test_checked_sub() {
for elm in sum_triples.iter() {
- let (aVec, bVec, cVec) = *elm;
- let a = BigInt::from_slice(Plus, aVec);
- let b = BigInt::from_slice(Plus, bVec);
- let c = BigInt::from_slice(Plus, cVec);
+ let (a_vec, b_vec, c_vec) = *elm;
+ let a = BigInt::from_slice(Plus, a_vec);
+ let b = BigInt::from_slice(Plus, b_vec);
+ let c = BigInt::from_slice(Plus, c_vec);
assert!(c.checked_sub(&a).unwrap() == b);
assert!(c.checked_sub(&b).unwrap() == a);
#[test]
fn test_checked_mul() {
for elm in mul_triples.iter() {
- let (aVec, bVec, cVec) = *elm;
- let a = BigInt::from_slice(Plus, aVec);
- let b = BigInt::from_slice(Plus, bVec);
- let c = BigInt::from_slice(Plus, cVec);
+ let (a_vec, b_vec, c_vec) = *elm;
+ let a = BigInt::from_slice(Plus, a_vec);
+ let b = BigInt::from_slice(Plus, b_vec);
+ let c = BigInt::from_slice(Plus, c_vec);
assert!(a.checked_mul(&b).unwrap() == c);
assert!(b.checked_mul(&a).unwrap() == c);
}
for elm in div_rem_quadruples.iter() {
- let (aVec, bVec, cVec, dVec) = *elm;
- let a = BigInt::from_slice(Plus, aVec);
- let b = BigInt::from_slice(Plus, bVec);
- let c = BigInt::from_slice(Plus, cVec);
- let d = BigInt::from_slice(Plus, dVec);
+ let (a_vec, b_vec, c_vec, d_vec) = *elm;
+ let a = BigInt::from_slice(Plus, a_vec);
+ let b = BigInt::from_slice(Plus, b_vec);
+ let c = BigInt::from_slice(Plus, c_vec);
+ let d = BigInt::from_slice(Plus, d_vec);
assert!(a == b.checked_mul(&c).unwrap() + d);
assert!(a == c.checked_mul(&b).unwrap() + d);
#[test]
fn test_checked_div() {
for elm in mul_triples.iter() {
- let (aVec, bVec, cVec) = *elm;
- let a = BigInt::from_slice(Plus, aVec);
- let b = BigInt::from_slice(Plus, bVec);
- let c = BigInt::from_slice(Plus, cVec);
+ let (a_vec, b_vec, c_vec) = *elm;
+ let a = BigInt::from_slice(Plus, a_vec);
+ let b = BigInt::from_slice(Plus, b_vec);
+ let c = BigInt::from_slice(Plus, c_vec);
if !a.is_zero() {
assert!(c.checked_div(&a).unwrap() == b);
self.isaac();
}
self.cnt -= 1;
- self.rsl[self.cnt as uint]
+
+ // self.cnt is at most RAND_SIZE, but that is before the
+ // subtraction above. We want to index without bounds
+ // checking, but this could lead to incorrect code if someone
+ // misrefactors, so we check, sometimes.
+ //
+ // (Changes here should be reflected in Isaac64Rng.next_u64.)
+ debug_assert!(self.cnt < RAND_SIZE);
+
+ // (the % is cheaply telling the optimiser that we're always
+ // in bounds, without unsafe. NB. this is a power of two, so
+ // it optimises to a bitwise mask).
+ self.rsl[(self.cnt % RAND_SIZE) as uint]
}
}
self.isaac64();
}
self.cnt -= 1;
- unsafe { *self.rsl.unsafe_get(self.cnt) }
+
+ // See corresponding location in IsaacRng.next_u32 for
+ // explanation.
+ debug_assert!(self.cnt < RAND_SIZE_64)
+ self.rsl[(self.cnt % RAND_SIZE_64) as uint]
}
}
use serialize::{Encodable, Decodable};
- use std::io::{IoError, IoResult, SeekStyle};
- use std::io;
use std::option::{None, Option, Some};
- use std::slice;
#[test]
fn test_vuint_at() {
#[cfg(test)]
mod test {
- use core::option::{Some, None};
- use core::iter::Iterator;
use core::collections::Collection;
use core::str::StrSlice;
use core::slice::{MutableSlice, ImmutableSlice};
("rustc_diagnostic_macros", Active),
("unboxed_closures", Active),
("import_shadowing", Active),
+ ("advanced_slice_patterns", Active),
// if you change this list without updating src/doc/rust.md, cmr will be sad
}
}
+ fn visit_pat(&mut self, pattern: &ast::Pat, (): ()) {
+ match pattern.node {
+ ast::PatVec(_, Some(_), ref last) if !last.is_empty() => {
+ self.gate_feature("advanced_slice_patterns",
+ pattern.span,
+ "multiple-element slice matches anywhere \
+ but at the end of a slice (e.g. \
+ `[0, ..xs, 0]` are experimental")
+ }
+ _ => {}
+ }
+ visit::walk_pat(self, pattern, ())
+ }
+
fn visit_fn(&mut self,
fn_kind: &visit::FnKind,
fn_decl: &ast::FnDecl,
// Add a special __test module to the crate that will contain code
// generated for the test harness
- let (mod_, reexport) = mk_test_module(&self.cx, &self.cx.reexport_test_harness_main);
+ let (mod_, reexport) = mk_test_module(&mut self.cx);
folded.module.items.push(mod_);
match reexport {
Some(re) => folded.module.view_items.push(re),
}
}
-fn mk_test_module(cx: &TestCtxt, reexport_test_harness_main: &Option<InternedString>)
- -> (Gc<ast::Item>, Option<ast::ViewItem>) {
+fn mk_test_module(cx: &mut TestCtxt) -> (Gc<ast::Item>, Option<ast::ViewItem>) {
// Link to test crate
let view_items = vec!(mk_std(cx));
// The synthesized main function which will call the console test runner
// with our list of tests
- let mainfn = (quote_item!(&cx.ext_cx,
+ let mainfn = (quote_item!(&mut cx.ext_cx,
pub fn main() {
#![main]
use std::slice::Slice;
vis: ast::Public,
span: DUMMY_SP,
};
- let reexport = reexport_test_harness_main.as_ref().map(|s| {
+ let reexport = cx.reexport_test_harness_main.as_ref().map(|s| {
// building `use <ident> = __test::main`
let reexport_ident = token::str_to_ident(s.get());
ast::ExprLit(lit) => {
match ty::get(ty::expr_ty(cx.tcx, e)).sty {
ty::ty_int(t) => {
- let int_type = if t == ast::TyI {
- cx.sess().targ_cfg.int_type
- } else { t };
- let (min, max) = int_ty_range(int_type);
- let mut lit_val: i64 = match lit.node {
+ match lit.node {
ast::LitInt(v, ast::SignedIntLit(_, ast::Plus)) |
ast::LitInt(v, ast::UnsuffixedIntLit(ast::Plus)) => {
- if v > i64::MAX as u64{
+ let int_type = if t == ast::TyI {
+ cx.sess().targ_cfg.int_type
+ } else { t };
+ let (min, max) = int_ty_range(int_type);
+ let negative = self.negated_expr_id == e.id;
+
+ if (negative && v > (min.abs() as u64)) ||
+ (!negative && v > (max.abs() as u64)) {
cx.span_lint(TYPE_OVERFLOW, e.span,
"literal out of range for its type");
return;
}
- v as i64
- }
- ast::LitInt(v, ast::SignedIntLit(_, ast::Minus)) |
- ast::LitInt(v, ast::UnsuffixedIntLit(ast::Minus)) => {
- -(v as i64)
}
_ => fail!()
};
- if self.negated_expr_id == e.id {
- lit_val *= -1;
- }
- if lit_val < min || lit_val > max {
- cx.span_lint(TYPE_OVERFLOW, e.span,
- "literal out of range for its type");
- }
},
ty::ty_uint(t) => {
let uint_type = if t == ast::TyU {
#[test]
fn test_basic() {
let cx = mk_ctxt();
- roundtrip(quote_item!(cx,
+ roundtrip(quote_item!(&cx,
fn foo() {}
));
}
#[test]
fn test_smalltalk() {
let cx = mk_ctxt();
- roundtrip(quote_item!(cx,
+ roundtrip(quote_item!(&cx,
fn foo() -> int { 3 + 4 } // first smalltalk program ever executed.
));
}
#[test]
fn test_more() {
let cx = mk_ctxt();
- roundtrip(quote_item!(cx,
+ roundtrip(quote_item!(&cx,
fn foo(x: uint, y: uint) -> uint {
let z = x + y;
return z;
).unwrap();
let item_in = e::IIItemRef(&*item);
let item_out = simplify_ast(item_in);
- let item_exp = ast::IIItem(quote_item!(cx,
+ let item_exp = ast::IIItem(quote_item!(&cx,
fn new_int_alist<B>() -> alist<int, B> {
return alist {eq_fn: eq_int, data: Vec::new()};
}
"target type not found for const cast")
});
- let base = eval_const_expr_partial(tcx, &**base);
- match base {
- Err(_) => base,
- Ok(val) => {
- match ty::get(ety).sty {
- ty::ty_float(_) => {
- match val {
- const_bool(b) => Ok(const_float(b as f64)),
- const_uint(u) => Ok(const_float(u as f64)),
- const_int(i) => Ok(const_float(i as f64)),
- const_float(f) => Ok(const_float(f)),
- _ => Err("can't cast this type to float".to_string()),
- }
+ macro_rules! define_casts(
+ ($val:ident, {
+ $($ty_pat:pat => (
+ $intermediate_ty:ty,
+ $const_type:ident,
+ $target_ty:ty
+ )),*
+ }) => (match ty::get(ety).sty {
+ $($ty_pat => {
+ match $val {
+ const_bool(b) => Ok($const_type(b as $intermediate_ty as $target_ty)),
+ const_uint(u) => Ok($const_type(u as $intermediate_ty as $target_ty)),
+ const_int(i) => Ok($const_type(i as $intermediate_ty as $target_ty)),
+ const_float(f) => Ok($const_type(f as $intermediate_ty as $target_ty)),
+ _ => Err(concat!(
+ "can't cast this type to ", stringify!($const_type)
+ ).to_string())
}
- ty::ty_uint(_) => {
- match val {
- const_bool(b) => Ok(const_uint(b as u64)),
- const_uint(u) => Ok(const_uint(u)),
- const_int(i) => Ok(const_uint(i as u64)),
- const_float(f) => Ok(const_uint(f as u64)),
- _ => Err("can't cast this type to uint".to_string()),
- }
- }
- ty::ty_int(_) => {
- match val {
- const_bool(b) => Ok(const_int(b as i64)),
- const_uint(u) => Ok(const_int(u as i64)),
- const_int(i) => Ok(const_int(i)),
- const_float(f) => Ok(const_int(f as i64)),
- _ => Err("can't cast this type to int".to_string()),
- }
- }
- _ => Err("can't cast this type".to_string())
- }
- }
- }
+ },)*
+ _ => Err("can't cast this type".to_string())
+ })
+ )
+
+ eval_const_expr_partial(tcx, &**base)
+ .and_then(|val| define_casts!(val, {
+ ty::ty_int(ast::TyI) => (int, const_int, i64),
+ ty::ty_int(ast::TyI8) => (i8, const_int, i64),
+ ty::ty_int(ast::TyI16) => (i16, const_int, i64),
+ ty::ty_int(ast::TyI32) => (i32, const_int, i64),
+ ty::ty_int(ast::TyI64) => (i64, const_int, i64),
+ ty::ty_uint(ast::TyU) => (uint, const_uint, u64),
+ ty::ty_uint(ast::TyU8) => (u8, const_uint, u64),
+ ty::ty_uint(ast::TyU16) => (u16, const_uint, u64),
+ ty::ty_uint(ast::TyU32) => (u32, const_uint, u64),
+ ty::ty_uint(ast::TyU64) => (u64, const_uint, u64),
+ ty::ty_float(ast::TyF32) => (f32, const_float, f64),
+ ty::ty_float(ast::TyF64) => (f64, const_float, f64)
+ }))
}
ExprPath(_) => {
match lookup_const(tcx, e) {
cx,
item.span,
&*trait_ref);
+
+ let trait_def = ty::lookup_trait_def(cx.tcx, trait_ref.def_id);
+ for (ty, type_param_def) in trait_ref.substs.types
+ .iter()
+ .zip(trait_def.generics
+ .types
+ .iter()) {
+ check_typaram_bounds(cx, item.span, *ty, type_param_def);
+ }
}
}
}
PathListMod { .. } => Some(item.span),
_ => None
}).collect::<Vec<Span>>();
- match mod_spans.as_slice() {
- [first, second, ..other] => {
- self.resolve_error(first,
- "`mod` import can only appear once in the list");
- self.session.span_note(second,
- "another `mod` import appears here");
- for &other_span in other.iter() {
- self.session.span_note(other_span,
- "another `mod` import appears here");
- }
- },
- [_] | [] => ()
+ if mod_spans.len() > 1 {
+ self.resolve_error(mod_spans[0],
+ "`mod` import can only appear once in the list");
+ for other_span in mod_spans.iter().skip(1) {
+ self.session.span_note(*other_span,
+ "another `mod` import appears here");
+ }
}
for source_item in source_items.iter() {
}
rcx.visit_expr(&**head, ());
+ type_of_node_must_outlive(rcx,
+ infer::AddrOf(expr.span),
+ head.id,
+ ty::ReScope(expr.id));
let repeating_scope = rcx.set_repeating_scope(body.id);
rcx.visit_block(&**body, ());
local_data_key!(pub playground_krate: Option<String>)
pub fn render(w: &mut fmt::Formatter, s: &str, print_toc: bool) -> fmt::Result {
- extern fn block(ob: *mut hoedown_buffer, text: *const hoedown_buffer,
+ extern fn block(ob: *mut hoedown_buffer, orig_text: *const hoedown_buffer,
lang: *const hoedown_buffer, opaque: *mut libc::c_void) {
unsafe {
- if text.is_null() { return }
+ if orig_text.is_null() { return }
let opaque = opaque as *mut hoedown_html_renderer_state;
let my_opaque: &MyOpaque = &*((*opaque).opaque as *const MyOpaque);
- slice::raw::buf_as_slice((*text).data, (*text).size as uint, |text| {
+ slice::raw::buf_as_slice((*orig_text).data, (*orig_text).size as uint,
+ |text| {
let origtext = str::from_utf8(text).unwrap();
debug!("docblock: ==============\n{}\n=======", text);
- let mut lines = origtext.lines().filter(|l| {
- stripped_filtered_line(*l).is_none()
- });
- let text = lines.collect::<Vec<&str>>().connect("\n");
-
- let buf = hoedown_buffer {
- data: text.as_bytes().as_ptr(),
- size: text.len() as libc::size_t,
- asize: text.len() as libc::size_t,
- unit: 0,
- };
let rendered = if lang.is_null() {
false
} else {
(*lang).size as uint, |rlang| {
let rlang = str::from_utf8(rlang).unwrap();
if LangString::parse(rlang).notrust {
- (my_opaque.dfltblk)(ob, &buf, lang,
+ (my_opaque.dfltblk)(ob, orig_text, lang,
opaque as *mut libc::c_void);
true
} else {
})
};
+ let mut lines = origtext.lines().filter(|l| {
+ stripped_filtered_line(*l).is_none()
+ });
+ let text = lines.collect::<Vec<&str>>().connect("\n");
if !rendered {
let mut s = String::new();
let id = playground_krate.get().map(|krate| {
#[test]
#[should_fail]
fn test_new_fail() {
- let c_str = unsafe { CString::new(ptr::null(), false) };
+ let _c_str = unsafe { CString::new(ptr::null(), false) };
}
#[test]
#[test]
fn block_and_wake() {
let task = box Task::new();
- let mut task = BlockedTask::block(task).wake().unwrap();
+ let task = BlockedTask::block(task).wake().unwrap();
task.drop();
}
}
let mut obj = try!(expect!(self.pop(), Object));
let value = match obj.pop(&name.to_string()) {
- None => return Err(MissingFieldError(name.to_string())),
+ None => {
+ // Add a Null and try to parse it as an Option<_>
+ // to get None as a default value.
+ self.stack.push(Null);
+ match f(self) {
+ Ok(x) => x,
+ Err(_) => return Err(MissingFieldError(name.to_string())),
+ }
+ },
Some(json) => {
self.stack.push(json);
try!(f(self))
}
fn read_option<T>(&mut self, f: |&mut Decoder, bool| -> DecodeResult<T>) -> DecodeResult<T> {
+ debug!("read_option()");
match self.pop() {
Null => f(self, false),
value => { self.stack.push(value); f(self, true) }
use std::{i64, u64, f32, f64, io};
use std::collections::TreeMap;
+ #[deriving(Decodable, Eq, PartialEq, Show)]
+ struct OptionData {
+ opt: Option<uint>,
+ }
+
+ #[test]
+ fn test_decode_option_none() {
+ let s ="{}";
+ let obj: OptionData = super::decode(s).unwrap();
+ assert_eq!(obj, OptionData { opt: None });
+ }
+
+ #[test]
+ fn test_decode_option_some() {
+ let s = "{ \"opt\": 10 }";
+ let obj: OptionData = super::decode(s).unwrap();
+ assert_eq!(obj, OptionData { opt: Some(10u) });
+ }
+
+ #[test]
+ fn test_decode_option_malformed() {
+ check_err::<OptionData>("{ \"opt\": [] }",
+ ExpectedError("Number".to_string(), "[]".to_string()));
+ check_err::<OptionData>("{ \"opt\": false }",
+ ExpectedError("Number".to_string(), "false".to_string()));
+ }
+
#[deriving(PartialEq, Encodable, Decodable, Show)]
enum Animal {
Dog,
// sizes. For an example, see #14940. For this reason, chunk the output
// buffer on windows, but on unix we can just write the whole buffer all
// at once.
- let max_size = if cfg!(windows) {64 * 1024} else {uint::MAX};
+ //
+ // For some other references, it appears that this problem has been
+ // encountered by others [1] [2]. We choose the number 8KB just because
+ // libuv does the same.
+ //
+ // [1]: https://tahoe-lafs.org/trac/tahoe-lafs/ticket/1232
+ // [2]: http://www.mail-archive.com/log4net-dev@logging.apache.org/msg00661.html
+ let max_size = if cfg!(windows) {8192} else {uint::MAX};
for chunk in buf.chunks(max_size) {
try!(match self.inner {
TTY(ref mut tty) => tty.write(chunk),
use native;
- use super::{queue, Queue};
+ use super::{queue};
#[test]
fn smoke() {
cx.view_use_glob(sp, ast::Inherited, ids_ext(path))
}).collect();
- let stmt_let_ext_cx = cx.stmt_let(sp, false, id_ext("ext_cx"), cx_expr);
+ // Explicitly borrow to avoid moving from the invoker (#16992)
+ let cx_expr_borrow = cx.expr_addr_of(sp, cx.expr_deref(sp, cx_expr));
+ let stmt_let_ext_cx = cx.stmt_let(sp, false, id_ext("ext_cx"), cx_expr_borrow);
cx.expr_block(cx.block_all(sp, uses, vec!(stmt_let_ext_cx), Some(expr)))
}
ObsoleteManagedType,
ObsoleteManagedExpr,
ObsoleteImportRenaming,
+ ObsoleteSubsliceMatch,
}
pub trait ParserObsoleteMethods {
ObsoleteImportRenaming => (
"`use foo = bar` syntax",
"write `use bar as foo` instead"
+ ),
+ ObsoleteSubsliceMatch => (
+ "subslice match syntax",
+ "instead of `..xs`, write `xs..` in a pattern"
)
};
let mut before_slice = true;
while self.token != token::RBRACKET {
- if first { first = false; }
- else { self.expect(&token::COMMA); }
+ if first {
+ first = false;
+ } else {
+ self.expect(&token::COMMA);
+ }
- let mut is_slice = false;
if before_slice {
if self.token == token::DOTDOT {
self.bump();
- is_slice = true;
- before_slice = false;
- }
- }
- if is_slice {
- if self.token == token::COMMA || self.token == token::RBRACKET {
- slice = Some(box(GC) ast::Pat {
- id: ast::DUMMY_NODE_ID,
- node: PatWild(PatWildMulti),
- span: self.span,
- })
- } else {
- let subpat = self.parse_pat();
- match *subpat {
- ast::Pat { node: PatIdent(_, _, _), .. } => {
- slice = Some(subpat);
- }
- ast::Pat { span, .. } => self.span_fatal(
- span, "expected an identifier or nothing"
- )
+ if self.token == token::COMMA ||
+ self.token == token::RBRACKET {
+ slice = Some(box(GC) ast::Pat {
+ id: ast::DUMMY_NODE_ID,
+ node: PatWild(PatWildMulti),
+ span: self.span,
+ });
+ before_slice = false;
+ } else {
+ let _ = self.parse_pat();
+ let span = self.span;
+ self.obsolete(span, ObsoleteSubsliceMatch);
}
+ continue
}
+ }
+
+ let subpat = self.parse_pat();
+ if before_slice && self.token == token::DOTDOT {
+ self.bump();
+ slice = Some(subpat);
+ before_slice = false;
+ } else if before_slice {
+ before.push(subpat);
} else {
- let subpat = self.parse_pat();
- if before_slice {
- before.push(subpat);
- } else {
- after.push(subpat);
- }
+ after.push(subpat);
}
}
// These expressions are limited to literals (possibly
// preceded by unary-minus) or identifiers.
let val = self.parse_literal_maybe_minus();
- if self.eat(&token::DOTDOT) {
+ if self.token == token::DOTDOT &&
+ self.look_ahead(1, |t| {
+ *t != token::COMMA && *t != token::RBRACKET
+ }) {
+ self.bump();
let end = if is_ident_or_path(&self.token) {
let path = self.parse_path(LifetimeAndTypesWithColons)
.path;
}
});
- if self.look_ahead(1, |t| *t == token::DOTDOT) {
+ if self.look_ahead(1, |t| *t == token::DOTDOT) &&
+ self.look_ahead(2, |t| {
+ *t != token::COMMA && *t != token::RBRACKET
+ }) {
let start = self.parse_expr_res(RESTRICT_NO_BAR_OP);
self.eat(&token::DOTDOT);
let end = self.parse_expr_res(RESTRICT_NO_BAR_OP);
|s, p| s.print_pat(&**p)));
for p in slice.iter() {
if !before.is_empty() { try!(self.word_space(",")); }
+ try!(self.print_pat(&**p));
match **p {
ast::Pat { node: ast::PatWild(ast::PatWildMulti), .. } => {
// this case is handled by print_pat
}
_ => try!(word(&mut self.s, "..")),
}
- try!(self.print_pat(&**p));
if !after.is_empty() { try!(self.word_space(",")); }
}
try!(self.commasep(Inconsistent,
use super::{Uuid, VariantMicrosoft, VariantNCS, VariantRFC4122,
Version1Mac, Version2Dce, Version3Md5, Version4Random,
Version5Sha1};
- use std::io::MemWriter;
use std::rand;
#[test]
#[test]
fn test_serialize_round_trip() {
use serialize::json;
- use serialize::{Encodable, Decodable};
let u = Uuid::new_v4();
let s = json::encode(&u);
#[test]
fn test_bad_decode() {
use serialize::json;
- use serialize::{Encodable, Decodable};
+ use serialize::{Decodable};
let js_good = json::String("a1a2a3a4a5a6a7a8a1a2a3a4a5a6a7a8".to_string());
let js_bad1 = json::String("a1a2a3a4a5a6a7a8a1a2a3a4a5a6a7ah".to_string());
-Subproject commit 90a314162053a0c51a50a1c603c9203bef241e0d
+Subproject commit e9d037419441d51ccb0f41aacbc64080b0c6e81b
# 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.
-2014-08-05
+2014-09-08
-// 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.
+// The Computer Language Benchmarks Game
+// http://benchmarksgame.alioth.debian.org/
//
-// 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.
+// contributed by the Rust Project Developers
+
+// Copyright (c) 2012-2014 The Rust Project Developers
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+//
+// - Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//
+// - Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in
+// the documentation and/or other materials provided with the
+// distribution.
+//
+// - Neither the name of "The Computer Language Benchmarks Game" nor
+// the name of "The Computer Language Shootout Benchmarks" nor the
+// names of its contributors may be used to endorse or promote
+// products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+// COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+// OF THE POSSIBILITY OF SUCH DAMAGE.
// no-pretty-expanded
-// 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.
+// The Computer Language Benchmarks Game
+// http://benchmarksgame.alioth.debian.org/
//
-// 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.
+// contributed by the Rust Project Developers
+
+// Copyright (c) 2011-2014 The Rust Project Developers
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+//
+// - Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//
+// - Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in
+// the documentation and/or other materials provided with the
+// distribution.
+//
+// - Neither the name of "The Computer Language Benchmarks Game" nor
+// the name of "The Computer Language Shootout Benchmarks" nor the
+// names of its contributors may be used to endorse or promote
+// products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+// COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+// OF THE POSSIBILITY OF SUCH DAMAGE.
static PI: f64 = 3.141592653589793;
static SOLAR_MASS: f64 = 4.0 * PI * PI;
-// 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.
+// The Computer Language Benchmarks Game
+// http://benchmarksgame.alioth.debian.org/
//
-// 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.
+// contributed by the Rust Project Developers
+
+// Copyright (c) 2013-2014 The Rust Project Developers
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+//
+// - Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//
+// - Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in
+// the documentation and/or other materials provided with the
+// distribution.
+//
+// - Neither the name of "The Computer Language Benchmarks Game" nor
+// the name of "The Computer Language Shootout Benchmarks" nor the
+// names of its contributors may be used to endorse or promote
+// products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+// COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+// OF THE POSSIBILITY OF SUCH DAMAGE.
// ignore-pretty very bad with line comments
// ignore-android doesn't terminate?
--- /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.
+
+fn main() {
+ let mut vector = vec![1u, 2];
+ for &x in vector.iter() {
+ let cap = vector.capacity();
+ vector.grow(cap, &0u); //~ ERROR cannot borrow
+ *vector.get_mut(1u) = 5u; //~ ERROR cannot borrow
+ }
+}
+
);
let x: &[Foo] = x.as_slice();
match x {
- [_, ..tail] => {
+ [_, tail..] => {
match tail {
[Foo { string: a }, //~ ERROR cannot move out of dereference of `&`-pointer
Foo { string: b }] => {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#![feature(advanced_slice_patterns)]
+
fn a<'a>() -> &'a [int] {
let vec = vec!(1, 2, 3, 4);
let vec: &[int] = vec.as_slice(); //~ ERROR does not live long enough
let tail = match vec {
- [_, ..tail] => tail,
+ [_, tail..] => tail,
_ => fail!("a")
};
tail
let vec = vec!(1, 2, 3, 4);
let vec: &[int] = vec.as_slice(); //~ ERROR does not live long enough
let init = match vec {
- [..init, _] => init,
+ [init.., _] => init,
_ => fail!("b")
};
init
let vec = vec!(1, 2, 3, 4);
let vec: &[int] = vec.as_slice(); //~ ERROR does not live long enough
let slice = match vec {
- [_, ..slice, _] => slice,
+ [_, slice.., _] => slice,
_ => fail!("c")
};
slice
let mut v = vec!(1, 2, 3);
let vb: &mut [int] = v.as_mut_slice();
match vb {
- [_a, ..tail] => {
+ [_a, tail..] => {
v.push(tail[0] + tail[1]); //~ ERROR cannot borrow
}
_ => {}
fn main() {
let mut a = [1i, 2, 3, 4];
let t = match a {
- [1, 2, ..tail] => tail,
+ [1, 2, tail..] => tail,
_ => unreachable!()
};
a[0] = 0; //~ ERROR cannot assign to `a[..]` because it is borrowed
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#![feature(advanced_slice_patterns)]
fn a() {
let mut vec = [box 1i, box 2, box 3];
let mut vec = vec!(box 1i, box 2, box 3);
let vec: &mut [Box<int>] = vec.as_mut_slice();
match vec {
- [.._b] => {
+ [_b..] => {
vec[0] = box 4; //~ ERROR cannot assign
}
}
let vec: &mut [Box<int>] = vec.as_mut_slice();
match vec {
[_a, //~ ERROR cannot move out
- .._b] => { //~^ NOTE attempting to move value to here
+ _b..] => { //~^ NOTE attempting to move value to here
// Note: `_a` is *moved* here, but `b` is borrowing,
// hence illegal.
let mut vec = vec!(box 1i, box 2, box 3);
let vec: &mut [Box<int>] = vec.as_mut_slice();
match vec {
- [.._a, //~ ERROR cannot move out
+ [_a.., //~ ERROR cannot move out
_b] => {} //~ NOTE attempting to move value to here
_ => {}
}
let vec = vec!(1, 2, 3, 4);
let vec: &[int] = vec.as_slice(); //~ ERROR `vec` does not live long enough
let tail = match vec {
- [_a, ..tail] => &tail[0],
+ [_a, tail..] => &tail[0],
_ => fail!("foo")
};
tail
--- /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.
+
+fn main() {
+ let x = [ 1i, 2, 3, 4, 5 ];
+ match x {
+ [ ..xs, 4, 5 ] => {} //~ ERROR multiple-element slice matches
+ [ 1, ..xs, 5 ] => {} //~ ERROR multiple-element slice matches
+ [ 1, 2, ..xs ] => {} // OK without feature gate
+ }
+}
+
--- /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.
+
+// This code used to produce an ICE on the definition of trait Bar
+// with the following message:
+//
+// Type parameter out of range when substituting in region 'a (root
+// type=fn(Self) -> 'astr) (space=FnSpace, index=0)
+//
+// Regression test for issue #16218.
+
+trait Bar<'a> {}
+
+trait Foo<'a> {
+ fn bar<'a, T: Bar<'a>>(self) -> &'a str;
+}
+
+impl<'a> Foo<'a> for &'a str {
+ fn bar<T: Bar<'a>>(self) -> &'a str { fail!() } //~ ERROR lifetime
+}
+
+fn main() {
+}
let v: int = match sl.as_slice() {
[] => 0,
[a,b,c] => 3,
- [a, ..rest] => a,
- [10,a, ..rest] => 10 //~ ERROR: unreachable pattern
+ [a, rest..] => a,
+ [10,a, rest..] => 10 //~ ERROR: unreachable pattern
};
}
fn match_vecs<'a, T>(l1: &'a [T], l2: &'a [T]) {
match (l1, l2) {
([], []) => println!("both empty"),
- ([], [hd, ..tl]) | ([hd, ..tl], []) => println!("one empty"),
+ ([], [hd, tl..]) | ([hd, tl..], []) => println!("one empty"),
//~^ ERROR: cannot move out of dereference
//~^^ ERROR: cannot move out of dereference
- ([hd1, ..tl1], [hd2, ..tl2]) => println!("both nonempty"),
+ ([hd1, tl1..], [hd2, tl2..]) => println!("both nonempty"),
//~^ ERROR: cannot move out of dereference
//~^^ ERROR: cannot move out of dereference
}
let x = -2147483649_i32; //~ error: literal out of range for its type
let x = 9223372036854775808_i64; //~ error: literal out of range for its type
+ let x = -9223372036854775808_i64; // should be OK
let x = 18446744073709551615_i64; //~ error: literal out of range for its type
let x = -3.40282348e+38_f32; //~ error: literal out of range for its type
fn main() {
let a = Vec::new();
match a {
- [1, ..tail, ..tail] => {}, //~ ERROR: unexpected token: `..`
+ [1, tail.., tail..] => {}, //~ ERROR: expected `,`, found `..`
_ => ()
}
}
let x: Vec<char> = vec!('a', 'b', 'c');
let x: &[char] = x.as_slice();
match x {
- ['a', 'b', 'c', .._tail] => {}
+ ['a', 'b', 'c', _tail..] => {}
['a', 'b', 'c'] => {} //~ ERROR unreachable pattern
_ => {}
}
let vec = vec!(Some(42i), None, Some(21i));
let vec: &[Option<int>] = vec.as_slice();
match vec { //~ ERROR non-exhaustive patterns: `[]` not covered
- [Some(..), None, ..tail] => {}
- [Some(..), Some(..), ..tail] => {}
+ [Some(..), None, tail..] => {}
+ [Some(..), Some(..), tail..] => {}
[None] => {}
}
let vec = vec!(1i);
let vec: &[int] = vec.as_slice();
match vec {
- [_, ..tail] => (),
+ [_, tail..] => (),
[] => ()
}
let vec = vec!(0.5f32);
let vec = vec!(Some(42i), None, Some(21i));
let vec: &[Option<int>] = vec.as_slice();
match vec {
- [Some(..), None, ..tail] => {}
- [Some(..), Some(..), ..tail] => {}
- [None, None, ..tail] => {}
- [None, Some(..), ..tail] => {}
+ [Some(..), None, tail..] => {}
+ [Some(..), Some(..), tail..] => {}
+ [None, None, tail..] => {}
+ [None, Some(..), tail..] => {}
[Some(_)] => {}
[None] => {}
[] => {}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-#![feature(struct_variant)]
+#![feature(advanced_slice_patterns, struct_variant)]
struct Foo {
first: bool,
[Second(true), First] => (),
[Second(true), Second(true)] => (),
[Second(false), _] => (),
- [_, _, ..tail, _] => ()
+ [_, _, tail.., _] => ()
}
}
//~^ ERROR instantiating a type parameter with an incompatible type
}
-// I would like these to fail eventually.
-/*
// impl - bounded
trait T1<Z: T> {
}
struct S3<Sized? Y>;
-impl<Sized? X: T> T1<X> for S3<X> { //ERROR instantiating a type parameter with an incompatible type
+impl<Sized? X: T> T1<X> for S3<X> { //~ ERROR instantiating a type parameter with an incompatible
}
// impl - unbounded
trait T2<Z> {
}
-impl<Sized? X> T2<X> for S3<X> { //ERROR instantiating a type parameter with an incompatible type `X
-*/
+impl<Sized? X> T2<X> for S3<X> { //~ ERROR instantiating a type parameter with an incompatible type
+}
// impl - struct
trait T3<Sized? Z> {
--- /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.
+
+fn main() {
+ let x = [1i, 2, 3];
+ match x {
+ [a, b, ..c] => { //~ ERROR obsolete syntax
+ assert_eq!(a, 1);
+ assert_eq!(b, 2);
+ let expected: &[_] = &[3];
+ assert_eq!(c, expected);
+ }
+ }
+}
+
--- /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-pretty
+
+#![feature(quote)]
+
+extern crate syntax;
+
+use syntax::ext::base::ExtCtxt;
+
+#[allow(dead_code)]
+fn foobar(cx: &mut ExtCtxt) {
+ quote_expr!(cx, 1i);
+ quote_expr!(cx, 2i);
+}
+
+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.
+
+// This test verifies that casting from the same lifetime on a value
+// to the same lifetime on a trait succeeds. See issue #10766.
+
+#![allow(dead_code)]
+fn main() {
+ trait T {}
+
+ fn f<'a, V: T>(v: &'a V) -> &'a T {
+ v as &'a T
+ }
+}
+++ /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.
-
-
-// The `for` loop use to keep a mutable borrow when executing its body,
-// making it impossible to re-use the iterator as follows.
-// https://github.com/rust-lang/rust/issues/8372
-//
-// This was fixed in https://github.com/rust-lang/rust/pull/15809
-
-pub fn main() {
- let mut for_loop_values = Vec::new();
- let mut explicit_next_call_values = Vec::new();
-
- let mut iter = range(1i, 10);
- for i in iter {
- for_loop_values.push(i);
- explicit_next_call_values.push(iter.next());
- }
-
- assert_eq!(for_loop_values, vec![1, 3, 5, 7, 9]);
- assert_eq!(explicit_next_call_values, vec![Some(2), Some(4), Some(6), Some(8), None]);
-}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#![feature(advanced_slice_patterns)]
+
struct Foo(int, int, int, int);
struct Bar{a: int, b: int, c: int, d: int}
let mut result = vec!();
loop {
x = match x {
- [1, n, 3, ..rest] => {
+ [1, n, 3, rest..] => {
result.push(n);
rest
}
- [n, ..rest] => {
+ [n, rest..] => {
result.push(n);
rest
}
match v {
[] => 0,
[_] => 1,
- [_x, ..xs] => 1 + count_members(xs)
+ [_x, xs..] => 1 + count_members(xs)
}
}
--- /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.
+
+static X: u64 = -1 as u16 as u64;
+static Y: u64 = -1 as u32 as u64;
+
+fn main() {
+ assert_eq!(match 1 {
+ X => unreachable!(),
+ Y => unreachable!(),
+ _ => 1i
+ }, 1);
+}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#![feature(advanced_slice_patterns)]
+
fn foo<T: Add<T, T> + Clone>([x, y, z]: [T, ..3]) -> (T, T, T) {
(x.clone(), x.clone() + y.clone(), x + y + z)
}
assert_eq!(d, "baz");
let out = bar("baz", "foo");
- let [a, ..xs, d] = out;
+ let [a, xs.., d] = out;
assert_eq!(a, "baz");
assert!(xs == ["foo", "foo"]);
assert_eq!(d, "baz");
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#![feature(advanced_slice_patterns)]
+
fn match_vecs<'a, T>(l1: &'a [T], l2: &'a [T]) -> &'static str {
match (l1, l2) {
([], []) => "both empty",
--- /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.
+//
+// This code used to produce the following ICE:
+//
+// error: internal compiler error: get_unique_type_id_of_type() -
+// unexpected type: closure,
+// ty_unboxed_closure(syntax::ast::DefId{krate: 0u32, node: 66u32},
+// ReScope(63u32))
+//
+// This is a regression test for issue #17021.
+
+#![feature(unboxed_closures, overloaded_calls)]
+
+use std::ptr;
+
+pub fn replace_map<'a, T, F>(src: &mut T, prod: F)
+where F: |: T| -> T {
+ unsafe { *src = prod(ptr::read(src as *mut T as *const T)); }
+}
+
+pub fn main() {
+ let mut a = 7u;
+ let b = &mut a;
+ replace_map(b, |: x: uint| x * 2);
+ assert_eq!(*b, 14u);
+}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#![feature(advanced_slice_patterns)]
+
fn a() {
let x = [1i, 2, 3];
match x {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#![feature(advanced_slice_patterns)]
+
fn foldl<T,U:Clone>(values: &[T],
initial: U,
function: |partial: U, element: &T| -> U)
-> U {
match values {
- [ref head, ..tail] =>
+ [ref head, tail..] =>
foldl(tail, function(initial, head), function),
[] => initial.clone()
}
function: |element: &T, partial: U| -> U)
-> U {
match values {
- [..head, ref tail] =>
+ [head.., ref tail] =>
foldr(head, function(tail, initial), function),
[] => initial.clone()
}
let x: &[int] = &[1, 2, 3, 4, 5];
if !x.is_empty() {
let el = match x {
- [1, ..ref tail] => &tail[0],
+ [1, ref tail..] => &tail[0],
_ => unreachable!()
};
println!("{}", *el);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#![feature(advanced_slice_patterns)]
+
fn a() {
let x = [1i];
match x {
fn b() {
let x = [1i, 2, 3];
match x {
- [a, b, ..c] => {
+ [a, b, c..] => {
assert_eq!(a, 1);
assert_eq!(b, 2);
let expected: &[_] = &[3];
}
}
match x {
- [..a, b, c] => {
+ [a.., b, c] => {
let expected: &[_] = &[1];
assert_eq!(a, expected);
assert_eq!(b, 2);
}
}
match x {
- [a, ..b, c] => {
+ [a, b.., c] => {
assert_eq!(a, 1);
let expected: &[_] = &[2];
assert_eq!(b, expected);
Foo { string: "baz".to_string() }
];
match x {
- [ref first, ..tail] => {
+ [ref first, tail..] => {
assert!(first.string == "foo".to_string());
assert_eq!(tail.len(), 2);
assert!(tail[0].string == "bar".to_string());
assert!(tail[1].string == "baz".to_string());
match tail {
- [Foo { .. }, _, Foo { .. }, .. _tail] => {
+ [Foo { .. }, _, Foo { .. }, _tail..] => {
unreachable!();
}
[Foo { string: ref a }, Foo { string: ref b }] => {
projects / rust.git / commitdiff