probe CFG_FLEX flex
probe CFG_BISON bison
probe CFG_PANDOC pandoc
-probe CFG_PDFLATEX pdflatex
probe CFG_XELATEX xelatex
-probe CFG_LUALATEX lualatex
probe CFG_GDB gdb
probe CFG_LLDB lldb
HTML_DEPS :=
endif
-# Check for the various external utilities for the EPUB/PDF docs:
-
-ifeq ($(CFG_LUALATEX),)
- $(info cfg: no lualatex found, deferring to xelatex)
- ifeq ($(CFG_XELATEX),)
- $(info cfg: no xelatex found, deferring to pdflatex)
- ifeq ($(CFG_PDFLATEX),)
- $(info cfg: no pdflatex found, disabling LaTeX docs)
- NO_PDF_DOCS = 1
- else
- CFG_LATEX := $(CFG_PDFLATEX)
- endif
- else
+# Check for xelatex
+
+ifeq ($(CFG_XELATEX),)
CFG_LATEX := $(CFG_XELATEX)
XELATEX = 1
- endif
-else
- CFG_LATEX := $(CFG_LUALATEX)
+ else
+ $(info cfg: no xelatex found, disabling LaTeX docs)
+ NO_PDF_DOCS = 1
endif
-
ifeq ($(CFG_PANDOC),)
$(info cfg: no pandoc found, omitting PDF and EPUB docs)
ONLY_HTML_DOCS = 1
CFAIL_FULL_RS := $(wildcard $(S)src/test/compile-fail-fulldeps/*.rs)
RFAIL_RS := $(wildcard $(S)src/test/run-fail/*.rs)
CFAIL_RS := $(wildcard $(S)src/test/compile-fail/*.rs)
+PFAIL_RS := $(wildcard $(S)src/test/parse-fail/*.rs)
BENCH_RS := $(wildcard $(S)src/test/bench/*.rs)
PRETTY_RS := $(wildcard $(S)src/test/pretty/*.rs)
DEBUGINFO_GDB_RS := $(wildcard $(S)src/test/debuginfo/*.rs)
RPASS_FULL_TESTS := $(RPASS_FULL_RS)
CFAIL_FULL_TESTS := $(CFAIL_FULL_RS)
RFAIL_TESTS := $(RFAIL_RS)
-CFAIL_TESTS := $(CFAIL_RS)
+CFAIL_TESTS := $(CFAIL_RS) $(PFAIL_RS)
BENCH_TESTS := $(BENCH_RS)
PERF_TESTS := $(PERF_RS)
PRETTY_TESTS := $(PRETTY_RS)
}
fn opt_path(m: &getopts::Matches, nm: &str) -> Path {
- Path::new(m.opt_str(nm).unwrap())
+ match m.opt_str(nm) {
+ Some(s) => Path::new(s),
+ None => panic!("no option (=path) found for {}", nm),
+ }
}
let filter = if !matches.free.is_empty() {
| [Number literals](#number-literals)`*` | Example | Exponentiation | Suffixes |
|----------------------------------------|---------|----------------|----------|
-| Decimal integer | `98_222is` | `N/A` | Integer suffixes |
-| Hex integer | `0xffis` | `N/A` | Integer suffixes |
-| Octal integer | `0o77is` | `N/A` | Integer suffixes |
-| Binary integer | `0b1111_0000is` | `N/A` | Integer suffixes |
-| Floating-point | `123.0E+77f64` | `Optional` | Floating-point suffixes |
+| Decimal integer | `98_222` | `N/A` | Integer suffixes |
+| Hex integer | `0xff` | `N/A` | Integer suffixes |
+| Octal integer | `0o77` | `N/A` | Integer suffixes |
+| Binary integer | `0b1111_0000` | `N/A` | Integer suffixes |
+| Floating-point | `123.0E+77` | `Optional` | Floating-point suffixes |
`*` All number literals allow `_` as a visual separator: `1_234.0E+18f64`
it can be thought of as being accessible to the outside world. For example:
```
-# #![allow(missing_copy_implementations)]
# fn main() {}
// Declare a private struct
struct Foo;
- `no_start` - disable linking to the `native` crate, which specifies the
"start" language item.
- `no_std` - disable linking to the `std` crate.
+- `plugin` — load a list of named crates as compiler plugins, e.g.
+ `#![plugin(foo, bar)]`. Optional arguments for each plugin,
+ i.e. `#![plugin(foo(... args ...))]`, are provided to the plugin's
+ registrar function. The `plugin` feature gate is required to use
+ this attribute.
### Module-only attributes
remove any padding between fields (note that this is very fragile and may
break platforms which require aligned access).
-### Macro- and plugin-related attributes
+### Macro-related attributes
- `macro_use` on a `mod` — macros defined in this module will be visible in the
module's parent, after this module has been included.
- `macro_export` - export a macro for cross-crate usage.
-- `plugin` on an `extern crate` — load this crate as a [compiler
- plugin][plugin]. The `plugin` feature gate is required. Any arguments to
- the attribute, e.g. `#[plugin=...]` or `#[plugin(...)]`, are provided to the
- plugin.
-
-- `no_link` on an `extern crate` — even if we load this crate for macros or
- compiler plugins, don't link it into the output.
+- `no_link` on an `extern crate` — even if we load this crate for macros, don't
+ link it into the output.
See the [macros section of the
book](book/macros.html#scoping-and-macro-import/export) for more information on
* `associated_types` - Allows type aliases in traits. Experimental.
+* `no_std` - Allows the `#![no_std]` crate attribute, which disables the implicit
+ `extern crate std`. This typically requires use of the unstable APIs
+ behind the libstd "facade", such as libcore and libcollections. It
+ may also cause problems when using syntax extensions, including
+ `#[derive]`.
+
If a feature is promoted to a language feature, then all existing programs will
start to receive compilation warnings about #[feature] directives which enabled
the new feature (because the directive is no longer necessary). However, if a
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
+// In the preceding 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.
extend the compiler's behavior with new syntax extensions, lint checks, etc.
A plugin is a dynamic library crate with a designated *registrar* function that
-registers extensions with `rustc`. Other crates can use these extensions by
-loading the plugin crate with `#[plugin] extern crate`. See the
+registers extensions with `rustc`. Other crates can load these extensions using
+the crate attribute `#![plugin(...)]`. See the
[`rustc::plugin`](../rustc/plugin/index.html) documentation for more about the
mechanics of defining and loading a plugin.
-Arguments passed as `#[plugin=...]` or `#[plugin(...)]` are not interpreted by
-rustc itself. They are provided to the plugin through the `Registry`'s [`args`
-method](../rustc/plugin/registry/struct.Registry.html#method.args).
+If present, arguments passed as `#![plugin(foo(... args ...))]` are not
+interpreted by rustc itself. They are provided to the plugin through the
+`Registry`'s [`args` method](../rustc/plugin/registry/struct.Registry.html#method.args).
# Syntax extensions
```ignore
#![feature(plugin)]
-
-#[plugin] extern crate roman_numerals;
+#![plugin(roman_numerals)]
fn main() {
assert_eq!(rn!(MMXV), 2015);
Then code like
```ignore
-#[plugin] extern crate lint_plugin_test;
+#![plugin(lint_plugin_test)]
fn lintme() { }
```
```ignore
// a minimal library
#![crate_type="lib"]
+#![feature(no_std)]
#![no_std]
# // fn main() {} tricked you, rustdoc!
```
in the same format as C:
```
+#![feature(lang_items, start, no_std)]
#![no_std]
-#![feature(lang_items, start)]
// Pull in the system libc library for what crt0.o likely requires
extern crate libc;
compiler's name mangling too:
```ignore
+#![feature(no_std)]
#![no_std]
#![no_main]
#![feature(lang_items, start)]
vectors provided from C, using idiomatic Rust practices.
```
+#![feature(lang_items, start, no_std)]
#![no_std]
-#![feature(lang_items, start)]
# extern crate libc;
extern crate core;
#[lang = "eh_personality"] extern fn eh_personality() {}
# #[start] fn start(argc: isize, argv: *const *const u8) -> isize { 0 }
# fn main() {}
-# mod std { // for-loops
-# pub use core::iter;
-# pub use core::option;
-# }
```
Note that there is one extra lang item here which differs from the examples
sugar for dynamic allocations via `malloc` and `free`:
```
+#![feature(lang_items, box_syntax, start, no_std)]
#![no_std]
-#![feature(lang_items, box_syntax, start)]
extern crate libc;
if not name in joint_features:
print "error: feature '" + name + "' is both a lang and lib feature but not whitelisted"
errors = True
- lang_status = lang_feature_stats[name][3]
+ lang_status = language_feature_stats[name][3]
lib_status = lib_feature_stats[name][3]
- lang_stable_since = lang_feature_stats[name][4]
+ lang_stable_since = language_feature_stats[name][4]
lib_stable_since = lib_feature_stats[name][4]
if lang_status != lib_status and lib_status != "deprecated":
//
// There are also two other expr subtypes: first, nonparen_expr
// disallows exprs surrounded by parens (including tuple expressions),
-// this is neccesary for BOX (place) expressions, so a parens expr
+// this is necessary for BOX (place) expressions, so a parens expr
// following the BOX is always parsed as the place. There is also
// expr_norange used in index_expr, which disallows '..' in
// expressions as that has special meaning inside of brackets.
ok[parser] = 0
bad[parser] = []
devnull = open(os.devnull, 'w')
-print "\n"
+print("\n")
for base, dirs, files in os.walk(args.source_dir[0]):
for f in filter(lambda p: p.endswith('.rs'), files):
p = os.path.join(base, f)
- compile_fail = 'compile-fail' in p
- ignore = any('ignore-test' in line or 'ignore-lexer-test' in line
- for line in open(p).readlines())
- if compile_fail or ignore:
+ parse_fail = 'parse-fail' in p
+ if sys.version_info.major == 3:
+ lines = open(p, encoding='utf-8').readlines()
+ else:
+ lines = open(p).readlines()
+ if any('ignore-test' in line or 'ignore-lexer-test' in line for line in lines):
continue
total += 1
for parser in args.parser:
if subprocess.call(parser, stdin=open(p), stderr=subprocess.STDOUT, stdout=devnull) == 0:
- ok[parser] += 1
+ if parse_fail:
+ bad[parser].append(p)
+ else:
+ ok[parser] += 1
else:
- bad[parser].append(p)
+ if parse_fail:
+ ok[parser] += 1
+ else:
+ bad[parser].append(p)
parser_stats = ', '.join(['{}: {}'.format(parser, ok[parser]) for parser in args.parser])
sys.stdout.write("\033[K\r total: {}, {}, scanned {}"
.format(total, os.path.relpath(parser_stats), os.path.relpath(p)))
devnull.close()
-print "\n"
+print("\n")
for parser in args.parser:
filename = os.path.basename(parser) + '.bad'
- print("writing {} files that failed to parse with {} to {}".format(len(bad[parser]), parser, filename))
+ print("writing {} files that did not yield the correct result with {} to {}".format(len(bad[parser]), parser, filename))
with open(filename, "w") as f:
- for p in bad[parser]:
- f.write(p)
- f.write("\n")
+ for p in bad[parser]:
+ f.write(p)
+ f.write("\n")
///
/// // stuff
///
- /// drop(five); // explict drop
+ /// drop(five); // explicit drop
/// }
/// {
/// let five = Arc::new(5);
///
/// // stuff
///
- /// drop(weak_five); // explict drop
+ /// drop(weak_five); // explicit drop
/// }
/// {
/// let five = Arc::new(5);
html_favicon_url = "http://www.rust-lang.org/favicon.ico",
html_root_url = "http://doc.rust-lang.org/nightly/")]
+#![feature(no_std)]
#![no_std]
#![feature(lang_items, unsafe_destructor)]
#![feature(box_syntax)]
#![feature(unboxed_closures)]
#![feature(core)]
#![feature(hash)]
-#![feature(libc)]
+#![cfg_attr(all(not(feature = "external_funcs"), not(feature = "external_crate")),
+ feature(libc))]
+
#[macro_use]
extern crate core;
#[doc(hidden)]
pub fn fixme_14344_be_sure_to_link_to_collections() {}
-#[cfg(not(test))]
+// NOTE: remove after next snapshot
+#[cfg(all(stage0, not(test)))]
#[doc(hidden)]
mod std {
pub use core::fmt;
/// An immutable reference-counted pointer type.
///
-/// See the [module level documentation](../index.html) for more details.
+/// See the [module level documentation](./index.html) for more details.
#[unsafe_no_drop_flag]
#[stable(feature = "rust1", since = "1.0.0")]
pub struct Rc<T> {
///
/// // stuff
///
- /// drop(five); // explict drop
+ /// drop(five); // explicit drop
/// }
/// {
/// let five = Rc::new(5);
///
/// Weak references do not count when determining if the inner value should be dropped.
///
-/// See the [module level documentation](../index.html) for more.
+/// See the [module level documentation](./index.html) for more.
#[unsafe_no_drop_flag]
#[unstable(feature = "alloc",
reason = "Weak pointers may not belong in this module.")]
///
/// // stuff
///
- /// drop(weak_five); // explict drop
+ /// drop(weak_five); // explicit drop
/// }
/// {
/// let five = Rc::new(5);
use std::rand::Rng;
use test::{Bencher, black_box};
-pub fn insert_rand_n<M, I, R>(n: uint,
+pub fn insert_rand_n<M, I, R>(n: usize,
map: &mut M,
b: &mut Bencher,
mut insert: I,
mut remove: R) where
- I: FnMut(&mut M, uint),
- R: FnMut(&mut M, uint),
+ I: FnMut(&mut M, usize),
+ R: FnMut(&mut M, usize),
{
// setup
let mut rng = rand::weak_rng();
for _ in 0..n {
- insert(map, rng.gen::<uint>() % n);
+ insert(map, rng.gen::<usize>() % n);
}
// measure
b.iter(|| {
- let k = rng.gen::<uint>() % n;
+ let k = rng.gen::<usize>() % n;
insert(map, k);
remove(map, k);
});
black_box(map);
}
-pub fn insert_seq_n<M, I, R>(n: uint,
+pub fn insert_seq_n<M, I, R>(n: usize,
map: &mut M,
b: &mut Bencher,
mut insert: I,
mut remove: R) where
- I: FnMut(&mut M, uint),
- R: FnMut(&mut M, uint),
+ I: FnMut(&mut M, usize),
+ R: FnMut(&mut M, usize),
{
// setup
- for i in 0u..n {
+ for i in 0..n {
insert(map, i * 2);
}
black_box(map);
}
-pub fn find_rand_n<M, T, I, F>(n: uint,
+pub fn find_rand_n<M, T, I, F>(n: usize,
map: &mut M,
b: &mut Bencher,
mut insert: I,
mut find: F) where
- I: FnMut(&mut M, uint),
- F: FnMut(&M, uint) -> T,
+ I: FnMut(&mut M, usize),
+ F: FnMut(&M, usize) -> T,
{
// setup
let mut rng = rand::weak_rng();
- let mut keys = (0..n).map(|_| rng.gen::<uint>() % n)
- .collect::<Vec<_>>();
+ let mut keys: Vec<_> = (0..n).map(|_| rng.gen::<usize>() % n).collect();
for k in &keys {
insert(map, *k);
})
}
-pub fn find_seq_n<M, T, I, F>(n: uint,
+pub fn find_seq_n<M, T, I, F>(n: usize,
map: &mut M,
b: &mut Bencher,
mut insert: I,
mut find: F) where
- I: FnMut(&mut M, uint),
- F: FnMut(&M, uint) -> T,
+ I: FnMut(&mut M, usize),
+ F: FnMut(&M, usize) -> T,
{
// setup
- for i in 0u..n {
+ for i in 0..n {
insert(map, i);
}
//! ```
//! use std::cmp::Ordering;
//! use std::collections::BinaryHeap;
-//! use std::uint;
+//! use std::usize;
//!
//! #[derive(Copy, Eq, PartialEq)]
//! struct State {
-//! cost: uint,
-//! position: uint,
+//! cost: usize,
+//! position: usize,
//! }
//!
//! // The priority queue depends on `Ord`.
//! }
//! }
//!
-//! // Each node is represented as an `uint`, for a shorter implementation.
+//! // Each node is represented as an `usize`, for a shorter implementation.
//! struct Edge {
-//! node: uint,
-//! cost: uint,
+//! node: usize,
+//! cost: usize,
//! }
//!
//! // Dijkstra's shortest path algorithm.
//!
//! // Start at `start` and use `dist` to track the current shortest distance
//! // to each node. This implementation isn't memory-efficient as it may leave duplicate
-//! // nodes in the queue. It also uses `uint::MAX` as a sentinel value,
+//! // nodes in the queue. It also uses `usize::MAX` as a sentinel value,
//! // for a simpler implementation.
-//! fn shortest_path(adj_list: &Vec<Vec<Edge>>, start: uint, goal: uint) -> uint {
+//! fn shortest_path(adj_list: &Vec<Vec<Edge>>, start: usize, goal: usize) -> usize {
//! // dist[node] = current shortest distance from `start` to `node`
-//! let mut dist: Vec<_> = (0..adj_list.len()).map(|_| uint::MAX).collect();
+//! let mut dist: Vec<_> = (0..adj_list.len()).map(|_| usize::MAX).collect();
//!
//! let mut heap = BinaryHeap::new();
//!
//! }
//!
//! // Goal not reachable
-//! uint::MAX
+//! usize::MAX
//! }
//!
//! fn main() {
//! assert_eq!(shortest_path(&graph, 0, 3), 3);
//! assert_eq!(shortest_path(&graph, 3, 0), 7);
//! assert_eq!(shortest_path(&graph, 0, 4), 5);
-//! assert_eq!(shortest_path(&graph, 4, 0), uint::MAX);
+//! assert_eq!(shortest_path(&graph, 4, 0), usize::MAX);
//! }
//! ```
/// ```
/// use std::collections::BinaryHeap;
/// let mut heap = BinaryHeap::new();
- /// heap.push(4u);
+ /// heap.push(4);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
pub fn new() -> BinaryHeap<T> { BinaryHeap { data: vec![] } }
/// ```
/// use std::collections::BinaryHeap;
/// let mut heap = BinaryHeap::with_capacity(10);
- /// heap.push(4u);
+ /// heap.push(4);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn with_capacity(capacity: uint) -> BinaryHeap<T> {
+ pub fn with_capacity(capacity: usize) -> BinaryHeap<T> {
BinaryHeap { data: Vec::with_capacity(capacity) }
}
/// use std::collections::BinaryHeap;
/// let mut heap = BinaryHeap::with_capacity(100);
/// assert!(heap.capacity() >= 100);
- /// heap.push(4u);
+ /// heap.push(4);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn capacity(&self) -> uint { self.data.capacity() }
+ pub fn capacity(&self) -> usize { self.data.capacity() }
/// Reserves the minimum capacity for exactly `additional` more elements to be inserted in the
/// given `BinaryHeap`. Does nothing if the capacity is already sufficient.
///
/// # Panics
///
- /// Panics if the new capacity overflows `uint`.
+ /// Panics if the new capacity overflows `usize`.
///
/// # Examples
///
/// let mut heap = BinaryHeap::new();
/// heap.reserve_exact(100);
/// assert!(heap.capacity() >= 100);
- /// heap.push(4u);
+ /// heap.push(4);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn reserve_exact(&mut self, additional: uint) {
+ pub fn reserve_exact(&mut self, additional: usize) {
self.data.reserve_exact(additional);
}
///
/// # Panics
///
- /// Panics if the new capacity overflows `uint`.
+ /// Panics if the new capacity overflows `usize`.
///
/// # Examples
///
/// let mut heap = BinaryHeap::new();
/// heap.reserve(100);
/// assert!(heap.capacity() >= 100);
- /// heap.push(4u);
+ /// heap.push(4);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn reserve(&mut self, additional: uint) {
+ pub fn reserve(&mut self, additional: usize) {
self.data.reserve(additional);
}
// zeroed element), shift along the others and move it back into the
// vector over the junk element. This reduces the constant factor
// compared to using swaps, which involves twice as many moves.
- fn sift_up(&mut self, start: uint, mut pos: uint) {
+ fn sift_up(&mut self, start: usize, mut pos: usize) {
unsafe {
let new = replace(&mut self.data[pos], zeroed());
}
}
- fn sift_down_range(&mut self, mut pos: uint, end: uint) {
+ fn sift_down_range(&mut self, mut pos: usize, end: usize) {
unsafe {
let start = pos;
let new = replace(&mut self.data[pos], zeroed());
}
}
- fn sift_down(&mut self, pos: uint) {
+ fn sift_down(&mut self, pos: usize) {
let len = self.len();
self.sift_down_range(pos, len);
}
/// Returns the length of the binary heap.
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn len(&self) -> uint { self.data.len() }
+ pub fn len(&self) -> usize { self.data.len() }
/// Checks if the binary heap is empty.
#[stable(feature = "rust1", since = "1.0.0")]
fn next(&mut self) -> Option<&'a T> { self.iter.next() }
#[inline]
- fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
+ fn size_hint(&self) -> (usize, Option<usize>) { self.iter.size_hint() }
}
#[stable(feature = "rust1", since = "1.0.0")]
fn next(&mut self) -> Option<T> { self.iter.next() }
#[inline]
- fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
+ fn size_hint(&self) -> (usize, Option<usize>) { self.iter.size_hint() }
}
#[stable(feature = "rust1", since = "1.0.0")]
fn next(&mut self) -> Option<T> { self.iter.next() }
#[inline]
- fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
+ fn size_hint(&self) -> (usize, Option<usize>) { self.iter.size_hint() }
}
#[stable(feature = "rust1", since = "1.0.0")]
#[test]
fn test_iterator() {
- let data = vec!(5, 9, 3);
+ let data = vec![5, 9, 3];
let iterout = [9, 5, 3];
let heap = BinaryHeap::from_vec(data);
let mut i = 0;
#[test]
fn test_iterator_reverse() {
- let data = vec!(5, 9, 3);
- let iterout = vec!(3, 5, 9);
+ let data = vec![5, 9, 3];
+ let iterout = vec![3, 5, 9];
let pq = BinaryHeap::from_vec(data);
- let v: Vec<int> = pq.iter().rev().map(|&x| x).collect();
+ let v: Vec<_> = pq.iter().rev().cloned().collect();
assert_eq!(v, iterout);
}
#[test]
fn test_move_iter() {
- let data = vec!(5, 9, 3);
- let iterout = vec!(9, 5, 3);
+ let data = vec![5, 9, 3];
+ let iterout = vec![9, 5, 3];
let pq = BinaryHeap::from_vec(data);
- let v: Vec<int> = pq.into_iter().collect();
+ let v: Vec<_> = pq.into_iter().collect();
assert_eq!(v, iterout);
}
#[test]
fn test_move_iter_size_hint() {
- let data = vec!(5, 9);
+ let data = vec![5, 9];
let pq = BinaryHeap::from_vec(data);
let mut it = pq.into_iter();
#[test]
fn test_move_iter_reverse() {
- let data = vec!(5, 9, 3);
- let iterout = vec!(3, 5, 9);
+ let data = vec![5, 9, 3];
+ let iterout = vec![3, 5, 9];
let pq = BinaryHeap::from_vec(data);
- let v: Vec<int> = pq.into_iter().rev().collect();
+ let v: Vec<_> = pq.into_iter().rev().collect();
assert_eq!(v, iterout);
}
#[test]
fn test_peek_and_pop() {
- let data = vec!(2u, 4, 6, 2, 1, 8, 10, 3, 5, 7, 0, 9, 1);
+ let data = vec![2, 4, 6, 2, 1, 8, 10, 3, 5, 7, 0, 9, 1];
let mut sorted = data.clone();
sorted.sort();
let mut heap = BinaryHeap::from_vec(data);
#[test]
fn test_push() {
- let mut heap = BinaryHeap::from_vec(vec!(2, 4, 9));
+ let mut heap = BinaryHeap::from_vec(vec![2, 4, 9]);
assert_eq!(heap.len(), 3);
assert!(*heap.peek().unwrap() == 9);
heap.push(11);
#[test]
fn test_push_unique() {
- let mut heap = BinaryHeap::from_vec(vec!(box 2, box 4, box 9));
+ let mut heap = BinaryHeap::from_vec(vec![box 2, box 4, box 9]);
assert_eq!(heap.len(), 3);
assert!(*heap.peek().unwrap() == box 9);
heap.push(box 11);
#[test]
fn test_push_pop() {
- let mut heap = BinaryHeap::from_vec(vec!(5, 5, 2, 1, 3));
+ let mut heap = BinaryHeap::from_vec(vec![5, 5, 2, 1, 3]);
assert_eq!(heap.len(), 5);
assert_eq!(heap.push_pop(6), 6);
assert_eq!(heap.len(), 5);
#[test]
fn test_replace() {
- let mut heap = BinaryHeap::from_vec(vec!(5, 5, 2, 1, 3));
+ let mut heap = BinaryHeap::from_vec(vec![5, 5, 2, 1, 3]);
assert_eq!(heap.len(), 5);
assert_eq!(heap.replace(6).unwrap(), 5);
assert_eq!(heap.len(), 5);
assert_eq!(heap.len(), 5);
}
- fn check_to_vec(mut data: Vec<int>) {
+ fn check_to_vec(mut data: Vec<i32>) {
let heap = BinaryHeap::from_vec(data.clone());
let mut v = heap.clone().into_vec();
v.sort();
#[test]
fn test_to_vec() {
- check_to_vec(vec!());
- check_to_vec(vec!(5));
- check_to_vec(vec!(3, 2));
- check_to_vec(vec!(2, 3));
- check_to_vec(vec!(5, 1, 2));
- check_to_vec(vec!(1, 100, 2, 3));
- check_to_vec(vec!(1, 3, 5, 7, 9, 2, 4, 6, 8, 0));
- check_to_vec(vec!(2, 4, 6, 2, 1, 8, 10, 3, 5, 7, 0, 9, 1));
- check_to_vec(vec!(9, 11, 9, 9, 9, 9, 11, 2, 3, 4, 11, 9, 0, 0, 0, 0));
- check_to_vec(vec!(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
- check_to_vec(vec!(10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0));
- check_to_vec(vec!(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 1, 2));
- check_to_vec(vec!(5, 4, 3, 2, 1, 5, 4, 3, 2, 1, 5, 4, 3, 2, 1));
+ check_to_vec(vec![]);
+ check_to_vec(vec![5]);
+ check_to_vec(vec![3, 2]);
+ check_to_vec(vec![2, 3]);
+ check_to_vec(vec![5, 1, 2]);
+ check_to_vec(vec![1, 100, 2, 3]);
+ check_to_vec(vec![1, 3, 5, 7, 9, 2, 4, 6, 8, 0]);
+ check_to_vec(vec![2, 4, 6, 2, 1, 8, 10, 3, 5, 7, 0, 9, 1]);
+ check_to_vec(vec![9, 11, 9, 9, 9, 9, 11, 2, 3, 4, 11, 9, 0, 0, 0, 0]);
+ check_to_vec(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+ check_to_vec(vec![10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]);
+ check_to_vec(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 1, 2]);
+ check_to_vec(vec![5, 4, 3, 2, 1, 5, 4, 3, 2, 1, 5, 4, 3, 2, 1]);
}
#[test]
fn test_empty_pop() {
- let mut heap = BinaryHeap::<int>::new();
+ let mut heap = BinaryHeap::<i32>::new();
assert!(heap.pop().is_none());
}
#[test]
fn test_empty_peek() {
- let empty = BinaryHeap::<int>::new();
+ let empty = BinaryHeap::<i32>::new();
assert!(empty.peek().is_none());
}
#[test]
fn test_empty_replace() {
- let mut heap = BinaryHeap::<int>::new();
+ let mut heap = BinaryHeap::new();
assert!(heap.replace(5).is_none());
}
#[test]
fn test_from_iter() {
- let xs = vec!(9u, 8, 7, 6, 5, 4, 3, 2, 1);
+ let xs = vec![9, 8, 7, 6, 5, 4, 3, 2, 1];
- let mut q: BinaryHeap<uint> = xs.iter().rev().map(|&x| x).collect();
+ let mut q: BinaryHeap<_> = xs.iter().rev().cloned().collect();
for &x in &xs {
assert_eq!(q.pop().unwrap(), x);
#[test]
fn test_drain() {
- let mut q: BinaryHeap<_> =
- [9u, 8, 7, 6, 5, 4, 3, 2, 1].iter().cloned().collect();
+ let mut q: BinaryHeap<_> = [9, 8, 7, 6, 5, 4, 3, 2, 1].iter().cloned().collect();
assert_eq!(q.drain().take(5).count(), 5);
// rather `or` and `and`.
// (1) Be careful, most things can overflow here because the amount of bits in
-// memory can overflow `uint`.
+// memory can overflow `usize`.
// (2) Make sure that the underlying vector has no excess length:
// E. g. `nbits == 16`, `storage.len() == 2` would be excess length,
// because the last word isn't used at all. This is important because some
//! bv.set(0, false);
//! bv.set(1, false);
//!
-//! for i in iter::range_inclusive(2, (max_prime as f64).sqrt() as uint) {
+//! for i in iter::range_inclusive(2, (max_prime as f64).sqrt() as usize) {
//! // if i is a prime
//! if bv[i] {
//! // Mark all multiples of i as non-prime (any multiples below i * i
//! };
//!
//! // Simple primality tests below our max bound
-//! let print_primes = 20u;
+//! let print_primes = 20;
//! print!("The primes below {} are: ", print_primes);
//! for x in 0..print_primes {
//! if primes.contains(&x) {
use core::num::Int;
use core::ops::Index;
use core::slice;
-use core::{u8, u32, uint};
+use core::{u8, u32, usize};
use bitv_set; //so meta
use Vec;
/// Internal representation of the bit vector
storage: Vec<u32>,
/// The number of valid bits in the internal representation
- nbits: uint
+ nbits: usize
}
// FIXME(Gankro): NopeNopeNopeNopeNope (wait for IndexGet to be a thing)
-impl Index<uint> for Bitv {
+impl Index<usize> for Bitv {
type Output = bool;
#[inline]
- fn index(&self, i: &uint) -> &bool {
+ fn index(&self, i: &usize) -> &bool {
if self.get(*i).expect("index out of bounds") {
&TRUE
} else {
}
/// Computes how many blocks are needed to store that many bits
-fn blocks_for_bits(bits: uint) -> uint {
+fn blocks_for_bits(bits: usize) -> usize {
// If we want 17 bits, dividing by 32 will produce 0. So we add 1 to make sure we
// reserve enough. But if we want exactly a multiple of 32, this will actually allocate
// one too many. So we need to check if that's the case. We can do that by computing if
// superior modulo operator on a power of two to this.
//
// Note that we can technically avoid this branch with the expression
- // `(nbits + u32::BITS - 1) / 32::BITS`, but if nbits is almost uint::MAX this will overflow.
+ // `(nbits + u32::BITS - 1) / 32::BITS`, but if nbits is almost usize::MAX this will overflow.
if bits % u32::BITS == 0 {
bits / u32::BITS
} else {
}
/// Computes the bitmask for the final word of the vector
-fn mask_for_bits(bits: uint) -> u32 {
+fn mask_for_bits(bits: usize) -> u32 {
// Note especially that a perfect multiple of u32::BITS should mask all 1s.
!0u32 >> (u32::BITS - bits % u32::BITS) % u32::BITS
}
/// ```
/// use std::collections::Bitv;
///
- /// let mut bv = Bitv::from_elem(10u, false);
- /// assert_eq!(bv.len(), 10u);
+ /// let mut bv = Bitv::from_elem(10, false);
+ /// assert_eq!(bv.len(), 10);
/// for x in bv.iter() {
/// assert_eq!(x, false);
/// }
/// ```
- pub fn from_elem(nbits: uint, bit: bool) -> Bitv {
+ pub fn from_elem(nbits: usize, bit: bool) -> Bitv {
let nblocks = blocks_for_bits(nbits);
let mut bitv = Bitv {
storage: repeat(if bit { !0u32 } else { 0u32 }).take(nblocks).collect(),
/// It is important to note that this function does not specify the
/// *length* of the returned bitvector, but only the *capacity*.
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn with_capacity(nbits: uint) -> Bitv {
+ pub fn with_capacity(nbits: usize) -> Bitv {
Bitv {
storage: Vec::with_capacity(blocks_for_bits(nbits)),
nbits: 0,
/// let bv = Bitv::from_fn(5, |i| { i % 2 == 0 });
/// assert!(bv.eq_vec(&[true, false, true, false, true]));
/// ```
- pub fn from_fn<F>(len: uint, mut f: F) -> Bitv where F: FnMut(uint) -> bool {
+ pub fn from_fn<F>(len: usize, mut f: F) -> Bitv where F: FnMut(usize) -> bool {
let mut bitv = Bitv::from_elem(len, false);
- for i in 0u..len {
+ for i in 0..len {
bitv.set(i, f(i));
}
bitv
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn get(&self, i: uint) -> Option<bool> {
+ pub fn get(&self, i: usize) -> Option<bool> {
if i >= self.nbits {
return None;
}
#[inline]
#[unstable(feature = "collections",
reason = "panic semantics are likely to change in the future")]
- pub fn set(&mut self, i: uint, x: bool) {
+ pub fn set(&mut self, i: usize, x: bool) {
assert!(i < self.nbits);
let w = i / u32::BITS;
let b = i % u32::BITS;
/// assert_eq!(bv.to_bytes(), vec!(0b00100000, 0b10000000));
/// ```
pub fn to_bytes(&self) -> Vec<u8> {
- fn bit(bitv: &Bitv, byte: uint, bit: uint) -> u8 {
+ fn bit(bitv: &Bitv, byte: usize, bit: usize) -> u8 {
let offset = byte * 8 + bit;
if offset >= bitv.nbits {
0
/// assert!(bv.eq_vec(&[false, true]));
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn truncate(&mut self, len: uint) {
+ pub fn truncate(&mut self, len: usize) {
if len < self.len() {
self.nbits = len;
// This fixes (2).
///
/// # Panics
///
- /// Panics if the new capacity overflows `uint`.
+ /// Panics if the new capacity overflows `usize`.
///
/// # Examples
///
/// assert!(bv.capacity() >= 13);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn reserve(&mut self, additional: uint) {
+ pub fn reserve(&mut self, additional: usize) {
let desired_cap = self.len().checked_add(additional).expect("capacity overflow");
let storage_len = self.storage.len();
if desired_cap > self.capacity() {
///
/// # Panics
///
- /// Panics if the new capacity overflows `uint`.
+ /// Panics if the new capacity overflows `usize`.
///
/// # Examples
///
/// assert!(bv.capacity() >= 13);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn reserve_exact(&mut self, additional: uint) {
+ pub fn reserve_exact(&mut self, additional: usize) {
let desired_cap = self.len().checked_add(additional).expect("capacity overflow");
let storage_len = self.storage.len();
if desired_cap > self.capacity() {
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn capacity(&self) -> uint {
- self.storage.capacity().checked_mul(u32::BITS).unwrap_or(uint::MAX)
+ pub fn capacity(&self) -> usize {
+ self.storage.capacity().checked_mul(u32::BITS).unwrap_or(usize::MAX)
}
/// Grows the `Bitv` in-place, adding `n` copies of `value` to the `Bitv`.
///
/// # Panics
///
- /// Panics if the new len overflows a `uint`.
+ /// Panics if the new len overflows a `usize`.
///
/// # Examples
///
/// assert_eq!(bv.len(), 10);
/// assert_eq!(bv.to_bytes(), vec!(0b01001011, 0b11000000));
/// ```
- pub fn grow(&mut self, n: uint, value: bool) {
+ pub fn grow(&mut self, n: usize, value: bool) {
// Note: we just bulk set all the bits in the last word in this fn in multiple places
// which is technically wrong if not all of these bits are to be used. However, at the end
// of this fn we call `fix_last_block` at the end of this fn, which should fix this.
/// Return the total number of bits in this vector
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn len(&self) -> uint { self.nbits }
+ pub fn len(&self) -> usize { self.nbits }
/// Returns true if there are no bits in this vector
#[inline]
#[derive(Clone)]
pub struct Iter<'a> {
bitv: &'a Bitv,
- next_idx: uint,
- end_idx: uint,
+ next_idx: usize,
+ end_idx: usize,
}
#[stable(feature = "rust1", since = "1.0.0")]
}
}
- fn size_hint(&self) -> (uint, Option<uint>) {
+ fn size_hint(&self) -> (usize, Option<usize>) {
let rem = self.end_idx - self.next_idx;
(rem, Some(rem))
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a> RandomAccessIterator for Iter<'a> {
#[inline]
- fn indexable(&self) -> uint {
+ fn indexable(&self) -> usize {
self.end_idx - self.next_idx
}
#[inline]
- fn idx(&mut self, index: uint) -> Option<bool> {
+ fn idx(&mut self, index: usize) -> Option<bool> {
if index >= self.indexable() {
None
} else {
///
/// It should also be noted that the amount of storage necessary for holding a
/// set of objects is proportional to the maximum of the objects when viewed
-/// as a `uint`.
+/// as a `usize`.
///
/// # Examples
///
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl FromIterator<uint> for BitvSet {
- fn from_iter<I:Iterator<Item=uint>>(iterator: I) -> BitvSet {
+impl FromIterator<usize> for BitvSet {
+ fn from_iter<I:Iterator<Item=usize>>(iterator: I) -> BitvSet {
let mut ret = BitvSet::new();
ret.extend(iterator);
ret
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl Extend<uint> for BitvSet {
+impl Extend<usize> for BitvSet {
#[inline]
- fn extend<I: Iterator<Item=uint>>(&mut self, iterator: I) {
+ fn extend<I: Iterator<Item=usize>>(&mut self, iterator: I) {
for i in iterator {
self.insert(i);
}
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn with_capacity(nbits: uint) -> BitvSet {
+ pub fn with_capacity(nbits: usize) -> BitvSet {
let bitv = Bitv::from_elem(nbits, false);
BitvSet::from_bitv(bitv)
}
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn capacity(&self) -> uint {
+ pub fn capacity(&self) -> usize {
self.bitv.capacity()
}
/// assert!(s.capacity() >= 10);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn reserve_len(&mut self, len: uint) {
+ pub fn reserve_len(&mut self, len: usize) {
let cur_len = self.bitv.len();
if len >= cur_len {
self.bitv.reserve(len - cur_len);
/// assert!(s.capacity() >= 10);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn reserve_len_exact(&mut self, len: uint) {
+ pub fn reserve_len_exact(&mut self, len: usize) {
let cur_len = self.bitv.len();
if len >= cur_len {
self.bitv.reserve_exact(len - cur_len);
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
pub fn iter(&self) -> bitv_set::Iter {
- SetIter {set: self, next_idx: 0u}
+ SetIter {set: self, next_idx: 0}
}
/// Iterator over each u32 stored in `self` union `other`.
set: self,
other: other,
merge: or,
- current_word: 0u32,
- next_idx: 0u
+ current_word: 0,
+ next_idx: 0
})
}
- /// Iterator over each uint stored in `self` intersect `other`.
+ /// Iterator over each usize stored in `self` intersect `other`.
/// See [intersect_with](#method.intersect_with) for an efficient in-place version.
///
/// # Examples
set: self,
other: other,
merge: bitand,
- current_word: 0u32,
+ current_word: 0,
next_idx: 0
}.take(min))
}
- /// Iterator over each uint stored in the `self` setminus `other`.
+ /// Iterator over each usize stored in the `self` setminus `other`.
/// See [difference_with](#method.difference_with) for an efficient in-place version.
///
/// # Examples
set: self,
other: other,
merge: diff,
- current_word: 0u32,
+ current_word: 0,
next_idx: 0
})
}
set: self,
other: other,
merge: bitxor,
- current_word: 0u32,
+ current_word: 0,
next_idx: 0
})
}
/// Return the number of set bits in this set.
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn len(&self) -> uint {
+ pub fn len(&self) -> usize {
self.bitv.blocks().fold(0, |acc, n| acc + n.count_ones())
}
/// Returns `true` if this set contains the specified integer.
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn contains(&self, value: &uint) -> bool {
+ pub fn contains(&self, value: &usize) -> bool {
let bitv = &self.bitv;
*value < bitv.nbits && bitv[*value]
}
/// Adds a value to the set. Returns `true` if the value was not already
/// present in the set.
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn insert(&mut self, value: uint) -> bool {
+ pub fn insert(&mut self, value: usize) -> bool {
if self.contains(&value) {
return false;
}
/// Removes a value from the set. Returns `true` if the value was
/// present in the set.
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn remove(&mut self, value: &uint) -> bool {
+ pub fn remove(&mut self, value: &usize) -> bool {
if !self.contains(value) {
return false;
}
#[stable(feature = "rust1", since = "1.0.0")]
pub struct SetIter<'a> {
set: &'a BitvSet,
- next_idx: uint
+ next_idx: usize
}
/// An iterator combining two `BitvSet` iterators.
other: &'a BitvSet,
merge: fn(u32, u32) -> u32,
current_word: u32,
- next_idx: uint
+ next_idx: usize
}
#[stable(feature = "rust1", since = "1.0.0")]
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a> Iterator for SetIter<'a> {
- type Item = uint;
+ type Item = usize;
- fn next(&mut self) -> Option<uint> {
+ fn next(&mut self) -> Option<usize> {
while self.next_idx < self.set.bitv.len() {
let idx = self.next_idx;
self.next_idx += 1;
}
#[inline]
- fn size_hint(&self) -> (uint, Option<uint>) {
+ fn size_hint(&self) -> (usize, Option<usize>) {
(0, Some(self.set.bitv.len() - self.next_idx))
}
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a> Iterator for TwoBitPositions<'a> {
- type Item = uint;
+ type Item = usize;
- fn next(&mut self) -> Option<uint> {
+ fn next(&mut self) -> Option<usize> {
while self.next_idx < self.set.bitv.len() ||
self.next_idx < self.other.bitv.len() {
let bit_idx = self.next_idx % u32::BITS;
}
#[inline]
- fn size_hint(&self) -> (uint, Option<uint>) {
+ fn size_hint(&self) -> (usize, Option<usize>) {
let cap = cmp::max(self.set.bitv.len(), self.other.bitv.len());
(0, Some(cap - self.next_idx))
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a> Iterator for Union<'a> {
- type Item = uint;
+ type Item = usize;
- #[inline] fn next(&mut self) -> Option<uint> { self.0.next() }
- #[inline] fn size_hint(&self) -> (uint, Option<uint>) { self.0.size_hint() }
+ #[inline] fn next(&mut self) -> Option<usize> { self.0.next() }
+ #[inline] fn size_hint(&self) -> (usize, Option<usize>) { self.0.size_hint() }
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a> Iterator for Intersection<'a> {
- type Item = uint;
+ type Item = usize;
- #[inline] fn next(&mut self) -> Option<uint> { self.0.next() }
- #[inline] fn size_hint(&self) -> (uint, Option<uint>) { self.0.size_hint() }
+ #[inline] fn next(&mut self) -> Option<usize> { self.0.next() }
+ #[inline] fn size_hint(&self) -> (usize, Option<usize>) { self.0.size_hint() }
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a> Iterator for Difference<'a> {
- type Item = uint;
+ type Item = usize;
- #[inline] fn next(&mut self) -> Option<uint> { self.0.next() }
- #[inline] fn size_hint(&self) -> (uint, Option<uint>) { self.0.size_hint() }
+ #[inline] fn next(&mut self) -> Option<usize> { self.0.next() }
+ #[inline] fn size_hint(&self) -> (usize, Option<usize>) { self.0.size_hint() }
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a> Iterator for SymmetricDifference<'a> {
- type Item = uint;
+ type Item = usize;
- #[inline] fn next(&mut self) -> Option<uint> { self.0.next() }
- #[inline] fn size_hint(&self) -> (uint, Option<uint>) { self.0.size_hint() }
+ #[inline] fn next(&mut self) -> Option<usize> { self.0.next() }
+ #[inline] fn size_hint(&self) -> (usize, Option<usize>) { self.0.size_hint() }
}
impl<'a> IntoIterator for &'a BitvSet {
let zerolen = Bitv::new();
assert_eq!(format!("{:?}", zerolen), "");
- let eightbits = Bitv::from_elem(8u, false);
+ let eightbits = Bitv::from_elem(8, false);
assert_eq!(format!("{:?}", eightbits), "00000000")
}
#[test]
fn test_1_element() {
- let mut act = Bitv::from_elem(1u, false);
+ let mut act = Bitv::from_elem(1, false);
assert!(act.eq_vec(&[false]));
assert!(act.none() && !act.all());
- act = Bitv::from_elem(1u, true);
+ act = Bitv::from_elem(1, true);
assert!(act.eq_vec(&[true]));
assert!(!act.none() && act.all());
}
let mut act;
// all 0
- act = Bitv::from_elem(10u, false);
+ act = Bitv::from_elem(10, false);
assert!((act.eq_vec(
&[false, false, false, false, false, false, false, false, false, false])));
assert!(act.none() && !act.all());
// all 1
- act = Bitv::from_elem(10u, true);
+ act = Bitv::from_elem(10, true);
assert!((act.eq_vec(&[true, true, true, true, true, true, true, true, true, true])));
assert!(!act.none() && act.all());
// mixed
- act = Bitv::from_elem(10u, false);
- act.set(0u, true);
- act.set(1u, true);
- act.set(2u, true);
- act.set(3u, true);
- act.set(4u, true);
+ act = Bitv::from_elem(10, false);
+ act.set(0, true);
+ act.set(1, true);
+ act.set(2, true);
+ act.set(3, true);
+ act.set(4, true);
assert!((act.eq_vec(&[true, true, true, true, true, false, false, false, false, false])));
assert!(!act.none() && !act.all());
// mixed
- act = Bitv::from_elem(10u, false);
- act.set(5u, true);
- act.set(6u, true);
- act.set(7u, true);
- act.set(8u, true);
- act.set(9u, true);
+ act = Bitv::from_elem(10, false);
+ act.set(5, true);
+ act.set(6, true);
+ act.set(7, true);
+ act.set(8, true);
+ act.set(9, true);
assert!((act.eq_vec(&[false, false, false, false, false, true, true, true, true, true])));
assert!(!act.none() && !act.all());
// mixed
- act = Bitv::from_elem(10u, false);
- act.set(0u, true);
- act.set(3u, true);
- act.set(6u, true);
- act.set(9u, true);
+ act = Bitv::from_elem(10, false);
+ act.set(0, true);
+ act.set(3, true);
+ act.set(6, true);
+ act.set(9, true);
assert!((act.eq_vec(&[true, false, false, true, false, false, true, false, false, true])));
assert!(!act.none() && !act.all());
}
let mut act;
// all 0
- act = Bitv::from_elem(31u, false);
+ act = Bitv::from_elem(31, false);
assert!(act.eq_vec(
&[false, false, false, false, false, false, false, false, false, false, false,
false, false, false, false, false, false, false, false, false, false, false,
assert!(act.none() && !act.all());
// all 1
- act = Bitv::from_elem(31u, true);
+ act = Bitv::from_elem(31, true);
assert!(act.eq_vec(
&[true, true, true, true, true, true, true, true, true, true, true, true, true,
true, true, true, true, true, true, true, true, true, true, true, true, true,
assert!(!act.none() && act.all());
// mixed
- act = Bitv::from_elem(31u, false);
- act.set(0u, true);
- act.set(1u, true);
- act.set(2u, true);
- act.set(3u, true);
- act.set(4u, true);
- act.set(5u, true);
- act.set(6u, true);
- act.set(7u, true);
+ act = Bitv::from_elem(31, false);
+ act.set(0, true);
+ act.set(1, true);
+ act.set(2, true);
+ act.set(3, true);
+ act.set(4, true);
+ act.set(5, true);
+ act.set(6, true);
+ act.set(7, true);
assert!(act.eq_vec(
&[true, true, true, true, true, true, true, true, false, false, false, false, false,
false, false, false, false, false, false, false, false, false, false, false,
assert!(!act.none() && !act.all());
// mixed
- act = Bitv::from_elem(31u, false);
- act.set(16u, true);
- act.set(17u, true);
- act.set(18u, true);
- act.set(19u, true);
- act.set(20u, true);
- act.set(21u, true);
- act.set(22u, true);
- act.set(23u, true);
+ act = Bitv::from_elem(31, false);
+ act.set(16, true);
+ act.set(17, true);
+ act.set(18, true);
+ act.set(19, true);
+ act.set(20, true);
+ act.set(21, true);
+ act.set(22, true);
+ act.set(23, true);
assert!(act.eq_vec(
&[false, false, false, false, false, false, false, false, false, false, false,
false, false, false, false, false, true, true, true, true, true, true, true, true,
assert!(!act.none() && !act.all());
// mixed
- act = Bitv::from_elem(31u, false);
- act.set(24u, true);
- act.set(25u, true);
- act.set(26u, true);
- act.set(27u, true);
- act.set(28u, true);
- act.set(29u, true);
- act.set(30u, true);
+ act = Bitv::from_elem(31, false);
+ act.set(24, true);
+ act.set(25, true);
+ act.set(26, true);
+ act.set(27, true);
+ act.set(28, true);
+ act.set(29, true);
+ act.set(30, true);
assert!(act.eq_vec(
&[false, false, false, false, false, false, false, false, false, false, false,
false, false, false, false, false, false, false, false, false, false, false,
assert!(!act.none() && !act.all());
// mixed
- act = Bitv::from_elem(31u, false);
- act.set(3u, true);
- act.set(17u, true);
- act.set(30u, true);
+ act = Bitv::from_elem(31, false);
+ act.set(3, true);
+ act.set(17, true);
+ act.set(30, true);
assert!(act.eq_vec(
&[false, false, false, true, false, false, false, false, false, false, false, false,
false, false, false, false, false, true, false, false, false, false, false, false,
let mut act;
// all 0
- act = Bitv::from_elem(32u, false);
+ act = Bitv::from_elem(32, false);
assert!(act.eq_vec(
&[false, false, false, false, false, false, false, false, false, false, false,
false, false, false, false, false, false, false, false, false, false, false,
assert!(act.none() && !act.all());
// all 1
- act = Bitv::from_elem(32u, true);
+ act = Bitv::from_elem(32, true);
assert!(act.eq_vec(
&[true, true, true, true, true, true, true, true, true, true, true, true, true,
true, true, true, true, true, true, true, true, true, true, true, true, true,
assert!(!act.none() && act.all());
// mixed
- act = Bitv::from_elem(32u, false);
- act.set(0u, true);
- act.set(1u, true);
- act.set(2u, true);
- act.set(3u, true);
- act.set(4u, true);
- act.set(5u, true);
- act.set(6u, true);
- act.set(7u, true);
+ act = Bitv::from_elem(32, false);
+ act.set(0, true);
+ act.set(1, true);
+ act.set(2, true);
+ act.set(3, true);
+ act.set(4, true);
+ act.set(5, true);
+ act.set(6, true);
+ act.set(7, true);
assert!(act.eq_vec(
&[true, true, true, true, true, true, true, true, false, false, false, false, false,
false, false, false, false, false, false, false, false, false, false, false,
assert!(!act.none() && !act.all());
// mixed
- act = Bitv::from_elem(32u, false);
- act.set(16u, true);
- act.set(17u, true);
- act.set(18u, true);
- act.set(19u, true);
- act.set(20u, true);
- act.set(21u, true);
- act.set(22u, true);
- act.set(23u, true);
+ act = Bitv::from_elem(32, false);
+ act.set(16, true);
+ act.set(17, true);
+ act.set(18, true);
+ act.set(19, true);
+ act.set(20, true);
+ act.set(21, true);
+ act.set(22, true);
+ act.set(23, true);
assert!(act.eq_vec(
&[false, false, false, false, false, false, false, false, false, false, false,
false, false, false, false, false, true, true, true, true, true, true, true, true,
assert!(!act.none() && !act.all());
// mixed
- act = Bitv::from_elem(32u, false);
- act.set(24u, true);
- act.set(25u, true);
- act.set(26u, true);
- act.set(27u, true);
- act.set(28u, true);
- act.set(29u, true);
- act.set(30u, true);
- act.set(31u, true);
+ act = Bitv::from_elem(32, false);
+ act.set(24, true);
+ act.set(25, true);
+ act.set(26, true);
+ act.set(27, true);
+ act.set(28, true);
+ act.set(29, true);
+ act.set(30, true);
+ act.set(31, true);
assert!(act.eq_vec(
&[false, false, false, false, false, false, false, false, false, false, false,
false, false, false, false, false, false, false, false, false, false, false,
assert!(!act.none() && !act.all());
// mixed
- act = Bitv::from_elem(32u, false);
- act.set(3u, true);
- act.set(17u, true);
- act.set(30u, true);
- act.set(31u, true);
+ act = Bitv::from_elem(32, false);
+ act.set(3, true);
+ act.set(17, true);
+ act.set(30, true);
+ act.set(31, true);
assert!(act.eq_vec(
&[false, false, false, true, false, false, false, false, false, false, false, false,
false, false, false, false, false, true, false, false, false, false, false, false,
let mut act;
// all 0
- act = Bitv::from_elem(33u, false);
+ act = Bitv::from_elem(33, false);
assert!(act.eq_vec(
&[false, false, false, false, false, false, false, false, false, false, false,
false, false, false, false, false, false, false, false, false, false, false,
assert!(act.none() && !act.all());
// all 1
- act = Bitv::from_elem(33u, true);
+ act = Bitv::from_elem(33, true);
assert!(act.eq_vec(
&[true, true, true, true, true, true, true, true, true, true, true, true, true,
true, true, true, true, true, true, true, true, true, true, true, true, true,
assert!(!act.none() && act.all());
// mixed
- act = Bitv::from_elem(33u, false);
- act.set(0u, true);
- act.set(1u, true);
- act.set(2u, true);
- act.set(3u, true);
- act.set(4u, true);
- act.set(5u, true);
- act.set(6u, true);
- act.set(7u, true);
+ act = Bitv::from_elem(33, false);
+ act.set(0, true);
+ act.set(1, true);
+ act.set(2, true);
+ act.set(3, true);
+ act.set(4, true);
+ act.set(5, true);
+ act.set(6, true);
+ act.set(7, true);
assert!(act.eq_vec(
&[true, true, true, true, true, true, true, true, false, false, false, false, false,
false, false, false, false, false, false, false, false, false, false, false,
assert!(!act.none() && !act.all());
// mixed
- act = Bitv::from_elem(33u, false);
- act.set(16u, true);
- act.set(17u, true);
- act.set(18u, true);
- act.set(19u, true);
- act.set(20u, true);
- act.set(21u, true);
- act.set(22u, true);
- act.set(23u, true);
+ act = Bitv::from_elem(33, false);
+ act.set(16, true);
+ act.set(17, true);
+ act.set(18, true);
+ act.set(19, true);
+ act.set(20, true);
+ act.set(21, true);
+ act.set(22, true);
+ act.set(23, true);
assert!(act.eq_vec(
&[false, false, false, false, false, false, false, false, false, false, false,
false, false, false, false, false, true, true, true, true, true, true, true, true,
assert!(!act.none() && !act.all());
// mixed
- act = Bitv::from_elem(33u, false);
- act.set(24u, true);
- act.set(25u, true);
- act.set(26u, true);
- act.set(27u, true);
- act.set(28u, true);
- act.set(29u, true);
- act.set(30u, true);
- act.set(31u, true);
+ act = Bitv::from_elem(33, false);
+ act.set(24, true);
+ act.set(25, true);
+ act.set(26, true);
+ act.set(27, true);
+ act.set(28, true);
+ act.set(29, true);
+ act.set(30, true);
+ act.set(31, true);
assert!(act.eq_vec(
&[false, false, false, false, false, false, false, false, false, false, false,
false, false, false, false, false, false, false, false, false, false, false,
assert!(!act.none() && !act.all());
// mixed
- act = Bitv::from_elem(33u, false);
- act.set(3u, true);
- act.set(17u, true);
- act.set(30u, true);
- act.set(31u, true);
- act.set(32u, true);
+ act = Bitv::from_elem(33, false);
+ act.set(3, true);
+ act.set(17, true);
+ act.set(30, true);
+ act.set(31, true);
+ act.set(32, true);
assert!(act.eq_vec(
&[false, false, false, true, false, false, false, false, false, false, false, false,
false, false, false, false, false, true, false, false, false, false, false, false,
#[test]
fn test_equal_differing_sizes() {
- let v0 = Bitv::from_elem(10u, false);
- let v1 = Bitv::from_elem(11u, false);
+ let v0 = Bitv::from_elem(10, false);
+ let v1 = Bitv::from_elem(11, false);
assert!(v0 != v1);
}
#[test]
fn test_equal_greatly_differing_sizes() {
- let v0 = Bitv::from_elem(10u, false);
- let v1 = Bitv::from_elem(110u, false);
+ let v0 = Bitv::from_elem(10, false);
+ let v1 = Bitv::from_elem(110, false);
assert!(v0 != v1);
}
#[test]
fn test_equal_sneaky_big() {
let mut a = Bitv::from_elem(100, false);
- for i in 0u..100 {
+ for i in 0..100 {
a.set(i, true);
}
let mut b = Bitv::from_elem(100, true);
- for i in 0u..100 {
+ for i in 0..100 {
b.set(i, true);
}
#[test]
fn test_to_bools() {
- let bools = vec!(false, false, true, false, false, true, true, false);
+ let bools = vec![false, false, true, false, false, true, true, false];
assert_eq!(Bitv::from_bytes(&[0b00100110]).iter().collect::<Vec<bool>>(), bools);
}
assert_eq!(bitv.iter().collect::<Vec<bool>>(), bools);
- let long = (0i32..10000).map(|i| i % 2 == 0).collect::<Vec<_>>();
+ let long: Vec<_> = (0i32..10000).map(|i| i % 2 == 0).collect();
let bitv: Bitv = long.iter().map(|n| *n).collect();
assert_eq!(bitv.iter().collect::<Vec<bool>>(), long)
}
#[test]
fn test_bitv_lt() {
- let mut a = Bitv::from_elem(5u, false);
- let mut b = Bitv::from_elem(5u, false);
+ let mut a = Bitv::from_elem(5, false);
+ let mut b = Bitv::from_elem(5, false);
assert!(!(a < b) && !(b < a));
b.set(2, true);
#[test]
fn test_ord() {
- let mut a = Bitv::from_elem(5u, false);
- let mut b = Bitv::from_elem(5u, false);
+ let mut a = Bitv::from_elem(5, false);
+ let mut b = Bitv::from_elem(5, false);
assert!(a <= b && a >= b);
a.set(1, true);
use super::Bitv;
- static BENCH_BITS : uint = 1 << 14;
+ static BENCH_BITS : usize = 1 << 14;
fn rng() -> rand::IsaacRng {
let seed: &[_] = &[1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
}
#[bench]
- fn bench_uint_small(b: &mut Bencher) {
+ fn bench_usize_small(b: &mut Bencher) {
let mut r = rng();
- let mut bitv = 0 as uint;
+ let mut bitv = 0 as usize;
b.iter(|| {
- for _ in 0u..100 {
- bitv |= 1 << ((r.next_u32() as uint) % u32::BITS);
+ for _ in 0..100 {
+ bitv |= 1 << ((r.next_u32() as usize) % u32::BITS);
}
black_box(&bitv);
});
let mut r = rng();
let mut bitv = Bitv::from_elem(BENCH_BITS, false);
b.iter(|| {
- for _ in 0u..100 {
- bitv.set((r.next_u32() as uint) % BENCH_BITS, true);
+ for _ in 0..100 {
+ bitv.set((r.next_u32() as usize) % BENCH_BITS, true);
}
black_box(&bitv);
});
let mut r = rng();
let mut bitv = Bitv::from_elem(BENCH_BITS, false);
b.iter(|| {
- for _ in 0u..100 {
- bitv.set((r.next_u32() as uint) % BENCH_BITS, r.gen());
+ for _ in 0..100 {
+ bitv.set((r.next_u32() as usize) % BENCH_BITS, r.gen());
}
black_box(&bitv);
});
let mut r = rng();
let mut bitv = Bitv::from_elem(u32::BITS, false);
b.iter(|| {
- for _ in 0u..100 {
- bitv.set((r.next_u32() as uint) % u32::BITS, true);
+ for _ in 0..100 {
+ bitv.set((r.next_u32() as usize) % u32::BITS, true);
}
black_box(&bitv);
});
fn bench_bitv_small_iter(b: &mut Bencher) {
let bitv = Bitv::from_elem(u32::BITS, false);
b.iter(|| {
- let mut sum = 0u;
- for _ in 0u..10 {
+ let mut sum = 0;
+ for _ in 0..10 {
for pres in &bitv {
- sum += pres as uint;
+ sum += pres as usize;
}
}
sum
fn bench_bitv_big_iter(b: &mut Bencher) {
let bitv = Bitv::from_elem(BENCH_BITS, false);
b.iter(|| {
- let mut sum = 0u;
+ let mut sum = 0;
for pres in &bitv {
- sum += pres as uint;
+ sum += pres as usize;
}
sum
})
}
#[test]
- fn test_bitv_set_from_uints() {
- let uints = vec![0, 2, 2, 3];
- let a: BitvSet = uints.into_iter().collect();
+ fn test_bitv_set_from_usizes() {
+ let usizes = vec![0, 2, 2, 3];
+ let a: BitvSet = usizes.into_iter().collect();
let mut b = BitvSet::new();
b.insert(0);
b.insert(2);
#[test]
fn test_bitv_set_iterator() {
- let uints = vec![0, 2, 2, 3];
- let bitv: BitvSet = uints.into_iter().collect();
+ let usizes = vec![0, 2, 2, 3];
+ let bitv: BitvSet = usizes.into_iter().collect();
- let idxs: Vec<uint> = bitv.iter().collect();
+ let idxs: Vec<_> = bitv.iter().collect();
assert_eq!(idxs, vec![0, 2, 3]);
- let long: BitvSet = (0u..10000).filter(|&n| n % 2 == 0).collect();
- let real = range_step(0, 10000, 2).collect::<Vec<uint>>();
+ let long: BitvSet = (0..10000).filter(|&n| n % 2 == 0).collect();
+ let real: Vec<_> = range_step(0, 10000, 2).collect();
- let idxs: Vec<uint> = long.iter().collect();
+ let idxs: Vec<_> = long.iter().collect();
assert_eq!(idxs, real);
}
for &b in &bools {
for &l in &lengths {
let bitset = BitvSet::from_bitv(Bitv::from_elem(l, b));
- assert_eq!(bitset.contains(&1u), b);
- assert_eq!(bitset.contains(&(l-1u)), b);
+ assert_eq!(bitset.contains(&1), b);
+ assert_eq!(bitset.contains(&(l-1)), b);
assert!(!bitset.contains(&l));
}
}
assert!(b.insert(3));
let expected = [3, 5, 11, 77];
- let actual = a.intersection(&b).collect::<Vec<uint>>();
+ let actual: Vec<_> = a.intersection(&b).collect();
assert_eq!(actual, expected);
}
assert!(b.insert(200));
let expected = [1, 5, 500];
- let actual = a.difference(&b).collect::<Vec<uint>>();
+ let actual: Vec<_> = a.difference(&b).collect();
assert_eq!(actual, expected);
}
assert!(b.insert(220));
let expected = [1, 5, 11, 14, 220];
- let actual = a.symmetric_difference(&b).collect::<Vec<uint>>();
+ let actual: Vec<_> = a.symmetric_difference(&b).collect();
assert_eq!(actual, expected);
}
assert!(b.insert(19));
let expected = [1, 3, 5, 9, 11, 13, 19, 24, 160, 200];
- let actual = a.union(&b).collect::<Vec<uint>>();
+ let actual: Vec<_> = a.union(&b).collect();
assert_eq!(actual, expected);
}
use super::{Bitv, BitvSet};
- static BENCH_BITS : uint = 1 << 14;
+ static BENCH_BITS : usize = 1 << 14;
fn rng() -> rand::IsaacRng {
let seed: &[_] = &[1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
let mut r = rng();
let mut bitv = BitvSet::new();
b.iter(|| {
- for _ in 0u..100 {
- bitv.insert((r.next_u32() as uint) % u32::BITS);
+ for _ in 0..100 {
+ bitv.insert((r.next_u32() as usize) % u32::BITS);
}
black_box(&bitv);
});
let mut r = rng();
let mut bitv = BitvSet::new();
b.iter(|| {
- for _ in 0u..100 {
- bitv.insert((r.next_u32() as uint) % BENCH_BITS);
+ for _ in 0..100 {
+ bitv.insert((r.next_u32() as usize) % BENCH_BITS);
}
black_box(&bitv);
});
let bitv = BitvSet::from_bitv(Bitv::from_fn(BENCH_BITS,
|idx| {idx % 3 == 0}));
b.iter(|| {
- let mut sum = 0u;
+ let mut sum = 0;
for idx in &bitv {
- sum += idx as uint;
+ sum += idx as usize;
}
sum
})
// writing (August 2014) freely licensed under the following Creative Commons Attribution
// License: [CC BY 2.5 CA](http://creativecommons.org/licenses/by/2.5/ca/).
-pub use self::Entry::*;
+use self::Entry::*;
use core::prelude::*;
/// would like to further explore choosing the optimal search strategy based on the choice of B,
/// and possibly other factors. Using linear search, searching for a random element is expected
/// to take O(B log<sub>B</sub>n) comparisons, which is generally worse than a BST. In practice,
-/// however, performance is excellent. `BTreeMap` is able to readily outperform `TreeMap` under
-/// many workloads, and is competitive where it doesn't. BTreeMap also generally *scales* better
-/// than TreeMap, making it more appropriate for large datasets.
-///
-/// However, `TreeMap` may still be more appropriate to use in many contexts. If elements are very
-/// large or expensive to compare, `TreeMap` may be more appropriate. It won't allocate any
-/// more space than is needed, and will perform the minimal number of comparisons necessary.
-/// `TreeMap` also provides much better performance stability guarantees. Generally, very few
-/// changes need to be made to update a BST, and two updates are expected to take about the same
-/// amount of time on roughly equal sized BSTs. However a B-Tree's performance is much more
-/// amortized. If a node is overfull, it must be split into two nodes. If a node is underfull, it
-/// may be merged with another. Both of these operations are relatively expensive to perform, and
-/// it's possible to force one to occur at every single level of the tree in a single insertion or
-/// deletion. In fact, a malicious or otherwise unlucky sequence of insertions and deletions can
-/// force this degenerate behaviour to occur on every operation. While the total amount of work
-/// done on each operation isn't *catastrophic*, and *is* still bounded by O(B log<sub>B</sub>n),
-/// it is certainly much slower when it does.
+/// however, performance is excellent.
#[derive(Clone)]
#[stable(feature = "rust1", since = "1.0.0")]
pub struct BTreeMap<K, V> {
root: Node<K, V>,
- length: uint,
- depth: uint,
- b: uint,
+ length: usize,
+ depth: usize,
+ b: usize,
}
/// An abstract base over-which all other BTree iterators are built.
struct AbsIter<T> {
traversals: RingBuf<T>,
- size: uint,
+ size: usize,
}
/// An iterator over a BTreeMap's entries.
/// Makes a new empty BTreeMap with the given B.
///
/// B cannot be less than 2.
- pub fn with_b(b: uint) -> BTreeMap<K, V> {
+ pub fn with_b(b: usize) -> BTreeMap<K, V> {
assert!(b > 1, "B must be greater than 1");
BTreeMap {
length: 0,
/// use std::collections::BTreeMap;
///
/// let mut a = BTreeMap::new();
- /// a.insert(1u, "a");
+ /// a.insert(1, "a");
/// a.clear();
/// assert!(a.is_empty());
/// ```
/// use std::collections::BTreeMap;
///
/// let mut map = BTreeMap::new();
- /// map.insert(1u, "a");
+ /// map.insert(1, "a");
/// assert_eq!(map.get(&1), Some(&"a"));
/// assert_eq!(map.get(&2), None);
/// ```
/// use std::collections::BTreeMap;
///
/// let mut map = BTreeMap::new();
- /// map.insert(1u, "a");
+ /// map.insert(1, "a");
/// assert_eq!(map.contains_key(&1), true);
/// assert_eq!(map.contains_key(&2), false);
/// ```
/// use std::collections::BTreeMap;
///
/// let mut map = BTreeMap::new();
- /// map.insert(1u, "a");
+ /// map.insert(1, "a");
/// match map.get_mut(&1) {
/// Some(x) => *x = "b",
/// None => (),
/// use std::collections::BTreeMap;
///
/// let mut map = BTreeMap::new();
- /// assert_eq!(map.insert(37u, "a"), None);
+ /// assert_eq!(map.insert(37, "a"), None);
/// assert_eq!(map.is_empty(), false);
///
/// map.insert(37, "b");
/// use std::collections::BTreeMap;
///
/// let mut map = BTreeMap::new();
- /// map.insert(1u, "a");
+ /// map.insert(1, "a");
/// assert_eq!(map.remove(&1), Some("a"));
/// assert_eq!(map.remove(&1), None);
/// ```
impl<K: Ord, Q: ?Sized, V> IndexMut<Q> for BTreeMap<K, V>
where Q: BorrowFrom<K> + Ord
{
- type Output = V;
-
fn index_mut(&mut self, key: &Q) -> &mut V {
self.get_mut(key).expect("no entry found for key")
}
}
}
- fn size_hint(&self) -> (uint, Option<uint>) {
+ fn size_hint(&self) -> (usize, Option<usize>) {
(self.size, Some(self.size))
}
}
type Item = (&'a K, &'a V);
fn next(&mut self) -> Option<(&'a K, &'a V)> { self.inner.next() }
- fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
+ fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, K, V> DoubleEndedIterator for Iter<'a, K, V> {
type Item = (&'a K, &'a mut V);
fn next(&mut self) -> Option<(&'a K, &'a mut V)> { self.inner.next() }
- fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
+ fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, K, V> DoubleEndedIterator for IterMut<'a, K, V> {
type Item = (K, V);
fn next(&mut self) -> Option<(K, V)> { self.inner.next() }
- fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
+ fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<K, V> DoubleEndedIterator for IntoIter<K, V> {
type Item = &'a K;
fn next(&mut self) -> Option<(&'a K)> { self.inner.next() }
- fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
+ fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, K, V> DoubleEndedIterator for Keys<'a, K, V> {
type Item = &'a V;
fn next(&mut self) -> Option<(&'a V)> { self.inner.next() }
- fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
+ fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, K, V> DoubleEndedIterator for Values<'a, K, V> {
impl<'a, K: Ord, V> VacantEntry<'a, K, V> {
/// Sets the value of the entry with the VacantEntry's key,
/// and returns a mutable reference to it.
- #[unstable(feature = "collections",
- reason = "matches collection reform v2 specification, waiting for dust to settle")]
+ #[stable(feature = "rust1", since = "1.0.0")]
pub fn insert(self, value: V) -> &'a mut V {
self.stack.insert(self.key, value)
}
impl<'a, K: Ord, V> OccupiedEntry<'a, K, V> {
/// Gets a reference to the value in the entry.
- #[unstable(feature = "collections",
- reason = "matches collection reform v2 specification, waiting for dust to settle")]
+ #[stable(feature = "rust1", since = "1.0.0")]
pub fn get(&self) -> &V {
self.stack.peek()
}
/// Gets a mutable reference to the value in the entry.
- #[unstable(feature = "collections",
- reason = "matches collection reform v2 specification, waiting for dust to settle")]
+ #[stable(feature = "rust1", since = "1.0.0")]
pub fn get_mut(&mut self) -> &mut V {
self.stack.peek_mut()
}
/// Converts the entry into a mutable reference to its value.
- #[unstable(feature = "collections",
- reason = "matches collection reform v2 specification, waiting for dust to settle")]
+ #[stable(feature = "rust1", since = "1.0.0")]
pub fn into_mut(self) -> &'a mut V {
self.stack.into_top()
}
/// Sets the value of the entry with the OccupiedEntry's key,
/// and returns the entry's old value.
- #[unstable(feature = "collections",
- reason = "matches collection reform v2 specification, waiting for dust to settle")]
+ #[stable(feature = "rust1", since = "1.0.0")]
pub fn insert(&mut self, mut value: V) -> V {
mem::swap(self.stack.peek_mut(), &mut value);
value
}
/// Takes the value of the entry out of the map, and returns it.
- #[unstable(feature = "collections",
- reason = "matches collection reform v2 specification, waiting for dust to settle")]
+ #[stable(feature = "rust1", since = "1.0.0")]
pub fn remove(self) -> V {
self.stack.remove()
}
/// use std::collections::BTreeMap;
///
/// let mut map = BTreeMap::new();
- /// map.insert(1u, "a");
- /// map.insert(2u, "b");
- /// map.insert(3u, "c");
+ /// map.insert(1, "a");
+ /// map.insert(2, "b");
+ /// map.insert(3, "c");
///
/// for (key, value) in map.iter() {
/// println!("{}: {}", key, value);
/// }
///
/// let (first_key, first_value) = map.iter().next().unwrap();
- /// assert_eq!((*first_key, *first_value), (1u, "a"));
+ /// assert_eq!((*first_key, *first_value), (1, "a"));
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
pub fn iter(&self) -> Iter<K, V> {
/// use std::collections::BTreeMap;
///
/// let mut map = BTreeMap::new();
- /// map.insert("a", 1u);
- /// map.insert("b", 2u);
- /// map.insert("c", 3u);
+ /// map.insert("a", 1);
+ /// map.insert("b", 2);
+ /// map.insert("c", 3);
///
/// // add 10 to the value if the key isn't "a"
/// for (key, value) in map.iter_mut() {
/// use std::collections::BTreeMap;
///
/// let mut map = BTreeMap::new();
- /// map.insert(1u, "a");
- /// map.insert(2u, "b");
- /// map.insert(3u, "c");
+ /// map.insert(1, "a");
+ /// map.insert(2, "b");
+ /// map.insert(3, "c");
///
/// for (key, value) in map.into_iter() {
/// println!("{}: {}", key, value);
/// use std::collections::BTreeMap;
///
/// let mut a = BTreeMap::new();
- /// a.insert(1u, "a");
- /// a.insert(2u, "b");
+ /// a.insert(1, "a");
+ /// a.insert(2, "b");
///
- /// let keys: Vec<uint> = a.keys().cloned().collect();
- /// assert_eq!(keys, vec![1u,2,]);
+ /// let keys: Vec<usize> = a.keys().cloned().collect();
+ /// assert_eq!(keys, vec![1,2,]);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
pub fn keys<'a>(&'a self) -> Keys<'a, K, V> {
/// use std::collections::BTreeMap;
///
/// let mut a = BTreeMap::new();
- /// a.insert(1u, "a");
- /// a.insert(2u, "b");
+ /// a.insert(1, "a");
+ /// a.insert(2, "b");
///
/// let values: Vec<&str> = a.values().cloned().collect();
/// assert_eq!(values, vec!["a","b"]);
///
/// let mut a = BTreeMap::new();
/// assert_eq!(a.len(), 0);
- /// a.insert(1u, "a");
+ /// a.insert(1, "a");
/// assert_eq!(a.len(), 1);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn len(&self) -> uint { self.length }
+ pub fn len(&self) -> usize { self.length }
/// Return true if the map contains no elements.
///
///
/// let mut a = BTreeMap::new();
/// assert!(a.is_empty());
- /// a.insert(1u, "a");
+ /// a.insert(1, "a");
/// assert!(!a.is_empty());
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
/// use std::collections::Bound::{Included, Unbounded};
///
/// let mut map = BTreeMap::new();
- /// map.insert(3u, "a");
- /// map.insert(5u, "b");
- /// map.insert(8u, "c");
+ /// map.insert(3, "a");
+ /// map.insert(5, "b");
+ /// map.insert(8, "c");
/// for (&key, &value) in map.range(Included(&4), Included(&8)) {
/// println!("{}: {}", key, value);
/// }
- /// assert_eq!(Some((&5u, &"b")), map.range(Included(&4), Unbounded).next());
+ /// assert_eq!(Some((&5, &"b")), map.range(Included(&4), Unbounded).next());
/// ```
#[unstable(feature = "collections",
reason = "matches collection reform specification, waiting for dust to settle")]
/// use std::collections::BTreeMap;
/// use std::collections::btree_map::Entry;
///
- /// let mut count: BTreeMap<&str, uint> = BTreeMap::new();
+ /// let mut count: BTreeMap<&str, usize> = BTreeMap::new();
///
/// // count the number of occurrences of letters in the vec
/// for x in vec!["a","b","a","c","a","b"].iter() {
/// }
/// }
///
- /// assert_eq!(count["a"], 3u);
+ /// assert_eq!(count["a"], 3);
/// ```
- /// The key must have the same ordering before or after `.to_owned()` is called.
- #[unstable(feature = "collections",
- reason = "precise API still under development")]
- pub fn entry<'a>(&'a mut self, mut key: K) -> Entry<'a, K, V> {
+ #[stable(feature = "rust1", since = "1.0.0")]
+ pub fn entry(&mut self, mut key: K) -> Entry<K, V> {
// same basic logic of `swap` and `pop`, blended together
let mut stack = stack::PartialSearchStack::new(self);
loop {
use prelude::*;
use std::iter::range_inclusive;
- use super::{BTreeMap, Occupied, Vacant};
+ use super::BTreeMap;
+ use super::Entry::{Occupied, Vacant};
use Bound::{self, Included, Excluded, Unbounded};
#[test]
fn test_basic_large() {
let mut map = BTreeMap::new();
- let size = 10000u;
+ let size = 10000;
assert_eq!(map.len(), 0);
for i in 0..size {
let mut map = BTreeMap::new();
assert_eq!(map.remove(&1), None);
assert_eq!(map.get(&1), None);
- assert_eq!(map.insert(1u, 1u), None);
+ assert_eq!(map.insert(1, 1), None);
assert_eq!(map.get(&1), Some(&1));
assert_eq!(map.insert(1, 2), Some(1));
assert_eq!(map.get(&1), Some(&2));
#[test]
fn test_iter() {
- let size = 10000u;
+ let size = 10000;
// Forwards
- let mut map: BTreeMap<uint, uint> = (0..size).map(|i| (i, i)).collect();
+ let mut map: BTreeMap<_, _> = (0..size).map(|i| (i, i)).collect();
- fn test<T>(size: uint, mut iter: T) where T: Iterator<Item=(uint, uint)> {
+ fn test<T>(size: usize, mut iter: T) where T: Iterator<Item=(usize, usize)> {
for i in 0..size {
assert_eq!(iter.size_hint(), (size - i, Some(size - i)));
assert_eq!(iter.next().unwrap(), (i, i));
#[test]
fn test_iter_rev() {
- let size = 10000u;
+ let size = 10000;
// Forwards
- let mut map: BTreeMap<uint, uint> = (0..size).map(|i| (i, i)).collect();
+ let mut map: BTreeMap<_, _> = (0..size).map(|i| (i, i)).collect();
- fn test<T>(size: uint, mut iter: T) where T: Iterator<Item=(uint, uint)> {
+ fn test<T>(size: usize, mut iter: T) where T: Iterator<Item=(usize, usize)> {
for i in 0..size {
assert_eq!(iter.size_hint(), (size - i, Some(size - i)));
assert_eq!(iter.next().unwrap(), (size - i - 1, size - i - 1));
#[test]
fn test_iter_mixed() {
- let size = 10000u;
+ let size = 10000;
// Forwards
- let mut map: BTreeMap<uint, uint> = (0..size).map(|i| (i, i)).collect();
+ let mut map: BTreeMap<_, _> = (0..size).map(|i| (i, i)).collect();
- fn test<T>(size: uint, mut iter: T)
- where T: Iterator<Item=(uint, uint)> + DoubleEndedIterator {
+ fn test<T>(size: usize, mut iter: T)
+ where T: Iterator<Item=(usize, usize)> + DoubleEndedIterator {
for i in 0..size / 4 {
assert_eq!(iter.size_hint(), (size - i * 2, Some(size - i * 2)));
assert_eq!(iter.next().unwrap(), (i, i));
#[test]
fn test_range_small() {
- let size = 5u;
+ let size = 5;
// Forwards
- let map: BTreeMap<uint, uint> = (0..size).map(|i| (i, i)).collect();
+ let map: BTreeMap<_, _> = (0..size).map(|i| (i, i)).collect();
- let mut j = 0u;
- for ((&k, &v), i) in map.range(Included(&2), Unbounded).zip(2u..size) {
+ let mut j = 0;
+ for ((&k, &v), i) in map.range(Included(&2), Unbounded).zip(2..size) {
assert_eq!(k, i);
assert_eq!(v, i);
j += 1;
#[test]
fn test_range_1000() {
- let size = 1000u;
- let map: BTreeMap<uint, uint> = (0..size).map(|i| (i, i)).collect();
+ let size = 1000;
+ let map: BTreeMap<_, _> = (0..size).map(|i| (i, i)).collect();
- fn test(map: &BTreeMap<uint, uint>, size: uint, min: Bound<&uint>, max: Bound<&uint>) {
+ fn test(map: &BTreeMap<u32, u32>, size: u32, min: Bound<&u32>, max: Bound<&u32>) {
let mut kvs = map.range(min, max).map(|(&k, &v)| (k, v));
let mut pairs = (0..size).map(|i| (i, i));
#[test]
fn test_range() {
- let size = 200u;
- let map: BTreeMap<uint, uint> = (0..size).map(|i| (i, i)).collect();
+ let size = 200;
+ let map: BTreeMap<_, _> = (0..size).map(|i| (i, i)).collect();
for i in 0..size {
for j in i..size {
fn test_entry(){
let xs = [(1, 10), (2, 20), (3, 30), (4, 40), (5, 50), (6, 60)];
- let mut map: BTreeMap<int, int> = xs.iter().map(|&x| x).collect();
+ let mut map: BTreeMap<_, _> = xs.iter().map(|&x| x).collect();
// Existing key (insert)
match map.entry(1) {
#[bench]
pub fn insert_rand_100(b: &mut Bencher) {
- let mut m : BTreeMap<uint,uint> = BTreeMap::new();
+ let mut m = BTreeMap::new();
insert_rand_n(100, &mut m, b,
|m, i| { m.insert(i, 1); },
|m, i| { m.remove(&i); });
#[bench]
pub fn insert_rand_10_000(b: &mut Bencher) {
- let mut m : BTreeMap<uint,uint> = BTreeMap::new();
+ let mut m = BTreeMap::new();
insert_rand_n(10_000, &mut m, b,
|m, i| { m.insert(i, 1); },
|m, i| { m.remove(&i); });
// Insert seq
#[bench]
pub fn insert_seq_100(b: &mut Bencher) {
- let mut m : BTreeMap<uint,uint> = BTreeMap::new();
+ let mut m = BTreeMap::new();
insert_seq_n(100, &mut m, b,
|m, i| { m.insert(i, 1); },
|m, i| { m.remove(&i); });
#[bench]
pub fn insert_seq_10_000(b: &mut Bencher) {
- let mut m : BTreeMap<uint,uint> = BTreeMap::new();
+ let mut m = BTreeMap::new();
insert_seq_n(10_000, &mut m, b,
|m, i| { m.insert(i, 1); },
|m, i| { m.remove(&i); });
// Find rand
#[bench]
pub fn find_rand_100(b: &mut Bencher) {
- let mut m : BTreeMap<uint,uint> = BTreeMap::new();
+ let mut m = BTreeMap::new();
find_rand_n(100, &mut m, b,
|m, i| { m.insert(i, 1); },
|m, i| { m.get(&i); });
#[bench]
pub fn find_rand_10_000(b: &mut Bencher) {
- let mut m : BTreeMap<uint,uint> = BTreeMap::new();
+ let mut m = BTreeMap::new();
find_rand_n(10_000, &mut m, b,
|m, i| { m.insert(i, 1); },
|m, i| { m.get(&i); });
// Find seq
#[bench]
pub fn find_seq_100(b: &mut Bencher) {
- let mut m : BTreeMap<uint,uint> = BTreeMap::new();
+ let mut m = BTreeMap::new();
find_seq_n(100, &mut m, b,
|m, i| { m.insert(i, 1); },
|m, i| { m.get(&i); });
#[bench]
pub fn find_seq_10_000(b: &mut Bencher) {
- let mut m : BTreeMap<uint,uint> = BTreeMap::new();
+ let mut m = BTreeMap::new();
find_seq_n(10_000, &mut m, b,
|m, i| { m.insert(i, 1); },
|m, i| { m.get(&i); });
}
- fn bench_iter(b: &mut Bencher, size: uint) {
- let mut map = BTreeMap::<uint, uint>::new();
+ fn bench_iter(b: &mut Bencher, size: i32) {
+ let mut map = BTreeMap::<i32, i32>::new();
let mut rng = weak_rng();
for _ in 0..size {
//
// Note: instead of accessing this field directly, please call the `len()` method, which should
// be more stable in the face of representation changes.
- _len: uint,
+ _len: usize,
// FIXME(gereeter) It shouldn't be necessary to store the capacity in every node, as it should
// be constant throughout the tree. Once a solution to this is found, it might be possible to
//
// Note: instead of accessing this field directly, please call the `capacity()` method, which
// should be more stable in the face of representation changes.
- _capacity: uint,
+ _capacity: usize,
}
struct NodeSlice<'a, K: 'a, V: 'a> {
///
/// Fails if `target_alignment` is not a power of two.
#[inline]
-fn round_up_to_next(unrounded: uint, target_alignment: uint) -> uint {
+fn round_up_to_next(unrounded: usize, target_alignment: usize) -> usize {
assert!(num::UnsignedInt::is_power_of_two(target_alignment));
(unrounded + target_alignment - 1) & !(target_alignment - 1)
}
// Returns a tuple of (val_offset, edge_offset),
// from the start of a mallocated array.
#[inline]
-fn calculate_offsets(keys_size: uint,
- vals_size: uint, vals_align: uint,
- edges_align: uint)
- -> (uint, uint) {
+fn calculate_offsets(keys_size: usize,
+ vals_size: usize, vals_align: usize,
+ edges_align: usize)
+ -> (usize, usize) {
let vals_offset = round_up_to_next(keys_size, vals_align);
let end_of_vals = vals_offset + vals_size;
// Returns a tuple of (minimum required alignment, array_size),
// from the start of a mallocated array.
#[inline]
-fn calculate_allocation(keys_size: uint, keys_align: uint,
- vals_size: uint, vals_align: uint,
- edges_size: uint, edges_align: uint)
- -> (uint, uint) {
+fn calculate_allocation(keys_size: usize, keys_align: usize,
+ vals_size: usize, vals_align: usize,
+ edges_size: usize, edges_align: usize)
+ -> (usize, usize) {
let (_, edges_offset) = calculate_offsets(keys_size,
vals_size, vals_align,
edges_align);
assert_eq!(calculate_offsets(6, 12, 4, 8), (8, 24));
}
-fn calculate_allocation_generic<K, V>(capacity: uint, is_leaf: bool) -> (uint, uint) {
+fn calculate_allocation_generic<K, V>(capacity: usize, is_leaf: bool) -> (usize, usize) {
let (keys_size, keys_align) = (capacity * mem::size_of::<K>(), mem::min_align_of::<K>());
let (vals_size, vals_align) = (capacity * mem::size_of::<V>(), mem::min_align_of::<V>());
let (edges_size, edges_align) = if is_leaf {
)
}
-fn calculate_offsets_generic<K, V>(capacity: uint, is_leaf: bool) -> (uint, uint) {
+fn calculate_offsets_generic<K, V>(capacity: usize, is_leaf: bool) -> (usize, usize) {
let keys_size = capacity * mem::size_of::<K>();
let vals_size = capacity * mem::size_of::<V>();
let vals_align = mem::min_align_of::<V>();
RawItems::from_parts(slice.as_ptr(), slice.len())
}
- unsafe fn from_parts(ptr: *const T, len: uint) -> RawItems<T> {
+ unsafe fn from_parts(ptr: *const T, len: usize) -> RawItems<T> {
if mem::size_of::<T>() == 0 {
RawItems {
head: ptr,
- tail: (ptr as uint + len) as *const T,
+ tail: (ptr as usize + len) as *const T,
}
} else {
RawItems {
head: ptr,
- tail: ptr.offset(len as int),
+ tail: ptr.offset(len as isize),
}
}
}
ptr::write(self.tail as *mut T, val);
if mem::size_of::<T>() == 0 {
- self.tail = (self.tail as uint + 1) as *const T;
+ self.tail = (self.tail as usize + 1) as *const T;
} else {
self.tail = self.tail.offset(1);
}
let ret = Some(ptr::read(self.head));
if mem::size_of::<T>() == 0 {
- self.head = (self.head as uint + 1) as *const T;
+ self.head = (self.head as usize + 1) as *const T;
} else {
self.head = self.head.offset(1);
}
} else {
unsafe {
if mem::size_of::<T>() == 0 {
- self.tail = (self.tail as uint - 1) as *const T;
+ self.tail = (self.tail as usize - 1) as *const T;
} else {
self.tail = self.tail.offset(-1);
}
impl<K, V> Node<K, V> {
/// Make a new internal node. The caller must initialize the result to fix the invariant that
/// there are `len() + 1` edges.
- unsafe fn new_internal(capacity: uint) -> Node<K, V> {
+ unsafe fn new_internal(capacity: usize) -> Node<K, V> {
let (alignment, size) = calculate_allocation_generic::<K, V>(capacity, false);
let buffer = heap::allocate(size, alignment);
Node {
keys: Unique(buffer as *mut K),
- vals: Unique(buffer.offset(vals_offset as int) as *mut V),
- edges: Unique(buffer.offset(edges_offset as int) as *mut Node<K, V>),
+ vals: Unique(buffer.offset(vals_offset as isize) as *mut V),
+ edges: Unique(buffer.offset(edges_offset as isize) as *mut Node<K, V>),
_len: 0,
_capacity: capacity,
}
}
/// Make a new leaf node
- fn new_leaf(capacity: uint) -> Node<K, V> {
+ fn new_leaf(capacity: usize) -> Node<K, V> {
let (alignment, size) = calculate_allocation_generic::<K, V>(capacity, true);
let buffer = unsafe { heap::allocate(size, alignment) };
Node {
keys: Unique(buffer as *mut K),
- vals: Unique(unsafe { buffer.offset(vals_offset as int) as *mut V }),
+ vals: Unique(unsafe { buffer.offset(vals_offset as isize) as *mut V }),
edges: Unique(ptr::null_mut()),
_len: 0,
_capacity: capacity,
///
/// ```rust,ignore
/// struct Nasty<'a> {
-/// first: &'a Node<uint, uint>,
-/// second: &'a Node<uint, uint>,
+/// first: &'a Node<usize, usize>,
+/// second: &'a Node<usize, usize>,
/// flag: &'a Cell<bool>,
/// }
///
/// impl<'a> Deref for Nasty<'a> {
-/// type Target = Node<uint, uint>;
+/// type Target = Node<usize, usize>;
///
-/// fn deref(&self) -> &Node<uint, uint> {
+/// fn deref(&self) -> &Node<usize, usize> {
/// if self.flag.get() {
/// &*self.second
/// } else {
#[derive(Copy)]
pub struct Handle<NodeRef, Type, NodeType> {
node: NodeRef,
- index: uint
+ index: usize
}
pub mod handle {
-> SearchResult<NodeRef> where Q: BorrowFrom<K> + Ord {
// FIXME(Gankro): Tune when to search linear or binary based on B (and maybe K/V).
// For the B configured as of this writing (B = 6), binary search was *significantly*
- // worse for uints.
+ // worse for usizes.
match node.as_slices_internal().search_linear(key) {
(index, true) => Found(Handle { node: node, index: index }),
(index, false) => GoDown(Handle { node: node, index: index }),
// Public interface
impl <K, V> Node<K, V> {
/// Make a leaf root from scratch
- pub fn make_leaf_root(b: uint) -> Node<K, V> {
+ pub fn make_leaf_root(b: usize) -> Node<K, V> {
Node::new_leaf(capacity_from_b(b))
}
/// Make an internal root and swap it with an old root
- pub fn make_internal_root(left_and_out: &mut Node<K,V>, b: uint, key: K, value: V,
+ pub fn make_internal_root(left_and_out: &mut Node<K,V>, b: usize, key: K, value: V,
right: Node<K,V>) {
let node = mem::replace(left_and_out, unsafe { Node::new_internal(capacity_from_b(b)) });
left_and_out._len = 1;
}
/// How many key-value pairs the node contains
- pub fn len(&self) -> uint {
+ pub fn len(&self) -> usize {
self._len
}
/// How many key-value pairs the node can fit
- pub fn capacity(&self) -> uint {
+ pub fn capacity(&self) -> usize {
self._capacity
}
impl<K, V, NodeRef: Deref<Target=Node<K, V>>> Handle<NodeRef, handle::Edge, handle::Internal> {
// This doesn't exist because there are no uses for it,
- // but is fine to add, analagous to edge_mut.
+ // but is fine to add, analogous to edge_mut.
//
// /// Returns a reference to the edge pointed-to by this handle. This should not be
// /// confused with `node`, which references the parent node of what is returned here.
/// # Panics (in debug build)
///
/// Panics if the given index is out of bounds.
- pub fn kv_handle(&mut self, index: uint) -> Handle<&mut Node<K, V>, handle::KV,
+ pub fn kv_handle(&mut self, index: usize) -> Handle<&mut Node<K, V>, handle::KV,
handle::LeafOrInternal> {
// Necessary for correctness, but in a private module
debug_assert!(index < self.len(), "kv_handle index out of bounds");
// This must be followed by insert_edge on an internal node.
#[inline]
- unsafe fn insert_kv(&mut self, index: uint, key: K, val: V) -> &mut V {
+ unsafe fn insert_kv(&mut self, index: usize, key: K, val: V) -> &mut V {
ptr::copy_memory(
- self.keys_mut().as_mut_ptr().offset(index as int + 1),
- self.keys().as_ptr().offset(index as int),
+ self.keys_mut().as_mut_ptr().offset(index as isize + 1),
+ self.keys().as_ptr().offset(index as isize),
self.len() - index
);
ptr::copy_memory(
- self.vals_mut().as_mut_ptr().offset(index as int + 1),
- self.vals().as_ptr().offset(index as int),
+ self.vals_mut().as_mut_ptr().offset(index as isize + 1),
+ self.vals().as_ptr().offset(index as isize),
self.len() - index
);
// This can only be called immediately after a call to insert_kv.
#[inline]
- unsafe fn insert_edge(&mut self, index: uint, edge: Node<K, V>) {
+ unsafe fn insert_edge(&mut self, index: usize, edge: Node<K, V>) {
ptr::copy_memory(
- self.edges_mut().as_mut_ptr().offset(index as int + 1),
- self.edges().as_ptr().offset(index as int),
+ self.edges_mut().as_mut_ptr().offset(index as isize + 1),
+ self.edges().as_ptr().offset(index as isize),
self.len() - index
);
ptr::write(self.edges_mut().get_unchecked_mut(index), edge);
// This must be followed by remove_edge on an internal node.
#[inline]
- unsafe fn remove_kv(&mut self, index: uint) -> (K, V) {
+ unsafe fn remove_kv(&mut self, index: usize) -> (K, V) {
let key = ptr::read(self.keys().get_unchecked(index));
let val = ptr::read(self.vals().get_unchecked(index));
ptr::copy_memory(
- self.keys_mut().as_mut_ptr().offset(index as int),
- self.keys().as_ptr().offset(index as int + 1),
+ self.keys_mut().as_mut_ptr().offset(index as isize),
+ self.keys().as_ptr().offset(index as isize + 1),
self.len() - index - 1
);
ptr::copy_memory(
- self.vals_mut().as_mut_ptr().offset(index as int),
- self.vals().as_ptr().offset(index as int + 1),
+ self.vals_mut().as_mut_ptr().offset(index as isize),
+ self.vals().as_ptr().offset(index as isize + 1),
self.len() - index - 1
);
// This can only be called immediately after a call to remove_kv.
#[inline]
- unsafe fn remove_edge(&mut self, index: uint) -> Node<K, V> {
+ unsafe fn remove_edge(&mut self, index: usize) -> Node<K, V> {
let edge = ptr::read(self.edges().get_unchecked(index));
ptr::copy_memory(
- self.edges_mut().as_mut_ptr().offset(index as int),
- self.edges().as_ptr().offset(index as int + 1),
+ self.edges_mut().as_mut_ptr().offset(index as isize),
+ self.edges().as_ptr().offset(index as isize + 1),
self.len() - index + 1
);
let right_offset = self.len() - right.len();
ptr::copy_nonoverlapping_memory(
right.keys_mut().as_mut_ptr(),
- self.keys().as_ptr().offset(right_offset as int),
+ self.keys().as_ptr().offset(right_offset as isize),
right.len()
);
ptr::copy_nonoverlapping_memory(
right.vals_mut().as_mut_ptr(),
- self.vals().as_ptr().offset(right_offset as int),
+ self.vals().as_ptr().offset(right_offset as isize),
right.len()
);
if !self.is_leaf() {
ptr::copy_nonoverlapping_memory(
right.edges_mut().as_mut_ptr(),
- self.edges().as_ptr().offset(right_offset as int),
+ self.edges().as_ptr().offset(right_offset as isize),
right.len() + 1
);
}
ptr::write(self.vals_mut().get_unchecked_mut(old_len), val);
ptr::copy_nonoverlapping_memory(
- self.keys_mut().as_mut_ptr().offset(old_len as int + 1),
+ self.keys_mut().as_mut_ptr().offset(old_len as isize + 1),
right.keys().as_ptr(),
right.len()
);
ptr::copy_nonoverlapping_memory(
- self.vals_mut().as_mut_ptr().offset(old_len as int + 1),
+ self.vals_mut().as_mut_ptr().offset(old_len as isize + 1),
right.vals().as_ptr(),
right.len()
);
if !self.is_leaf() {
ptr::copy_nonoverlapping_memory(
- self.edges_mut().as_mut_ptr().offset(old_len as int + 1),
+ self.edges_mut().as_mut_ptr().offset(old_len as isize + 1),
right.edges().as_ptr(),
right.len() + 1
);
}
/// Get the capacity of a node from the order of the parent B-Tree
-fn capacity_from_b(b: uint) -> uint {
+fn capacity_from_b(b: usize) -> usize {
2 * b - 1
}
/// Get the minimum load of a node from its capacity
-fn min_load_from_capacity(cap: uint) -> uint {
+fn min_load_from_capacity(cap: usize) -> usize {
// B - 1
cap / 2
}
// For deallocation when we are done iterating.
ptr: *mut u8,
- capacity: uint,
+ capacity: usize,
is_leaf: bool
}
$as_slices_internal:ident, $index:ident, $iter:ident) => {
impl<'a, K: Ord + 'a, V: 'a> $NodeSlice<'a, K, V> {
/// Performs linear search in a slice. Returns a tuple of (index, is_exact_match).
- fn search_linear<Q: ?Sized>(&self, key: &Q) -> (uint, bool)
+ fn search_linear<Q: ?Sized>(&self, key: &Q) -> (usize, bool)
where Q: BorrowFrom<K> + Ord {
for (i, k) in self.keys.iter().enumerate() {
match key.cmp(BorrowFrom::borrow_from(k)) {
/// B cannot be less than 2.
#[unstable(feature = "collections",
reason = "probably want this to be on the type, eventually")]
- pub fn with_b(b: uint) -> BTreeSet<T> {
+ pub fn with_b(b: usize) -> BTreeSet<T> {
BTreeSet { map: BTreeMap::with_b(b) }
}
}
/// ```
/// use std::collections::BTreeSet;
///
- /// let set: BTreeSet<uint> = [1u, 2, 3, 4].iter().map(|&x| x).collect();
+ /// let set: BTreeSet<usize> = [1, 2, 3, 4].iter().map(|&x| x).collect();
///
/// for x in set.iter() {
/// println!("{}", x);
/// }
///
- /// let v: Vec<uint> = set.iter().map(|&x| x).collect();
- /// assert_eq!(v, vec![1u,2,3,4]);
+ /// let v: Vec<usize> = set.iter().map(|&x| x).collect();
+ /// assert_eq!(v, vec![1,2,3,4]);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
pub fn iter(&self) -> Iter<T> {
/// ```
/// use std::collections::BTreeSet;
///
- /// let set: BTreeSet<uint> = [1u, 2, 3, 4].iter().map(|&x| x).collect();
+ /// let set: BTreeSet<usize> = [1, 2, 3, 4].iter().map(|&x| x).collect();
///
- /// let v: Vec<uint> = set.into_iter().collect();
- /// assert_eq!(v, vec![1u,2,3,4]);
+ /// let v: Vec<usize> = set.into_iter().collect();
+ /// assert_eq!(v, vec![1,2,3,4]);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
pub fn into_iter(self) -> IntoIter<T> {
/// use std::collections::Bound::{Included, Unbounded};
///
/// let mut set = BTreeSet::new();
- /// set.insert(3u);
- /// set.insert(5u);
- /// set.insert(8u);
+ /// set.insert(3);
+ /// set.insert(5);
+ /// set.insert(8);
/// for &elem in set.range(Included(&4), Included(&8)) {
/// println!("{}", elem);
/// }
- /// assert_eq!(Some(&5u), set.range(Included(&4), Unbounded).next());
+ /// assert_eq!(Some(&5), set.range(Included(&4), Unbounded).next());
/// ```
#[unstable(feature = "collections",
reason = "matches collection reform specification, waiting for dust to settle")]
/// use std::collections::BTreeSet;
///
/// let mut a = BTreeSet::new();
- /// a.insert(1u);
- /// a.insert(2u);
+ /// a.insert(1);
+ /// a.insert(2);
///
/// let mut b = BTreeSet::new();
- /// b.insert(2u);
- /// b.insert(3u);
+ /// b.insert(2);
+ /// b.insert(3);
///
- /// let diff: Vec<uint> = a.difference(&b).cloned().collect();
- /// assert_eq!(diff, vec![1u]);
+ /// let diff: Vec<usize> = a.difference(&b).cloned().collect();
+ /// assert_eq!(diff, vec![1]);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
pub fn difference<'a>(&'a self, other: &'a BTreeSet<T>) -> Difference<'a, T> {
/// use std::collections::BTreeSet;
///
/// let mut a = BTreeSet::new();
- /// a.insert(1u);
- /// a.insert(2u);
+ /// a.insert(1);
+ /// a.insert(2);
///
/// let mut b = BTreeSet::new();
- /// b.insert(2u);
- /// b.insert(3u);
+ /// b.insert(2);
+ /// b.insert(3);
///
- /// let sym_diff: Vec<uint> = a.symmetric_difference(&b).cloned().collect();
- /// assert_eq!(sym_diff, vec![1u,3]);
+ /// let sym_diff: Vec<usize> = a.symmetric_difference(&b).cloned().collect();
+ /// assert_eq!(sym_diff, vec![1,3]);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
pub fn symmetric_difference<'a>(&'a self, other: &'a BTreeSet<T>)
/// use std::collections::BTreeSet;
///
/// let mut a = BTreeSet::new();
- /// a.insert(1u);
- /// a.insert(2u);
+ /// a.insert(1);
+ /// a.insert(2);
///
/// let mut b = BTreeSet::new();
- /// b.insert(2u);
- /// b.insert(3u);
+ /// b.insert(2);
+ /// b.insert(3);
///
- /// let intersection: Vec<uint> = a.intersection(&b).cloned().collect();
- /// assert_eq!(intersection, vec![2u]);
+ /// let intersection: Vec<usize> = a.intersection(&b).cloned().collect();
+ /// assert_eq!(intersection, vec![2]);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
pub fn intersection<'a>(&'a self, other: &'a BTreeSet<T>)
/// use std::collections::BTreeSet;
///
/// let mut a = BTreeSet::new();
- /// a.insert(1u);
+ /// a.insert(1);
///
/// let mut b = BTreeSet::new();
- /// b.insert(2u);
+ /// b.insert(2);
///
- /// let union: Vec<uint> = a.union(&b).cloned().collect();
- /// assert_eq!(union, vec![1u,2]);
+ /// let union: Vec<usize> = a.union(&b).cloned().collect();
+ /// assert_eq!(union, vec![1,2]);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
pub fn union<'a>(&'a self, other: &'a BTreeSet<T>) -> Union<'a, T> {
/// assert_eq!(v.len(), 1);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn len(&self) -> uint { self.map.len() }
+ pub fn len(&self) -> usize { self.map.len() }
/// Returns true if the set contains no elements
///
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(feature = "rust1", since = "1.0.0")]
impl<'a, T> DoubleEndedIterator for Iter<'a, T> {
type Item = T;
fn next(&mut self) -> Option<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(feature = "rust1", since = "1.0.0")]
impl<T> DoubleEndedIterator for IntoIter<T> {
}
struct Counter<'a, 'b> {
- i: &'a mut uint,
- expected: &'b [int],
+ i: &'a mut usize,
+ expected: &'b [i32],
}
- impl<'a, 'b, 'c> FnMut<(&'c int,)> for Counter<'a, 'b> {
+ impl<'a, 'b, 'c> FnMut<(&'c i32,)> for Counter<'a, 'b> {
type Output = bool;
- extern "rust-call" fn call_mut(&mut self, (&x,): (&'c int,)) -> bool {
+ extern "rust-call" fn call_mut(&mut self, (&x,): (&'c i32,)) -> bool {
assert_eq!(x, self.expected[*self.i]);
*self.i += 1;
true
}
}
- fn check<F>(a: &[int], b: &[int], expected: &[int], f: F) where
+ fn check<F>(a: &[i32], b: &[i32], expected: &[i32], f: F) where
// FIXME Replace Counter with `Box<FnMut(_) -> _>`
- F: FnOnce(&BTreeSet<int>, &BTreeSet<int>, Counter) -> bool,
+ F: FnOnce(&BTreeSet<i32>, &BTreeSet<i32>, Counter) -> bool,
{
let mut set_a = BTreeSet::new();
let mut set_b = BTreeSet::new();
#[test]
fn test_intersection() {
- fn check_intersection(a: &[int], b: &[int], expected: &[int]) {
+ fn check_intersection(a: &[i32], b: &[i32], expected: &[i32]) {
check(a, b, expected, |x, y, f| x.intersection(y).all(f))
}
#[test]
fn test_difference() {
- fn check_difference(a: &[int], b: &[int], expected: &[int]) {
+ fn check_difference(a: &[i32], b: &[i32], expected: &[i32]) {
check(a, b, expected, |x, y, f| x.difference(y).all(f))
}
#[test]
fn test_symmetric_difference() {
- fn check_symmetric_difference(a: &[int], b: &[int],
- expected: &[int]) {
+ fn check_symmetric_difference(a: &[i32], b: &[i32], expected: &[i32]) {
check(a, b, expected, |x, y, f| x.symmetric_difference(y).all(f))
}
#[test]
fn test_union() {
- fn check_union(a: &[int], b: &[int],
- expected: &[int]) {
+ fn check_union(a: &[i32], b: &[i32], expected: &[i32]) {
check(a, b, expected, |x, y, f| x.union(y).all(f))
}
#[test]
fn test_zip() {
let mut x = BTreeSet::new();
- x.insert(5u);
- x.insert(12u);
- x.insert(11u);
+ x.insert(5);
+ x.insert(12);
+ x.insert(11);
let mut y = BTreeSet::new();
y.insert("foo");
let mut z = x.iter().zip(y.iter());
// FIXME: #5801: this needs a type hint to compile...
- let result: Option<(&uint, & &'static str)> = z.next();
- assert_eq!(result.unwrap(), (&5u, &("bar")));
+ let result: Option<(&usize, & &'static str)> = z.next();
+ assert_eq!(result.unwrap(), (&5, &("bar")));
- let result: Option<(&uint, & &'static str)> = z.next();
- assert_eq!(result.unwrap(), (&11u, &("foo")));
+ let result: Option<(&usize, & &'static str)> = z.next();
+ assert_eq!(result.unwrap(), (&11, &("foo")));
- let result: Option<(&uint, & &'static str)> = z.next();
+ let result: Option<(&usize, & &'static str)> = z.next();
assert!(result.is_none());
}
fn test_from_iter() {
let xs = [1, 2, 3, 4, 5, 6, 7, 8, 9];
- let set: BTreeSet<int> = xs.iter().map(|&x| x).collect();
+ let set: BTreeSet<_> = xs.iter().cloned().collect();
for x in &xs {
assert!(set.contains(x));
#[test]
fn test_show() {
- let mut set: BTreeSet<int> = BTreeSet::new();
- let empty: BTreeSet<int> = BTreeSet::new();
+ let mut set = BTreeSet::new();
+ let empty = BTreeSet::<i32>::new();
set.insert(1);
set.insert(2);
/// A doubly-linked list.
#[stable(feature = "rust1", since = "1.0.0")]
pub struct DList<T> {
- length: uint,
+ length: usize,
list_head: Link<T>,
list_tail: Rawlink<Node<T>>,
}
pub struct Iter<'a, T:'a> {
head: &'a Link<T>,
tail: Rawlink<Node<T>>,
- nelem: uint,
+ nelem: usize,
}
// FIXME #19839: deriving is too aggressive on the bounds (T doesn't need to be Clone).
list: &'a mut DList<T>,
head: Rawlink<Node<T>>,
tail: Rawlink<Node<T>>,
- nelem: uint,
+ nelem: usize,
}
/// An iterator over mutable references to the items of a `DList`.
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn len(&self) -> uint {
+ pub fn len(&self) -> usize {
self.length
}
/// assert_eq!(splitted.pop_front(), None);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn split_off(&mut self, at: uint) -> DList<T> {
+ pub fn split_off(&mut self, at: usize) -> DList<T> {
let len = self.len();
assert!(at < len, "Cannot split off at a nonexistent index");
if at == 0 {
}
#[inline]
- fn size_hint(&self) -> (uint, Option<uint>) {
+ fn size_hint(&self) -> (usize, Option<usize>) {
(self.nelem, Some(self.nelem))
}
}
}
#[inline]
- fn size_hint(&self) -> (uint, Option<uint>) {
+ fn size_hint(&self) -> (usize, Option<usize>) {
(self.nelem, Some(self.nelem))
}
}
fn next(&mut self) -> Option<A> { self.list.pop_front() }
#[inline]
- fn size_hint(&self) -> (uint, Option<uint>) {
+ fn size_hint(&self) -> (usize, Option<usize>) {
(self.list.length, Some(self.list.length))
}
}
use super::{DList, Node};
pub fn check_links<T>(list: &DList<T>) {
- let mut len = 0u;
+ let mut len = 0;
let mut last_ptr: Option<&Node<T>> = None;
let mut node_ptr: &Node<T>;
match list.list_head {
- None => { assert_eq!(0u, list.length); return }
+ None => { assert_eq!(0, list.length); return }
Some(ref node) => node_ptr = &**node,
}
loop {
#[test]
fn test_basic() {
- let mut m: DList<Box<int>> = DList::new();
+ let mut m = DList::new();
assert_eq!(m.pop_front(), None);
assert_eq!(m.pop_back(), None);
assert_eq!(m.pop_front(), None);
}
#[cfg(test)]
- fn generate_test() -> DList<int> {
+ fn generate_test() -> DList<i32> {
list_from(&[0,1,2,3,4,5,6])
}
fn test_append() {
// Empty to empty
{
- let mut m: DList<int> = DList::new();
+ let mut m = DList::<i32>::new();
let mut n = DList::new();
m.append(&mut n);
check_links(&m);
fn test_iterator() {
let m = generate_test();
for (i, elt) in m.iter().enumerate() {
- assert_eq!(i as int, *elt);
+ assert_eq!(i as i32, *elt);
}
let mut n = DList::new();
assert_eq!(n.iter().next(), None);
fn test_rev_iter() {
let m = generate_test();
for (i, elt) in m.iter().rev().enumerate() {
- assert_eq!((6 - i) as int, *elt);
+ assert_eq!((6 - i) as i32, *elt);
}
let mut n = DList::new();
assert_eq!(n.iter().rev().next(), None);
let mut m = generate_test();
let mut len = m.len();
for (i, elt) in m.iter_mut().enumerate() {
- assert_eq!(i as int, *elt);
+ assert_eq!(i as i32, *elt);
len -= 1;
}
assert_eq!(len, 0);
}
check_links(&m);
assert_eq!(m.len(), 3 + len * 2);
- assert_eq!(m.into_iter().collect::<Vec<int>>(), vec![-2,0,1,2,3,4,5,6,7,8,9,0,1]);
+ assert_eq!(m.into_iter().collect::<Vec<_>>(), vec![-2,0,1,2,3,4,5,6,7,8,9,0,1]);
}
#[test]
fn test_mut_rev_iter() {
let mut m = generate_test();
for (i, elt) in m.iter_mut().rev().enumerate() {
- assert_eq!((6-i) as int, *elt);
+ assert_eq!((6 - i) as i32, *elt);
}
let mut n = DList::new();
assert!(n.iter_mut().rev().next().is_none());
Thread::scoped(move || {
check_links(&n);
let a: &[_] = &[&1,&2,&3];
- assert_eq!(a, n.iter().collect::<Vec<&int>>());
+ assert_eq!(a, n.iter().collect::<Vec<_>>());
}).join().ok().unwrap();
}
#[test]
fn test_eq() {
- let mut n: DList<u8> = list_from(&[]);
+ let mut n = list_from(&[]);
let mut m = list_from(&[]);
assert!(n == m);
n.push_front(1);
#[test]
fn test_ord() {
- let n: DList<int> = list_from(&[]);
+ let n = list_from(&[]);
let m = list_from(&[1,2,3]);
assert!(n < m);
assert!(m > n);
#[test]
fn test_fuzz() {
- for _ in 0u..25 {
+ for _ in 0..25 {
fuzz_test(3);
fuzz_test(16);
fuzz_test(189);
#[test]
fn test_show() {
- let list: DList<i32> = (0..10).collect();
+ let list: DList<_> = (0..10).collect();
assert_eq!(format!("{:?}", list), "DList [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]");
- let list: DList<&str> = vec!["just", "one", "test", "more"].iter()
- .map(|&s| s)
- .collect();
+ let list: DList<_> = vec!["just", "one", "test", "more"].iter().cloned().collect();
assert_eq!(format!("{:?}", list), "DList [\"just\", \"one\", \"test\", \"more\"]");
}
#[cfg(test)]
- fn fuzz_test(sz: int) {
- let mut m: DList<int> = DList::new();
+ fn fuzz_test(sz: i32) {
+ let mut m: DList<_> = DList::new();
let mut v = vec![];
for i in 0..sz {
check_links(&m);
check_links(&m);
- let mut i = 0u;
+ let mut i = 0;
for (a, &b) in m.into_iter().zip(v.iter()) {
i += 1;
assert_eq!(a, b);
fn bench_collect_into(b: &mut test::Bencher) {
let v = &[0; 64];
b.iter(|| {
- let _: DList<int> = v.iter().map(|x| *x).collect();
+ let _: DList<_> = v.iter().cloned().collect();
})
}
#[bench]
fn bench_push_front(b: &mut test::Bencher) {
- let mut m: DList<int> = DList::new();
+ let mut m: DList<_> = DList::new();
b.iter(|| {
m.push_front(0);
})
#[bench]
fn bench_push_back(b: &mut test::Bencher) {
- let mut m: DList<int> = DList::new();
+ let mut m: DList<_> = DList::new();
b.iter(|| {
m.push_back(0);
})
#[bench]
fn bench_push_back_pop_back(b: &mut test::Bencher) {
- let mut m: DList<int> = DList::new();
+ let mut m: DList<_> = DList::new();
b.iter(|| {
m.push_back(0);
m.pop_back();
#[bench]
fn bench_push_front_pop_front(b: &mut test::Bencher) {
- let mut m: DList<int> = DList::new();
+ let mut m: DList<_> = DList::new();
b.iter(|| {
m.push_front(0);
m.pop_front();
#[bench]
fn bench_iter(b: &mut test::Bencher) {
let v = &[0; 128];
- let m: DList<int> = v.iter().map(|&x|x).collect();
+ let m: DList<_> = v.iter().cloned().collect();
b.iter(|| {
assert!(m.iter().count() == 128);
})
#[bench]
fn bench_iter_mut(b: &mut test::Bencher) {
let v = &[0; 128];
- let mut m: DList<int> = v.iter().map(|&x|x).collect();
+ let mut m: DList<_> = v.iter().cloned().collect();
b.iter(|| {
assert!(m.iter_mut().count() == 128);
})
#[bench]
fn bench_iter_rev(b: &mut test::Bencher) {
let v = &[0; 128];
- let m: DList<int> = v.iter().map(|&x|x).collect();
+ let m: DList<_> = v.iter().cloned().collect();
b.iter(|| {
assert!(m.iter().rev().count() == 128);
})
#[bench]
fn bench_iter_mut_rev(b: &mut test::Bencher) {
let v = &[0; 128];
- let mut m: DList<int> = v.iter().map(|&x|x).collect();
+ let mut m: DList<_> = v.iter().cloned().collect();
b.iter(|| {
assert!(m.iter_mut().rev().count() == 128);
})
pub struct EnumSet<E> {
// We must maintain the invariant that no bits are set
// for which no variant exists
- bits: uint
+ bits: usize
}
impl<E> Copy for EnumSet<E> {}
}
}
-/// An interface for casting C-like enum to uint and back.
+/// An interface for casting C-like enum to usize and back.
/// A typically implementation is as below.
///
/// ```{rust,ignore}
-/// #[repr(uint)]
+/// #[repr(usize)]
/// enum Foo {
/// A, B, C
/// }
///
/// impl CLike for Foo {
-/// fn to_uint(&self) -> uint {
-/// *self as uint
+/// fn to_usize(&self) -> usize {
+/// *self as usize
/// }
///
-/// fn from_uint(v: uint) -> Foo {
+/// fn from_usize(v: usize) -> Foo {
/// unsafe { mem::transmute(v) }
/// }
/// }
/// ```
pub trait CLike {
- /// Converts a C-like enum to a `uint`.
- fn to_uint(&self) -> uint;
- /// Converts a `uint` to a C-like enum.
- fn from_uint(uint) -> Self;
+ /// Converts a C-like enum to a `usize`.
+ fn to_usize(&self) -> usize;
+ /// Converts a `usize` to a C-like enum.
+ fn from_usize(usize) -> Self;
}
-fn bit<E:CLike>(e: &E) -> uint {
- use core::uint;
- let value = e.to_uint();
- assert!(value < uint::BITS,
- "EnumSet only supports up to {} variants.", uint::BITS - 1);
+fn bit<E:CLike>(e: &E) -> usize {
+ use core::usize;
+ let value = e.to_usize();
+ assert!(value < usize::BITS,
+ "EnumSet only supports up to {} variants.", usize::BITS - 1);
1 << value
}
/// Returns the number of elements in the given `EnumSet`.
#[unstable(feature = "collections",
reason = "matches collection reform specification, waiting for dust to settle")]
- pub fn len(&self) -> uint {
+ pub fn len(&self) -> usize {
self.bits.count_ones()
}
/// An iterator over an EnumSet
pub struct Iter<E> {
- index: uint,
- bits: uint,
+ index: usize,
+ bits: usize,
}
// FIXME(#19839) Remove in favor of `#[derive(Clone)]`
}
impl<E:CLike> Iter<E> {
- fn new(bits: uint) -> Iter<E> {
+ fn new(bits: usize) -> Iter<E> {
Iter { index: 0, bits: bits }
}
}
self.index += 1;
self.bits >>= 1;
}
- let elem = CLike::from_uint(self.index);
+ let elem = CLike::from_usize(self.index);
self.index += 1;
self.bits >>= 1;
Some(elem)
}
- fn size_hint(&self) -> (uint, Option<uint>) {
+ fn size_hint(&self) -> (usize, Option<usize>) {
let exact = self.bits.count_ones();
(exact, Some(exact))
}
use super::{EnumSet, CLike};
#[derive(Copy, PartialEq, Debug)]
- #[repr(uint)]
+ #[repr(usize)]
enum Foo {
A, B, C
}
impl CLike for Foo {
- fn to_uint(&self) -> uint {
- *self as uint
+ fn to_usize(&self) -> usize {
+ *self as usize
}
- fn from_uint(v: uint) -> Foo {
+ fn from_usize(v: usize) -> Foo {
unsafe { mem::transmute(v) }
}
}
fn test_overflow() {
#[allow(dead_code)]
#[derive(Copy)]
- #[repr(uint)]
+ #[repr(usize)]
enum Bar {
V00, V01, V02, V03, V04, V05, V06, V07, V08, V09,
V10, V11, V12, V13, V14, V15, V16, V17, V18, V19,
}
impl CLike for Bar {
- fn to_uint(&self) -> uint {
- *self as uint
+ fn to_usize(&self) -> usize {
+ *self as usize
}
- fn from_uint(v: uint) -> Bar {
+ fn from_usize(v: usize) -> Bar {
unsafe { mem::transmute(v) }
}
}
--- /dev/null
+// 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.
+//
+// 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-lexer-test FIXME #15679
+
+//! Utilities for formatting and printing strings
+//!
+//! This module contains the runtime support for the `format!` syntax extension.
+//! This macro is implemented in the compiler to emit calls to this module in
+//! order to format arguments at runtime into strings and streams.
+//!
+//! ## Usage
+//!
+//! The `format!` macro is intended to be familiar to those coming from C's
+//! printf/fprintf functions or Python's `str.format` function. In its current
+//! revision, the `format!` macro returns a `String` type which is the result of
+//! the formatting. In the future it will also be able to pass in a stream to
+//! format arguments directly while performing minimal allocations.
+//!
+//! Some examples of the `format!` extension are:
+//!
+//! ```
+//! format!("Hello"); // => "Hello"
+//! format!("Hello, {}!", "world"); // => "Hello, world!"
+//! format!("The number is {}", 1); // => "The number is 1"
+//! format!("{:?}", (3, 4)); // => "(3, 4)"
+//! format!("{value}", value=4); // => "4"
+//! format!("{} {}", 1, 2u); // => "1 2"
+//! ```
+//!
+//! From these, you can see that the first argument is a format string. It is
+//! required by the compiler for this to be a string literal; it cannot be a
+//! variable passed in (in order to perform validity checking). The compiler
+//! will then parse the format string and determine if the list of arguments
+//! provided is suitable to pass to this format string.
+//!
+//! ### Positional parameters
+//!
+//! Each formatting argument is allowed to specify which value argument it's
+//! referencing, and if omitted it is assumed to be "the next argument". For
+//! example, the format string `{} {} {}` would take three parameters, and they
+//! would be formatted in the same order as they're given. The format string
+//! `{2} {1} {0}`, however, would format arguments in reverse order.
+//!
+//! Things can get a little tricky once you start intermingling the two types of
+//! positional specifiers. The "next argument" specifier can be thought of as an
+//! iterator over the argument. Each time a "next argument" specifier is seen,
+//! the iterator advances. This leads to behavior like this:
+//!
+//! ```rust
+//! format!("{1} {} {0} {}", 1, 2); // => "2 1 1 2"
+//! ```
+//!
+//! The internal iterator over the argument has not been advanced by the time
+//! the first `{}` is seen, so it prints the first argument. Then upon reaching
+//! the second `{}`, the iterator has advanced forward to the second argument.
+//! Essentially, parameters which explicitly name their argument do not affect
+//! parameters which do not name an argument in terms of positional specifiers.
+//!
+//! A format string is required to use all of its arguments, otherwise it is a
+//! compile-time error. You may refer to the same argument more than once in the
+//! format string, although it must always be referred to with the same type.
+//!
+//! ### Named parameters
+//!
+//! Rust itself does not have a Python-like equivalent of named parameters to a
+//! function, but the `format!` macro is a syntax extension which allows it to
+//! leverage named parameters. Named parameters are listed at the end of the
+//! argument list and have the syntax:
+//!
+//! ```text
+//! identifier '=' expression
+//! ```
+//!
+//! For example, the following `format!` expressions all use named argument:
+//!
+//! ```
+//! format!("{argument}", argument = "test"); // => "test"
+//! format!("{name} {}", 1, name = 2); // => "2 1"
+//! format!("{a} {c} {b}", a="a", b='b', c=3); // => "a 3 b"
+//! ```
+//!
+//! It is illegal to put positional parameters (those without names) after
+//! arguments which have names. Like with positional parameters, it is illegal
+//! to provide named parameters that are unused by the format string.
+//!
+//! ### Argument types
+//!
+//! Each argument's type is dictated by the format string. It is a requirement
+//! that every argument is only ever referred to by one type. For example, this
+//! is an invalid format string:
+//!
+//! ```text
+//! {0:x} {0:o}
+//! ```
+//!
+//! This is invalid because the first argument is both referred to as a
+//! hexadecimal as well as an
+//! octal.
+//!
+//! There are various parameters which do require a particular type, however.
+//! Namely if the syntax `{:.*}` is used, then the number of characters to print
+//! precedes the actual object being formatted, and the number of characters
+//! must have the type `uint`. Although a `uint` can be printed with `{}`, it is
+//! illegal to reference an argument as such. For example this is another
+//! invalid format string:
+//!
+//! ```text
+//! {:.*} {0}
+//! ```
+//!
+//! ### Formatting traits
+//!
+//! When requesting that an argument be formatted with a particular type, you
+//! are actually requesting that an argument ascribes to a particular trait.
+//! This allows multiple actual types to be formatted via `{:x}` (like `i8` as
+//! well as `int`). The current mapping of types to traits is:
+//!
+//! * *nothing* ⇒ `Display`
+//! * `?` ⇒ `Debug`
+//! * `o` ⇒ `Octal`
+//! * `x` ⇒ `LowerHex`
+//! * `X` ⇒ `UpperHex`
+//! * `p` ⇒ `Pointer`
+//! * `b` ⇒ `Binary`
+//! * `e` ⇒ `LowerExp`
+//! * `E` ⇒ `UpperExp`
+//!
+//! What this means is that any type of argument which implements the
+//! `fmt::Binary` trait can then be formatted with `{:b}`. Implementations
+//! are provided for these traits for a number of primitive types by the
+//! standard library as well. If no format is specified (as in `{}` or `{:6}`),
+//! then the format trait used is the `Display` trait.
+//!
+//! When implementing a format trait for your own type, you will have to
+//! implement a method of the signature:
+//!
+//! ```rust
+//! # use std::fmt;
+//! # struct Foo; // our custom type
+//! # impl fmt::Display for Foo {
+//! fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+//! # write!(f, "testing, testing")
+//! # } }
+//! ```
+//!
+//! Your type will be passed as `self` by-reference, and then the function
+//! should emit output into the `f.buf` stream. It is up to each format trait
+//! implementation to correctly adhere to the requested formatting parameters.
+//! The values of these parameters will be listed in the fields of the
+//! `Formatter` struct. In order to help with this, the `Formatter` struct also
+//! provides some helper methods.
+//!
+//! Additionally, the return value of this function is `fmt::Result` which is a
+//! typedef to `Result<(), IoError>` (also known as `IoResult<()>`). Formatting
+//! implementations should ensure that they return errors from `write!`
+//! correctly (propagating errors upward).
+//!
+//! An example of implementing the formatting traits would look
+//! like:
+//!
+//! ```rust
+//! use std::fmt;
+//! use std::f64;
+//! use std::num::Float;
+//!
+//! #[derive(Debug)]
+//! struct Vector2D {
+//! x: int,
+//! y: int,
+//! }
+//!
+//! impl fmt::Display for Vector2D {
+//! fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+//! // The `f` value implements the `Writer` trait, which is what the
+//! // write! macro is expecting. Note that this formatting ignores the
+//! // various flags provided to format strings.
+//! write!(f, "({}, {})", self.x, self.y)
+//! }
+//! }
+//!
+//! // Different traits allow different forms of output of a type. The meaning
+//! // of this format is to print the magnitude of a vector.
+//! impl fmt::Binary for Vector2D {
+//! fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+//! let magnitude = (self.x * self.x + self.y * self.y) as f64;
+//! let magnitude = magnitude.sqrt();
+//!
+//! // Respect the formatting flags by using the helper method
+//! // `pad_integral` on the Formatter object. See the method documentation
+//! // for details, and the function `pad` can be used to pad strings.
+//! let decimals = f.precision().unwrap_or(3);
+//! let string = f64::to_str_exact(magnitude, decimals);
+//! f.pad_integral(true, "", string.as_slice())
+//! }
+//! }
+//!
+//! fn main() {
+//! let myvector = Vector2D { x: 3, y: 4 };
+//!
+//! println!("{}", myvector); // => "(3, 4)"
+//! println!("{:?}", myvector); // => "Vector2D {x: 3, y:4}"
+//! println!("{:10.3b}", myvector); // => " 5.000"
+//! }
+//! ```
+//!
+//! #### fmt::Display vs fmt::Debug
+//!
+//! These two formatting traits have distinct purposes:
+//!
+//! - `fmt::Display` implementations assert that the type can be faithfully
+//! represented as a UTF-8 string at all times. It is **not** expected that
+//! all types implement the `Display` trait.
+//! - `fmt::Debug` implementations should be implemented for **all** public types.
+//! Output will typically represent the internal state as faithfully as possible.
+//! The purpose of the `Debug` trait is to facilitate debugging Rust code. In
+//! most cases, using `#[derive(Debug)]` is sufficient and recommended.
+//!
+//! Some examples of the output from both traits:
+//!
+//! ```
+//! assert_eq!(format!("{} {:?}", 3i32, 4i32), "3 4");
+//! assert_eq!(format!("{} {:?}", 'a', 'b'), "a 'b'");
+//! assert_eq!(format!("{} {:?}", "foo\n", "bar\n"), "foo\n \"bar\\n\"");
+//! ```
+//!
+//! ### Related macros
+//!
+//! There are a number of related macros in the `format!` family. The ones that
+//! are currently implemented are:
+//!
+//! ```ignore
+//! format! // described above
+//! write! // first argument is a &mut old_io::Writer, the destination
+//! writeln! // same as write but appends a newline
+//! print! // the format string is printed to the standard output
+//! println! // same as print but appends a newline
+//! format_args! // described below.
+//! ```
+//!
+//! #### `write!`
+//!
+//! This and `writeln` are two macros which are used to emit the format string
+//! to a specified stream. This is used to prevent intermediate allocations of
+//! format strings and instead directly write the output. Under the hood, this
+//! function is actually invoking the `write` function defined in this module.
+//! Example usage is:
+//!
+//! ```rust
+//! # #![allow(unused_must_use)]
+//! let mut w = Vec::new();
+//! write!(&mut w, "Hello {}!", "world");
+//! ```
+//!
+//! #### `print!`
+//!
+//! This and `println` emit their output to stdout. Similarly to the `write!`
+//! macro, the goal of these macros is to avoid intermediate allocations when
+//! printing output. Example usage is:
+//!
+//! ```rust
+//! print!("Hello {}!", "world");
+//! println!("I have a newline {}", "character at the end");
+//! ```
+//!
+//! #### `format_args!`
+//! This is a curious macro which is used to safely pass around
+//! an opaque object describing the format string. This object
+//! does not require any heap allocations to create, and it only
+//! references information on the stack. Under the hood, all of
+//! the related macros are implemented in terms of this. First
+//! off, some example usage is:
+//!
+//! ```
+//! use std::fmt;
+//! use std::old_io;
+//!
+//! fmt::format(format_args!("this returns {}", "String"));
+//!
+//! let mut some_writer = old_io::stdout();
+//! write!(&mut some_writer, "{}", format_args!("print with a {}", "macro"));
+//!
+//! fn my_fmt_fn(args: fmt::Arguments) {
+//! write!(&mut old_io::stdout(), "{}", args);
+//! }
+//! my_fmt_fn(format_args!("or a {} too", "function"));
+//! ```
+//!
+//! The result of the `format_args!` macro is a value of type `fmt::Arguments`.
+//! This structure can then be passed to the `write` and `format` functions
+//! inside this module in order to process the format string.
+//! The goal of this macro is to even further prevent intermediate allocations
+//! when dealing formatting strings.
+//!
+//! For example, a logging library could use the standard formatting syntax, but
+//! it would internally pass around this structure until it has been determined
+//! where output should go to.
+//!
+//! ## Syntax
+//!
+//! The syntax for the formatting language used is drawn from other languages,
+//! so it should not be too alien. Arguments are formatted with python-like
+//! syntax, meaning that arguments are surrounded by `{}` instead of the C-like
+//! `%`. The actual grammar for the formatting syntax is:
+//!
+//! ```text
+//! format_string := <text> [ format <text> ] *
+//! format := '{' [ argument ] [ ':' format_spec ] '}'
+//! argument := integer | identifier
+//!
+//! format_spec := [[fill]align][sign]['#'][0][width]['.' precision][type]
+//! fill := character
+//! align := '<' | '^' | '>'
+//! sign := '+' | '-'
+//! width := count
+//! precision := count | '*'
+//! type := identifier | ''
+//! count := parameter | integer
+//! parameter := integer '$'
+//! ```
+//!
+//! ## Formatting Parameters
+//!
+//! Each argument being formatted can be transformed by a number of formatting
+//! parameters (corresponding to `format_spec` in the syntax above). These
+//! parameters affect the string representation of what's being formatted. This
+//! syntax draws heavily from Python's, so it may seem a bit familiar.
+//!
+//! ### Fill/Alignment
+//!
+//! The fill character is provided normally in conjunction with the `width`
+//! parameter. This indicates that if the value being formatted is smaller than
+//! `width` some extra characters will be printed around it. The extra
+//! characters are specified by `fill`, and the alignment can be one of two
+//! options:
+//!
+//! * `<` - the argument is left-aligned in `width` columns
+//! * `^` - the argument is center-aligned in `width` columns
+//! * `>` - the argument is right-aligned in `width` columns
+//!
+//! ### Sign/#/0
+//!
+//! These can all be interpreted as flags for a particular formatter.
+//!
+//! * '+' - This is intended for numeric types and indicates that the sign
+//! should always be printed. Positive signs are never printed by
+//! default, and the negative sign is only printed by default for the
+//! `Signed` trait. This flag indicates that the correct sign (+ or -)
+//! should always be printed.
+//! * '-' - Currently not used
+//! * '#' - This flag is indicates that the "alternate" form of printing should
+//! be used. By default, this only applies to the integer formatting
+//! traits and performs like:
+//! * `x` - precedes the argument with a "0x"
+//! * `X` - precedes the argument with a "0x"
+//! * `t` - precedes the argument with a "0b"
+//! * `o` - precedes the argument with a "0o"
+//! * '0' - This is used to indicate for integer formats that the padding should
+//! both be done with a `0` character as well as be sign-aware. A format
+//! like `{:08d}` would yield `00000001` for the integer `1`, while the
+//! same format would yield `-0000001` for the integer `-1`. Notice that
+//! the negative version has one fewer zero than the positive version.
+//!
+//! ### Width
+//!
+//! This is a parameter for the "minimum width" that the format should take up.
+//! If the value's string does not fill up this many characters, then the
+//! padding specified by fill/alignment will be used to take up the required
+//! space.
+//!
+//! The default fill/alignment for non-numerics is a space and left-aligned. The
+//! defaults for numeric formatters is also a space but with right-alignment. If
+//! the '0' flag is specified for numerics, then the implicit fill character is
+//! '0'.
+//!
+//! The value for the width can also be provided as a `uint` in the list of
+//! parameters by using the `2$` syntax indicating that the second argument is a
+//! `uint` specifying the width.
+//!
+//! ### Precision
+//!
+//! For non-numeric types, this can be considered a "maximum width". If the
+//! resulting string is longer than this width, then it is truncated down to
+//! this many characters and only those are emitted.
+//!
+//! For integral types, this has no meaning currently.
+//!
+//! For floating-point types, this indicates how many digits after the decimal
+//! point should be printed.
+//!
+//! ## Escaping
+//!
+//! The literal characters `{` and `}` may be included in a string by preceding
+//! them with the same character. For example, the `{` character is escaped with
+//! `{{` and the `}` character is escaped with `}}`.
+
+#![unstable(feature = "std_misc")]
+
+pub use core::fmt::{Formatter, Result, Writer, rt};
+pub use core::fmt::{Show, String, Octal, Binary};
+pub use core::fmt::{Display, Debug};
+pub use core::fmt::{LowerHex, UpperHex, Pointer};
+pub use core::fmt::{LowerExp, UpperExp};
+pub use core::fmt::Error;
+pub use core::fmt::{ArgumentV1, Arguments, write, radix, Radix, RadixFmt};
+
+use string;
+
+/// The format function takes a precompiled format string and a list of
+/// arguments, to return the resulting formatted string.
+///
+/// # Arguments
+///
+/// * args - a structure of arguments generated via the `format_args!` macro.
+///
+/// # Example
+///
+/// ```rust
+/// use std::fmt;
+///
+/// let s = fmt::format(format_args!("Hello, {}!", "world"));
+/// assert_eq!(s, "Hello, world!".to_string());
+/// ```
+#[stable(feature = "rust1", since = "1.0.0")]
+pub fn format(args: Arguments) -> string::String {
+ let mut output = string::String::new();
+ let _ = write!(&mut output, "{}", args);
+ output
+}
+
+#[cfg(test)]
+mod tests {
+ use prelude::*;
+ use fmt;
+
+ #[test]
+ fn test_format() {
+ let s = fmt::format(format_args!("Hello, {}!", "world"));
+ assert_eq!(s.as_slice(), "Hello, world!");
+ }
+}
#![feature(box_syntax)]
#![feature(core)]
#![feature(hash)]
-#![feature(int_uint)]
#![feature(staged_api)]
#![feature(unboxed_closures)]
#![feature(unicode)]
#![cfg_attr(test, feature(test))]
#![cfg_attr(test, allow(deprecated))] // rand
+#![feature(no_std)]
#![no_std]
#[macro_use]
mod btree;
pub mod dlist;
pub mod enum_set;
+pub mod fmt;
pub mod ring_buf;
pub mod slice;
pub mod str;
#[cfg(not(test))]
mod std {
- pub use core::fmt; // necessary for panic!()
- pub use core::option; // necessary for panic!()
- pub use core::clone; // derive(Clone)
- pub use core::cmp; // derive(Eq, Ord, etc.)
- pub use core::marker; // derive(Copy)
- pub use core::hash; // derive(Hash)
+ // NOTE: remove after next snapshot
+ #[cfg(stage0)] pub use core::clone; // derive(Clone)
+ #[cfg(stage0)] pub use core::cmp; // derive(Eq, Ord, etc.)
+ #[cfg(stage0)] pub use core::marker; // derive(Copy)
+ #[cfg(stage0)] pub use core::hash; // derive(Hash)
+ #[cfg(stage0)] pub use core::iter;
+ #[cfg(stage0)] pub use core::fmt; // necessary for panic!()
+ #[cfg(stage0)] pub use core::option; // necessary for panic!()
+
pub use core::ops; // RangeFull
- // for-loops
- pub use core::iter;
}
#[cfg(test)]
);
($($x:expr,)*) => (vec![$($x),*])
}
+
+/// Use the syntax described in `std::fmt` to create a value of type `String`.
+/// See `std::fmt` for more information.
+///
+/// # Example
+///
+/// ```
+/// format!("test");
+/// format!("hello {}", "world!");
+/// format!("x = {}, y = {y}", 10, y = 30);
+/// ```
+#[macro_export]
+#[stable(feature = "rust1", since = "1.0.0")]
+macro_rules! format {
+ ($($arg:tt)*) => ($crate::fmt::format(format_args!($($arg)*)))
+}
use core::ptr;
use core::raw::Slice as RawSlice;
-use std::hash::{Writer, Hash, Hasher};
-use std::cmp;
+use core::hash::{Writer, Hash, Hasher};
+use core::cmp;
use alloc::heap;
-static INITIAL_CAPACITY: uint = 7u; // 2^3 - 1
-static MINIMUM_CAPACITY: uint = 1u; // 2 - 1
+static INITIAL_CAPACITY: usize = 7; // 2^3 - 1
+static MINIMUM_CAPACITY: usize = 1; // 2 - 1
/// `RingBuf` is a circular buffer, which can be used as a double-ended queue efficiently.
#[stable(feature = "rust1", since = "1.0.0")]
// If tail == head the buffer is empty. The length of the ringbuf
// is defined as the distance between the two.
- tail: uint,
- head: uint,
- cap: uint,
+ tail: usize,
+ head: usize,
+ cap: usize,
ptr: *mut T
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<T: Clone> Clone for RingBuf<T> {
fn clone(&self) -> RingBuf<T> {
- self.iter().map(|t| t.clone()).collect()
+ self.iter().cloned().collect()
}
}
/// Moves an element out of the buffer
#[inline]
- unsafe fn buffer_read(&mut self, off: uint) -> T {
- ptr::read(self.ptr.offset(off as int))
+ unsafe fn buffer_read(&mut self, off: usize) -> T {
+ ptr::read(self.ptr.offset(off as isize))
}
/// Writes an element into the buffer, moving it.
#[inline]
- unsafe fn buffer_write(&mut self, off: uint, t: T) {
- ptr::write(self.ptr.offset(off as int), t);
+ unsafe fn buffer_write(&mut self, off: usize, t: T) {
+ ptr::write(self.ptr.offset(off as isize), t);
}
/// Returns true iff the buffer is at capacity
/// Returns the index in the underlying buffer for a given logical element index.
#[inline]
- fn wrap_index(&self, idx: uint) -> uint { wrap_index(idx, self.cap) }
+ fn wrap_index(&self, idx: usize) -> usize { wrap_index(idx, self.cap) }
/// Copies a contiguous block of memory len long from src to dst
#[inline]
- unsafe fn copy(&self, dst: uint, src: uint, len: uint) {
+ unsafe fn copy(&self, dst: usize, src: usize, len: usize) {
debug_assert!(dst + len <= self.cap, "dst={} src={} len={} cap={}", dst, src, len,
self.cap);
debug_assert!(src + len <= self.cap, "dst={} src={} len={} cap={}", dst, src, len,
self.cap);
ptr::copy_memory(
- self.ptr.offset(dst as int),
- self.ptr.offset(src as int),
+ self.ptr.offset(dst as isize),
+ self.ptr.offset(src as isize),
len);
}
/// Copies a contiguous block of memory len long from src to dst
#[inline]
- unsafe fn copy_nonoverlapping(&self, dst: uint, src: uint, len: uint) {
+ unsafe fn copy_nonoverlapping(&self, dst: usize, src: usize, len: usize) {
debug_assert!(dst + len <= self.cap, "dst={} src={} len={} cap={}", dst, src, len,
self.cap);
debug_assert!(src + len <= self.cap, "dst={} src={} len={} cap={}", dst, src, len,
self.cap);
ptr::copy_nonoverlapping_memory(
- self.ptr.offset(dst as int),
- self.ptr.offset(src as int),
+ self.ptr.offset(dst as isize),
+ self.ptr.offset(src as isize),
len);
}
}
/// Creates an empty `RingBuf` with space for at least `n` elements.
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn with_capacity(n: uint) -> RingBuf<T> {
+ pub fn with_capacity(n: usize) -> RingBuf<T> {
// +1 since the ringbuffer always leaves one space empty
let cap = cmp::max(n + 1, MINIMUM_CAPACITY + 1).next_power_of_two();
assert!(cap > n, "capacity overflow");
/// assert_eq!(buf.get(1).unwrap(), &4);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn get(&self, i: uint) -> Option<&T> {
+ pub fn get(&self, i: usize) -> Option<&T> {
if i < self.len() {
let idx = self.wrap_index(self.tail + i);
- unsafe { Some(&*self.ptr.offset(idx as int)) }
+ unsafe { Some(&*self.ptr.offset(idx as isize)) }
} else {
None
}
/// assert_eq!(buf[1], 7);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn get_mut(&mut self, i: uint) -> Option<&mut T> {
+ pub fn get_mut(&mut self, i: usize) -> Option<&mut T> {
if i < self.len() {
let idx = self.wrap_index(self.tail + i);
- unsafe { Some(&mut *self.ptr.offset(idx as int)) }
+ unsafe { Some(&mut *self.ptr.offset(idx as isize)) }
} else {
None
}
/// assert_eq!(buf[2], 3);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn swap(&mut self, i: uint, j: uint) {
+ pub fn swap(&mut self, i: usize, j: usize) {
assert!(i < self.len());
assert!(j < self.len());
let ri = self.wrap_index(self.tail + i);
let rj = self.wrap_index(self.tail + j);
unsafe {
- ptr::swap(self.ptr.offset(ri as int), self.ptr.offset(rj as int))
+ ptr::swap(self.ptr.offset(ri as isize), self.ptr.offset(rj as isize))
}
}
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn capacity(&self) -> uint { self.cap - 1 }
+ pub fn capacity(&self) -> usize { self.cap - 1 }
/// Reserves the minimum capacity for exactly `additional` more elements to be inserted in the
/// given `RingBuf`. Does nothing if the capacity is already sufficient.
///
/// # Panics
///
- /// Panics if the new capacity overflows `uint`.
+ /// Panics if the new capacity overflows `usize`.
///
/// # Examples
///
/// assert!(buf.capacity() >= 11);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn reserve_exact(&mut self, additional: uint) {
+ pub fn reserve_exact(&mut self, additional: usize) {
self.reserve(additional);
}
///
/// # Panics
///
- /// Panics if the new capacity overflows `uint`.
+ /// Panics if the new capacity overflows `usize`.
///
/// # Examples
///
/// assert!(buf.capacity() >= 11);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn reserve(&mut self, additional: uint) {
+ pub fn reserve(&mut self, additional: usize) {
let new_len = self.len() + additional;
assert!(new_len + 1 > self.len(), "capacity overflow");
if new_len > self.capacity() {
/// use std::collections::RingBuf;
///
/// let mut buf = RingBuf::with_capacity(15);
- /// buf.extend(0u..4);
+ /// buf.extend(0..4);
/// assert_eq!(buf.capacity(), 15);
/// buf.shrink_to_fit();
/// assert!(buf.capacity() >= 4);
/// ```
#[unstable(feature = "collections",
reason = "matches collection reform specification; waiting on panic semantics")]
- pub fn truncate(&mut self, len: uint) {
+ pub fn truncate(&mut self, len: usize) {
for _ in len..self.len() {
self.pop_back();
}
/// assert_eq!(&buf.iter_mut().collect::<Vec<&mut i32>>()[], b);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn iter_mut<'a>(&'a mut self) -> IterMut<'a, T> {
+ pub fn iter_mut(&mut self) -> IterMut<T> {
IterMut {
tail: self.tail,
head: self.head,
cap: self.cap,
ptr: self.ptr,
- marker: marker::ContravariantLifetime::<'a>,
+ marker: marker::ContravariantLifetime,
}
}
#[inline]
#[unstable(feature = "collections",
reason = "matches collection reform specification, waiting for dust to settle")]
- pub fn as_slices<'a>(&'a self) -> (&'a [T], &'a [T]) {
+ pub fn as_slices(&self) -> (&[T], &[T]) {
unsafe {
let contiguous = self.is_contiguous();
let buf = self.buffer_as_slice();
#[inline]
#[unstable(feature = "collections",
reason = "matches collection reform specification, waiting for dust to settle")]
- pub fn as_mut_slices<'a>(&'a mut self) -> (&'a mut [T], &'a mut [T]) {
+ pub fn as_mut_slices(&mut self) -> (&mut [T], &mut [T]) {
unsafe {
let contiguous = self.is_contiguous();
let head = self.head;
/// assert_eq!(v.len(), 1);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn len(&self) -> uint { count(self.tail, self.head, self.cap) }
+ pub fn len(&self) -> usize { count(self.tail, self.head, self.cap) }
/// Returns true if the buffer contains no elements
///
/// ```
#[unstable(feature = "collections",
reason = "the naming of this function may be altered")]
- pub fn swap_back_remove(&mut self, index: uint) -> Option<T> {
+ pub fn swap_back_remove(&mut self, index: usize) -> Option<T> {
let length = self.len();
if length > 0 && index < length - 1 {
self.swap(index, length - 1);
/// ```
#[unstable(feature = "collections",
reason = "the naming of this function may be altered")]
- pub fn swap_front_remove(&mut self, index: uint) -> Option<T> {
+ pub fn swap_front_remove(&mut self, index: usize) -> Option<T> {
let length = self.len();
if length > 0 && index < length && index != 0 {
self.swap(index, 0);
/// buf.insert(1,11);
/// assert_eq!(Some(&11), buf.get(1));
/// ```
- pub fn insert(&mut self, i: uint, t: T) {
+ pub fn insert(&mut self, i: usize, t: T) {
assert!(i <= self.len(), "index out of bounds");
if self.is_full() {
self.reserve(1);
/// assert_eq!(Some(&15), buf.get(2));
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn remove(&mut self, i: uint) -> Option<T> {
+ pub fn remove(&mut self, i: usize) -> Option<T> {
if self.is_empty() || self.len() <= i {
return None;
}
/// ```
#[unstable(feature = "collections",
reason = "matches collection reform specification; waiting on panic semantics")]
- pub fn resize(&mut self, new_len: uint, value: T) {
+ pub fn resize(&mut self, new_len: usize, value: T) {
let len = self.len();
if new_len > len {
/// Returns the index in the underlying buffer for a given logical element index.
#[inline]
-fn wrap_index(index: uint, size: uint) -> uint {
+fn wrap_index(index: usize, size: usize) -> usize {
// size is always a power of 2
index & (size - 1)
}
/// Calculate the number of elements left to be read in the buffer
#[inline]
-fn count(tail: uint, head: uint, size: uint) -> uint {
+fn count(tail: usize, head: usize, size: usize) -> usize {
// size is always a power of 2
(head - tail) & (size - 1)
}
#[stable(feature = "rust1", since = "1.0.0")]
pub struct Iter<'a, T:'a> {
ring: &'a [T],
- tail: uint,
- head: uint
+ tail: usize,
+ head: usize
}
// FIXME(#19839) Remove in favor of `#[derive(Clone)]`
}
#[inline]
- fn size_hint(&self) -> (uint, Option<uint>) {
+ fn size_hint(&self) -> (usize, Option<usize>) {
let len = count(self.tail, self.head, self.ring.len());
(len, Some(len))
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, T> RandomAccessIterator for Iter<'a, T> {
#[inline]
- fn indexable(&self) -> uint {
+ fn indexable(&self) -> usize {
let (len, _) = self.size_hint();
len
}
#[inline]
- fn idx(&mut self, j: uint) -> Option<&'a T> {
+ fn idx(&mut self, j: usize) -> Option<&'a T> {
if j >= self.indexable() {
None
} else {
#[stable(feature = "rust1", since = "1.0.0")]
pub struct IterMut<'a, T:'a> {
ptr: *mut T,
- tail: uint,
- head: uint,
- cap: uint,
+ tail: usize,
+ head: usize,
+ cap: usize,
marker: marker::ContravariantLifetime<'a>,
}
self.tail = wrap_index(self.tail + 1, self.cap);
unsafe {
- Some(&mut *self.ptr.offset(tail as int))
+ Some(&mut *self.ptr.offset(tail as isize))
}
}
#[inline]
- fn size_hint(&self) -> (uint, Option<uint>) {
+ fn size_hint(&self) -> (usize, Option<usize>) {
let len = count(self.tail, self.head, self.cap);
(len, Some(len))
}
self.head = wrap_index(self.head - 1, self.cap);
unsafe {
- Some(&mut *self.ptr.offset(self.head as int))
+ Some(&mut *self.ptr.offset(self.head as isize))
}
}
}
}
#[inline]
- fn size_hint(&self) -> (uint, Option<uint>) {
+ fn size_hint(&self) -> (usize, Option<usize>) {
let len = self.inner.len();
(len, Some(len))
}
}
#[inline]
- fn size_hint(&self) -> (uint, Option<uint>) {
+ fn size_hint(&self) -> (usize, Option<usize>) {
let len = self.inner.len();
(len, Some(len))
}
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<A> Index<u
int> for RingBuf<A> {
+impl<A> Index<u
size> for RingBuf<A> {
type Output = A;
#[inline]
- fn index<'a>(&'a self, i: &uint) -> &'a A {
+ fn index(&self, i: &usize) -> &A {
self.get(*i).expect("Out of bounds access")
}
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<A> IndexMut<uint> for RingBuf<A> {
- type Output = A;
-
+impl<A> IndexMut<usize> for RingBuf<A> {
#[inline]
- fn index_mut<'a>(&'a mut self, i: &uint) -> &'a mut A {
+ fn index_mut(&mut self, i: &usize) -> &mut A {
self.get_mut(*i).expect("Out of bounds access")
}
}
#[allow(deprecated)]
fn test_simple() {
let mut d = RingBuf::new();
- assert_eq!(d.len(), 0u);
+ assert_eq!(d.len(), 0);
d.push_front(17);
d.push_front(42);
d.push_back(137);
- assert_eq!(d.len(), 3u);
+ assert_eq!(d.len(), 3);
d.push_back(137);
- assert_eq!(d.len(), 4u);
+ assert_eq!(d.len(), 4);
assert_eq!(*d.front().unwrap(), 42);
assert_eq!(*d.back().unwrap(), 137);
let mut i = d.pop_front();
assert_eq!(i, Some(137));
i = d.pop_back();
assert_eq!(i, Some(17));
- assert_eq!(d.len(), 0u);
+ assert_eq!(d.len(), 0);
d.push_back(3);
- assert_eq!(d.len(), 1u);
+ assert_eq!(d.len(), 1);
d.push_front(2);
- assert_eq!(d.len(), 2u);
+ assert_eq!(d.len(), 2);
d.push_back(4);
- assert_eq!(d.len(), 3u);
+ assert_eq!(d.len(), 3);
d.push_front(1);
- assert_eq!(d.len(), 4u);
+ assert_eq!(d.len(), 4);
debug!("{}", d[0]);
debug!("{}", d[1]);
debug!("{}", d[2]);
#[test]
fn test_push_front_grow() {
let mut deq = RingBuf::new();
- for i in 0u..66 {
+ for i in 0..66 {
deq.push_front(i);
}
assert_eq!(deq.len(), 66);
- for i in 0u..66 {
+ for i in 0..66 {
assert_eq!(deq[i], 65 - i);
}
let mut deq = RingBuf::new();
- for i in 0u..66 {
+ for i in 0..66 {
deq.push_back(i);
}
- for i in 0u..66 {
+ for i in 0..66 {
assert_eq!(deq[i], i);
}
}
#[test]
fn test_index() {
let mut deq = RingBuf::new();
- for i in 1u..4 {
+ for i in 1..4 {
deq.push_front(i);
}
assert_eq!(deq[1], 2);
#[should_fail]
fn test_index_out_of_bounds() {
let mut deq = RingBuf::new();
- for i in 1u..4 {
+ for i in 1..4 {
deq.push_front(i);
}
deq[3];
#[bench]
fn bench_new(b: &mut test::Bencher) {
b.iter(|| {
- let ring: RingBuf<u64> = RingBuf::new();
+ let ring: RingBuf<i32> = RingBuf::new();
test::black_box(ring);
})
}
#[bench]
fn bench_pop_back_100(b: &mut test::Bencher) {
- let mut deq: RingBuf<i32> = RingBuf::with_capacity(101);
+ let mut deq= RingBuf::<i32>::with_capacity(101);
b.iter(|| {
deq.head = 100;
#[bench]
fn bench_pop_front_100(b: &mut test::Bencher) {
- let mut deq: RingBuf<i32> = RingBuf::with_capacity(101);
+ let mut deq = RingBuf::<i32>::with_capacity(101);
b.iter(|| {
deq.head = 100;
#[bench]
fn bench_iter_1000(b: &mut test::Bencher) {
- let ring: RingBuf<i32> = (0..1000).collect();
+ let ring: RingBuf<_> = (0..1000).collect();
b.iter(|| {
let mut sum = 0;
#[bench]
fn bench_mut_iter_1000(b: &mut test::Bencher) {
- let mut ring: RingBuf<i32> = (0..1000).collect();
+ let mut ring: RingBuf<_> = (0..1000).collect();
b.iter(|| {
let mut sum = 0;
#[test]
fn test_reserve_exact() {
let mut d = RingBuf::new();
- d.push_back(0u64);
- d.reserve_exact(50);
- assert!(d.capacity() >= 51);
- let mut d = RingBuf::new();
- d.push_back(0u32);
+ d.push_back(0);
d.reserve_exact(50);
assert!(d.capacity() >= 51);
}
#[test]
fn test_reserve() {
let mut d = RingBuf::new();
- d.push_back(0u64);
- d.reserve(50);
- assert!(d.capacity() >= 51);
- let mut d = RingBuf::new();
- d.push_back(0u32);
+ d.push_back(0);
d.reserve(50);
assert!(d.capacity() >= 51);
}
#[test]
fn test_swap() {
- let mut d: RingBuf<i32> = (0..5).collect();
+ let mut d: RingBuf<_> = (0..5).collect();
d.pop_front();
d.swap(0, 3);
- assert_eq!(d.iter().map(|&x|x).collect::<Vec<i32>>(), vec!(4, 2, 3, 1));
+ assert_eq!(d.iter().cloned().collect::<Vec<_>>(), vec!(4, 2, 3, 1));
}
#[test]
}
{
let b: &[_] = &[&0,&1,&2,&3,&4];
- assert_eq!(d.iter().collect::<Vec<&i32>>(), b);
+ assert_eq!(d.iter().collect::<Vec<_>>(), b);
}
for i in 6..9 {
}
{
let b: &[_] = &[&8,&7,&6,&0,&1,&2,&3,&4];
- assert_eq!(d.iter().collect::<Vec<&i32>>(), b);
+ assert_eq!(d.iter().collect::<Vec<_>>(), b);
}
let mut it = d.iter();
}
{
let b: &[_] = &[&4,&3,&2,&1,&0];
- assert_eq!(d.iter().rev().collect::<Vec<&i32>>(), b);
+ assert_eq!(d.iter().rev().collect::<Vec<_>>(), b);
}
for i in 6..9 {
d.push_front(i);
}
let b: &[_] = &[&4,&3,&2,&1,&0,&6,&7,&8];
- assert_eq!(d.iter().rev().collect::<Vec<&i32>>(), b);
+ assert_eq!(d.iter().rev().collect::<Vec<_>>(), b);
}
#[test]
assert_eq!(d.pop_front(), Some(1));
d.push_back(4);
- assert_eq!(d.iter_mut().rev().map(|x| *x).collect::<Vec<i32>>(),
- vec!(4, 3, 2));
+ assert_eq!(d.iter_mut().rev().cloned().collect::<Vec<_>>(),
+ vec![4, 3, 2]);
}
#[test]
let mut d = RingBuf::new();
assert!(d.iter_mut().next().is_none());
- for i in 0u..3 {
+ for i in 0..3 {
d.push_front(i);
}
let mut d = RingBuf::new();
assert!(d.iter_mut().rev().next().is_none());
- for i in 0u..3 {
+ for i in 0..3 {
d.push_front(i);
}
}
let b = vec![0,1,2,3,4];
- assert_eq!(d.into_iter().collect::<Vec<i32>>(), b);
+ assert_eq!(d.into_iter().collect::<Vec<_>>(), b);
}
// wrapped iter
}
let b = vec![8,7,6,0,1,2,3,4];
- assert_eq!(d.into_iter().collect::<Vec<i32>>(), b);
+ assert_eq!(d.into_iter().collect::<Vec<_>>(), b);
}
// partially used
// partially used
{
- let mut d: RingBuf<i32> = RingBuf::new();
+ let mut d: RingBuf<_> = RingBuf::new();
for i in 0..5 {
d.push_back(i);
}
fn test_from_iter() {
use core::iter;
let v = vec!(1,2,3,4,5,6,7);
- let deq: RingBuf<i32> = v.iter().map(|&x| x).collect();
- let u: Vec<i32> = deq.iter().map(|&x| x).collect();
+ let deq: RingBuf<_> = v.iter().cloned().collect();
+ let u: Vec<_> = deq.iter().cloned().collect();
assert_eq!(u, v);
- let seq = iter::count(0u, 2).take(256);
- let deq: RingBuf<uint> = seq.collect();
+ let seq = iter::count(0, 2).take(256);
+ let deq: RingBuf<_> = seq.collect();
for (i, &x) in deq.iter().enumerate() {
assert_eq!(2*i, x);
}
d.push_front(42);
d.push_back(137);
d.push_back(137);
- assert_eq!(d.len(), 4u);
+ assert_eq!(d.len(), 4);
let mut e = d.clone();
- assert_eq!(e.len(), 4u);
+ assert_eq!(e.len(), 4);
while !d.is_empty() {
assert_eq!(d.pop_back(), e.pop_back());
}
- assert_eq!(d.len(), 0u);
- assert_eq!(e.len(), 0u);
+ assert_eq!(d.len(), 0);
+ assert_eq!(e.len(), 0);
}
#[test]
#[test]
fn test_show() {
- let ringbuf: RingBuf<i32> = (0..10).collect();
+ let ringbuf: RingBuf<_> = (0..10).collect();
assert_eq!(format!("{:?}", ringbuf), "RingBuf [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]");
- let ringbuf: RingBuf<&str> = vec!["just", "one", "test", "more"].iter()
- .map(|&s| s)
+ let ringbuf: RingBuf<_> = vec!["just", "one", "test", "more"].iter()
+ .cloned()
.collect();
assert_eq!(format!("{:?}", ringbuf), "RingBuf [\"just\", \"one\", \"test\", \"more\"]");
}
#[test]
fn test_drop() {
- static mut drops: uint = 0;
+ static mut drops: i32 = 0;
struct Elem;
impl Drop for Elem {
fn drop(&mut self) {
#[test]
fn test_drop_with_pop() {
- static mut drops: uint = 0;
+ static mut drops: i32 = 0;
struct Elem;
impl Drop for Elem {
fn drop(&mut self) {
#[test]
fn test_drop_clear() {
- static mut drops: uint = 0;
+ static mut drops: i32 = 0;
struct Elem;
impl Drop for Elem {
fn drop(&mut self) {
//! block of memory that a mutable slice points to:
//!
//! ```rust
-//! let x: &mut[int] = &mut [1, 2, 3];
+//! let x: &mut[i32] = &mut [1, 2, 3];
//! x[1] = 7;
//! assert_eq!(x[0], 1);
//! assert_eq!(x[1], 7);
pub use core::slice::{IntSliceExt, SplitMut, ChunksMut, Split};
pub use core::slice::{SplitN, RSplitN, SplitNMut, RSplitNMut};
pub use core::slice::{bytes, mut_ref_slice, ref_slice};
+pub use core::slice::{from_raw_parts, from_raw_parts_mut};
pub use core::slice::{from_raw_buf, from_raw_mut_buf};
////////////////////////////////////////////////////////////////////////////////
/// ```
#[unstable(feature = "collections",
reason = "uncertain about this API approach")]
- fn move_from(&mut self, src: Vec<Self::Item>, start: uint, end: uint) -> uint;
+ fn move_from(&mut self, src: Vec<Self::Item>, start: usize, end: usize) -> usize;
/// Deprecated: use `&s[start .. end]` notation instead.
#[unstable(feature = "collections",
reason = "will be replaced by slice syntax")]
#[deprecated(since = "1.0.0", reason = "use &s[start .. end] instead")]
- fn slice(&self, start: uint, end: uint) -> &[Self::Item];
+ fn slice(&self, start: usize, end: usize) -> &[Self::Item];
/// Deprecated: use `&s[start..]` notation instead.
#[unstable(feature = "collections",
reason = "will be replaced by slice syntax")]
#[deprecated(since = "1.0.0", reason = "use &s[start..] instead")]
- fn slice_from(&self, start: uint) -> &[Self::Item];
+ fn slice_from(&self, start: usize) -> &[Self::Item];
/// Deprecated: use `&s[..end]` notation instead.
#[unstable(feature = "collections",
reason = "will be replaced by slice syntax")]
#[deprecated(since = "1.0.0", reason = "use &s[..end] instead")]
- fn slice_to(&self, end: uint) -> &[Self::Item];
+ fn slice_to(&self, end: usize) -> &[Self::Item];
/// Divides one slice into two at an index.
///
/// assert_eq!([30, 20, 50], v2);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- fn split_at(&self, mid: uint) -> (&[Self::Item], &[Self::Item]);
+ fn split_at(&self, mid: usize) -> (&[Self::Item], &[Self::Item]);
/// Returns an iterator over the slice.
#[stable(feature = "rust1", since = "1.0.0")]
/// }
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- fn splitn<F>(&self, n: uint, pred: F) -> SplitN<Self::Item, F>
+ fn splitn<F>(&self, n: usize, pred: F) -> SplitN<Self::Item, F>
where F: FnMut(&Self::Item) -> bool;
/// Returns an iterator over subslices separated by elements that match
/// }
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- fn rsplitn<F>(&self, n: uint, pred: F) -> RSplitN<Self::Item, F>
+ fn rsplitn<F>(&self, n: usize, pred: F) -> RSplitN<Self::Item, F>
where F: FnMut(&Self::Item) -> bool;
/// Returns an iterator over all contiguous windows of length
/// }
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- fn windows(&self, size: uint) -> Windows<Self::Item>;
+ fn windows(&self, size: usize) -> Windows<Self::Item>;
/// Returns an iterator over `size` elements of the slice at a
/// time. The chunks do not overlap. If `size` does not divide the
/// }
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- fn chunks(&self, size: uint) -> Chunks<Self::Item>;
+ fn chunks(&self, size: usize) -> Chunks<Self::Item>;
/// Returns the element of a slice at the given index, or `None` if the
/// index is out of bounds.
/// assert_eq!(None, v.get(3));
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- fn get(&self, index: uint) -> Option<&Self::Item>;
+ fn get(&self, index: usize) -> Option<&Self::Item>;
/// Returns the first element of a slice, or `None` if it is empty.
///
/// Returns a pointer to the element at the given index, without doing
/// bounds checking.
#[stable(feature = "rust1", since = "1.0.0")]
- unsafe fn get_unchecked(&self, index: uint) -> &Self::Item;
+ unsafe fn get_unchecked(&self, index: usize) -> &Self::Item;
/// Returns an unsafe pointer to the slice's buffer
///
/// assert!(match r { Ok(1...4) => true, _ => false, });
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- fn binary_search_by<F>(&self, f: F) -> Result<uint, uint> where
+ fn binary_search_by<F>(&self, f: F) -> Result<usize, usize> where
F: FnMut(&Self::Item) -> Ordering;
/// Return the number of elements in the slice
/// assert_eq!(a.len(), 3);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- fn len(&self) -> uint;
+ fn len(&self) -> usize;
/// Returns true if the slice has a length of 0
///
/// Returns a mutable reference to the element at the given index,
/// or `None` if the index is out of bounds
#[stable(feature = "rust1", since = "1.0.0")]
- fn get_mut(&mut self, index: uint) -> Option<&mut Self::Item>;
+ fn get_mut(&mut self, index: usize) -> Option<&mut Self::Item>;
/// Work with `self` as a mut slice.
/// Primarily intended for getting a &mut [T] from a [T; N].
#[unstable(feature = "collections",
reason = "will be replaced by slice syntax")]
#[deprecated(since = "1.0.0", reason = "use &mut s[start .. end] instead")]
- fn slice_mut(&mut self, start: uint, end: uint) -> &mut [Self::Item];
+ fn slice_mut(&mut self, start: usize, end: usize) -> &mut [Self::Item];
/// Deprecated: use `&mut s[start ..]` instead.
#[unstable(feature = "collections",
reason = "will be replaced by slice syntax")]
#[deprecated(since = "1.0.0", reason = "use &mut s[start ..] instead")]
- fn slice_from_mut(&mut self, start: uint) -> &mut [Self::Item];
+ fn slice_from_mut(&mut self, start: usize) -> &mut [Self::Item];
/// Deprecated: use `&mut s[.. end]` instead.
#[unstable(feature = "collections",
reason = "will be replaced by slice syntax")]
#[deprecated(since = "1.0.0", reason = "use &mut s[.. end] instead")]
- fn slice_to_mut(&mut self, end: uint) -> &mut [Self::Item];
+ fn slice_to_mut(&mut self, end: usize) -> &mut [Self::Item];
/// Returns an iterator that allows modifying each value
#[stable(feature = "rust1", since = "1.0.0")]
/// `pred`, limited to splitting at most `n` times. The matched element is
/// not contained in the subslices.
#[stable(feature = "rust1", since = "1.0.0")]
- fn splitn_mut<F>(&mut self, n: uint, pred: F) -> SplitNMut<Self::Item, F>
+ fn splitn_mut<F>(&mut self, n: usize, pred: F) -> SplitNMut<Self::Item, F>
where F: FnMut(&Self::Item) -> bool;
/// Returns an iterator over subslices separated by elements that match
/// the slice and works backwards. The matched element is not contained in
/// the subslices.
#[stable(feature = "rust1", since = "1.0.0")]
- fn rsplitn_mut<F>(&mut self, n: uint, pred: F) -> RSplitNMut<Self::Item, F>
+ fn rsplitn_mut<F>(&mut self, n: usize, pred: F) -> RSplitNMut<Self::Item, F>
where F: FnMut(&Self::Item) -> bool;
/// Returns an iterator over `chunk_size` elements of the slice at a time.
///
/// Panics if `chunk_size` is 0.
#[stable(feature = "rust1", since = "1.0.0")]
- fn chunks_mut(&mut self, chunk_size: uint) -> ChunksMut<Self::Item>;
+ fn chunks_mut(&mut self, chunk_size: usize) -> ChunksMut<Self::Item>;
/// Swaps two elements in a slice.
///
/// assert!(v == ["a", "d", "c", "b"]);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- fn swap(&mut self, a: uint, b: uint);
+ fn swap(&mut self, a: usize, b: usize);
/// Divides one `&mut` into two at an index.
///
/// }
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- fn split_at_mut(&mut self, mid: uint) -> (&mut [Self::Item], &mut [Self::Item]);
+ fn split_at_mut(&mut self, mid: usize) -> (&mut [Self::Item], &mut [Self::Item]);
/// Reverse the order of elements in a slice, in place.
///
/// Returns an unsafe mutable pointer to the element in index
#[stable(feature = "rust1", since = "1.0.0")]
- unsafe fn get_unchecked_mut(&mut self, index: uint) -> &mut Self::Item;
+ unsafe fn get_unchecked_mut(&mut self, index: usize) -> &mut Self::Item;
/// Return an unsafe mutable pointer to the slice's buffer.
///
/// assert!(dst == [3, 4, 5]);
/// ```
#[unstable(feature = "collections")]
- fn clone_from_slice(&mut self, &[Self::Item]) -> uint where Self::Item: Clone;
+ fn clone_from_slice(&mut self, &[Self::Item]) -> usize where Self::Item: Clone;
/// Sorts the slice, in place.
///
/// assert!(match r { Ok(1...4) => true, _ => false, });
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- fn binary_search(&self, x: &Self::Item) -> Result<uint, uint> where Self::Item: Ord;
+ fn binary_search(&self, x: &Self::Item) -> Result<usize, usize> where Self::Item: Ord;
/// Deprecated: use `binary_search` instead.
#[unstable(feature = "collections")]
#[deprecated(since = "1.0.0", reason = "use binary_search instead")]
- fn binary_search_elem(&self, x: &Self::Item) -> Result<uint, uint> where Self::Item: Ord {
+ fn binary_search_elem(&self, x: &Self::Item) -> Result<usize, usize> where Self::Item: Ord {
self.binary_search(x)
}
/// Find the first index containing a matching value.
#[unstable(feature = "collections")]
- fn position_elem(&self, t: &Self::Item) -> Option<uint> where Self::Item: PartialEq;
+ fn position_elem(&self, t: &Self::Item) -> Option<usize> where Self::Item: PartialEq;
/// Find the last index containing a matching value.
#[unstable(feature = "collections")]
- fn rposition_elem(&self, t: &Self::Item) -> Option<uint> where Self::Item: PartialEq;
+ fn rposition_elem(&self, t: &Self::Item) -> Option<usize> where Self::Item: PartialEq;
/// Returns true if the slice contains an element with the given value.
///
}
#[inline]
- fn move_from(&mut self, mut src: Vec<T>, start: uint, end: uint) -> uint {
+ fn move_from(&mut self, mut src: Vec<T>, start: usize, end: usize) -> usize {
for (a, b) in self.iter_mut().zip(src[start .. end].iter_mut()) {
mem::swap(a, b);
}
}
#[inline]
- fn slice<'a>(&'a self, start: uint, end: uint) -> &'a [T] {
+ fn slice(&self, start: usize, end: usize) -> &[T] {
&self[start .. end]
}
#[inline]
- fn slice_from<'a>(&'a self, start: uint) -> &'a [T] {
+ fn slice_from(&self, start: usize) -> &[T] {
&self[start ..]
}
#[inline]
- fn slice_to<'a>(&'a self, end: uint) -> &'a [T] {
+ fn slice_to(&self, end: usize) -> &[T] {
&self[.. end]
}
#[inline]
- fn split_at<'a>(&'a self, mid: uint) -> (&'a [T], &'a [T]) {
+ fn split_at(&self, mid: usize) -> (&[T], &[T]) {
core_slice::SliceExt::split_at(self, mid)
}
#[inline]
- fn iter<'a>(&'a self) -> Iter<'a, T> {
+ fn iter(&self) -> Iter<T> {
core_slice::SliceExt::iter(self)
}
}
#[inline]
- fn splitn<F>(&self, n: uint, pred: F) -> SplitN<T, F>
+ fn splitn<F>(&self, n: usize, pred: F) -> SplitN<T, F>
where F: FnMut(&T) -> bool {
core_slice::SliceExt::splitn(self, n, pred)
}
#[inline]
- fn rsplitn<F>(&self, n: uint, pred: F) -> RSplitN<T, F>
+ fn rsplitn<F>(&self, n: usize, pred: F) -> RSplitN<T, F>
where F: FnMut(&T) -> bool {
core_slice::SliceExt::rsplitn(self, n, pred)
}
#[inline]
- fn windows<'a>(&'a self, size: uint) -> Windows<'a, T> {
+ fn windows(&self, size: usize) -> Windows<T> {
core_slice::SliceExt::windows(self, size)
}
#[inline]
- fn chunks<'a>(&'a self, size: uint) -> Chunks<'a, T> {
+ fn chunks(&self, size: usize) -> Chunks<T> {
core_slice::SliceExt::chunks(self, size)
}
#[inline]
- fn get<'a>(&'a self, index: uint) -> Option<&'a T> {
+ fn get(&self, index: usize) -> Option<&T> {
core_slice::SliceExt::get(self, index)
}
#[inline]
- fn first<'a>(&'a self) -> Option<&'a T> {
+ fn first(&self) -> Option<&T> {
core_slice::SliceExt::first(self)
}
#[inline]
- fn tail<'a>(&'a self) -> &'a [T] {
+ fn tail(&self) -> &[T] {
core_slice::SliceExt::tail(self)
}
#[inline]
- fn init<'a>(&'a self) -> &'a [T] {
+ fn init(&self) -> &[T] {
core_slice::SliceExt::init(self)
}
#[inline]
- fn last<'a>(&'a self) -> Option<&'a T> {
+ fn last(&self) -> Option<&T> {
core_slice::SliceExt::last(self)
}
#[inline]
- unsafe fn get_unchecked<'a>(&'a self, index: uint) -> &'a T {
+ unsafe fn get_unchecked(&self, index: usize) -> &T {
core_slice::SliceExt::get_unchecked(self, index)
}
}
#[inline]
- fn binary_search_by<F>(&self, f: F) -> Result<uint, uint>
+ fn binary_search_by<F>(&self, f: F) -> Result<usize, usize>
where F: FnMut(&T) -> Ordering {
core_slice::SliceExt::binary_search_by(self, f)
}
#[inline]
- fn len(&self) -> uint {
+ fn len(&self) -> usize {
core_slice::SliceExt::len(self)
}
}
#[inline]
- fn get_mut<'a>(&'a mut self, index: uint) -> Option<&'a mut T> {
+ fn get_mut(&mut self, index: usize) -> Option<&mut T> {
core_slice::SliceExt::get_mut(self, index)
}
#[inline]
- fn as_mut_slice<'a>(&'a mut self) -> &'a mut [T] {
+ fn as_mut_slice(&mut self) -> &mut [T] {
core_slice::SliceExt::as_mut_slice(self)
}
#[inline]
- fn slice_mut<'a>(&'a mut self, start: uint, end: uint) -> &'a mut [T] {
+ fn slice_mut(&mut self, start: usize, end: usize) -> &mut [T] {
&mut self[start .. end]
}
#[inline]
- fn slice_from_mut<'a>(&'a mut self, start: uint) -> &'a mut [T] {
+ fn slice_from_mut(&mut self, start: usize) -> &mut [T] {
&mut self[start ..]
}
#[inline]
- fn slice_to_mut<'a>(&'a mut self, end: uint) -> &'a mut [T] {
+ fn slice_to_mut(&mut self, end: usize) -> &mut [T] {
&mut self[.. end]
}
#[inline]
- fn iter_mut<'a>(&'a mut self) -> IterMut<'a, T> {
+ fn iter_mut(&mut self) -> IterMut<T> {
core_slice::SliceExt::iter_mut(self)
}
#[inline]
- fn first_mut<'a>(&'a mut self) -> Option<&'a mut T> {
+ fn first_mut(&mut self) -> Option<&mut T> {
core_slice::SliceExt::first_mut(self)
}
#[inline]
- fn tail_mut<'a>(&'a mut self) -> &'a mut [T] {
+ fn tail_mut(&mut self) -> &mut [T] {
core_slice::SliceExt::tail_mut(self)
}
#[inline]
- fn init_mut<'a>(&'a mut self) -> &'a mut [T] {
+ fn init_mut(&mut self) -> &mut [T] {
core_slice::SliceExt::init_mut(self)
}
#[inline]
- fn last_mut<'a>(&'a mut self) -> Option<&'a mut T> {
+ fn last_mut(&mut self) -> Option<&mut T> {
core_slice::SliceExt::last_mut(self)
}
}
#[inline]
- fn splitn_mut<F>(&mut self, n: uint, pred: F) -> SplitNMut<T, F>
+ fn splitn_mut<F>(&mut self, n: usize, pred: F) -> SplitNMut<T, F>
where F: FnMut(&T) -> bool {
core_slice::SliceExt::splitn_mut(self, n, pred)
}
#[inline]
- fn rsplitn_mut<F>(&mut self, n: uint, pred: F) -> RSplitNMut<T, F>
+ fn rsplitn_mut<F>(&mut self, n: usize, pred: F) -> RSplitNMut<T, F>
where F: FnMut(&T) -> bool {
core_slice::SliceExt::rsplitn_mut(self, n, pred)
}
#[inline]
- fn chunks_mut<'a>(&'a mut self, chunk_size: uint) -> ChunksMut<'a, T> {
+ fn chunks_mut(&mut self, chunk_size: usize) -> ChunksMut<T> {
core_slice::SliceExt::chunks_mut(self, chunk_size)
}
#[inline]
- fn swap(&mut self, a: uint, b: uint) {
+ fn swap(&mut self, a: usize, b: usize) {
core_slice::SliceExt::swap(self, a, b)
}
#[inline]
- fn split_at_mut<'a>(&'a mut self, mid: uint) -> (&'a mut [T], &'a mut [T]) {
+ fn split_at_mut(&mut self, mid: usize) -> (&mut [T], &mut [T]) {
core_slice::SliceExt::split_at_mut(self, mid)
}
}
#[inline]
- unsafe fn get_unchecked_mut<'a>(&'a mut self, index: uint) -> &'a mut T {
+ unsafe fn get_unchecked_mut(&mut self, index: usize) -> &mut T {
core_slice::SliceExt::get_unchecked_mut(self, index)
}
}
}
- fn clone_from_slice(&mut self, src: &[T]) -> uint where T: Clone {
+ fn clone_from_slice(&mut self, src: &[T]) -> usize where T: Clone {
core_slice::SliceExt::clone_from_slice(self, src)
}
self.sort_by(|a, b| a.cmp(b))
}
- fn binary_search(&self, x: &T) -> Result<uint, uint> where T: Ord {
+ fn binary_search(&self, x: &T) -> Result<usize, usize> where T: Ord {
core_slice::SliceExt::binary_search(self, x)
}
core_slice::SliceExt::prev_permutation(self)
}
- fn position_elem(&self, t: &T) -> Option<uint> where T: PartialEq {
+ fn position_elem(&self, t: &T) -> Option<usize> where T: PartialEq {
core_slice::SliceExt::position_elem(self, t)
}
- fn rposition_elem(&self, t: &T) -> Option<uint> where T: PartialEq {
+ fn rposition_elem(&self, t: &T) -> Option<usize> where T: PartialEq {
core_slice::SliceExt::rposition_elem(self, t)
}
impl<T: Clone, V: AsSlice<T>> SliceConcatExt<T, Vec<T>> for [V] {
fn concat(&self) -> Vec<T> {
- let size = self.iter().fold(0u, |acc, v| acc + v.as_slice().len());
+ let size = self.iter().fold(0, |acc, v| acc + v.as_slice().len());
let mut result = Vec::with_capacity(size);
for v in self {
result.push_all(v.as_slice())
}
fn connect(&self, sep: &T) -> Vec<T> {
- let size = self.iter().fold(0u, |acc, v| acc + v.as_slice().len());
+ let size = self.iter().fold(0, |acc, v| acc + v.as_slice().len());
let mut result = Vec::with_capacity(size + self.len());
let mut first = true;
for v in self {
/// If `true`, emit the last swap that returns the sequence to initial
/// state.
emit_reset: bool,
- swaps_made : uint,
+ swaps_made : usize,
}
impl ElementSwaps {
/// Creates an `ElementSwaps` iterator for a sequence of `length` elements.
#[unstable(feature = "collections")]
- pub fn new(length: uint) -> ElementSwaps {
+ pub fn new(length: usize) -> ElementSwaps {
// Initialize `sdir` with a direction that position should move in
// (all negative at the beginning) and the `size` of the
// element (equal to the original index).
/// An `Index` and `Direction` together.
#[derive(Copy, Clone)]
struct SizeDirection {
- size: uint,
+ size: usize,
dir: Direction,
}
#[stable(feature = "rust1", since = "1.0.0")]
impl Iterator for ElementSwaps {
- type Item = (uint, uint);
+ type Item = (usize, usize);
#[inline]
- fn next(&mut self) -> Option<(uint, uint)> {
- fn new_pos(i: uint, s: Direction) -> uint {
+ fn next(&mut self) -> Option<(usize, usize)> {
+ fn new_pos(i: usize, s: Direction) -> usize {
i + match s { Pos => 1, Neg => -1 }
}
}
#[inline]
- fn size_hint(&self) -> (uint, Option<uint>) {
+ fn size_hint(&self) -> (usize, Option<usize>) {
// For a vector of size n, there are exactly n! permutations.
let n = (2..self.sdir.len() + 1).product();
(n - self.swaps_made, Some(n - self.swaps_made))
}
#[inline]
- fn size_hint(&self) -> (uint, Option<uint>) {
+ fn size_hint(&self) -> (usize, Option<usize>) {
self.swaps.size_hint()
}
}
////////////////////////////////////////////////////////////////////////////////
fn insertion_sort<T, F>(v: &mut [T], mut compare: F) where F: FnMut(&T, &T) -> Ordering {
- let len = v.len() as int;
+ let len = v.len() as isize;
let buf_v = v.as_mut_ptr();
// 1 <= i < len;
let tmp = ptr::read(read_ptr);
ptr::copy_memory(buf_v.offset(j + 1),
&*buf_v.offset(j),
- (i - j) as uint);
+ (i - j) as usize);
ptr::copy_nonoverlapping_memory(buf_v.offset(j),
&tmp,
1);
fn merge_sort<T, F>(v: &mut [T], mut compare: F) where F: FnMut(&T, &T) -> Ordering {
// warning: this wildly uses unsafe.
- static BASE_INSERTION: uint = 32;
- static LARGE_INSERTION: uint = 16;
+ static BASE_INSERTION: usize = 32;
+ static LARGE_INSERTION: usize = 16;
// FIXME #12092: smaller insertion runs seems to make sorting
// vectors of large elements a little faster on some platforms,
let mut working_space = Vec::with_capacity(2 * len);
// these both are buffers of length `len`.
let mut buf_dat = working_space.as_mut_ptr();
- let mut buf_tmp = unsafe {buf_dat.offset(len as int)};
+ let mut buf_tmp = unsafe {buf_dat.offset(len as isize)};
// length `len`.
let buf_v = v.as_ptr();
// start <= i < len;
for i in start..cmp::min(start + insertion, len) {
// j satisfies: start <= j <= i;
- let mut j = i as int;
+ let mut j = i as isize;
unsafe {
// `i` is in bounds.
- let read_ptr = buf_v.offset(i as int);
+ let read_ptr = buf_v.offset(i as isize);
// find where to insert, we need to do strict <,
// rather than <=, to maintain stability.
// start <= j - 1 < len, so .offset(j - 1) is in
// bounds.
- while j > start as int &&
+ while j > start as isize &&
compare(&*read_ptr, &*buf_dat.offset(j - 1)) == Less {
j -= 1;
}
// `.offset(j)` is always in bounds.
ptr::copy_memory(buf_dat.offset(j + 1),
&*buf_dat.offset(j),
- i - j as uint);
+ i - j as usize);
ptr::copy_nonoverlapping_memory(buf_dat.offset(j), read_ptr, 1);
}
}
// the end of the first run & start of the
// second. Offset of `len` is defined, since this is
// precisely one byte past the end of the object.
- let right_start = buf_dat.offset(cmp::min(start + width, len) as int);
+ let right_start = buf_dat.offset(cmp::min(start + width, len) as isize);
// end of the second. Similar reasoning to the above re safety.
let right_end_idx = cmp::min(start + 2 * width, len);
- let right_end = buf_dat.offset(right_end_idx as int);
+ let right_end = buf_dat.offset(right_end_idx as isize);
// the pointers to the elements under consideration
// from the two runs.
// both of these are in bounds.
- let mut left = buf_dat.offset(start as int);
+ let mut left = buf_dat.offset(start as isize);
let mut right = right_start;
// where we're putting the results, it is a run of
// length `2*width`, so we step it once for each step
// of either `left` or `right`. `buf_tmp` has length
// `len`, so these are in bounds.
- let mut out = buf_tmp.offset(start as int);
- let out_end = buf_tmp.offset(right_end_idx as int);
+ let mut out = buf_tmp.offset(start as isize);
+ let out_end = buf_tmp.offset(right_end_idx as isize);
while out < out_end {
// Either the left or the right run are exhausted,
// case).
if left == right_start {
// the number remaining in this run.
- let elems = (right_end as uint - right as uint) / mem::size_of::<T>();
+ let elems = (right_end as usize - right as usize) / mem::size_of::<T>();
ptr::copy_nonoverlapping_memory(out, &*right, elems);
break;
} else if right == right_end {
- let elems = (right_start as uint - left as uint) / mem::size_of::<T>();
+ let elems = (right_start as usize - left as usize) / mem::size_of::<T>();
ptr::copy_nonoverlapping_memory(out, &*left, elems);
break;
}
#[cfg(test)]
mod tests {
use core::cmp::Ordering::{Greater, Less, Equal};
- use core::prelude::{Some, None, range, Clone};
+ use core::prelude::{Some, None, Clone};
use core::prelude::{Iterator, IteratorExt};
use core::prelude::{AsSlice};
use core::prelude::Ord;
use vec::Vec;
use super::{ElementSwaps, SliceConcatExt, SliceExt};
- fn square(n: uint) -> uint { n * n }
+ fn square(n: usize) -> usize { n * n }
- fn is_odd(n: &uint) -> bool { *n % 2u == 1u }
+ fn is_odd(n: &usize) -> bool { *n % 2 == 1 }
#[test]
fn test_from_fn() {
// Test on-stack from_fn.
- let mut v = (0u..3).map(square).collect::<Vec<_>>();
+ let mut v: Vec<_> = (0..3).map(square).collect();
{
let v = v;
- assert_eq!(v.len(), 3u);
- assert_eq!(v[0], 0u);
- assert_eq!(v[1], 1u);
- assert_eq!(v[2], 4u);
+ assert_eq!(v.len(), 3);
+ assert_eq!(v[0], 0);
+ assert_eq!(v[1], 1);
+ assert_eq!(v[2], 4);
}
// Test on-heap from_fn.
- v = (0u..5).map(square).collect::<Vec<_>>();
+ v = (0..5).map(square).collect();
{
let v = v;
- assert_eq!(v.len(), 5u);
- assert_eq!(v[0], 0u);
- assert_eq!(v[1], 1u);
- assert_eq!(v[2], 4u);
- assert_eq!(v[3], 9u);
- assert_eq!(v[4], 16u);
+ assert_eq!(v.len(), 5);
+ assert_eq!(v[0], 0);
+ assert_eq!(v[1], 1);
+ assert_eq!(v[2], 4);
+ assert_eq!(v[3], 9);
+ assert_eq!(v[4], 16);
}
}
#[test]
fn test_from_elem() {
// Test on-stack from_elem.
- let mut v = vec![10u, 10u];
+ let mut v = vec![10, 10];
{
let v = v;
- assert_eq!(v.len(), 2u);
- assert_eq!(v[0], 10u);
- assert_eq!(v[1], 10u);
+ assert_eq!(v.len(), 2);
+ assert_eq!(v[0], 10);
+ assert_eq!(v[1], 10);
}
// Test on-heap from_elem.
- v = vec![20u, 20u, 20u, 20u, 20u, 20u];
+ v = vec![20; 6];
{
- let v = v;
- assert_eq!(v[0], 20u);
- assert_eq!(v[1], 20u);
- assert_eq!(v[2], 20u);
- assert_eq!(v[3], 20u);
- assert_eq!(v[4], 20u);
- assert_eq!(v[5], 20u);
+ let v = v.as_slice();
+ assert_eq!(v[0], 20);
+ assert_eq!(v[1], 20);
+ assert_eq!(v[2], 20);
+ assert_eq!(v[3], 20);
+ assert_eq!(v[4], 20);
+ assert_eq!(v[5], 20);
}
}
#[test]
fn test_is_empty() {
- let xs: [int; 0] = [];
+ let xs: [i32; 0] = [];
assert!(xs.is_empty());
assert!(![0].is_empty());
}
#[test]
fn test_tail() {
let mut a = vec![11];
- let b: &[int] = &[];
+ let b: &[i32] = &[];
assert_eq!(a.tail(), b);
a = vec![11, 12];
- let b: &[int] = &[12];
+ let b: &[i32] = &[12];
assert_eq!(a.tail(), b);
}
#[test]
fn test_tail_mut() {
let mut a = vec![11];
- let b: &mut [int] = &mut [];
+ let b: &mut [i32] = &mut [];
assert!(a.tail_mut() == b);
a = vec![11, 12];
- let b: &mut [int] = &mut [12];
+ let b: &mut [_] = &mut [12];
assert!(a.tail_mut() == b);
}
#[test]
#[should_fail]
fn test_tail_empty() {
- let a: Vec<int> = vec![];
+ let a = Vec::<i32>::new();
a.tail();
}
#[test]
#[should_fail]
fn test_tail_mut_empty() {
- let mut a: Vec<int> = vec![];
+ let mut a = Vec::<i32>::new();
a.tail_mut();
}
#[test]
fn test_init() {
let mut a = vec![11];
- let b: &[int] = &[];
+ let b: &[i32] = &[];
assert_eq!(a.init(), b);
a = vec![11, 12];
- let b: &[int] = &[11];
+ let b: &[_] = &[11];
assert_eq!(a.init(), b);
}
#[test]
fn test_init_mut() {
let mut a = vec![11];
- let b: &mut [int] = &mut [];
+ let b: &mut [i32] = &mut [];
assert!(a.init_mut() == b);
a = vec![11, 12];
- let b: &mut [int] = &mut [11];
+ let b: &mut [_] = &mut [11];
assert!(a.init_mut() == b);
}
#[test]
#[should_fail]
fn test_init_empty() {
- let a: Vec<int> = vec![];
+ let a = Vec::<i32>::new();
a.init();
}
#[test]
#[should_fail]
fn test_init_mut_empty() {
- let mut a: Vec<int> = vec![];
+ let mut a = Vec::<i32>::new();
a.init_mut();
}
fn test_slice() {
// Test fixed length vector.
let vec_fixed = [1, 2, 3, 4];
- let v_a = vec_fixed[1u..vec_fixed.len()].to_vec();
- assert_eq!(v_a.len(), 3u);
- let v_a = v_a;
+ let v_a = vec_fixed[1..vec_fixed.len()].to_vec();
+ assert_eq!(v_a.len(), 3);
+
assert_eq!(v_a[0], 2);
assert_eq!(v_a[1], 3);
assert_eq!(v_a[2], 4);
// Test on stack.
let vec_stack: &[_] = &[1, 2, 3];
- let v_b = vec_stack[1u..3u].to_vec();
- assert_eq!(v_b.len(), 2u);
- let v_b = v_b;
+ let v_b = vec_stack[1..3].to_vec();
+ assert_eq!(v_b.len(), 2);
+
assert_eq!(v_b[0], 2);
assert_eq!(v_b[1], 3);
// Test `Box<[T]>`
let vec_unique = vec![1, 2, 3, 4, 5, 6];
- let v_d = vec_unique[1u..6u].to_vec();
- assert_eq!(v_d.len(), 5u);
- let v_d = v_d;
+ let v_d = vec_unique[1..6].to_vec();
+ assert_eq!(v_d.len(), 5);
+
assert_eq!(v_d[0], 2);
assert_eq!(v_d[1], 3);
assert_eq!(v_d[2], 4);
#[test]
fn test_slice_from() {
- let vec: &[int] = &[1, 2, 3, 4];
+ let vec: &[_] = &[1, 2, 3, 4];
assert_eq!(&vec[], vec);
- let b: &[int] = &[3, 4];
+ let b: &[_] = &[3, 4];
assert_eq!(&vec[2..], b);
- let b: &[int] = &[];
+ let b: &[_] = &[];
assert_eq!(&vec[4..], b);
}
#[test]
fn test_slice_to() {
- let vec: &[int] = &[1, 2, 3, 4];
+ let vec: &[_] = &[1, 2, 3, 4];
assert_eq!(&vec[..4], vec);
- let b: &[int] = &[1, 2];
+ let b: &[_] = &[1, 2];
assert_eq!(&vec[..2], b);
- let b: &[int] = &[];
+ let b: &[_] = &[];
assert_eq!(&vec[..0], b);
}
// Test on-stack push().
let mut v = vec![];
v.push(1);
- assert_eq!(v.len(), 1u);
+ assert_eq!(v.len(), 1);
assert_eq!(v[0], 1);
// Test on-heap push().
v.push(2);
- assert_eq!(v.len(), 2u);
+ assert_eq!(v.len(), 2);
assert_eq!(v[0], 1);
assert_eq!(v[1], 2);
}
#[test]
fn test_dedup() {
- fn case(a: Vec<uint>, b: Vec<uint>) {
+ fn case(a: Vec<i32>, b: Vec<i32>) {
let mut v = a;
v.dedup();
assert_eq!(v, b);
}
case(vec![], vec![]);
- case(vec![1u], vec![1]);
- case(vec![1u,1], vec![1]);
- case(vec![1u,2,3], vec![1,2,3]);
- case(vec![1u,1,2,3], vec![1,2,3]);
- case(vec![1u,2,2,3], vec![1,2,3]);
- case(vec![1u,2,3,3], vec![1,2,3]);
- case(vec![1u,1,2,2,2,3,3], vec![1,2,3]);
+ case(vec![1], vec![1]);
+ case(vec![1,1], vec![1]);
+ case(vec![1,2,3], vec![1,2,3]);
+ case(vec![1,1,2,3], vec![1,2,3]);
+ case(vec![1,2,2,3], vec![1,2,3]);
+ case(vec![1,2,3,3], vec![1,2,3]);
+ case(vec![1,1,2,2,2,3,3], vec![1,2,3]);
}
#[test]
#[test]
fn test_retain() {
- let mut v = vec![1u, 2, 3, 4, 5];
+ let mut v = vec![1, 2, 3, 4, 5];
v.retain(is_odd);
- assert_eq!(v, vec![1u, 3, 5]);
+ assert_eq!(v, vec![1, 3, 5]);
}
#[test]
#[test]
fn test_permutations() {
{
- let v: [int; 0] = [];
+ let v: [i32; 0] = [];
let mut it = v.permutations();
let (min_size, max_opt) = it.size_hint();
assert_eq!(min_size, 1);
#[test]
fn test_lexicographic_permutations() {
- let v : &mut[int] = &mut[1, 2, 3, 4, 5];
+ let v : &mut[_] = &mut[1, 2, 3, 4, 5];
assert!(v.prev_permutation() == false);
assert!(v.next_permutation());
- let b: &mut[int] = &mut[1, 2, 3, 5, 4];
+ let b: &mut[_] = &mut[1, 2, 3, 5, 4];
assert!(v == b);
assert!(v.prev_permutation());
- let b: &mut[int] = &mut[1, 2, 3, 4, 5];
+ let b: &mut[_] = &mut[1, 2, 3, 4, 5];
assert!(v == b);
assert!(v.next_permutation());
assert!(v.next_permutation());
- let b: &mut[int] = &mut[1, 2, 4, 3, 5];
+ let b: &mut[_] = &mut[1, 2, 4, 3, 5];
assert!(v == b);
assert!(v.next_permutation());
- let b: &mut[int] = &mut[1, 2, 4, 5, 3];
+ let b: &mut[_] = &mut[1, 2, 4, 5, 3];
assert!(v == b);
- let v : &mut[int] = &mut[1, 0, 0, 0];
+ let v : &mut[_] = &mut[1, 0, 0, 0];
assert!(v.next_permutation() == false);
assert!(v.prev_permutation());
- let b: &mut[int] = &mut[0, 1, 0, 0];
+ let b: &mut[_] = &mut[0, 1, 0, 0];
assert!(v == b);
assert!(v.prev_permutation());
- let b: &mut[int] = &mut[0, 0, 1, 0];
+ let b: &mut[_] = &mut[0, 0, 1, 0];
assert!(v == b);
assert!(v.prev_permutation());
- let b: &mut[int] = &mut[0, 0, 0, 1];
+ let b: &mut[_] = &mut[0, 0, 0, 1];
assert!(v == b);
assert!(v.prev_permutation() == false);
}
#[test]
fn test_lexicographic_permutations_empty_and_short() {
- let empty : &mut[int] = &mut[];
+ let empty : &mut[i32] = &mut[];
assert!(empty.next_permutation() == false);
- let b: &mut[int] = &mut[];
+ let b: &mut[i32] = &mut[];
assert!(empty == b);
assert!(empty.prev_permutation() == false);
assert!(empty == b);
- let one_elem : &mut[int] = &mut[4];
+ let one_elem : &mut[_] = &mut[4];
assert!(one_elem.prev_permutation() == false);
- let b: &mut[int] = &mut[4];
+ let b: &mut[_] = &mut[4];
assert!(one_elem == b);
assert!(one_elem.next_permutation() == false);
assert!(one_elem == b);
- let two_elem : &mut[int] = &mut[1, 2];
+ let two_elem : &mut[_] = &mut[1, 2];
assert!(two_elem.prev_permutation() == false);
- let b : &mut[int] = &mut[1, 2];
- let c : &mut[int] = &mut[2, 1];
+ let b : &mut[_] = &mut[1, 2];
+ let c : &mut[_] = &mut[2, 1];
assert!(two_elem == b);
assert!(two_elem.next_permutation());
assert!(two_elem == c);
assert!([].position_elem(&1).is_none());
let v1 = vec![1, 2, 3, 3, 2, 5];
- assert_eq!(v1.position_elem(&1), Some(0u));
- assert_eq!(v1.position_elem(&2), Some(1u));
- assert_eq!(v1.position_elem(&5), Some(5u));
+ assert_eq!(v1.position_elem(&1), Some(0));
+ assert_eq!(v1.position_elem(&2), Some(1));
+ assert_eq!(v1.position_elem(&5), Some(5));
assert!(v1.position_elem(&4).is_none());
}
#[test]
fn test_reverse() {
- let mut v: Vec<int> = vec![10, 20];
+ let mut v = vec![10, 20];
assert_eq!(v[0], 10);
assert_eq!(v[1], 20);
v.reverse();
assert_eq!(v[0], 20);
assert_eq!(v[1], 10);
- let mut v3: Vec<int> = vec![];
+ let mut v3 = Vec::<i32>::new();
v3.reverse();
assert!(v3.is_empty());
}
#[test]
fn test_sort() {
- for len in 4u..25 {
+ for len in 4..25 {
for _ in 0..100 {
- let mut v = thread_rng().gen_iter::<uint>().take(len)
- .collect::<Vec<uint>>();
+ let mut v: Vec<_> = thread_rng().gen_iter::<i32>().take(len).collect();
let mut v1 = v.clone();
v.sort();
}
// shouldn't panic
- let mut v: [uint; 0] = [];
+ let mut v: [i32; 0] = [];
v.sort();
- let mut v = [0xDEADBEEFu];
+ let mut v = [0xDEADBEEFu64];
v.sort();
assert!(v == [0xDEADBEEF]);
}
#[test]
fn test_sort_stability() {
for len in 4..25 {
- for _ in 0u..10 {
+ for _ in 0..10 {
let mut counts = [0; 10];
// create a vector like [(6, 1), (5, 1), (6, 2), ...],
// the second item represents which occurrence of that
// number this element is, i.e. the second elements
// will occur in sorted order.
- let mut v = (0..len).map(|_| {
- let n = thread_rng().gen::<uint>() % 10;
+ let mut v: Vec<_> = (0..len).map(|_| {
+ let n = thread_rng().gen::<usize>() % 10;
counts[n] += 1;
(n, counts[n])
- }).collect::<Vec<(uint, int)>>();
+ }).collect();
// only sort on the first element, so an unstable sort
// may mix up the counts.
#[test]
fn test_concat() {
- let v: [Vec<int>; 0] = [];
- let c: Vec<int> = v.concat();
+ let v: [Vec<i32>; 0] = [];
+ let c = v.concat();
assert_eq!(c, []);
- let d: Vec<int> = [vec![1], vec![2,3]].concat();
+ let d = [vec![1], vec![2,3]].concat();
assert_eq!(d, vec![1, 2, 3]);
- let v: [&[int]; 2] = [&[1], &[2, 3]];
+ let v: &[&[_]] = &[&[1], &[2, 3]];
assert_eq!(v.connect(&0), vec![1, 0, 2, 3]);
- let v: [&[int]; 3] = [&[1], &[2], &[3]];
+ let v: &[&[_]] = &[&[1], &[2], &[3]];
assert_eq!(v.connect(&0), vec![1, 0, 2, 0, 3]);
}
#[test]
fn test_connect() {
- let v: [Vec<int>; 0] = [];
+ let v: [Vec<i32>; 0] = [];
assert_eq!(v.connect(&0), vec![]);
assert_eq!([vec![1], vec![2, 3]].connect(&0), vec![1, 0, 2, 3]);
assert_eq!([vec![1], vec![2], vec![3]].connect(&0), vec![1, 0, 2, 0, 3]);
- let v: [&[int]; 2] = [&[1], &[2, 3]];
+ let v: [&[_]; 2] = [&[1], &[2, 3]];
assert_eq!(v.connect(&0), vec![1, 0, 2, 3]);
- let v: [&[int]; 3] = [&[1], &[2], &[3]];
+ let v: [&[_]; 3] = [&[1], &[2], &[3]];
assert_eq!(v.connect(&0), vec![1, 0, 2, 0, 3]);
}
#[test]
fn test_remove() {
- let mut a = vec![1,2,3,4];
+ let mut a = vec![1, 2, 3, 4];
assert_eq!(a.remove(2), 3);
- assert_eq!(a, vec![1,2,4]);
+ assert_eq!(a, vec![1, 2, 4]);
assert_eq!(a.remove(2), 4);
- assert_eq!(a, vec![1,2]);
+ assert_eq!(a, vec![1, 2]);
assert_eq!(a.remove(0), 1);
assert_eq!(a, vec![2]);
#[test]
fn test_capacity() {
- let mut v = vec![0u64];
- v.reserve_exact(10u);
- assert!(v.capacity() >= 11u);
- let mut v = vec![0u32];
- v.reserve_exact(10u);
- assert!(v.capacity() >= 11u);
+ let mut v = vec![0];
+ v.reserve_exact(10);
+ assert!(v.capacity() >= 11);
}
#[test]
fn test_slice_2() {
let v = vec![1, 2, 3, 4, 5];
- let v = v.slice(1u, 3u);
- assert_eq!(v.len(), 2u);
+ let v = v.slice(1, 3);
+ assert_eq!(v.len(), 2);
assert_eq!(v[0], 2);
assert_eq!(v[1], 3);
}
fn test_permute_fail() {
let v = [(box 0, Rc::new(0)), (box 0, Rc::new(0)),
(box 0, Rc::new(0)), (box 0, Rc::new(0))];
- let mut i = 0u;
+ let mut i = 0;
for _ in v.permutations() {
if i == 2 {
panic!()
#[test]
fn test_total_ord() {
- let c: &[int] = &[1, 2, 3];
+ let c = &[1, 2, 3];
[1, 2, 3, 4][].cmp(c) == Greater;
- let c: &[int] = &[1, 2, 3, 4];
+ let c = &[1, 2, 3, 4];
[1, 2, 3][].cmp(c) == Less;
- let c: &[int] = &[1, 2, 3, 6];
+ let c = &[1, 2, 3, 6];
[1, 2, 3, 4][].cmp(c) == Equal;
- let c: &[int] = &[1, 2, 3, 4, 5, 6];
+ let c = &[1, 2, 3, 4, 5, 6];
[1, 2, 3, 4, 5, 5, 5, 5][].cmp(c) == Less;
- let c: &[int] = &[1, 2, 3, 4];
+ let c = &[1, 2, 3, 4];
[2, 2][].cmp(c) == Greater;
}
#[test]
fn test_mut_rev_iterator() {
- let mut xs = [1u, 2, 3, 4, 5];
+ let mut xs = [1, 2, 3, 4, 5];
for (i,x) in xs.iter_mut().rev().enumerate() {
*x += i;
}
#[test]
fn test_move_iterator() {
- let xs = vec![1u,2,3,4,5];
- assert_eq!(xs.into_iter().fold(0, |a: uint, b: uint| 10*a + b), 12345);
+ let xs = vec![1,2,3,4,5];
+ assert_eq!(xs.into_iter().fold(0, |a: usize, b: usize| 10*a + b), 12345);
}
#[test]
fn test_move_rev_iterator() {
- let xs = vec![1u,2,3,4,5];
- assert_eq!(xs.into_iter().rev().fold(0, |a: uint, b: uint| 10*a + b), 54321);
+ let xs = vec![1,2,3,4,5];
+ assert_eq!(xs.into_iter().rev().fold(0, |a: usize, b: usize| 10*a + b), 54321);
}
#[test]
fn test_splitator() {
let xs = &[1,2,3,4,5];
- let splits: &[&[int]] = &[&[1], &[3], &[5]];
- assert_eq!(xs.split(|x| *x % 2 == 0).collect::<Vec<&[int]>>(),
+ let splits: &[&[_]] = &[&[1], &[3], &[5]];
+ assert_eq!(xs.split(|x| *x % 2 == 0).collect::<Vec<_>>(),
splits);
- let splits: &[&[int]] = &[&[], &[2,3,4,5]];
- assert_eq!(xs.split(|x| *x == 1).collect::<Vec<&[int]>>(),
+ let splits: &[&[_]] = &[&[], &[2,3,4,5]];
+ assert_eq!(xs.split(|x| *x == 1).collect::<Vec<_>>(),
splits);
- let splits: &[&[int]] = &[&[1,2,3,4], &[]];
- assert_eq!(xs.split(|x| *x == 5).collect::<Vec<&[int]>>(),
+ let splits: &[&[_]] = &[&[1,2,3,4], &[]];
+ assert_eq!(xs.split(|x| *x == 5).collect::<Vec<_>>(),
splits);
- let splits: &[&[int]] = &[&[1,2,3,4,5]];
- assert_eq!(xs.split(|x| *x == 10).collect::<Vec<&[int]>>(),
+ let splits: &[&[_]] = &[&[1,2,3,4,5]];
+ assert_eq!(xs.split(|x| *x == 10).collect::<Vec<_>>(),
splits);
- let splits: &[&[int]] = &[&[], &[], &[], &[], &[], &[]];
- assert_eq!(xs.split(|_| true).collect::<Vec<&[int]>>(),
+ let splits: &[&[_]] = &[&[], &[], &[], &[], &[], &[]];
+ assert_eq!(xs.split(|_| true).collect::<Vec<&[i32]>>(),
splits);
- let xs: &[int] = &[];
- let splits: &[&[int]] = &[&[]];
- assert_eq!(xs.split(|x| *x == 5).collect::<Vec<&[int]>>(), splits);
+ let xs: &[i32] = &[];
+ let splits: &[&[i32]] = &[&[]];
+ assert_eq!(xs.split(|x| *x == 5).collect::<Vec<&[i32]>>(), splits);
}
#[test]
fn test_splitnator() {
let xs = &[1,2,3,4,5];
- let splits: &[&[int]] = &[&[1,2,3,4,5]];
- assert_eq!(xs.splitn(0, |x| *x % 2 == 0).collect::<Vec<&[int]>>(),
+ let splits: &[&[_]] = &[&[1,2,3,4,5]];
+ assert_eq!(xs.splitn(0, |x| *x % 2 == 0).collect::<Vec<_>>(),
splits);
- let splits: &[&[int]] = &[&[1], &[3,4,5]];
- assert_eq!(xs.splitn(1, |x| *x % 2 == 0).collect::<Vec<&[int]>>(),
+ let splits: &[&[_]] = &[&[1], &[3,4,5]];
+ assert_eq!(xs.splitn(1, |x| *x % 2 == 0).collect::<Vec<_>>(),
splits);
- let splits: &[&[int]] = &[&[], &[], &[], &[4,5]];
- assert_eq!(xs.splitn(3, |_| true).collect::<Vec<&[int]>>(),
+ let splits: &[&[_]] = &[&[], &[], &[], &[4,5]];
+ assert_eq!(xs.splitn(3, |_| true).collect::<Vec<_>>(),
splits);
- let xs: &[int] = &[];
- let splits: &[&[int]] = &[&[]];
- assert_eq!(xs.splitn(1, |x| *x == 5).collect::<Vec<&[int]>>(), splits);
+ let xs: &[i32] = &[];
+ let splits: &[&[i32]] = &[&[]];
+ assert_eq!(xs.splitn(1, |x| *x == 5).collect::<Vec<_>>(), splits);
}
#[test]
fn test_splitnator_mut() {
let xs = &mut [1,2,3,4,5];
- let splits: &[&mut [int]] = &[&mut [1,2,3,4,5]];
- assert_eq!(xs.splitn_mut(0, |x| *x % 2 == 0).collect::<Vec<&mut [int]>>(),
+ let splits: &[&mut[_]] = &[&mut [1,2,3,4,5]];
+ assert_eq!(xs.splitn_mut(0, |x| *x % 2 == 0).collect::<Vec<_>>(),
splits);
- let splits: &[&mut [int]] = &[&mut [1], &mut [3,4,5]];
- assert_eq!(xs.splitn_mut(1, |x| *x % 2 == 0).collect::<Vec<&mut [int]>>(),
+ let splits: &[&mut[_]] = &[&mut [1], &mut [3,4,5]];
+ assert_eq!(xs.splitn_mut(1, |x| *x % 2 == 0).collect::<Vec<_>>(),
splits);
- let splits: &[&mut [int]] = &[&mut [], &mut [], &mut [], &mut [4,5]];
- assert_eq!(xs.splitn_mut(3, |_| true).collect::<Vec<&mut [int]>>(),
+ let splits: &[&mut[_]] = &[&mut [], &mut [], &mut [], &mut [4,5]];
+ assert_eq!(xs.splitn_mut(3, |_| true).collect::<Vec<_>>(),
splits);
- let xs: &mut [int] = &mut [];
- let splits: &[&mut [int]] = &[&mut []];
- assert_eq!(xs.splitn_mut(1, |x| *x == 5).collect::<Vec<&mut [int]>>(),
+ let xs: &mut [i32] = &mut [];
+ let splits: &[&mut[i32]] = &[&mut []];
+ assert_eq!(xs.splitn_mut(1, |x| *x == 5).collect::<Vec<_>>(),
splits);
}
fn test_rsplitator() {
let xs = &[1,2,3,4,5];
- let splits: &[&[int]] = &[&[5], &[3], &[1]];
- assert_eq!(xs.split(|x| *x % 2 == 0).rev().collect::<Vec<&[int]>>(),
+ let splits: &[&[_]] = &[&[5], &[3], &[1]];
+ assert_eq!(xs.split(|x| *x % 2 == 0).rev().collect::<Vec<_>>(),
splits);
- let splits: &[&[int]] = &[&[2,3,4,5], &[]];
- assert_eq!(xs.split(|x| *x == 1).rev().collect::<Vec<&[int]>>(),
+ let splits: &[&[_]] = &[&[2,3,4,5], &[]];
+ assert_eq!(xs.split(|x| *x == 1).rev().collect::<Vec<_>>(),
splits);
- let splits: &[&[int]] = &[&[], &[1,2,3,4]];
- assert_eq!(xs.split(|x| *x == 5).rev().collect::<Vec<&[int]>>(),
+ let splits: &[&[_]] = &[&[], &[1,2,3,4]];
+ assert_eq!(xs.split(|x| *x == 5).rev().collect::<Vec<_>>(),
splits);
- let splits: &[&[int]] = &[&[1,2,3,4,5]];
- assert_eq!(xs.split(|x| *x == 10).rev().collect::<Vec<&[int]>>(),
+ let splits: &[&[_]] = &[&[1,2,3,4,5]];
+ assert_eq!(xs.split(|x| *x == 10).rev().collect::<Vec<_>>(),
splits);
- let xs: &[int] = &[];
- let splits: &[&[int]] = &[&[]];
- assert_eq!(xs.split(|x| *x == 5).rev().collect::<Vec<&[int]>>(), splits);
+ let xs: &[i32] = &[];
+ let splits: &[&[i32]] = &[&[]];
+ assert_eq!(xs.split(|x| *x == 5).rev().collect::<Vec<&[i32]>>(), splits);
}
#[test]
fn test_rsplitnator() {
let xs = &[1,2,3,4,5];
- let splits: &[&[int]] = &[&[1,2,3,4,5]];
- assert_eq!(xs.rsplitn(0, |x| *x % 2 == 0).collect::<Vec<&[int]>>(),
+ let splits: &[&[_]] = &[&[1,2,3,4,5]];
+ assert_eq!(xs.rsplitn(0, |x| *x % 2 == 0).collect::<Vec<_>>(),
splits);
- let splits: &[&[int]] = &[&[5], &[1,2,3]];
- assert_eq!(xs.rsplitn(1, |x| *x % 2 == 0).collect::<Vec<&[int]>>(),
+ let splits: &[&[_]] = &[&[5], &[1,2,3]];
+ assert_eq!(xs.rsplitn(1, |x| *x % 2 == 0).collect::<Vec<_>>(),
splits);
- let splits: &[&[int]] = &[&[], &[], &[], &[1,2]];
- assert_eq!(xs.rsplitn(3, |_| true).collect::<Vec<&[int]>>(),
+ let splits: &[&[_]] = &[&[], &[], &[], &[1,2]];
+ assert_eq!(xs.rsplitn(3, |_| true).collect::<Vec<_>>(),
splits);
- let xs: &[int] = &[];
- let splits: &[&[int]] = &[&[]];
- assert_eq!(xs.rsplitn(1, |x| *x == 5).collect::<Vec<&[int]>>(), splits);
+ let xs: &[i32] = &[];
+ let splits: &[&[i32]] = &[&[]];
+ assert_eq!(xs.rsplitn(1, |x| *x == 5).collect::<Vec<&[i32]>>(), splits);
}
#[test]
fn test_windowsator() {
let v = &[1,2,3,4];
- let wins: &[&[int]] = &[&[1,2], &[2,3], &[3,4]];
- assert_eq!(v.windows(2).collect::<Vec<&[int]>>(), wins);
- let wins: &[&[int]] = &[&[1,2,3], &[2,3,4]];
- assert_eq!(v.windows(3).collect::<Vec<&[int]>>(), wins);
+ let wins: &[&[_]] = &[&[1,2], &[2,3], &[3,4]];
+ assert_eq!(v.windows(2).collect::<Vec<_>>(), wins);
+
+ let wins: &[&[_]] = &[&[1,2,3], &[2,3,4]];
+ assert_eq!(v.windows(3).collect::<Vec<_>>(), wins);
assert!(v.windows(6).next().is_none());
}
assert_eq!(v.chunks(2).len(), 3);
- let chunks: &[&[int]] = &[&[1,2], &[3,4], &[5]];
- assert_eq!(v.chunks(2).collect::<Vec<&[int]>>(), chunks);
- let chunks: &[&[int]] = &[&[1,2,3], &[4,5]];
- assert_eq!(v.chunks(3).collect::<Vec<&[int]>>(), chunks);
- let chunks: &[&[int]] = &[&[1,2,3,4,5]];
- assert_eq!(v.chunks(6).collect::<Vec<&[int]>>(), chunks);
+ let chunks: &[&[_]] = &[&[1,2], &[3,4], &[5]];
+ assert_eq!(v.chunks(2).collect::<Vec<_>>(), chunks);
+ let chunks: &[&[_]] = &[&[1,2,3], &[4,5]];
+ assert_eq!(v.chunks(3).collect::<Vec<_>>(), chunks);
+ let chunks: &[&[_]] = &[&[1,2,3,4,5]];
+ assert_eq!(v.chunks(6).collect::<Vec<_>>(), chunks);
- let chunks: &[&[int]] = &[&[5], &[3,4], &[1,2]];
- assert_eq!(v.chunks(2).rev().collect::<Vec<&[int]>>(), chunks);
+ let chunks: &[&[_]] = &[&[5], &[3,4], &[1,2]];
+ assert_eq!(v.chunks(2).rev().collect::<Vec<_>>(), chunks);
let mut it = v.chunks(2);
assert_eq!(it.indexable(), 3);
- let chunk: &[int] = &[1,2];
+
+ let chunk: &[_] = &[1,2];
assert_eq!(it.idx(0).unwrap(), chunk);
- let chunk: &[int] = &[3,4];
+ let chunk: &[_] = &[3,4];
assert_eq!(it.idx(1).unwrap(), chunk);
- let chunk: &[int] = &[5];
+ let chunk: &[_] = &[5];
assert_eq!(it.idx(2).unwrap(), chunk);
assert_eq!(it.idx(3), None);
}
assert_eq!(format!("{:?}", x), x_str);
})
}
- let empty: Vec<int> = vec![];
+ let empty = Vec::<i32>::new();
test_show_vec!(empty, "[]");
test_show_vec!(vec![1], "[1]");
test_show_vec!(vec![1, 2, 3], "[1, 2, 3]");
- test_show_vec!(vec![vec![], vec![1u], vec![1u, 1u]],
+ test_show_vec!(vec![vec![], vec![1], vec![1, 1]],
"[[], [1], [1, 1]]");
- let empty_mut: &mut [int] = &mut[];
+ let empty_mut: &mut [i32] = &mut[];
test_show_vec!(empty_mut, "[]");
- let v: &mut[int] = &mut[1];
+ let v = &mut[1];
test_show_vec!(v, "[1]");
- let v: &mut[int] = &mut[1, 2, 3];
+ let v = &mut[1, 2, 3];
test_show_vec!(v, "[1, 2, 3]");
- let v: &mut [&mut[uint]] = &mut[&mut[], &mut[1u], &mut[1u, 1u]];
+ let v: &mut[&mut[_]] = &mut[&mut[], &mut[1], &mut[1, 1]];
test_show_vec!(v, "[[], [1], [1, 1]]");
}
}}
}
- t!(&[int]);
- t!(Vec<int>);
+ t!(&[i32]);
+ t!(Vec<i32>);
}
#[test]
fn test_iter_zero_sized() {
let mut v = vec![Foo, Foo, Foo];
assert_eq!(v.len(), 3);
- let mut cnt = 0u;
+ let mut cnt = 0;
for f in &v {
assert!(*f == Foo);
let h = x.last_mut();
assert_eq!(*h.unwrap(), 5);
- let y: &mut [int] = &mut [];
+ let y: &mut [i32] = &mut [];
assert!(y.last_mut().is_none());
}
#[test]
fn test_to_vec() {
- let xs = box [1u, 2, 3];
+ let xs = box [1, 2, 3];
let ys = xs.to_vec();
- assert_eq!(ys, [1u, 2, 3]);
+ assert_eq!(ys, [1, 2, 3]);
}
}
fn iterator(b: &mut Bencher) {
// peculiar numbers to stop LLVM from optimising the summation
// out.
- let v = (0u..100).map(|i| i ^ (i << 1) ^ (i >> 1)).collect::<Vec<_>>();
+ let v: Vec<_> = (0..100).map(|i| i ^ (i << 1) ^ (i >> 1)).collect();
b.iter(|| {
let mut sum = 0;
#[bench]
fn mut_iterator(b: &mut Bencher) {
- let mut v = repeat(0).take(100).collect::<Vec<_>>();
+ let mut v: Vec<_> = repeat(0).take(100).collect();
b.iter(|| {
let mut i = 0;
#[bench]
fn concat(b: &mut Bencher) {
- let xss: Vec<Vec<uint>> =
- (0..100u).map(|i| (0..i).collect()).collect();
+ let xss: Vec<Vec<i32>> =
+ (0..100).map(|i| (0..i).collect()).collect();
b.iter(|| {
xss.concat();
});
#[bench]
fn connect(b: &mut Bencher) {
- let xss: Vec<Vec<uint>> =
- (0..100u).map(|i| (0..i).collect()).collect();
+ let xss: Vec<Vec<i32>> =
+ (0..100).map(|i| (0..i).collect()).collect();
b.iter(|| {
xss.connect(&0)
});
#[bench]
fn push(b: &mut Bencher) {
- let mut vec: Vec<uint> = vec![];
+ let mut vec = Vec::<i32>::new();
b.iter(|| {
vec.push(0);
black_box(&vec);
#[bench]
fn starts_with_same_vector(b: &mut Bencher) {
- let vec: Vec<uint> = (0u..100).collect();
+ let vec: Vec<_> = (0..100).collect();
b.iter(|| {
vec.starts_with(&vec)
})
#[bench]
fn starts_with_single_element(b: &mut Bencher) {
- let vec: Vec<uint> = vec![0];
+ let vec: Vec<_> = vec![0];
b.iter(|| {
vec.starts_with(&vec)
})
#[bench]
fn starts_with_diff_one_element_at_end(b: &mut Bencher) {
- let vec: Vec<uint> = (0u..100).collect();
- let mut match_vec: Vec<uint> = (0u..99).collect();
+ let vec: Vec<_> = (0..100).collect();
+ let mut match_vec: Vec<_> = (0..99).collect();
match_vec.push(0);
b.iter(|| {
vec.starts_with(&match_vec)
#[bench]
fn ends_with_same_vector(b: &mut Bencher) {
- let vec: Vec<uint> = (0u..100).collect();
+ let vec: Vec<_> = (0..100).collect();
b.iter(|| {
vec.ends_with(&vec)
})
#[bench]
fn ends_with_single_element(b: &mut Bencher) {
- let vec: Vec<uint> = vec![0];
+ let vec: Vec<_> = vec![0];
b.iter(|| {
vec.ends_with(&vec)
})
#[bench]
fn ends_with_diff_one_element_at_beginning(b: &mut Bencher) {
- let vec: Vec<uint> = (0u..100).collect();
- let mut match_vec: Vec<uint> = (0u..100).collect();
+ let vec: Vec<_> = (0..100).collect();
+ let mut match_vec: Vec<_> = (0..100).collect();
match_vec[0] = 200;
b.iter(|| {
vec.starts_with(&match_vec)
#[bench]
fn contains_last_element(b: &mut Bencher) {
- let vec: Vec<uint> = (0u..100).collect();
+ let vec: Vec<_> = (0..100).collect();
b.iter(|| {
- vec.contains(&99u)
+ vec.contains(&99)
})
}
#[bench]
fn zero_1kb_set_memory(b: &mut Bencher) {
b.iter(|| {
- let mut v: Vec<uint> = Vec::with_capacity(1024);
+ let mut v = Vec::<u8>::with_capacity(1024);
unsafe {
let vp = v.as_mut_ptr();
ptr::set_memory(vp, 0, 1024);
#[bench]
fn zero_1kb_loop_set(b: &mut Bencher) {
b.iter(|| {
- let mut v: Vec<uint> = Vec::with_capacity(1024);
+ let mut v = Vec::<u8>::with_capacity(1024);
unsafe {
v.set_len(1024);
}
- for i in 0u..1024 {
+ for i in 0..1024 {
v[i] = 0;
}
});
#[bench]
fn zero_1kb_mut_iter(b: &mut Bencher) {
b.iter(|| {
- let mut v = Vec::with_capacity(1024);
+ let mut v = Vec::<u8>::with_capacity(1024);
unsafe {
v.set_len(1024);
}
fn random_inserts(b: &mut Bencher) {
let mut rng = weak_rng();
b.iter(|| {
- let mut v = repeat((0u, 0u)).take(30).collect::<Vec<_>>();
- for _ in 0u..100 {
+ let mut v: Vec<_> = repeat((0, 0)).take(30).collect();
+ for _ in 0..100 {
let l = v.len();
- v.insert(rng.gen::<uint>() % (l + 1),
+ v.insert(rng.gen::<usize>() % (l + 1),
(1, 1));
}
})
fn random_removes(b: &mut Bencher) {
let mut rng = weak_rng();
b.iter(|| {
- let mut v = repeat((0u, 0u)).take(130).collect::<Vec<_>>();
- for _ in 0u..100 {
+ let mut v: Vec<_> = repeat((0, 0)).take(130).collect();
+ for _ in 0..100 {
let l = v.len();
- v.remove(rng.gen::<uint>() % l);
+ v.remove(rng.gen::<usize>() % l);
}
})
}
fn sort_random_small(b: &mut Bencher) {
let mut rng = weak_rng();
b.iter(|| {
- let mut v = rng.gen_iter::<u64>().take(5).collect::<Vec<u64>>();
+ let mut v: Vec<_> = rng.gen_iter::<u64>().take(5).collect();
v.sort();
});
b.bytes = 5 * mem::size_of::<u64>() as u64;
fn sort_random_medium(b: &mut Bencher) {
let mut rng = weak_rng();
b.iter(|| {
- let mut v = rng.gen_iter::<u64>().take(100).collect::<Vec<u64>>();
+ let mut v: Vec<_> = rng.gen_iter::<u64>().take(100).collect();
v.sort();
});
b.bytes = 100 * mem::size_of::<u64>() as u64;
fn sort_random_large(b: &mut Bencher) {
let mut rng = weak_rng();
b.iter(|| {
- let mut v = rng.gen_iter::<u64>().take(10000).collect::<Vec<u64>>();
+ let mut v: Vec<_> = rng.gen_iter::<u64>().take(10000).collect();
v.sort();
});
b.bytes = 10000 * mem::size_of::<u64>() as u64;
#[bench]
fn sort_sorted(b: &mut Bencher) {
- let mut v = (0u..10000).collect::<Vec<_>>();
+ let mut v: Vec<_> = (0..10000).collect();
b.iter(|| {
v.sort();
});
b.bytes = (v.len() * mem::size_of_val(&v[0])) as u64;
}
- type BigSortable = (u64,u64,u64,u64);
+ type BigSortable = (u64, u64, u64, u64);
#[bench]
fn sort_big_random_small(b: &mut Bencher) {
#[bench]
fn sort_big_sorted(b: &mut Bencher) {
- let mut v = (0..10000u).map(|i| (i, i, i, i)).collect::<Vec<_>>();
+ let mut v: Vec<BigSortable> = (0..10000).map(|i| (i, i, i, i)).collect();
b.iter(|| {
v.sort();
});
pub use core::str::{Split, SplitTerminator};
pub use core::str::{SplitN, RSplitN};
pub use core::str::{from_utf8, CharEq, Chars, CharIndices, Bytes};
-pub use core::str::{from_utf8_unchecked, from_c_str};
+pub use core::str::{from_utf8_unchecked, from_c_str, ParseBoolError};
pub use unicode::str::{Words, Graphemes, GraphemeIndices};
/*
}
}
- fn size_hint(&self) -> (uint, Option<uint>) {
+ fn size_hint(&self) -> (usize, Option<usize>) {
let (lower, _) = self.iter.size_hint();
(lower, None)
}
fn next(&mut self) -> Option<u16> { self.encoder.next() }
#[inline]
- fn size_hint(&self) -> (uint, Option<uint>) { self.encoder.size_hint() }
+ fn size_hint(&self) -> (usize, Option<usize>) { self.encoder.size_hint() }
}
/*
#[inline]
#[unstable(feature = "collections",
reason = "this functionality may be moved to libunicode")]
- fn nfd_chars<'a>(&'a self) -> Decompositions<'a> {
+ fn nfd_chars(&self) -> Decompositions {
Decompositions {
iter: self[].chars(),
buffer: Vec::new(),
#[inline]
#[unstable(feature = "collections",
reason = "this functionality may be moved to libunicode")]
- fn nfkd_chars<'a>(&'a self) -> Decompositions<'a> {
+ fn nfkd_chars(&self) -> Decompositions {
Decompositions {
iter: self[].chars(),
buffer: Vec::new(),
#[inline]
#[unstable(feature = "collections",
reason = "this functionality may be moved to libunicode")]
- fn nfc_chars<'a>(&'a self) -> Recompositions<'a> {
+ fn nfc_chars(&self) -> Recompositions {
Recompositions {
iter: self.nfd_chars(),
state: Composing,
#[inline]
#[unstable(feature = "collections",
reason = "this functionality may be moved to libunicode")]
- fn nfkc_chars<'a>(&'a self) -> Recompositions<'a> {
+ fn nfkc_chars(&self) -> Recompositions {
Recompositions {
iter: self.nfkd_chars(),
state: Composing,
/// assert_eq!(v, vec![""]);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- fn splitn<P: CharEq>(&self, count: u
int, pat: P) -> SplitN<P> {
+ fn splitn<P: CharEq>(&self, count: u
size, pat: P) -> SplitN<P> {
core_str::StrExt::splitn(&self[], count, pat)
}
/// assert_eq!(v, vec!["leopard", "tiger", "lionX"]);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- fn rsplitn<P: CharEq>(&self, count: u
int, pat: P) -> RSplitN<P> {
+ fn rsplitn<P: CharEq>(&self, count: u
size, pat: P) -> RSplitN<P> {
core_str::StrExt::rsplitn(&self[], count, pat)
}
/// # Example
///
/// ```rust
- /// let v: Vec<(uint, uint)> = "abcXXXabcYYYabc".match_indices("abc").collect();
+ /// let v: Vec<(usize, usize)> = "abcXXXabcYYYabc".match_indices("abc").collect();
/// assert_eq!(v, vec![(0,3), (6,9), (12,15)]);
///
- /// let v: Vec<(uint, uint)> = "1abcabc2".match_indices("abc").collect();
+ /// let v: Vec<(usize, usize)> = "1abcabc2".match_indices("abc").collect();
/// assert_eq!(v, vec![(1,4), (4,7)]);
///
- /// let v: Vec<(uint, uint)> = "ababa".match_indices("aba").collect();
+ /// let v: Vec<(usize, usize)> = "ababa".match_indices("aba").collect();
/// assert_eq!(v, vec![(0, 3)]); // only the first `aba`
/// ```
#[unstable(feature = "collections",
#[unstable(feature = "collections",
reason = "use slice notation [a..b] instead")]
#[deprecated(since = "1.0.0", reason = "use slice notation [a..b] instead")]
- fn slice(&self, begin: uint, end: uint) -> &str;
+ fn slice(&self, begin: usize, end: usize) -> &str;
/// Deprecated: use `s[a..]` instead.
#[unstable(feature = "collections",
reason = "use slice notation [a..b] instead")]
#[deprecated(since = "1.0.0", reason = "use slice notation [a..] instead")]
- fn slice_from(&self, begin: uint) -> &str;
+ fn slice_from(&self, begin: usize) -> &str;
/// Deprecated: use `s[..a]` instead.
#[unstable(feature = "collections",
reason = "use slice notation [a..b] instead")]
#[deprecated(since = "1.0.0", reason = "use slice notation [..a] instead")]
- fn slice_to(&self, end: uint) -> &str;
+ fn slice_to(&self, end: usize) -> &str;
/// Returns a slice of the string from the character range
/// [`begin`..`end`).
/// ```
#[unstable(feature = "collections",
reason = "may have yet to prove its worth")]
- fn slice_chars(&self, begin: uint, end: uint) -> &str {
+ fn slice_chars(&self, begin: usize, end: usize) -> &str {
core_str::StrExt::slice_chars(&self[], begin, end)
}
/// Caller must check both UTF-8 character boundaries and the boundaries of
/// the entire slice as well.
#[stable(feature = "rust1", since = "1.0.0")]
- unsafe fn slice_unchecked(&self, begin: uint, end: uint) -> &str {
+ unsafe fn slice_unchecked(&self, begin: usize, end: usize) -> &str {
core_str::StrExt::slice_unchecked(&self[], begin, end)
}
/// ```
#[unstable(feature = "collections",
reason = "naming is uncertain with container conventions")]
- fn is_char_boundary(&self, index: uint) -> bool {
+ fn is_char_boundary(&self, index: usize) -> bool {
core_str::StrExt::is_char_boundary(&self[], index)
}
/// use std::str::CharRange;
///
/// let s = "中华Việt Nam";
- /// let mut i = 0u;
+ /// let mut i = 0;
/// while i < s.len() {
/// let CharRange {ch, next} = s.char_range_at(i);
/// println!("{}: {}", i, ch);
///
/// # Return value
///
- /// A record {ch: char, next: uint} containing the char value and the byte
+ /// A record {ch: char, next: usize} containing the char value and the byte
/// index of the next Unicode character.
///
/// # Panics
/// If `i` is not the index of the beginning of a valid UTF-8 character.
#[unstable(feature = "collections",
reason = "naming is uncertain with container conventions")]
- fn char_range_at(&self, start: uint) -> CharRange {
+ fn char_range_at(&self, start: usize) -> CharRange {
core_str::StrExt::char_range_at(&self[], start)
}
/// If `i` is not an index following a valid UTF-8 character.
#[unstable(feature = "collections",
reason = "naming is uncertain with container conventions")]
- fn char_range_at_reverse(&self, start: uint) -> CharRange {
+ fn char_range_at_reverse(&self, start: usize) -> CharRange {
core_str::StrExt::char_range_at_reverse(&self[], start)
}
/// If `i` is not the index of the beginning of a valid UTF-8 character.
#[unstable(feature = "collections",
reason = "naming is uncertain with container conventions")]
- fn char_at(&self, i: uint) -> char {
+ fn char_at(&self, i: usize) -> char {
core_str::StrExt::char_at(&self[], i)
}
/// If `i` is not an index following a valid UTF-8 character.
#[unstable(feature = "collections",
reason = "naming is uncertain with container conventions")]
- fn char_at_reverse(&self, i: uint) -> char {
+ fn char_at_reverse(&self, i: usize) -> char {
core_str::StrExt::char_at_reverse(&self[], i)
}
/// assert_eq!(s.find(x), None);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- fn find<P: CharEq>(&self, pat: P) -> Option<uint> {
+ fn find<P: CharEq>(&self, pat: P) -> Option<usize> {
core_str::StrExt::find(&self[], pat)
}
/// assert_eq!(s.rfind(x), None);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- fn rfind<P: CharEq>(&self, pat: P) -> Option<uint> {
+ fn rfind<P: CharEq>(&self, pat: P) -> Option<usize> {
core_str::StrExt::rfind(&self[], pat)
}
/// ```
#[unstable(feature = "collections",
reason = "might get removed in favor of a more generic find in the future")]
- fn find_str(&self, needle: &str) -> Option<uint> {
+ fn find_str(&self, needle: &str) -> Option<usize> {
core_str::StrExt::find_str(&self[], needle)
}
/// ```
#[unstable(feature = "collections",
reason = "awaiting convention about comparability of arbitrary slices")]
- fn subslice_offset(&self, inner: &str) -> uint {
+ fn subslice_offset(&self, inner: &str) -> usize {
core_str::StrExt::subslice_offset(&self[], inner)
}
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
- fn len(&self) -> uint {
+ fn len(&self) -> usize {
core_str::StrExt::len(&self[])
}
/// # Example
///
/// ```rust
- /// let gr_inds = "a̐éö̲\r\n".grapheme_indices(true).collect::<Vec<(uint, &str)>>();
- /// let b: &[_] = &[(0u, "a̐"), (3, "é"), (6, "ö̲"), (11, "\r\n")];
+ /// let gr_inds = "a̐éö̲\r\n".grapheme_indices(true).collect::<Vec<(usize, &str)>>();
+ /// let b: &[_] = &[(0, "a̐"), (3, "é"), (6, "ö̲"), (11, "\r\n")];
/// assert_eq!(gr_inds.as_slice(), b);
/// ```
#[unstable(feature = "collections",
/// `is_cjk` = `false`) if the locale is unknown.
#[unstable(feature = "collections",
reason = "this functionality may only be provided by libunicode")]
- fn width(&self, is_cjk: bool) -> uint {
+ fn width(&self, is_cjk: bool) -> usize {
UnicodeStr::width(&self[], is_cjk)
}
#[stable(feature = "rust1", since = "1.0.0")]
impl StrExt for str {
- fn slice(&self, begin: uint, end: uint) -> &str {
+ fn slice(&self, begin: usize, end: usize) -> &str {
&self[begin..end]
}
- fn slice_from(&self, begin: uint) -> &str {
+ fn slice_from(&self, begin: usize) -> &str {
&self[begin..]
}
- fn slice_to(&self, end: uint) -> &str {
+ fn slice_to(&self, end: usize) -> &str {
&self[..end]
}
}
#[test]
fn test_len() {
- assert_eq!("".len(), 0u);
- assert_eq!("hello world".len(), 11u);
- assert_eq!("\x63".len(), 1u);
- assert_eq!("\u{a2}".len(), 2u);
- assert_eq!("\u{3c0}".len(), 2u);
- assert_eq!("\u{2620}".len(), 3u);
- assert_eq!("\u{1d11e}".len(), 4u);
-
- assert_eq!("".chars().count(), 0u);
- assert_eq!("hello world".chars().count(), 11u);
- assert_eq!("\x63".chars().count(), 1u);
- assert_eq!("\u{a2}".chars().count(), 1u);
- assert_eq!("\u{3c0}".chars().count(), 1u);
- assert_eq!("\u{2620}".chars().count(), 1u);
- assert_eq!("\u{1d11e}".chars().count(), 1u);
- assert_eq!("ประเทศไทย中华Việt Nam".chars().count(), 19u);
-
- assert_eq!("ｈｅｌｌｏ".width(false), 10u);
- assert_eq!("ｈｅｌｌｏ".width(true), 10u);
- assert_eq!("\0\0\0\0\0".width(false), 0u);
- assert_eq!("\0\0\0\0\0".width(true), 0u);
- assert_eq!("".width(false), 0u);
- assert_eq!("".width(true), 0u);
- assert_eq!("\u{2081}\u{2082}\u{2083}\u{2084}".width(false), 4u);
- assert_eq!("\u{2081}\u{2082}\u{2083}\u{2084}".width(true), 8u);
+ assert_eq!("".len(), 0);
+ assert_eq!("hello world".len(), 11);
+ assert_eq!("\x63".len(), 1);
+ assert_eq!("\u{a2}".len(), 2);
+ assert_eq!("\u{3c0}".len(), 2);
+ assert_eq!("\u{2620}".len(), 3);
+ assert_eq!("\u{1d11e}".len(), 4);
+
+ assert_eq!("".chars().count(), 0);
+ assert_eq!("hello world".chars().count(), 11);
+ assert_eq!("\x63".chars().count(), 1);
+ assert_eq!("\u{a2}".chars().count(), 1);
+ assert_eq!("\u{3c0}".chars().count(), 1);
+ assert_eq!("\u{2620}".chars().count(), 1);
+ assert_eq!("\u{1d11e}".chars().count(), 1);
+ assert_eq!("ประเทศไทย中华Việt Nam".chars().count(), 19);
+
+ assert_eq!("ｈｅｌｌｏ".width(false), 10);
+ assert_eq!("ｈｅｌｌｏ".width(true), 10);
+ assert_eq!("\0\0\0\0\0".width(false), 0);
+ assert_eq!("\0\0\0\0\0".width(true), 0);
+ assert_eq!("".width(false), 0);
+ assert_eq!("".width(true), 0);
+ assert_eq!("\u{2081}\u{2082}\u{2083}\u{2084}".width(false), 4);
+ assert_eq!("\u{2081}\u{2082}\u{2083}\u{2084}".width(true), 8);
}
#[test]
fn test_find() {
- assert_eq!("hello".find('l'), Some(2u));
- assert_eq!("hello".find(|c:char| c == 'o'), Some(4u));
+ assert_eq!("hello".find('l'), Some(2));
+ assert_eq!("hello".find(|c:char| c == 'o'), Some(4));
assert!("hello".find('x').is_none());
assert!("hello".find(|c:char| c == 'x').is_none());
- assert_eq!("ประเทศไทย中华Việt Nam".find('华'), Some(30u));
- assert_eq!("ประเทศไทย中华Việt Nam".find(|c: char| c == '华'), Some(30u));
+ assert_eq!("ประเทศไทย中华Việt Nam".find('华'), Some(30));
+ assert_eq!("ประเทศไทย中华Việt Nam".find(|c: char| c == '华'), Some(30));
}
#[test]
fn test_rfind() {
- assert_eq!("hello".rfind('l'), Some(3u));
- assert_eq!("hello".rfind(|c:char| c == 'o'), Some(4u));
+ assert_eq!("hello".rfind('l'), Some(3));
+ assert_eq!("hello".rfind(|c:char| c == 'o'), Some(4));
assert!("hello".rfind('x').is_none());
assert!("hello".rfind(|c:char| c == 'x').is_none());
- assert_eq!("ประเทศไทย中华Việt Nam".rfind('华'), Some(30u));
- assert_eq!("ประเทศไทย中华Việt Nam".rfind(|c: char| c == '华'), Some(30u));
+ assert_eq!("ประเทศไทย中华Việt Nam".rfind('华'), Some(30));
+ assert_eq!("ประเทศไทย中华Việt Nam".rfind(|c: char| c == '华'), Some(30));
}
#[test]
#[test]
fn test_find_str() {
// byte positions
- assert_eq!("".find_str(""), Some(0u));
+ assert_eq!("".find_str(""), Some(0));
assert!("banana".find_str("apple pie").is_none());
let data = "abcabc";
- assert_eq!(data[0u..6u].find_str("ab"), Some(0u));
- assert_eq!(data[2u..6u].find_str("ab"), Some(3u - 2u));
- assert!(data[2u..4u].find_str("ab").is_none());
+ assert_eq!(data[0..6].find_str("ab"), Some(0));
+ assert_eq!(data[2..6].find_str("ab"), Some(3 - 2));
+ assert!(data[2..4].find_str("ab").is_none());
let string = "ประเทศไทย中华Việt Nam";
let mut data = String::from_str(string);
data.push_str(string);
assert!(data.find_str("ไท华").is_none());
- assert_eq!(data[0u..43u].find_str(""), Some(0u));
- assert_eq!(data[6u..43u].find_str(""), Some(6u - 6u));
+ assert_eq!(data[0..43].find_str(""), Some(0));
+ assert_eq!(data[6..43].find_str(""), Some(6 - 6));
- assert_eq!(data[0u..43u].find_str("ประ"), Some( 0u));
- assert_eq!(data[0u..43u].find_str("ทศไ"), Some(12u));
- assert_eq!(data[0u..43u].find_str("ย中"), Some(24u));
- assert_eq!(data[0u..43u].find_str("iệt"), Some(34u));
- assert_eq!(data[0u..43u].find_str("Nam"), Some(40u));
+ assert_eq!(data[0..43].find_str("ประ"), Some( 0));
+ assert_eq!(data[0..43].find_str("ทศไ"), Some(12));
+ assert_eq!(data[0..43].find_str("ย中"), Some(24));
+ assert_eq!(data[0..43].find_str("iệt"), Some(34));
+ assert_eq!(data[0..43].find_str("Nam"), Some(40));
- assert_eq!(data[43u..86u].find_str("ประ"), Some(43u - 43u));
- assert_eq!(data[43u..86u].find_str("ทศไ"), Some(55u - 43u));
- assert_eq!(data[43u..86u].find_str("ย中"), Some(67u - 43u));
- assert_eq!(data[43u..86u].find_str("iệt"), Some(77u - 43u));
- assert_eq!(data[43u..86u].find_str("Nam"), Some(83u - 43u));
+ assert_eq!(data[43..86].find_str("ประ"), Some(43 - 43));
+ assert_eq!(data[43..86].find_str("ทศไ"), Some(55 - 43));
+ assert_eq!(data[43..86].find_str("ย中"), Some(67 - 43));
+ assert_eq!(data[43..86].find_str("iệt"), Some(77 - 43));
+ assert_eq!(data[43..86].find_str("Nam"), Some(83 - 43));
}
#[test]
fn test_slice_chars() {
- fn t(a: &str, b: &str, start: uint) {
+ fn t(a: &str, b: &str, start: usize) {
assert_eq!(a.slice_chars(start, start + b.chars().count()), b);
}
t("", "", 0);
assert_eq!("bc", unsafe {"abc".slice_unchecked(1, 3)});
assert_eq!("", unsafe {"abc".slice_unchecked(1, 1)});
fn a_million_letter_a() -> String {
- let mut i = 0u;
+ let mut i = 0;
let mut rs = String::new();
while i < 100000 {
rs.push_str("aaaaaaaaaa");
rs
}
fn half_a_million_letter_a() -> String {
- let mut i = 0u;
+ let mut i = 0;
let mut rs = String::new();
while i < 100000 {
rs.push_str("aaaaa");
let letters = a_million_letter_a();
assert!(half_a_million_letter_a() ==
unsafe {String::from_str(letters.slice_unchecked(
- 0u,
+ 0,
500000))});
}
assert_eq!("华", data.slice(30, 33));
fn a_million_letter_x() -> String {
- let mut i = 0u;
+ let mut i = 0;
let mut rs = String::new();
while i < 100000 {
rs.push_str("华华华华华华华华华华");
rs
}
fn half_a_million_letter_x() -> String {
- let mut i = 0u;
+ let mut i = 0;
let mut rs = String::new();
while i < 100000 {
rs.push_str("华华华华华");
}
let letters = a_million_letter_x();
assert!(half_a_million_letter_x() ==
- String::from_str(letters.slice(0u, 3u * 500000u)));
+ String::from_str(letters.slice(0, 3 * 500000)));
}
#[test]
fn test_slice_2() {
let ss = "中华Việt Nam";
- assert_eq!("华", ss.slice(3u, 6u));
- assert_eq!("Việt Nam", ss.slice(6u, 16u));
+ assert_eq!("华", ss.slice(3, 6));
+ assert_eq!("Việt Nam", ss.slice(6, 16));
- assert_eq!("ab", "abc".slice(0u, 2u));
- assert_eq!("bc", "abc".slice(1u, 3u));
- assert_eq!("", "abc".slice(1u, 1u));
+ assert_eq!("ab", "abc".slice(0, 2));
+ assert_eq!("bc", "abc".slice(1, 3));
+ assert_eq!("", "abc".slice(1, 1));
- assert_eq!("中", ss.slice(0u, 3u));
- assert_eq!("华V", ss.slice(3u, 7u));
- assert_eq!("", ss.slice(3u, 3u));
+ assert_eq!("中", ss.slice(0, 3));
+ assert_eq!("华V", ss.slice(3, 7));
+ assert_eq!("", ss.slice(3, 3));
/*0: 中
3: 华
6: V
#[test]
#[should_fail]
fn test_slice_fail() {
- "中华Việt Nam".slice(0u, 2u);
+ "中华Việt Nam".slice(0, 2);
}
#[test]
let v: Vec<u8> = s1.as_bytes().to_vec();
let s2: String = String::from_str(from_utf8(&v).unwrap());
- let mut i: uint = 0u;
- let n1: uint = s1.len();
- let n2: uint = v.len();
+ let mut i = 0;
+ let n1 = s1.len();
+ let n2 = v.len();
assert_eq!(n1, n2);
while i < n1 {
let a: u8 = s1.as_bytes()[i];
debug!("{}", a);
debug!("{}", b);
assert_eq!(a, b);
- i += 1u;
+ i += 1;
}
}
let v = ['ศ','ไ','ท','ย','中','华','V','i','ệ','t',' ','N','a','m'];
let mut pos = 0;
- let mut it = s.chars();
+ let it = s.chars();
for c in it {
assert_eq!(c, v[pos]);
let v = ['m', 'a', 'N', ' ', 't', 'ệ','i','V','华','中','ย','ท','ไ','ศ'];
let mut pos = 0;
- let mut it = s.chars().rev();
+ let it = s.chars().rev();
for c in it {
assert_eq!(c, v[pos]);
let v = ['ศ','ไ','ท','ย','中','华','V','i','ệ','t',' ','N','a','m'];
let mut pos = 0;
- let mut it = s.char_indices();
+ let it = s.char_indices();
for c in it {
assert_eq!(c, (p[pos], v[pos]));
let v = ['m', 'a', 'N', ' ', 't', 'ệ','i','V','华','中','ย','ท','ไ','ศ'];
let mut pos = 0;
- let mut it = s.char_indices().rev();
+ let it = s.char_indices().rev();
for c in it {
assert_eq!(c, (p[pos], v[pos]));
// test the indices iterators
let s = "a̐éö̲\r\n";
- let gr_inds = s.grapheme_indices(true).collect::<Vec<(uint, &str)>>();
- let b: &[_] = &[(0u, "a̐"), (3, "é"), (6, "ö̲"), (11, "\r\n")];
+ let gr_inds = s.grapheme_indices(true).collect::<Vec<(usize, &str)>>();
+ let b: &[_] = &[(0, "a̐"), (3, "é"), (6, "ö̲"), (11, "\r\n")];
assert_eq!(gr_inds, b);
- let gr_inds = s.grapheme_indices(true).rev().collect::<Vec<(uint, &str)>>();
- let b: &[_] = &[(11, "\r\n"), (6, "ö̲"), (3, "é"), (0u, "a̐")];
+ let gr_inds = s.grapheme_indices(true).rev().collect::<Vec<(usize, &str)>>();
+ let b: &[_] = &[(11, "\r\n"), (6, "ö̲"), (3, "é"), (0, "a̐")];
assert_eq!(gr_inds, b);
let mut gr_inds_iter = s.grapheme_indices(true);
{
#[test]
fn test_str_container() {
- fn sum_len(v: &[&str]) -> uint {
+ fn sum_len(v: &[&str]) -> usize {
v.iter().map(|x| x.len()).sum()
}
/// A possible error value from the `String::from_utf16` function.
#[stable(feature = "rust1", since = "1.0.0")]
-#[allow(missing_copy_implementations)]
#[derive(Debug)]
pub struct FromUtf16Error(());
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn with_capacity(capacity: uint) -> String {
+ pub fn with_capacity(capacity: usize) -> String {
String {
vec: Vec::with_capacity(capacity),
}
static TAG_CONT_U8: u8 = 128u8;
static REPLACEMENT: &'static [u8] = b"\xEF\xBF\xBD"; // U+FFFD in UTF-8
let total = v.len();
- fn unsafe_get(xs: &[u8], i: uint) -> u8 {
+ fn unsafe_get(xs: &[u8], i: usize) -> u8 {
unsafe { *xs.get_unchecked(i) }
}
- fn safe_get(xs: &[u8], i: uint, total: uint) -> u8 {
+ fn safe_get(xs: &[u8], i: usize, total: usize) -> u8 {
if i >= total {
0
} else {
/// * We assume that the `Vec` contains valid UTF-8.
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub unsafe fn from_raw_parts(buf: *mut u8, length: uint, capacity: uint) -> String {
+ pub unsafe fn from_raw_parts(buf: *mut u8, length: usize, capacity: usize) -> String {
String {
vec: Vec::from_raw_parts(buf, length, capacity),
}
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn capacity(&self) -> uint {
+ pub fn capacity(&self) -> usize {
self.vec.capacity()
}
///
/// # Panics
///
- /// Panics if the new capacity overflows `uint`.
+ /// Panics if the new capacity overflows `usize`.
///
/// # Examples
///
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn reserve(&mut self, additional: uint) {
+ pub fn reserve(&mut self, additional: usize) {
self.vec.reserve(additional)
}
///
/// # Panics
///
- /// Panics if the new capacity overflows `uint`.
+ /// Panics if the new capacity overflows `usize`.
///
/// # Examples
///
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn reserve_exact(&mut self, additional: uint) {
+ pub fn reserve_exact(&mut self, additional: usize) {
self.vec.reserve_exact(additional)
}
// Attempt to not use an intermediate buffer by just pushing bytes
// directly onto this string.
let slice = RawSlice {
- data: self.vec.as_ptr().offset(cur_len as int),
+ data: self.vec.as_ptr().offset(cur_len as isize),
len: 4,
};
let used = ch.encode_utf8(mem::transmute(slice)).unwrap_or(0);
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn as_bytes<'a>(&'a self) -> &'a [u8] {
+ pub fn as_bytes(&self) -> &[u8] {
&self.vec
}
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn truncate(&mut self, new_len: uint) {
+ pub fn truncate(&mut self, new_len: usize) {
assert!(self.is_char_boundary(new_len));
self.vec.truncate(new_len)
}
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn remove(&mut self, idx: uint) -> char {
+ pub fn remove(&mut self, idx: usize) -> char {
let len = self.len();
assert!(idx <= len);
let CharRange { ch, next } = self.char_range_at(idx);
unsafe {
- ptr::copy_memory(self.vec.as_mut_ptr().offset(idx as int),
- self.vec.as_ptr().offset(next as int),
+ ptr::copy_memory(self.vec.as_mut_ptr().offset(idx as isize),
+ self.vec.as_ptr().offset(next as isize),
len - next);
self.vec.set_len(len - (next - idx));
}
/// this function will panic.
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn insert(&mut self, idx: uint, ch: char) {
+ pub fn insert(&mut self, idx: usize, ch: char) {
let len = self.len();
assert!(idx <= len);
assert!(self.is_char_boundary(idx));
let amt = ch.encode_utf8(&mut bits).unwrap();
unsafe {
- ptr::copy_memory(self.vec.as_mut_ptr().offset((idx + amt) as int),
- self.vec.as_ptr().offset(idx as int),
+ ptr::copy_memory(self.vec.as_mut_ptr().offset((idx + amt) as isize),
+ self.vec.as_ptr().offset(idx as isize),
len - idx);
- ptr::copy_memory(self.vec.as_mut_ptr().offset(idx as int),
+ ptr::copy_memory(self.vec.as_mut_ptr().offset(idx as isize),
bits.as_ptr(),
amt);
self.vec.set_len(len + amt);
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub unsafe fn as_mut_vec<'a>(&'a mut self) -> &'a mut Vec<u8> {
+ pub unsafe fn as_mut_vec(&mut self) -> &mut Vec<u8> {
&mut self.vec
}
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn len(&self) -> uint { self.vec.len() }
+ pub fn len(&self) -> usize { self.vec.len() }
/// Returns true if the string contains no bytes
///
impl Str for String {
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- fn as_slice<'a>(&'a self) -> &'a str {
+ fn as_slice(&self) -> &str {
unsafe { mem::transmute(&*self.vec) }
}
}
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl ops::Index<ops::Range<uint>> for String {
+impl ops::Index<ops::Range<usize>> for String {
type Output = str;
#[inline]
- fn index(&self, index: &ops::Range<uint>) -> &str {
+ fn index(&self, index: &ops::Range<usize>) -> &str {
&self[][*index]
}
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl ops::Index<ops::RangeTo<uint>> for String {
+impl ops::Index<ops::RangeTo<usize>> for String {
type Output = str;
#[inline]
- fn index(&self, index: &ops::RangeTo<uint>) -> &str {
+ fn index(&self, index: &ops::RangeTo<usize>) -> &str {
&self[][*index]
}
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl ops::Index<ops::RangeFrom<uint>> for String {
+impl ops::Index<ops::RangeFrom<usize>> for String {
type Output = str;
#[inline]
- fn index(&self, index: &ops::RangeFrom<uint>) -> &str {
+ fn index(&self, index: &ops::RangeFrom<usize>) -> &str {
&self[][*index]
}
}
type Target = str;
#[inline]
- fn deref<'a>(&'a self) -> &'a str {
+ fn deref(&self) -> &str {
unsafe { mem::transmute(&self.vec[]) }
}
}
fn test_simple_types() {
assert_eq!(1.to_string(), "1");
assert_eq!((-1).to_string(), "-1");
- assert_eq!(200u.to_string(), "200");
+ assert_eq!(200.to_string(), "200");
assert_eq!(2u8.to_string(), "2");
assert_eq!(true.to_string(), "true");
assert_eq!(false.to_string(), "false");
#[test]
fn test_vectors() {
- let x: Vec<int> = vec![];
+ let x: Vec<i32> = vec![];
assert_eq!(format!("{:?}", x), "[]");
assert_eq!(format!("{:?}", vec![1]), "[1]");
assert_eq!(format!("{:?}", vec![1, 2, 3]), "[1, 2, 3]");
use core::ptr;
use core::raw::Slice as RawSlice;
use core::slice;
-use core::uint;
+use core::usize;
/// A growable list type, written `Vec<T>` but pronounced 'vector.'
///
#[stable(feature = "rust1", since = "1.0.0")]
pub struct Vec<T> {
ptr: NonZero<*mut T>,
- len: uint,
- cap: uint,
+ len: usize,
+ cap: usize,
}
unsafe impl<T: Send> Send for Vec<T> { }
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn with_capacity(capacity: uint) -> Vec<T> {
+ pub fn with_capacity(capacity: usize) -> Vec<T> {
if mem::size_of::<T>() == 0 {
- Vec { ptr: unsafe { NonZero::new(EMPTY as *mut T) }, len: 0, cap: uint::MAX }
+ Vec { ptr: unsafe { NonZero::new(EMPTY as *mut T) }, len: 0, cap: usize::MAX }
} else if capacity == 0 {
Vec::new()
} else {
/// mem::forget(v);
///
/// // Overwrite memory with 4, 5, 6
- /// for i in 0..len as int {
+ /// for i in 0..len as isize {
/// ptr::write(p.offset(i), 4 + i);
/// }
///
/// }
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub unsafe fn from_raw_parts(ptr: *mut T, length: uint,
- capacity: uint) -> Vec<T> {
+ pub unsafe fn from_raw_parts(ptr: *mut T, length: usize,
+ capacity: usize) -> Vec<T> {
Vec { ptr: NonZero::new(ptr), len: length, cap: capacity }
}
#[inline]
#[unstable(feature = "collections",
reason = "may be better expressed via composition")]
- pub unsafe fn from_raw_buf(ptr: *const T, elts: uint) -> Vec<T> {
+ pub unsafe fn from_raw_buf(ptr: *const T, elts: usize) -> Vec<T> {
let mut dst = Vec::with_capacity(elts);
dst.set_len(elts);
ptr::copy_nonoverlapping_memory(dst.as_mut_ptr(), ptr, elts);
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn capacity(&self) -> uint {
+ pub fn capacity(&self) -> usize {
self.cap
}
///
/// # Panics
///
- /// Panics if the new capacity overflows `uint`.
+ /// Panics if the new capacity overflows `usize`.
///
/// # Examples
///
/// assert!(vec.capacity() >= 11);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn reserve(&mut self, additional: uint) {
+ pub fn reserve(&mut self, additional: usize) {
if self.cap - self.len < additional {
- let err_msg = "Vec::reserve: `uint` overflow";
+ let err_msg = "Vec::reserve: `usize` overflow";
let new_cap = self.len.checked_add(additional).expect(err_msg)
.checked_next_power_of_two().expect(err_msg);
self.grow_capacity(new_cap);
///
/// # Panics
///
- /// Panics if the new capacity overflows `uint`.
+ /// Panics if the new capacity overflows `usize`.
///
/// # Examples
///
/// assert!(vec.capacity() >= 11);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn reserve_exact(&mut self, additional: uint) {
+ pub fn reserve_exact(&mut self, additional: usize) {
if self.cap - self.len < additional {
match self.len.checked_add(additional) {
- None => panic!("Vec::reserve: `uint` overflow"),
+ None => panic!("Vec::reserve: `usize` overflow"),
Some(new_cap) => self.grow_capacity(new_cap)
}
}
/// assert_eq!(vec, vec![1, 2]);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn truncate(&mut self, len: uint) {
+ pub fn truncate(&mut self, len: usize) {
unsafe {
// drop any extra elements
while len < self.len {
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn as_mut_slice<'a>(&'a mut self) -> &'a mut [T] {
+ pub fn as_mut_slice(&mut self) -> &mut [T] {
unsafe {
mem::transmute(RawSlice {
data: *self.ptr,
let cap = self.cap;
let begin = ptr as *const T;
let end = if mem::size_of::<T>() == 0 {
- (ptr as uint + self.len()) as *const T
+ (ptr as usize + self.len()) as *const T
} else {
- ptr.offset(self.len() as int) as *const T
+ ptr.offset(self.len() as isize) as *const T
};
mem::forget(self);
IntoIter { allocation: ptr, cap: cap, ptr: begin, end: end }
/// # Examples
///
/// ```
- /// let mut v = vec![1u, 2, 3, 4];
+ /// let mut v = vec![1, 2, 3, 4];
/// unsafe {
/// v.set_len(1);
/// }
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub unsafe fn set_len(&mut self, len: uint) {
+ pub unsafe fn set_len(&mut self, len: usize) {
self.len = len;
}
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn swap_remove(&mut self, index: uint) -> T {
+ pub fn swap_remove(&mut self, index: usize) -> T {
let length = self.len();
self.swap(index, length - 1);
self.pop().unwrap()
/// assert_eq!(vec, vec![1, 4, 2, 3, 5]);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn insert(&mut self, index: uint, element: T) {
+ pub fn insert(&mut self, index: usize, element: T) {
let len = self.len();
assert!(index <= len);
// space for the new element
unsafe { // infallible
// The spot to put the new value
{
- let p = self.as_mut_ptr().offset(index as int);
+ let p = self.as_mut_ptr().offset(index as isize);
// Shift everything over to make space. (Duplicating the
// `index`th element into two consecutive places.)
ptr::copy_memory(p.offset(1), &*p, len - index);
/// assert_eq!(v, vec![1, 3]);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn remove(&mut self, index: uint) -> T {
+ pub fn remove(&mut self, index: usize) -> T {
let len = self.len();
assert!(index < len);
unsafe { // infallible
let ret;
{
// the place we are taking from.
- let ptr = self.as_mut_ptr().offset(index as int);
+ let ptr = self.as_mut_ptr().offset(index as isize);
// copy it out, unsafely having a copy of the value on
// the stack and in the vector at the same time.
ret = ptr::read(ptr);
#[stable(feature = "rust1", since = "1.0.0")]
pub fn retain<F>(&mut self, mut f: F) where F: FnMut(&T) -> bool {
let len = self.len();
- let mut del = 0u;
+ let mut del = 0;
{
let v = &mut **self;
- for i in 0u..len {
+ for i in 0..len {
if !f(&v[i]) {
del += 1;
} else if del > 0 {
///
/// # Panics
///
- /// Panics if the number of elements in the vector overflows a `uint`.
+ /// Panics if the number of elements in the vector overflows a `usize`.
///
/// # Examples
///
}
unsafe {
- let end = (*self.ptr).offset(self.len as int);
+ let end = (*self.ptr).offset(self.len as isize);
ptr::write(&mut *end, value);
self.len += 1;
}
///
/// # Panics
///
- /// Panics if the number of elements in the vector overflows a `uint`.
+ /// Panics if the number of elements in the vector overflows a `usize`.
///
/// # Examples
- /// ```rust
+ ///
+ /// ```
/// let mut vec = vec![1, 2, 3];
/// let mut vec2 = vec![4, 5, 6];
/// vec.append(&mut vec2);
#[inline]
#[unstable(feature = "collections",
reason = "matches collection reform specification, waiting for dust to settle")]
- pub fn drain<'a>(&'a mut self) -> Drain<'a, T> {
+ pub fn drain(&mut self) -> Drain<T> {
unsafe {
let begin = *self.ptr as *const T;
let end = if mem::size_of::<T>() == 0 {
- (*self.ptr as uint + self.len()) as *const T
+ (*self.ptr as usize + self.len()) as *const T
} else {
- (*self.ptr).offset(self.len() as int) as *const T
+ (*self.ptr).offset(self.len() as isize) as *const T
};
self.set_len(0);
Drain {
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn len(&self) -> uint { self.len }
+ pub fn len(&self) -> usize { self.len }
/// Returns `true` if the vector contains no elements.
///
/// # Examples
///
/// ```
- /// let v = vec![0u, 1, 2];
+ /// let v = vec![0, 1, 2];
/// let w = v.map_in_place(|i| i + 3);
/// assert_eq!(w.as_slice(), [3, 4, 5].as_slice());
///
// types are passed to the allocator by `Vec`.
assert!(mem::min_align_of::<T>() == mem::min_align_of::<U>());
- // This `as int` cast is safe, because the size of the elements of the
+ // This `as isize` cast is safe, because the size of the elements of the
// vector is not 0, and:
//
// 1) If the size of the elements in the vector is 1, the `int` may
// After `array.offset(offset)`: 0x9.
// (0x1 + 0x8 = 0x1 - 0x8)
//
- // 2) If the size of the elements in the vector is >1, the `uint` ->
+ // 2) If the size of the elements in the vector is >1, the `usize` ->
// `int` conversion can't overflow.
- let offset = vec.len() as int;
+ let offset = vec.len() as isize;
let start = vec.as_mut_ptr();
let mut pv = PartialVecNonZeroSized {
let u = f(t);
// Forget the `U` and increment `num_u`. This increment
- // cannot overflow the `uint` as we only do this for a
- // number of times that fits into a `uint` (and start with
+ // cannot overflow the `usize` as we only do this for a
+ // number of times that fits into a `usize` (and start with
// `0`). Again, we should not panic between these steps.
mem::forget(u);
pv.num_u += 1;
///
/// Note that the capacity of `self` does not change.
///
+ /// # Panics
+ ///
+ /// Panics if `at > len`.
+ ///
/// # Examples
- /// ```rust
+ ///
+ /// ```
/// let mut vec = vec![1,2,3];
/// let vec2 = vec.split_off(1);
/// assert_eq!(vec, vec![1]);
#[unstable(feature = "collections",
reason = "new API, waiting for dust to settle")]
pub fn split_off(&mut self, at: usize) -> Self {
- assert!(at < self.len(), "`at` out of bounds");
+ assert!(at <= self.len(), "`at` out of bounds");
let other_len = self.len - at;
let mut other = Vec::with_capacity(other_len);
/// ```
#[unstable(feature = "collections",
reason = "matches collection reform specification; waiting for dust to settle")]
- pub fn resize(&mut self, new_len: uint, value: T) {
+ pub fn resize(&mut self, new_len: usize, value: T) {
let len = self.len();
if new_len > len {
let mut w = 1;
while r < ln {
- let p_r = p.offset(r as int);
- let p_wm1 = p.offset((w - 1) as int);
+ let p_r = p.offset(r as isize);
+ let p_wm1 = p.offset((w - 1) as isize);
if *p_r != *p_wm1 {
if r != w {
let p_w = p_wm1.offset(1);
///
/// If the capacity for `self` is already equal to or greater than the
/// requested capacity, then no action is taken.
- fn grow_capacity(&mut self, capacity: uint) {
+ fn grow_capacity(&mut self, capacity: usize) {
if mem::size_of::<T>() == 0 { return }
if capacity > self.cap {
// FIXME: #13996: need a way to mark the return value as `noalias`
#[inline(never)]
-unsafe fn alloc_or_realloc<T>(ptr: *mut T, old_size: uint, size: uint) -> *mut T {
+unsafe fn alloc_or_realloc<T>(ptr: *mut T, old_size: usize, size: usize) -> *mut T {
if old_size == 0 {
allocate(size, mem::min_align_of::<T>()) as *mut T
} else {
}
#[inline]
-unsafe fn dealloc<T>(ptr: *mut T, len: uint) {
+unsafe fn dealloc<T>(ptr: *mut T, len: usize) {
if mem::size_of::<T>() != 0 {
deallocate(ptr as *mut u8,
len * mem::size_of::<T>(),
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> Index<uint> for Vec<T> {
+impl<T> Index<usize> for Vec<T> {
type Output = T;
#[inline]
- fn index<'a>(&'a self, index: &uint) -> &'a T {
+ fn index(&self, index: &usize) -> &T {
// NB built-in indexing via `&[T]`
&(**self)[*index]
}
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> IndexMut<uint> for Vec<T> {
- type Output = T;
-
+impl<T> IndexMut<usize> for Vec<T> {
#[inline]
- fn index_mut<'a>(&'a mut self, index: &uint) -> &'a mut T {
+ fn index_mut(&mut self, index: &usize) -> &mut T {
// NB built-in indexing via `&mut [T]`
&mut (**self)[*index]
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> ops::Index<ops::Range<uint>> for Vec<T> {
+impl<T> ops::Index<ops::Range<usize>> for Vec<T> {
type Output = [T];
#[inline]
- fn index(&self, index: &ops::Range<uint>) -> &[T] {
+ fn index(&self, index: &ops::Range<usize>) -> &[T] {
Index::index(&**self, index)
}
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> ops::Index<ops::RangeTo<uint>> for Vec<T> {
+impl<T> ops::Index<ops::RangeTo<usize>> for Vec<T> {
type Output = [T];
#[inline]
- fn index(&self, index: &ops::RangeTo<uint>) -> &[T] {
+ fn index(&self, index: &ops::RangeTo<usize>) -> &[T] {
Index::index(&**self, index)
}
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> ops::Index<ops::RangeFrom<uint>> for Vec<T> {
+impl<T> ops::Index<ops::RangeFrom<usize>> for Vec<T> {
type Output = [T];
#[inline]
- fn index(&self, index: &ops::RangeFrom<uint>) -> &[T] {
+ fn index(&self, index: &ops::RangeFrom<usize>) -> &[T] {
Index::index(&**self, index)
}
}
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> ops::IndexMut<ops::Range<uint>> for Vec<T> {
- type Output = [T];
+impl<T> ops::IndexMut<ops::Range<usize>> for Vec<T> {
#[inline]
- fn index_mut(&mut self, index: &ops::Range<uint>) -> &mut [T] {
+ fn index_mut(&mut self, index: &ops::Range<usize>) -> &mut [T] {
IndexMut::index_mut(&mut **self, index)
}
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> ops::IndexMut<ops::RangeTo<uint>> for Vec<T> {
- type Output = [T];
+impl<T> ops::IndexMut<ops::RangeTo<usize>> for Vec<T> {
#[inline]
- fn index_mut(&mut self, index: &ops::RangeTo<uint>) -> &mut [T] {
+ fn index_mut(&mut self, index: &ops::RangeTo<usize>) -> &mut [T] {
IndexMut::index_mut(&mut **self, index)
}
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> ops::IndexMut<ops::RangeFrom<uint>> for Vec<T> {
- type Output = [T];
+impl<T> ops::IndexMut<ops::RangeFrom<usize>> for Vec<T> {
#[inline]
- fn index_mut(&mut self, index: &ops::RangeFrom<uint>) -> &mut [T] {
+ fn index_mut(&mut self, index: &ops::RangeFrom<usize>) -> &mut [T] {
IndexMut::index_mut(&mut **self, index)
}
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<T> ops::IndexMut<ops::RangeFull> for Vec<T> {
- type Output = [T];
#[inline]
fn index_mut(&mut self, _index: &ops::RangeFull) -> &mut [T] {
self.as_mut_slice()
impl<T> ops::Deref for Vec<T> {
type Target = [T];
- fn deref<'a>(&'a self) -> &'a [T] { self.as_slice() }
+ fn deref(&self) -> &[T] { self.as_slice() }
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<T> ops::DerefMut for Vec<T> {
- fn deref_mut<'a>(&'a mut self) -> &'a mut [T] { self.as_mut_slice() }
+ fn deref_mut(&mut self) -> &mut [T] { self.as_mut_slice() }
}
#[stable(feature = "rust1", since = "1.0.0")]
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- fn as_slice<'a>(&'a self) -> &'a [T] {
+ fn as_slice(&self) -> &[T] {
unsafe {
mem::transmute(RawSlice {
data: *self.ptr,
#[stable(feature = "rust1", since = "1.0.0")]
pub struct IntoIter<T> {
allocation: *mut T, // the block of memory allocated for the vector
- cap: uint, // the capacity of the vector
+ cap: usize, // the capacity of the vector
ptr: *const T,
end: *const T
}
type Item = T;
#[inline]
- fn next<'a>(&'a mut self) -> Option<T> {
+ fn next(&mut self) -> Option<T> {
unsafe {
if self.ptr == self.end {
None
// purposefully don't use 'ptr.offset' because for
// vectors with 0-size elements this would return the
// same pointer.
- self.ptr = mem::transmute(self.ptr as uint + 1);
+ self.ptr = mem::transmute(self.ptr as usize + 1);
// Use a non-null pointer value
- Some(ptr::read(mem::transmute(1u)))
+ Some(ptr::read(EMPTY as *mut T))
} else {
let old = self.ptr;
self.ptr = self.ptr.offset(1);
}
#[inline]
- fn size_hint(&self) -> (uint, Option<uint>) {
- let diff = (self.end as uint) - (self.ptr as uint);
+ fn size_hint(&self) -> (usize, Option<usize>) {
+ let diff = (self.end as usize) - (self.ptr as usize);
let size = mem::size_of::<T>();
let exact = diff / (if size == 0 {1} else {size});
(exact, Some(exact))
#[stable(feature = "rust1", since = "1.0.0")]
impl<T> DoubleEndedIterator for IntoIter<T> {
#[inline]
- fn next_back<'a>(&'a mut self) -> Option<T> {
+ fn next_back(&mut self) -> Option<T> {
unsafe {
if self.end == self.ptr {
None
} else {
if mem::size_of::<T>() == 0 {
// See above for why 'ptr.offset' isn't used
- self.end = mem::transmute(self.end as uint - 1);
+ self.end = mem::transmute(self.end as usize - 1);
// Use a non-null pointer value
- Some(ptr::read(mem::transmute(1u)))
+ Some(ptr::read(EMPTY as *mut T))
} else {
self.end = self.end.offset(-1);
// purposefully don't use 'ptr.offset' because for
// vectors with 0-size elements this would return the
// same pointer.
- self.ptr = mem::transmute(self.ptr as uint + 1);
+ self.ptr = mem::transmute(self.ptr as usize + 1);
// Use a non-null pointer value
- Some(ptr::read(mem::transmute(1u)))
+ Some(ptr::read(EMPTY as *mut T))
} else {
let old = self.ptr;
self.ptr = self.ptr.offset(1);
}
#[inline]
- fn size_hint(&self) -> (uint, Option<uint>) {
- let diff = (self.end as uint) - (self.ptr as uint);
+ fn size_hint(&self) -> (usize, Option<usize>) {
+ let diff = (self.end as usize) - (self.ptr as usize);
let size = mem::size_of::<T>();
let exact = diff / (if size == 0 {1} else {size});
(exact, Some(exact))
} else {
if mem::size_of::<T>() == 0 {
// See above for why 'ptr.offset' isn't used
- self.end = mem::transmute(self.end as uint - 1);
+ self.end = mem::transmute(self.end as usize - 1);
// Use a non-null pointer value
- Some(ptr::read(mem::transmute(1u)))
+ Some(ptr::read(EMPTY as *mut T))
} else {
self.end = self.end.offset(-1);
/// When the destructor of this struct runs, all `num_t` `T`s and `num_u` `U`s
/// are destructed.
struct PartialVecZeroSized<T,U> {
- num_t: uint,
- num_u: uint,
+ num_t: usize,
+ num_u: usize,
marker_t: InvariantType<T>,
marker_u: InvariantType<U>,
}
use super::as_vec;
struct DropCounter<'a> {
- count: &'a mut int
+ count: &'a mut u32
}
#[unsafe_destructor]
#[test]
fn test_small_vec_struct() {
- assert!(size_of::<Vec<u8>>() == size_of::<uint>() * 3);
+ assert!(size_of::<Vec<u8>>() == size_of::<usize>() * 3);
}
#[test]
#[test]
fn test_slice_from_mut() {
- let mut values = vec![1u8,2,3,4,5];
+ let mut values = vec![1, 2, 3, 4, 5];
{
let slice = &mut values[2 ..];
assert!(slice == [3, 4, 5]);
#[test]
fn test_slice_to_mut() {
- let mut values = vec![1u8,2,3,4,5];
+ let mut values = vec![1, 2, 3, 4, 5];
{
let slice = &mut values[.. 2];
assert!(slice == [1, 2]);
#[test]
fn test_split_at_mut() {
- let mut values = vec![1u8,2,3,4,5];
+ let mut values = vec![1, 2, 3, 4, 5];
{
let (left, right) = values.split_at_mut(2);
{
}
}
- assert!(values == vec![2u8, 3, 5, 6, 7]);
+ assert!(values == vec![2, 3, 5, 6, 7]);
}
#[test]
fn test_clone() {
- let v: Vec<int> = vec!();
+ let v: Vec<i32> = vec![];
let w = vec!(1, 2, 3);
assert_eq!(v, v.clone());
#[test]
fn test_retain() {
- let mut vec = vec![1u, 2, 3, 4];
+ let mut vec = vec![1, 2, 3, 4];
vec.retain(|&x| x % 2 == 0);
- assert!(vec == vec![2u, 4]);
+ assert!(vec == vec![2, 4]);
}
#[test]
#[test]
fn test_partition() {
- assert_eq!(vec![].into_iter().partition(|x: &int| *x < 3), (vec![], vec![]));
- assert_eq!(vec![1, 2, 3].into_iter().partition(|x: &int| *x < 4), (vec![1, 2, 3], vec![]));
- assert_eq!(vec![1, 2, 3].into_iter().partition(|x: &int| *x < 2), (vec![1], vec![2, 3]));
- assert_eq!(vec![1, 2, 3].into_iter().partition(|x: &int| *x < 0), (vec![], vec![1, 2, 3]));
+ assert_eq!(vec![].into_iter().partition(|x: &i32| *x < 3), (vec![], vec![]));
+ assert_eq!(vec![1, 2, 3].into_iter().partition(|x| *x < 4), (vec![1, 2, 3], vec![]));
+ assert_eq!(vec![1, 2, 3].into_iter().partition(|x| *x < 2), (vec![1], vec![2, 3]));
+ assert_eq!(vec![1, 2, 3].into_iter().partition(|x| *x < 0), (vec![], vec![1, 2, 3]));
}
#[test]
// Test on-stack copy-from-buf.
let a = [1, 2, 3];
let ptr = a.as_ptr();
- let b = Vec::from_raw_buf(ptr, 3u);
+ let b = Vec::from_raw_buf(ptr, 3);
assert_eq!(b, vec![1, 2, 3]);
// Test on-heap copy-from-buf.
let c = vec![1, 2, 3, 4, 5];
let ptr = c.as_ptr();
- let d = Vec::from_raw_buf(ptr, 5u);
+ let d = Vec::from_raw_buf(ptr, 5);
assert_eq!(d, vec![1, 2, 3, 4, 5]);
}
}
#[test]
fn test_vec_truncate_drop() {
- static mut drops: uint = 0;
- struct Elem(int);
+ static mut drops: u32 = 0;
+ struct Elem(i32);
impl Drop for Elem {
fn drop(&mut self) {
unsafe { drops += 1; }
#[test]
#[should_fail]
fn test_vec_truncate_fail() {
- struct BadElem(int);
+ struct BadElem(i32);
impl Drop for BadElem {
fn drop(&mut self) {
let BadElem(ref mut x) = *self;
#[test]
fn test_index() {
- let vec = vec!(1, 2, 3);
+ let vec = vec![1, 2, 3];
assert!(vec[1] == 2);
}
#[test]
#[should_fail]
fn test_index_out_of_bounds() {
- let vec = vec!(1, 2, 3);
+ let vec = vec![1, 2, 3];
let _ = vec[3];
}
#[test]
#[should_fail]
fn test_slice_out_of_bounds_1() {
- let x: Vec<int> = vec![1, 2, 3, 4, 5];
+ let x = vec![1, 2, 3, 4, 5];
&x[-1..];
}
#[test]
#[should_fail]
fn test_slice_out_of_bounds_2() {
- let x: Vec<int> = vec![1, 2, 3, 4, 5];
+ let x = vec![1, 2, 3, 4, 5];
&x[..6];
}
#[test]
#[should_fail]
fn test_slice_out_of_bounds_3() {
- let x: Vec<int> = vec![1, 2, 3, 4, 5];
+ let x = vec![1, 2, 3, 4, 5];
&x[-1..4];
}
#[test]
#[should_fail]
fn test_slice_out_of_bounds_4() {
- let x: Vec<int> = vec![1, 2, 3, 4, 5];
+ let x = vec![1, 2, 3, 4, 5];
&x[1..6];
}
#[test]
#[should_fail]
fn test_slice_out_of_bounds_5() {
- let x: Vec<int> = vec![1, 2, 3, 4, 5];
+ let x = vec![1, 2, 3, 4, 5];
&x[3..2];
}
#[test]
#[should_fail]
fn test_swap_remove_empty() {
- let mut vec: Vec<uint> = vec!();
+ let mut vec= Vec::<i32>::new();
vec.swap_remove(0);
}
#[test]
fn test_move_iter_unwrap() {
- let mut vec: Vec<uint> = Vec::with_capacity(7);
+ let mut vec = Vec::with_capacity(7);
vec.push(1);
vec.push(2);
let ptr = vec.as_ptr();
#[test]
#[should_fail]
fn test_map_in_place_incompatible_types_fail() {
- let v = vec![0u, 1, 2];
+ let v = vec![0, 1, 2];
v.map_in_place(|_| ());
}
#[test]
fn test_map_in_place() {
- let v = vec![0u, 1, 2];
- assert_eq!(v.map_in_place(|i: uint| i as int - 1), [-1, 0, 1]);
+ let v = vec![0, 1, 2];
+ assert_eq!(v.map_in_place(|i: u32| i as i32 - 1), [-1, 0, 1]);
}
#[test]
DROP_COUNTER.fetch_add(1, Ordering::Relaxed);
}
}
- const NUM_ELEMENTS: uint = 2;
+ const NUM_ELEMENTS: usize = 2;
static DROP_COUNTER: AtomicUsize = ATOMIC_USIZE_INIT;
let v = repeat(Nothing).take(NUM_ELEMENTS).collect::<Vec<_>>();
#[test]
fn test_move_items() {
let vec = vec![1, 2, 3];
- let mut vec2 : Vec<i32> = vec![];
+ let mut vec2 = vec![];
for i in vec {
vec2.push(i);
}
#[test]
fn test_move_items_reverse() {
let vec = vec![1, 2, 3];
- let mut vec2 : Vec<i32> = vec![];
+ let mut vec2 = vec![];
for i in vec.into_iter().rev() {
vec2.push(i);
}
#[test]
fn test_move_items_zero_sized() {
let vec = vec![(), (), ()];
- let mut vec2 : Vec<()> = vec![];
+ let mut vec2 = vec![];
for i in vec {
vec2.push(i);
}
#[test]
fn test_drain_items() {
let mut vec = vec![1, 2, 3];
- let mut vec2: Vec<i32> = vec![];
+ let mut vec2 = vec![];
for i in vec.drain() {
vec2.push(i);
}
#[test]
fn test_drain_items_reverse() {
let mut vec = vec![1, 2, 3];
- let mut vec2: Vec<i32> = vec![];
+ let mut vec2 = vec![];
for i in vec.drain().rev() {
vec2.push(i);
}
assert_eq!(vec, []);
- assert_eq!(vec2, [ 3, 2, 1 ]);
+ assert_eq!(vec2, [3, 2, 1]);
}
#[test]
fn test_drain_items_zero_sized() {
let mut vec = vec![(), (), ()];
- let mut vec2: Vec<()> = vec![];
+ let mut vec2 = vec![];
for i in vec.drain() {
vec2.push(i);
}
#[test]
fn test_into_boxed_slice() {
- let xs = vec![1u, 2, 3];
+ let xs = vec![1, 2, 3];
let ys = xs.into_boxed_slice();
- assert_eq!(ys, [1u, 2, 3]);
+ assert_eq!(ys, [1, 2, 3]);
}
#[test]
#[bench]
fn bench_new(b: &mut Bencher) {
b.iter(|| {
- let v: Vec<uint> = Vec::new();
+ let v: Vec<u32> = Vec::new();
assert_eq!(v.len(), 0);
assert_eq!(v.capacity(), 0);
})
}
- fn do_bench_with_capacity(b: &mut Bencher, src_len: uint) {
+ fn do_bench_with_capacity(b: &mut Bencher, src_len: usize) {
b.bytes = src_len as u64;
b.iter(|| {
- let v: Vec<uint> = Vec::with_capacity(src_len);
+ let v: Vec<u32> = Vec::with_capacity(src_len);
assert_eq!(v.len(), 0);
assert_eq!(v.capacity(), src_len);
})
do_bench_with_capacity(b, 1000)
}
- fn do_bench_from_fn(b: &mut Bencher, src_len: uint) {
+ fn do_bench_from_fn(b: &mut Bencher, src_len: usize) {
b.bytes = src_len as u64;
b.iter(|| {
do_bench_from_fn(b, 1000)
}
- fn do_bench_from_elem(b: &mut Bencher, src_len: uint) {
+ fn do_bench_from_elem(b: &mut Bencher, src_len: usize) {
b.bytes = src_len as u64;
b.iter(|| {
- let dst: Vec<uint> = repeat(5).take(src_len).collect();
+ let dst: Vec<usize> = repeat(5).take(src_len).collect();
assert_eq!(dst.len(), src_len);
assert!(dst.iter().all(|x| *x == 5));
})
do_bench_from_elem(b, 1000)
}
- fn do_bench_from_slice(b: &mut Bencher, src_len: uint) {
- let src: Vec<uint> = FromIterator::from_iter(0..src_len);
+ fn do_bench_from_slice(b: &mut Bencher, src_len: usize) {
+ let src: Vec<_> = FromIterator::from_iter(0..src_len);
b.bytes = src_len as u64;
do_bench_from_slice(b, 1000)
}
- fn do_bench_from_iter(b: &mut Bencher, src_len: uint) {
- let src: Vec<uint> = FromIterator::from_iter(0..src_len);
+ fn do_bench_from_iter(b: &mut Bencher, src_len: usize) {
+ let src: Vec<_> = FromIterator::from_iter(0..src_len);
b.bytes = src_len as u64;
b.iter(|| {
- let dst: Vec<uint> = FromIterator::from_iter(src.clone().into_iter());
+ let dst: Vec<_> = FromIterator::from_iter(src.clone().into_iter());
assert_eq!(dst.len(), src_len);
assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
});
do_bench_from_iter(b, 1000)
}
- fn do_bench_extend(b: &mut Bencher, dst_len: uint, src_len: uint) {
- let dst: Vec<uint> = FromIterator::from_iter(0..dst_len);
- let src: Vec<uint> = FromIterator::from_iter(dst_len..dst_len + src_len);
+ fn do_bench_extend(b: &mut Bencher, dst_len: usize, src_len: usize) {
+ let dst: Vec<_> = FromIterator::from_iter(0..dst_len);
+ let src: Vec<_> = FromIterator::from_iter(dst_len..dst_len + src_len);
b.bytes = src_len as u64;
do_bench_extend(b, 1000, 1000)
}
- fn do_bench_push_all(b: &mut Bencher, dst_len: uint, src_len: uint) {
- let dst: Vec<uint> = FromIterator::from_iter(0..dst_len);
- let src: Vec<uint> = FromIterator::from_iter(dst_len..dst_len + src_len);
+ fn do_bench_push_all(b: &mut Bencher, dst_len: usize, src_len: usize) {
+ let dst: Vec<_> = FromIterator::from_iter(0..dst_len);
+ let src: Vec<_> = FromIterator::from_iter(dst_len..dst_len + src_len);
b.bytes = src_len as u64;
do_bench_push_all(b, 1000, 1000)
}
- fn do_bench_push_all_move(b: &mut Bencher, dst_len: uint, src_len: uint) {
- let dst: Vec<uint> = FromIterator::from_iter(0u..dst_len);
- let src: Vec<uint> = FromIterator::from_iter(dst_len..dst_len + src_len);
+ fn do_bench_push_all_move(b: &mut Bencher, dst_len: usize, src_len: usize) {
+ let dst: Vec<_> = FromIterator::from_iter(0..dst_len);
+ let src: Vec<_> = FromIterator::from_iter(dst_len..dst_len + src_len);
b.bytes = src_len as u64;
do_bench_push_all_move(b, 1000, 1000)
}
- fn do_bench_clone(b: &mut Bencher, src_len: uint) {
- let src: Vec<uint> = FromIterator::from_iter(0..src_len);
+ fn do_bench_clone(b: &mut Bencher, src_len: usize) {
+ let src: Vec<usize> = FromIterator::from_iter(0..src_len);
b.bytes = src_len as u64;
do_bench_clone(b, 1000)
}
- fn do_bench_clone_from(b: &mut Bencher, times: uint, dst_len: uint, src_len: uint) {
- let dst: Vec<uint> = FromIterator::from_iter(0..src_len);
- let src: Vec<uint> = FromIterator::from_iter(dst_len..dst_len + src_len);
+ fn do_bench_clone_from(b: &mut Bencher, times: usize, dst_len: usize, src_len: usize) {
+ let dst: Vec<_> = FromIterator::from_iter(0..src_len);
+ let src: Vec<_> = FromIterator::from_iter(dst_len..dst_len + src_len);
b.bytes = (times * src_len) as u64;
#![allow(missing_docs)]
-pub use self::Entry::*;
+use self::Entry::*;
use core::prelude::*;
use {vec, slice};
use vec::Vec;
-// FIXME(conventions): capacity management???
-
/// A map optimized for small integer keys.
///
/// # Examples
fn hash(&self, state: &mut S) {
// In order to not traverse the `VecMap` twice, count the elements
// during iteration.
- let mut count: uint = 0;
+ let mut count: usize = 0;
for elt in self {
elt.hash(state);
count += 1;
/// let mut map: VecMap<&str> = VecMap::with_capacity(10);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn with_capacity(capacity: uint) -> VecMap<V> {
+ pub fn with_capacity(capacity: usize) -> VecMap<V> {
VecMap { v: Vec::with_capacity(capacity) }
}
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn capacity(&self) -> uint {
+ pub fn capacity(&self) -> usize {
self.v.capacity()
}
/// assert!(map.capacity() >= 10);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn reserve_len(&mut self, len: uint) {
+ pub fn reserve_len(&mut self, len: usize) {
let cur_len = self.v.len();
if len >= cur_len {
self.v.reserve(len - cur_len);
/// assert!(map.capacity() >= 10);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn reserve_len_exact(&mut self, len: uint) {
+ pub fn reserve_len_exact(&mut self, len: usize) {
let cur_len = self.v.len();
if len >= cur_len {
self.v.reserve_exact(len - cur_len);
}
/// Returns an iterator visiting all keys in ascending order of the keys.
- /// The iterator's element type is `uint`.
+ /// The iterator's element type is `usize`.
#[stable(feature = "rust1", since = "1.0.0")]
pub fn keys<'r>(&'r self) -> Keys<'r, V> {
fn first<A, B>((a, _): (A, B)) -> A { a }
- let first: fn((uint, &'r V)) -> uint = first; // coerce to fn pointer
+ let first: fn((usize, &'r V)) -> usize = first; // coerce to fn pointer
Keys { iter: self.iter().map(first) }
}
#[stable(feature = "rust1", since = "1.0.0")]
pub fn values<'r>(&'r self) -> Values<'r, V> {
fn second<A, B>((_, b): (A, B)) -> B { b }
- let second: fn((uint, &'r V)) -> &'r V = second; // coerce to fn pointer
+ let second: fn((usize, &'r V)) -> &'r V = second; // coerce to fn pointer
Values { iter: self.iter().map(second) }
}
/// Returns an iterator visiting all key-value pairs in ascending order of the keys.
- /// The iterator's element type is `(uint, &'r V)`.
+ /// The iterator's element type is `(usize, &'r V)`.
///
/// # Examples
///
/// Returns an iterator visiting all key-value pairs in ascending order of the keys,
/// with mutable references to the values.
- /// The iterator's element type is `(uint, &'r mut V)`.
+ /// The iterator's element type is `(usize, &'r mut V)`.
///
/// # Examples
///
/// Returns an iterator visiting all key-value pairs in ascending order of
/// the keys, consuming the original `VecMap`.
- /// The iterator's element type is `(uint, &'r V)`.
+ /// The iterator's element type is `(usize, &'r V)`.
///
/// # Examples
///
/// map.insert(3, "c");
/// map.insert(2, "b");
///
- /// let vec: Vec<(uint, &str)> = map.into_iter().collect();
+ /// let vec: Vec<(usize, &str)> = map.into_iter().collect();
///
/// assert_eq!(vec, vec![(1, "a"), (2, "b"), (3, "c")]);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
pub fn into_iter(self) -> IntoIter<V> {
- fn filter<A>((i, v): (uint, Option<A>)) -> Option<(uint, A)> {
+ fn filter<A>((i, v): (usize, Option<A>)) -> Option<(usize, A)> {
v.map(|v| (i, v))
}
- let filter: fn((uint, Option<V>)) -> Option<(uint, V)> = filter; // coerce to fn ptr
+ let filter: fn((usize, Option<V>)) -> Option<(usize, V)> = filter; // coerce to fn ptr
IntoIter { iter: self.v.into_iter().enumerate().filter_map(filter) }
}
/// Returns an iterator visiting all key-value pairs in ascending order of
/// the keys, emptying (but not consuming) the original `VecMap`.
- /// The iterator's element type is `(uint, &'r V)`. Keeps the allocated memory for reuse.
+ /// The iterator's element type is `(usize, &'r V)`. Keeps the allocated memory for reuse.
///
/// # Examples
///
/// map.insert(3, "c");
/// map.insert(2, "b");
///
- /// let vec: Vec<(uint, &str)> = map.drain().collect();
+ /// let vec: Vec<(usize, &str)> = map.drain().collect();
///
/// assert_eq!(vec, vec![(1, "a"), (2, "b"), (3, "c")]);
/// ```
#[unstable(feature = "collections",
reason = "matches collection reform specification, waiting for dust to settle")]
pub fn drain<'a>(&'a mut self) -> Drain<'a, V> {
- fn filter<A>((i, v): (uint, Option<A>)) -> Option<(uint, A)> {
+ fn filter<A>((i, v): (usize, Option<A>)) -> Option<(usize, A)> {
v.map(|v| (i, v))
}
- let filter: fn((uint, Option<V>)) -> Option<(uint, V)> = filter; // coerce to fn ptr
+ let filter: fn((usize, Option<V>)) -> Option<(usize, V)> = filter; // coerce to fn ptr
Drain { iter: self.v.drain().enumerate().filter_map(filter) }
}
/// assert_eq!(a.len(), 1);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn len(&self) -> uint {
+ pub fn len(&self) -> usize {
self.v.iter().filter(|elt| elt.is_some()).count()
}
/// assert_eq!(map.get(&2), None);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn get(&self, key: &uint) -> Option<&V> {
+ pub fn get(&self, key: &usize) -> Option<&V> {
if *key < self.v.len() {
match self.v[*key] {
Some(ref value) => Some(value),
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn contains_key(&self, key: &uint) -> bool {
+ pub fn contains_key(&self, key: &usize) -> bool {
self.get(key).is_some()
}
/// assert_eq!(map[1], "b");
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn get_mut(&mut self, key: &uint) -> Option<&mut V> {
+ pub fn get_mut(&mut self, key: &usize) -> Option<&mut V> {
if *key < self.v.len() {
match *(&mut self.v[*key]) {
Some(ref mut value) => Some(value),
/// assert_eq!(map[37], "c");
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn insert(&mut self, key: uint, value: V) -> Option<V> {
+ pub fn insert(&mut self, key: usize, value: V) -> Option<V> {
let len = self.v.len();
if len <= key {
self.v.extend((0..key - len + 1).map(|_| None));
/// assert_eq!(map.remove(&1), None);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn remove(&mut self, key: &uint) -> Option<V> {
+ pub fn remove(&mut self, key: &usize) -> Option<V> {
if *key >= self.v.len() {
return None;
}
///
/// assert_eq!(count[1], 3);
/// ```
- #[unstable(feature = "collections",
- reason = "precise API still under development")]
+ #[stable(feature = "rust1", since = "1.0.0")]
pub fn entry(&mut self, key: usize) -> Entry<V> {
// FIXME(Gankro): this is basically the dumbest implementation of
// entry possible, because weird non-lexical borrows issues make it
impl<'a, V> VacantEntry<'a, V> {
/// Sets the value of the entry with the VacantEntry's key,
/// and returns a mutable reference to it.
- #[unstable(feature = "collections",
- reason = "matches collection reform v2 specification, waiting for dust to settle")]
+ #[stable(feature = "rust1", since = "1.0.0")]
pub fn insert(self, value: V) -> &'a mut V {
let index = self.index;
self.map.insert(index, value);
impl<'a, V> OccupiedEntry<'a, V> {
/// Gets a reference to the value in the entry.
- #[unstable(feature = "collections",
- reason = "matches collection reform v2 specification, waiting for dust to settle")]
+ #[stable(feature = "rust1", since = "1.0.0")]
pub fn get(&self) -> &V {
let index = self.index;
&self.map[index]
}
/// Gets a mutable reference to the value in the entry.
- #[unstable(feature = "collections",
- reason = "matches collection reform v2 specification, waiting for dust to settle")]
+ #[stable(feature = "rust1", since = "1.0.0")]
pub fn get_mut(&mut self) -> &mut V {
let index = self.index;
&mut self.map[index]
}
/// Converts the entry into a mutable reference to its value.
- #[unstable(feature = "collections",
- reason = "matches collection reform v2 specification, waiting for dust to settle")]
+ #[stable(feature = "rust1", since = "1.0.0")]
pub fn into_mut(self) -> &'a mut V {
let index = self.index;
&mut self.map[index]
/// Sets the value of the entry with the OccupiedEntry's key,
/// and returns the entry's old value.
- #[unstable(feature = "collections",
- reason = "matches collection reform v2 specification, waiting for dust to settle")]
+ #[stable(feature = "rust1", since = "1.0.0")]
pub fn insert(&mut self, value: V) -> V {
let index = self.index;
self.map.insert(index, value).unwrap()
}
/// Takes the value of the entry out of the map, and returns it.
- #[unstable(feature = "collections",
- reason = "matches collection reform v2 specification, waiting for dust to settle")]
+ #[stable(feature = "rust1", since = "1.0.0")]
pub fn remove(self) -> V {
let index = self.index;
self.map.remove(&index).unwrap()
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<V> FromIterator<(uint, V)> for VecMap<V> {
- fn from_iter<Iter: Iterator<Item=(uint, V)>>(iter: Iter) -> VecMap<V> {
+impl<V> FromIterator<(usize, V)> for VecMap<V> {
+ fn from_iter<Iter: Iterator<Item=(usize, V)>>(iter: Iter) -> VecMap<V> {
let mut map = VecMap::new();
map.extend(iter);
map
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<V> Extend<(uint, V)> for VecMap<V> {
- fn extend<Iter: Iterator<Item=(uint, V)>>(&mut self, iter: Iter) {
+impl<V> Extend<(usize, V)> for VecMap<V> {
+ fn extend<Iter: Iterator<Item=(usize, V)>>(&mut self, iter: Iter) {
for (k, v) in iter {
self.insert(k, v);
}
}
}
-impl<V> Index<uint> for VecMap<V> {
+impl<V> Index<usize> for VecMap<V> {
type Output = V;
#[inline]
- fn index<'a>(&'a self, i: &uint) -> &'a V {
+ fn index<'a>(&'a self, i: &usize) -> &'a V {
self.get(i).expect("key not present")
}
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<V> IndexMut<uint> for VecMap<V> {
- type Output = V;
-
+impl<V> IndexMut<usize> for VecMap<V> {
#[inline]
- fn index_mut<'a>(&'a mut self, i: &uint) -> &'a mut V {
+ fn index_mut<'a>(&'a mut self, i: &usize) -> &'a mut V {
self.get_mut(i).expect("key not present")
}
}
}
#[inline]
- fn size_hint(&self) -> (uint, Option<uint>) {
+ fn size_hint(&self) -> (usize, Option<usize>) {
(0, Some(self.back - self.front))
}
}
/// An iterator over the key-value pairs of a map.
#[stable(feature = "rust1", since = "1.0.0")]
pub struct Iter<'a, V:'a> {
- front: uint,
- back: uint,
+ front: usize,
+ back: usize,
iter: slice::Iter<'a, Option<V>>
}
}
}
-iterator! { impl Iter -> (uint, &'a V), as_ref }
-double_ended_iterator! { impl Iter -> (uint, &'a V), as_ref }
+iterator! { impl Iter -> (usize, &'a V), as_ref }
+double_ended_iterator! { impl Iter -> (usize, &'a V), as_ref }
/// An iterator over the key-value pairs of a map, with the
/// values being mutable.
#[stable(feature = "rust1", since = "1.0.0")]
pub struct IterMut<'a, V:'a> {
- front: uint,
- back: uint,
+ front: usize,
+ back: usize,
iter: slice::IterMut<'a, Option<V>>
}
-iterator! { impl IterMut -> (uint, &'a mut V), as_mut }
-double_ended_iterator! { impl IterMut -> (uint, &'a mut V), as_mut }
+iterator! { impl IterMut -> (usize, &'a mut V), as_mut }
+double_ended_iterator! { impl IterMut -> (usize, &'a mut V), as_mut }
/// An iterator over the keys of a map.
#[stable(feature = "rust1", since = "1.0.0")]
pub struct Keys<'a, V: 'a> {
- iter: Map<Iter<'a, V>, fn((uint, &'a V)) -> uint>
+ iter: Map<Iter<'a, V>, fn((usize, &'a V)) -> usize>
}
// FIXME(#19839) Remove in favor of `#[derive(Clone)]`
/// An iterator over the values of a map.
#[stable(feature = "rust1", since = "1.0.0")]
pub struct Values<'a, V: 'a> {
- iter: Map<Iter<'a, V>, fn((uint, &'a V)) -> &'a V>
+ iter: Map<Iter<'a, V>, fn((usize, &'a V)) -> &'a V>
}
// FIXME(#19839) Remove in favor of `#[derive(Clone)]`
pub struct IntoIter<V> {
iter: FilterMap<
Enumerate<vec::IntoIter<Option<V>>>,
- fn((uint, Option<V>)) -> Option<(uint, V)>>
+ fn((usize, Option<V>)) -> Option<(usize, V)>>
}
#[unstable(feature = "collections")]
pub struct Drain<'a, V> {
iter: FilterMap<
Enumerate<vec::Drain<'a, Option<V>>>,
- fn((uint, Option<V>)) -> Option<(uint, V)>>
+ fn((usize, Option<V>)) -> Option<(usize, V)>>
}
#[unstable(feature = "collections")]
impl<'a, V> Iterator for Drain<'a, V> {
- type Item = (uint, V);
+ type Item = (usize, V);
- fn next(&mut self) -> Option<(uint, V)> { self.iter.next() }
- fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
+ fn next(&mut self) -> Option<(usize, V)> { self.iter.next() }
+ fn size_hint(&self) -> (usize, Option<usize>) { self.iter.size_hint() }
}
#[unstable(feature = "collections")]
impl<'a, V> DoubleEndedIterator for Drain<'a, V> {
- fn next_back(&mut self) -> Option<(uint, V)> { self.iter.next_back() }
+ fn next_back(&mut self) -> Option<(usize, V)> { self.iter.next_back() }
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, V> Iterator for Keys<'a, V> {
- type Item = uint;
+ type Item = usize;
- fn next(&mut self) -> Option<uint> { self.iter.next() }
- fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
+ fn next(&mut self) -> Option<usize> { self.iter.next() }
+ fn size_hint(&self) -> (usize, Option<usize>) { self.iter.size_hint() }
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, V> DoubleEndedIterator for Keys<'a, V> {
- fn next_back(&mut self) -> Option<uint> { self.iter.next_back() }
+ fn next_back(&mut self) -> Option<usize> { self.iter.next_back() }
}
#[stable(feature = "rust1", since = "1.0.0")]
type Item = &'a V;
fn next(&mut self) -> Option<(&'a V)> { 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(feature = "rust1", since = "1.0.0")]
impl<'a, V> DoubleEndedIterator for Values<'a, V> {
#[stable(feature = "rust1", since = "1.0.0")]
impl<V> Iterator for IntoIter<V> {
- type Item = (uint, V);
+ type Item = (usize, V);
- fn next(&mut self) -> Option<(uint, V)> { self.iter.next() }
- fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
+ fn next(&mut self) -> Option<(usize, V)> { self.iter.next() }
+ fn size_hint(&self) -> (usize, Option<usize>) { self.iter.size_hint() }
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<V> DoubleEndedIterator for IntoIter<V> {
- fn next_back(&mut self) -> Option<(uint, V)> { self.iter.next_back() }
+ fn next_back(&mut self) -> Option<(usize, V)> { self.iter.next_back() }
}
#[cfg(test)]
use prelude::*;
use core::hash::{hash, SipHasher};
- use super::{VecMap, Occupied, Vacant};
+ use super::VecMap;
+ use super::Entry::{Occupied, Vacant};
#[test]
fn test_get_mut() {
map.insert(1, 'a');
map.insert(2, 'b');
map.insert(3, 'c');
- let keys = map.keys().collect::<Vec<uint>>();
+ let keys: Vec<_> = map.keys().collect();
assert_eq!(keys.len(), 3);
assert!(keys.contains(&1));
assert!(keys.contains(&2));
map.insert(1, 'a');
map.insert(2, 'b');
map.insert(3, 'c');
- let values = map.values().map(|&v| v).collect::<Vec<char>>();
+ let values: Vec<_> = map.values().cloned().collect();
assert_eq!(values.len(), 3);
assert!(values.contains(&'a'));
assert!(values.contains(&'b'));
assert!(m.insert(10, 11).is_none());
for (k, v) in &mut m {
- *v += k as int;
+ *v += k as isize;
}
let mut it = m.iter();
assert!(m.insert(10, 11).is_none());
for (k, v) in m.iter_mut().rev() {
- *v += k as int;
+ *v += k as isize;
}
let mut it = m.iter();
map.insert(3, "c");
map.insert(2, "b");
- let vec: Vec<(usize, &str)> = map.drain().collect();
+ let vec: Vec<_> = map.drain().collect();
assert_eq!(vec, vec![(1, "a"), (2, "b"), (3, "c")]);
assert_eq!(map.len(), 0);
#[test]
fn test_show() {
let mut map = VecMap::new();
- let empty = VecMap::<int>::new();
+ let empty = VecMap::<i32>::new();
map.insert(1, 2);
map.insert(3, 4);
let mut b = VecMap::new();
assert!(!(a < b) && !(b < a));
- assert!(b.insert(2u, 5).is_none());
+ assert!(b.insert(2, 5).is_none());
assert!(a < b);
assert!(a.insert(2, 7).is_none());
assert!(!(a < b) && b < a);
let mut b = VecMap::new();
assert!(a <= b && a >= b);
- assert!(a.insert(1u, 1).is_none());
+ assert!(a.insert(1, 1).is_none());
assert!(a > b && a >= b);
assert!(b < a && b <= a);
assert!(b.insert(2, 2).is_none());
#[test]
fn test_from_iter() {
- let xs: Vec<(uint, char)> = vec![(1u, 'a'), (2, 'b'), (3, 'c'), (4, 'd'), (5, 'e')];
+ let xs = vec![(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd'), (5, 'e')];
- let map: VecMap<char> = xs.iter().map(|&x| x).collect();
+ let map: VecMap<_> = xs.iter().cloned().collect();
for &(k, v) in &xs {
assert_eq!(map.get(&k), Some(&v));
#[test]
fn test_index() {
- let mut map: VecMap<int> = VecMap::new();
+ let mut map = VecMap::new();
map.insert(1, 2);
map.insert(2, 1);
#[test]
#[should_fail]
fn test_index_nonexistent() {
- let mut map: VecMap<int> = VecMap::new();
+ let mut map = VecMap::new();
map.insert(1, 2);
map.insert(2, 1);
fn test_entry(){
let xs = [(1, 10), (2, 20), (3, 30), (4, 40), (5, 50), (6, 60)];
- let mut map: VecMap<i32> = xs.iter().map(|&x| x).collect();
+ let mut map: VecMap<_> = xs.iter().cloned().collect();
// Existing key (insert)
match map.entry(1) {
#[bench]
pub fn insert_rand_100(b: &mut Bencher) {
- let mut m : VecMap<uint> = VecMap::new();
+ let mut m = VecMap::new();
insert_rand_n(100, &mut m, b,
|m, i| { m.insert(i, 1); },
|m, i| { m.remove(&i); });
#[bench]
pub fn insert_rand_10_000(b: &mut Bencher) {
- let mut m : VecMap<uint> = VecMap::new();
+ let mut m = VecMap::new();
insert_rand_n(10_000, &mut m, b,
|m, i| { m.insert(i, 1); },
|m, i| { m.remove(&i); });
// Insert seq
#[bench]
pub fn insert_seq_100(b: &mut Bencher) {
- let mut m : VecMap<uint> = VecMap::new();
+ let mut m = VecMap::new();
insert_seq_n(100, &mut m, b,
|m, i| { m.insert(i, 1); },
|m, i| { m.remove(&i); });
#[bench]
pub fn insert_seq_10_000(b: &mut Bencher) {
- let mut m : VecMap<uint> = VecMap::new();
+ let mut m = VecMap::new();
insert_seq_n(10_000, &mut m, b,
|m, i| { m.insert(i, 1); },
|m, i| { m.remove(&i); });
// Find rand
#[bench]
pub fn find_rand_100(b: &mut Bencher) {
- let mut m : VecMap<uint> = VecMap::new();
+ let mut m = VecMap::new();
find_rand_n(100, &mut m, b,
|m, i| { m.insert(i, 1); },
|m, i| { m.get(&i); });
#[bench]
pub fn find_rand_10_000(b: &mut Bencher) {
- let mut m : VecMap<uint> = VecMap::new();
+ let mut m = VecMap::new();
find_rand_n(10_000, &mut m, b,
|m, i| { m.insert(i, 1); },
|m, i| { m.get(&i); });
// Find seq
#[bench]
pub fn find_seq_100(b: &mut Bencher) {
- let mut m : VecMap<uint> = VecMap::new();
+ let mut m = VecMap::new();
find_seq_n(100, &mut m, b,
|m, i| { m.insert(i, 1); },
|m, i| { m.get(&i); });
#[bench]
pub fn find_seq_10_000(b: &mut Bencher) {
- let mut m : VecMap<uint> = VecMap::new();
+ let mut m = VecMap::new();
find_seq_n(10_000, &mut m, b,
|m, i| { m.insert(i, 1); },
|m, i| { m.get(&i); });
/// strong, this implementation has not been reviewed for such purposes.
/// As such, all cryptographic uses of this implementation are strongly
/// discouraged.
-#[allow(missing_copy_implementations)]
pub struct SipHasher {
k0: u64,
k1: u64,
use ops::{Add, Deref, FnMut};
use option::Option;
use option::Option::{Some, None};
-use std::marker::Sized;
+use marker::Sized;
use usize;
/// An interface for dealing with "external iterators". These types of iterators
}
/// Creates an iterator that applies the predicate to each element returned
- /// by this iterator. The only elements that will be yieled are those that
+ /// by this iterator. The only elements that will be yielded are those that
/// make the predicate evaluate to `true`.
///
/// # Examples
html_root_url = "http://doc.rust-lang.org/nightly/",
html_playground_url = "http://play.rust-lang.org/")]
+#![feature(no_std)]
#![no_std]
#![allow(raw_pointer_derive)]
#![deny(missing_docs)]
mod core {
pub use panicking;
pub use fmt;
+ #[cfg(not(stage0))] pub use clone;
+ #[cfg(not(stage0))] pub use cmp;
+ #[cfg(not(stage0))] pub use hash;
+ #[cfg(not(stage0))] pub use marker;
+ #[cfg(not(stage0))] pub use option;
+ #[cfg(not(stage0))] pub use iter;
}
#[doc(hidden)]
mod std {
- pub use clone;
- pub use cmp;
- pub use fmt;
- pub use hash;
- pub use marker;
+ // NOTE: remove after next snapshot
+ #[cfg(stage0)] pub use clone;
+ #[cfg(stage0)] pub use cmp;
+ #[cfg(stage0)] pub use hash;
+ #[cfg(stage0)] pub use marker;
+ #[cfg(stage0)] pub use option;
+ #[cfg(stage0)] pub use fmt;
+ #[cfg(stage0)] pub use iter;
+
+ // range syntax
pub use ops;
- pub use option;
- // for-loops
- pub use iter;
}
///
/// # Example
///
-/// The Cell type is an example which uses unsafe code to achieve
-/// "interior" mutability:
+/// The Cell type is an example of an `InvariantType` which uses unsafe
+/// code to achieve "interior" mutability:
///
/// ```
/// struct Cell<T> { value: T }
/// ```
///
-/// The type system would infer that `value` is only read here and
-/// never written, but in fact `Cell` uses unsafe code to achieve
-/// interior mutability.
+/// The type system would infer that `value` is only read here
+/// and never written, but in fact `Cell` uses unsafe code to achieve
+/// interior mutability. In order to get correct behavior, the
+/// `InvariantType` marker must be applied.
#[unstable(feature = "core",
reason = "likely to change with new variance strategy")]
#[lang="invariant_type"]
reason = "likely to change with new variance strategy")]
#[lang="no_copy_bound"]
#[derive(Clone, PartialEq, Eq, PartialOrd, Ord)]
-#[allow(missing_copy_implementations)]
pub struct NoCopy;
/// A type which is considered managed by the GC. This is typically
reason = "likely to change with new variance strategy")]
#[lang="managed_bound"]
#[derive(Clone, PartialEq, Eq, PartialOrd, Ord)]
-#[allow(missing_copy_implementations)]
pub struct Managed;
#[unstable(feature = "core",
reason = "this function may be removed in the future due to its \
questionable utility")]
-pub unsafe fn copy_mut_lifetime<'a, S: ?Sized, T: ?Sized + 'a>(_ptr: &'a mut S,
- ptr: &mut T)
- -> &'a mut T {
+pub unsafe fn copy_mut_lifetime<'a, S: ?Sized, T: ?Sized + 'a>(_ptr: &'a S,
+ ptr: &mut T)
+ -> &'a mut T
+{
transmute(ptr)
}
/// }
/// ```
#[lang="index"]
-#[rustc_on_unimplemented = "the type `{Self}` cannot be indexed by `{Index}`"]
+#[rustc_on_unimplemented = "the type `{Self}` cannot be indexed by `{Idx}`"]
#[stable(feature = "rust1", since = "1.0.0")]
-pub trait Index<Index: ?Sized> {
+pub trait Index<Idx: ?Sized> {
type Output: ?Sized;
/// The method for the indexing (`Foo[Bar]`) operation
#[stable(feature = "rust1", since = "1.0.0")]
- fn index<'a>(&'a self, index: &Index) -> &'a Self::Output;
+ fn index<'a>(&'a self, index: &Idx) -> &'a Self::Output;
}
/// The `IndexMut` trait is used to specify the functionality of indexing
/// calling `index_mut`, and therefore, `main` prints `Indexing!`.
///
/// ```
-/// use std::ops::IndexMut;
+/// use std::ops::{Index, IndexMut};
///
/// #[derive(Copy)]
/// struct Foo;
/// struct Bar;
///
-/// impl IndexMut<Bar> for Foo {
+/// impl Index<Bar> for Foo {
/// type Output = Foo;
///
+/// fn index<'a>(&'a self, _index: &Bar) -> &'a Foo {
+/// self
+/// }
+/// }
+///
+/// impl IndexMut<Bar> for Foo {
/// fn index_mut<'a>(&'a mut self, _index: &Bar) -> &'a mut Foo {
/// println!("Indexing!");
/// self
/// }
/// ```
#[lang="index_mut"]
-#[rustc_on_unimplemented = "the type `{Self}` cannot be mutably indexed by `{Index}`"]
+#[rustc_on_unimplemented = "the type `{Self}` cannot be mutably indexed by `{Idx}`"]
#[stable(feature = "rust1", since = "1.0.0")]
-pub trait IndexMut<Index: ?Sized> {
- type Output: ?Sized;
-
+pub trait IndexMut<Idx: ?Sized>: Index<Idx> {
/// The method for the indexing (`Foo[Bar]`) operation
#[stable(feature = "rust1", since = "1.0.0")]
- fn index_mut<'a>(&'a mut self, index: &Index) -> &'a mut Self::Output;
+ fn index_mut<'a>(&'a mut self, index: &Idx) -> &'a mut Self::Output;
}
/// An unbounded range.
src
}
-/// Reads the value from `src` without dropping it. This leaves the
+/// Reads the value from `src` without moving it. This leaves the
/// memory in `src` unchanged.
///
/// # Safety
#[stable(feature = "rust1", since = "1.0.0")]
impl<T> ops::IndexMut<uint> for [T] {
- type Output = T;
-
fn index_mut(&mut self, &index: &uint) -> &mut T {
assert!(index < self.len());
#[stable(feature = "rust1", since = "1.0.0")]
impl<T> ops::IndexMut<ops::Range<uint>> for [T] {
- type Output = [T];
#[inline]
fn index_mut(&mut self, index: &ops::Range<uint>) -> &mut [T] {
assert!(index.start <= index.end);
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<T> ops::IndexMut<ops::RangeTo<uint>> for [T] {
- type Output = [T];
#[inline]
fn index_mut(&mut self, index: &ops::RangeTo<uint>) -> &mut [T] {
self.index_mut(&ops::Range{ start: 0, end: index.end })
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<T> ops::IndexMut<ops::RangeFrom<uint>> for [T] {
- type Output = [T];
#[inline]
fn index_mut(&mut self, index: &ops::RangeFrom<uint>) -> &mut [T] {
let len = self.len();
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<T> ops::IndexMut<RangeFull> for [T] {
- type Output = [T];
#[inline]
fn index_mut(&mut self, _index: &RangeFull) -> &mut [T] {
self
#[unstable(feature = "core")]
impl<'a, T> ops::IndexMut<ops::Range<uint>> for IterMut<'a, T> {
- type Output = [T];
#[inline]
fn index_mut(&mut self, index: &ops::Range<uint>) -> &mut [T] {
self.index_mut(&RangeFull).index_mut(index)
}
#[unstable(feature = "core")]
impl<'a, T> ops::IndexMut<ops::RangeTo<uint>> for IterMut<'a, T> {
- type Output = [T];
#[inline]
fn index_mut(&mut self, index: &ops::RangeTo<uint>) -> &mut [T] {
self.index_mut(&RangeFull).index_mut(index)
}
#[unstable(feature = "core")]
impl<'a, T> ops::IndexMut<ops::RangeFrom<uint>> for IterMut<'a, T> {
- type Output = [T];
#[inline]
fn index_mut(&mut self, index: &ops::RangeFrom<uint>) -> &mut [T] {
self.index_mut(&RangeFull).index_mut(index)
}
#[unstable(feature = "core")]
impl<'a, T> ops::IndexMut<RangeFull> for IterMut<'a, T> {
- type Output = [T];
#[inline]
fn index_mut(&mut self, _index: &RangeFull) -> &mut [T] {
make_slice!(T => &mut [T]: self.ptr, self.end)
}
}
+/// Forms a slice from a pointer and a length.
+///
+/// The `len` argument is the number of **elements**, not the number of bytes.
+///
+/// This function is unsafe as there is no guarantee that the given pointer is
+/// valid for `len` elements, nor whether the lifetime inferred is a suitable
+/// lifetime for the returned slice.
+///
+/// # Caveat
+///
+/// The lifetime for the returned slice is inferred from its usage. To
+/// prevent accidental misuse, it's suggested to tie the lifetime to whichever
+/// source lifetime is safe in the context, such as by providing a helper
+/// function taking the lifetime of a host value for the slice, or by explicit
+/// annotation.
+///
+/// # Example
+///
+/// ```rust
+/// use std::slice;
+///
+/// // manifest a slice out of thin air!
+/// let ptr = 0x1234 as *const uint;
+/// let amt = 10;
+/// unsafe {
+/// let slice = slice::from_raw_parts(ptr, amt);
+/// }
+/// ```
+#[inline]
+#[unstable(feature = "core")]
+pub unsafe fn from_raw_parts<'a, T>(p: *const T, len: uint) -> &'a [T] {
+ transmute(RawSlice { data: p, len: len })
+}
+
+/// Performs the same functionality as `from_raw_parts`, except that a mutable
+/// slice is returned.
+///
+/// This function is unsafe for the same reasons as `from_raw_parts`, as well
+/// as not being able to provide a non-aliasing guarantee of the returned
+/// mutable slice.
+#[inline]
+#[unstable(feature = "core")]
+pub unsafe fn from_raw_parts_mut<'a, T>(p: *mut T, len: uint) -> &'a mut [T] {
+ transmute(RawSlice { data: p, len: len })
+}
+
/// Forms a slice from a pointer and a length.
///
/// The pointer given is actually a reference to the base of the slice. This
/// }
/// ```
#[inline]
-#[unstable(feature = "core",
- reason = "should be renamed to from_raw_parts")]
+#[unstable(feature = "core")]
+#[deprecated(since = "1.0.0",
+ reason = "use from_raw_parts")]
pub unsafe fn from_raw_buf<'a, T>(p: &'a *const T, len: uint) -> &'a [T] {
transmute(RawSlice { data: *p, len: len })
}
/// not being able to provide a non-aliasing guarantee of the returned mutable
/// slice.
#[inline]
-#[unstable(feature = "core",
- reason = "should be renamed to from_raw_parts_mut")]
+#[unstable(feature = "core")]
+#[deprecated(since = "1.0.0",
+ reason = "use from_raw_parts_mut")]
pub unsafe fn from_raw_mut_buf<'a, T>(p: &'a *mut T, len: uint) -> &'a mut [T] {
transmute(RawSlice { data: *p, len: len })
}
/// An error returned when parsing a `bool` from a string fails.
#[derive(Debug, Clone, PartialEq)]
-#[allow(missing_copy_implementations)]
#[stable(feature = "rust1", since = "1.0.0")]
pub struct ParseBoolError { _priv: () }
impl Deref for Bytes {
type Target = [u8];
fn deref(&self) -> &[u8] {
- unsafe { slice::from_raw_mut_buf(&self.ptr.0, self.len) }
+ unsafe { slice::from_raw_parts_mut(self.ptr.0, self.len) }
}
}
#![feature(collections)]
#![feature(core)]
#![feature(io)]
-#![feature(path)]
use self::LabelText::*;
use std::string::CowString;
use std::vec::CowVec;
-pub mod maybe_owned_vec;
-
/// The text for a graphviz label on a node or edge.
pub enum LabelText<'a> {
/// This kind of label preserves the text directly as is.
+++ /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.
-
-#![unstable(feature = "rustc_private")]
-#![deprecated(since = "1.0.0", reason = "use std::vec::CowVec")]
-
-pub use self::MaybeOwnedVector::*;
-
-use std::cmp::Ordering;
-use std::default::Default;
-use std::fmt;
-use std::iter::FromIterator;
-use std::old_path::BytesContainer;
-use std::slice;
-
-// Note 1: It is not clear whether the flexibility of providing both
-// the `Growable` and `FixedLen` variants is sufficiently useful.
-// Consider restricting to just a two variant enum.
-
-// Note 2: Once Dynamically Sized Types (DST) lands, it might be
-// reasonable to replace this with something like `enum MaybeOwned<'a,
-// U: ?Sized>{ Owned(Box<U>), Borrowed(&'a U) }`; and then `U` could be
-// instantiated with `[T]` or `str`, etc. Of course, that would imply
-// removing the `Growable` variant, which relates to note 1 above.
-// Alternatively, we might add `MaybeOwned` for the general case but
-// keep some form of `MaybeOwnedVector` to avoid unnecessary copying
-// of the contents of `Vec<T>`, since we anticipate that to be a
-// frequent way to dynamically construct a vector.
-
-/// MaybeOwnedVector<'a,T> abstracts over `Vec<T>`, `&'a [T]`.
-///
-/// Some clients will have a pre-allocated vector ready to hand off in
-/// a slice; others will want to create the set on the fly and hand
-/// off ownership, via `Growable`.
-pub enum MaybeOwnedVector<'a,T:'a> {
- Growable(Vec<T>),
- Borrowed(&'a [T]),
-}
-
-/// Trait for moving into a `MaybeOwnedVector`
-pub trait IntoMaybeOwnedVector<'a,T> {
- /// Moves self into a `MaybeOwnedVector`
- fn into_maybe_owned(self) -> MaybeOwnedVector<'a,T>;
-}
-
-#[allow(deprecated)]
-impl<'a,T:'a> IntoMaybeOwnedVector<'a,T> for Vec<T> {
- #[allow(deprecated)]
- #[inline]
- fn into_maybe_owned(self) -> MaybeOwnedVector<'a,T> { Growable(self) }
-}
-
-#[allow(deprecated)]
-impl<'a,T> IntoMaybeOwnedVector<'a,T> for &'a [T] {
- #[allow(deprecated)]
- #[inline]
- fn into_maybe_owned(self) -> MaybeOwnedVector<'a,T> { Borrowed(self) }
-}
-
-impl<'a,T> MaybeOwnedVector<'a,T> {
- pub fn iter(&'a self) -> slice::Iter<'a,T> {
- match self {
- &Growable(ref v) => v.as_slice().iter(),
- &Borrowed(ref v) => v.iter(),
- }
- }
-
- pub fn len(&self) -> uint { self.as_slice().len() }
-
- #[allow(deprecated)]
- pub fn is_empty(&self) -> bool { self.len() == 0 }
-}
-
-impl<'a, T: PartialEq> PartialEq for MaybeOwnedVector<'a, T> {
- fn eq(&self, other: &MaybeOwnedVector<T>) -> bool {
- self.as_slice() == other.as_slice()
- }
-}
-
-impl<'a, T: Eq> Eq for MaybeOwnedVector<'a, T> {}
-
-impl<'a, T: PartialOrd> PartialOrd for MaybeOwnedVector<'a, T> {
- fn partial_cmp(&self, other: &MaybeOwnedVector<T>) -> Option<Ordering> {
- self.as_slice().partial_cmp(other.as_slice())
- }
-}
-
-impl<'a, T: Ord> Ord for MaybeOwnedVector<'a, T> {
- fn cmp(&self, other: &MaybeOwnedVector<T>) -> Ordering {
- self.as_slice().cmp(other.as_slice())
- }
-}
-
-// The `Vector` trait is provided in the prelude and is implemented on
-// both `&'a [T]` and `Vec<T>`, so it makes sense to try to support it
-// seamlessly. The other vector related traits from the prelude do
-// not appear to be implemented on both `&'a [T]` and `Vec<T>`. (It
-// is possible that this is an oversight in some cases.)
-//
-// In any case, with `Vector` in place, the client can just use
-// `as_slice` if they prefer that over `match`.
-
-impl<'b,T> AsSlice<T> for MaybeOwnedVector<'b,T> {
- fn as_slice<'a>(&'a self) -> &'a [T] {
- match self {
- &Growable(ref v) => v.as_slice(),
- &Borrowed(ref v) => v.as_slice(),
- }
- }
-}
-
-impl<'a,T> FromIterator<T> for MaybeOwnedVector<'a,T> {
- #[allow(deprecated)]
- fn from_iter<I:Iterator<Item=T>>(iterator: I) -> MaybeOwnedVector<'a,T> {
- // If we are building from scratch, might as well build the
- // most flexible variant.
- Growable(iterator.collect())
- }
-}
-
-impl<'a,T:fmt::Debug> fmt::Debug for MaybeOwnedVector<'a,T> {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- self.as_slice().fmt(f)
- }
-}
-
-impl<'a, T: Clone> Clone for MaybeOwnedVector<'a, T> {
- #[allow(deprecated)]
- fn clone(&self) -> MaybeOwnedVector<'a, T> {
- match *self {
- Growable(ref v) => Growable(v.clone()),
- Borrowed(v) => Borrowed(v)
- }
- }
-}
-
-impl<'a, T> Default for MaybeOwnedVector<'a, T> {
- #[allow(deprecated)]
- fn default() -> MaybeOwnedVector<'a, T> {
- Growable(Vec::new())
- }
-}
-
-impl<'a> BytesContainer for MaybeOwnedVector<'a, u8> {
- fn container_as_bytes(&self) -> &[u8] {
- self.as_slice()
- }
-}
-
-impl<'a,T:Clone> MaybeOwnedVector<'a,T> {
- /// Convert `self` into a growable `Vec`, not making a copy if possible.
- pub fn into_vec(self) -> Vec<T> {
- match self {
- Growable(v) => v,
- Borrowed(v) => v.to_vec(),
- }
- }
-}
#![cfg_attr(not(feature = "cargo-build"), staged_api)]
#![cfg_attr(not(feature = "cargo-build"), feature(core))]
#![feature(int_uint)]
+#![feature(no_std)]
#![no_std]
#![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
html_favicon_url = "http://www.rust-lang.org/favicon.ico",
/// variants, because the compiler complains about the repr attribute
/// otherwise.
#[repr(u8)]
- #[allow(missing_copy_implementations)]
pub enum c_void {
__variant1,
__variant2,
}
- #[allow(missing_copy_implementations)]
pub enum FILE {}
- #[allow(missing_copy_implementations)]
pub enum fpos_t {}
}
pub mod c99 {
pub type uint64_t = u64;
}
pub mod posix88 {
- #[allow(missing_copy_implementations)]
pub enum DIR {}
- #[allow(missing_copy_implementations)]
pub enum dirent_t {}
}
pub mod posix01 {}
#[test] fn work_on_windows() { } // FIXME #10872 needed for a happy windows
+// NOTE: remove after next snapshot
#[doc(hidden)]
-#[cfg(not(test))]
+#[cfg(all(stage0, not(test)))]
mod std {
pub use core::marker;
}
unsafe {
let ptr = ret.rsl.as_mut_ptr() as *mut u8;
- let slice = slice::from_raw_mut_buf(&ptr, (RAND_SIZE * 4) as uint);
+ let slice = slice::from_raw_parts_mut(ptr, (RAND_SIZE * 4) as uint);
other.fill_bytes(slice);
}
ret.cnt = 0;
unsafe {
let ptr = ret.rsl.as_mut_ptr() as *mut u8;
- let slice = slice::from_raw_mut_buf(&ptr, (RAND_SIZE_64 * 8) as uint);
+ let slice = slice::from_raw_parts_mut(ptr, (RAND_SIZE_64 * 8) as uint);
other.fill_bytes(slice);
}
ret.cnt = 0;
html_root_url = "http://doc.rust-lang.org/nightly/",
html_playground_url = "http://play.rust-lang.org/")]
#![feature(int_uint)]
+#![feature(no_std)]
#![no_std]
#![unstable(feature = "rand")]
#![feature(staged_api)]
/// [1]: Marsaglia, George (July 2003). ["Xorshift
/// RNGs"](http://www.jstatsoft.org/v08/i14/paper). *Journal of
/// Statistical Software*. Vol. 8 (Issue 14).
-#[allow(missing_copy_implementations)]
#[derive(Clone)]
pub struct XorShiftRng {
x: u32,
/// ```
pub struct Closed01<F>(pub F);
-#[cfg(not(test))]
+// NOTE: remove after next snapshot
+#[cfg(all(stage0, not(test)))]
mod std {
pub use core::{option, fmt}; // panic!()
pub use core::clone; // derive Clone
E0001: r##"
This error suggests that the expression arm corresponding to the noted pattern
will never be reached as for all possible values of the expression being matched,
- one of the preceeding patterns will match.
+ one of the preceding patterns will match.
- This means that perhaps some of the preceeding patterns are too general, this
+ This means that perhaps some of the preceding patterns are too general, this
one is too specific or the ordering is incorrect.
"##,
E0312, // lifetime of reference outlives lifetime of borrowed content
E0313, // lifetime of borrowed pointer outlives lifetime of captured variable
E0314, // closure outlives stack frame
- E0315 // cannot invoke closure outside of its lifetime
+ E0315, // cannot invoke closure outside of its lifetime
+ E0316 // nested quantification of lifetimes
}
__build_diagnostic_array! { DIAGNOSTICS }
if !attr::is_used(attr) {
cx.span_lint(UNUSED_ATTRIBUTES, attr.span, "unused attribute");
- if CRATE_ATTRS.contains(&attr.name().get()) {
+ if CRATE_ATTRS.contains(&&attr.name()[]) {
let msg = match attr.node.style {
ast::AttrOuter => "crate-level attribute should be an inner \
attribute: add an exclamation mark: #![foo]",
None => {}
Some(s) => {
msg.push_str(": ");
- msg.push_str(s.get());
+ msg.push_str(&s);
}
}
- cx.span_lint(UNUSED_MUST_USE, sp, &msg[]);
+ cx.span_lint(UNUSED_MUST_USE, sp, &msg);
return true;
}
}
fn check_case(&self, cx: &Context, sort: &str, ident: ast::Ident, span: Span) {
fn is_camel_case(ident: ast::Ident) -> bool {
let ident = token::get_ident(ident);
- if ident.get().is_empty() { return true; }
- let ident = ident.get().trim_matches('_');
+ if ident.is_empty() { return true; }
+ let ident = ident.trim_matches('_');
// start with a non-lowercase letter rather than non-uppercase
// ones (some scripts don't have a concept of upper/lowercase)
let s = token::get_ident(ident);
if !is_camel_case(ident) {
- let c = to_camel_case(s.get());
+ let c = to_camel_case(&s);
let m = if c.is_empty() {
format!("{} `{}` should have a camel case name such as `CamelCase`", sort, s)
} else {
fn check_snake_case(&self, cx: &Context, sort: &str, ident: ast::Ident, span: Span) {
fn is_snake_case(ident: ast::Ident) -> bool {
let ident = token::get_ident(ident);
- if ident.get().is_empty() { return true; }
- let ident = ident.get().trim_left_matches('\'');
+ if ident.is_empty() { return true; }
+ let ident = ident.trim_left_matches('\'');
let ident = ident.trim_matches('_');
let mut allow_underscore = true;
let s = token::get_ident(ident);
if !is_snake_case(ident) {
- let sc = NonSnakeCase::to_snake_case(s.get());
- if sc != s.get() {
+ let sc = NonSnakeCase::to_snake_case(&s);
+ if sc != &s[] {
cx.span_lint(NON_SNAKE_CASE, span,
&*format!("{} `{}` should have a snake case name such as `{}`",
sort, s, sc));
fn check_upper_case(cx: &Context, sort: &str, ident: ast::Ident, span: Span) {
let s = token::get_ident(ident);
- if s.get().chars().any(|c| c.is_lowercase()) {
- let uc: String = NonSnakeCase::to_snake_case(s.get()).chars()
+ if s.chars().any(|c| c.is_lowercase()) {
+ let uc: String = NonSnakeCase::to_snake_case(&s).chars()
.map(|c| c.to_uppercase()).collect();
- if uc != s.get() {
+ if uc != &s[] {
cx.span_lint(NON_UPPER_CASE_GLOBALS, span,
&format!("{} `{}` should have an upper case name such as `{}`",
sort, s, uc));
match items[0].node {
ast::PathListIdent {ref name, ..} => {
let m = format!("braces around {} is unnecessary",
- token::get_ident(*name).get());
+ &token::get_ident(*name));
cx.span_lint(UNUSED_IMPORT_BRACES, item.span,
&m[]);
},
pat_util::pat_bindings(&cx.tcx.def_map, &**p, |mode, id, _, path1| {
let ident = path1.node;
if let ast::BindByValue(ast::MutMutable) = mode {
- if !token::get_ident(ident).get().starts_with("_") {
+ if !token::get_ident(ident).starts_with("_") {
match mutables.entry(ident.name.usize()) {
Vacant(entry) => { entry.insert(vec![id]); },
Occupied(mut entry) => { entry.get_mut().push(id); },
"unused or unknown features found in crate-level #[feature] directives"
}
+declare_lint! {
+ pub STABLE_FEATURES,
+ Warn,
+ "stable features found in #[feature] directive"
+}
+
declare_lint! {
pub UNKNOWN_CRATE_TYPES,
Deny,
declare_lint! {
pub MISSING_COPY_IMPLEMENTATIONS,
- Warn,
+ Allow,
"detects potentially-forgotten implementations of `Copy`"
}
UNREACHABLE_CODE,
WARNINGS,
UNUSED_FEATURES,
+ STABLE_FEATURES,
UNKNOWN_CRATE_TYPES,
VARIANT_SIZE_DIFFERENCES,
FAT_PTR_TRANSMUTES
-> Vec<Result<(InternedString, Level, Span), Span>> {
let mut out = vec!();
for attr in attrs {
- let level = match Level::from_str(attr.name().get()) {
+ let level = match Level::from_str(&attr.name()) {
None => continue,
Some(lvl) => lvl,
};
continue;
}
Ok((lint_name, level, span)) => {
- match self.lints.find_lint(lint_name.get(), &self.tcx.sess, Some(span)) {
+ match self.lints.find_lint(&lint_name, &self.tcx.sess, Some(span)) {
Some(lint_id) => vec![(lint_id, level, span)],
None => {
- match self.lints.lint_groups.get(lint_name.get()) {
+ match self.lints.lint_groups.get(&lint_name[]) {
Some(&(ref v, _)) => v.iter()
.map(|lint_id: &LintId|
(*lint_id, level, span))
-// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
use syntax::abi;
use syntax::attr;
use syntax::attr::AttrMetaMethods;
-use syntax::codemap::{COMMAND_LINE_SP, Span, mk_sp};
+use syntax::codemap::{Span, mk_sp};
use syntax::parse;
use syntax::parse::token::InternedString;
use syntax::parse::token;
fn process_crate(&self, c: &ast::Crate) {
for a in c.attrs.iter().filter(|m| m.name() == "link_args") {
match a.value_str() {
- Some(ref linkarg) => self.sess.cstore.add_used_link_args(linkarg.get()),
+ Some(ref linkarg) => self.sess.cstore.add_used_link_args(&linkarg),
None => { /* fallthrough */ }
}
}
ident, path_opt);
let name = match *path_opt {
Some((ref path_str, _)) => {
- let name = path_str.get().to_string();
+ let name = path_str.to_string();
validate_crate_name(Some(self.sess), &name[],
Some(i.span));
name
}
- None => ident.get().to_string(),
+ None => ident.to_string(),
};
Some(CrateInfo {
- ident: ident.get().to_string(),
+ ident: ident.to_string(),
name: name,
id: i.id,
should_link: should_link(i),
.collect::<Vec<&ast::Attribute>>();
for m in &link_args {
match m.value_str() {
- Some(linkarg) => self.sess.cstore.add_used_link_args(linkarg.get()),
+ Some(linkarg) => self.sess.cstore.add_used_link_args(&linkarg),
None => { /* fallthrough */ }
}
}
}
};
register_native_lib(self.sess, Some(m.span),
- n.get().to_string(), kind);
+ n.to_string(), kind);
}
None => {}
}
root: root,
rejected_via_hash: vec!(),
rejected_via_triple: vec!(),
+ rejected_via_kind: vec!(),
should_match_name: true,
};
let library = load_ctxt.load_library_crate();
CrateOrString::Krate(c) => {
(self.extract_crate_info(c).unwrap(), c.span)
}
- CrateOrString::Str(s) => {
+ CrateOrString::Str(sp, s) => {
(CrateInfo {
name: s.to_string(),
ident: s.to_string(),
id: ast::DUMMY_NODE_ID,
should_link: true,
- }, COMMAND_LINE_SP)
+ }, sp)
}
};
let target_triple = &self.sess.opts.target_triple[];
root: &None,
rejected_via_hash: vec!(),
rejected_via_triple: vec!(),
+ rejected_via_kind: vec!(),
should_match_name: true,
};
let library = match load_ctxt.maybe_load_library_crate() {
#[derive(Copy)]
pub enum CrateOrString<'a> {
Krate(&'a ast::Item),
- Str(&'a str)
+ Str(Span, &'a str)
}
impl<'a> PluginMetadata<'a> {
let cdata = cstore.get_crate_data(def.krate);
let attrs = decoder::get_crate_attributes(cdata.data());
for attr in &attrs {
- if attr.name().get() == "staged_api" {
+ if &attr.name()[] == "staged_api" {
match attr.node.value.node { ast::MetaWord(_) => return true, _ => (/*pass*/) }
}
}
}
fn encode_name(rbml_w: &mut Encoder, name: ast::Name) {
- rbml_w.wr_tagged_str(tag_paths_data_name, token::get_name(name).get());
+ rbml_w.wr_tagged_str(tag_paths_data_name, &token::get_name(name));
}
fn encode_impl_type_basename(rbml_w: &mut Encoder, name: ast::Ident) {
- rbml_w.wr_tagged_str(tag_item_impl_type_basename, token::get_ident(name).get());
+ rbml_w.wr_tagged_str(tag_item_impl_type_basename, &token::get_ident(name));
}
pub fn encode_def_id(rbml_w: &mut Encoder, id: DefId) {
ast_map::PathMod(_) => tag_path_elem_mod,
ast_map::PathName(_) => tag_path_elem_name
};
- rbml_w.wr_tagged_str(tag, token::get_name(pe.name()).get());
+ rbml_w.wr_tagged_str(tag, &token::get_name(pe.name()));
}
rbml_w.end_tag();
}
rbml_w.start_tag(tag_method_argument_name);
if let ast::PatIdent(_, ref path1, _) = arg.pat.node {
let name = token::get_ident(path1.node);
- rbml_w.writer.write_all(name.get().as_bytes());
+ rbml_w.writer.write_all(name.as_bytes());
}
rbml_w.end_tag();
}
encode_def_id(rbml_w, local_def(nitem.id));
encode_visibility(rbml_w, nitem.vis);
match nitem.node {
- ast::ForeignItemFn(..) => {
+ ast::ForeignItemFn(ref fndecl, _) => {
encode_family(rbml_w, FN_FAMILY);
encode_bounds_and_type(rbml_w, ecx,
&lookup_item_type(ecx.tcx,local_def(nitem.id)));
let stab = stability::lookup(ecx.tcx, ast_util::local_def(nitem.id));
encode_stability(rbml_w, stab);
encode_symbol(ecx, rbml_w, nitem.id);
+ encode_method_argument_names(rbml_w, &*fndecl);
}
ast::ForeignItemStatic(_, mutbl) => {
if mutbl {
ast::MetaWord(ref name) => {
rbml_w.start_tag(tag_meta_item_word);
rbml_w.start_tag(tag_meta_item_name);
- rbml_w.writer.write_all(name.get().as_bytes());
+ rbml_w.writer.write_all(name.as_bytes());
rbml_w.end_tag();
rbml_w.end_tag();
}
ast::LitStr(ref value, _) => {
rbml_w.start_tag(tag_meta_item_name_value);
rbml_w.start_tag(tag_meta_item_name);
- rbml_w.writer.write_all(name.get().as_bytes());
+ rbml_w.writer.write_all(name.as_bytes());
rbml_w.end_tag();
rbml_w.start_tag(tag_meta_item_value);
- rbml_w.writer.write_all(value.get().as_bytes());
+ rbml_w.writer.write_all(value.as_bytes());
rbml_w.end_tag();
rbml_w.end_tag();
}
ast::MetaList(ref name, ref items) => {
rbml_w.start_tag(tag_meta_item_list);
rbml_w.start_tag(tag_meta_item_name);
- rbml_w.writer.write_all(name.get().as_bytes());
+ rbml_w.writer.write_all(name.as_bytes());
rbml_w.end_tag();
for inner_item in items {
encode_meta_item(rbml_w, &**inner_item);
fn encode_associated_type_names(rbml_w: &mut Encoder, names: &[ast::Name]) {
rbml_w.start_tag(tag_associated_type_names);
for &name in names {
- rbml_w.wr_tagged_str(tag_associated_type_name, token::get_name(name).get());
+ rbml_w.wr_tagged_str(tag_associated_type_name, &token::get_name(name));
}
rbml_w.end_tag();
}
-// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
pub root: &'a Option<CratePaths>,
pub rejected_via_hash: Vec<CrateMismatch>,
pub rejected_via_triple: Vec<CrateMismatch>,
+ pub rejected_via_kind: Vec<CrateMismatch>,
pub should_match_name: bool,
}
} else if self.rejected_via_triple.len() > 0 {
format!("couldn't find crate `{}` with expected target triple {}",
self.ident, self.triple)
+ } else if self.rejected_via_kind.len() > 0 {
+ format!("found staticlib `{}` instead of rlib or dylib", self.ident)
} else {
format!("can't find crate for `{}`", self.ident)
};
let mismatches = self.rejected_via_hash.iter();
for (i, &CrateMismatch{ ref path, .. }) in mismatches.enumerate() {
self.sess.fileline_note(self.span,
- &format!("crate `{}` path {}{}: {}",
- self.ident, "#", i+1, path.display())[]);
+ &format!("crate `{}` path #{}: {}",
+ self.ident, i+1, path.display())[]);
}
match self.root {
&None => {}
}
}
}
+ if self.rejected_via_kind.len() > 0 {
+ self.sess.span_help(self.span, "please recompile this crate using \
+ --crate-type lib");
+ let mismatches = self.rejected_via_kind.iter();
+ for (i, &CrateMismatch { ref path, .. }) in mismatches.enumerate() {
+ self.sess.fileline_note(self.span,
+ &format!("crate `{}` path #{}: {}",
+ self.ident, i+1, path.display())[]);
+ }
+ }
self.sess.abort_if_errors();
}
// must be loaded via -L plus some filtering.
if self.hash.is_none() {
self.should_match_name = false;
- match self.find_commandline_library() {
- Some(l) => return Some(l),
- None => {}
+ if let Some(s) = self.sess.opts.externs.get(self.crate_name) {
+ return self.find_commandline_library(s);
}
self.should_match_name = true;
}
// want: crate_name.dir_part() + prefix + crate_name.file_part + "-"
let dylib_prefix = format!("{}{}", dypair.0, self.crate_name);
let rlib_prefix = format!("lib{}", self.crate_name);
+ let staticlib_prefix = format!("lib{}", self.crate_name);
let mut candidates = HashMap::new();
+ let mut staticlibs = vec!();
// First, find all possible candidate rlibs and dylibs purely based on
// the name of the files themselves. We're trying to match against an
Some(file) => file,
};
let (hash, rlib) = if file.starts_with(&rlib_prefix[]) &&
- file.ends_with(".rlib") {
+ file.ends_with(".rlib") {
(&file[(rlib_prefix.len()) .. (file.len() - ".rlib".len())],
true)
} else if file.starts_with(&dylib_prefix) &&
(&file[(dylib_prefix.len()) .. (file.len() - dypair.1.len())],
false)
} else {
+ if file.starts_with(&staticlib_prefix[]) &&
+ file.ends_with(".a") {
+ staticlibs.push(CrateMismatch {
+ path: path.clone(),
+ got: "static".to_string()
+ });
+ }
return FileDoesntMatch
};
info!("lib candidate: {}", path.display());
FileMatches
});
+ self.rejected_via_kind.extend(staticlibs.into_iter());
// We have now collected all known libraries into a set of candidates
// keyed of the filename hash listed. For each filename, we also have a
(t.options.dll_prefix.clone(), t.options.dll_suffix.clone())
}
- fn find_commandline_library(&mut self) -> Option<Library> {
- let locs = match self.sess.opts.externs.get(self.crate_name) {
- Some(s) => s,
- None => return None,
- };
-
+ fn find_commandline_library(&mut self, locs: &[String]) -> Option<Library> {
// First, filter out all libraries that look suspicious. We only accept
// files which actually exist that have the correct naming scheme for
// rlibs/dylibs.
while llvm::LLVMIsSectionIteratorAtEnd(of.llof, si.llsi) == False {
let mut name_buf = ptr::null();
let name_len = llvm::LLVMRustGetSectionName(si.llsi, &mut name_buf);
- let name = slice::from_raw_buf(&(name_buf as *const u8),
- name_len as uint).to_vec();
+ let name = slice::from_raw_parts(name_buf as *const u8,
+ name_len as uint).to_vec();
let name = String::from_utf8(name).unwrap();
debug!("get_metadata_section: name {}", name);
if read_meta_section_name(is_osx) == name {
debug!("checking {} bytes of metadata-version stamp",
vlen);
let minsz = cmp::min(vlen, csz);
- let buf0 = slice::from_raw_buf(&cvbuf, minsz);
+ let buf0 = slice::from_raw_parts(cvbuf, minsz);
let version_ok = buf0 == encoder::metadata_encoding_version;
if !version_ok {
return Err((format!("incompatible metadata version found: '{}'",
let cvbuf1 = cvbuf.offset(vlen as int);
debug!("inflating {} bytes of compressed metadata",
csz - vlen);
- let bytes = slice::from_raw_buf(&cvbuf1, csz-vlen);
+ let bytes = slice::from_raw_parts(cvbuf1, csz - vlen);
match flate::inflate_bytes(bytes) {
Some(inflated) => return Ok(MetadataVec(inflated)),
None => {}
use std::num::Float;
use std::slice;
use syntax::ast::{self, DUMMY_NODE_ID, NodeId, Pat};
-use syntax::ast_util::walk_pat;
+use syntax::ast_util;
use syntax::codemap::{Span, Spanned, DUMMY_SP};
use syntax::fold::{Folder, noop_fold_pat};
use syntax::print::pprust::pat_to_string;
use syntax::ptr::P;
use syntax::visit::{self, Visitor, FnKind};
use util::ppaux::ty_to_string;
+use util::nodemap::FnvHashMap;
pub const DUMMY_WILD_PAT: &'static Pat = &Pat {
id: DUMMY_NODE_ID,
}
}
- let mut static_inliner = StaticInliner::new(cx.tcx);
+ let mut static_inliner = StaticInliner::new(cx.tcx, None);
let inlined_arms = arms.iter().map(|arm| {
(arm.pats.iter().map(|pat| {
static_inliner.fold_pat((*pat).clone())
}
fn check_for_bindings_named_the_same_as_variants(cx: &MatchCheckCtxt, pat: &Pat) {
- walk_pat(pat, |p| {
+ ast_util::walk_pat(pat, |p| {
match p.node {
ast::PatIdent(ast::BindByValue(ast::MutImmutable), ident, None) => {
let pat_ty = ty::pat_ty(cx.tcx, p);
span_warn!(cx.tcx.sess, p.span, E0170,
"pattern binding `{}` is named the same as one \
of the variants of the type `{}`",
- token::get_ident(ident.node).get(), ty_to_string(cx.tcx, pat_ty));
+ &token::get_ident(ident.node), ty_to_string(cx.tcx, pat_ty));
span_help!(cx.tcx.sess, p.span,
"if you meant to match on a variant, \
consider making the path in the pattern qualified: `{}::{}`",
- ty_to_string(cx.tcx, pat_ty), token::get_ident(ident.node).get());
+ ty_to_string(cx.tcx, pat_ty), &token::get_ident(ident.node));
}
}
}
// Check that we do not match against a static NaN (#6804)
fn check_for_static_nan(cx: &MatchCheckCtxt, pat: &Pat) {
- walk_pat(pat, |p| {
+ ast_util::walk_pat(pat, |p| {
match p.node {
ast::PatLit(ref expr) if is_expr_const_nan(cx.tcx, &**expr) => {
span_warn!(cx.tcx.sess, p.span, E0003,
pub struct StaticInliner<'a, 'tcx: 'a> {
pub tcx: &'a ty::ctxt<'tcx>,
- pub failed: bool
+ pub failed: bool,
+ pub renaming_map: Option<&'a mut FnvHashMap<(NodeId, Span), NodeId>>,
}
impl<'a, 'tcx> StaticInliner<'a, 'tcx> {
- pub fn new<'b>(tcx: &'b ty::ctxt<'tcx>) -> StaticInliner<'b, 'tcx> {
+ pub fn new<'b>(tcx: &'b ty::ctxt<'tcx>,
+ renaming_map: Option<&'b mut FnvHashMap<(NodeId, Span), NodeId>>)
+ -> StaticInliner<'b, 'tcx> {
StaticInliner {
tcx: tcx,
- failed: false
+ failed: false,
+ renaming_map: renaming_map
}
}
}
+struct RenamingRecorder<'map> {
+ substituted_node_id: NodeId,
+ origin_span: Span,
+ renaming_map: &'map mut FnvHashMap<(NodeId, Span), NodeId>
+}
+
+impl<'map> ast_util::IdVisitingOperation for RenamingRecorder<'map> {
+ fn visit_id(&mut self, node_id: NodeId) {
+ let key = (node_id, self.origin_span);
+ self.renaming_map.insert(key, self.substituted_node_id);
+ }
+}
+
impl<'a, 'tcx> Folder for StaticInliner<'a, 'tcx> {
fn fold_pat(&mut self, pat: P<Pat>) -> P<Pat> {
- match pat.node {
+ return match pat.node {
ast::PatIdent(..) | ast::PatEnum(..) => {
let def = self.tcx.def_map.borrow().get(&pat.id).cloned();
match def {
Some(DefConst(did)) => match lookup_const_by_id(self.tcx, did) {
Some(const_expr) => {
- const_expr_to_pat(self.tcx, const_expr).map(|mut new_pat| {
- new_pat.span = pat.span;
+ const_expr_to_pat(self.tcx, const_expr, pat.span).map(|new_pat| {
+
+ if let Some(ref mut renaming_map) = self.renaming_map {
+ // Record any renamings we do here
+ record_renamings(const_expr, &pat, renaming_map);
+ }
+
new_pat
})
}
}
}
_ => noop_fold_pat(pat, self)
+ };
+
+ fn record_renamings(const_expr: &ast::Expr,
+ substituted_pat: &ast::Pat,
+ renaming_map: &mut FnvHashMap<(NodeId, Span), NodeId>) {
+ let mut renaming_recorder = RenamingRecorder {
+ substituted_node_id: substituted_pat.id,
+ origin_span: substituted_pat.span,
+ renaming_map: renaming_map,
+ };
+
+ let mut id_visitor = ast_util::IdVisitor {
+ operation: &mut renaming_recorder,
+ pass_through_items: true,
+ visited_outermost: false,
+ };
+
+ id_visitor.visit_expr(const_expr);
}
}
}
ast::LocalFor => "`for` loop"
};
- let mut static_inliner = StaticInliner::new(cx.tcx);
+ let mut static_inliner = StaticInliner::new(cx.tcx, None);
is_refutable(cx, &*static_inliner.fold_pat(loc.pat.clone()), |pat| {
span_err!(cx.tcx.sess, loc.pat.span, E0005,
"refutable pattern in {} binding: `{}` not covered",
};
for pat in pats {
- walk_pat(&**pat, |p| {
+ ast_util::walk_pat(&**pat, |p| {
if pat_is_binding(def_map, &*p) {
match p.node {
ast::PatIdent(ast::BindByValue(_), _, ref sub) => {
use util::nodemap::DefIdMap;
use syntax::ast::{self, Expr};
+use syntax::codemap::Span;
use syntax::parse::token::InternedString;
use syntax::ptr::P;
use syntax::visit::{self, Visitor};
const_bool(bool)
}
-pub fn const_expr_to_pat(tcx: &ty::ctxt, expr: &Expr) -> P<ast::Pat> {
+pub fn const_expr_to_pat(tcx: &ty::ctxt, expr: &Expr
, span: Span) -> P<ast::Pat> {
let pat = match expr.node {
ast::ExprTup(ref exprs) =>
- ast::PatTup(exprs.iter().map(|expr| const_expr_to_pat(tcx, &**expr)).collect()),
+ ast::PatTup(exprs.iter().map(|expr| const_expr_to_pat(tcx, &**expr, span)).collect()),
ast::ExprCall(ref callee, ref args) => {
let def = tcx.def_map.borrow()[callee.id].clone();
def::DefVariant(_, variant_did, _) => def_to_path(tcx, variant_did),
_ => unreachable!()
};
- let pats = args.iter().map(|expr| const_expr_to_pat(tcx, &**expr)).collect();
+ let pats = args.iter().map(|expr| const_expr_to_pat(tcx, &**expr, span)).collect();
ast::PatEnum(path, Some(pats))
}
span: codemap::DUMMY_SP,
node: ast::FieldPat {
ident: field.ident.node,
- pat: const_expr_to_pat(tcx, &*field.expr),
+ pat: const_expr_to_pat(tcx, &*field.expr, span),
is_shorthand: false,
},
}).collect();
}
ast::ExprVec(ref exprs) => {
- let pats = exprs.iter().map(|expr| const_expr_to_pat(tcx, &**expr)).collect();
+ let pats = exprs.iter().map(|expr| const_expr_to_pat(tcx, &**expr, span)).collect();
ast::PatVec(pats, None, vec![])
}
ast::PatEnum(path.clone(), None),
_ => {
match lookup_const(tcx, expr) {
- Some(actual) => return const_expr_to_pat(tcx, actual),
+ Some(actual) => return const_expr_to_pat(tcx, actual, span),
_ => unreachable!()
}
}
ast::ExprQPath(_) => {
match lookup_const(tcx, expr) {
- Some(actual) => return const_expr_to_pat(tcx, actual),
+ Some(actual) => return const_expr_to_pat(tcx, actual, span),
_ => unreachable!()
}
}
_ => ast::PatLit(P(expr.clone()))
};
- P(ast::Pat { id: expr.id, node: pat, span: expr.span })
+ P(ast::Pat { id: expr.id, node: pat, span: span })
}
pub fn eval_const_expr(tcx: &ty::ctxt, e: &Expr) -> const_val {
ast::LitInt(n, ast::UnsignedIntLit(_)) => const_uint(n),
ast::LitFloat(ref n, _) |
ast::LitFloatUnsuffixed(ref n) => {
- const_float(n.get().parse::<f64>().unwrap() as f64)
+ const_float(n.parse::<f64>().unwrap() as f64)
}
ast::LitBool(b) => const_bool(b)
}
for attr in lint::gather_attrs(attrs) {
match attr {
Ok((ref name, lint::Allow, _))
- if name.get() == dead_code => return true,
+ if &name[] == dead_code => return true,
_ => (),
}
}
lifetime of captured variable `{}`...",
ty::local_var_name_str(self.tcx,
upvar_id.var_id)
- .get()
.to_string());
note_and_explain_region(
self.tcx,
&format!("...but `{}` is only valid for ",
ty::local_var_name_str(self.tcx,
upvar_id.var_id)
- .get()
.to_string())[],
sup,
"");
&format!("captured variable `{}` does not \
outlive the enclosing closure",
ty::local_var_name_str(self.tcx,
- id).get()
- .to_string())[]);
+ id).to_string())[]);
note_and_explain_region(
self.tcx,
"captured variable is valid for ",
// choice of lifetime name deterministic and thus easier to test.
let mut names = Vec::new();
for rn in region_names {
- let lt_name = token::get_name(*rn).get().to_string();
+ let lt_name = token::get_name(*rn).to_string();
names.push(lt_name);
}
names.sort();
trait_ref: ast::TraitRef {
path: new_path,
ref_id: tr.ref_id,
- }
+ },
+ span: poly_tr.span,
}, modifier)
}
}
}
infer::EarlyBoundRegion(_, name) => {
format!(" for lifetime parameter `{}`",
- token::get_name(name).get())
+ &token::get_name(name))
}
infer::BoundRegionInCoherence(name) => {
format!(" for lifetime parameter `{}` in coherence check",
- token::get_name(name).get())
+ &token::get_name(name))
}
infer::UpvarRegion(ref upvar_id, _) => {
format!(" for capture of `{}` by closure",
- ty::local_var_name_str(self.tcx, upvar_id.var_id).get().to_string())
+ ty::local_var_name_str(self.tcx, upvar_id.var_id).to_string())
}
};
&format!(
"...so that closure can access `{}`",
ty::local_var_name_str(self.tcx, upvar_id.var_id)
- .get()
.to_string())[])
}
infer::InfStackClosure(span) => {
does not outlive the enclosing closure",
ty::local_var_name_str(
self.tcx,
- id).get().to_string())[]);
+ id).to_string())[]);
}
infer::IndexSlice(span) => {
self.tcx.sess.span_note(
fn with_taken(taken: &[ast::LifetimeDef]) -> LifeGiver {
let mut taken_ = HashSet::new();
for lt in taken {
- let lt_name = token::get_name(lt.lifetime.name).get().to_string();
+ let lt_name = token::get_name(lt.lifetime.name).to_string();
taken_.insert(lt_name);
}
LifeGiver {
use graphviz as dot;
use middle::ty;
+use middle::region::CodeExtent;
use super::Constraint;
use middle::infer::SubregionOrigin;
use middle::infer::region_inference::RegionVarBindings;
use util::nodemap::{FnvHashMap, FnvHashSet};
use util::ppaux::Repr;
+use std::borrow::Cow;
use std::collections::hash_map::Entry::Vacant;
use std::old_io::{self, File};
use std::env;
node_ids: FnvHashMap<Node, uint>,
}
-#[derive(Clone, Hash, PartialEq, Eq, Debug)]
+#[derive(Clone, Hash, PartialEq, Eq, Debug, Copy)]
enum Node {
RegionVid(ty::RegionVid),
Region(ty::Region),
}
-type Edge = Constraint;
+// type Edge = Constraint;
+#[derive(Clone, PartialEq, Eq, Debug, Copy)]
+enum Edge {
+ Constraint(Constraint),
+ EnclScope(CodeExtent, CodeExtent),
+}
impl<'a, 'tcx> ConstraintGraph<'a, 'tcx> {
fn new(tcx: &'a ty::ctxt<'tcx>,
add_node(n1);
add_node(n2);
}
+
+ tcx.region_maps.each_encl_scope(|sub, sup| {
+ add_node(Node::Region(ty::ReScope(*sub)));
+ add_node(Node::Region(ty::ReScope(*sup)));
+ });
}
ConstraintGraph { tcx: tcx,
dot::Id::new(&*self.graph_name).ok().unwrap()
}
fn node_id(&self, n: &Node) -> dot::Id {
- dot::Id::new(format!("node_{}", self.node_ids.get(n).unwrap())).ok().unwrap()
+ let node_id = match self.node_ids.get(n) {
+ Some(node_id) => node_id,
+ None => panic!("no node_id found for node: {:?}", n),
+ };
+ let name = || format!("node_{}", node_id);
+ match dot::Id::new(name()) {
+ Ok(id) => id,
+ Err(_) => {
+ panic!("failed to create graphviz node identified by {}", name());
+ }
+ }
}
fn node_label(&self, n: &Node) -> dot::LabelText {
match *n {
}
}
fn edge_label(&self, e: &Edge) -> dot::LabelText {
- dot::LabelText::label(format!("{}", self.map.get(e).unwrap().repr(self.tcx)))
+ match *e {
+ Edge::Constraint(ref c) =>
+ dot::LabelText::label(format!("{}", self.map.get(c).unwrap().repr(self.tcx))),
+ Edge::EnclScope(..) =>
+ dot::LabelText::label(format!("(enclosed)")),
+ }
}
}
}
}
+fn edge_to_nodes(e: &Edge) -> (Node, Node) {
+ match *e {
+ Edge::Constraint(ref c) => constraint_to_nodes(c),
+ Edge::EnclScope(sub, sup) => {
+ (Node::Region(ty::ReScope(sub)), Node::Region(ty::ReScope(sup)))
+ }
+ }
+}
+
impl<'a, 'tcx> dot::GraphWalk<'a, Node, Edge> for ConstraintGraph<'a, 'tcx> {
fn nodes(&self) -> dot::Nodes<Node> {
let mut set = FnvHashSet();
- for constraint in self.map.keys() {
- let (n1, n2) = constraint_to_nodes(constraint);
- set.insert(n1);
- set.insert(n2);
+ for node in self.node_ids.keys() {
+ set.insert(*node);
}
debug!("constraint graph has {} nodes", set.len());
set.into_iter().collect()
}
fn edges(&self) -> dot::Edges<Edge> {
debug!("constraint graph has {} edges", self.map.len());
- self.map.keys().map(|e|*e).collect()
+ let mut v : Vec<_> = self.map.keys().map(|e| Edge::Constraint(*e)).collect();
+ self.tcx.region_maps.each_encl_scope(|sub, sup| {
+ v.push(Edge::EnclScope(*sub, *sup))
+ });
+ debug!("region graph has {} edges", v.len());
+ Cow::Owned(v)
}
fn source(&self, edge: &Edge) -> Node {
- let (n1, _) = constraint_to_nodes(edge);
+ let (n1, _) = edge_to_nodes(edge);
debug!("edge {:?} has source {:?}", edge, n1);
n1
}
fn target(&self, edge: &Edge) -> Node {
- let (_, n2) = constraint_to_nodes(edge);
+ let (_, n2) = edge_to_nodes(edge);
debug!("edge {:?} has target {:?}", edge, n2);
n2
}
}
#[derive(Debug)]
-#[allow(missing_copy_implementations)]
pub struct RegionSnapshot {
length: uint,
skolemization_count: u32,
fn visit_item(&mut self, item: &ast::Item) {
match extract(&item.attrs) {
Some(value) => {
- let item_index = self.item_refs.get(value.get()).map(|x| *x);
+ let item_index = self.item_refs.get(&value[]).map(|x| *x);
match item_index {
Some(item_index) => {
fn variable_name(&self, var: Variable) -> String {
match self.var_kinds[var.get()] {
Local(LocalInfo { ident: nm, .. }) | Arg(_, nm) => {
- token::get_ident(nm).get().to_string()
+ token::get_ident(nm).to_string()
},
ImplicitRet => "<implicit-ret>".to_string(),
CleanExit => "<clean-exit>".to_string()
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
pub enum InteriorKind {
InteriorField(FieldName),
- InteriorElement(ElementKind),
+ InteriorElement(InteriorOffsetKind, ElementKind),
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
PositionalField(uint)
}
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
+pub enum InteriorOffsetKind {
+ Index, // e.g. `array_expr[index_expr]`
+ Pattern, // e.g. `fn foo([_, a, _, _]: [A; 4]) { ... }`
+}
+
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
pub enum ElementKind {
VecElement,
deref_interior(InteriorKind),
}
+type DerefKindContext = Option<InteriorOffsetKind>;
+
// Categorizes a derefable type. Note that we include vectors and strings as
// derefable (we model an index as the combination of a deref and then a
// pointer adjustment).
-pub fn deref_kind(t: Ty) -> McResult<deref_kind> {
+fn deref_kind(t: Ty, context: DerefKindContext) -> McResult<deref_kind> {
match t.sty {
ty::ty_uniq(_) => {
Ok(deref_ptr(Unique))
}
ty::ty_vec(_, _) | ty::ty_str => {
- Ok(deref_interior(InteriorElement(element_kind(t))))
+ // no deref of indexed content without supplying InteriorOffsetKind
+ if let Some(context) = context {
+ Ok(deref_interior(InteriorElement(context, element_kind(t))))
+ } else {
+ Err(())
+ }
}
_ => Err(()),
autoderefs,
cmt.repr(self.tcx()));
for deref in 1..autoderefs + 1 {
- cmt = try!(self.cat_deref(expr, cmt, deref));
+ cmt = try!(self.cat_deref(expr, cmt, deref, None));
}
return Ok(cmt);
}
match expr.node {
ast::ExprUnary(ast::UnDeref, ref e_base) => {
let base_cmt = try!(self.cat_expr(&**e_base));
- self.cat_deref(expr, base_cmt, 0)
+ self.cat_deref(expr, base_cmt, 0, None)
}
ast::ExprField(ref base, f_name) => {
ast::ExprIndex(ref base, _) => {
let method_call = ty::MethodCall::expr(expr.id());
+ let context = InteriorOffsetKind::Index;
match self.typer.node_method_ty(method_call) {
Some(method_ty) => {
// If this is an index implemented by a method call, then it
// is an rvalue. That is what we will be
// dereferencing.
let base_cmt = self.cat_rvalue_node(expr.id(), expr.span(), ret_ty);
- self.cat_deref_common(expr, base_cmt, 1, elem_ty, true)
+ self.cat_deref_common(expr, base_cmt, 1, elem_ty, Some(context), true)
}
None => {
- self.cat_index(expr, try!(self.cat_expr(&**base)))
+ self.cat_index(expr, try!(self.cat_expr(&**base)), context)
}
}
}
fn cat_deref<N:ast_node>(&self,
node: &N,
base_cmt: cmt<'tcx>,
- deref_cnt: uint)
+ deref_cnt: uint,
+ deref_context: DerefKindContext)
-> McResult<cmt<'tcx>> {
let adjustment = match self.typer.adjustments().borrow().get(&node.id()) {
Some(adj) if ty::adjust_is_object(adj) => ty::AutoObject,
};
let base_cmt_ty = base_cmt.ty;
match ty::deref(base_cmt_ty, true) {
- Some(mt) => self.cat_deref_common(node, base_cmt, deref_cnt, mt.ty,
+ Some(mt) => self.cat_deref_common(node, base_cmt, deref_cnt,
+ mt.ty,
+ deref_context,
/* implicit: */ false),
None => {
debug!("Explicit deref of non-derefable type: {}",
base_cmt: cmt<'tcx>,
deref_cnt: uint,
deref_ty: Ty<'tcx>,
+ deref_context: DerefKindContext,
implicit: bool)
-> McResult<cmt<'tcx>>
{
- let (m, cat) = match try!(deref_kind(base_cmt.ty)) {
+ let (m, cat) = match try!(deref_kind(base_cmt.ty, deref_context)) {
deref_ptr(ptr) => {
let ptr = if implicit {
match ptr {
pub fn cat_index<N:ast_node>(&self,
elt: &N,
- mut base_cmt: cmt<'tcx>)
+ mut base_cmt: cmt<'tcx>,
+ context: InteriorOffsetKind)
-> McResult<cmt<'tcx>> {
//! Creates a cmt for an indexing operation (`[]`).
//!
};
let m = base_cmt.mutbl.inherit();
- return Ok(interior(elt, base_cmt.clone(), base_cmt.ty, m, element_ty));
+ return Ok(interior(elt, base_cmt.clone(), base_cmt.ty,
+ m, context, element_ty));
fn interior<'tcx, N: ast_node>(elt: &N,
of_cmt: cmt<'tcx>,
vec_ty: Ty<'tcx>,
mutbl: MutabilityCategory,
+ context: InteriorOffsetKind,
element_ty: Ty<'tcx>) -> cmt<'tcx>
{
+ let interior_elem = InteriorElement(context, element_kind(vec_ty));
Rc::new(cmt_ {
id:elt.id(),
span:elt.span(),
- cat:cat_interior(of_cmt, InteriorElement(element_kind(vec_ty))),
+ cat:cat_interior(of_cmt, interior_elem),
mutbl:mutbl,
ty:element_ty,
note: NoteNone
// underlying vec.
fn deref_vec<N:ast_node>(&self,
elt: &N,
- base_cmt: cmt<'tcx>)
+ base_cmt: cmt<'tcx>,
+ context: InteriorOffsetKind)
-> McResult<cmt<'tcx>>
{
- match try!(deref_kind(base_cmt.ty)) {
+ match try!(deref_kind(base_cmt.ty, Some(context))) {
deref_ptr(ptr) => {
// for unique ptrs, we inherit mutability from the
// owning reference.
let (slice_mutbl, slice_r) = vec_slice_info(self.tcx(),
slice_pat,
slice_ty);
- let cmt_slice = try!(self.cat_index(slice_pat, try!(self.deref_vec(slice_pat, vec_cmt))));
+ let context = InteriorOffsetKind::Pattern;
+ let cmt_vec = try!(self.deref_vec(slice_pat, vec_cmt, context));
+ let cmt_slice = try!(self.cat_index(slice_pat, cmt_vec, context));
return Ok((cmt_slice, slice_mutbl, slice_r));
/// In a pattern like [a, b, ..c], normally `c` has slice type, but if you have [a, b,
// box p1, &p1, &mut p1. we can ignore the mutability of
// PatRegion since that information is already contained
// in the type.
- let subcmt = try!(self.cat_deref(pat, cmt, 0));
+ let subcmt = try!(self.cat_deref(pat, cmt, 0, None));
try!(self.cat_pattern_(subcmt, &**subpat, op));
}
ast::PatVec(ref before, ref slice, ref after) => {
- let elt_cmt = try!(self.cat_index(pat, try!(self.deref_vec(pat, cmt))));
+ let context = InteriorOffsetKind::Pattern;
+ let vec_cmt = try!(self.deref_vec(pat, cmt, context));
+ let elt_cmt = try!(self.cat_index(pat, vec_cmt, context));
for before_pat in before {
try!(self.cat_pattern_(elt_cmt.clone(), &**before_pat, op));
}
cat_interior(_, InteriorField(PositionalField(_))) => {
"anonymous field".to_string()
}
- cat_interior(_, InteriorElement(VecElement)) |
- cat_interior(_, InteriorElement(OtherElement)) => {
+ cat_interior(_, InteriorElement(InteriorOffsetKind::Index,
+ VecElement)) |
+ cat_interior(_, InteriorElement(InteriorOffsetKind::Index,
+ OtherElement)) => {
"indexed content".to_string()
}
+ cat_interior(_, InteriorElement(InteriorOffsetKind::Pattern,
+ VecElement)) |
+ cat_interior(_, InteriorElement(InteriorOffsetKind::Pattern,
+ OtherElement)) => {
+ "pattern-bound indexed content".to_string()
+ }
cat_upvar(ref var) => {
var.user_string(tcx)
}
fn repr(&self, _tcx: &ty::ctxt) -> String {
match *self {
InteriorField(NamedField(fld)) => {
- token::get_name(fld).get().to_string()
+ token::get_name(fld).to_string()
}
InteriorField(PositionalField(i)) => format!("#{}", i),
- InteriorElement(_) => "[]".to_string(),
+ InteriorElement(..) => "[]".to_string(),
}
}
}
impl RegionMaps {
+ pub fn each_encl_scope<E>(&self, mut e:E) where E: FnMut(&CodeExtent, &CodeExtent) {
+ for (child, parent) in self.scope_map.borrow().iter() {
+ e(child, parent)
+ }
+ }
+ pub fn each_var_scope<E>(&self, mut e:E) where E: FnMut(&ast::NodeId, &CodeExtent) {
+ for (child, parent) in self.var_map.borrow().iter() {
+ e(child, parent)
+ }
+ }
+ pub fn each_encl_free_region<E>(&self, mut e:E) where E: FnMut(&FreeRegion, &FreeRegion) {
+ for (child, parents) in self.free_region_map.borrow().iter() {
+ for parent in parents.iter() {
+ e(child, parent)
+ }
+ }
+ }
+ pub fn each_rvalue_scope<E>(&self, mut e:E) where E: FnMut(&ast::NodeId, &CodeExtent) {
+ for (child, parent) in self.rvalue_scopes.borrow().iter() {
+ e(child, parent)
+ }
+ }
+ pub fn each_terminating_scope<E>(&self, mut e:E) where E: FnMut(&CodeExtent) {
+ for scope in self.terminating_scopes.borrow().iter() {
+ e(scope)
+ }
+ }
+
pub fn relate_free_regions(&self, sub: FreeRegion, sup: FreeRegion) {
match self.free_region_map.borrow_mut().get_mut(&sub) {
Some(sups) => {
/* lifetime decl */ ast::NodeId),
}
-// maps the id of each lifetime reference to the lifetime decl
-// that it corresponds to
+// Maps the id of each lifetime reference to the lifetime decl
+// that it corresponds to.
pub type NamedRegionMap = NodeMap<DefRegion>;
struct LifetimeContext<'a> {
named_region_map: &'a mut NamedRegionMap,
scope: Scope<'a>,
def_map: &'a DefMap,
+ // Deep breath. Our representation for poly trait refs contains a single
+ // binder and thus we only allow a single level of quantification. However,
+ // the syntax of Rust permits quantification in two places, e.g., `T: for <'a> Foo<'a>`
+ // and `for <'a, 'b> &'b T: Foo<'a>`. In order to get the de Bruijn indices
+ // correct when representing these constraints, we should only introduce one
+ // scope. However, we want to support both locations for the quantifier and
+ // during lifetime resolution we want precise information (so we can't
+ // desugar in an earlier phase).
+
+ // SO, if we encounter a quantifier at the outer scope, we set
+ // trait_ref_hack to true (and introduce a scope), and then if we encounter
+ // a quantifier at the inner scope, we error. If trait_ref_hack is false,
+ // then we introduce the scope at the inner quantifier.
+
+ // I'm sorry.
+ trait_ref_hack: bool,
}
enum ScopeChain<'a> {
named_region_map: &mut named_region_map,
scope: &ROOT_SCOPE,
def_map: def_map,
+ trait_ref_hack: false,
}, krate);
sess.abort_if_errors();
named_region_map
match predicate {
&ast::WherePredicate::BoundPredicate(ast::WhereBoundPredicate{ ref bounded_ty,
ref bounds,
+ ref bound_lifetimes,
.. }) => {
- self.visit_ty(&**bounded_ty);
- visit::walk_ty_param_bounds_helper(self, bounds);
+ if bound_lifetimes.len() > 0 {
+ self.trait_ref_hack = true;
+ let result = self.with(LateScope(bound_lifetimes, self.scope),
+ |old_scope, this| {
+ this.check_lifetime_defs(old_scope, bound_lifetimes);
+ this.visit_ty(&**bounded_ty);
+ visit::walk_ty_param_bounds_helper(this, bounds);
+ });
+ self.trait_ref_hack = false;
+ result
+ } else {
+ self.visit_ty(&**bounded_ty);
+ visit::walk_ty_param_bounds_helper(self, bounds);
+ }
}
&ast::WherePredicate::RegionPredicate(ast::WhereRegionPredicate{ref lifetime,
ref bounds,
}
}
- fn visit_poly_trait_ref(&mut self, trait_ref:
- &ast::PolyTraitRef,
+ fn visit_poly_trait_ref(&mut self,
+ trait_ref: &ast::PolyTraitRef,
_modifier: &ast::TraitBoundModifier) {
debug!("visit_poly_trait_ref trait_ref={:?}", trait_ref);
- self.with(LateScope(&trait_ref.bound_lifetimes, self.scope), |old_scope, this| {
- this.check_lifetime_defs(old_scope, &trait_ref.bound_lifetimes);
- for lifetime in &trait_ref.bound_lifetimes {
- this.visit_lifetime_def(lifetime);
+ if !self.trait_ref_hack || trait_ref.bound_lifetimes.len() > 0 {
+ if self.trait_ref_hack {
+ println!("{:?}", trait_ref.span);
+ span_err!(self.sess, trait_ref.span, E0316,
+ "nested quantification of lifetimes");
}
- this.visit_trait_ref(&trait_ref.trait_ref)
- })
+ self.with(LateScope(&trait_ref.bound_lifetimes, self.scope), |old_scope, this| {
+ this.check_lifetime_defs(old_scope, &trait_ref.bound_lifetimes);
+ for lifetime in &trait_ref.bound_lifetimes {
+ this.visit_lifetime_def(lifetime);
+ }
+ this.visit_trait_ref(&trait_ref.trait_ref)
+ })
+ } else {
+ self.visit_trait_ref(&trait_ref.trait_ref)
+ }
}
fn visit_trait_ref(&mut self, trait_ref: &ast::TraitRef) {
named_region_map: *named_region_map,
scope: &wrap_scope,
def_map: self.def_map,
+ trait_ref_hack: self.trait_ref_hack,
};
debug!("entering scope {:?}", this.scope);
f(self.scope, &mut this);
pub fn new(krate: &Crate) -> Index {
let mut staged_api = false;
for attr in &krate.attrs {
- if attr.name().get() == "staged_api" {
+ if &attr.name()[] == "staged_api" {
match attr.node.value.node {
ast::MetaWord(_) => {
attr::mark_used(attr);
/// Cross-references the feature names of unstable APIs with enabled
/// features and possibly prints errors. Returns a list of all
/// features used.
-pub fn check_unstable_api_usage(tcx: &ty::ctxt) -> FnvHashSet<InternedString> {
- let ref active_lib_features = tcx.sess.features.borrow().lib_features;
+pub fn check_unstable_api_usage(tcx: &ty::ctxt)
+ -> FnvHashMap<InternedString, attr::StabilityLevel> {
+ let ref active_lib_features = tcx.sess.features.borrow().declared_lib_features;
// Put the active features into a map for quick lookup
let active_features = active_lib_features.iter().map(|&(ref s, _)| s.clone()).collect();
let mut checker = Checker {
tcx: tcx,
active_features: active_features,
- used_features: FnvHashSet()
+ used_features: FnvHashMap()
};
let krate = tcx.map.krate();
struct Checker<'a, 'tcx: 'a> {
tcx: &'a ty::ctxt<'tcx>,
active_features: FnvHashSet<InternedString>,
- used_features: FnvHashSet<InternedString>
+ used_features: FnvHashMap<InternedString, attr::StabilityLevel>
}
impl<'a, 'tcx> Checker<'a, 'tcx> {
match *stab {
Some(Stability { level: attr::Unstable, ref feature, ref reason, .. }) => {
- self.used_features.insert(feature.clone());
+ self.used_features.insert(feature.clone(), attr::Unstable);
if !self.active_features.contains(feature) {
let msg = match *reason {
Some(ref r) => format!("use of unstable library feature '{}': {}",
- feature.get(), r.get()),
- None => format!("use of unstable library feature '{}'", feature.get())
+ &feature, &r),
+ None => format!("use of unstable library feature '{}'", &feature)
};
emit_feature_warn(&self.tcx.sess.parse_sess.span_diagnostic,
- feature.get(), span, &msg[]);
+ &feature, span, &msg);
}
}
- Some(..) => {
+ Some(Stability { level, ref feature, .. }) => {
+ self.used_features.insert(feature.clone(), level);
+
// Stable APIs are always ok to call and deprecated APIs are
// handled by a lint.
}
/// Given the list of enabled features that were not language features (i.e. that
/// were expected to be library features), and the list of features used from
/// libraries, identify activated features that don't exist and error about them.
-pub fn check_unused_features(sess: &Session,
- used_lib_features: &FnvHashSet<InternedString>) {
- let ref lib_features = sess.features.borrow().lib_features;
- let mut active_lib_features: FnvHashMap<InternedString, Span>
- = lib_features.clone().into_iter().collect();
-
- for used_feature in used_lib_features {
- active_lib_features.remove(used_feature);
+pub fn check_unused_or_stable_features(sess: &Session,
+ lib_features_used: &FnvHashMap<InternedString,
+ attr::StabilityLevel>) {
+ let ref declared_lib_features = sess.features.borrow().declared_lib_features;
+ let mut remaining_lib_features: FnvHashMap<InternedString, Span>
+ = declared_lib_features.clone().into_iter().collect();
+
+ let stable_msg = "this feature is stable. attribute no longer needed";
+
+ for &span in sess.features.borrow().declared_stable_lang_features.iter() {
+ sess.add_lint(lint::builtin::STABLE_FEATURES,
+ ast::CRATE_NODE_ID,
+ span,
+ stable_msg.to_string());
+ }
+
+ for (used_lib_feature, level) in lib_features_used.iter() {
+ match remaining_lib_features.remove(used_lib_feature) {
+ Some(span) => {
+ if *level == attr::Stable {
+ sess.add_lint(lint::builtin::STABLE_FEATURES,
+ ast::CRATE_NODE_ID,
+ span,
+ stable_msg.to_string());
+ }
+ }
+ None => ( /* used but undeclared, handled during the previous ast visit */ )
+ }
}
- for (_, &span) in &active_lib_features {
+ for (_, &span) in remaining_lib_features.iter() {
sess.add_lint(lint::builtin::UNUSED_FEATURES,
ast::CRATE_NODE_ID,
span,
|o| selcx.evaluate_obligation(o))
}
-#[allow(missing_copy_implementations)]
pub enum OrphanCheckErr<'tcx> {
NoLocalInputType,
UncoveredTy(Ty<'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 parser = Parser::new(&istring);
let mut errored = false;
let err: String = parser.filter_map(|p| {
match p {
-> bool
{
// In general, it's a good idea to cache results, even
- // ambigious ones, to save us some trouble later. But we have
+ // ambiguous ones, to save us some trouble later. But we have
// to be careful not to cache results that could be
// invalidated later by advances in inference. Normally, this
// is not an issue, because any inference variables whose
///
/// - The impl is conditional, in which case we may not have winnowed it out
/// because we don't know if the conditions apply, but the where clause is basically
- /// telling us taht there is some impl, though not necessarily the one we see.
+ /// telling us that there is some impl, though not necessarily the one we see.
///
/// In both cases we prefer to take the where clause, which is
/// essentially harmless. See issue #18453 for more details of
// 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()
- })
- }
_ => {
false
}
use middle::subst::{Substs, VecPerParamSpace};
use middle::infer::InferCtxt;
use middle::ty::{self, Ty, AsPredicate, ToPolyTraitRef};
-use std::collections::HashSet;
use std::fmt;
use std::rc::Rc;
use syntax::ast;
use syntax::codemap::Span;
use util::common::ErrorReported;
+use util::nodemap::FnvHashSet;
use util::ppaux::Repr;
use super::{Obligation, ObligationCause, PredicateObligation,
VtableImpl, VtableParam, VtableImplData};
+struct PredicateSet<'a,'tcx:'a> {
+ tcx: &'a ty::ctxt<'tcx>,
+ set: FnvHashSet<ty::Predicate<'tcx>>,
+}
+
+impl<'a,'tcx> PredicateSet<'a,'tcx> {
+ fn new(tcx: &'a ty::ctxt<'tcx>) -> PredicateSet<'a,'tcx> {
+ PredicateSet { tcx: tcx, set: FnvHashSet() }
+ }
+
+ fn insert(&mut self, pred: &ty::Predicate<'tcx>) -> bool {
+ // We have to be careful here because we want
+ //
+ // for<'a> Foo<&'a int>
+ //
+ // and
+ //
+ // for<'b> Foo<&'b int>
+ //
+ // to be considered equivalent. So normalize all late-bound
+ // regions before we throw things into the underlying set.
+ let normalized_pred = match *pred {
+ ty::Predicate::Trait(ref data) =>
+ ty::Predicate::Trait(ty::anonymize_late_bound_regions(self.tcx, data)),
+
+ ty::Predicate::Equate(ref data) =>
+ ty::Predicate::Equate(ty::anonymize_late_bound_regions(self.tcx, data)),
+
+ ty::Predicate::RegionOutlives(ref data) =>
+ ty::Predicate::RegionOutlives(ty::anonymize_late_bound_regions(self.tcx, data)),
+
+ ty::Predicate::TypeOutlives(ref data) =>
+ ty::Predicate::TypeOutlives(ty::anonymize_late_bound_regions(self.tcx, data)),
+
+ ty::Predicate::Projection(ref data) =>
+ ty::Predicate::Projection(ty::anonymize_late_bound_regions(self.tcx, data)),
+ };
+ self.set.insert(normalized_pred)
+ }
+}
+
///////////////////////////////////////////////////////////////////////////
// `Elaboration` iterator
///////////////////////////////////////////////////////////////////////////
pub struct Elaborator<'cx, 'tcx:'cx> {
tcx: &'cx ty::ctxt<'tcx>,
stack: Vec<StackEntry<'tcx>>,
- visited: HashSet<ty::Predicate<'tcx>>,
+ visited: PredicateSet<'cx,'tcx>,
}
struct StackEntry<'tcx> {
pub fn elaborate_predicates<'cx, 'tcx>(
tcx: &'cx ty::ctxt<'tcx>,
- predicates: Vec<ty::Predicate<'tcx>>)
+ mut predicates: Vec<ty::Predicate<'tcx>>)
-> Elaborator<'cx, 'tcx>
{
- let visited: HashSet<ty::Predicate<'tcx>> =
- predicates.iter()
- .map(|b| (*b).clone())
- .collect();
-
+ let mut visited = PredicateSet::new(tcx);
+ predicates.retain(|pred| visited.insert(pred));
let entry = StackEntry { position: 0, predicates: predicates };
Elaborator { tcx: tcx, stack: vec![entry], visited: visited }
}
// recursion in some cases. One common case is when
// people define `trait Sized: Sized { }` rather than `trait
// Sized { }`.
- predicates.retain(|r| self.visited.insert(r.clone()));
+ predicates.retain(|r| self.visited.insert(r));
self.stack.push(StackEntry { position: 0,
predicates: predicates });
/// compiler's representation for things like `for<'a> Fn(&'a int)`
/// (which would be represented by the type `PolyTraitRef ==
/// Binder<TraitRef>`). Note that when we skolemize, instantiate,
-/// erase, or otherwise "discharge" these bound reons, we change the
+/// erase, or otherwise "discharge" these bound regions, we change the
/// type from `Binder<T>` to just `T` (see
/// e.g. `liberate_late_bound_regions`).
#[derive(Clone, PartialEq, Eq, Hash, Debug)]
}
impl CLike for BuiltinBound {
- fn to_uint(&self) -> uint {
+ fn to_usize(&self) -> uint {
*self as uint
}
- fn from_uint(v: uint) -> BuiltinBound {
+ fn from_usize(v: uint) -> BuiltinBound {
unsafe { mem::transmute(v) }
}
}
fn add_bound_computation(&mut self, computation: &FlagComputation) {
self.add_flags(computation.flags);
- // The types that contributed to `computation` occured within
+ // The types that contributed to `computation` occurred within
// a region binder, so subtract one from the region depth
// within when adding the depth to `self`.
let depth = computation.depth;
"no field named `{}` found in the list of fields `{:?}`",
token::get_name(name),
fields.iter()
- .map(|f| token::get_name(f.name).get().to_string())
+ .map(|f| token::get_name(f.name).to_string())
.collect::<Vec<String>>())[]);
}
pub fn link_name(attrs: &[ast::Attribute]) -> Option<InternedString> {
lang_items::extract(attrs).and_then(|name| {
- $(if name.get() == stringify!($name) {
+ $(if &name[] == stringify!($name) {
Some(InternedString::new(stringify!($sym)))
} else)* {
None
fn visit_foreign_item(&mut self, i: &ast::ForeignItem) {
match lang_items::extract(&i.attrs) {
None => {}
- Some(lang_item) => self.register(lang_item.get(), i.span),
+ Some(lang_item) => self.register(&lang_item, i.span),
}
visit::walk_foreign_item(self, i)
}
use std::env;
use std::dynamic_lib::DynamicLibrary;
use std::collections::HashSet;
+use std::borrow::ToOwned;
use syntax::ast;
use syntax::attr;
-use syntax::codemap::Span;
+use syntax::codemap::{Span, COMMAND_LINE_SP};
use syntax::parse::token;
use syntax::ptr::P;
use syntax::visit;
pub struct PluginRegistrar {
pub fun: PluginRegistrarFun,
- pub args: P<ast::MetaItem>,
+ pub args: Vec<P<ast::MetaItem>>,
}
/// Information about loaded plugins.
visit::walk_crate(&mut loader, krate);
+ for attr in &krate.attrs {
+ if !attr.check_name("plugin") {
+ continue;
+ }
+
+ let plugins = match attr.meta_item_list() {
+ Some(xs) => xs,
+ None => {
+ sess.span_err(attr.span, "malformed plugin attribute");
+ continue;
+ }
+ };
+
+ for plugin in plugins {
+ if plugin.value_str().is_some() {
+ sess.span_err(attr.span, "malformed plugin attribute");
+ continue;
+ }
+
+ let args = plugin.meta_item_list().map(ToOwned::to_owned).unwrap_or_default();
+ loader.load_plugin(CrateOrString::Str(plugin.span, &*plugin.name()),
+ args);
+ }
+ }
+
if let Some(plugins) = addl_plugins {
for plugin in plugins {
- loader.load_plugin(CrateOrString::Str(&plugin),
- None, None, None)
+ loader.load_plugin(CrateOrString::Str(COMMAND_LINE_SP, &plugin), vec![]);
}
}
}
// Parse the attributes relating to macro / plugin loading.
- let mut plugin_attr = None;
let mut macro_selection = Some(HashSet::new()); // None => load all
let mut reexport = HashSet::new();
for attr in &item.attrs {
let mut used = true;
- match attr.name().get() {
+ match &attr.name()[] {
"phase" => {
- self.sess.span_err(attr.span, "#[phase] is deprecated; use \
- #[macro_use], #[plugin], and/or #[no_link]");
+ self.sess.span_err(attr.span, "#[phase] is deprecated");
}
"plugin" => {
- if plugin_attr.is_some() {
- self.sess.span_err(attr.span, "#[plugin] specified multiple times");
- }
- plugin_attr = Some(attr.node.value.clone());
+ self.sess.span_err(attr.span, "#[plugin] on `extern crate` is deprecated");
+ self.sess.span_help(attr.span, &format!("use a crate attribute instead, \
+ i.e. #![plugin({})]",
+ item.ident.as_str())[]);
}
"macro_use" => {
let names = attr.meta_item_list();
}
}
- self.load_plugin(CrateOrString::Krate(item),
- plugin_attr,
- macro_selection,
- Some(reexport))
+ self.load_macros(item, macro_selection, Some(reexport))
}
fn visit_mac(&mut self, _: &ast::Mac) {
}
impl<'a> PluginLoader<'a> {
- pub fn load_plugin<'b>(&mut self,
- c: CrateOrString<'b>,
- plugin_attr: Option<P<ast::MetaItem>>,
+ pub fn load_macros<'b>(&mut self,
+ vi: &ast::Item,
macro_selection: Option<HashSet<token::InternedString>>,
reexport: Option<HashSet<token::InternedString>>) {
- let mut macros = vec![];
- let mut registrar = None;
-
- let load_macros = match (macro_selection.as_ref(), reexport.as_ref()) {
- (Some(sel), Some(re)) => sel.len() != 0 || re.len() != 0,
- _ => true,
- };
- let load_registrar = plugin_attr.is_some();
-
- if let CrateOrString::Krate(vi) = c {
- if load_macros && !self.span_whitelist.contains(&vi.span) {
- self.sess.span_err(vi.span, "an `extern crate` loading macros must be at \
- the crate root");
+ if let (Some(sel), Some(re)) = (macro_selection.as_ref(), reexport.as_ref()) {
+ if sel.is_empty() && re.is_empty() {
+ return;
}
- }
+ }
- if load_macros || load_registrar {
- let pmd = self.reader.read_plugin_metadata(c);
- if load_macros {
- macros = pmd.exported_macros();
- }
- if load_registrar {
- registrar = pmd.plugin_registrar();
- }
+ if !self.span_whitelist.contains(&vi.span) {
+ self.sess.span_err(vi.span, "an `extern crate` loading macros must be at \
+ the crate root");
+ return;
}
- for mut def in macros {
+ let pmd = self.reader.read_plugin_metadata(CrateOrString::Krate(vi));
+
+ for mut def in pmd.exported_macros() {
let name = token::get_ident(def.ident);
def.use_locally = match macro_selection.as_ref() {
None => true,
};
self.plugins.macros.push(def);
}
+ }
+
+ pub fn load_plugin<'b>(&mut self,
+ c: CrateOrString<'b>,
+ args: Vec<P<ast::MetaItem>>) {
+ let registrar = {
+ let pmd = self.reader.read_plugin_metadata(c);
+ pmd.plugin_registrar()
+ };
if let Some((lib, symbol)) = registrar {
let fun = self.dylink_registrar(c, lib, symbol);
self.plugins.registrars.push(PluginRegistrar {
fun: fun,
- args: plugin_attr.unwrap(),
+ args: args,
});
}
}
//!
//! ```rust
//! #![feature(plugin)]
-//!
-//! #[plugin]
-//! extern crate myplugin;
+//! #![plugin(myplugin)]
//! ```
//!
-//! If you don't need the plugin crate available at runtime, use
-//! `#[no_link]` as well.
-//!
//! See [the compiler plugin guide](../../guide-plugin.html)
//! for more examples.
pub sess: &'a Session,
#[doc(hidden)]
- pub args_hidden: Option<P<ast::MetaItem>>,
+ pub args_hidden: Option<Vec<P<ast::MetaItem>>>,
#[doc(hidden)]
pub krate_span: Span,
}
}
- /// Get the `#[plugin]` attribute used to load this plugin.
+ /// Get the plugin's arguments, if any.
///
- /// This gives access to arguments passed via `#[plugin=...]` or
- /// `#[plugin(...)]`.
- pub fn args<'b>(&'b self) -> &'b P<ast::MetaItem> {
+ /// These are specified inside the `plugin` crate attribute as
+ ///
+ /// ```no_run
+ /// #![plugin(my_plugin_name(... args ...))]
+ /// ```
+ pub fn args<'b>(&'b self) -> &'b Vec<P<ast::MetaItem>> {
self.args_hidden.as_ref().expect("args not set")
}
use syntax::parse;
use syntax::parse::token::InternedString;
+use getopts;
use std::collections::HashMap;
use std::collections::hash_map::Entry::{Occupied, Vacant};
-use getopts;
+use std::env;
use std::fmt;
use llvm;
}
#[derive(Clone, PartialEq, Eq)]
-#[allow(missing_copy_implementations)]
pub enum PrintRequest {
FileNames,
Sysroot,
$($opt:ident : $t:ty = ($init:expr, $parse:ident, $desc:expr)),* ,) =>
(
#[derive(Clone)]
- #[allow(missing_copy_implementations)]
pub struct $struct_name { $(pub $opt: $t),* }
pub fn $defaultfn() -> $struct_name {
}
pub fn build_session_options(matches: &getopts::Matches) -> Options {
-
let unparsed_crate_types = matches.opt_strs("crate-type");
let crate_types = parse_crate_types_from_list(unparsed_crate_types)
.unwrap_or_else(|e| early_error(&e[]));
crate_name: crate_name,
alt_std_name: None,
libs: libs,
- unstable_features: UnstableFeatures::Disallow
+ unstable_features: get_unstable_features_setting(),
+ }
+}
+
+pub fn get_unstable_features_setting() -> UnstableFeatures {
+ // Whether this is a feature-staged build, i.e. on the beta or stable channel
+ let disable_unstable_features = option_env!("CFG_DISABLE_UNSTABLE_FEATURES").is_some();
+ // The secret key needed to get through the rustc build itself by
+ // subverting the unstable features lints
+ let bootstrap_secret_key = option_env!("CFG_BOOTSTRAP_KEY");
+ // The matching key to the above, only known by the build system
+ let bootstrap_provided_key = env::var_string("RUSTC_BOOTSTRAP_KEY").ok();
+ match (disable_unstable_features, bootstrap_secret_key, bootstrap_provided_key) {
+ (_, Some(ref s), Some(ref p)) if s == p => UnstableFeatures::Cheat,
+ (true, _, _) => UnstableFeatures::Disallow,
+ (false, _, _) => UnstableFeatures::Default
}
}
///
/// This uses FNV hashing, as described here:
/// http://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function
-#[allow(missing_copy_implementations)]
pub struct FnvHasher(u64);
impl Default for FnvHasher {
match region {
ty::ReScope(_) => prefix.to_string(),
ty::ReEarlyBound(_, _, _, name) => {
- token::get_name(name).get().to_string()
+ token::get_name(name).to_string()
}
ty::ReLateBound(_, br) => bound_region_to_string(cx, prefix, space, br),
ty::ReFree(ref fr) => bound_region_to_string(cx, prefix, space, fr.bound_region),
match ident {
Some(i) => {
s.push(' ');
- s.push_str(token::get_ident(i).get());
+ s.push_str(&token::get_ident(i));
}
_ => { }
}
impl<'tcx> Repr<'tcx> for ast::Name {
fn repr(&self, _tcx: &ctxt) -> String {
- token::get_name(*self).get().to_string()
+ token::get_name(*self).to_string()
}
}
impl<'tcx> UserString<'tcx> for ast::Name {
fn user_string(&self, _tcx: &ctxt) -> String {
- token::get_name(*self).get().to_string()
+ token::get_name(*self).to_string()
}
}
impl<'tcx> Repr<'tcx> for ast::Ident {
fn repr(&self, _tcx: &ctxt) -> String {
- token::get_ident(*self).get().to_string()
+ token::get_ident(*self).to_string()
}
}
}
})
});
- let names: Vec<_> = names.iter().map(|s| s.get()).collect();
+ let names: Vec<_> = names.iter().map(|s| &s[]).collect();
let value_str = unbound_value.user_string(tcx);
if names.len() == 0 {
impl<'tcx> UserString<'tcx> for ast::Ident {
fn user_string(&self, _tcx: &ctxt) -> String {
- token::get_name(self.name).get().to_string()
+ token::get_name(self.name).to_string()
}
}
}
// Snapshots are tokens that should be created/consumed linearly.
-#[allow(missing_copy_implementations)]
pub struct Snapshot {
// Length of the undo log at the time the snapshot was taken.
length: uint,
// macro invocations, namely macro_rules definitions,
// *can* appear as items, even in the expanded crate AST.
- if macro_name(mac).get() == "macro_rules" {
+ if ¯o_name(mac)[] == "macro_rules" {
// Pretty-printing definition to a string strips out
// surface artifacts (currently), such as the span
// information, yielding a content-based hash.
#![feature(staged_api)]
#![staged_api]
#![crate_type = "rlib"]
+#![feature(no_std)]
#![no_std]
#![unstable(feature = "rustc_private")]
};
}
+// This is a no_std crate. So the test code's invocation of #[derive] etc, via
+// bitflags!, will use names from the underlying crates.
+#[cfg(test)]
+mod core {
+ pub use std::{fmt, hash, clone, cmp, marker, option};
+}
+
#[cfg(test)]
#[allow(non_upper_case_globals)]
mod tests {
use self::UseError::*;
use borrowck::*;
+use borrowck::InteriorKind::{InteriorElement, InteriorField};
use rustc::middle::expr_use_visitor as euv;
use rustc::middle::mem_categorization as mc;
use rustc::middle::region;
self.check_if_assigned_path_is_moved(id, span,
use_kind, lp_base);
}
- LpExtend(ref lp_base, _, LpInterior(_)) => {
+ LpExtend(ref lp_base, _, LpInterior(InteriorField(_))) => {
// assigning to `P.f` is ok if assigning to `P` is ok
self.check_if_assigned_path_is_moved(id, span,
use_kind, lp_base);
}
+ LpExtend(ref lp_base, _, LpInterior(InteriorElement(..))) |
LpExtend(ref lp_base, _, LpDeref(_)) => {
- // assigning to `(*P)` requires that `P` be initialized
- self.check_if_path_is_moved(id, span,
- use_kind, lp_base);
+ // assigning to `P[i]` requires `P` is initialized
+ // assigning to `(*P)` requires `P` is initialized
+ self.check_if_path_is_moved(id, span, use_kind, lp_base);
}
}
}
//! which contains an empty set of actions, still has a purpose---it
//! prevents moves from `LV`. I chose not to make `MOVE` a fourth kind of
//! action because that would imply that sometimes moves are permitted
-//! from restrictived values, which is not the case.
+//! from restricted values, which is not the case.
//!
//! #### Example
//!
use self::Fragment::*;
+use borrowck::InteriorKind::{InteriorField, InteriorElement};
use borrowck::{LoanPath};
use borrowck::LoanPathKind::{LpVar, LpUpvar, LpDowncast, LpExtend};
use borrowck::LoanPathElem::{LpDeref, LpInterior};
LpExtend(_, _, LpDeref(mc::Implicit(..))) |
LpExtend(_, _, LpDeref(mc::BorrowedPtr(..))) => {}
- // FIXME(pnkfelix): LV[j] should be tracked, at least in the
+ // FIXME (pnkfelix): LV[j] should be tracked, at least in the
// sense of we will track the remaining drop obligation of the
// rest of the array.
//
- // LV[j] is not tracked precisely
- LpExtend(_, _, LpInterior(mc::InteriorElement(_))) => {
+ // Well, either that or LV[j] should be made illegal.
+ // But even then, we will need to deal with destructuring
+ // bind.
+ //
+ // Anyway, for now: LV[j] is not tracked precisely
+ LpExtend(_, _, LpInterior(InteriorElement(..))) => {
let mp = this.move_path(tcx, lp.clone());
gathered_fragments.push(AllButOneFrom(mp));
}
// field access LV.x and tuple access LV#k are the cases
// we are interested in
LpExtend(ref loan_parent, mc,
- LpInterior(mc::InteriorField(ref field_name))) => {
+ LpInterior(InteriorField(ref field_name))) => {
let enum_variant_info = match loan_parent.kind {
LpDowncast(ref loan_parent_2, variant_def_id) =>
Some((variant_def_id, loan_parent_2.clone())),
LpVar(..) | LpUpvar(..) | LpExtend(..) => enum_variant_did,
};
- let loan_path_elem = LpInterior(mc::InteriorField(new_field_name));
+ let loan_path_elem = LpInterior(InteriorField(new_field_name));
let new_lp_type = match new_field_name {
mc::NamedField(ast_name) =>
ty::named_element_ty(tcx, parent.to_type(), ast_name, opt_variant_did),
use borrowck::move_data::*;
use rustc::middle::expr_use_visitor as euv;
use rustc::middle::mem_categorization as mc;
+use rustc::middle::mem_categorization::Typer;
+use rustc::middle::mem_categorization::InteriorOffsetKind as Kind;
use rustc::middle::ty;
use rustc::util::ppaux::Repr;
use std::rc::Rc;
mode);
}
+// (keep in sync with move_error::report_cannot_move_out_of )
fn check_and_get_illegal_move_origin<'a, 'tcx>(bccx: &BorrowckCtxt<'a, 'tcx>,
cmt: &mc::cmt<'tcx>)
-> Option<mc::cmt<'tcx>> {
}
mc::cat_downcast(ref b, _) |
- mc::cat_interior(ref b, _) => {
+ mc::cat_interior(ref b, mc::InteriorField(_)) |
+ mc::cat_interior(ref b, mc::InteriorElement(Kind::Pattern, _)) => {
match b.ty.sty {
ty::ty_struct(did, _) | ty::ty_enum(did, _) => {
if ty::has_dtor(bccx.tcx, did) {
}
}
+ mc::cat_interior(_, mc::InteriorElement(Kind::Index, _)) => {
+ // Forbid move of arr[i] for arr: [T; 3]; see RFC 533.
+ Some(cmt.clone())
+ }
+
mc::cat_deref(ref b, _, mc::Unique) => {
check_and_get_illegal_move_origin(bccx, b)
}
use borrowck::BorrowckCtxt;
use rustc::middle::mem_categorization as mc;
+use rustc::middle::mem_categorization::Typer;
+use rustc::middle::mem_categorization::InteriorOffsetKind as Kind;
use rustc::middle::ty;
use rustc::util::ppaux::UserString;
use std::cell::RefCell;
}
}
+// (keep in sync with gather_moves::check_and_get_illegal_move_origin )
fn report_cannot_move_out_of<'a, 'tcx>(bccx: &BorrowckCtxt<'a, 'tcx>,
move_from: mc::cmt<'tcx>) {
match move_from.cat {
move_from.descriptive_string(bccx.tcx))[]);
}
+ mc::cat_interior(ref b, mc::InteriorElement(Kind::Index, _)) => {
+ let expr = bccx.tcx.map.expect_expr(move_from.id);
+ if let ast::ExprIndex(..) = expr.node {
+ bccx.span_err(move_from.span,
+ &format!("cannot move out of type `{}`, \
+ a non-copy fixed-size array",
+ b.ty.user_string(bccx.tcx))[]);
+ }
+ }
+
mc::cat_downcast(ref b, _) |
- mc::cat_interior(ref b, _) => {
+ mc::cat_interior(ref b, mc::InteriorField(_)) => {
match b.ty.sty {
ty::ty_struct(did, _) |
ty::ty_enum(did, _) if ty::has_dtor(bccx.tcx, did) => {
use rustc::util::ppaux::Repr;
use syntax::codemap::Span;
+use borrowck::ToInteriorKind;
+
use std::rc::Rc;
#[derive(Debug)]
// the memory, so no additional restrictions are
// needed.
let result = self.restrict(cmt_base);
- self.extend(result, &cmt, LpInterior(i))
+ self.extend(result, &cmt, LpInterior(i.cleaned()))
}
mc::cat_static_item(..) => {
pub use self::AliasableViolationKind::*;
pub use self::MovedValueUseKind::*;
+use self::InteriorKind::*;
+
use rustc::middle::cfg;
use rustc::middle::dataflow::DataFlowContext;
use rustc::middle::dataflow::BitwiseOperator;
// b2b39e8700e37ad32b486b9a8409b50a8a53aa51#commitcomment-7892003
static DOWNCAST_PRINTED_OPERATOR : &'static str = " as ";
+// A local, "cleaned" version of `mc::InteriorKind` that drops
+// information that is not relevant to loan-path analysis. (In
+// particular, the distinction between how precisely a array-element
+// is tracked is irrelevant here.)
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
+pub enum InteriorKind {
+ InteriorField(mc::FieldName),
+ InteriorElement(mc::ElementKind),
+}
+
+trait ToInteriorKind { fn cleaned(self) -> InteriorKind; }
+impl ToInteriorKind for mc::InteriorKind {
+ fn cleaned(self) -> InteriorKind {
+ match self {
+ mc::InteriorField(name) => InteriorField(name),
+ mc::InteriorElement(_, elem_kind) => InteriorElement(elem_kind),
+ }
+ }
+}
+
#[derive(Copy, PartialEq, Eq, Hash, Debug)]
pub enum LoanPathElem {
LpDeref(mc::PointerKind), // `*LV` in doc.rs
- LpInterior(mc::InteriorKind) // `LV.f` in doc.rs
+ LpInterior(InteriorKind), // `LV.f` in doc.rs
}
pub fn closure_to_block(closure_id: ast::NodeId,
mc::cat_interior(ref cmt_base, ik) => {
opt_loan_path(cmt_base).map(|lp| {
- new_lp(LpExtend(lp, cmt.mutbl, LpInterior(ik)))
+ new_lp(LpExtend(lp, cmt.mutbl, LpInterior(ik.cleaned())))
})
}
// Errors that can occur
#[derive(PartialEq)]
-#[allow(missing_copy_implementations)]
pub enum bckerr_code {
err_mutbl,
err_out_of_scope(ty::Region, ty::Region), // superscope, subscope
match loan_path.kind {
LpUpvar(ty::UpvarId{ var_id: id, closure_expr_id: _ }) |
LpVar(id) => {
- out.push_str(ty::local_var_name_str(self.tcx, id).get());
+ out.push_str(&ty::local_var_name_str(self.tcx, id));
}
LpDowncast(ref lp_base, variant_def_id) => {
}
- LpExtend(ref lp_base, _, LpInterior(mc::InteriorField(fname))) => {
+ LpExtend(ref lp_base, _, LpInterior(InteriorField(fname))) => {
self.append_autoderefd_loan_path_to_string(&**lp_base, out);
match fname {
mc::NamedField(fname) => {
out.push('.');
- out.push_str(token::get_name(fname).get());
+ out.push_str(&token::get_name(fname));
}
mc::PositionalField(idx) => {
out.push('.');
}
}
- LpExtend(ref lp_base, _, LpInterior(mc::InteriorElement(_))) => {
+ LpExtend(ref lp_base, _, LpInterior(InteriorElement(..))) => {
self.append_autoderefd_loan_path_to_string(&**lp_base, out);
out.push_str("[..]");
}
}
}
+impl<'tcx> Repr<'tcx> for InteriorKind {
+ fn repr(&self, _tcx: &ty::ctxt<'tcx>) -> String {
+ match *self {
+ InteriorField(mc::NamedField(fld)) =>
+ format!("{}", token::get_name(fld)),
+ InteriorField(mc::PositionalField(i)) => format!("#{}", i),
+ InteriorElement(..) => "[]".to_string(),
+ }
+ }
+}
+
impl<'tcx> Repr<'tcx> for Loan<'tcx> {
fn repr(&self, tcx: &ty::ctxt<'tcx>) -> String {
format!("Loan_{}({}, {:?}, {:?}-{:?}, {})",
use rustc::middle::dataflow::BitwiseOperator;
use rustc::middle::dataflow::DataFlowOperator;
use rustc::middle::expr_use_visitor as euv;
-use rustc::middle::mem_categorization as mc;
use rustc::middle::ty;
use rustc::util::nodemap::{FnvHashMap, NodeSet};
use rustc::util::ppaux::Repr;
LpVar(_) | LpUpvar(_) => {
true
}
- LpExtend(_, _, LpInterior(mc::InteriorElement(_))) => {
- // Paths involving element accesses do not refer to a unique
+ LpExtend(_, _, LpInterior(InteriorKind::InteriorElement(..))) => {
+ // Paths involving element accesses a[i] do not refer to a unique
// location, as there is no accurate tracking of the indices.
+ //
+ // (Paths involving element accesses via slice pattern bindings
+ // can in principle be tracked precisely, but that is future
+ // work. For now, continue claiming that they are imprecise.)
false
}
LpDowncast(ref lp_base, _) |
-// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
use rustc_trans::trans;
use rustc_typeck as typeck;
use rustc_privacy;
+use super::Compilation;
use serialize::json;
let state = $make_state;
(control.$point.callback)(state);
}
- if control.$point.stop {
+ if control.$point.stop == Compilation::Stop {
return;
}
})}
/// 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.
+/// collected during compilation.
///
/// This is a somewhat higher level controller than a Session - the Session
/// controls what happens in each phase, whereas the CompileController controls
}
pub struct PhaseController<'a> {
- pub stop: bool,
+ pub stop: Compilation,
pub callback: Box<Fn(CompileState) -> () + 'a>,
}
impl<'a> PhaseController<'a> {
pub fn basic() -> PhaseController<'a> {
PhaseController {
- stop: false,
+ stop: Compilation::Continue,
callback: box |_| {},
}
}
time(time_passes, "stability checking", (), |_|
stability::check_unstable_api_usage(&ty_cx));
- time(time_passes, "unused feature checking", (), |_|
- stability::check_unused_features(
+ time(time_passes, "unused lib feature checking", (), |_|
+ stability::check_unused_or_stable_features(
&ty_cx.sess, lib_features_used));
time(time_passes, "lint checking", (), |_|
// If a crate name is present, we use it as the link name
let stem = sess.opts.crate_name.clone().or_else(|| {
- attr::find_crate_name(attrs).map(|n| n.get().to_string())
+ attr::find_crate_name(attrs).map(|n| n.to_string())
}).unwrap_or(input.filestem());
OutputFilenames {
-// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// 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.
//
pub use syntax::diagnostic;
use driver::CompileController;
+use pretty::{PpMode, UserIdentifiedItem};
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::session::config::{Input, PrintRequest};
use rustc::lint::Lint;
use rustc::lint;
use rustc::metadata;
-use rustc::metadata::creader::CrateOrString::Str;
use rustc::util::common::time;
use std::cmp::Ordering::Equal;
pub mod driver;
pub mod pretty;
+
+static BUG_REPORT_URL: &'static str =
+ "http://doc.rust-lang.org/complement-bugreport.html";
+
+
pub fn run(args: Vec<String>) -> int {
- monitor(move || run_compiler(&args));
+ monitor(move || run_compiler(&args, &mut RustcDefaultCalls));
0
}
-static BUG_REPORT_URL: &'static str =
- "http://doc.rust-lang.org/complement-bugreport.html";
+// Parse args and run the compiler. This is the primary entry point for rustc.
+// See comments on CompilerCalls below for details about the callbacks argument.
+pub fn run_compiler<'a>(args: &[String],
+ callbacks: &mut CompilerCalls<'a>) {
+ macro_rules! do_or_return {($expr: expr) => {
+ match $expr {
+ Compilation::Stop => return,
+ Compilation::Continue => {}
+ }
+ }}
-fn run_compiler(args: &[String]) {
let matches = match handle_options(args.to_vec()) {
Some(matches) => matches,
None => return
};
let descriptions = diagnostics_registry();
- match matches.opt_str("explain") {
- Some(ref code) => {
- match descriptions.find_description(&code[]) {
- Some(ref description) => {
- println!("{}", description);
- }
- None => {
- early_error(&format!("no extended information for {}", code)[]);
- }
- }
- return;
- },
- None => ()
- }
+
+ do_or_return!(callbacks.early_callback(&matches, &descriptions));
let sopts = config::build_session_options(&matches);
- let odir = matches.opt_str("out-dir").map(|o| Path::new(o));
- let ofile = matches.opt_str("o").map(|o| Path::new(o));
- let (input, input_file_path) = match matches.free.len() {
- 0 => {
- if sopts.describe_lints {
- let mut ls = lint::LintStore::new();
- ls.register_builtin(None);
- describe_lints(&ls, false);
- return;
- }
- let sess = build_session(sopts, None, descriptions);
- if print_crate_info(&sess, None, &odir, &ofile) {
- return;
- }
- early_error("no input filename given");
- }
- 1 => {
- let ifile = &matches.free[0][];
- if ifile == "-" {
- let contents = old_io::stdin().read_to_end().unwrap();
- let src = String::from_utf8(contents).unwrap();
- (Input::Str(src), None)
- } else {
- (Input::File(Path::new(ifile)), Some(Path::new(ifile)))
- }
+
+ let (odir, ofile) = make_output(&matches);
+ let (input, input_file_path) = match make_input(&matches.free[]) {
+ Some((input, input_file_path)) => callbacks.some_input(input, input_file_path),
+ None => match callbacks.no_input(&matches, &sopts, &odir, &ofile, &descriptions) {
+ Some((input, input_file_path)) => (input, input_file_path),
+ None => return
}
- _ => early_error("multiple input filenames provided")
};
- let mut sopts = sopts;
- sopts.unstable_features = get_unstable_features_setting();
-
let mut sess = build_session(sopts, input_file_path, descriptions);
-
- let cfg = config::build_configuration(&sess);
- if print_crate_info(&sess, Some(&input), &odir, &ofile) {
- return
+ if sess.unstable_options() {
+ sess.opts.show_span = matches.opt_str("show-span");
}
+ let cfg = config::build_configuration(&sess);
- let pretty = if sess.opts.debugging_opts.unstable_options {
- matches.opt_default("pretty", "normal").map(|a| {
- // stable pretty-print variants only
- pretty::parse_pretty(&sess, &a, false)
- })
- } else {
- None
- };
- let pretty = if pretty.is_none() &&
- sess.unstable_options() {
- matches.opt_str("xpretty").map(|a| {
- // extended with unstable pretty-print variants
- pretty::parse_pretty(&sess, &a, true)
- })
- } else {
- pretty
- };
+ do_or_return!(callbacks.late_callback(&matches, &sess, &input, &odir, &ofile));
- match pretty.into_iter().next() {
+ // It is somewhat unfortunate that this is hardwired in - this is forced by
+ // the fact that pretty_print_input requires the session by value.
+ let pretty = callbacks.parse_pretty(&sess, &matches);
+ match pretty {
Some((ppm, opt_uii)) => {
pretty::pretty_print_input(sess, cfg, &input, ppm, opt_uii, ofile);
return;
None => {/* continue */ }
}
- if sess.unstable_options() {
- sess.opts.show_span = matches.opt_str("show-span");
- }
+ let plugins = sess.opts.debugging_opts.extra_plugins.clone();
+ let control = callbacks.build_controller(&sess);
+ driver::compile_input(sess, cfg, &input, &odir, &ofile, Some(plugins), control);
+}
- let r = matches.opt_strs("Z");
- if r.contains(&("ls".to_string())) {
- match input {
- Input::File(ref ifile) => {
- let mut stdout = old_io::stdout();
- list_metadata(&sess, &(*ifile), &mut stdout).unwrap();
- }
- Input::Str(_) => {
- early_error("cannot list metadata for stdin");
- }
+// Extract output directory and file from matches.
+fn make_output(matches: &getopts::Matches) -> (Option<Path>, Option<Path>) {
+ let odir = matches.opt_str("out-dir").map(|o| Path::new(o));
+ let ofile = matches.opt_str("o").map(|o| Path::new(o));
+ (odir, ofile)
+}
+
+// Extract input (string or file and optional path) from matches.
+fn make_input(free_matches: &[String]) -> Option<(Input, Option<Path>)> {
+ if free_matches.len() == 1 {
+ let ifile = &free_matches[0][];
+ if ifile == "-" {
+ let contents = old_io::stdin().read_to_end().unwrap();
+ let src = String::from_utf8(contents).unwrap();
+ Some((Input::Str(src), None))
+ } else {
+ Some((Input::File(Path::new(ifile)), Some(Path::new(ifile))))
}
- return;
+ } else {
+ None
}
+}
- let plugins = sess.opts.debugging_opts.extra_plugins.clone();
- let control = build_controller(&sess);
- driver::compile_input(sess, cfg, &input, &odir, &ofile, Some(plugins), control);
+// Whether to stop or continue compilation.
+#[derive(Copy, Debug, Eq, PartialEq)]
+pub enum Compilation {
+ Stop,
+ Continue,
}
-fn build_controller<'a>(sess: &Session) -> CompileController<'a> {
- let mut control = CompileController::basic();
+impl Compilation {
+ pub fn and_then<F: FnOnce() -> Compilation>(self, next: F) -> Compilation {
+ match self {
+ Compilation::Stop => Compilation::Stop,
+ Compilation::Continue => next()
+ }
+ }
+}
- if sess.opts.parse_only ||
- sess.opts.show_span.is_some() ||
- sess.opts.debugging_opts.ast_json_noexpand {
- control.after_parse.stop = true;
+// A trait for customising the compilation process. Offers a number of hooks for
+// executing custom code or customising input.
+pub trait CompilerCalls<'a> {
+ // Hook for a callback early in the process of handling arguments. This will
+ // be called straight after options have been parsed but before anything
+ // else (e.g., selecting input and output).
+ fn early_callback(&mut self,
+ &getopts::Matches,
+ &diagnostics::registry::Registry)
+ -> Compilation;
+
+ // Hook for a callback late in the process of handling arguments. This will
+ // be called just before actual compilation starts (and before build_controller
+ // is called), after all arguments etc. have been completely handled.
+ fn late_callback(&mut self,
+ &getopts::Matches,
+ &Session,
+ &Input,
+ &Option<Path>,
+ &Option<Path>)
+ -> Compilation;
+
+ // Called after we extract the input from the arguments. Gives the implementer
+ // an opportunity to change the inputs or to add some custom input handling.
+ // The default behaviour is to simply pass through the inputs.
+ fn some_input(&mut self, input: Input, input_path: Option<Path>) -> (Input, Option<Path>) {
+ (input, input_path)
}
- if sess.opts.no_analysis || sess.opts.debugging_opts.ast_json {
- control.after_write_deps.stop = true;
+ // Called after we extract the input from the arguments if there is no valid
+ // input. Gives the implementer an opportunity to supply alternate input (by
+ // returning a Some value) or to add custom behaviour for this error such as
+ // emitting error messages. Returning None will cause compilation to stop
+ // at this point.
+ fn no_input(&mut self,
+ &getopts::Matches,
+ &config::Options,
+ &Option<Path>,
+ &Option<Path>,
+ &diagnostics::registry::Registry)
+ -> Option<(Input, Option<Path>)>;
+
+ // Parse pretty printing information from the arguments. The implementer can
+ // choose to ignore this (the default will return None) which will skip pretty
+ // printing. If you do want to pretty print, it is recommended to use the
+ // implementation of this method from RustcDefaultCalls.
+ // FIXME, this is a terrible bit of API. Parsing of pretty printing stuff
+ // should be done as part of the framework and the implementor should customise
+ // handling of it. However, that is not possible atm because pretty printing
+ // essentially goes off and takes another path through the compiler which
+ // means the session is either moved or not depending on what parse_pretty
+ // returns (we could fix this by cloning, but it's another hack). The proper
+ // solution is to handle pretty printing as if it were a compiler extension,
+ // extending CompileController to make this work (see for example the treatment
+ // of save-analysis in RustcDefaultCalls::build_controller).
+ fn parse_pretty(&mut self,
+ _sess: &Session,
+ _matches: &getopts::Matches)
+ -> Option<(PpMode, Option<UserIdentifiedItem>)> {
+ None
}
- if sess.opts.no_trans {
- control.after_analysis.stop = true;
+ // Create a CompilController struct for controlling the behaviour of compilation.
+ fn build_controller(&mut self, &Session) -> CompileController<'a>;
+}
+
+// CompilerCalls instance for a regular rustc build.
+#[derive(Copy)]
+pub struct RustcDefaultCalls;
+
+impl<'a> CompilerCalls<'a> for RustcDefaultCalls {
+ fn early_callback(&mut self,
+ matches: &getopts::Matches,
+ descriptions: &diagnostics::registry::Registry)
+ -> Compilation {
+ match matches.opt_str("explain") {
+ Some(ref code) => {
+ match descriptions.find_description(&code[]) {
+ Some(ref description) => {
+ println!("{}", description);
+ }
+ None => {
+ early_error(&format!("no extended information for {}", code)[]);
+ }
+ }
+ return Compilation::Stop;
+ },
+ None => ()
+ }
+
+ return Compilation::Continue;
}
- if !sess.opts.output_types.iter().any(|&i| i == config::OutputTypeExe) {
- control.after_llvm.stop = true;
+ fn no_input(&mut self,
+ matches: &getopts::Matches,
+ sopts: &config::Options,
+ odir: &Option<Path>,
+ ofile: &Option<Path>,
+ descriptions: &diagnostics::registry::Registry)
+ -> Option<(Input, Option<Path>)> {
+ match matches.free.len() {
+ 0 => {
+ if sopts.describe_lints {
+ let mut ls = lint::LintStore::new();
+ ls.register_builtin(None);
+ describe_lints(&ls, false);
+ return None;
+ }
+ let sess = build_session(sopts.clone(), None, descriptions.clone());
+ let should_stop = RustcDefaultCalls::print_crate_info(&sess, None, odir, ofile);
+ if should_stop == Compilation::Stop {
+ return None;
+ }
+ early_error("no input filename given");
+ }
+ 1 => panic!("make_input should have provided valid inputs"),
+ _ => early_error("multiple input filenames provided")
+ }
+
+ None
}
- 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));
+ fn parse_pretty(&mut self,
+ sess: &Session,
+ matches: &getopts::Matches)
+ -> Option<(PpMode, Option<UserIdentifiedItem>)> {
+ let pretty = if sess.opts.debugging_opts.unstable_options {
+ matches.opt_default("pretty", "normal").map(|a| {
+ // stable pretty-print variants only
+ pretty::parse_pretty(sess, &a, false)
+ })
+ } else {
+ None
};
- control.make_glob_map = resolve::MakeGlobMap::Yes;
+ if pretty.is_none() && sess.unstable_options() {
+ matches.opt_str("xpretty").map(|a| {
+ // extended with unstable pretty-print variants
+ pretty::parse_pretty(sess, &a, true)
+ })
+ } else {
+ pretty
+ }
+ }
+
+ fn late_callback(&mut self,
+ matches: &getopts::Matches,
+ sess: &Session,
+ input: &Input,
+ odir: &Option<Path>,
+ ofile: &Option<Path>)
+ -> Compilation {
+ RustcDefaultCalls::print_crate_info(sess, Some(input), odir, ofile).and_then(
+ || RustcDefaultCalls::list_metadata(sess, matches, input))
}
- control
+ fn build_controller(&mut self, 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 = Compilation::Stop;
+ }
+
+ if sess.opts.no_analysis || sess.opts.debugging_opts.ast_json {
+ control.after_write_deps.stop = Compilation::Stop;
+ }
+
+ if sess.opts.no_trans {
+ control.after_analysis.stop = Compilation::Stop;
+ }
+
+ if !sess.opts.output_types.iter().any(|&i| i == config::OutputTypeExe) {
+ control.after_llvm.stop = Compilation::Stop;
+ }
+
+ 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 {
- // Whether this is a feature-staged build, i.e. on the beta or stable channel
- let disable_unstable_features = option_env!("CFG_DISABLE_UNSTABLE_FEATURES").is_some();
- // The secret key needed to get through the rustc build itself by
- // subverting the unstable features lints
- let bootstrap_secret_key = option_env!("CFG_BOOTSTRAP_KEY");
- // The matching key to the above, only known by the build system
- let bootstrap_provided_key = env::var_string("RUSTC_BOOTSTRAP_KEY").ok();
- match (disable_unstable_features, bootstrap_secret_key, bootstrap_provided_key) {
- (_, Some(ref s), Some(ref p)) if s == p => UnstableFeatures::Cheat,
- (true, _, _) => UnstableFeatures::Disallow,
- (false, _, _) => UnstableFeatures::Default
+impl RustcDefaultCalls {
+ pub fn list_metadata(sess: &Session,
+ matches: &getopts::Matches,
+ input: &Input)
+ -> Compilation {
+ let r = matches.opt_strs("Z");
+ if r.contains(&("ls".to_string())) {
+ match input {
+ &Input::File(ref ifile) => {
+ let mut stdout = old_io::stdout();
+ let path = &(*ifile);
+ metadata::loader::list_file_metadata(sess.target.target.options.is_like_osx,
+ path,
+ &mut stdout).unwrap();
+ }
+ &Input::Str(_) => {
+ early_error("cannot list metadata for stdin");
+ }
+ }
+ return Compilation::Stop;
+ }
+
+ return Compilation::Continue;
+ }
+
+
+ fn print_crate_info(sess: &Session,
+ input: Option<&Input>,
+ odir: &Option<Path>,
+ ofile: &Option<Path>)
+ -> Compilation {
+ if sess.opts.prints.len() == 0 {
+ return Compilation::Continue;
+ }
+
+ let attrs = input.map(|input| parse_crate_attrs(sess, input));
+ for req in &sess.opts.prints {
+ match *req {
+ PrintRequest::Sysroot => println!("{}", sess.sysroot().display()),
+ PrintRequest::FileNames |
+ PrintRequest::CrateName => {
+ let input = match input {
+ Some(input) => input,
+ None => early_error("no input file provided"),
+ };
+ let attrs = attrs.as_ref().unwrap();
+ let t_outputs = driver::build_output_filenames(input,
+ odir,
+ ofile,
+ attrs,
+ sess);
+ let id = link::find_crate_name(Some(sess),
+ attrs,
+ input);
+ if *req == PrintRequest::CrateName {
+ println!("{}", id);
+ continue
+ }
+ let crate_types = driver::collect_crate_types(sess, attrs);
+ let metadata = driver::collect_crate_metadata(sess, attrs);
+ *sess.crate_metadata.borrow_mut() = metadata;
+ for &style in &crate_types {
+ let fname = link::filename_for_input(sess,
+ style,
+ &id,
+ &t_outputs.with_extension(""));
+ println!("{}", fname.filename_display());
+ }
+ }
+ }
+ }
+ return Compilation::Stop;
}
}
Some(matches)
}
-fn print_crate_info(sess: &Session,
- input: Option<&Input>,
- odir: &Option<Path>,
- ofile: &Option<Path>)
- -> bool {
- if sess.opts.prints.len() == 0 { return false }
-
- let attrs = input.map(|input| parse_crate_attrs(sess, input));
- for req in &sess.opts.prints {
- match *req {
- PrintRequest::Sysroot => println!("{}", sess.sysroot().display()),
- PrintRequest::FileNames |
- PrintRequest::CrateName => {
- let input = match input {
- Some(input) => input,
- None => early_error("no input file provided"),
- };
- let attrs = attrs.as_ref().unwrap();
- let t_outputs = driver::build_output_filenames(input,
- odir,
- ofile,
- attrs,
- sess);
- let id = link::find_crate_name(Some(sess), attrs,
- input);
- if *req == PrintRequest::CrateName {
- println!("{}", id);
- continue
- }
- let crate_types = driver::collect_crate_types(sess, attrs);
- let metadata = driver::collect_crate_metadata(sess, attrs);
- *sess.crate_metadata.borrow_mut() = metadata;
- for &style in &crate_types {
- let fname = link::filename_for_input(sess, style,
- &id,
- &t_outputs.with_extension(""));
- println!("{}", fname.filename_display());
- }
- }
- }
- }
- return true;
-}
-
fn parse_crate_attrs(sess: &Session, input: &Input) ->
Vec<ast::Attribute> {
let result = match *input {
result.into_iter().collect()
}
-pub fn list_metadata(sess: &Session, path: &Path,
- out: &mut old_io::Writer) -> old_io::IoResult<()> {
- metadata::loader::list_file_metadata(sess.target.target.options.is_like_osx, path, out)
-}
-
/// Run a procedure which will detect panics in the compiler and print nicer
/// error messages rather than just failing the test.
///
sub: &'a [RH<'a>]
}
-static EMPTY_SOURCE_STR: &'static str = "#![no_std]";
+static EMPTY_SOURCE_STR: &'static str = "#![feature(no_std)] #![no_std]";
struct ExpectErrorEmitter {
messages: Vec<String>
}
// Opaque pointer types
-#[allow(missing_copy_implementations)]
pub enum Module_opaque {}
pub type ModuleRef = *mut Module_opaque;
-#[allow(missing_copy_implementations)]
pub enum Context_opaque {}
pub type ContextRef = *mut Context_opaque;
-#[allow(missing_copy_implementations)]
pub enum Type_opaque {}
pub type TypeRef = *mut Type_opaque;
-#[allow(missing_copy_implementations)]
pub enum Value_opaque {}
pub type ValueRef = *mut Value_opaque;
-#[allow(missing_copy_implementations)]
pub enum Metadata_opaque {}
pub type MetadataRef = *mut Metadata_opaque;
-#[allow(missing_copy_implementations)]
pub enum BasicBlock_opaque {}
pub type BasicBlockRef = *mut BasicBlock_opaque;
-#[allow(missing_copy_implementations)]
pub enum Builder_opaque {}
pub type BuilderRef = *mut Builder_opaque;
-#[allow(missing_copy_implementations)]
pub enum ExecutionEngine_opaque {}
pub type ExecutionEngineRef = *mut ExecutionEngine_opaque;
-#[allow(missing_copy_implementations)]
pub enum RustJITMemoryManager_opaque {}
pub type RustJITMemoryManagerRef = *mut RustJITMemoryManager_opaque;
-#[allow(missing_copy_implementations)]
pub enum MemoryBuffer_opaque {}
pub type MemoryBufferRef = *mut MemoryBuffer_opaque;
-#[allow(missing_copy_implementations)]
pub enum PassManager_opaque {}
pub type PassManagerRef = *mut PassManager_opaque;
-#[allow(missing_copy_implementations)]
pub enum PassManagerBuilder_opaque {}
pub type PassManagerBuilderRef = *mut PassManagerBuilder_opaque;
-#[allow(missing_copy_implementations)]
pub enum Use_opaque {}
pub type UseRef = *mut Use_opaque;
-#[allow(missing_copy_implementations)]
pub enum TargetData_opaque {}
pub type TargetDataRef = *mut TargetData_opaque;
-#[allow(missing_copy_implementations)]
pub enum ObjectFile_opaque {}
pub type ObjectFileRef = *mut ObjectFile_opaque;
-#[allow(missing_copy_implementations)]
pub enum SectionIterator_opaque {}
pub type SectionIteratorRef = *mut SectionIterator_opaque;
-#[allow(missing_copy_implementations)]
pub enum Pass_opaque {}
pub type PassRef = *mut Pass_opaque;
-#[allow(missing_copy_implementations)]
pub enum TargetMachine_opaque {}
pub type TargetMachineRef = *mut TargetMachine_opaque;
-#[allow(missing_copy_implementations)]
pub enum Archive_opaque {}
pub type ArchiveRef = *mut Archive_opaque;
-#[allow(missing_copy_implementations)]
pub enum Twine_opaque {}
pub type TwineRef = *mut Twine_opaque;
-#[allow(missing_copy_implementations)]
pub enum DiagnosticInfo_opaque {}
pub type DiagnosticInfoRef = *mut DiagnosticInfo_opaque;
-#[allow(missing_copy_implementations)]
pub enum DebugLoc_opaque {}
pub type DebugLocRef = *mut DebugLoc_opaque;
-#[allow(missing_copy_implementations)]
pub enum SMDiagnostic_opaque {}
pub type SMDiagnosticRef = *mut SMDiagnostic_opaque;
pub use self::DIDescriptorFlags::*;
use super::{MetadataRef};
- #[allow(missing_copy_implementations)]
pub enum DIBuilder_opaque {}
pub type DIBuilderRef = *mut DIBuilder_opaque;
}
}
-#[allow(missing_copy_implementations)]
pub enum RustString_opaque {}
pub type RustStringRef = *mut RustString_opaque;
type RustStringRepr = *mut RefCell<Vec<u8>>;
ViewPathSimple(binding, ref full_path) => {
let source_name =
full_path.segments.last().unwrap().identifier.name;
- if token::get_name(source_name).get() == "mod" ||
- token::get_name(source_name).get() == "self" {
+ if &token::get_name(source_name)[] == "mod" ||
+ &token::get_name(source_name)[] == "self" {
self.resolve_error(view_path.span,
"`self` imports are only allowed within a { } list");
}
self.handle_external_def(def,
def_visibility,
&*child_name_bindings,
- token::get_name(name).get(),
+ &token::get_name(name),
name,
root);
}
E0254, // import conflicts with imported crate in this module
E0255, // import conflicts with value in this module
E0256, // import conflicts with type in this module
- E0257, // inherent implementations are only allowen on types defined in the current module
+ E0257, // inherent implementations are only allowed on types defined in the current module
E0258, // import conflicts with existing submodule
E0259, // an extern crate has already been imported into this module
E0260 // name conflicts with an external crate that has been imported into this module
} else {
result.push_str("::")
}
- result.push_str(token::get_name(*name).get());
+ result.push_str(&token::get_name(*name));
};
result
}
-> String {
match subclass {
SingleImport(_, source) => {
- token::get_name(source).get().to_string()
+ token::get_name(source).to_string()
}
GlobImport => "*".to_string()
}
debug!("(resolving glob import) writing resolution `{}` in `{}` \
to `{}`",
- token::get_name(name).get(),
+ &token::get_name(name),
self.module_to_string(&*containing_module),
self.module_to_string(module_));
let msg = format!("a {} named `{}` has already been imported \
in this module",
namespace_name,
- token::get_name(name).get());
+ &token::get_name(name));
span_err!(self.session, import_directive.span, E0251, "{}", msg);
} else {
let target = Target::new(containing_module.clone(),
name: Name,
namespace: Namespace) {
debug!("check_for_conflicting_import: {}; target exists: {}",
- token::get_name(name).get(),
+ &token::get_name(name),
target.is_some());
match *target {
TypeNS => "type",
ValueNS => "value",
},
- token::get_name(name).get());
+ &token::get_name(name));
span_err!(self.session, import_span, E0252, "{}", &msg[]);
}
Some(_) | None => {}
let msg = format!("import `{0}` conflicts with imported \
crate in this module \
(maybe you meant `use {0}::*`?)",
- token::get_name(name).get());
+ &token::get_name(name));
span_err!(self.session, import_span, E0254, "{}", &msg[]);
}
Some(_) | None => {}
if let Some(ref value) = *name_bindings.value_def.borrow() {
let msg = format!("import `{}` conflicts with value \
in this module",
- token::get_name(name).get());
+ &token::get_name(name));
span_err!(self.session, import_span, E0255, "{}", &msg[]);
if let Some(span) = value.value_span {
self.session.span_note(span,
None => {
let msg = format!("import `{}` conflicts with type in \
this module",
- token::get_name(name).get());
+ &token::get_name(name));
span_err!(self.session, import_span, E0256, "{}", &msg[]);
if let Some(span) = ty.type_span {
self.session.span_note(span,
_ => {
let msg = format!("import `{}` conflicts with existing \
submodule",
- token::get_name(name).get());
+ &token::get_name(name));
span_err!(self.session, import_span, E0258, "{}", &msg[]);
if let Some(span) = ty.type_span {
self.session.span_note(span,
span_err!(self.session, span, E0259,
"an external crate named `{}` has already \
been imported into this module",
- token::get_name(name).get());
+ &token::get_name(name));
}
}
"the name `{}` conflicts with an external \
crate that has been imported into this \
module",
- token::get_name(name).get());
+ &token::get_name(name));
}
}
let module_name = self.module_to_string(&*search_module);
let mut span = span;
let msg = if "???" == &module_name[] {
- span.hi = span.lo + Pos::from_usize(segment_name.get().len());
+ span.hi = span.lo + Pos::from_usize(segment_name.len());
match search_parent_externals(name,
&self.current_module) {
let mut containing_module;
let mut i;
let first_module_path_string = token::get_name(module_path[0]);
- if "self" == first_module_path_string.get() {
+ if "self" == &first_module_path_string[] {
containing_module =
self.get_nearest_normal_module_parent_or_self(module_);
i = 1;
- } else if "super" == first_module_path_string.get() {
+ } else if "super" == &first_module_path_string[] {
containing_module =
self.get_nearest_normal_module_parent_or_self(module_);
i = 0; // We'll handle `super` below.
// Now loop through all the `super`s we find.
while i < module_path.len() {
let string = token::get_name(module_path[i]);
- if "super" != string.get() {
+ if "super" != &string[] {
break
}
debug!("(resolving module prefix) resolving `super` at {}",
allow_private_imports: bool)
-> ResolveResult<(Target, bool)> {
debug!("(resolving name in module) resolving `{}` in `{}`",
- token::get_name(name).get(),
+ &token::get_name(name),
self.module_to_string(&*module_));
// First, check the direct children of the module.
// We're out of luck.
debug!("(resolving name in module) failed to resolve `{}`",
- token::get_name(name).get());
+ &token::get_name(name));
return Failed(None);
}
let mut smallest = 0;
for (i, other) in maybes.iter().enumerate() {
- values[i] = lev_distance(name, other.get());
+ values[i] = lev_distance(name, &other);
if values[i] <= values[smallest] {
smallest = i;
values[smallest] != uint::MAX &&
values[smallest] < name.len() + 2 &&
values[smallest] <= max_distance &&
- name != maybes[smallest].get() {
+ name != &maybes[smallest][] {
- Some(maybes[smallest].get().to_string())
+ Some(maybes[smallest].to_string())
} else {
None
false // Stop advancing
});
- if method_scope && token::get_name(self.self_name).get()
+ if method_scope && &token::get_name(self.self_name)[]
== path_name {
self.resolve_error(
expr.span,
if let Some(sess) = sess {
if let Some(ref s) = sess.opts.crate_name {
if let Some((attr, ref name)) = attr_crate_name {
- if *s != name.get() {
+ if *s != &name[] {
let msg = format!("--crate-name and #[crate_name] are \
required to match, but `{}` != `{}`",
s, name);
}
if let Some((attr, s)) = attr_crate_name {
- return validate(s.get().to_string(), Some(attr.span));
+ return validate(s.to_string(), Some(attr.span));
}
if let Input::File(ref path) = *input {
if let Some(s) = path.filestem_str() {
// First, connect each component with <len, name> pairs.
for e in path {
- push(&mut n, &token::get_name(e.name()).get()[])
+ push(&mut n, &token::get_name(e.name()))
}
match hash {
},
};
- let qualname = format!("{}::{}", qualname, get_ident(method.pe_ident()).get());
+ let qualname = format!("{}::{}", qualname, &get_ident(method.pe_ident()));
let qualname = &qualname[];
// record the decl for this def (if it has one)
Some(sub_span) => self.fmt.field_str(field.span,
Some(sub_span),
field.node.id,
- &name.get()[],
+ &name[],
&qualname[],
&typ[],
scope_id),
self.fmt.static_str(item.span,
sub_span,
item.id,
- get_ident(item.ident).get(),
+ &get_ident(item.ident),
&qualname[],
&value[],
&ty_to_string(&*typ)[],
self.fmt.static_str(item.span,
sub_span,
item.id,
- get_ident(item.ident).get(),
+ &get_ident(item.ident),
&qualname[],
"",
&ty_to_string(&*typ)[],
}
for variant in &enum_definition.variants {
let name = get_ident(variant.node.name);
- let name = name.get();
+ let name = &name;
let mut qualname = enum_name.clone();
qualname.push_str("::");
qualname.push_str(name);
sub_span,
item.id,
mod_id,
- get_ident(ident).get(),
+ &get_ident(ident),
self.cur_scope);
self.write_sub_paths_truncated(path, true);
}
}
ast::ItemExternCrate(ref s) => {
let name = get_ident(item.ident);
- let name = name.get();
+ let name = &name;
let location = match *s {
- Some((ref s, _)) => s.get().to_string(),
+ Some((ref s, _)) => s.to_string(),
None => name.to_string(),
};
let alias_span = self.span.span_for_last_ident(item.span);
},
};
- qualname.push_str(get_ident(method_type.ident).get());
+ qualname.push_str(&get_ident(method_type.ident));
let qualname = &qualname[];
let sub_span = self.span.sub_span_after_keyword(method_type.span, keywords::Fn);
assert!(analysis.glob_map.is_some());
let cratename = match attr::find_crate_name(&krate.attrs[]) {
- Some(name) => name.get().to_string(),
+ Some(name) => name.to_string(),
None => {
info!("Could not find crate name, using 'unknown_crate'");
String::from_str("unknown_crate")
pub fn snippet(&self, span: Span) -> String {
match self.sess.codemap().span_to_snippet(span) {
- Some(s) => s,
- None => String::new(),
+ Ok(s) => s,
+ Err(_) => String::new(),
}
}
use trans::tvec;
use trans::type_of;
use middle::ty::{self, Ty};
-use session::config::FullDebugInfo;
+use session::config::{NoDebugInfo, FullDebugInfo};
use util::common::indenter;
use util::nodemap::FnvHashMap;
use util::ppaux::{Repr, vec_map_to_string};
use std::iter::AdditiveIterator;
use std::rc::Rc;
use syntax::ast;
-use syntax::ast::{DUMMY_NODE_ID, Ident};
+use syntax::ast::{DUMMY_NODE_ID, Ident, NodeId};
use syntax::codemap::Span;
use syntax::fold::Folder;
use syntax::ptr::P;
// An option identifying a branch (either a literal, an enum variant or a range)
#[derive(Debug)]
enum Opt<'a, 'tcx> {
- ConstantValue(ConstantExpr<'a>),
- ConstantRange(ConstantExpr<'a>, ConstantExpr<'a>),
- Variant(ty::Disr, Rc<adt::Repr<'tcx>>, ast::DefId),
- SliceLengthEqual(uint),
- SliceLengthGreaterOrEqual(/* prefix length */ uint, /* suffix length */ uint),
+ ConstantValue(ConstantExpr<'a>, DebugLoc),
+ ConstantRange(ConstantExpr<'a>, ConstantExpr<'a>, DebugLoc),
+ Variant(ty::Disr, Rc<adt::Repr<'tcx>>, ast::DefId, DebugLoc),
+ SliceLengthEqual(uint, DebugLoc),
+ SliceLengthGreaterOrEqual(/* prefix length */ uint,
+ /* suffix length */ uint,
+ DebugLoc),
}
impl<'a, 'tcx> Opt<'a, 'tcx> {
fn eq(&self, other: &Opt<'a, 'tcx>, tcx: &ty::ctxt<'tcx>) -> bool {
match (self, other) {
- (&ConstantValue(a), &ConstantValue(b)) => a.eq(b, tcx),
- (&ConstantRange(a1, a2), &ConstantRange(b1, b2)) => {
+ (&ConstantValue(a, _), &ConstantValue(b, _)) => a.eq(b, tcx),
+ (&ConstantRange(a1, a2, _), &ConstantRange(b1, b2, _)) => {
a1.eq(b1, tcx) && a2.eq(b2, tcx)
}
- (&Variant(a_disr, ref a_repr, a_def), &Variant(b_disr, ref b_repr, b_def)) => {
+ (&Variant(a_disr, ref a_repr, a_def, _),
+ &Variant(b_disr, ref b_repr, b_def, _)) => {
a_disr == b_disr && *a_repr == *b_repr && a_def == b_def
}
- (&SliceLengthEqual(a), &SliceLengthEqual(b)) => a == b,
- (&SliceLengthGreaterOrEqual(a1, a2), &SliceLengthGreaterOrEqual(b1, b2)) => {
+ (&SliceLengthEqual(a, _), &SliceLengthEqual(b, _)) => a == b,
+ (&SliceLengthGreaterOrEqual(a1, a2, _),
+ &SliceLengthGreaterOrEqual(b1, b2, _)) => {
a1 == b1 && a2 == b2
}
_ => false
let _icx = push_ctxt("match::trans_opt");
let ccx = bcx.ccx();
match *self {
- ConstantValue(ConstantExpr(lit_expr)) => {
+ ConstantValue(ConstantExpr(lit_expr), _) => {
let lit_ty = ty::node_id_to_type(bcx.tcx(), lit_expr.id);
let (llval, _) = consts::const_expr(ccx, &*lit_expr);
let lit_datum = immediate_rvalue(llval, lit_ty);
let lit_datum = unpack_datum!(bcx, lit_datum.to_appropriate_datum(bcx));
SingleResult(Result::new(bcx, lit_datum.val))
}
- ConstantRange(ConstantExpr(ref l1), ConstantExpr(ref l2)) => {
+ ConstantRange(ConstantExpr(ref l1), ConstantExpr(ref l2), _) => {
let (l1, _) = consts::const_expr(ccx, &**l1);
let (l2, _) = consts::const_expr(ccx, &**l2);
RangeResult(Result::new(bcx, l1), Result::new(bcx, l2))
}
- Variant(disr_val, ref repr, _) => {
+ Variant(disr_val, ref repr, _, _) => {
adt::trans_case(bcx, &**repr, disr_val)
}
- SliceLengthEqual(length) => {
+ SliceLengthEqual(length, _) => {
SingleResult(Result::new(bcx, C_uint(ccx, length)))
}
- SliceLengthGreaterOrEqual(prefix, suffix) => {
+ SliceLengthGreaterOrEqual(prefix, suffix, _) => {
LowerBound(Result::new(bcx, C_uint(ccx, prefix + suffix)))
}
}
}
+
+ fn debug_loc(&self) -> DebugLoc {
+ match *self {
+ ConstantValue(_,debug_loc) |
+ ConstantRange(_, _, debug_loc) |
+ Variant(_, _, _, debug_loc) |
+ SliceLengthEqual(_, debug_loc) |
+ SliceLengthGreaterOrEqual(_, _, debug_loc) => debug_loc
+ }
+ }
}
#[derive(Copy, PartialEq)]
pats: Vec<&'p ast::Pat>,
data: &'a ArmData<'p, 'blk, 'tcx>,
bound_ptrs: Vec<(Ident, ValueRef)>,
+ // Thread along renamings done by the check_match::StaticInliner, so we can
+ // map back to original NodeIds
+ pat_renaming_map: Option<&'a FnvHashMap<(NodeId, Span), NodeId>>
}
impl<'a, 'p, 'blk, 'tcx> Repr<'tcx> for Match<'a, 'p, 'blk, 'tcx> {
Match {
pats: pats,
data: &*br.data,
- bound_ptrs: bound_ptrs
+ bound_ptrs: bound_ptrs,
+ pat_renaming_map: br.pat_renaming_map,
}
}).collect()
}
Match {
pats: pats,
data: br.data,
- bound_ptrs: bound_ptrs
+ bound_ptrs: bound_ptrs,
+ pat_renaming_map: br.pat_renaming_map,
}
})
}).collect()
let _indenter = indenter();
let ctor = match opt {
- &ConstantValue(ConstantExpr(expr)) => check_match::ConstantValue(
+ &ConstantValue(ConstantExpr(expr), _) => check_match::ConstantValue(
const_eval::eval_const_expr(bcx.tcx(), &*expr)
),
- &ConstantRange(ConstantExpr(lo), ConstantExpr(hi)) => check_match::ConstantRange(
+ &ConstantRange(ConstantExpr(lo), ConstantExpr(hi), _) => check_match::ConstantRange(
const_eval::eval_const_expr(bcx.tcx(), &*lo),
const_eval::eval_const_expr(bcx.tcx(), &*hi)
),
- &SliceLengthEqual(n) =>
+ &SliceLengthEqual(n, _) =>
check_match::Slice(n),
- &SliceLengthGreaterOrEqual(before, after) =>
+ &SliceLengthGreaterOrEqual(before, after, _) =>
check_match::SliceWithSubslice(before, after),
- &Variant(_, _, def_id) =>
+ &Variant(_, _, def_id, _) =>
check_match::Constructor::Variant(def_id)
};
// needs to be conditionally matched at runtime; for example, the discriminant
// on a set of enum variants or a literal.
fn get_branches<'a, 'p, 'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
- m: &[Match<'a, 'p, 'blk, 'tcx>], col: uint)
+ m: &[Match<'a, 'p, 'blk, 'tcx>],
+ col: uint)
-> Vec<Opt<'p, 'tcx>> {
let tcx = bcx.tcx();
let mut found: Vec<Opt> = vec![];
for br in m {
let cur = br.pats[col];
+ let debug_loc = match br.pat_renaming_map {
+ Some(pat_renaming_map) => {
+ match pat_renaming_map.get(&(cur.id, cur.span)) {
+ Some(&id) => DebugLoc::At(id, cur.span),
+ None => DebugLoc::At(cur.id, cur.span),
+ }
+ }
+ None => DebugLoc::None
+ };
+
let opt = match cur.node {
- ast::PatLit(ref l) => ConstantValue(ConstantExpr(&**l)),
+ ast::PatLit(ref l) => {
+ ConstantValue(ConstantExpr(&**l), debug_loc)
+ }
ast::PatIdent(..) | ast::PatEnum(..) | ast::PatStruct(..) => {
// This is either an enum variant or a variable binding.
let opt_def = tcx.def_map.borrow().get(&cur.id).cloned();
match opt_def {
Some(def::DefVariant(enum_id, var_id, _)) => {
let variant = ty::enum_variant_with_id(tcx, enum_id, var_id);
- Variant(variant.disr_val, adt::represent_node(bcx, cur.id), var_id)
+ Variant(variant.disr_val,
+ adt::represent_node(bcx, cur.id),
+ var_id,
+ debug_loc)
}
_ => continue
}
}
ast::PatRange(ref l1, ref l2) => {
- ConstantRange(ConstantExpr(&**l1), ConstantExpr(&**l2))
+ ConstantRange(ConstantExpr(&**l1), ConstantExpr(&**l2), debug_loc)
}
ast::PatVec(ref before, None, ref after) => {
- SliceLengthEqual(before.len() + after.len())
+ SliceLengthEqual(before.len() + after.len(), debug_loc)
}
ast::PatVec(ref before, Some(_), ref after) => {
- SliceLengthGreaterOrEqual(before.len(), after.len())
+ SliceLengthGreaterOrEqual(before.len(), after.len(), debug_loc)
}
_ => continue
};
fn compare_values<'blk, 'tcx>(cx: Block<'blk, 'tcx>,
lhs: ValueRef,
rhs: ValueRef,
- rhs_t: Ty<'tcx>)
+ rhs_t: Ty<'tcx>,
+ debug_loc: DebugLoc)
-> Result<'blk, 'tcx> {
fn compare_str<'blk, 'tcx>(cx: Block<'blk, 'tcx>,
lhs: ValueRef,
rhs: ValueRef,
- rhs_t: Ty<'tcx>)
+ rhs_t: Ty<'tcx>,
+ debug_loc: DebugLoc)
-> Result<'blk, 'tcx> {
let did = langcall(cx,
None,
&format!("comparison of `{}`",
cx.ty_to_string(rhs_t))[],
StrEqFnLangItem);
- callee::trans_lang_call(cx, did, &[lhs, rhs], None)
+ callee::trans_lang_call(cx, did, &[lhs, rhs], None, debug_loc)
}
let _icx = push_ctxt("compare_values");
if ty::type_is_scalar(rhs_t) {
- let rs = compare_scalar_types(cx, lhs, rhs, rhs_t, ast::BiEq);
+ let rs = compare_scalar_types(cx, lhs, rhs, rhs_t, ast::BiEq, debug_loc);
return Result::new(rs.bcx, rs.val);
}
match rhs_t.sty {
ty::ty_rptr(_, mt) => match mt.ty.sty {
- ty::ty_str => compare_str(cx, lhs, rhs, rhs_t),
+ ty::ty_str => compare_str(cx, lhs, rhs, rhs_t, debug_loc),
ty::ty_vec(ty, _) => match ty.sty {
ty::ty_uint(ast::TyU8) => {
// NOTE: cast &[u8] to &str and abuse the str_eq lang item,
ast::MutImmutable);
let lhs = BitCast(cx, lhs, type_of::type_of(cx.ccx(), t).ptr_to());
let rhs = BitCast(cx, rhs, type_of::type_of(cx.ccx(), t).ptr_to());
- compare_str(cx, lhs, rhs, rhs_t)
+ compare_str(cx, lhs, rhs, rhs_t, debug_loc)
},
_ => cx.sess().bug("only byte strings supported in compare_values"),
},
}
}
+ for (_, &binding_info) in &data.bindings_map {
+ bcx.fcx.lllocals.borrow_mut().remove(&binding_info.id);
+ }
+
with_cond(bcx, Not(bcx, val, guard_expr.debug_loc()), |bcx| {
- // Guard does not match: remove all bindings from the lllocals table
for (_, &binding_info) in &data.bindings_map {
call_lifetime_end(bcx, binding_info.llmatch);
- bcx.fcx.lllocals.borrow_mut().remove(&binding_info.id);
}
match chk {
// If the default arm is the only one left, move on to the next
debug!("test_val={}", bcx.val_to_string(test_val));
if opts.len() > 0 {
match opts[0] {
- ConstantValue(_) | ConstantRange(_, _) => {
+ ConstantValue(..) | ConstantRange(..) => {
test_val = load_if_immediate(bcx, val, left_ty);
kind = if ty::type_is_integral(left_ty) {
Switch
Compare
};
}
- Variant(_, ref repr, _) => {
+ Variant(_, ref repr, _, _) => {
let (the_kind, val_opt) = adt::trans_switch(bcx, &**repr, val);
kind = the_kind;
if let Some(tval) = val_opt { test_val = tval; }
}
- SliceLengthEqual(_) | SliceLengthGreaterOrEqual(_, _) => {
+ SliceLengthEqual(..) | SliceLengthGreaterOrEqual(..) => {
let (_, len) = tvec::get_base_and_len(bcx, val, left_ty);
test_val = len;
kind = Switch;
}
for o in &opts {
match *o {
- ConstantRange(_, _) => { kind = Compare; break },
- SliceLengthGreaterOrEqual(_, _) => { kind = CompareSliceLength; break },
+ ConstantRange(..) => { kind = Compare; break },
+ SliceLengthGreaterOrEqual(..) => { kind = CompareSliceLength; break },
_ => ()
}
}
// for the current conditional branch.
let mut branch_chk = None;
let mut opt_cx = else_cx;
+ let debug_loc = opt.debug_loc();
+
if !exhaustive || i + 1 < len {
opt_cx = bcx.fcx.new_temp_block("match_case");
match kind {
- Single => Br(bcx, opt_cx.llbb, DebugLoc::None),
+ Single => Br(bcx, opt_cx.llbb, debug_loc),
Switch => {
match opt.trans(bcx) {
SingleResult(r) => {
let Result { bcx: after_cx, val: matches } = {
match opt.trans(bcx) {
SingleResult(Result { bcx, val }) => {
- compare_values(bcx, test_val, val, t)
+ compare_values(bcx, test_val, val, t, debug_loc)
}
RangeResult(Result { val: vbegin, .. },
Result { bcx, val: vend }) => {
let Result { bcx, val: llge } =
- compare_scalar_types(
- bcx, test_val,
- vbegin, t, ast::BiGe);
+ compare_scalar_types(bcx,
+ test_val,
+ vbegin,
+ t,
+ ast::BiGe,
+ debug_loc);
let Result { bcx, val: llle } =
- compare_scalar_types(
- bcx, test_val, vend,
- t, ast::BiLe);
- Result::new(bcx, And(bcx, llge, llle, DebugLoc::None))
+ compare_scalar_types(bcx,
+ test_val,
+ vend,
+ t,
+ ast::BiLe,
+ debug_loc);
+ Result::new(bcx, And(bcx, llge, llle, debug_loc))
}
LowerBound(Result { bcx, val }) => {
- compare_scalar_types(bcx, test_val, val, t, ast::BiGe)
+ compare_scalar_types(bcx,
+ test_val,
+ val,
+ t,
+ ast::BiGe,
+ debug_loc)
}
}
};
if i + 1 < len && (guarded || multi_pats || kind == CompareSliceLength) {
branch_chk = Some(JumpToBasicBlock(bcx.llbb));
}
- CondBr(after_cx, matches, opt_cx.llbb, bcx.llbb, DebugLoc::None);
+ CondBr(after_cx, matches, opt_cx.llbb, bcx.llbb, debug_loc);
}
_ => ()
}
} else if kind == Compare || kind == CompareSliceLength {
- Br(bcx, else_cx.llbb, DebugLoc::None);
+ Br(bcx, else_cx.llbb, debug_loc);
}
let mut size = 0;
let mut unpacked = Vec::new();
match *opt {
- Variant(disr_val, ref repr, _) => {
+ Variant(disr_val, ref repr, _, _) => {
let ExtractedBlock {vals: argvals, bcx: new_bcx} =
extract_variant_args(opt_cx, &**repr, disr_val, val);
size = argvals.len();
unpacked = argvals;
opt_cx = new_bcx;
}
- SliceLengthEqual(len) => {
+ SliceLengthEqual(len, _) => {
let args = extract_vec_elems(opt_cx, left_ty, len, 0, val);
size = args.vals.len();
unpacked = args.vals.clone();
opt_cx = args.bcx;
}
- SliceLengthGreaterOrEqual(before, after) => {
+ SliceLengthGreaterOrEqual(before, after, _) => {
let args = extract_vec_elems(opt_cx, left_ty, before, after, val);
size = args.vals.len();
unpacked = args.vals.clone();
opt_cx = args.bcx;
}
- ConstantValue(_) | ConstantRange(_, _) => ()
+ ConstantValue(..) | ConstantRange(..) => ()
}
let opt_ms = enter_opt(opt_cx, pat_id, dm, m, opt, col, size, val);
let mut opt_vals = unpacked;
bindings_map: create_bindings_map(bcx, &*arm.pats[0], discr_expr, &*arm.body)
}).collect();
- let mut static_inliner = StaticInliner::new(scope_cx.tcx());
- let arm_pats: Vec<Vec<P<ast::Pat>>> = arm_datas.iter().map(|arm_data| {
- arm_data.arm.pats.iter().map(|p| static_inliner.fold_pat((*p).clone())).collect()
- }).collect();
+ let mut pat_renaming_map = if scope_cx.sess().opts.debuginfo != NoDebugInfo {
+ Some(FnvHashMap())
+ } else {
+ None
+ };
+
+ let arm_pats: Vec<Vec<P<ast::Pat>>> = {
+ let mut static_inliner = StaticInliner::new(scope_cx.tcx(),
+ pat_renaming_map.as_mut());
+ arm_datas.iter().map(|arm_data| {
+ arm_data.arm.pats.iter().map(|p| static_inliner.fold_pat((*p).clone())).collect()
+ }).collect()
+ };
+
let mut matches = Vec::new();
for (arm_data, pats) in arm_datas.iter().zip(arm_pats.iter()) {
matches.extend(pats.iter().map(|p| Match {
pats: vec![&**p],
data: arm_data,
bound_ptrs: Vec::new(),
+ pat_renaming_map: pat_renaming_map.as_ref()
}));
}
RawNullablePointer { nndiscr, nnty, .. } => {
let cmp = if nndiscr == 0 { IntEQ } else { IntNE };
let llptrty = type_of::sizing_type_of(bcx.ccx(), nnty);
- val = ICmp(bcx, cmp, Load(bcx, scrutinee), C_null(llptrty));
+ val = ICmp(bcx, cmp, Load(bcx, scrutinee), C_null(llptrty), DebugLoc::None);
signed = false;
}
StructWrappedNullablePointer { nndiscr, ref discrfield, .. } => {
let llptrptr = GEPi(bcx, scrutinee, &discrfield[]);
let llptr = Load(bcx, llptrptr);
let cmp = if nndiscr == 0 { IntEQ } else { IntNE };
- ICmp(bcx, cmp, llptr, C_null(val_ty(llptr)))
+ ICmp(bcx, cmp, llptr, C_null(val_ty(llptr)), DebugLoc::None)
}
/// Helper for cases where the discriminant is simply loaded.
fcx.pop_custom_cleanup_scope(temp_scope);
let mut constraints = constraints.iter()
- .map(|s| s.get().to_string())
+ .map(|s| s.to_string())
.chain(ext_constraints.into_iter())
.collect::<Vec<String>>()
.connect(",");
let mut clobbers = ia.clobbers.iter()
- .map(|s| format!("~{{{}}}", s.get()))
+ .map(|s| format!("~{{{}}}", &s))
.collect::<Vec<String>>()
.connect(",");
let more_clobbers = get_clobbers();
ast::AsmIntel => llvm::AD_Intel
};
- let asm = CString::from_slice(ia.asm.get().as_bytes());
+ let asm = CString::from_slice(ia.asm.as_bytes());
let constraints = CString::from_slice(constraints.as_bytes());
let r = InlineAsmCall(bcx,
asm.as_ptr(),
use trans::common::{Block, C_bool, C_bytes_in_context, C_i32, C_integral};
use trans::common::{C_null, C_struct_in_context, C_u64, C_u8, C_undef};
use trans::common::{CrateContext, ExternMap, FunctionContext};
-use trans::common::{Result};
+use trans::common::{Result, NodeIdAndSpan};
use trans::common::{node_id_type, return_type_is_void};
use trans::common::{tydesc_info, type_is_immediate};
use trans::common::{type_is_zero_size, val_ty};
use trans::context::SharedCrateContext;
use trans::controlflow;
use trans::datum;
-use trans::debuginfo::{self, DebugLoc};
+use trans::debuginfo::{self, DebugLoc, ToDebugLoc};
use trans::expr;
use trans::foreign;
use trans::glue;
llty_ptr: Type,
info_ty: Ty<'tcx>,
size: ValueRef,
- align: ValueRef)
+ align: ValueRef,
+ debug_loc: DebugLoc)
-> Result<'blk, 'tcx> {
let _icx = push_ctxt("malloc_raw_exchange");
let r = callee::trans_lang_call(bcx,
require_alloc_fn(bcx, info_ty, ExchangeMallocFnLangItem),
&[size, align],
- None);
+ None,
+ debug_loc);
Result::new(r.bcx, PointerCast(r.bcx, r.val, llty_ptr))
}
for attr in attrs {
let mut used = true;
- match attr.name().get() {
+ match &attr.name()[] {
"no_stack_check" => unset_split_stack(llfn),
"no_split_stack" => {
unset_split_stack(llfn);
lhs: ValueRef,
rhs: ValueRef,
t: Ty<'tcx>,
- op: ast::BinOp_)
+ op: ast::BinOp_,
+ debug_loc: DebugLoc)
-> Result<'blk, 'tcx> {
- let f = |a| Result::new(cx, compare_scalar_values(cx, lhs, rhs, a, op));
+ let f = |a| Result::new(cx, compare_scalar_values(cx, lhs, rhs, a, op, debug_loc));
match t.sty {
ty::ty_tup(ref tys) if tys.is_empty() => f(nil_type),
lhs: ValueRef,
rhs: ValueRef,
nt: scalar_type,
- op: ast::BinOp_)
+ op: ast::BinOp_,
+ debug_loc: DebugLoc)
-> ValueRef {
let _icx = push_ctxt("compare_scalar_values");
fn die(cx: Block) -> ! {
ast::BiGe => llvm::RealOGE,
_ => die(cx)
};
- return FCmp(cx, cmp, lhs, rhs);
+ return FCmp(cx, cmp, lhs, rhs, debug_loc);
}
signed_int => {
let cmp = match op {
ast::BiGe => llvm::IntSGE,
_ => die(cx)
};
- return ICmp(cx, cmp, lhs, rhs);
+ return ICmp(cx, cmp, lhs, rhs, debug_loc);
}
unsigned_int => {
let cmp = match op {
ast::BiGe => llvm::IntUGE,
_ => die(cx)
};
- return ICmp(cx, cmp, lhs, rhs);
+ return ICmp(cx, cmp, lhs, rhs, debug_loc);
}
}
}
rhs: ValueRef,
t: Ty<'tcx>,
size: uint,
- op: ast::BinOp)
+ op: ast::BinOp_,
+ debug_loc: DebugLoc)
-> ValueRef {
let cmp = match t.sty {
ty::ty_float(_) => {
cx.sess().bug("compare_simd_types: comparison operators \
not supported for floating point SIMD types")
},
- ty::ty_uint(_) => match op.node {
+ ty::ty_uint(_) => match op {
ast::BiEq => llvm::IntEQ,
ast::BiNe => llvm::IntNE,
ast::BiLt => llvm::IntULT,
ast::BiGe => llvm::IntUGE,
_ => cx.sess().bug("compare_simd_types: must be a comparison operator"),
},
- ty::ty_int(_) => match op.node {
+ ty::ty_int(_) => match op {
ast::BiEq => llvm::IntEQ,
ast::BiNe => llvm::IntNE,
ast::BiLt => llvm::IntSLT,
// to get the correctly sized type. This will compile to a single instruction
// once the IR is converted to assembly if the SIMD instruction is supported
// by the target architecture.
- SExt(cx, ICmp(cx, cmp, lhs, rhs), return_ty)
+ SExt(cx, ICmp(cx, cmp, lhs, rhs, debug_loc), return_ty)
}
// Iterates through the elements of a structural type.
pub fn fail_if_zero_or_overflows<'blk, 'tcx>(
cx: Block<'blk, 'tcx>,
- span: Span,
+ call_info: NodeIdAndSpan,
divrem: ast::BinOp,
lhs: ValueRef,
rhs: ValueRef,
("attempted remainder with a divisor of zero",
"attempted remainder with overflow")
};
+ let debug_loc = call_info.debug_loc();
+
let (is_zero, is_signed) = match rhs_t.sty {
ty::ty_int(t) => {
let zero = C_integral(Type::int_from_ty(cx.ccx(), t), 0u64, false);
- (ICmp(cx, llvm::IntEQ, rhs, zero), true)
+ (ICmp(cx, llvm::IntEQ, rhs, zero, debug_loc), true)
}
ty::ty_uint(t) => {
let zero = C_integral(Type::uint_from_ty(cx.ccx(), t), 0u64, false);
- (ICmp(cx, llvm::IntEQ, rhs, zero), false)
+ (ICmp(cx, llvm::IntEQ, rhs, zero, debug_loc), false)
}
_ => {
cx.sess().bug(&format!("fail-if-zero on unexpected type: {}",
}
};
let bcx = with_cond(cx, is_zero, |bcx| {
- controlflow::trans_fail(bcx, span, InternedString::new(zero_text))
+ controlflow::trans_fail(bcx, call_info, InternedString::new(zero_text))
});
// To quote LLVM's documentation for the sdiv instruction:
_ => unreachable!(),
};
let minus_one = ICmp(bcx, llvm::IntEQ, rhs,
- C_integral(llty, -1, false));
+ C_integral(llty, -1, false), debug_loc);
with_cond(bcx, minus_one, |bcx| {
let is_min = ICmp(bcx, llvm::IntEQ, lhs,
- C_integral(llty, min, true));
+ C_integral(llty, min, true), debug_loc);
with_cond(bcx, is_min, |bcx| {
- controlflow::trans_fail(bcx, span,
+ controlflow::trans_fail(bcx,
+ call_info,
InternedString::new(overflow_text))
})
})
F: FnOnce(Block<'blk, 'tcx>) -> Block<'blk, 'tcx>,
{
let _icx = push_ctxt("with_cond");
+
+ if bcx.unreachable.get() ||
+ (common::is_const(val) && common::const_to_uint(val) == 0) {
+ return bcx;
+ }
+
let fcx = bcx.fcx;
let next_cx = fcx.new_temp_block("next");
let cond_cx = fcx.new_temp_block("cond");
let item = ccx.tcx().map.get(id);
if let ast_map::NodeItem(i) = item {
if let Some(name) = attr::first_attr_value_str_by_name(&i.attrs, "linkage") {
- if let Some(linkage) = llvm_linkage_by_name(name.get()) {
+ if let Some(linkage) = llvm_linkage_by_name(&name) {
llvm::SetLinkage(llval, linkage);
} else {
ccx.sess().span_fatal(i.span, "invalid linkage specified");
match attr::first_attr_value_str_by_name(attrs, "export_name") {
// Use provided name
- Some(name) => name.get().to_string(),
+ Some(name) => name.to_string(),
_ => ccx.tcx().map.with_path(id, |path| {
if attr::contains_name(attrs, "no_mangle") {
path.last().unwrap().to_string()
} else {
match weak_lang_items::link_name(attrs) {
- Some(name) => name.get().to_string(),
+ Some(name) => name.to_string(),
None => {
// Usual name mangling
mangle_exported_name(ccx, path, ty, id)
match attr::first_attr_value_str_by_name(&i.attrs[],
"link_section") {
Some(sect) => {
- if contains_null(sect.get()) {
+ if contains_null(§) {
ccx.sess().fatal(&format!("Illegal null byte in link_section value: `{}`",
- sect.get())[]);
+ §)[]);
}
unsafe {
- let buf = CString::from_slice(sect.get().as_bytes());
+ let buf = CString::from_slice(sect.as_bytes());
llvm::LLVMSetSection(v, buf.as_ptr());
}
},
let abi = ccx.tcx().map.get_foreign_abi(id);
let ty = ty::node_id_to_type(ccx.tcx(), ni.id);
let name = foreign::link_name(&*ni);
- foreign::register_foreign_item_fn(ccx, abi, ty, &name.get()[])
+ foreign::register_foreign_item_fn(ccx, abi, ty, &name)
}
ast::ForeignItemStatic(..) => {
foreign::register_static(ccx, &*ni)
/* Comparisons */
-pub fn ICmp(cx: Block, op: IntPredicate, lhs: ValueRef, rhs: ValueRef)
- -> ValueRef {
+pub fn ICmp(cx: Block,
+ op: IntPredicate,
+ lhs: ValueRef,
+ rhs: ValueRef,
+ debug_loc: DebugLoc)
+ -> ValueRef {
unsafe {
if cx.unreachable.get() {
return llvm::LLVMGetUndef(Type::i1(cx.ccx()).to_ref());
}
+ debug_loc.apply(cx.fcx);
B(cx).icmp(op, lhs, rhs)
}
}
-pub fn FCmp(cx: Block, op: RealPredicate, lhs: ValueRef, rhs: ValueRef)
- -> ValueRef {
+pub fn FCmp(cx: Block,
+ op: RealPredicate,
+ lhs: ValueRef,
+ rhs: ValueRef,
+ debug_loc: DebugLoc)
+ -> ValueRef {
unsafe {
if cx.unreachable.get() {
return llvm::LLVMGetUndef(Type::i1(cx.ccx()).to_ref());
}
+ debug_loc.apply(cx.fcx);
B(cx).fcmp(op, lhs, rhs)
}
}
B(cx).call(fn_, args, attributes)
}
-pub fn CallWithConv(cx: Block, fn_: ValueRef, args: &[ValueRef], conv: CallConv,
- attributes: Option<AttrBuilder>) -> ValueRef {
- if cx.unreachable.get() { return _UndefReturn(cx, fn_); }
+pub fn CallWithConv(cx: Block,
+ fn_: ValueRef,
+ args: &[ValueRef],
+ conv: CallConv,
+ attributes: Option<AttrBuilder>,
+ debug_loc: DebugLoc)
+ -> ValueRef {
+ if cx.unreachable.get() {
+ return _UndefReturn(cx, fn_);
+ }
+ debug_loc.apply(cx.fcx);
B(cx).call_with_conv(fn_, args, conv, attributes)
}
use trans::cleanup;
use trans::cleanup::CleanupMethods;
use trans::closure;
-use trans::common;
-use trans::common::*;
+use trans::common::{self, Block, Result, NodeIdAndSpan, ExprId, CrateContext,
+ ExprOrMethodCall, FunctionContext, MethodCallKey};
use trans::consts;
use trans::datum::*;
use trans::debuginfo::{DebugLoc, ToDebugLoc};
ref_expr: &ast::Expr)
-> Callee<'blk, 'tcx> {
debug!("trans_def(def={}, ref_expr={})", def.repr(bcx.tcx()), ref_expr.repr(bcx.tcx()));
- let expr_ty = node_id_type(bcx, ref_expr.id);
+ let expr_ty = common::node_id_type(bcx, ref_expr.id);
match def {
def::DefFn(did, _) if {
let maybe_def_id = inline::get_local_instance(bcx.ccx(), did);
_ => false
}
} => {
- let substs = node_id_substs(bcx.ccx(), ExprId(ref_expr.id),
- bcx.fcx.param_substs);
+ let substs = common::node_id_substs(bcx.ccx(),
+ ExprId(ref_expr.id),
+ bcx.fcx.param_substs);
Callee {
bcx: bcx,
data: NamedTupleConstructor(substs, 0)
ty::ty_bare_fn(_, ref f) => f.abi == synabi::RustIntrinsic,
_ => false
} => {
- let substs = node_id_substs(bcx.ccx(), ExprId(ref_expr.id),
- bcx.fcx.param_substs);
+ let substs = common::node_id_substs(bcx.ccx(),
+ ExprId(ref_expr.id),
+ bcx.fcx.param_substs);
let def_id = inline::maybe_instantiate_inline(bcx.ccx(), did);
Callee { bcx: bcx, data: Intrinsic(def_id.node, substs) }
}
}
def::DefVariant(tid, vid, _) => {
let vinfo = ty::enum_variant_with_id(bcx.tcx(), tid, vid);
- let substs = node_id_substs(bcx.ccx(), ExprId(ref_expr.id),
- bcx.fcx.param_substs);
+ let substs = common::node_id_substs(bcx.ccx(),
+ ExprId(ref_expr.id),
+ bcx.fcx.param_substs);
// Nullary variants are not callable
assert!(vinfo.args.len() > 0);
}
}
def::DefStruct(_) => {
- let substs = node_id_substs(bcx.ccx(), ExprId(ref_expr.id),
- bcx.fcx.param_substs);
+ let substs = common::node_id_substs(bcx.ccx(),
+ ExprId(ref_expr.id),
+ bcx.fcx.param_substs);
Callee {
bcx: bcx,
data: NamedTupleConstructor(substs, 0)
-> Datum<'tcx, Rvalue> {
let _icx = push_ctxt("trans_fn_ref");
- let substs = node_id_substs(ccx, node, param_substs);
+ let substs = common::node_id_substs(ccx, node, param_substs);
debug!("trans_fn_ref(def_id={}, node={:?}, substs={})",
def_id.repr(ccx.tcx()),
node,
let _icx = push_ctxt("trans_fn_pointer_shim");
let tcx = ccx.tcx();
- let bare_fn_ty = erase_regions(tcx, &bare_fn_ty);
+ let bare_fn_ty = common::erase_regions(tcx, &bare_fn_ty);
match ccx.fn_pointer_shims().borrow().get(&bare_fn_ty) {
Some(&llval) => { return llval; }
None => { }
);
bcx = trans_call_inner(bcx,
- None,
+ DebugLoc::None,
bare_fn_ty,
|bcx, _| Callee { bcx: bcx, data: Fn(llfnpointer) },
ArgVals(&llargs[]),
param_substs,
&ref_ty);
let llptrty = type_of::type_of_fn_from_ty(ccx, ref_ty).ptr_to();
- if llptrty != val_ty(val) {
+ if llptrty != common::val_ty(val) {
let val = consts::ptrcast(val, llptrty);
return Datum::new(val, ref_ty, Rvalue::new(ByValue));
}
// other weird situations. Annoying.
let llty = type_of::type_of_fn_from_ty(ccx, fn_type);
let llptrty = llty.ptr_to();
- if val_ty(val) != llptrty {
+ if common::val_ty(val) != llptrty {
debug!("trans_fn_ref_with_vtables(): casting pointer!");
val = consts::ptrcast(val, llptrty);
} else {
// Translating calls
pub fn trans_call<'a, 'blk, 'tcx>(in_cx: Block<'blk, 'tcx>,
- call_ex: &ast::Expr,
+ call_expr: &ast::Expr,
f: &ast::Expr,
args: CallArgs<'a, 'tcx>,
dest: expr::Dest)
-> Block<'blk, 'tcx> {
let _icx = push_ctxt("trans_call");
trans_call_inner(in_cx,
- Some(common::expr_info(call_ex)),
- expr_ty_adjusted(in_cx, f),
+ call_expr.debug_loc(),
+ common::expr_ty_adjusted(in_cx, f),
|cx, _| trans(cx, f),
args,
Some(dest)).bcx
}
pub fn trans_method_call<'a, 'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
- call_ex: &ast::Expr,
+ call_expr: &ast::Expr,
rcvr: &ast::Expr,
args: CallArgs<'a, 'tcx>,
dest: expr::Dest)
-> Block<'blk, 'tcx> {
let _icx = push_ctxt("trans_method_call");
- debug!("trans_method_call(call_ex={})", call_ex.repr(bcx.tcx()));
- let method_call = MethodCall::expr(call_ex.id);
+ debug!("trans_method_call(call_expr={})", call_expr.repr(bcx.tcx()));
+ let method_call = MethodCall::expr(call_expr.id);
let method_ty = (*bcx.tcx().method_map.borrow())[method_call].ty;
trans_call_inner(
bcx,
- Some(common::expr_info(call_ex)),
- monomorphize_type(bcx, method_ty),
+ call_expr.debug_loc(),
+ common::monomorphize_type(bcx, method_ty),
|cx, arg_cleanup_scope| {
meth::trans_method_callee(cx, method_call, Some(rcvr), arg_cleanup_scope)
},
pub fn trans_lang_call<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
did: ast::DefId,
args: &[ValueRef],
- dest: Option<expr::Dest>)
+ dest: Option<expr::Dest>,
+ debug_loc: DebugLoc)
-> Result<'blk, 'tcx> {
let fty = if did.krate == ast::LOCAL_CRATE {
ty::node_id_to_type(bcx.tcx(), did.node)
csearch::get_type(bcx.tcx(), did).ty
};
callee::trans_call_inner(bcx,
- None,
+ debug_loc,
fty,
|bcx, _| {
trans_fn_ref_with_substs_to_callee(bcx,
/// For non-lang items, `dest` is always Some, and hence the result is written into memory
/// somewhere. Nonetheless we return the actual return value of the function.
pub fn trans_call_inner<'a, 'blk, 'tcx, F>(bcx: Block<'blk, 'tcx>,
- call_info: Option<NodeIdAndSpan>,
+ debug_loc: DebugLoc,
callee_ty: Ty<'tcx>,
get_callee: F,
args: CallArgs<'a, 'tcx>,
assert!(abi == synabi::RustIntrinsic);
assert!(dest.is_some());
- let call_info = call_info.expect("no call info for intrinsic call?");
+ let call_info = match debug_loc {
+ DebugLoc::At(id, span) => NodeIdAndSpan { id: id, span: span },
+ DebugLoc::None => {
+ bcx.sess().bug("No call info for intrinsic call?")
+ }
+ };
+
return intrinsic::trans_intrinsic_call(bcx, node, callee_ty,
arg_cleanup_scope, args,
dest.unwrap(), substs,
disr,
args,
dest.unwrap(),
- call_info.debug_loc());
+ debug_loc);
}
};
};
if !is_rust_fn ||
type_of::return_uses_outptr(ccx, ret_ty) ||
- type_needs_drop(bcx.tcx(), ret_ty) {
+ common::type_needs_drop(bcx.tcx(), ret_ty) {
// Push the out-pointer if we use an out-pointer for this
// return type, otherwise push "undef".
- if type_is_zero_size(ccx, ret_ty) {
+ if common::type_is_zero_size(ccx, ret_ty) {
let llty = type_of::type_of(ccx, ret_ty);
- Some(C_undef(llty.ptr_to()))
+ Some(common::C_undef(llty.ptr_to()))
} else {
Some(alloc_ty(bcx, ret_ty, "__llret"))
}
llfn,
&llargs[],
callee_ty,
- call_info.debug_loc());
+ debug_loc);
bcx = b;
llresult = llret;
match (opt_llretslot, ret_ty) {
(Some(llretslot), ty::FnConverging(ret_ty)) => {
if !type_of::return_uses_outptr(bcx.ccx(), ret_ty) &&
- !type_is_zero_size(bcx.ccx(), ret_ty)
+ !common::type_is_zero_size(bcx.ccx(), ret_ty)
{
store_ty(bcx, llret, llretslot, ret_ty)
}
let mut llargs = Vec::new();
let arg_tys = match args {
- ArgExprs(a) => a.iter().map(|x| expr_ty(bcx, &**x)).collect(),
+ ArgExprs(a) => a.iter().map(|x| common::expr_ty(bcx, &**x)).collect(),
_ => panic!("expected arg exprs.")
};
bcx = trans_args(bcx,
abi);
fcx.scopes.borrow_mut().last_mut().unwrap().drop_non_lifetime_clean();
- bcx = foreign::trans_native_call(bcx, callee_ty,
- llfn, opt_llretslot.unwrap(),
- &llargs[], arg_tys);
+ bcx = foreign::trans_native_call(bcx,
+ callee_ty,
+ llfn,
+ opt_llretslot.unwrap(),
+ &llargs[],
+ arg_tys,
+ debug_loc);
}
fcx.pop_and_trans_custom_cleanup_scope(bcx, arg_cleanup_scope);
bcx = glue::drop_ty(bcx,
llretslot,
ret_ty,
- call_info.debug_loc());
+ debug_loc);
call_lifetime_end(bcx, llretslot);
}
_ => {}
// Now untuple the rest of the arguments.
let tuple_expr = &arg_exprs[1];
- let tuple_type = node_id_type(bcx, tuple_expr.id);
+ let tuple_type = common::node_id_type(bcx, tuple_expr.id);
match tuple_type.sty {
ty::ty_tup(ref field_types) => {
}
let arg_ty = if i >= num_formal_args {
assert!(variadic);
- expr_ty_adjusted(cx, &**arg_expr)
+ common::expr_ty_adjusted(cx, &**arg_expr)
} else {
arg_tys[i]
};
bcx: Block<'blk, 'tcx>,
debug_loc: DebugLoc)
-> Block<'blk, 'tcx> {
- debug_loc.apply(bcx.fcx);
-
match self.heap {
HeapExchange => {
- glue::trans_exchange_free_ty(bcx, self.ptr, self.content_ty)
+ glue::trans_exchange_free_ty(bcx,
+ self.ptr,
+ self.content_ty,
+ debug_loc)
}
}
}
bcx: Block<'blk, 'tcx>,
debug_loc: DebugLoc)
-> Block<'blk, 'tcx> {
- debug_loc.apply(bcx.fcx);
-
match self.heap {
HeapExchange => {
- glue::trans_exchange_free_dyn(bcx, self.ptr, self.size, self.align)
+ glue::trans_exchange_free_dyn(bcx,
+ self.ptr,
+ self.size,
+ self.align,
+ debug_loc)
}
}
}
pub fn sess(&self) -> &'blk Session { self.fcx.ccx.sess() }
pub fn ident(&self, ident: Ident) -> String {
- token::get_ident(ident).get().to_string()
+ token::get_ident(ident).to_string()
}
pub fn node_id_to_string(&self, id: ast::NodeId) -> String {
}
let sc = llvm::LLVMConstStringInContext(cx.llcx(),
- s.get().as_ptr() as *const c_char,
- s.get().len() as c_uint,
+ s.as_ptr() as *const c_char,
+ s.len() as c_uint,
!null_terminated as Bool);
let gsym = token::gensym("str");
// NB: Do not use `do_spill_noroot` to make this into a constant string, or
// you will be kicked off fast isel. See issue #4352 for an example of this.
pub fn C_str_slice(cx: &CrateContext, s: InternedString) -> ValueRef {
- let len = s.get().len();
+ let len = s.len();
let cs = consts::ptrcast(C_cstr(cx, s, false), Type::i8p(cx));
C_named_struct(cx.tn().find_type("str_slice").unwrap(), &[cs, C_uint(cx, len)])
}
}
}
ast::LitFloat(ref fs, t) => {
- C_floating(fs.get(), Type::float_from_ty(cx, t))
+ C_floating(&fs, Type::float_from_ty(cx, t))
}
ast::LitFloatUnsuffixed(ref fs) => {
let lit_float_ty = ty::node_id_to_type(cx.tcx(), e.id);
match lit_float_ty.sty {
ty::ty_float(t) => {
- C_floating(fs.get(), Type::float_from_ty(cx, t))
+ C_floating(&fs, Type::float_from_ty(cx, t))
}
_ => {
cx.sess().span_bug(lit.span,
ty::ty_vec(unit_ty, Some(len)) => {
let llunitty = type_of::type_of(cx, unit_ty);
let llptr = ptrcast(llconst, llunitty.ptr_to());
- assert!(cx.const_globals().borrow_mut()
- .insert(llptr as int, llconst).is_none());
+ let prev_const = cx.const_globals().borrow_mut()
+ .insert(llptr as int, llconst);
+ assert!(prev_const.is_none() ||
+ prev_const == Some(llconst));
assert_eq!(abi::FAT_PTR_ADDR, 0);
assert_eq!(abi::FAT_PTR_EXTRA, 1);
llconst = C_struct(cx, &[
use syntax::ast;
use syntax::ast::Ident;
use syntax::ast_util;
-use syntax::codemap::Span;
use syntax::parse::token::InternedString;
use syntax::parse::token;
use syntax::visit::Visitor;
}
pub fn trans_fail<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
- sp: Span,
+ call_info: NodeIdAndSpan,
fail_str: InternedString)
-> Block<'blk, 'tcx> {
let ccx = bcx.ccx();
let _icx = push_ctxt("trans_fail_value");
let v_str = C_str_slice(ccx, fail_str);
- let loc = bcx.sess().codemap().lookup_char_pos(sp.lo);
+ let loc = bcx.sess().codemap().lookup_char_pos(call_info.span.lo);
let filename = token::intern_and_get_ident(&loc.file.name[]);
let filename = C_str_slice(ccx, filename);
let line = C_uint(ccx, loc.line);
let expr_file_line_const = C_struct(ccx, &[v_str, filename, line], false);
let expr_file_line = consts::const_addr_of(ccx, expr_file_line_const, ast::MutImmutable);
let args = vec!(expr_file_line);
- let did = langcall(bcx, Some(sp), "", PanicFnLangItem);
+ let did = langcall(bcx, Some(call_info.span), "", PanicFnLangItem);
let bcx = callee::trans_lang_call(bcx,
did,
&args[],
- Some(expr::Ignore)).bcx;
+ Some(expr::Ignore),
+ call_info.debug_loc()).bcx;
Unreachable(bcx);
return bcx;
}
pub fn trans_fail_bounds_check<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
- sp: Span,
+ call_info: NodeIdAndSpan,
index: ValueRef,
len: ValueRef)
-> Block<'blk, 'tcx> {
let _icx = push_ctxt("trans_fail_bounds_check");
// Extract the file/line from the span
- let loc = bcx.sess().codemap().lookup_char_pos(sp.lo);
+ let loc = bcx.sess().codemap().lookup_char_pos(call_info.span.lo);
let filename = token::intern_and_get_ident(&loc.file.name[]);
// Invoke the lang item
let file_line_const = C_struct(ccx, &[filename, line], false);
let file_line = consts::const_addr_of(ccx, file_line_const, ast::MutImmutable);
let args = vec!(file_line, index, len);
- let did = langcall(bcx, Some(sp), "", PanicBoundsCheckFnLangItem);
+ let did = langcall(bcx, Some(call_info.span), "", PanicBoundsCheckFnLangItem);
let bcx = callee::trans_lang_call(bcx,
did,
&args[],
- Some(expr::Ignore)).bcx;
+ Some(expr::Ignore),
+ call_info.debug_loc()).bcx;
Unreachable(bcx);
return bcx;
}
let variable_type = ty::node_id_to_type(cx.tcx(), node_id);
let type_metadata = type_metadata(cx, variable_type, span);
let namespace_node = namespace_for_item(cx, ast_util::local_def(node_id));
- let var_name = token::get_ident(ident).get().to_string();
+ let var_name = token::get_ident(ident).to_string();
let linkage_name =
namespace_node.mangled_name_of_contained_item(&var_name[]);
let var_scope = namespace_node.scope;
// bodies), in which case we also just want to return the span of the
// whole expression.
let code_snippet = cx.sess().codemap().span_to_snippet(node_span);
- if let Some(code_snippet) = code_snippet {
+ if let Ok(code_snippet) = code_snippet {
let bytes = code_snippet.as_bytes();
if bytes.len() > 0 && &bytes[bytes.len()-1..] == b"}" {
}
}
-#[derive(Copy, Clone, PartialEq, Eq)]
+#[derive(Copy, Clone, PartialEq, Eq, Debug)]
pub enum DebugLoc {
At(ast::NodeId, Span),
None
// Get_template_parameters() will append a `<...>` clause to the function
// name if necessary.
- let mut function_name = String::from_str(token::get_ident(ident).get());
+ let mut function_name = String::from_str(&token::get_ident(ident));
let template_parameters = get_template_parameters(cx,
generics,
param_substs,
let ident = special_idents::type_self;
let ident = token::get_ident(ident);
- let name = CString::from_slice(ident.get().as_bytes());
+ let name = CString::from_slice(ident.as_bytes());
let param_metadata = unsafe {
llvm::LLVMDIBuilderCreateTemplateTypeParameter(
DIB(cx),
if cx.sess().opts.debuginfo == FullDebugInfo {
let actual_type_metadata = type_metadata(cx, actual_type, codemap::DUMMY_SP);
let ident = token::get_ident(ident);
- let name = CString::from_slice(ident.get().as_bytes());
+ let name = CString::from_slice(ident.as_bytes());
let param_metadata = unsafe {
llvm::LLVMDIBuilderCreateTemplateTypeParameter(
DIB(cx),
CapturedVariable => (0, DW_TAG_auto_variable)
};
- let name = CString::from_slice(name.get().as_bytes());
+ let name = CString::from_slice(name.as_bytes());
match (variable_access, [].as_slice()) {
(DirectVariable { alloca }, address_operations) |
(IndirectVariable {alloca, address_operations}, _) => {
let name = if field.name == special_idents::unnamed_field.name {
"".to_string()
} else {
- token::get_name(field.name).get().to_string()
+ token::get_name(field.name).to_string()
};
let offset = if self.is_simd {
// MemberDescription of the struct's single field.
let sole_struct_member_description = MemberDescription {
name: match non_null_variant.arg_names {
- Some(ref names) => token::get_ident(names[0]).get().to_string(),
+ Some(ref names) => token::get_ident(names[0]).to_string(),
None => "".to_string()
},
llvm_type: non_null_llvm_type,
.get_unique_type_id_of_enum_variant(
cx,
self.enum_type,
- non_null_variant_name.get());
+ &non_null_variant_name);
// Now we can create the metadata of the artificial struct
let artificial_struct_metadata =
composite_type_metadata(cx,
artificial_struct_llvm_type,
- non_null_variant_name.get(),
+ &non_null_variant_name,
unique_type_id,
&[sole_struct_member_description],
self.containing_scope,
// Could do some consistency checks here: size, align, field count, discr type
let variant_name = token::get_name(variant_info.name);
- let variant_name = variant_name.get();
+ let variant_name = &variant_name;
let unique_type_id = debug_context(cx).type_map
.borrow_mut()
.get_unique_type_id_of_enum_variant(
Some(ref names) => {
names.iter()
.map(|ident| {
- token::get_ident(*ident).get().to_string()
+ token::get_ident(*ident).to_string()
}).collect()
}
None => variant_info.args.iter().map(|_| "".to_string()).collect()
.iter()
.map(|v| {
let token = token::get_name(v.name);
- let name = CString::from_slice(token.get().as_bytes());
+ let name = CString::from_slice(token.as_bytes());
unsafe {
llvm::LLVMDIBuilderCreateEnumerator(
DIB(cx),
codemap::DUMMY_SP);
let discriminant_name = get_enum_discriminant_name(cx, enum_def_id);
- let name = CString::from_slice(discriminant_name.get().as_bytes());
+ let name = CString::from_slice(discriminant_name.as_bytes());
let discriminant_type_metadata = unsafe {
llvm::LLVMDIBuilderCreateEnumerationType(
DIB(cx),
attributes.iter().any(|attr| {
let meta_item: &ast::MetaItem = &*attr.node.value;
match meta_item.node {
- ast::MetaWord(ref value) => value.get() == "no_debug",
+ ast::MetaWord(ref value) => &value[] == "no_debug",
_ => false
}
})
let mut path_element_count = 0;
for path_element in path {
let name = token::get_name(path_element.name());
- output.push_str(name.get());
+ output.push_str(&name);
output.push_str("::");
path_element_count += 1;
}
let name = token::get_name(path.last()
.expect("debuginfo: Empty item path?")
.name());
- output.push_str(name.get());
+ output.push_str(&name);
}
});
}
None => {}
}
let string = token::get_name(node.name);
- output.push_str(&format!("{}", string.get().len())[]);
- output.push_str(string.get());
+ output.push_str(&format!("{}", string.len())[]);
+ output.push_str(&string);
}
let mut name = String::from_str("_ZN");
};
let namespace_name = token::get_name(name);
let namespace_name = CString::from_slice(namespace_name
- .get().as_bytes());
+ .as_bytes());
let scope = unsafe {
llvm::LLVMDIBuilderCreateNameSpace(
DIB(cx),
let contents_ty = expr_ty(bcx, &**contents);
match box_ty.sty {
ty::ty_uniq(..) => {
- trans_uniq_expr(bcx, box_ty, &**contents, contents_ty)
+ trans_uniq_expr(bcx, expr, box_ty, &**contents, contents_ty)
}
_ => bcx.sess().span_bug(expr.span,
"expected unique box")
let ccx = bcx.ccx();
let mut bcx = bcx;
+ let index_expr_debug_loc = index_expr.debug_loc();
+
// Check for overloaded index.
let method_ty = ccx.tcx()
.method_map
debug!("trans_index: base {}", bcx.val_to_string(base));
debug!("trans_index: len {}", bcx.val_to_string(len));
- let bounds_check = ICmp(bcx, llvm::IntUGE, ix_val, len);
+ let bounds_check = ICmp(bcx,
+ llvm::IntUGE,
+ ix_val,
+ len,
+ index_expr_debug_loc);
let expect = ccx.get_intrinsic(&("llvm.expect.i1"));
let expected = Call(bcx,
expect,
&[bounds_check, C_bool(ccx, false)],
None,
- index_expr.debug_loc());
+ index_expr_debug_loc);
bcx = with_cond(bcx, expected, |bcx| {
controlflow::trans_fail_bounds_check(bcx,
- index_expr.span,
+ expr_info(index_expr),
ix_val,
len)
});
immediate_rvalue_bcx(bcx, llneg, un_ty).to_expr_datumblock()
}
ast::UnUniq => {
- trans_uniq_expr(bcx, un_ty, sub_expr, expr_ty(bcx, sub_expr))
+ trans_uniq_expr(bcx, expr, un_ty, sub_expr, expr_ty(bcx, sub_expr))
}
ast::UnDeref => {
let datum = unpack_datum!(bcx, trans(bcx, sub_expr));
}
fn trans_uniq_expr<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
+ box_expr: &ast::Expr,
box_ty: Ty<'tcx>,
contents: &ast::Expr,
contents_ty: Ty<'tcx>)
let size = llsize_of(bcx.ccx(), llty);
let align = C_uint(bcx.ccx(), type_of::align_of(bcx.ccx(), contents_ty));
let llty_ptr = llty.ptr_to();
- let Result { bcx, val } = malloc_raw_dyn(bcx, llty_ptr, box_ty, size, align);
+ let Result { bcx, val } = malloc_raw_dyn(bcx,
+ llty_ptr,
+ box_ty,
+ size,
+ align,
+ box_expr.debug_loc());
// Unique boxes do not allocate for zero-size types. The standard library
// may assume that `free` is never called on the pointer returned for
// `Box<ZeroSizeType>`.
FDiv(bcx, lhs, rhs, binop_debug_loc)
} else {
// Only zero-check integers; fp /0 is NaN
- bcx = base::fail_if_zero_or_overflows(bcx, binop_expr.span,
- op, lhs, rhs, rhs_t);
+ bcx = base::fail_if_zero_or_overflows(bcx,
+ expr_info(binop_expr),
+ op,
+ lhs,
+ rhs,
+ rhs_t);
if is_signed {
SDiv(bcx, lhs, rhs, binop_debug_loc)
} else {
FRem(bcx, lhs, rhs, binop_debug_loc)
} else {
// Only zero-check integers; fp %0 is NaN
- bcx = base::fail_if_zero_or_overflows(bcx, binop_expr.span,
+ bcx = base::fail_if_zero_or_overflows(bcx,
+ expr_info(binop_expr),
op, lhs, rhs, rhs_t);
if is_signed {
SRem(bcx, lhs, rhs, binop_debug_loc)
}
ast::BiEq | ast::BiNe | ast::BiLt | ast::BiGe | ast::BiLe | ast::BiGt => {
if ty::type_is_scalar(rhs_t) {
- unpack_result!(bcx, base::compare_scalar_types(bcx, lhs, rhs, rhs_t, op.node))
+ unpack_result!(bcx,
+ base::compare_scalar_types(bcx,
+ lhs,
+ rhs,
+ rhs_t,
+ op.node,
+ binop_debug_loc))
} else if is_simd {
- base::compare_simd_types(bcx, lhs, rhs, intype, ty::simd_size(tcx, lhs_t), op)
+ base::compare_simd_types(bcx,
+ lhs,
+ rhs,
+ intype,
+ ty::simd_size(tcx, lhs_t),
+ op.node,
+ binop_debug_loc)
} else {
bcx.tcx().sess.span_bug(binop_expr.span, "comparison operator unsupported for type")
}
-> Result<'blk, 'tcx> {
let method_ty = (*bcx.tcx().method_map.borrow())[method_call].ty;
callee::trans_call_inner(bcx,
- Some(expr_info(expr)),
+ expr.debug_loc(),
monomorphize_type(bcx, method_ty),
|bcx, arg_cleanup_scope| {
meth::trans_method_callee(bcx,
all_args.extend(args.iter().map(|e| &**e));
unpack_result!(bcx,
callee::trans_call_inner(bcx,
- Some(expr_info(expr)),
+ expr.debug_loc(),
monomorphize_type(bcx,
method_type),
|bcx, arg_cleanup_scope| {
use trans::build::*;
use trans::cabi;
use trans::common::*;
+use trans::debuginfo::DebugLoc;
use trans::machine;
use trans::monomorphize;
use trans::type_::Type;
// static and call it a day. Some linkages (like weak) will make it such
// that the static actually has a null value.
Some(name) => {
- let linkage = match llvm_linkage_by_name(name.get()) {
+ let linkage = match llvm_linkage_by_name(&name) {
Some(linkage) => linkage,
None => {
ccx.sess().span_fatal(foreign_item.span,
};
unsafe {
// Declare a symbol `foo` with the desired linkage.
- let buf = CString::from_slice(ident.get().as_bytes());
+ let buf = CString::from_slice(ident.as_bytes());
let g1 = llvm::LLVMAddGlobal(ccx.llmod(), llty2.to_ref(),
buf.as_ptr());
llvm::SetLinkage(g1, linkage);
// `extern_with_linkage_foo` will instead be initialized to
// zero.
let mut real_name = "_rust_extern_with_linkage_".to_string();
- real_name.push_str(ident.get());
+ real_name.push_str(&ident);
let real_name = CString::from_vec(real_name.into_bytes());
let g2 = llvm::LLVMAddGlobal(ccx.llmod(), llty.to_ref(),
real_name.as_ptr());
}
None => unsafe {
// Generate an external declaration.
- let buf = CString::from_slice(ident.get().as_bytes());
+ let buf = CString::from_slice(ident.as_bytes());
llvm::LLVMAddGlobal(ccx.llmod(), llty.to_ref(), buf.as_ptr())
}
}
llfn: ValueRef,
llretptr: ValueRef,
llargs_rust: &[ValueRef],
- passed_arg_tys: Vec<Ty<'tcx>>)
+ passed_arg_tys: Vec<Ty<'tcx>>,
+ call_debug_loc: DebugLoc)
-> Block<'blk, 'tcx>
{
let ccx = bcx.ccx();
llfn,
&llargs_foreign[],
cc,
- Some(attrs));
+ Some(attrs),
+ call_debug_loc);
// If the function we just called does not use an outpointer,
// store the result into the rust outpointer. Cast the outpointer
}
register_foreign_item_fn(ccx, abi, ty,
- &lname.get()[]);
+ &lname);
// Unlike for other items, we shouldn't call
// `base::update_linkage` here. Foreign items have
// special linkage requirements, which are handled
}
ccx.item_symbols().borrow_mut().insert(foreign_item.id,
- lname.get().to_string());
+ lname.to_string());
}
}
use syntax::ast;
use syntax::parse::token;
-pub fn trans_exchange_free_dyn<'blk, 'tcx>(cx: Block<'blk, 'tcx>, v: ValueRef,
- size: ValueRef, align: ValueRef)
+pub fn trans_exchange_free_dyn<'blk, 'tcx>(cx: Block<'blk, 'tcx>,
+ v: ValueRef,
+ size: ValueRef,
+ align: ValueRef,
+ debug_loc: DebugLoc)
-> Block<'blk, 'tcx> {
let _icx = push_ctxt("trans_exchange_free");
let ccx = cx.ccx();
callee::trans_lang_call(cx,
langcall(cx, None, "", ExchangeFreeFnLangItem),
&[PointerCast(cx, v, Type::i8p(ccx)), size, align],
- Some(expr::Ignore)).bcx
+ Some(expr::Ignore),
+ debug_loc).bcx
}
-pub fn trans_exchange_free<'blk, 'tcx>(cx: Block<'blk, 'tcx>, v: ValueRef,
- size: u64, align: u32) -> Block<'blk, 'tcx> {
- trans_exchange_free_dyn(cx, v, C_uint(cx.ccx(), size),
- C_uint(cx.ccx(), align))
+pub fn trans_exchange_free<'blk, 'tcx>(cx: Block<'blk, 'tcx>,
+ v: ValueRef,
+ size: u64,
+ align: u32,
+ debug_loc: DebugLoc)
+ -> Block<'blk, 'tcx> {
+ trans_exchange_free_dyn(cx,
+ v,
+ C_uint(cx.ccx(), size),
+ C_uint(cx.ccx(), align),
+ debug_loc)
}
-pub fn trans_exchange_free_ty<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, ptr: ValueRef,
- content_ty: Ty<'tcx>) -> Block<'blk, 'tcx> {
+pub fn trans_exchange_free_ty<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
+ ptr: ValueRef,
+ content_ty: Ty<'tcx>,
+ debug_loc: DebugLoc)
+ -> Block<'blk, 'tcx> {
assert!(type_is_sized(bcx.ccx().tcx(), content_ty));
let sizing_type = sizing_type_of(bcx.ccx(), content_ty);
let content_size = llsize_of_alloc(bcx.ccx(), sizing_type);
// `Box<ZeroSizeType>` does not allocate.
if content_size != 0 {
let content_align = align_of(bcx.ccx(), content_ty);
- trans_exchange_free(bcx, ptr, content_size, content_align)
+ trans_exchange_free(bcx, ptr, content_size, content_align, debug_loc)
} else {
bcx
}
// Return the sum of sizes and max of aligns.
let size = Add(bcx, sized_size, unsized_size, DebugLoc::None);
let align = Select(bcx,
- ICmp(bcx, llvm::IntULT, sized_align, unsized_align),
+ ICmp(bcx,
+ llvm::IntULT,
+ sized_align,
+ unsized_align,
+ DebugLoc::None),
sized_align,
unsized_align);
(size, align)
let info = GEPi(bcx, v0, &[0, abi::FAT_PTR_EXTRA]);
let info = Load(bcx, info);
let (llsize, llalign) = size_and_align_of_dst(bcx, content_ty, info);
- trans_exchange_free_dyn(bcx, llbox, llsize, llalign)
+ trans_exchange_free_dyn(bcx, llbox, llsize, llalign, DebugLoc::None)
})
}
_ => {
let not_null = IsNotNull(bcx, llbox);
with_cond(bcx, not_null, |bcx| {
let bcx = drop_ty(bcx, llbox, content_ty, DebugLoc::None);
- trans_exchange_free_ty(bcx, llbox, content_ty)
+ trans_exchange_free_ty(bcx, llbox, content_ty, DebugLoc::None)
})
}
}
use util::ppaux::{Repr, ty_to_string};
pub fn get_simple_intrinsic(ccx: &CrateContext, item: &ast::ForeignItem) -> Option<ValueRef> {
- let name = match token::get_ident(item.ident).get() {
+ let name = match &token::get_ident(item.ident)[] {
"sqrtf32" => "llvm.sqrt.f32",
"sqrtf64" => "llvm.sqrt.f64",
"powif32" => "llvm.powi.f32",
let name = token::get_ident(foreign_item.ident);
// For `transmute` we can just trans the input expr directly into dest
- if name.get() == "transmute" {
+ if &name[] == "transmute" {
let llret_ty = type_of::type_of(ccx, ret_ty.unwrap());
match args {
callee::ArgExprs(arg_exprs) => {
let call_debug_location = DebugLoc::At(call_info.id, call_info.span);
// These are the only intrinsic functions that diverge.
- if name.get() == "abort" {
+ if &name[] == "abort" {
let llfn = ccx.get_intrinsic(&("llvm.trap"));
Call(bcx, llfn, &[], None, call_debug_location);
fcx.pop_and_trans_custom_cleanup_scope(bcx, cleanup_scope);
Unreachable(bcx);
return Result::new(bcx, C_undef(Type::nil(ccx).ptr_to()));
- } else if name.get() == "unreachable" {
+ } else if &name[] == "unreachable" {
fcx.pop_and_trans_custom_cleanup_scope(bcx, cleanup_scope);
Unreachable(bcx);
return Result::new(bcx, C_nil(ccx));
};
let simple = get_simple_intrinsic(ccx, &*foreign_item);
- let llval = match (simple, name.get()) {
+ let llval = match (simple, &name[]) {
(Some(llfn), _) => {
Call(bcx, llfn, &llargs, None, call_debug_location)
}
(_, "init") => {
let tp_ty = *substs.types.get(FnSpace, 0);
if !return_type_is_void(ccx, tp_ty) {
- // Just zero out the stack slot. (See comment on base::memzero for explaination)
+ // Just zero out the stack slot. (See comment on base::memzero for explanation)
zero_mem(bcx, llresult, tp_ty);
}
C_nil(ccx)
method_offset_in_vtable);
bcx = trans_call_inner(bcx,
- None,
+ DebugLoc::None,
method_bare_fn_ty,
|bcx, _| trans_trait_callee_from_llval(bcx,
method_bare_fn_ty,
let unit_size = llsize_of_alloc(ccx, llty);
if unit_size != 0 {
let len = get_len(bcx, vptr);
- let not_empty = ICmp(bcx, llvm::IntNE, len, C_uint(ccx, 0us));
+ let not_empty = ICmp(bcx,
+ llvm::IntNE,
+ len,
+ C_uint(ccx, 0us),
+ DebugLoc::None);
with_cond(bcx, not_empty, |bcx| {
let llalign = C_uint(ccx, machine::llalign_of_min(ccx, llty));
let size = Mul(bcx, C_uint(ccx, unit_size), len, DebugLoc::None);
- glue::trans_exchange_free_dyn(bcx, dataptr, size, llalign)
+ glue::trans_exchange_free_dyn(bcx,
+ dataptr,
+ size,
+ llalign,
+ DebugLoc::None)
})
} else {
bcx
match dest {
Ignore => bcx,
SaveIn(lldest) => {
- let bytes = str_lit.get().len();
+ let bytes = str_lit.len();
let llbytes = C_uint(bcx.ccx(), bytes);
let llcstr = C_cstr(bcx.ccx(), str_lit, false);
let llcstr = consts::ptrcast(llcstr, Type::i8p(bcx.ccx()));
match dest {
Ignore => return bcx,
SaveIn(lldest) => {
- let bytes = s.get().len();
+ let bytes = s.len();
let llbytes = C_uint(bcx.ccx(), bytes);
let llcstr = C_cstr(bcx.ccx(), (*s).clone(), false);
base::call_memcpy(bcx,
match content_expr.node {
ast::ExprLit(ref lit) => {
match lit.node {
- ast::LitStr(ref s, _) => s.get().len(),
+ ast::LitStr(ref s, _) => s.len(),
_ => {
bcx.tcx().sess.span_bug(content_expr.span,
"unexpected evec content")
{ // i < count
let lhs = Load(cond_bcx, loop_counter);
let rhs = count;
- let cond_val = ICmp(cond_bcx, llvm::IntULT, lhs, rhs);
+ let cond_val = ICmp(cond_bcx, llvm::IntULT, lhs, rhs, DebugLoc::None);
CondBr(cond_bcx, cond_val, body_bcx.llbb, next_bcx.llbb, DebugLoc::None);
}
let data_ptr =
Phi(header_bcx, val_ty(data_ptr), &[data_ptr], &[bcx.llbb]);
let not_yet_at_end =
- ICmp(header_bcx, llvm::IntULT, data_ptr, data_end_ptr);
+ ICmp(header_bcx, llvm::IntULT, data_ptr, data_end_ptr, DebugLoc::None);
let body_bcx = fcx.new_temp_block("iter_vec_loop_body");
let next_bcx = fcx.new_temp_block("iter_vec_next");
CondBr(header_bcx, not_yet_at_end, body_bcx.llbb, next_bcx.llbb, DebugLoc::None);
}
/// Iterator for the users of a value
-#[allow(missing_copy_implementations)]
pub struct Users {
next: Option<Use>
}
{
let mut projections = Vec::new();
- // the trait reference introduces a binding level here, so
+ // The trait reference introduces a binding level here, so
// we need to shift the `rscope`. It'd be nice if we could
// do away with this rscope stuff and work this knowledge
// into resolve_lifetimes, as we do with non-omitted
using the syntax `<Type \
as {}>::{}`",
path_str,
- token::get_ident(
+ &token::get_ident(
path.segments
.last()
.unwrap()
- .identifier)
- .get());
+ .identifier));
this.tcx().types.err
}
def::DefAssociatedPath(provenance, assoc_ident) => {
// 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
+ // We now use these substitutions 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
+ // substitution 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.
//
a.check_name("rustc_on_unimplemented")
}) {
if let Some(ref istring) = attr.value_str() {
- let parser = Parser::new(istring.get());
+ let parser = Parser::new(&istring);
let types = &*generics.ty_params;
for token in parser {
match token {
tcx : &ty::ctxt<'tcx>,
skip : Vec<&str>) {
let ident = token::get_ident(field.node);
- let name = ident.get();
+ let name = &ident;
// only find fits with at least one matching letter
let mut best_dist = name.len();
let fields = ty::lookup_struct_fields(tcx, id);
let (_, seen) = class_field_map[name];
if !seen {
missing_fields.push(
- format!("`{}`", token::get_name(name).get()))
+ format!("`{}`", &token::get_name(name)))
}
}
let tcx = ccx.tcx;
let name = token::get_ident(it.ident);
- let (n_tps, inputs, output) = if name.get().starts_with("atomic_") {
- let split : Vec<&str> = name.get().split('_').collect();
+ let (n_tps, inputs, output) = if name.starts_with("atomic_") {
+ let split : Vec<&str> = name.split('_').collect();
assert!(split.len() >= 2, "Atomic intrinsic not correct format");
//We only care about the operation here
}
};
(n_tps, inputs, ty::FnConverging(output))
- } else if name.get() == "abort" || name.get() == "unreachable" {
+ } else if &name[] == "abort" || &name[] == "unreachable" {
(0, Vec::new(), ty::FnDiverging)
} else {
- let (n_tps, inputs, output) = match name.get() {
+ let (n_tps, inputs, output) = match &name[] {
"breakpoint" => (0, Vec::new(), ty::mk_nil(tcx)),
"size_of" |
"pref_align_of" | "min_align_of" => (1, Vec::new(), ccx.tcx.types.uint),
pub fn select_all_fcx_obligations_or_error(fcx: &FnCtxt) {
debug!("select_all_fcx_obligations_or_error");
- // upvar inference should have ensured that all deferrred call
+ // upvar inference should have ensured that all deferred call
// resolutions are handled by now.
assert!(fcx.inh.deferred_call_resolutions.borrow().is_empty());
let span = self.reason.span(self.tcx);
span_err!(self.tcx.sess, span, E0104,
"cannot resolve lifetime for captured variable `{}`: {}",
- ty::local_var_name_str(self.tcx, upvar_id.var_id).get().to_string(),
+ ty::local_var_name_str(self.tcx, upvar_id.var_id).to_string(),
infer::fixup_err_to_string(e));
}
E0189, // can only cast a boxed pointer to a boxed object
E0190, // can only cast a &-pointer to an &-object
E0191, // value of the associated type must be specified
- E0192, // negative imples are allowed just fo `Send` and `Sync`
+ E0192, // negative imples are allowed just for `Send` and `Sync`
E0193, // cannot bound type where clause bounds may only be attached to types
// involving type parameters
E0194,
E0199, // implementing trait is not unsafe
E0200, // trait requires an `unsafe impl` declaration
E0201, // duplicate method in trait impl
- E0202, // associated items are not allowed in inherint impls
+ E0202, // associated items are not allowed in inherent impls
E0203, // type parameter has more than one relaxed default bound,
// and only one is supported
E0204, // trait `Copy` may not be implemented for this type; field
#![feature(rustc_private)]
#![feature(slicing_syntax, unsafe_destructor)]
#![feature(staged_api)]
-#![feature(std_misc)]
#[macro_use] extern crate log;
#[macro_use] extern crate syntax;
// A scope in which any omitted region defaults to `default`. This is
// used after the `->` in function signatures, but also for backwards
// compatibility with object types. The latter use may go away.
-#[allow(missing_copy_implementations)]
pub struct SpecificRscope {
default: ty::Region
}
use self::ParamKind::*;
use arena;
-use arena::Arena;
+use arena::TypedArena;
use middle::resolve_lifetime as rl;
use middle::subst;
use middle::subst::{ParamSpace, FnSpace, TypeSpace, SelfSpace, VecPerParamSpace};
pub fn infer_variance(tcx: &ty::ctxt) {
let krate = tcx.map.krate();
- let mut arena = arena::Arena::new();
+ let mut arena = arena::TypedArena::new();
let terms_cx = determine_parameters_to_be_inferred(tcx, &mut arena, krate);
let constraints_cx = add_constraints_from_crate(terms_cx, krate);
solve_constraints(constraints_cx);
struct TermsContext<'a, 'tcx: 'a> {
tcx: &'a ty::ctxt<'tcx>,
- arena: &'a Arena,
+ arena: &'a TypedArena<VarianceTerm<'a>>,
empty_variances: Rc<ty::ItemVariances>,
}
fn determine_parameters_to_be_inferred<'a, 'tcx>(tcx: &'a ty::ctxt<'tcx>,
- arena: &'a mut Arena,
+ arena: &'a mut TypedArena<VarianceTerm<'a>>,
krate: &ast::Crate)
-> TermsContext<'a, 'tcx> {
let mut terms_cx = TermsContext {
index: uint,
param_id: ast::NodeId) {
let inf_index = InferredIndex(self.inferred_infos.len());
- let term = self.arena.alloc(|| InferredTerm(inf_index));
+ let term = self.arena.alloc(InferredTerm(inf_index));
self.inferred_infos.push(InferredInfo { item_id: item_id,
kind: kind,
space: space,
let unsafe_lang_item = terms_cx.tcx.lang_items.unsafe_type();
- let covariant = terms_cx.arena.alloc(|| ConstantTerm(ty::Covariant));
- let contravariant = terms_cx.arena.alloc(|| ConstantTerm(ty::Contravariant));
- let invariant = terms_cx.arena.alloc(|| ConstantTerm(ty::Invariant));
- let bivariant = terms_cx.arena.alloc(|| ConstantTerm(ty::Bivariant));
+ let covariant = terms_cx.arena.alloc(ConstantTerm(ty::Covariant));
+ let contravariant = terms_cx.arena.alloc(ConstantTerm(ty::Contravariant));
+ let invariant = terms_cx.arena.alloc(ConstantTerm(ty::Invariant));
+ let bivariant = terms_cx.arena.alloc(ConstantTerm(ty::Bivariant));
let mut constraint_cx = ConstraintContext {
terms_cx: terms_cx,
}
_ => {
- &*self.terms_cx.arena.alloc(|| TransformTerm(v1, v2))
+ &*self.terms_cx.arena.alloc(TransformTerm(v1, v2))
}
}
}
let mut item = method.clean(cx);
item.inner = match item.inner.clone() {
clean::TyMethodItem(clean::TyMethod {
- unsafety, decl, self_, generics
+ unsafety, decl, self_, generics, abi
}) => {
clean::MethodItem(clean::Method {
unsafety: unsafety,
decl: decl,
self_: self_,
generics: generics,
+ abi: abi
})
}
_ => panic!("not a tymethod"),
pub use self::TraitMethod::*;
use syntax;
+use syntax::abi;
use syntax::ast;
use syntax::ast_util;
use syntax::ast_util::PostExpansionMethod;
impl Clean<Attribute> for ast::MetaItem {
fn clean(&self, cx: &DocContext) -> Attribute {
match self.node {
- ast::MetaWord(ref s) => Word(s.get().to_string()),
+ ast::MetaWord(ref s) => Word(s.to_string()),
ast::MetaList(ref s, ref l) => {
- List(s.get().to_string(), l.clean(cx))
+ List(s.to_string(), l.clean(cx))
}
ast::MetaNameValue(ref s, ref v) => {
- NameValue(s.get().to_string(), lit_to_string(v))
+ NameValue(s.to_string(), lit_to_string(v))
}
}
}
impl Clean<Lifetime> for ast::Lifetime {
fn clean(&self, _: &DocContext) -> Lifetime {
- Lifetime(token::get_name(self.name).get().to_string())
+ Lifetime(token::get_name(self.name).to_string())
}
}
impl Clean<Lifetime> for ast::LifetimeDef {
fn clean(&self, _: &DocContext) -> Lifetime {
- Lifetime(token::get_name(self.lifetime.name).get().to_string())
+ Lifetime(token::get_name(self.lifetime.name).to_string())
}
}
impl Clean<Lifetime> for ty::RegionParameterDef {
fn clean(&self, _: &DocContext) -> Lifetime {
- Lifetime(token::get_name(self.name).get().to_string())
+ Lifetime(token::get_name(self.name).to_string())
}
}
match *self {
ty::ReStatic => Some(Lifetime::statik()),
ty::ReLateBound(_, ty::BrNamed(_, name)) =>
- Some(Lifetime(token::get_name(name).get().to_string())),
+ Some(Lifetime(token::get_name(name).to_string())),
ty::ReEarlyBound(_, _, _, name) => Some(Lifetime(name.clean(cx))),
ty::ReLateBound(..) |
pub self_: SelfTy,
pub unsafety: ast::Unsafety,
pub decl: FnDecl,
+ pub abi: abi::Abi
}
impl Clean<Item> for ast::Method {
self_: self.pe_explicit_self().node.clean(cx),
unsafety: self.pe_unsafety().clone(),
decl: decl,
+ abi: self.pe_abi()
}),
}
}
pub decl: FnDecl,
pub generics: Generics,
pub self_: SelfTy,
+ pub abi: abi::Abi
}
impl Clean<Item> for ast::TypeMethod {
decl: decl,
self_: self.explicit_self.node.clean(cx),
generics: self.generics.clean(cx),
+ abi: self.abi
}),
}
}
generics: (&self.generics, subst::FnSpace).clean(cx),
self_: self_,
decl: (self.def_id, &sig).clean(cx),
+ abi: self.fty.abi
})
}
}
} else {
first = false;
}
- s.push_str(i.get());
+ s.push_str(&i);
}
s
}
impl Clean<String> for ast::Ident {
fn clean(&self, _: &DocContext) -> String {
- token::get_ident(*self).get().to_string()
+ token::get_ident(*self).to_string()
}
}
impl Clean<String> for ast::Name {
fn clean(&self, _: &DocContext) -> String {
- token::get_name(*self).get().to_string()
+ token::get_name(*self).to_string()
}
}
// forcefully don't inline if this is not public or if the
// #[doc(no_inline)] attribute is present.
let denied = self.vis != ast::Public || self.attrs.iter().any(|a| {
- a.name().get() == "doc" && match a.meta_item_list() {
+ &a.name()[] == "doc" && match a.meta_item_list() {
Some(l) => attr::contains_name(l, "no_inline"),
None => false,
}
fn to_src(&self, cx: &DocContext) -> String {
debug!("converting span {:?} to snippet", self.clean(cx));
let sn = match cx.sess().codemap().span_to_snippet(*self) {
- Some(x) => x.to_string(),
- None => "".to_string()
+ Ok(x) => x.to_string(),
+ Err(_) => "".to_string()
};
debug!("got snippet {}", sn);
sn
fn lit_to_string(lit: &ast::Lit) -> String {
match lit.node {
- ast::LitStr(ref st, _) => st.get().to_string(),
+ ast::LitStr(ref st, _) => st.to_string(),
ast::LitBinary(ref data) => format!("{:?}", data),
ast::LitByte(b) => {
let mut res = String::from_str("b'");
},
ast::LitChar(c) => format!("'{}'", c),
ast::LitInt(i, _t) => i.to_string(),
- ast::LitFloat(ref f, _t) => f.get().to_string(),
- ast::LitFloatUnsuffixed(ref f) => f.get().to_string(),
+ ast::LitFloat(ref f, _t) => f.to_string(),
+ ast::LitFloatUnsuffixed(ref f) => f.to_string(),
ast::LitBool(b) => b.to_string(),
}
}
match p.node {
PatWild(PatWildSingle) => "_".to_string(),
PatWild(PatWildMulti) => "..".to_string(),
- PatIdent(_, ref p, _) => token::get_ident(p.node).get().to_string(),
+ PatIdent(_, ref p, _) => token::get_ident(p.node).to_string(),
PatEnum(ref p, _) => path_to_string(p),
PatStruct(ref name, ref fields, etc) => {
format!("{} {{ {}{} }}", path_to_string(name),
fn clean(&self, _: &DocContext) -> Stability {
Stability {
level: self.level,
- feature: self.feature.get().to_string(),
+ feature: self.feature.to_string(),
since: self.since.as_ref().map_or("".to_string(),
- |interned| interned.get().to_string()),
+ |interned| interned.to_string()),
reason: self.reason.as_ref().map_or("".to_string(),
- |interned| interned.get().to_string()),
+ |interned| interned.to_string()),
}
}
}
f.write_str(name)
}
clean::ResolvedPath{ did, ref typarams, ref path } => {
- try!(resolved_path(f, did, path, false));
+ // Paths like Self::Output should be rendered with all segments
+ try!(resolved_path(f, did, path, path.segments[0].name == "Self"));
tybounds(f, typarams)
}
clean::Infer => write!(f, "_"),
// keywords are also included in the identifier set
token::Ident(ident, _is_mod_sep) => {
- match token::get_ident(ident).get() {
+ match &token::get_ident(ident)[] {
"ref" | "mut" => "kw-2",
"self" => "self",
}
+// hoedown_buffer helpers
+impl hoedown_buffer {
+ fn as_bytes(&self) -> &[u8] {
+ unsafe { slice::from_raw_parts(self.data, self.size as usize) }
+ }
+}
+
/// Returns Some(code) if `s` is a line that should be stripped from
/// documentation but used in example code. `code` is the portion of
/// `s` that should be used in tests. (None for lines that should be
let opaque = opaque as *mut hoedown_html_renderer_state;
let my_opaque: &MyOpaque = &*((*opaque).opaque as *const MyOpaque);
- let text = slice::from_raw_buf(&(*orig_text).data,
- (*orig_text).size as uint);
+ let text = (*orig_text).as_bytes();
let origtext = str::from_utf8(text).unwrap();
debug!("docblock: ==============\n{:?}\n=======", text);
let rendered = if lang.is_null() {
false
} else {
- let rlang = slice::from_raw_buf(&(*lang).data,
- (*lang).size as uint);
+ let rlang = (*lang).as_bytes();
let rlang = str::from_utf8(rlang).unwrap();
if !LangString::parse(rlang).rust {
(my_opaque.dfltblk)(ob, orig_text, lang,
let s = if text.is_null() {
"".to_string()
} else {
- let s = unsafe {
- slice::from_raw_buf(&(*text).data, (*text).size as uint)
- };
+ let s = unsafe { (*text).as_bytes() };
str::from_utf8(s).unwrap().to_string()
};
};
if ret.is_ok() {
- let buf = slice::from_raw_buf(&(*ob).data, (*ob).size as uint);
+ let buf = (*ob).as_bytes();
ret = w.write_str(str::from_utf8(buf).unwrap());
}
hoedown_buffer_free(ob);
let block_info = if lang.is_null() {
LangString::all_false()
} else {
- let lang = slice::from_raw_buf(&(*lang).data,
- (*lang).size as uint);
+ let lang = (*lang).as_bytes();
let s = str::from_utf8(lang).unwrap();
LangString::parse(s)
};
if !block_info.rust { return }
- let text = slice::from_raw_buf(&(*text).data, (*text).size as uint);
+ let text = (*text).as_bytes();
let opaque = opaque as *mut hoedown_html_renderer_state;
let tests = &mut *((*opaque).opaque as *mut ::test::Collector);
let text = str::from_utf8(text).unwrap();
if text.is_null() {
tests.register_header("", level as u32);
} else {
- let text = slice::from_raw_buf(&(*text).data, (*text).size as uint);
+ let text = (*text).as_bytes();
let text = str::from_utf8(text).unwrap();
tests.register_header(text, level as u32);
}
hoedown_document_render(document, ob, md.as_ptr(),
md.len() as libc::size_t);
hoedown_document_free(document);
- let plain_slice = slice::from_raw_buf(&(*ob).data, (*ob).size as uint);
+ let plain_slice = (*ob).as_bytes();
let plain = match str::from_utf8(plain_slice) {
Ok(s) => s.to_string(),
Err(_) => "".to_string(),
use serialize::json;
use serialize::json::ToJson;
+use syntax::abi;
use syntax::ast;
use syntax::ast_util;
use rustc::util::nodemap::NodeSet;
}
fn render_method(w: &mut fmt::Formatter, meth: &clean::Item) -> fmt::Result {
- fn method(w: &mut fmt::Formatter, it: &clean::Item, unsafety: ast::Unsafety,
- g: &clean::Generics, selfty: &clean::SelfTy,
- d: &clean::FnDecl) -> fmt::Result {
- write!(w, "{}fn <a href='#{ty}.{name}' class='fnname'>{name}</a>\
+ fn method(w: &mut fmt::Formatter, it: &clean::Item,
+ unsafety: ast::Unsafety, abi: abi::Abi,
+ g: &clean::Generics, selfty: &clean::SelfTy,
+ d: &clean::FnDecl) -> fmt::Result {
+ use syntax::abi::Abi;
+
+ write!(w, "{}{}fn <a href='#{ty}.{name}' class='fnname'>{name}</a>\
{generics}{decl}{where_clause}",
match unsafety {
ast::Unsafety::Unsafe => "unsafe ",
_ => "",
},
+ match abi {
+ Abi::Rust => String::new(),
+ a => format!("extern {} ", a.to_string())
+ },
ty = shortty(it),
name = it.name.as_ref().unwrap(),
generics = *g,
}
match meth.inner {
clean::TyMethodItem(ref m) => {
- method(w, meth, m.unsafety, &m.generics, &m.self_, &m.decl)
+ method(w, meth, m.unsafety, m.abi, &m.generics, &m.self_, &m.decl)
}
clean::MethodItem(ref m) => {
- method(w, meth, m.unsafety, &m.generics, &m.self_, &m.decl)
+ method(w, meth, m.unsafety, m.abi, &m.generics, &m.self_, &m.decl)
}
clean::AssociatedTypeItem(ref typ) => {
assoc_type(w, meth, typ)
use std::collections::{HashSet, HashMap};
use testing;
use rustc::session::{self, config};
+use rustc::session::config::get_unstable_features_setting;
use rustc::session::search_paths::{SearchPaths, PathKind};
-use rustc_driver::get_unstable_features_setting;
-use rustc_driver::driver;
+use rustc_driver::{driver, Compilation};
use syntax::ast;
use syntax::codemap::{CodeMap, dummy_spanned};
use syntax::diagnostic;
let libdir = sess.target_filesearch(PathKind::All).get_lib_path();
let mut control = driver::CompileController::basic();
if no_run {
- control.after_analysis.stop = true;
+ control.after_analysis.stop = Compilation::Stop;
}
driver::compile_input(sess, cfg, &input, &out, &None, None, control);
ast::ItemExternCrate(ref p) => {
let path = match *p {
None => None,
- Some((ref x, _)) => Some(x.get().to_string()),
+ Some((ref x, _)) => Some(x.to_string()),
};
om.extern_crates.push(ExternCrate {
name: name,
let please_inline = item.attrs.iter().any(|item| {
match item.meta_item_list() {
Some(list) => {
- list.iter().any(|i| i.name().get() == "inline")
+ list.iter().any(|i| &i.name()[] == "inline")
}
None => false,
}
fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
let mut bits = 0;
for item in self {
- bits |= item.to_uint();
+ bits |= item.to_usize();
}
s.emit_uint(bits)
}
let mut set = EnumSet::new();
for bit in 0..uint::BITS {
if bits & (1 << bit) != 0 {
- set.insert(CLike::from_uint(1 << bit));
+ set.insert(CLike::from_usize(1 << bit));
}
}
Ok(set)
use super::map::HashMap;
b.iter(|| {
- let m : HashMap<int, int> = HashMap::new();
+ let m : HashMap<i32, i32> = HashMap::new();
assert_eq!(m.len(), 0);
})
}
};
use super::state::HashState;
-const INITIAL_LOG2_CAP: uint = 5;
+const INITIAL_LOG2_CAP: usize = 5;
#[unstable(feature = "std_misc")]
-pub const INITIAL_CAPACITY: uint = 1 << INITIAL_LOG2_CAP; // 2^5
+pub const INITIAL_CAPACITY: usize = 1 << INITIAL_LOG2_CAP; // 2^5
/// The default behavior of HashMap implements a load factor of 90.9%.
/// This behavior is characterized by the following condition:
}
#[inline]
- fn min_capacity(&self, usable_size: uint) -> uint {
+ fn min_capacity(&self, usable_size: usize) -> usize {
// Here, we are rephrasing the logic by specifying the lower limit
// on capacity:
//
/// An inverse of `min_capacity`, approximately.
#[inline]
- fn usable_capacity(&self, cap: uint) -> uint {
+ fn usable_capacity(&self, cap: usize) -> usize {
// As the number of entries approaches usable capacity,
// min_capacity(size) must be smaller than the internal capacity,
// so that the map is not resized:
fn test_resize_policy() {
use prelude::v1::*;
let rp = DefaultResizePolicy;
- for n in 0u..1000 {
+ for n in 0..1000 {
assert!(rp.min_capacity(rp.usable_capacity(n)) <= n);
assert!(rp.usable_capacity(rp.min_capacity(n)) <= n);
}
/// // Use a HashMap to store the vikings' health points.
/// let mut vikings = HashMap::new();
///
-/// vikings.insert(Viking::new("Einar", "Norway"), 25u);
-/// vikings.insert(Viking::new("Olaf", "Denmark"), 24u);
-/// vikings.insert(Viking::new("Harald", "Iceland"), 12u);
+/// vikings.insert(Viking::new("Einar", "Norway"), 25);
+/// vikings.insert(Viking::new("Olaf", "Denmark"), 24);
+/// vikings.insert(Viking::new("Harald", "Iceland"), 12);
///
/// // Use derived implementation to print the status of the vikings.
/// for (viking, health) in vikings.iter() {
///
/// `hash`, `k`, and `v` are the elements to "robin hood" into the hashtable.
fn robin_hood<'a, K: 'a, V: 'a>(mut bucket: FullBucketMut<'a, K, V>,
- mut ib: uint,
+ mut ib: usize,
mut hash: SafeHash,
mut k: K,
mut v: V)
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn with_capacity(capacity: uint) -> HashMap<K, V, RandomState> {
+ pub fn with_capacity(capacity: usize) -> HashMap<K, V, RandomState> {
HashMap::with_capacity_and_hash_state(capacity, Default::default())
}
}
///
/// let s = RandomState::new();
/// let mut map = HashMap::with_hash_state(s);
- /// map.insert(1, 2u);
+ /// map.insert(1, 2);
/// ```
#[inline]
#[unstable(feature = "std_misc", reason = "hasher stuff is unclear")]
///
/// let s = RandomState::new();
/// let mut map = HashMap::with_capacity_and_hash_state(10, s);
- /// map.insert(1, 2u);
+ /// map.insert(1, 2);
/// ```
#[inline]
#[unstable(feature = "std_misc", reason = "hasher stuff is unclear")]
- pub fn with_capacity_and_hash_state(capacity: uint, hash_state: S)
+ pub fn with_capacity_and_hash_state(capacity: usize, hash_state: S)
-> HashMap<K, V, S> {
let resize_policy = DefaultResizePolicy::new();
let min_cap = max(INITIAL_CAPACITY, resize_policy.min_capacity(capacity));
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn capacity(&self) -> uint {
+ pub fn capacity(&self) -> usize {
self.resize_policy.usable_capacity(self.table.capacity())
}
///
/// # Panics
///
- /// Panics if the new allocation size overflows `uint`.
+ /// Panics if the new allocation size overflows `usize`.
///
/// # Example
///
/// map.reserve(10);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn reserve(&mut self, additional: uint) {
+ pub fn reserve(&mut self, additional: usize) {
let new_size = self.len().checked_add(additional).expect("capacity overflow");
let min_cap = self.resize_policy.min_capacity(new_size);
/// 1) Make sure the new capacity is enough for all the elements, accounting
/// for the load factor.
/// 2) Ensure new_capacity is a power of two or zero.
- fn resize(&mut self, new_capacity: uint) {
+ fn resize(&mut self, new_capacity: usize) {
assert!(self.table.size() <= new_capacity);
assert!(new_capacity.is_power_of_two() || new_capacity == 0);
if (ib as int) < robin_ib {
// Found a luckier bucket than me. Better steal his spot.
- return robin_hood(bucket, robin_ib as uint, hash, k, v);
+ return robin_hood(bucket, robin_ib as usize, hash, k, v);
}
probe = bucket.next();
}
/// Gets the given key's corresponding entry in the map for in-place manipulation.
- #[unstable(feature = "std_misc",
- reason = "precise API still being fleshed out")]
- pub fn entry<'a>(&'a mut self, key: K) -> Entry<'a, K, V>
- {
+ #[stable(feature = "rust1", since = "1.0.0")]
+ pub fn entry(&mut self, key: K) -> Entry<K, V> {
// Gotta resize now.
self.reserve(1);
///
/// let mut a = HashMap::new();
/// assert_eq!(a.len(), 0);
- /// a.insert(1u, "a");
+ /// a.insert(1, "a");
/// assert_eq!(a.len(), 1);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn len(&self) -> uint { self.table.size() }
+ pub fn len(&self) -> usize { self.table.size() }
/// Returns true if the map contains no elements.
///
///
/// let mut a = HashMap::new();
/// assert!(a.is_empty());
- /// a.insert(1u, "a");
+ /// a.insert(1, "a");
/// assert!(!a.is_empty());
/// ```
#[inline]
/// use std::collections::HashMap;
///
/// let mut a = HashMap::new();
- /// a.insert(1u, "a");
- /// a.insert(2u, "b");
+ /// a.insert(1, "a");
+ /// a.insert(2, "b");
///
/// for (k, v) in a.drain().take(1) {
/// assert!(k == 1 || k == 2);
/// use std::collections::HashMap;
///
/// let mut a = HashMap::new();
- /// a.insert(1u, "a");
+ /// a.insert(1, "a");
/// a.clear();
/// assert!(a.is_empty());
/// ```
/// use std::collections::HashMap;
///
/// let mut map = HashMap::new();
- /// map.insert(1u, "a");
+ /// map.insert(1, "a");
/// assert_eq!(map.get(&1), Some(&"a"));
/// assert_eq!(map.get(&2), None);
/// ```
/// use std::collections::HashMap;
///
/// let mut map = HashMap::new();
- /// map.insert(1u, "a");
+ /// map.insert(1, "a");
/// assert_eq!(map.contains_key(&1), true);
/// assert_eq!(map.contains_key(&2), false);
/// ```
/// use std::collections::HashMap;
///
/// let mut map = HashMap::new();
- /// map.insert(1u, "a");
+ /// map.insert(1, "a");
/// match map.get_mut(&1) {
/// Some(x) => *x = "b",
/// None => (),
/// use std::collections::HashMap;
///
/// let mut map = HashMap::new();
- /// assert_eq!(map.insert(37u, "a"), None);
+ /// assert_eq!(map.insert(37, "a"), None);
/// assert_eq!(map.is_empty(), false);
///
/// map.insert(37, "b");
/// use std::collections::HashMap;
///
/// let mut map = HashMap::new();
- /// map.insert(1u, "a");
+ /// map.insert(1, "a");
/// assert_eq!(map.remove(&1), Some("a"));
/// assert_eq!(map.remove(&1), None);
/// ```
return Vacant(VacantEntry {
hash: hash,
key: k,
- elem: NeqElem(bucket, robin_ib as uint),
+ elem: NeqElem(bucket, robin_ib as usize),
});
}
S: HashState<Hasher=H>,
H: hash::Hasher<Output=u64>
{
- type Output = V;
-
#[inline]
fn index_mut<'a>(&'a mut self, index: &Q) -> &'a mut V {
self.get_mut(index).expect("no entry found for key")
enum VacantEntryState<K, V, M> {
/// The index is occupied, but the key to insert has precedence,
/// and will kick the current one out on insertion.
- NeqElem(FullBucket<K, V, M>, uint),
+ NeqElem(FullBucket<K, V, M>, usize),
/// The index is genuinely vacant.
NoElem(EmptyBucket<K, V, M>),
}
}
}
-#[unstable(feature = "std_misc",
- reason = "matches collection reform v2 specification, waiting for dust to settle")]
impl<'a, K, V> OccupiedEntry<'a, K, V> {
/// Gets a reference to the value in the entry.
+ #[stable(feature = "rust1", since = "1.0.0")]
pub fn get(&self) -> &V {
self.elem.read().1
}
/// Gets a mutable reference to the value in the entry.
+ #[stable(feature = "rust1", since = "1.0.0")]
pub fn get_mut(&mut self) -> &mut V {
self.elem.read_mut().1
}
/// Converts the OccupiedEntry into a mutable reference to the value in the entry
/// with a lifetime bound to the map itself
+ #[stable(feature = "rust1", since = "1.0.0")]
pub fn into_mut(self) -> &'a mut V {
self.elem.into_mut_refs().1
}
/// Sets the value of the entry, and returns the entry's old value
+ #[stable(feature = "rust1", since = "1.0.0")]
pub fn insert(&mut self, mut value: V) -> V {
let old_value = self.get_mut();
mem::swap(&mut value, old_value);
}
/// Takes the value out of the entry, and returns it
+ #[stable(feature = "rust1", since = "1.0.0")]
pub fn remove(self) -> V {
pop_internal(self.elem).1
}
}
-#[unstable(feature = "std_misc",
- reason = "matches collection reform v2 specification, waiting for dust to settle")]
impl<'a, K: 'a, V: 'a> VacantEntry<'a, K, V> {
/// Sets the value of the entry with the VacantEntry's key,
/// and returns a mutable reference to it
+ #[stable(feature = "rust1", since = "1.0.0")]
pub fn insert(self, value: V) -> &'a mut V {
match self.elem {
NeqElem(bucket, ib) => {
/// `Hasher`, but the hashers created by two different `RandomState`
/// instances are unlikely to produce the same result for the same values.
#[derive(Clone)]
-#[allow(missing_copy_implementations)]
#[unstable(feature = "std_misc",
reason = "hashing an hash maps may be altered")]
pub struct RandomState {
/// This is the default hasher used in a `HashMap` to hash keys. Types do not
/// typically declare an ability to explicitly hash into this particular type,
/// but rather in a `H: hash::Writer` type parameter.
-#[allow(missing_copy_implementations)]
#[unstable(feature = "std_misc",
reason = "hashing an hash maps may be altered")]
pub struct Hasher { inner: SipHasher }
#[derive(Hash, PartialEq, Eq)]
struct Dropable {
- k: uint
+ k: usize
}
impl Dropable {
- fn new(k: uint) -> Dropable {
+ fn new(k: usize) -> Dropable {
DROP_VECTOR.with(|slot| {
slot.borrow_mut()[k] += 1;
});
let mut m = HashMap::new();
DROP_VECTOR.with(|v| {
- for i in 0u..200 {
+ for i in 0..200 {
assert_eq!(v.borrow()[i], 0);
}
});
- for i in 0u..100 {
+ for i in 0..100 {
let d1 = Dropable::new(i);
let d2 = Dropable::new(i+100);
m.insert(d1, d2);
}
DROP_VECTOR.with(|v| {
- for i in 0u..200 {
+ for i in 0..200 {
assert_eq!(v.borrow()[i], 1);
}
});
- for i in 0u..50 {
+ for i in 0..50 {
let k = Dropable::new(i);
let v = m.remove(&k);
}
DROP_VECTOR.with(|v| {
- for i in 0u..50 {
+ for i in 0..50 {
assert_eq!(v.borrow()[i], 0);
assert_eq!(v.borrow()[i+100], 0);
}
- for i in 50u..100 {
+ for i in 50..100 {
assert_eq!(v.borrow()[i], 1);
assert_eq!(v.borrow()[i+100], 1);
}
}
DROP_VECTOR.with(|v| {
- for i in 0u..200 {
+ for i in 0..200 {
assert_eq!(v.borrow()[i], 0);
}
});
let mut hm = HashMap::new();
DROP_VECTOR.with(|v| {
- for i in 0u..200 {
+ for i in 0..200 {
assert_eq!(v.borrow()[i], 0);
}
});
- for i in 0u..100 {
+ for i in 0..100 {
let d1 = Dropable::new(i);
let d2 = Dropable::new(i+100);
hm.insert(d1, d2);
}
DROP_VECTOR.with(|v| {
- for i in 0u..200 {
+ for i in 0..200 {
assert_eq!(v.borrow()[i], 1);
}
});
let mut half = hm.into_iter().take(50);
DROP_VECTOR.with(|v| {
- for i in 0u..200 {
+ for i in 0..200 {
assert_eq!(v.borrow()[i], 1);
}
});
for _ in half.by_ref() {}
DROP_VECTOR.with(|v| {
- let nk = (0u..100).filter(|&i| {
+ let nk = (0..100).filter(|&i| {
v.borrow()[i] == 1
}).count();
- let nv = (0u..100).filter(|&i| {
+ let nv = (0..100).filter(|&i| {
v.borrow()[i+100] == 1
}).count();
};
DROP_VECTOR.with(|v| {
- for i in 0u..200 {
+ for i in 0..200 {
assert_eq!(v.borrow()[i], 0);
}
});
#[test]
fn test_iterate() {
let mut m = HashMap::with_capacity(4);
- for i in 0u..32 {
+ for i in 0..32 {
assert!(m.insert(i, i*2).is_none());
}
assert_eq!(m.len(), 32);
#[test]
fn test_keys() {
let vec = vec![(1, 'a'), (2, 'b'), (3, 'c')];
- let map = vec.into_iter().collect::<HashMap<int, char>>();
- let keys = map.keys().map(|&k| k).collect::<Vec<int>>();
+ let map: HashMap<_, _> = vec.into_iter().collect();
+ let keys: Vec<_> = map.keys().cloned().collect();
assert_eq!(keys.len(), 3);
assert!(keys.contains(&1));
assert!(keys.contains(&2));
#[test]
fn test_values() {
let vec = vec![(1, 'a'), (2, 'b'), (3, 'c')];
- let map = vec.into_iter().collect::<HashMap<int, char>>();
- let values = map.values().map(|&v| v).collect::<Vec<char>>();
+ let map: HashMap<_, _> = vec.into_iter().collect();
+ let values: Vec<_> = map.values().cloned().collect();
assert_eq!(values.len(), 3);
assert!(values.contains(&'a'));
assert!(values.contains(&'b'));
#[test]
fn test_show() {
- let mut map: HashMap<int, int> = HashMap::new();
- let empty: HashMap<int, int> = HashMap::new();
+ let mut map = HashMap::new();
+ let empty: HashMap<i32, i32> = HashMap::new();
map.insert(1, 2);
map.insert(3, 4);
assert_eq!(m.len(), 0);
assert!(m.is_empty());
- let mut i = 0u;
+ let mut i = 0;
let old_cap = m.table.capacity();
while old_cap == m.table.capacity() {
m.insert(i, i);
assert_eq!(cap, initial_cap * 2);
- let mut i = 0u;
+ let mut i = 0;
for _ in 0..cap * 3 / 4 {
m.insert(i, i);
i += 1;
#[test]
fn test_reserve_shrink_to_fit() {
let mut m = HashMap::new();
- m.insert(0u, 0u);
+ m.insert(0, 0);
m.remove(&0);
assert!(m.capacity() >= m.len());
- for i in 0us..128 {
+ for i in 0..128 {
m.insert(i, i);
}
m.reserve(256);
let usable_cap = m.capacity();
- for i in 128us..128+256 {
+ for i in 128..(128 + 256) {
m.insert(i, i);
assert_eq!(m.capacity(), usable_cap);
}
- for i in 100us..128+256 {
+ for i in 100..(128 + 256) {
assert_eq!(m.remove(&i), Some(i));
}
m.shrink_to_fit();
assert!(!m.is_empty());
assert!(m.capacity() >= m.len());
- for i in 0us..100 {
+ for i in 0..100 {
assert_eq!(m.remove(&i), Some(i));
}
m.shrink_to_fit();
fn test_from_iter() {
let xs = [(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)];
- let map: HashMap<int, int> = xs.iter().map(|&x| x).collect();
+ let map: HashMap<_, _> = xs.iter().cloned().collect();
for &(k, v) in &xs {
assert_eq!(map.get(&k), Some(&v));
fn test_size_hint() {
let xs = [(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)];
- let map: HashMap<int, int> = xs.iter().map(|&x| x).collect();
+ let map: HashMap<_, _> = xs.iter().cloned().collect();
let mut iter = map.iter();
fn test_iter_len() {
let xs = [(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)];
- let map: HashMap<int, int> = xs.iter().map(|&x| x).collect();
+ let map: HashMap<_, _> = xs.iter().cloned().collect();
let mut iter = map.iter();
fn test_mut_size_hint() {
let xs = [(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)];
- let mut map: HashMap<int, int> = xs.iter().map(|&x| x).collect();
+ let mut map: HashMap<_, _> = xs.iter().cloned().collect();
let mut iter = map.iter_mut();
fn test_iter_mut_len() {
let xs = [(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)];
- let mut map: HashMap<int, int> = xs.iter().map(|&x| x).collect();
+ let mut map: HashMap<_, _> = xs.iter().cloned().collect();
let mut iter = map.iter_mut();
#[test]
fn test_index() {
- let mut map: HashMap<int, int> = HashMap::new();
+ let mut map = HashMap::new();
map.insert(1, 2);
map.insert(2, 1);
#[test]
#[should_fail]
fn test_index_nonexistent() {
- let mut map: HashMap<int, int> = HashMap::new();
+ let mut map = HashMap::new();
map.insert(1, 2);
map.insert(2, 1);
fn test_entry(){
let xs = [(1, 10), (2, 20), (3, 30), (4, 40), (5, 50), (6, 60)];
- let mut map: HashMap<int, int> = xs.iter().map(|&x| x).collect();
+ let mut map: HashMap<_, _> = xs.iter().cloned().collect();
// Existing key (insert)
match map.entry(1) {
#[test]
fn test_entry_take_doesnt_corrupt() {
// Test for #19292
- fn check(m: &HashMap<int, ()>) {
+ fn check(m: &HashMap<isize, ()>) {
for k in m.keys() {
assert!(m.contains_key(k),
"{} is in keys() but not in the map?", k);
let mut rng = weak_rng();
// Populate the map with some items.
- for _ in 0u..50 {
+ for _ in 0..50 {
let x = rng.gen_range(-10, 10);
m.insert(x, ());
}
- for i in 0u..1000 {
+ for i in 0..1000 {
let x = rng.gen_range(-10, 10);
match m.entry(x) {
Vacant(_) => {},
/// #[derive(Hash, Eq, PartialEq, Debug)]
/// struct Viking<'a> {
/// name: &'a str,
-/// power: uint,
+/// power: usize,
/// }
///
/// let mut vikings = HashSet::new();
///
-/// vikings.insert(Viking { name: "Einar", power: 9u });
-/// vikings.insert(Viking { name: "Einar", power: 9u });
-/// vikings.insert(Viking { name: "Olaf", power: 4u });
-/// vikings.insert(Viking { name: "Harald", power: 8u });
+/// vikings.insert(Viking { name: "Einar", power: 9 });
+/// vikings.insert(Viking { name: "Einar", power: 9 });
+/// vikings.insert(Viking { name: "Olaf", power: 4 });
+/// vikings.insert(Viking { name: "Harald", power: 8 });
///
/// // Use derived implementation to print the vikings.
/// for x in vikings.iter() {
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn with_capacity(capacity: uint) -> HashSet<T, RandomState> {
+ pub fn with_capacity(capacity: usize) -> HashSet<T, RandomState> {
HashSet { map: HashMap::with_capacity(capacity) }
}
}
///
/// let s = RandomState::new();
/// let mut set = HashSet::with_hash_state(s);
- /// set.insert(2u);
+ /// set.insert(2);
/// ```
#[inline]
#[unstable(feature = "std_misc", reason = "hasher stuff is unclear")]
/// use std::collections::hash_map::RandomState;
///
/// let s = RandomState::new();
- /// let mut set = HashSet::with_capacity_and_hash_state(10u, s);
+ /// let mut set = HashSet::with_capacity_and_hash_state(10, s);
/// set.insert(1);
/// ```
#[inline]
#[unstable(feature = "std_misc", reason = "hasher stuff is unclear")]
- pub fn with_capacity_and_hash_state(capacity: uint, hash_state: S)
+ pub fn with_capacity_and_hash_state(capacity: usize, hash_state: S)
-> HashSet<T, S> {
HashSet {
map: HashMap::with_capacity_and_hash_state(capacity, hash_state),
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn capacity(&self) -> uint {
+ pub fn capacity(&self) -> usize {
self.map.capacity()
}
///
/// # Panics
///
- /// Panics if the new allocation size overflows `uint`.
+ /// Panics if the new allocation size overflows `usize`.
///
/// # Example
///
/// set.reserve(10);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn reserve(&mut self, additional: uint) {
+ pub fn reserve(&mut self, additional: usize) {
self.map.reserve(additional)
}
///
/// let mut v = HashSet::new();
/// assert_eq!(v.len(), 0);
- /// v.insert(1u);
+ /// v.insert(1);
/// assert_eq!(v.len(), 1);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn len(&self) -> uint { self.map.len() }
+ pub fn len(&self) -> usize { self.map.len() }
/// Returns true if the set contains no elements
///
///
/// let mut v = HashSet::new();
/// assert!(v.is_empty());
- /// v.insert(1u);
+ /// v.insert(1);
/// assert!(!v.is_empty());
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
/// use std::collections::HashSet;
///
/// let mut v = HashSet::new();
- /// v.insert(1u);
+ /// v.insert(1);
/// v.clear();
/// assert!(v.is_empty());
/// ```
/// ```
/// use std::collections::HashSet;
///
- /// let set: HashSet<uint> = [1, 2, 3].iter().map(|&x| x).collect();
+ /// let set: HashSet<_> = [1, 2, 3].iter().cloned().collect();
/// assert_eq!(set.contains(&1), true);
/// assert_eq!(set.contains(&4), false);
/// ```
/// ```
/// use std::collections::HashSet;
///
- /// let a: HashSet<uint> = [1, 2, 3].iter().map(|&x| x).collect();
- /// let mut b: HashSet<uint> = HashSet::new();
+ /// let a: HashSet<_> = [1, 2, 3].iter().cloned().collect();
+ /// let mut b = HashSet::new();
///
/// assert_eq!(a.is_disjoint(&b), true);
/// b.insert(4);
/// ```
/// use std::collections::HashSet;
///
- /// let sup: HashSet<uint> = [1, 2, 3].iter().map(|&x| x).collect();
- /// let mut set: HashSet<uint> = HashSet::new();
+ /// let sup: HashSet<_> = [1, 2, 3].iter().cloned().collect();
+ /// let mut set = HashSet::new();
///
/// assert_eq!(set.is_subset(&sup), true);
/// set.insert(2);
/// ```
/// use std::collections::HashSet;
///
- /// let sub: HashSet<uint> = [1, 2].iter().map(|&x| x).collect();
- /// let mut set: HashSet<uint> = HashSet::new();
+ /// let sub: HashSet<_> = [1, 2].iter().cloned().collect();
+ /// let mut set = HashSet::new();
///
/// assert_eq!(set.is_superset(&sub), false);
///
///
/// let mut set = HashSet::new();
///
- /// assert_eq!(set.insert(2u), true);
+ /// assert_eq!(set.insert(2), true);
/// assert_eq!(set.insert(2), false);
/// assert_eq!(set.len(), 1);
/// ```
///
/// let mut set = HashSet::new();
///
- /// set.insert(2u);
+ /// set.insert(2);
/// assert_eq!(set.remove(&2), true);
/// assert_eq!(set.remove(&2), false);
/// ```
/// ```
/// use std::collections::HashSet;
///
- /// let a: HashSet<int> = vec![1, 2, 3].into_iter().collect();
- /// let b: HashSet<int> = vec![3, 4, 5].into_iter().collect();
+ /// let a: HashSet<_> = vec![1, 2, 3].into_iter().collect();
+ /// let b: HashSet<_> = vec![3, 4, 5].into_iter().collect();
///
- /// let set: HashSet<int> = &a | &b;
+ /// let set = &a | &b;
///
/// let mut i = 0;
/// let expected = [1, 2, 3, 4, 5];
/// ```
/// use std::collections::HashSet;
///
- /// let a: HashSet<int> = vec![1, 2, 3].into_iter().collect();
- /// let b: HashSet<int> = vec![2, 3, 4].into_iter().collect();
+ /// let a: HashSet<_> = vec![1, 2, 3].into_iter().collect();
+ /// let b: HashSet<_> = vec![2, 3, 4].into_iter().collect();
///
- /// let set: HashSet<int> = &a & &b;
+ /// let set = &a & &b;
///
/// let mut i = 0;
/// let expected = [2, 3];
/// ```
/// use std::collections::HashSet;
///
- /// let a: HashSet<int> = vec![1, 2, 3].into_iter().collect();
- /// let b: HashSet<int> = vec![3, 4, 5].into_iter().collect();
+ /// let a: HashSet<_> = vec![1, 2, 3].into_iter().collect();
+ /// let b: HashSet<_> = vec![3, 4, 5].into_iter().collect();
///
- /// let set: HashSet<int> = &a ^ &b;
+ /// let set = &a ^ &b;
///
/// let mut i = 0;
/// let expected = [1, 2, 4, 5];
/// ```
/// use std::collections::HashSet;
///
- /// let a: HashSet<int> = vec![1, 2, 3].into_iter().collect();
- /// let b: HashSet<int> = vec![3, 4, 5].into_iter().collect();
+ /// let a: HashSet<_> = vec![1, 2, 3].into_iter().collect();
+ /// let b: HashSet<_> = vec![3, 4, 5].into_iter().collect();
///
- /// let set: HashSet<int> = &a - &b;
+ /// let set = &a - &b;
///
/// let mut i = 0;
/// let expected = [1, 2];
#[test]
fn test_iterate() {
let mut a = HashSet::new();
- for i in 0u..32 {
+ for i in 0..32 {
assert!(a.insert(i));
}
let mut observed: u32 = 0;
fn test_from_iter() {
let xs = [1, 2, 3, 4, 5, 6, 7, 8, 9];
- let set: HashSet<int> = xs.iter().map(|&x| x).collect();
+ let set: HashSet<_> = xs.iter().cloned().collect();
for x in &xs {
assert!(set.contains(x));
#[test]
fn test_show() {
- let mut set: HashSet<int> = HashSet::new();
- let empty: HashSet<int> = HashSet::new();
+ let mut set = HashSet::new();
+ let empty = HashSet::<i32>::new();
set.insert(1);
set.insert(2);
#[test]
fn test_trivial_drain() {
- let mut s = HashSet::<int>::new();
+ let mut s = HashSet::<i32>::new();
for _ in s.drain() {}
assert!(s.is_empty());
drop(s);
- let mut s = HashSet::<int>::new();
+ let mut s = HashSet::<i32>::new();
drop(s.drain());
assert!(s.is_empty());
}
#[test]
fn test_drain() {
- let mut s: HashSet<i32> = (1..100).collect();
+ let mut s: HashSet<_> = (1..100).collect();
// try this a bunch of times to make sure we don't screw up internal state.
for _ in 0..20 {
/// but in general is just a tricked out `Vec<Option<u64, K, V>>`.
#[unsafe_no_drop_flag]
pub struct RawTable<K, V> {
- capacity: uint,
- size: uint,
+ capacity: usize,
+ size: usize,
hashes: *mut u64,
// Because K/V do not appear directly in any of the types in the struct,
// inform rustc that in fact instances of K and V are reachable from here.
pub struct Bucket<K, V, M> {
raw: RawBucket<K, V>,
- idx: uint,
+ idx: usize,
table: M
}
pub struct EmptyBucket<K, V, M> {
raw: RawBucket<K, V>,
- idx: uint,
+ idx: usize,
table: M
}
pub struct FullBucket<K, V, M> {
raw: RawBucket<K, V>,
- idx: uint,
+ idx: usize,
table: M
}
self.table
}
/// Get the raw index.
- pub fn index(&self) -> uint {
+ pub fn index(&self) -> usize {
self.idx
}
}
self.table
}
/// Get the raw index.
- pub fn index(&self) -> uint {
+ pub fn index(&self) -> usize {
self.idx
}
}
impl<K, V, M: Deref<Target=RawTable<K, V>>> Bucket<K, V, M> {
pub fn new(table: M, hash: SafeHash) -> Bucket<K, V, M> {
- Bucket::at_index(table, hash.inspect() as uint)
+ Bucket::at_index(table, hash.inspect() as usize)
}
- pub fn at_index(table: M, ib_index: uint) -> Bucket<K, V, M> {
+ pub fn at_index(table: M, ib_index: usize) -> Bucket<K, V, M> {
let ib_index = ib_index & (table.capacity() - 1);
Bucket {
raw: unsafe {
- table.first_bucket_raw().offset(ib_index as int)
+ table.first_bucket_raw().offset(ib_index as isize)
},
idx: ib_index,
table: table
// ... and it's zero at all other times.
let maybe_wraparound_dist = (self.idx ^ (self.idx + 1)) & self.table.capacity();
// Finally, we obtain the offset 1 or the offset -cap + 1.
- let dist = 1 - (maybe_wraparound_dist as int);
+ let dist = 1 - (maybe_wraparound_dist as isize);
self.idx += 1;
///
/// In the cited blog posts above, this is called the "distance to
/// initial bucket", or DIB. Also known as "probe count".
- pub fn distance(&self) -> uint {
+ pub fn distance(&self) -> usize {
// Calculates the distance one has to travel when going from
// `hash mod capacity` onwards to `idx mod capacity`, wrapping around
// if the destination is not reached before the end of the table.
- (self.idx - self.hash().inspect() as uint) & (self.table.capacity() - 1)
+ (self.idx - self.hash().inspect() as usize) & (self.table.capacity() - 1)
}
#[inline]
/// # Panics
///
/// Panics if `target_alignment` is not a power of two.
-fn round_up_to_next(unrounded: uint, target_alignment: uint) -> uint {
+fn round_up_to_next(unrounded: usize, target_alignment: usize) -> usize {
assert!(target_alignment.is_power_of_two());
(unrounded + target_alignment - 1) & !(target_alignment - 1)
}
// Returns a tuple of (key_offset, val_offset),
// from the start of a mallocated array.
-fn calculate_offsets(hashes_size: uint,
- keys_size: uint, keys_align: uint,
- vals_align: uint)
- -> (uint, uint) {
+fn calculate_offsets(hashes_size: usize,
+ keys_size: usize, keys_align: usize,
+ vals_align: usize)
+ -> (usize, usize) {
let keys_offset = round_up_to_next(hashes_size, keys_align);
let end_of_keys = keys_offset + keys_size;
// Returns a tuple of (minimum required malloc alignment, hash_offset,
// array_size), from the start of a mallocated array.
-fn calculate_allocation(hash_size: uint, hash_align: uint,
- keys_size: uint, keys_align: uint,
- vals_size: uint, vals_align: uint)
- -> (uint, uint, uint) {
+fn calculate_allocation(hash_size: usize, hash_align: usize,
+ keys_size: usize, keys_align: usize,
+ vals_size: usize, vals_align: usize)
+ -> (usize, usize, usize) {
let hash_offset = 0;
let (_, vals_offset) = calculate_offsets(hash_size,
keys_size, keys_align,
impl<K, V> RawTable<K, V> {
/// Does not initialize the buckets. The caller should ensure they,
/// at the very least, set every hash to EMPTY_BUCKET.
- unsafe fn new_uninitialized(capacity: uint) -> RawTable<K, V> {
+ unsafe fn new_uninitialized(capacity: usize) -> RawTable<K, V> {
if capacity == 0 {
return RawTable {
size: 0,
let buffer = allocate(size, malloc_alignment);
if buffer.is_null() { ::alloc::oom() }
- let hashes = buffer.offset(hash_offset as int) as *mut u64;
+ let hashes = buffer.offset(hash_offset as isize) as *mut u64;
RawTable {
capacity: capacity,
unsafe {
RawBucket {
hash: self.hashes,
- key: buffer.offset(keys_offset as int) as *mut K,
- val: buffer.offset(vals_offset as int) as *mut V
+ key: buffer.offset(keys_offset as isize) as *mut K,
+ val: buffer.offset(vals_offset as isize) as *mut V
}
}
}
/// Creates a new raw table from a given capacity. All buckets are
/// initially empty.
- pub fn new(capacity: uint) -> RawTable<K, V> {
+ pub fn new(capacity: usize) -> RawTable<K, V> {
unsafe {
let ret = RawTable::new_uninitialized(capacity);
zero_memory(ret.hashes, capacity);
}
/// The hashtable's capacity, similar to a vector's.
- pub fn capacity(&self) -> uint {
+ pub fn capacity(&self) -> usize {
self.capacity
}
/// The number of elements ever `put` in the hashtable, minus the number
/// of elements ever `take`n.
- pub fn size(&self) -> uint {
+ pub fn size(&self) -> usize {
self.size
}
RawBuckets {
raw: self.first_bucket_raw(),
hashes_end: unsafe {
- self.hashes.offset(self.capacity as int)
+ self.hashes.offset(self.capacity as isize)
},
marker: marker::ContravariantLifetime,
}
unsafe fn rev_move_buckets(&mut self) -> RevMoveBuckets<K, V> {
let raw_bucket = self.first_bucket_raw();
RevMoveBuckets {
- raw: raw_bucket.offset(self.capacity as int),
+ raw: raw_bucket.offset(self.capacity as isize),
hashes_end: raw_bucket.hash,
elems_left: self.size,
marker: marker::ContravariantLifetime,
struct RevMoveBuckets<'a, K, V> {
raw: RawBucket<K, V>,
hashes_end: *mut u64,
- elems_left: uint,
+ elems_left: usize,
marker: marker::ContravariantLifetime<'a>,
}
/// Iterator over shared references to entries in a table.
pub struct Iter<'a, K: 'a, V: 'a> {
iter: RawBuckets<'a, K, V>,
- elems_left: uint,
+ elems_left: usize,
}
// FIXME(#19839) Remove in favor of `#[derive(Clone)]`
/// Iterator over mutable references to entries in a table.
pub struct IterMut<'a, K: 'a, V: 'a> {
iter: RawBuckets<'a, K, V>,
- elems_left: uint,
+ elems_left: usize,
}
/// Iterator over the entries in a table, consuming the table.
//! all the contents of the collection.
//!
//! ```
-//! let vec = vec![1u, 2, 3, 4];
+//! let vec = vec![1, 2, 3, 4];
//! for x in vec.iter() {
//! println!("vec contained {}", x);
//! }
//! This is great for mutating all the contents of the collection.
//!
//! ```
-//! let mut vec = vec![1u, 2, 3, 4];
+//! let mut vec = vec![1, 2, 3, 4];
//! for x in vec.iter_mut() {
//! *x += 1;
//! }
//! previous section to do this as efficiently as possible.
//!
//! ```
-//! let mut vec1 = vec![1u, 2, 3, 4];
-//! let vec2 = vec![10u, 20, 30, 40];
+//! let mut vec1 = vec![1, 2, 3, 4];
+//! let vec2 = vec![10, 20, 30, 40];
//! vec1.extend(vec2.into_iter());
//! ```
//!
//! ```
//! use std::collections::RingBuf;
//!
-//! let vec = vec![1u, 2, 3, 4];
+//! let vec = vec![1, 2, 3, 4];
//! let buf: RingBuf<uint> = vec.into_iter().collect();
//! ```
//!
//! iterators as the way to iterate over them in reverse order.
//!
//! ```
-//! let vec = vec![1u, 2, 3, 4];
+//! let vec = vec![1, 2, 3, 4];
//! for x in vec.iter().rev() {
//! println!("vec contained {}", x);
//! }
//! #### Counting the number of times each character in a string occurs
//!
//! ```
-//! use std::collections::btree_map::{BTreeMap, Occupied, Vacant};
+//! use std::collections::btree_map::{BTreeMap, Entry};
//!
//! let mut count = BTreeMap::new();
//! let message = "she sells sea shells by the sea shore";
//!
//! for c in message.chars() {
//! match count.entry(c) {
-//! Vacant(entry) => { entry.insert(1u); },
-//! Occupied(mut entry) => *entry.get_mut() += 1,
+//! Entry::Vacant(entry) => { entry.insert(1); },
+//! Entry::Occupied(mut entry) => *entry.get_mut() += 1,
//! }
//! }
//!
//! assert_eq!(count.get(&'s'), Some(&8));
//!
-//! println!("Number of occurences of each character");
+//! println!("Number of occurrences of each character");
//! for (char, count) in count.iter() {
//! println!("{}: {}", char, count);
//! }
//! #### Tracking the inebriation of customers at a bar
//!
//! ```
-//! use std::collections::btree_map::{BTreeMap, Occupied, Vacant};
+//! use std::collections::btree_map::{BTreeMap, Entry};
//!
//! // A client of the bar. They have an id and a blood alcohol level.
//! struct Person { id: u32, blood_alcohol: f32 };
//! // If this is the first time we've seen this customer, initialize them
//! // with no blood alcohol. Otherwise, just retrieve them.
//! let person = match blood_alcohol.entry(id) {
-//! Vacant(entry) => entry.insert(Person{id: id, blood_alcohol: 0.0}),
-//! Occupied(entry) => entry.into_mut(),
+//! Entry::Vacant(entry) => entry.insert(Person{id: id, blood_alcohol: 0.0}),
+//! Entry::Occupied(entry) => entry.into_mut(),
//! };
//!
//! // Reduce their blood alcohol level. It takes time to order and drink a beer!
use env;
use str;
-#[allow(missing_copy_implementations)]
pub struct DynamicLibrary {
handle: *mut u8
}
///
/// # Errors
///
-/// Acquring the path to the current executable is a platform-specific operation
+/// Acquiring the path to the current executable is a platform-specific operation
/// that can fail for a good number of reasons. Some errors can include, but not
/// be limited to filesystem operations failing or general syscall failures.
///
pub const EXE_EXTENSION: &'static str = "";
}
+/// Constants associated with the current target
+#[cfg(target_os = "openbsd")]
+pub mod consts {
+ pub use super::arch_consts::ARCH;
+
+ pub const FAMILY: &'static str = "unix";
+
+ /// A string describing the specific operating system in use: in this
+ /// case, `dragonfly`.
+ pub const OS: &'static str = "openbsd";
+
+ /// Specifies the filename prefix used for shared libraries on this
+ /// platform: in this case, `lib`.
+ pub const DLL_PREFIX: &'static str = "lib";
+
+ /// Specifies the filename suffix used for shared libraries on this
+ /// platform: in this case, `.so`.
+ pub const DLL_SUFFIX: &'static str = ".so";
+
+ /// Specifies the file extension used for shared libraries on this
+ /// platform that goes after the dot: in this case, `so`.
+ pub const DLL_EXTENSION: &'static str = "so";
+
+ /// Specifies the filename suffix used for executable binaries on this
+ /// platform: in this case, the empty string.
+ pub const EXE_SUFFIX: &'static str = "";
+
+ /// Specifies the file extension, if any, used for executable binaries
+ /// on this platform: in this case, the empty string.
+ pub const EXE_EXTENSION: &'static str = "";
+}
+
/// Constants associated with the current target
#[cfg(target_os = "android")]
pub mod consts {
/// ```
pub unsafe fn c_str_to_bytes<'a>(raw: &'a *const libc::c_char) -> &'a [u8] {
let len = libc::strlen(*raw);
- slice::from_raw_buf(&*(raw as *const _ as *const *const u8), len as uint)
+ slice::from_raw_parts(*(raw as *const _ as *const *const u8), len as usize)
}
/// Interpret a C string as a byte slice with the nul terminator.
/// will include the nul terminator of the string.
pub unsafe fn c_str_to_bytes_with_nul<'a>(raw: &'a *const libc::c_char) -> &'a [u8] {
let len = libc::strlen(*raw) + 1;
- slice::from_raw_buf(&*(raw as *const _ as *const *const u8), len as uint)
+ slice::from_raw_parts(*(raw as *const _ as *const *const u8), len as usize)
}
#[cfg(test)]
+++ /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-lexer-test FIXME #15679
-
-//! Utilities for formatting and printing strings
-//!
-//! This module contains the runtime support for the `format!` syntax extension.
-//! This macro is implemented in the compiler to emit calls to this module in
-//! order to format arguments at runtime into strings and streams.
-//!
-//! ## Usage
-//!
-//! The `format!` macro is intended to be familiar to those coming from C's
-//! printf/fprintf functions or Python's `str.format` function. In its current
-//! revision, the `format!` macro returns a `String` type which is the result of
-//! the formatting. In the future it will also be able to pass in a stream to
-//! format arguments directly while performing minimal allocations.
-//!
-//! Some examples of the `format!` extension are:
-//!
-//! ```
-//! format!("Hello"); // => "Hello"
-//! format!("Hello, {}!", "world"); // => "Hello, world!"
-//! format!("The number is {}", 1); // => "The number is 1"
-//! format!("{:?}", (3, 4)); // => "(3, 4)"
-//! format!("{value}", value=4); // => "4"
-//! format!("{} {}", 1, 2u); // => "1 2"
-//! ```
-//!
-//! From these, you can see that the first argument is a format string. It is
-//! required by the compiler for this to be a string literal; it cannot be a
-//! variable passed in (in order to perform validity checking). The compiler
-//! will then parse the format string and determine if the list of arguments
-//! provided is suitable to pass to this format string.
-//!
-//! ### Positional parameters
-//!
-//! Each formatting argument is allowed to specify which value argument it's
-//! referencing, and if omitted it is assumed to be "the next argument". For
-//! example, the format string `{} {} {}` would take three parameters, and they
-//! would be formatted in the same order as they're given. The format string
-//! `{2} {1} {0}`, however, would format arguments in reverse order.
-//!
-//! Things can get a little tricky once you start intermingling the two types of
-//! positional specifiers. The "next argument" specifier can be thought of as an
-//! iterator over the argument. Each time a "next argument" specifier is seen,
-//! the iterator advances. This leads to behavior like this:
-//!
-//! ```rust
-//! format!("{1} {} {0} {}", 1, 2); // => "2 1 1 2"
-//! ```
-//!
-//! The internal iterator over the argument has not been advanced by the time
-//! the first `{}` is seen, so it prints the first argument. Then upon reaching
-//! the second `{}`, the iterator has advanced forward to the second argument.
-//! Essentially, parameters which explicitly name their argument do not affect
-//! parameters which do not name an argument in terms of positional specifiers.
-//!
-//! A format string is required to use all of its arguments, otherwise it is a
-//! compile-time error. You may refer to the same argument more than once in the
-//! format string, although it must always be referred to with the same type.
-//!
-//! ### Named parameters
-//!
-//! Rust itself does not have a Python-like equivalent of named parameters to a
-//! function, but the `format!` macro is a syntax extension which allows it to
-//! leverage named parameters. Named parameters are listed at the end of the
-//! argument list and have the syntax:
-//!
-//! ```text
-//! identifier '=' expression
-//! ```
-//!
-//! For example, the following `format!` expressions all use named argument:
-//!
-//! ```
-//! format!("{argument}", argument = "test"); // => "test"
-//! format!("{name} {}", 1, name = 2); // => "2 1"
-//! format!("{a} {c} {b}", a="a", b='b', c=3); // => "a 3 b"
-//! ```
-//!
-//! It is illegal to put positional parameters (those without names) after
-//! arguments which have names. Like with positional parameters, it is illegal
-//! to provide named parameters that are unused by the format string.
-//!
-//! ### Argument types
-//!
-//! Each argument's type is dictated by the format string. It is a requirement
-//! that every argument is only ever referred to by one type. For example, this
-//! is an invalid format string:
-//!
-//! ```text
-//! {0:x} {0:o}
-//! ```
-//!
-//! This is invalid because the first argument is both referred to as a
-//! hexadecimal as well as an
-//! octal.
-//!
-//! There are various parameters which do require a particular type, however.
-//! Namely if the syntax `{:.*}` is used, then the number of characters to print
-//! precedes the actual object being formatted, and the number of characters
-//! must have the type `uint`. Although a `uint` can be printed with `{}`, it is
-//! illegal to reference an argument as such. For example this is another
-//! invalid format string:
-//!
-//! ```text
-//! {:.*} {0}
-//! ```
-//!
-//! ### Formatting traits
-//!
-//! When requesting that an argument be formatted with a particular type, you
-//! are actually requesting that an argument ascribes to a particular trait.
-//! This allows multiple actual types to be formatted via `{:x}` (like `i8` as
-//! well as `int`). The current mapping of types to traits is:
-//!
-//! * *nothing* ⇒ `Display`
-//! * `?` ⇒ `Debug`
-//! * `o` ⇒ `Octal`
-//! * `x` ⇒ `LowerHex`
-//! * `X` ⇒ `UpperHex`
-//! * `p` ⇒ `Pointer`
-//! * `b` ⇒ `Binary`
-//! * `e` ⇒ `LowerExp`
-//! * `E` ⇒ `UpperExp`
-//!
-//! What this means is that any type of argument which implements the
-//! `std::fmt::Binary` trait can then be formatted with `{:b}`. Implementations
-//! are provided for these traits for a number of primitive types by the
-//! standard library as well. If no format is specified (as in `{}` or `{:6}`),
-//! then the format trait used is the `Display` trait.
-//!
-//! When implementing a format trait for your own type, you will have to
-//! implement a method of the signature:
-//!
-//! ```rust
-//! # use std::fmt;
-//! # struct Foo; // our custom type
-//! # impl fmt::Display for Foo {
-//! fn fmt(&self, f: &mut std::fmt::Formatter) -> fmt::Result {
-//! # write!(f, "testing, testing")
-//! # } }
-//! ```
-//!
-//! Your type will be passed as `self` by-reference, and then the function
-//! should emit output into the `f.buf` stream. It is up to each format trait
-//! implementation to correctly adhere to the requested formatting parameters.
-//! The values of these parameters will be listed in the fields of the
-//! `Formatter` struct. In order to help with this, the `Formatter` struct also
-//! provides some helper methods.
-//!
-//! Additionally, the return value of this function is `fmt::Result` which is a
-//! typedef to `Result<(), IoError>` (also known as `IoResult<()>`). Formatting
-//! implementations should ensure that they return errors from `write!`
-//! correctly (propagating errors upward).
-//!
-//! An example of implementing the formatting traits would look
-//! like:
-//!
-//! ```rust
-//! use std::fmt;
-//! use std::f64;
-//! use std::num::Float;
-//!
-//! #[derive(Debug)]
-//! struct Vector2D {
-//! x: int,
-//! y: int,
-//! }
-//!
-//! impl fmt::Display for Vector2D {
-//! fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-//! // The `f` value implements the `Writer` trait, which is what the
-//! // write! macro is expecting. Note that this formatting ignores the
-//! // various flags provided to format strings.
-//! write!(f, "({}, {})", self.x, self.y)
-//! }
-//! }
-//!
-//! // Different traits allow different forms of output of a type. The meaning
-//! // of this format is to print the magnitude of a vector.
-//! impl fmt::Binary for Vector2D {
-//! fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-//! let magnitude = (self.x * self.x + self.y * self.y) as f64;
-//! let magnitude = magnitude.sqrt();
-//!
-//! // Respect the formatting flags by using the helper method
-//! // `pad_integral` on the Formatter object. See the method documentation
-//! // for details, and the function `pad` can be used to pad strings.
-//! let decimals = f.precision().unwrap_or(3);
-//! let string = f64::to_str_exact(magnitude, decimals);
-//! f.pad_integral(true, "", string.as_slice())
-//! }
-//! }
-//!
-//! fn main() {
-//! let myvector = Vector2D { x: 3, y: 4 };
-//!
-//! println!("{}", myvector); // => "(3, 4)"
-//! println!("{:?}", myvector); // => "Vector2D {x: 3, y:4}"
-//! println!("{:10.3b}", myvector); // => " 5.000"
-//! }
-//! ```
-//!
-//! #### fmt::Display vs fmt::Debug
-//!
-//! These two formatting traits have distinct purposes:
-//!
-//! - `fmt::Display` implementations assert that the type can be faithfully
-//! represented as a UTF-8 string at all times. It is **not** expected that
-//! all types implement the `Display` trait.
-//! - `fmt::Debug` implementations should be implemented for **all** public types.
-//! Output will typically represent the internal state as faithfully as possible.
-//! The purpose of the `Debug` trait is to facilitate debugging Rust code. In
-//! most cases, using `#[derive(Debug)]` is sufficient and recommended.
-//!
-//! Some examples of the output from both traits:
-//!
-//! ```
-//! assert_eq!(format!("{} {:?}", 3i32, 4i32), "3 4");
-//! assert_eq!(format!("{} {:?}", 'a', 'b'), "a 'b'");
-//! assert_eq!(format!("{} {:?}", "foo\n", "bar\n"), "foo\n \"bar\\n\"");
-//! ```
-//!
-//! ### Related macros
-//!
-//! There are a number of related macros in the `format!` family. The ones that
-//! are currently implemented are:
-//!
-//! ```ignore
-//! format! // described above
-//! write! // first argument is a &mut old_io::Writer, the destination
-//! writeln! // same as write but appends a newline
-//! print! // the format string is printed to the standard output
-//! println! // same as print but appends a newline
-//! format_args! // described below.
-//! ```
-//!
-//! #### `write!`
-//!
-//! This and `writeln` are two macros which are used to emit the format string
-//! to a specified stream. This is used to prevent intermediate allocations of
-//! format strings and instead directly write the output. Under the hood, this
-//! function is actually invoking the `write` function defined in this module.
-//! Example usage is:
-//!
-//! ```rust
-//! # #![allow(unused_must_use)]
-//! let mut w = Vec::new();
-//! write!(&mut w, "Hello {}!", "world");
-//! ```
-//!
-//! #### `print!`
-//!
-//! This and `println` emit their output to stdout. Similarly to the `write!`
-//! macro, the goal of these macros is to avoid intermediate allocations when
-//! printing output. Example usage is:
-//!
-//! ```rust
-//! print!("Hello {}!", "world");
-//! println!("I have a newline {}", "character at the end");
-//! ```
-//!
-//! #### `format_args!`
-//! This is a curious macro which is used to safely pass around
-//! an opaque object describing the format string. This object
-//! does not require any heap allocations to create, and it only
-//! references information on the stack. Under the hood, all of
-//! the related macros are implemented in terms of this. First
-//! off, some example usage is:
-//!
-//! ```
-//! use std::fmt;
-//! use std::old_io;
-//!
-//! fmt::format(format_args!("this returns {}", "String"));
-//!
-//! let mut some_writer = old_io::stdout();
-//! write!(&mut some_writer, "{}", format_args!("print with a {}", "macro"));
-//!
-//! fn my_fmt_fn(args: fmt::Arguments) {
-//! write!(&mut old_io::stdout(), "{}", args);
-//! }
-//! my_fmt_fn(format_args!("or a {} too", "function"));
-//! ```
-//!
-//! The result of the `format_args!` macro is a value of type `fmt::Arguments`.
-//! This structure can then be passed to the `write` and `format` functions
-//! inside this module in order to process the format string.
-//! The goal of this macro is to even further prevent intermediate allocations
-//! when dealing formatting strings.
-//!
-//! For example, a logging library could use the standard formatting syntax, but
-//! it would internally pass around this structure until it has been determined
-//! where output should go to.
-//!
-//! ## Syntax
-//!
-//! The syntax for the formatting language used is drawn from other languages,
-//! so it should not be too alien. Arguments are formatted with python-like
-//! syntax, meaning that arguments are surrounded by `{}` instead of the C-like
-//! `%`. The actual grammar for the formatting syntax is:
-//!
-//! ```text
-//! format_string := <text> [ format <text> ] *
-//! format := '{' [ argument ] [ ':' format_spec ] '}'
-//! argument := integer | identifier
-//!
-//! format_spec := [[fill]align][sign]['#'][0][width]['.' precision][type]
-//! fill := character
-//! align := '<' | '^' | '>'
-//! sign := '+' | '-'
-//! width := count
-//! precision := count | '*'
-//! type := identifier | ''
-//! count := parameter | integer
-//! parameter := integer '$'
-//! ```
-//!
-//! ## Formatting Parameters
-//!
-//! Each argument being formatted can be transformed by a number of formatting
-//! parameters (corresponding to `format_spec` in the syntax above). These
-//! parameters affect the string representation of what's being formatted. This
-//! syntax draws heavily from Python's, so it may seem a bit familiar.
-//!
-//! ### Fill/Alignment
-//!
-//! The fill character is provided normally in conjunction with the `width`
-//! parameter. This indicates that if the value being formatted is smaller than
-//! `width` some extra characters will be printed around it. The extra
-//! characters are specified by `fill`, and the alignment can be one of two
-//! options:
-//!
-//! * `<` - the argument is left-aligned in `width` columns
-//! * `^` - the argument is center-aligned in `width` columns
-//! * `>` - the argument is right-aligned in `width` columns
-//!
-//! ### Sign/#/0
-//!
-//! These can all be interpreted as flags for a particular formatter.
-//!
-//! * '+' - This is intended for numeric types and indicates that the sign
-//! should always be printed. Positive signs are never printed by
-//! default, and the negative sign is only printed by default for the
-//! `Signed` trait. This flag indicates that the correct sign (+ or -)
-//! should always be printed.
-//! * '-' - Currently not used
-//! * '#' - This flag is indicates that the "alternate" form of printing should
-//! be used. By default, this only applies to the integer formatting
-//! traits and performs like:
-//! * `x` - precedes the argument with a "0x"
-//! * `X` - precedes the argument with a "0x"
-//! * `t` - precedes the argument with a "0b"
-//! * `o` - precedes the argument with a "0o"
-//! * '0' - This is used to indicate for integer formats that the padding should
-//! both be done with a `0` character as well as be sign-aware. A format
-//! like `{:08d}` would yield `00000001` for the integer `1`, while the
-//! same format would yield `-0000001` for the integer `-1`. Notice that
-//! the negative version has one fewer zero than the positive version.
-//!
-//! ### Width
-//!
-//! This is a parameter for the "minimum width" that the format should take up.
-//! If the value's string does not fill up this many characters, then the
-//! padding specified by fill/alignment will be used to take up the required
-//! space.
-//!
-//! The default fill/alignment for non-numerics is a space and left-aligned. The
-//! defaults for numeric formatters is also a space but with right-alignment. If
-//! the '0' flag is specified for numerics, then the implicit fill character is
-//! '0'.
-//!
-//! The value for the width can also be provided as a `uint` in the list of
-//! parameters by using the `2$` syntax indicating that the second argument is a
-//! `uint` specifying the width.
-//!
-//! ### Precision
-//!
-//! For non-numeric types, this can be considered a "maximum width". If the
-//! resulting string is longer than this width, then it is truncated down to
-//! this many characters and only those are emitted.
-//!
-//! For integral types, this has no meaning currently.
-//!
-//! For floating-point types, this indicates how many digits after the decimal
-//! point should be printed.
-//!
-//! ## Escaping
-//!
-//! The literal characters `{` and `}` may be included in a string by preceding
-//! them with the same character. For example, the `{` character is escaped with
-//! `{{` and the `}` character is escaped with `}}`.
-
-#![unstable(feature = "std_misc")]
-
-use string;
-
-pub use core::fmt::{Formatter, Result, Writer, rt};
-pub use core::fmt::{Show, String, Octal, Binary};
-pub use core::fmt::{Display, Debug};
-pub use core::fmt::{LowerHex, UpperHex, Pointer};
-pub use core::fmt::{LowerExp, UpperExp};
-pub use core::fmt::Error;
-pub use core::fmt::{ArgumentV1, Arguments, write, radix, Radix, RadixFmt};
-
-/// The format function takes a precompiled format string and a list of
-/// arguments, to return the resulting formatted string.
-///
-/// # Arguments
-///
-/// * args - a structure of arguments generated via the `format_args!` macro.
-///
-/// # Example
-///
-/// ```rust
-/// use std::fmt;
-///
-/// let s = fmt::format(format_args!("Hello, {}!", "world"));
-/// assert_eq!(s, "Hello, world!".to_string());
-/// ```
-#[stable(feature = "rust1", since = "1.0.0")]
-pub fn format(args: Arguments) -> string::String {
- let mut output = string::String::new();
- let _ = write!(&mut output, "{}", args);
- output
-}
--- /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.
+
+//! Filesystem manipulation operations
+//!
+//! This module contains basic methods to manipulate the contents of the local
+//! filesystem. All methods in this module represent cross-platform filesystem
+//! operations. Extra platform-specific functionality can be found in the
+//! extension traits of `std::os::$platform`.
+
+#![unstable(feature = "fs")]
+
+use core::prelude::*;
+
+use io::{self, Error, ErrorKind, SeekFrom, Seek, Read, Write};
+use path::{AsPath, Path, PathBuf};
+use sys::fs2 as fs_imp;
+use sys_common::{AsInnerMut, FromInner, AsInner};
+use vec::Vec;
+
+/// A reference to an open file on the filesystem.
+///
+/// An instance of a `File` can be read and/or written depending on what options
+/// it was opened with. Files also implement `Seek` to alter the logical cursor
+/// that the file contains internally.
+///
+/// # Example
+///
+/// ```no_run
+/// use std::io::prelude::*;
+/// use std::fs::File;
+///
+/// # fn foo() -> std::io::Result<()> {
+/// let mut f = try!(File::create("foo.txt"));
+/// try!(f.write_all(b"Hello, world!"));
+///
+/// let mut f = try!(File::open("foo.txt"));
+/// let mut s = String::new();
+/// try!(f.read_to_string(&mut s));
+/// assert_eq!(s, "Hello, world!");
+/// # Ok(())
+/// # }
+/// ```
+pub struct File {
+ inner: fs_imp::File,
+ path: PathBuf,
+}
+
+/// Metadata information about a file.
+///
+/// This structure is returned from the `metadata` function or method and
+/// represents known metadata about a file such as its permissions, size,
+/// modification times, etc.
+pub struct Metadata(fs_imp::FileAttr);
+
+/// Iterator over the entries in a directory.
+///
+/// This iterator is returned from the `read_dir` function of this module and
+/// will yield instances of `io::Result<DirEntry>`. Through a `DirEntry`
+/// information like the entry's path and possibly other metadata can be
+/// learned.
+pub struct ReadDir(fs_imp::ReadDir);
+
+/// Entries returned by the `ReadDir` iterator.
+///
+/// An instance of `DirEntry` represents an entry inside of a directory on the
+/// filesystem. Each entry can be inspected via methods to learn about the full
+/// path or possibly other metadata through per-platform extension traits.
+pub struct DirEntry(fs_imp::DirEntry);
+
+/// An iterator that recursively walks over the contents of a directory.
+pub struct WalkDir {
+ cur: Option<ReadDir>,
+ stack: Vec<io::Result<ReadDir>>,
+}
+
+/// Options and flags which can be used to configure how a file is opened.
+///
+/// This builder exposes the ability to configure how a `File` is opened and
+/// what operations are permitted on the open file. The `File::open` and
+/// `File::create` methods are aliases for commonly used options using this
+/// builder.
+#[derive(Clone)]
+pub struct OpenOptions(fs_imp::OpenOptions);
+
+/// Representation of the various permissions on a file.
+///
+/// This module only currently provides one bit of information, `readonly`,
+/// which is exposed on all currently supported platforms. Unix-specific
+/// functionality, such as mode bits, is available through the
+/// `os::unix::PermissionsExt` trait.
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct Permissions(fs_imp::FilePermissions);
+
+impl File {
+ /// Attempts to open a file in read-only mode.
+ ///
+ /// See the `OpenOptions::open` method for more details.
+ ///
+ /// # Errors
+ ///
+ /// This function will return an error if `path` does not already exist.
+ /// Other errors may also be returned according to `OpenOptions::open`.
+ pub fn open<P: AsPath + ?Sized>(path: &P) -> io::Result<File> {
+ OpenOptions::new().read(true).open(path)
+ }
+
+ /// Creates a open a file in write-only mode.
+ ///
+ /// This method will attempt to open a new file, truncating it if it already
+ /// exists.
+ ///
+ /// See the `OpenOptions::open` function for more details.
+ pub fn create<P: AsPath + ?Sized>(path: &P) -> io::Result<File> {
+ OpenOptions::new().write(true).create(true).truncate(true).open(path)
+ }
+
+ /// Returns the original path that was used to open this file.
+ pub fn path(&self) -> Option<&Path> {
+ Some(&self.path)
+ }
+
+ /// Attempt to sync all OS-internal metadata to disk.
+ ///
+ /// This function will attempt to ensure that all in-core data reaches the
+ /// filesystem before returning.
+ pub fn sync_all(&self) -> io::Result<()> {
+ self.inner.fsync()
+ }
+
+ /// This function is similar to `sync_all`, except that it may not
+ /// synchronize file metadata to the filesystem.
+ ///
+ /// This is intended for use cases that must synchronize content, but don't
+ /// need the metadata on disk. The goal of this method is to reduce disk
+ /// operations.
+ ///
+ /// Note that some platforms may simply implement this in terms of
+ /// `sync_all`.
+ pub fn sync_data(&self) -> io::Result<()> {
+ self.inner.datasync()
+ }
+
+ /// Truncates or extends the underlying file, updating the size of
+ /// this file to become `size`.
+ ///
+ /// If the `size` is less than the current file's size, then the file will
+ /// be shrunk. If it is greater than the current file's size, then the file
+ /// will be extended to `size` and have all of the intermediate data filled
+ /// in with 0s.
+ pub fn set_len(&self, size: u64) -> io::Result<()> {
+ self.inner.truncate(size)
+ }
+
+ /// Queries information about the underlying file.
+ pub fn metadata(&self) -> io::Result<Metadata> {
+ self.inner.file_attr().map(Metadata)
+ }
+}
+
+impl AsInner<fs_imp::File> for File {
+ fn as_inner(&self) -> &fs_imp::File { &self.inner }
+}
+impl Read for File {
+ fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+ self.inner.read(buf)
+ }
+}
+impl Write for File {
+ fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+ self.inner.write(buf)
+ }
+ fn flush(&mut self) -> io::Result<()> { self.inner.flush() }
+}
+impl Seek for File {
+ fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> {
+ self.inner.seek(pos)
+ }
+}
+impl<'a> Read for &'a File {
+ fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+ self.inner.read(buf)
+ }
+}
+impl<'a> Write for &'a File {
+ fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+ self.inner.write(buf)
+ }
+ fn flush(&mut self) -> io::Result<()> { self.inner.flush() }
+}
+impl<'a> Seek for &'a File {
+ fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> {
+ self.inner.seek(pos)
+ }
+}
+
+impl OpenOptions {
+ /// Creates a blank net set of options ready for configuration.
+ ///
+ /// All options are initially set to `false`.
+ pub fn new() -> OpenOptions {
+ OpenOptions(fs_imp::OpenOptions::new())
+ }
+
+ /// Set the option for read access.
+ ///
+ /// This option, when true, will indicate that the file should be
+ /// `read`-able if opened.
+ pub fn read(&mut self, read: bool) -> &mut OpenOptions {
+ self.0.read(read); self
+ }
+
+ /// Set the option for write access.
+ ///
+ /// This option, when true, will indicate that the file should be
+ /// `write`-able if opened.
+ pub fn write(&mut self, write: bool) -> &mut OpenOptions {
+ self.0.write(write); self
+ }
+
+ /// Set the option for the append mode.
+ ///
+ /// This option, when true, means that writes will append to a file instead
+ /// of overwriting previous contents.
+ pub fn append(&mut self, append: bool) -> &mut OpenOptions {
+ self.0.append(append); self
+ }
+
+ /// Set the option for truncating a previous file.
+ ///
+ /// If a file is successfully opened with this option set it will truncate
+ /// the file to 0 length if it already exists.
+ pub fn truncate(&mut self, truncate: bool) -> &mut OpenOptions {
+ self.0.truncate(truncate); self
+ }
+
+ /// Set the option for creating a new file.
+ ///
+ /// This option indicates whether a new file will be created if the file
+ /// does not yet already exist.
+ pub fn create(&mut self, create: bool) -> &mut OpenOptions {
+ self.0.create(create); self
+ }
+
+ /// Open a file at `path` with the options specified by `self`.
+ ///
+ /// # Errors
+ ///
+ /// This function will return an error under a number of different
+ /// circumstances, to include but not limited to:
+ ///
+ /// * Opening a file that does not exist with read access.
+ /// * Attempting to open a file with access that the user lacks
+ /// permissions for
+ /// * Filesystem-level errors (full disk, etc)
+ pub fn open<P: AsPath + ?Sized>(&self, path: &P) -> io::Result<File> {
+ let path = path.as_path();
+ let inner = try!(fs_imp::File::open(path, &self.0));
+
+ // On *BSD systems, we can open a directory as a file and read from
+ // it: fd=open("/tmp", O_RDONLY); read(fd, buf, N); due to an old
+ // tradition before the introduction of opendir(3). We explicitly
+ // reject it because there are few use cases.
+ if cfg!(not(any(target_os = "linux", target_os = "android"))) &&
+ try!(inner.file_attr()).is_dir() {
+ Err(Error::new(ErrorKind::InvalidInput, "is a directory", None))
+ } else {
+ Ok(File { path: path.to_path_buf(), inner: inner })
+ }
+ }
+}
+impl AsInnerMut<fs_imp::OpenOptions> for OpenOptions {
+ fn as_inner_mut(&mut self) -> &mut fs_imp::OpenOptions { &mut self.0 }
+}
+
+impl Metadata {
+ /// Returns whether this metadata is for a directory.
+ pub fn is_dir(&self) -> bool { self.0.is_dir() }
+
+ /// Returns whether this metadata is for a regular file.
+ pub fn is_file(&self) -> bool { self.0.is_file() }
+
+ /// Returns the size of the file, in bytes, this metadata is for.
+ pub fn len(&self) -> u64 { self.0.size() }
+
+ /// Returns the permissions of the file this metadata is for.
+ pub fn permissions(&self) -> Permissions {
+ Permissions(self.0.perm())
+ }
+
+ /// Returns the most recent access time for a file.
+ ///
+ /// The return value is in milliseconds since the epoch.
+ pub fn accessed(&self) -> u64 { self.0.accessed() }
+
+ /// Returns the most recent modification time for a file.
+ ///
+ /// The return value is in milliseconds since the epoch.
+ pub fn modified(&self) -> u64 { self.0.modified() }
+}
+
+impl Permissions {
+ /// Returns whether these permissions describe a readonly file.
+ pub fn readonly(&self) -> bool { self.0.readonly() }
+
+ /// Modify the readonly flag for this set of permissions.
+ ///
+ /// This operation does **not** modify the filesystem. To modify the
+ /// filesystem use the `fs::set_permissions` function.
+ pub fn set_readonly(&mut self, readonly: bool) {
+ self.0.set_readonly(readonly)
+ }
+}
+
+impl FromInner<fs_imp::FilePermissions> for Permissions {
+ fn from_inner(f: fs_imp::FilePermissions) -> Permissions {
+ Permissions(f)
+ }
+}
+
+impl Iterator for ReadDir {
+ type Item = io::Result<DirEntry>;
+
+ fn next(&mut self) -> Option<io::Result<DirEntry>> {
+ self.0.next().map(|entry| entry.map(DirEntry))
+ }
+}
+
+impl DirEntry {
+ /// Returns the full path to the file that this entry represents.
+ ///
+ /// The full path is created by joining the original path to `read_dir` or
+ /// `walk_dir` with the filename of this entry.
+ pub fn path(&self) -> PathBuf { self.0.path() }
+}
+
+/// Remove a file from the underlying filesystem.
+///
+/// # Example
+///
+/// ```rust,no_run
+/// use std::fs;
+///
+/// fs::remove_file("/some/file/path.txt");
+/// ```
+///
+/// Note that, just because an unlink call was successful, it is not
+/// guaranteed that a file is immediately deleted (e.g. depending on
+/// platform, other open file descriptors may prevent immediate removal).
+///
+/// # Errors
+///
+/// This function will return an error if `path` points to a directory, if the
+/// user lacks permissions to remove the file, or if some other filesystem-level
+/// error occurs.
+pub fn remove_file<P: AsPath + ?Sized>(path: &P) -> io::Result<()> {
+ let path = path.as_path();
+ let e = match fs_imp::unlink(path) {
+ Ok(()) => return Ok(()),
+ Err(e) => e,
+ };
+ if !cfg!(windows) { return Err(e) }
+
+ // On unix, a readonly file can be successfully removed. On windows,
+ // however, it cannot. To keep the two platforms in line with
+ // respect to their behavior, catch this case on windows, attempt to
+ // change it to read-write, and then remove the file.
+ if e.kind() != ErrorKind::PermissionDenied { return Err(e) }
+
+ let attr = match metadata(path) { Ok(a) => a, Err(..) => return Err(e) };
+ let mut perms = attr.permissions();
+ if !perms.readonly() { return Err(e) }
+ perms.set_readonly(false);
+
+ if set_permissions(path, perms).is_err() { return Err(e) }
+ if fs_imp::unlink(path).is_ok() { return Ok(()) }
+
+ // Oops, try to put things back the way we found it
+ let _ = set_permissions(path, attr.permissions());
+ Err(e)
+}
+
+/// Given a path, query the file system to get information about a file,
+/// directory, etc.
+///
+/// This function will traverse soft links to query information about the
+/// destination file.
+///
+/// # Example
+///
+/// ```rust,no_run
+/// # fn foo() -> std::io::Result<()> {
+/// use std::fs;
+///
+/// let attr = try!(fs::metadata("/some/file/path.txt"));
+/// // inspect attr ...
+/// # Ok(())
+/// # }
+/// ```
+///
+/// # Errors
+///
+/// This function will return an error if the user lacks the requisite
+/// permissions to perform a `metadata` call on the given `path` or if there
+/// is no entry in the filesystem at the provided path.
+pub fn metadata<P: AsPath + ?Sized>(path: &P) -> io::Result<Metadata> {
+ fs_imp::stat(path.as_path()).map(Metadata)
+}
+
+/// Rename a file or directory to a new name.
+///
+/// # Example
+///
+/// ```rust,no_run
+/// use std::fs;
+///
+/// fs::rename("foo", "bar");
+/// ```
+///
+/// # Errors
+///
+/// This function will return an error if the provided `from` doesn't exist, if
+/// the process lacks permissions to view the contents, if `from` and `to`
+/// reside on separate filesystems, or if some other intermittent I/O error
+/// occurs.
+pub fn rename<P: AsPath + ?Sized, Q: AsPath + ?Sized>(from: &P, to: &Q)
+ -> io::Result<()> {
+ fs_imp::rename(from.as_path(), to.as_path())
+}
+
+/// Copies the contents of one file to another. This function will also
+/// copy the permission bits of the original file to the destination file.
+///
+/// This function will **overwrite** the contents of `to`.
+///
+/// Note that if `from` and `to` both point to the same file, then the file
+/// will likely get truncated by this operation.
+///
+/// # Example
+///
+/// ```rust
+/// use std::fs;
+///
+/// fs::copy("foo.txt", "bar.txt");
+/// ```
+///
+/// # Errors
+///
+/// This function will return an error in the following situations, but is not
+/// limited to just these cases:
+///
+/// * The `from` path is not a file
+/// * The `from` file does not exist
+/// * The current process does not have the permission rights to access
+/// `from` or write `to`
+pub fn copy<P: AsPath + ?Sized, Q: AsPath + ?Sized>(from: &P, to: &Q)
+ -> io::Result<u64> {
+ let from = from.as_path();
+ if !from.is_file() {
+ return Err(Error::new(ErrorKind::MismatchedFileTypeForOperation,
+ "the source path is not an existing file",
+ None))
+ }
+
+ let mut reader = try!(File::open(from));
+ let mut writer = try!(File::create(to));
+ let perm = try!(reader.metadata()).permissions();
+
+ let ret = try!(io::copy(&mut reader, &mut writer));
+ try!(set_permissions(to, perm));
+ Ok(ret)
+}
+
+/// Creates a new hard link on the filesystem.
+///
+/// The `dst` path will be a link pointing to the `src` path. Note that systems
+/// often require these two paths to both be located on the same filesystem.
+pub fn hard_link<P: AsPath + ?Sized, Q: AsPath + ?Sized>(src: &P, dst: &Q)
+ -> io::Result<()> {
+ fs_imp::link(src.as_path(), dst.as_path())
+}
+
+/// Creates a new soft link on the filesystem.
+///
+/// The `dst` path will be a soft link pointing to the `src` path.
+pub fn soft_link<P: AsPath + ?Sized, Q: AsPath + ?Sized>(src: &P, dst: &Q)
+ -> io::Result<()> {
+ fs_imp::symlink(src.as_path(), dst.as_path())
+}
+
+/// Reads a soft link, returning the file that the link points to.
+///
+/// # Errors
+///
+/// This function will return an error on failure. Failure conditions include
+/// reading a file that does not exist or reading a file that is not a soft
+/// link.
+pub fn read_link<P: AsPath + ?Sized>(path: &P) -> io::Result<PathBuf> {
+ fs_imp::readlink(path.as_path())
+}
+
+/// Create a new, empty directory at the provided path
+///
+/// # Example
+///
+/// ```rust
+/// use std::fs;
+///
+/// fs::create_dir("/some/dir");
+/// ```
+///
+/// # Errors
+///
+/// This function will return an error if the user lacks permissions to make a
+/// new directory at the provided `path`, or if the directory already exists.
+pub fn create_dir<P: AsPath + ?Sized>(path: &P) -> io::Result<()> {
+ fs_imp::mkdir(path.as_path())
+}
+
+/// Recursively create a directory and all of its parent components if they
+/// are missing.
+///
+/// # Errors
+///
+/// This function will fail if any directory in the path specified by `path`
+/// does not already exist and it could not be created otherwise. The specific
+/// error conditions for when a directory is being created (after it is
+/// determined to not exist) are outlined by `fs::create_dir`.
+pub fn create_dir_all<P: AsPath + ?Sized>(path: &P) -> io::Result<()> {
+ let path = path.as_path();
+ if path.is_dir() { return Ok(()) }
+ match path.parent() {
+ Some(p) if p != path => try!(create_dir_all(p)),
+ _ => {}
+ }
+ create_dir(path)
+}
+
+/// Remove an existing, empty directory
+///
+/// # Example
+///
+/// ```rust
+/// use std::fs;
+///
+/// fs::remove_dir("/some/dir");
+/// ```
+///
+/// # Errors
+///
+/// This function will return an error if the user lacks permissions to remove
+/// the directory at the provided `path`, or if the directory isn't empty.
+pub fn remove_dir<P: AsPath + ?Sized>(path: &P) -> io::Result<()> {
+ fs_imp::rmdir(path.as_path())
+}
+
+/// Removes a directory at this path, after removing all its contents. Use
+/// carefully!
+///
+/// This function does **not** follow soft links and it will simply remove the
+/// soft link itself.
+///
+/// # Errors
+///
+/// See `file::remove_file` and `fs::remove_dir`
+pub fn remove_dir_all<P: AsPath + ?Sized>(path: &P) -> io::Result<()> {
+ let path = path.as_path();
+ for child in try!(read_dir(path)) {
+ let child = try!(child).path();
+ let stat = try!(lstat(&*child));
+ if stat.is_dir() {
+ try!(remove_dir_all(&*child));
+ } else {
+ try!(remove_file(&*child));
+ }
+ }
+ return remove_dir(path);
+
+ #[cfg(unix)]
+ fn lstat(path: &Path) -> io::Result<fs_imp::FileAttr> { fs_imp::lstat(path) }
+ #[cfg(windows)]
+ fn lstat(path: &Path) -> io::Result<fs_imp::FileAttr> { fs_imp::stat(path) }
+}
+
+/// Returns an iterator over the entries within a directory.
+///
+/// The iterator will yield instances of `io::Result<DirEntry>`. New errors may
+/// be encountered after an iterator is initially constructed.
+///
+/// # Example
+///
+/// ```rust
+/// use std::io;
+/// use std::fs::{self, PathExt, DirEntry};
+/// use std::path::Path;
+///
+/// // one possible implementation of fs::walk_dir only visiting files
+/// fn visit_dirs(dir: &Path, cb: &mut FnMut(DirEntry)) -> io::Result<()> {
+/// if dir.is_dir() {
+/// for entry in try!(fs::read_dir(dir)) {
+/// let entry = try!(entry);
+/// if entry.path().is_dir() {
+/// try!(visit_dirs(&entry.path(), cb));
+/// } else {
+/// cb(entry);
+/// }
+/// }
+/// }
+/// Ok(())
+/// }
+/// ```
+///
+/// # Errors
+///
+/// This function will return an error if the provided `path` doesn't exist, if
+/// the process lacks permissions to view the contents or if the `path` points
+/// at a non-directory file
+pub fn read_dir<P: AsPath + ?Sized>(path: &P) -> io::Result<ReadDir> {
+ fs_imp::readdir(path.as_path()).map(ReadDir)
+}
+
+/// Returns an iterator that will recursively walk the directory structure
+/// rooted at `path`.
+///
+/// The path given will not be iterated over, and this will perform iteration in
+/// some top-down order. The contents of unreadable subdirectories are ignored.
+///
+/// The iterator will yield instances of `io::Result<DirEntry>`. New errors may
+/// be encountered after an iterator is initially constructed.
+pub fn walk_dir<P: AsPath + ?Sized>(path: &P) -> io::Result<WalkDir> {
+ let start = try!(read_dir(path));
+ Ok(WalkDir { cur: Some(start), stack: Vec::new() })
+}
+
+impl Iterator for WalkDir {
+ type Item = io::Result<DirEntry>;
+
+ fn next(&mut self) -> Option<io::Result<DirEntry>> {
+ loop {
+ if let Some(ref mut cur) = self.cur {
+ match cur.next() {
+ Some(Err(e)) => return Some(Err(e)),
+ Some(Ok(next)) => {
+ let path = next.path();
+ if path.is_dir() {
+ self.stack.push(read_dir(&*path));
+ }
+ return Some(Ok(next))
+ }
+ None => {}
+ }
+ }
+ self.cur = None;
+ match self.stack.pop() {
+ Some(Err(e)) => return Some(Err(e)),
+ Some(Ok(next)) => self.cur = Some(next),
+ None => return None,
+ }
+ }
+ }
+}
+
+/// Utility methods for paths.
+pub trait PathExt {
+ /// Get information on the file, directory, etc at this path.
+ ///
+ /// Consult the `fs::stat` documentation for more info.
+ ///
+ /// This call preserves identical runtime/error semantics with `file::stat`.
+ fn metadata(&self) -> io::Result<Metadata>;
+
+ /// Boolean value indicator whether the underlying file exists on the local
+ /// filesystem. Returns false in exactly the cases where `fs::stat` fails.
+ fn exists(&self) -> bool;
+
+ /// Whether the underlying implementation (be it a file path, or something
+ /// else) points at a "regular file" on the FS. Will return false for paths
+ /// to non-existent locations or directories or other non-regular files
+ /// (named pipes, etc). Follows links when making this determination.
+ fn is_file(&self) -> bool;
+
+ /// Whether the underlying implementation (be it a file path, or something
+ /// else) is pointing at a directory in the underlying FS. Will return
+ /// false for paths to non-existent locations or if the item is not a
+ /// directory (eg files, named pipes, etc). Follows links when making this
+ /// determination.
+ fn is_dir(&self) -> bool;
+}
+
+impl PathExt for Path {
+ fn metadata(&self) -> io::Result<Metadata> { metadata(self) }
+
+ fn exists(&self) -> bool { metadata(self).is_ok() }
+
+ fn is_file(&self) -> bool {
+ metadata(self).map(|s| s.is_file()).unwrap_or(false)
+ }
+ fn is_dir(&self) -> bool {
+ metadata(self).map(|s| s.is_dir()).unwrap_or(false)
+ }
+}
+
+/// Changes the timestamps for a file's last modification and access time.
+///
+/// The file at the path specified will have its last access time set to
+/// `atime` and its modification time set to `mtime`. The times specified should
+/// be in milliseconds.
+pub fn set_file_times<P: AsPath + ?Sized>(path: &P, accessed: u64,
+ modified: u64) -> io::Result<()> {
+ fs_imp::utimes(path.as_path(), accessed, modified)
+}
+
+/// Changes the permissions found on a file or a directory.
+///
+/// # Example
+///
+/// ```
+/// # fn foo() -> std::io::Result<()> {
+/// use std::fs;
+///
+/// let mut perms = try!(fs::metadata("foo.txt")).permissions();
+/// perms.set_readonly(true);
+/// try!(fs::set_permissions("foo.txt", perms));
+/// # Ok(())
+/// # }
+/// ```
+///
+/// # Errors
+///
+/// This function will return an error if the provided `path` doesn't exist, if
+/// the process lacks permissions to change the attributes of the file, or if
+/// some other I/O error is encountered.
+pub fn set_permissions<P: AsPath + ?Sized>(path: &P, perm: Permissions)
+ -> io::Result<()> {
+ fs_imp::set_perm(path.as_path(), perm.0)
+}
+
+#[cfg(test)]
+mod tests {
+ use prelude::v1::*;
+ use io::prelude::*;
+
+ use fs::{self, File, OpenOptions};
+ use io::{ErrorKind, SeekFrom};
+ use path::PathBuf;
+ use path::Path as Path2;
+ use os;
+ use rand::{self, StdRng, Rng};
+ use str;
+
+ macro_rules! check { ($e:expr) => (
+ match $e {
+ Ok(t) => t,
+ Err(e) => panic!("{} failed with: {}", stringify!($e), e),
+ }
+ ) }
+
+ macro_rules! error { ($e:expr, $s:expr) => (
+ match $e {
+ Ok(_) => panic!("Unexpected success. Should've been: {:?}", $s),
+ Err(ref err) => assert!(err.to_string().contains($s.as_slice()),
+ format!("`{}` did not contain `{}`", err, $s))
+ }
+ ) }
+
+ pub struct TempDir(PathBuf);
+
+ impl TempDir {
+ fn join(&self, path: &str) -> PathBuf {
+ let TempDir(ref p) = *self;
+ p.join(path)
+ }
+
+ fn path<'a>(&'a self) -> &'a Path2 {
+ let TempDir(ref p) = *self;
+ p
+ }
+ }
+
+ impl Drop for TempDir {
+ fn drop(&mut self) {
+ // Gee, seeing how we're testing the fs module I sure hope that we
+ // at least implement this correctly!
+ let TempDir(ref p) = *self;
+ check!(fs::remove_dir_all(p));
+ }
+ }
+
+ pub fn tmpdir() -> TempDir {
+ let s = os::tmpdir();
+ let p = Path2::new(s.as_str().unwrap());
+ let ret = p.join(&format!("rust-{}", rand::random::<u32>()));
+ check!(fs::create_dir(&ret));
+ TempDir(ret)
+ }
+
+ #[test]
+ fn file_test_io_smoke_test() {
+ let message = "it's alright. have a good time";
+ let tmpdir = tmpdir();
+ let filename = &tmpdir.join("file_rt_io_file_test.txt");
+ {
+ let mut write_stream = check!(File::create(filename));
+ check!(write_stream.write(message.as_bytes()));
+ }
+ {
+ let mut read_stream = check!(File::open(filename));
+ 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[..n]).unwrap().to_string()
+ };
+ assert_eq!(read_str.as_slice(), message);
+ }
+ check!(fs::remove_file(filename));
+ }
+
+ #[test]
+ fn invalid_path_raises() {
+ let tmpdir = tmpdir();
+ let filename = &tmpdir.join("file_that_does_not_exist.txt");
+ let result = File::open(filename);
+
+ if cfg!(unix) {
+ error!(result, "o such file or directory");
+ }
+ // error!(result, "couldn't open path as file");
+ // error!(result, format!("path={}; mode=open; access=read", filename.display()));
+ }
+
+ #[test]
+ fn file_test_iounlinking_invalid_path_should_raise_condition() {
+ let tmpdir = tmpdir();
+ let filename = &tmpdir.join("file_another_file_that_does_not_exist.txt");
+
+ let result = fs::remove_file(filename);
+
+ if cfg!(unix) {
+ error!(result, "o such file or directory");
+ }
+ // error!(result, "couldn't unlink path");
+ // error!(result, format!("path={}", filename.display()));
+ }
+
+ #[test]
+ fn file_test_io_non_positional_read() {
+ let message: &str = "ten-four";
+ let mut read_mem = [0; 8];
+ let tmpdir = tmpdir();
+ let filename = &tmpdir.join("file_rt_io_file_test_positional.txt");
+ {
+ let mut rw_stream = check!(File::create(filename));
+ check!(rw_stream.write(message.as_bytes()));
+ }
+ {
+ let mut read_stream = check!(File::open(filename));
+ {
+ let read_buf = &mut read_mem[0..4];
+ check!(read_stream.read(read_buf));
+ }
+ {
+ let read_buf = &mut read_mem[4..8];
+ check!(read_stream.read(read_buf));
+ }
+ }
+ check!(fs::remove_file(filename));
+ let read_str = str::from_utf8(&read_mem).unwrap();
+ assert_eq!(read_str, message);
+ }
+
+ #[test]
+ fn file_test_io_seek_and_tell_smoke_test() {
+ let message = "ten-four";
+ let mut read_mem = [0; 4];
+ let set_cursor = 4 as u64;
+ let mut tell_pos_pre_read;
+ let mut tell_pos_post_read;
+ let tmpdir = tmpdir();
+ let filename = &tmpdir.join("file_rt_io_file_test_seeking.txt");
+ {
+ let mut rw_stream = check!(File::create(filename));
+ check!(rw_stream.write(message.as_bytes()));
+ }
+ {
+ let mut read_stream = check!(File::open(filename));
+ check!(read_stream.seek(SeekFrom::Start(set_cursor)));
+ tell_pos_pre_read = check!(read_stream.seek(SeekFrom::Current(0)));
+ check!(read_stream.read(&mut read_mem));
+ tell_pos_post_read = check!(read_stream.seek(SeekFrom::Current(0)));
+ }
+ check!(fs::remove_file(filename));
+ let read_str = str::from_utf8(&read_mem).unwrap();
+ assert_eq!(read_str, &message[4..8]);
+ assert_eq!(tell_pos_pre_read, set_cursor);
+ assert_eq!(tell_pos_post_read, message.len() as u64);
+ }
+
+ #[test]
+ fn file_test_io_seek_and_write() {
+ let initial_msg = "food-is-yummy";
+ let overwrite_msg = "-the-bar!!";
+ let final_msg = "foo-the-bar!!";
+ let seek_idx = 3;
+ let mut read_mem = [0; 13];
+ let tmpdir = tmpdir();
+ let filename = &tmpdir.join("file_rt_io_file_test_seek_and_write.txt");
+ {
+ let mut rw_stream = check!(File::create(filename));
+ check!(rw_stream.write(initial_msg.as_bytes()));
+ check!(rw_stream.seek(SeekFrom::Start(seek_idx)));
+ check!(rw_stream.write(overwrite_msg.as_bytes()));
+ }
+ {
+ let mut read_stream = check!(File::open(filename));
+ check!(read_stream.read(&mut read_mem));
+ }
+ check!(fs::remove_file(filename));
+ let read_str = str::from_utf8(&read_mem).unwrap();
+ assert!(read_str == final_msg);
+ }
+
+ #[test]
+ fn file_test_io_seek_shakedown() {
+ // 01234567890123
+ let initial_msg = "qwer-asdf-zxcv";
+ let chunk_one: &str = "qwer";
+ let chunk_two: &str = "asdf";
+ let chunk_three: &str = "zxcv";
+ let mut read_mem = [0; 4];
+ let tmpdir = tmpdir();
+ let filename = &tmpdir.join("file_rt_io_file_test_seek_shakedown.txt");
+ {
+ let mut rw_stream = check!(File::create(filename));
+ check!(rw_stream.write(initial_msg.as_bytes()));
+ }
+ {
+ let mut read_stream = check!(File::open(filename));
+
+ check!(read_stream.seek(SeekFrom::End(-4)));
+ check!(read_stream.read(&mut read_mem));
+ assert_eq!(str::from_utf8(&read_mem).unwrap(), chunk_three);
+
+ check!(read_stream.seek(SeekFrom::Current(-9)));
+ check!(read_stream.read(&mut read_mem));
+ assert_eq!(str::from_utf8(&read_mem).unwrap(), chunk_two);
+
+ check!(read_stream.seek(SeekFrom::Start(0)));
+ check!(read_stream.read(&mut read_mem));
+ assert_eq!(str::from_utf8(&read_mem).unwrap(), chunk_one);
+ }
+ check!(fs::remove_file(filename));
+ }
+
+ #[test]
+ fn file_test_stat_is_correct_on_is_file() {
+ let tmpdir = tmpdir();
+ let filename = &tmpdir.join("file_stat_correct_on_is_file.txt");
+ {
+ let mut opts = OpenOptions::new();
+ let mut fs = check!(opts.read(true).write(true)
+ .create(true).open(filename));
+ let msg = "hw";
+ fs.write(msg.as_bytes()).unwrap();
+
+ let fstat_res = check!(fs.metadata());
+ assert!(fstat_res.is_file());
+ }
+ let stat_res_fn = check!(fs::metadata(filename));
+ assert!(stat_res_fn.is_file());
+ let stat_res_meth = check!(filename.metadata());
+ assert!(stat_res_meth.is_file());
+ check!(fs::remove_file(filename));
+ }
+
+ #[test]
+ fn file_test_stat_is_correct_on_is_dir() {
+ let tmpdir = tmpdir();
+ let filename = &tmpdir.join("file_stat_correct_on_is_dir");
+ check!(fs::create_dir(filename));
+ let stat_res_fn = check!(fs::metadata(filename));
+ assert!(stat_res_fn.is_dir());
+ let stat_res_meth = check!(filename.metadata());
+ assert!(stat_res_meth.is_dir());
+ check!(fs::remove_dir(filename));
+ }
+
+ #[test]
+ fn file_test_fileinfo_false_when_checking_is_file_on_a_directory() {
+ let tmpdir = tmpdir();
+ let dir = &tmpdir.join("fileinfo_false_on_dir");
+ check!(fs::create_dir(dir));
+ assert!(dir.is_file() == false);
+ check!(fs::remove_dir(dir));
+ }
+
+ #[test]
+ fn file_test_fileinfo_check_exists_before_and_after_file_creation() {
+ let tmpdir = tmpdir();
+ let file = &tmpdir.join("fileinfo_check_exists_b_and_a.txt");
+ check!(check!(File::create(file)).write(b"foo"));
+ assert!(file.exists());
+ check!(fs::remove_file(file));
+ assert!(!file.exists());
+ }
+
+ #[test]
+ fn file_test_directoryinfo_check_exists_before_and_after_mkdir() {
+ let tmpdir = tmpdir();
+ let dir = &tmpdir.join("before_and_after_dir");
+ assert!(!dir.exists());
+ check!(fs::create_dir(dir));
+ assert!(dir.exists());
+ assert!(dir.is_dir());
+ check!(fs::remove_dir(dir));
+ assert!(!dir.exists());
+ }
+
+ #[test]
+ fn file_test_directoryinfo_readdir() {
+ let tmpdir = tmpdir();
+ let dir = &tmpdir.join("di_readdir");
+ check!(fs::create_dir(dir));
+ let prefix = "foo";
+ for n in range(0, 3) {
+ let f = dir.join(&format!("{}.txt", n));
+ let mut w = check!(File::create(&f));
+ let msg_str = format!("{}{}", prefix, n.to_string());
+ let msg = msg_str.as_bytes();
+ check!(w.write(msg));
+ }
+ let mut files = check!(fs::read_dir(dir));
+ let mut mem = [0u8; 4];
+ for f in files {
+ let f = f.unwrap().path();
+ {
+ let n = f.file_stem().unwrap();
+ check!(check!(File::open(&f)).read(&mut mem));
+ let read_str = str::from_utf8(&mem).unwrap();
+ let expected = format!("{}{}", prefix, n.to_str().unwrap());
+ assert_eq!(expected.as_slice(), read_str);
+ }
+ check!(fs::remove_file(&f));
+ }
+ check!(fs::remove_dir(dir));
+ }
+
+ #[test]
+ fn file_test_walk_dir() {
+ let tmpdir = tmpdir();
+ let dir = &tmpdir.join("walk_dir");
+ check!(fs::create_dir(dir));
+
+ let dir1 = &dir.join("01/02/03");
+ check!(fs::create_dir_all(dir1));
+ check!(File::create(&dir1.join("04")));
+
+ let dir2 = &dir.join("11/12/13");
+ check!(fs::create_dir_all(dir2));
+ check!(File::create(&dir2.join("14")));
+
+ let mut files = check!(fs::walk_dir(dir));
+ let mut cur = [0u8; 2];
+ for f in files {
+ let f = f.unwrap().path();
+ let stem = f.file_stem().unwrap().to_str().unwrap();
+ let root = stem.as_bytes()[0] - b'0';
+ let name = stem.as_bytes()[1] - b'0';
+ assert!(cur[root as usize] < name);
+ cur[root as usize] = name;
+ }
+
+ check!(fs::remove_dir_all(dir));
+ }
+
+ #[test]
+ fn mkdir_path_already_exists_error() {
+ let tmpdir = tmpdir();
+ let dir = &tmpdir.join("mkdir_error_twice");
+ check!(fs::create_dir(dir));
+ let e = fs::create_dir(dir).err().unwrap();
+ assert_eq!(e.kind(), ErrorKind::PathAlreadyExists);
+ }
+
+ #[test]
+ fn recursive_mkdir() {
+ let tmpdir = tmpdir();
+ let dir = tmpdir.join("d1/d2");
+ check!(fs::create_dir_all(&dir));
+ assert!(dir.is_dir())
+ }
+
+ #[test]
+ fn recursive_mkdir_failure() {
+ let tmpdir = tmpdir();
+ let dir = tmpdir.join("d1");
+ let file = dir.join("f1");
+
+ check!(fs::create_dir_all(&dir));
+ check!(File::create(&file));
+
+ let result = fs::create_dir_all(&file);
+
+ assert!(result.is_err());
+ // error!(result, "couldn't recursively mkdir");
+ // error!(result, "couldn't create directory");
+ // error!(result, "mode=0700");
+ // error!(result, format!("path={}", file.display()));
+ }
+
+ #[test]
+ fn recursive_mkdir_slash() {
+ check!(fs::create_dir_all(&Path2::new("/")));
+ }
+
+ // FIXME(#12795) depends on lstat to work on windows
+ #[cfg(not(windows))]
+ #[test]
+ fn recursive_rmdir() {
+ let tmpdir = tmpdir();
+ let d1 = tmpdir.join("d1");
+ let dt = d1.join("t");
+ let dtt = dt.join("t");
+ let d2 = tmpdir.join("d2");
+ let canary = d2.join("do_not_delete");
+ check!(fs::create_dir_all(&dtt));
+ check!(fs::create_dir_all(&d2));
+ check!(check!(File::create(&canary)).write(b"foo"));
+ check!(fs::soft_link(&d2, &dt.join("d2")));
+ check!(fs::remove_dir_all(&d1));
+
+ assert!(!d1.is_dir());
+ assert!(canary.exists());
+ }
+
+ #[test]
+ fn unicode_path_is_dir() {
+ assert!(Path2::new(".").is_dir());
+ assert!(!Path2::new("test/stdtest/fs.rs").is_dir());
+
+ let tmpdir = tmpdir();
+
+ let mut dirpath = tmpdir.path().to_path_buf();
+ dirpath.push(&format!("test-가一ー你好"));
+ check!(fs::create_dir(&dirpath));
+ assert!(dirpath.is_dir());
+
+ let mut filepath = dirpath;
+ filepath.push("unicode-file-\u{ac00}\u{4e00}\u{30fc}\u{4f60}\u{597d}.rs");
+ check!(File::create(&filepath)); // ignore return; touch only
+ assert!(!filepath.is_dir());
+ assert!(filepath.exists());
+ }
+
+ #[test]
+ fn unicode_path_exists() {
+ assert!(Path2::new(".").exists());
+ assert!(!Path2::new("test/nonexistent-bogus-path").exists());
+
+ let tmpdir = tmpdir();
+ let unicode = tmpdir.path();
+ let unicode = unicode.join(&format!("test-각丁ー再见"));
+ check!(fs::create_dir(&unicode));
+ assert!(unicode.exists());
+ assert!(!Path2::new("test/unicode-bogus-path-각丁ー再见").exists());
+ }
+
+ #[test]
+ fn copy_file_does_not_exist() {
+ let from = Path2::new("test/nonexistent-bogus-path");
+ let to = Path2::new("test/other-bogus-path");
+
+ match fs::copy(&from, &to) {
+ Ok(..) => panic!(),
+ Err(..) => {
+ assert!(!from.exists());
+ assert!(!to.exists());
+ }
+ }
+ }
+
+ #[test]
+ fn copy_file_ok() {
+ let tmpdir = tmpdir();
+ let input = tmpdir.join("in.txt");
+ let out = tmpdir.join("out.txt");
+
+ check!(check!(File::create(&input)).write(b"hello"));
+ check!(fs::copy(&input, &out));
+ let mut v = Vec::new();
+ check!(check!(File::open(&out)).read_to_end(&mut v));
+ assert_eq!(v.as_slice(), b"hello");
+
+ assert_eq!(check!(input.metadata()).permissions(),
+ check!(out.metadata()).permissions());
+ }
+
+ #[test]
+ fn copy_file_dst_dir() {
+ let tmpdir = tmpdir();
+ let out = tmpdir.join("out");
+
+ check!(File::create(&out));
+ match fs::copy(&*out, tmpdir.path()) {
+ Ok(..) => panic!(), Err(..) => {}
+ }
+ }
+
+ #[test]
+ fn copy_file_dst_exists() {
+ let tmpdir = tmpdir();
+ let input = tmpdir.join("in");
+ let output = tmpdir.join("out");
+
+ check!(check!(File::create(&input)).write("foo".as_bytes()));
+ check!(check!(File::create(&output)).write("bar".as_bytes()));
+ check!(fs::copy(&input, &output));
+
+ let mut v = Vec::new();
+ check!(check!(File::open(&output)).read_to_end(&mut v));
+ assert_eq!(v, b"foo".to_vec());
+ }
+
+ #[test]
+ fn copy_file_src_dir() {
+ let tmpdir = tmpdir();
+ let out = tmpdir.join("out");
+
+ match fs::copy(tmpdir.path(), &out) {
+ Ok(..) => panic!(), Err(..) => {}
+ }
+ assert!(!out.exists());
+ }
+
+ #[test]
+ fn copy_file_preserves_perm_bits() {
+ let tmpdir = tmpdir();
+ let input = tmpdir.join("in.txt");
+ let out = tmpdir.join("out.txt");
+
+ let attr = check!(check!(File::create(&input)).metadata());
+ let mut p = attr.permissions();
+ p.set_readonly(true);
+ check!(fs::set_permissions(&input, p));
+ check!(fs::copy(&input, &out));
+ assert!(check!(out.metadata()).permissions().readonly());
+ }
+
+ #[cfg(not(windows))] // FIXME(#10264) operation not permitted?
+ #[test]
+ fn symlinks_work() {
+ let tmpdir = tmpdir();
+ let input = tmpdir.join("in.txt");
+ let out = tmpdir.join("out.txt");
+
+ check!(check!(File::create(&input)).write("foobar".as_bytes()));
+ check!(fs::soft_link(&input, &out));
+ // if cfg!(not(windows)) {
+ // assert_eq!(check!(lstat(&out)).kind, FileType::Symlink);
+ // assert_eq!(check!(out.lstat()).kind, FileType::Symlink);
+ // }
+ assert_eq!(check!(fs::metadata(&out)).len(),
+ check!(fs::metadata(&input)).len());
+ let mut v = Vec::new();
+ check!(check!(File::open(&out)).read_to_end(&mut v));
+ assert_eq!(v, b"foobar".to_vec());
+ }
+
+ #[cfg(not(windows))] // apparently windows doesn't like symlinks
+ #[test]
+ fn symlink_noexist() {
+ let tmpdir = tmpdir();
+ // symlinks can point to things that don't exist
+ check!(fs::soft_link(&tmpdir.join("foo"), &tmpdir.join("bar")));
+ assert_eq!(check!(fs::read_link(&tmpdir.join("bar"))),
+ tmpdir.join("foo"));
+ }
+
+ #[test]
+ fn readlink_not_symlink() {
+ let tmpdir = tmpdir();
+ match fs::read_link(tmpdir.path()) {
+ Ok(..) => panic!("wanted a failure"),
+ Err(..) => {}
+ }
+ }
+
+ #[test]
+ fn links_work() {
+ let tmpdir = tmpdir();
+ let input = tmpdir.join("in.txt");
+ let out = tmpdir.join("out.txt");
+
+ check!(check!(File::create(&input)).write("foobar".as_bytes()));
+ check!(fs::hard_link(&input, &out));
+ assert_eq!(check!(fs::metadata(&out)).len(),
+ check!(fs::metadata(&input)).len());
+ assert_eq!(check!(fs::metadata(&out)).len(),
+ check!(input.metadata()).len());
+ let mut v = Vec::new();
+ check!(check!(File::open(&out)).read_to_end(&mut v));
+ assert_eq!(v, b"foobar".to_vec());
+
+ // can't link to yourself
+ match fs::hard_link(&input, &input) {
+ Ok(..) => panic!("wanted a failure"),
+ Err(..) => {}
+ }
+ // can't link to something that doesn't exist
+ match fs::hard_link(&tmpdir.join("foo"), &tmpdir.join("bar")) {
+ Ok(..) => panic!("wanted a failure"),
+ Err(..) => {}
+ }
+ }
+
+ #[test]
+ fn chmod_works() {
+ let tmpdir = tmpdir();
+ let file = tmpdir.join("in.txt");
+
+ check!(File::create(&file));
+ let attr = check!(fs::metadata(&file));
+ assert!(!attr.permissions().readonly());
+ let mut p = attr.permissions();
+ p.set_readonly(true);
+ check!(fs::set_permissions(&file, p.clone()));
+ let attr = check!(fs::metadata(&file));
+ assert!(attr.permissions().readonly());
+
+ match fs::set_permissions(&tmpdir.join("foo"), p) {
+ Ok(..) => panic!("wanted a panic"),
+ Err(..) => {}
+ }
+ }
+
+ #[test]
+ fn sync_doesnt_kill_anything() {
+ let tmpdir = tmpdir();
+ let path = tmpdir.join("in.txt");
+
+ let mut file = check!(File::create(&path));
+ check!(file.sync_all());
+ check!(file.sync_data());
+ check!(file.write(b"foo"));
+ check!(file.sync_all());
+ check!(file.sync_data());
+ }
+
+ #[test]
+ fn truncate_works() {
+ let tmpdir = tmpdir();
+ let path = tmpdir.join("in.txt");
+
+ let mut file = check!(File::create(&path));
+ check!(file.write(b"foo"));
+ check!(file.sync_all());
+
+ // Do some simple things with truncation
+ assert_eq!(check!(file.metadata()).len(), 3);
+ check!(file.set_len(10));
+ assert_eq!(check!(file.metadata()).len(), 10);
+ check!(file.write(b"bar"));
+ check!(file.sync_all());
+ assert_eq!(check!(file.metadata()).len(), 10);
+
+ let mut v = Vec::new();
+ check!(check!(File::open(&path)).read_to_end(&mut v));
+ assert_eq!(v, b"foobar\0\0\0\0".to_vec());
+
+ // Truncate to a smaller length, don't seek, and then write something.
+ // Ensure that the intermediate zeroes are all filled in (we're seeked
+ // past the end of the file).
+ check!(file.set_len(2));
+ assert_eq!(check!(file.metadata()).len(), 2);
+ check!(file.write(b"wut"));
+ check!(file.sync_all());
+ assert_eq!(check!(file.metadata()).len(), 9);
+ let mut v = Vec::new();
+ check!(check!(File::open(&path)).read_to_end(&mut v));
+ assert_eq!(v, b"fo\0\0\0\0wut".to_vec());
+ }
+
+ #[test]
+ fn open_flavors() {
+ use fs::OpenOptions as OO;
+ fn c<T: Clone>(t: &T) -> T { t.clone() }
+
+ let tmpdir = tmpdir();
+
+ let mut r = OO::new(); r.read(true);
+ let mut w = OO::new(); w.write(true);
+ let mut rw = OO::new(); rw.write(true).read(true);
+
+ match r.open(&tmpdir.join("a")) {
+ Ok(..) => panic!(), Err(..) => {}
+ }
+
+ // Perform each one twice to make sure that it succeeds the second time
+ // (where the file exists)
+ check!(c(&w).create(true).open(&tmpdir.join("b")));
+ assert!(tmpdir.join("b").exists());
+ check!(c(&w).create(true).open(&tmpdir.join("b")));
+ check!(w.open(&tmpdir.join("b")));
+
+ check!(c(&rw).create(true).open(&tmpdir.join("c")));
+ assert!(tmpdir.join("c").exists());
+ check!(c(&rw).create(true).open(&tmpdir.join("c")));
+ check!(rw.open(&tmpdir.join("c")));
+
+ check!(c(&w).append(true).create(true).open(&tmpdir.join("d")));
+ assert!(tmpdir.join("d").exists());
+ check!(c(&w).append(true).create(true).open(&tmpdir.join("d")));
+ check!(c(&w).append(true).open(&tmpdir.join("d")));
+
+ check!(c(&rw).append(true).create(true).open(&tmpdir.join("e")));
+ assert!(tmpdir.join("e").exists());
+ check!(c(&rw).append(true).create(true).open(&tmpdir.join("e")));
+ check!(c(&rw).append(true).open(&tmpdir.join("e")));
+
+ check!(c(&w).truncate(true).create(true).open(&tmpdir.join("f")));
+ assert!(tmpdir.join("f").exists());
+ check!(c(&w).truncate(true).create(true).open(&tmpdir.join("f")));
+ check!(c(&w).truncate(true).open(&tmpdir.join("f")));
+
+ check!(c(&rw).truncate(true).create(true).open(&tmpdir.join("g")));
+ assert!(tmpdir.join("g").exists());
+ check!(c(&rw).truncate(true).create(true).open(&tmpdir.join("g")));
+ check!(c(&rw).truncate(true).open(&tmpdir.join("g")));
+
+ check!(check!(File::create(&tmpdir.join("h"))).write("foo".as_bytes()));
+ check!(r.open(&tmpdir.join("h")));
+ {
+ let mut f = check!(r.open(&tmpdir.join("h")));
+ assert!(f.write("wut".as_bytes()).is_err());
+ }
+ assert_eq!(check!(fs::metadata(&tmpdir.join("h"))).len(), 3);
+ {
+ let mut f = check!(c(&w).append(true).open(&tmpdir.join("h")));
+ check!(f.write("bar".as_bytes()));
+ }
+ assert_eq!(check!(fs::metadata(&tmpdir.join("h"))).len(), 6);
+ {
+ let mut f = check!(c(&w).truncate(true).open(&tmpdir.join("h")));
+ check!(f.write("bar".as_bytes()));
+ }
+ assert_eq!(check!(fs::metadata(&tmpdir.join("h"))).len(), 3);
+ }
+
+ #[test]
+ fn utime() {
+ let tmpdir = tmpdir();
+ let path = tmpdir.join("a");
+ check!(File::create(&path));
+ // These numbers have to be bigger than the time in the day to account
+ // for timezones Windows in particular will fail in certain timezones
+ // with small enough values
+ check!(fs::set_file_times(&path, 100000, 200000));
+ assert_eq!(check!(path.metadata()).accessed(), 100000);
+ assert_eq!(check!(path.metadata()).modified(), 200000);
+ }
+
+ #[test]
+ fn utime_noexist() {
+ let tmpdir = tmpdir();
+
+ match fs::set_file_times(&tmpdir.join("a"), 100, 200) {
+ Ok(..) => panic!(),
+ Err(..) => {}
+ }
+ }
+
+ #[test]
+ fn binary_file() {
+ let mut bytes = [0; 1024];
+ StdRng::new().ok().unwrap().fill_bytes(&mut bytes);
+
+ let tmpdir = tmpdir();
+
+ check!(check!(File::create(&tmpdir.join("test"))).write(&bytes));
+ let mut v = Vec::new();
+ check!(check!(File::open(&tmpdir.join("test"))).read_to_end(&mut v));
+ assert!(v == bytes.as_slice());
+ }
+
+ #[test]
+ fn unlink_readonly() {
+ let tmpdir = tmpdir();
+ let path = tmpdir.join("file");
+ check!(File::create(&path));
+ let mut perm = check!(fs::metadata(&path)).permissions();
+ perm.set_readonly(true);
+ check!(fs::set_permissions(&path, perm));
+ check!(fs::remove_file(&path));
+ }
+}
use fmt;
use iter::Iterator;
use marker::Sized;
-use mem;
use ops::{Drop, FnOnce};
use option::Option::{self, Some, None};
use ptr::PtrExt;
unsafe {
let n = try!(f({
let base = v.as_mut_ptr().offset(v.len() as isize);
- black_box(slice::from_raw_mut_buf(mem::copy_lifetime(v, &base),
- v.capacity() - v.len()))
+ black_box(slice::from_raw_parts_mut(base,
+ v.capacity() - v.len()))
}));
// If the closure (typically a `read` implementation) reported that it
//
// To this end, we use an RAII guard (to protect against panics) which updates
// the length of the string when it is dropped. This guard initially truncates
-// the string to the prior length and only afer we've validated that the
+// the string to the prior length and only after we've validated that the
// new contents are valid UTF-8 do we allow it to set a longer length.
//
// The unsafety in this function is twofold:
///
/// # Note
///
- /// This instance may reach EOF after reading fewer bytes than indiccated by
+ /// This instance may reach EOF after reading fewer bytes than indicated by
/// this method if the underlying `Read` instance reaches EOF.
pub fn limit(&self) -> u64 { self.limit }
}
//! contained in this module.
pub use super::{Read, ReadExt, Write, WriteExt, BufRead, BufReadExt};
+pub use fs::PathExt;
// FIXME: pub use as `Seek` when the name isn't in the actual prelude any more
pub use super::Seek as NewSeek;
#![cfg_attr(test, feature(test))]
// Don't link to std. We are std.
+#![feature(no_std)]
#![no_std]
#![deny(missing_docs)]
extern crate core;
#[macro_use]
-#[macro_reexport(vec)]
+#[macro_reexport(vec, format)]
extern crate "collections" as core_collections;
#[allow(deprecated)] extern crate "rand" as core_rand;
#[cfg(not(test))] pub use alloc::boxed;
pub use alloc::rc;
+pub use core_collections::fmt;
pub use core_collections::slice;
pub use core_collections::str;
pub use core_collections::string;
pub mod dynamic_lib;
pub mod ffi;
-pub mod fmt;
pub mod old_io;
pub mod io;
+pub mod fs;
pub mod os;
pub mod env;
pub mod path;
// can be resolved within libstd.
#[doc(hidden)]
mod std {
+ // NOTE: remove after next snapshot
// mods used for deriving
- pub use clone;
- pub use cmp;
- pub use hash;
- pub use default;
+ #[cfg(stage0)] pub use clone;
+ #[cfg(stage0)] pub use cmp;
+ #[cfg(stage0)] pub use hash;
+ #[cfg(stage0)] pub use default;
pub use sync; // used for select!()
pub use error; // used for try!()
pub use boxed; // used for vec![]
// for-loops
- pub use iter;
+ // NOTE: remove after next snapshot
+ #[cfg(stage0)] pub use iter;
}
/// format!("hello {}", "world!");
/// format!("x = {}, y = {y}", 10, y = 30);
/// ```
+#[cfg(stage0)] // NOTE: remove after snapshot
#[macro_export]
#[stable(feature = "rust1", since = "1.0.0")]
macro_rules! format {
pub use core::num::{from_uint, from_u8, from_u16, from_u32, from_u64};
pub use core::num::{from_f32, from_f64};
pub use core::num::{FromStrRadix, from_str_radix};
-pub use core::num::{FpCategory};
+pub use core::num::{FpCategory, ParseIntError, ParseFloatError};
use option::Option;
// Push it onto the list.
let ptr = ptr as *const u16;
- let buf = slice::from_raw_buf(&ptr, len);
+ let buf = slice::from_raw_parts(ptr, len);
let opt_s = String::from_utf16(sys::truncate_utf16_at_nul(buf));
opt_s.ok().expect("CommandLineToArgvW returned invalid UTF-16")
}).collect();
///
/// The memory map is released (unmapped) when the destructor is run, so don't
/// let it leave scope by accident if you want it to stick around.
-#[allow(missing_copy_implementations)]
pub struct MemoryMap {
data: *mut u8,
len: uint,
}
#[cfg(target_os = "openbsd")]
+#[deprecated(since = "1.0.0", reason = "renamed to env::consts")]
+#[unstable(feature = "os")]
pub mod consts {
pub use os::arch_consts::ARCH;
///
/// If `self.file_name()` is `None`, does nothing and returns `false`.
///
- /// Otherwise, returns `tru`; if `self.exension()` is `None`, the extension
+ /// Otherwise, returns `true`; if `self.extension()` is `None`, the extension
/// is added; otherwise it is replaced.
pub fn set_extension<S: ?Sized + AsOsStr>(&mut self, extension: &S) -> bool {
if self.file_name().is_none() { return false; }
}
}
+impl AsOsStr for PathBuf {
+ fn as_os_str(&self) -> &OsStr {
+ &self.inner[]
+ }
+}
+
/// A slice of a path (akin to `str`).
///
/// This type supports a number of operations for inspecting a path, including
PathBuf::new(self)
}
- /// A path is *absolute* if it is indepedent of the current directory.
+ /// A path is *absolute* if it is independent of the current directory.
///
/// * On Unix, a path is absolute if it starts with the root, so
/// `is_absolute` and `has_root` are equivalent.
/// - iOS: calls SecRandomCopyBytes as /dev/(u)random is sandboxed.
///
/// This does not block.
- #[allow(missing_copy_implementations)]
pub struct OsRng {
// dummy field to ensure that this struct cannot be constructed outside of this module
_dummy: (),
/// Invoke a closure, capturing the cause of panic if one occurs.
///
-/// This function will return `None` if the closure did not panic, and will
-/// return `Some(cause)` if the closure panics. The `cause` returned is the
+/// This function will return `Ok(())` if the closure did not panic, and will
+/// return `Err(cause)` if the closure panics. The `cause` returned is the
/// object with which panic was originally invoked.
///
/// This function also is unsafe for a variety of reasons:
use libc::{c_void, c_int};
#[repr(C)]
- #[allow(missing_copy_implementations)]
pub struct EXCEPTION_RECORD;
#[repr(C)]
- #[allow(missing_copy_implementations)]
pub struct CONTEXT;
#[repr(C)]
- #[allow(missing_copy_implementations)]
pub struct DISPATCHER_CONTEXT;
#[repr(C)]
pub const ENFORCE_SANITY: bool = true || !cfg!(rtopt) || cfg!(rtdebug) ||
cfg!(rtassert);
-#[allow(missing_copy_implementations)]
pub struct Stdio(libc::c_int);
#[allow(non_upper_case_globals)]
///
/// Currently this opaque structure only has one method, `.is_leader()`. Only
/// one thread will receive a result that will return `true` from this function.
-#[allow(missing_copy_implementations)]
pub struct BarrierWaitResult(bool);
impl Barrier {
use sys_common::condvar as sys;
use sys_common::mutex as sys_mutex;
use time::Duration;
-use sync::{mutex, MutexGuard};
+use sync::{mutex, MutexGuard, PoisonError};
/// A Condition Variable
///
mutex::guard_poison(&guard).get()
};
if poisoned {
- Err(poison::new_poison_error(guard))
+ Err(PoisonError::new(guard))
} else {
Ok(guard)
}
(mutex::guard_poison(&guard).get(), success)
};
if poisoned {
- Err(poison::new_poison_error((guard, success)))
+ Err(PoisonError::new((guard, success)))
} else {
Ok((guard, success))
}
while !f(guard_result
.as_mut()
.map(|g| &mut **g)
- .map_err(|e| poison::new_poison_error(&mut **e.get_mut()))) {
+ .map_err(|e| PoisonError::new(&mut **e.get_mut()))) {
let now = SteadyTime::now();
let consumed = &now - &start;
let guard = guard_result.unwrap_or_else(|e| e.into_inner());
Ok((new_guard, no_timeout)) => (Ok(new_guard), no_timeout),
Err(err) => {
let (new_guard, no_timeout) = err.into_inner();
- (Err(poison::new_poison_error(new_guard)), no_timeout)
+ (Err(PoisonError::new(new_guard)), no_timeout)
}
};
guard_result = new_guard_result;
let result = f(guard_result
.as_mut()
.map(|g| &mut **g)
- .map_err(|e| poison::new_poison_error(&mut **e.get_mut())));
+ .map_err(|e| PoisonError::new(&mut **e.get_mut())));
return poison::map_result(guard_result, |g| (g, result));
}
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-//! Multi-producer, single-consumer communication primitives threads
+//! Multi-producer, single-consumer FIFO queue communication primitives.
//!
//! This module provides message-based communication over channels, concretely
//! defined among three types:
use sync::atomic::{AtomicUsize, Ordering};
// Various states you can find a port in.
-const EMPTY: uint = 0; // initial state: no data, no blocked reciever
+const EMPTY: uint = 0; // initial state: no data, no blocked receiver
const DATA: uint = 1; // data ready for receiver to take
const DISCONNECTED: uint = 2; // channel is disconnected OR upgraded
// Any other value represents a pointer to a SignalToken value. The
Err(TryLockError::WouldBlock)
}
}
+
+ /// Determine whether the lock is poisoned.
+ ///
+ /// If another thread is active, the lock can still become poisoned at any
+ /// time. You should not trust a `false` value for program correctness
+ /// without additional synchronization.
+ #[inline]
+ #[unstable(feature = "std_misc")]
+ pub fn is_poisoned(&self) -> bool {
+ self.inner.poison.get()
+ }
}
#[unsafe_destructor]
#[test]
fn test_mutex_arc_poison() {
let arc = Arc::new(Mutex::new(1));
+ assert!(!arc.is_poisoned());
let arc2 = arc.clone();
let _ = Thread::scoped(move|| {
let lock = arc2.lock().unwrap();
assert_eq!(*lock, 2);
}).join();
assert!(arc.lock().is_err());
+ assert!(arc.is_poisoned());
}
#[test]
pub fn borrow(&self) -> LockResult<Guard> {
let ret = Guard { panicking: Thread::panicking() };
if unsafe { *self.failed.get() } {
- Err(new_poison_error(ret))
+ Err(PoisonError::new(ret))
} else {
Ok(ret)
}
}
}
-#[allow(missing_copy_implementations)]
pub struct Guard {
panicking: bool,
}
}
impl<T> PoisonError<T> {
+ /// Create a `PoisonError`.
+ #[unstable(feature = "std_misc")]
+ pub fn new(guard: T) -> PoisonError<T> {
+ PoisonError { guard: guard }
+ }
+
/// Consumes this error indicating that a lock is poisoned, returning the
/// underlying guard to allow access regardless.
#[unstable(feature = "std_misc")]
}
}
-pub fn new_poison_error<T>(guard: T) -> PoisonError<T> {
- PoisonError { guard: guard }
-}
-
pub fn map_result<T, U, F>(result: LockResult<T>, f: F)
-> LockResult<U>
where F: FnOnce(T) -> U {
match result {
Ok(t) => Ok(f(t)),
- Err(PoisonError { guard }) => Err(new_poison_error(f(guard)))
+ Err(PoisonError { guard }) => Err(PoisonError::new(f(guard)))
}
}
Err(TryLockError::WouldBlock)
}
}
+
+ /// Determine whether the lock is poisoned.
+ ///
+ /// If another thread is active, the lock can still become poisoned at any
+ /// time. You should not trust a `false` value for program correctness
+ /// without additional synchronization.
+ #[inline]
+ #[unstable(feature = "std_misc")]
+ pub fn is_poisoned(&self) -> bool {
+ self.inner.poison.get()
+ }
}
#[unsafe_destructor]
#[test]
fn test_rw_arc_poison_ww() {
let arc = Arc::new(RwLock::new(1));
+ assert!(!arc.is_poisoned());
let arc2 = arc.clone();
let _: Result<uint, _> = Thread::scoped(move|| {
let _lock = arc2.write().unwrap();
panic!();
}).join();
assert!(arc.write().is_err());
+ assert!(arc.is_poisoned());
}
#[test]
}
/// A trait for viewing representations from std types
+#[doc(hidden)]
pub trait AsInner<Inner: ?Sized> {
fn as_inner(&self) -> &Inner;
}
+/// A trait for viewing representations from std types
+#[doc(hidden)]
+pub trait AsInnerMut<Inner: ?Sized> {
+ fn as_inner_mut(&mut self) -> &mut Inner;
+}
+
/// A trait for extracting representations from std types
+#[doc(hidden)]
pub trait IntoInner<Inner> {
fn into_inner(self) -> Inner;
}
/// A trait for creating std types from internal representations
+#[doc(hidden)]
pub trait FromInner<Inner> {
fn from_inner(inner: Inner) -> Self;
}
+#[doc(hidden)]
pub trait ProcessConfig<K: BytesContainer, V: BytesContainer> {
fn program(&self) -> &CString;
fn args(&self) -> &[CString];
/// Create a new `CodePoint` from a `char`.
///
- /// Since all Unicode scalar values are code points, this always succeds.
+ /// Since all Unicode scalar values are code points, this always succeeds.
#[inline]
pub fn from_char(value: char) -> CodePoint {
CodePoint { value: value as u32 }
#[cfg(target_os = "linux")]
pub const _SC_GETPW_R_SIZE_MAX: libc::c_int = 70;
#[cfg(any(target_os = "macos",
- target_os = "freebsd"))]
+ target_os = "freebsd",
+ target_os = "dragonfly"))]
pub const _SC_GETPW_R_SIZE_MAX: libc::c_int = 71;
+#[cfg(target_os = "openbsd")]
+pub const _SC_GETPW_R_SIZE_MAX: libc::c_int = 101;
#[cfg(target_os = "android")]
pub const _SC_GETPW_R_SIZE_MAX: libc::c_int = 0x0048;
#[repr(C)]
#[cfg(any(target_os = "macos",
- target_os = "freebsd"))]
+ target_os = "freebsd",
+ target_os = "dragonfly",
+ target_os = "openbsd"))]
pub struct passwd {
pub pw_name: *mut libc::c_char,
pub pw_passwd: *mut libc::c_char,
buf: *mut libc::c_char,
buflen: libc::size_t,
result: *mut *mut passwd) -> libc::c_int;
+
+ pub fn utimes(filename: *const libc::c_char,
+ times: *const libc::timeval) -> libc::c_int;
}
#[cfg(any(target_os = "macos", target_os = "ios"))]
#![unstable(feature = "std_misc")]
-use vec::Vec;
-use sys::os_str::Buf;
-use sys_common::{AsInner, IntoInner, FromInner};
use ffi::{OsStr, OsString};
+use fs::{Permissions, OpenOptions};
+use fs;
use libc;
+use mem;
+use sys::os_str::Buf;
+use sys_common::{AsInner, AsInnerMut, IntoInner, FromInner};
+use vec::Vec;
use old_io;
}
}
+impl AsRawFd for fs::File {
+ fn as_raw_fd(&self) -> Fd {
+ self.as_inner().fd().raw()
+ }
+}
+
impl AsRawFd for old_io::pipe::PipeStream {
fn as_raw_fd(&self) -> Fd {
self.as_inner().fd()
// Unix-specific extensions to `OsStr`.
pub trait OsStrExt {
+ fn from_byte_slice(slice: &[u8]) -> &OsStr;
fn as_byte_slice(&self) -> &[u8];
}
impl OsStrExt for OsStr {
+ fn from_byte_slice(slice: &[u8]) -> &OsStr {
+ unsafe { mem::transmute(slice) }
+ }
fn as_byte_slice(&self) -> &[u8] {
&self.as_inner().inner
}
}
+// Unix-specific extensions to `Permissions`
+pub trait PermissionsExt {
+ fn set_mode(&mut self, mode: i32);
+}
+
+impl PermissionsExt for Permissions {
+ fn set_mode(&mut self, mode: i32) {
+ *self = FromInner::from_inner(FromInner::from_inner(mode));
+ }
+}
+
+// Unix-specific extensions to `OpenOptions`
+pub trait OpenOptionsExt {
+ /// Set the mode bits that a new file will be created with.
+ ///
+ /// If a new file is created as part of a `File::open_opts` call then this
+ /// specified `mode` will be used as the permission bits for the new file.
+ fn mode(&mut self, mode: i32) -> &mut Self;
+}
+
+impl OpenOptionsExt for OpenOptions {
+ fn mode(&mut self, mode: i32) -> &mut OpenOptions {
+ self.as_inner_mut().mode(mode); self
+ }
+}
+
/// A prelude for conveniently writing platform-specific code.
///
/// Includes all extension traits, and some important type definitions.
pub mod prelude {
- pub use super::{Fd, AsRawFd};
+ #[doc(no_inline)]
+ pub use super::{Fd, AsRawFd, OsStrExt, OsStringExt, PermissionsExt};
}
--- /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.
+
+use core::prelude::*;
+use io::prelude::*;
+
+use io;
+use libc::{self, c_int, size_t, c_void};
+use mem;
+use sys::cvt;
+
+pub type fd_t = c_int;
+
+pub struct FileDesc {
+ fd: c_int,
+}
+
+impl FileDesc {
+ pub fn new(fd: c_int) -> FileDesc {
+ FileDesc { fd: fd }
+ }
+
+ pub fn raw(&self) -> c_int { self.fd }
+
+ /// Extract the actual filedescriptor without closing it.
+ pub fn into_raw(self) -> c_int {
+ let fd = self.fd;
+ unsafe { mem::forget(self) };
+ fd
+ }
+
+ pub fn read(&self, buf: &mut [u8]) -> io::Result<usize> {
+ let ret = try!(cvt(unsafe {
+ libc::read(self.fd,
+ buf.as_mut_ptr() as *mut c_void,
+ buf.len() as size_t)
+ }));
+ Ok(ret as usize)
+ }
+
+ pub fn write(&self, buf: &[u8]) -> io::Result<usize> {
+ let ret = try!(cvt(unsafe {
+ libc::write(self.fd,
+ buf.as_ptr() as *const c_void,
+ buf.len() as size_t)
+ }));
+ Ok(ret as usize)
+ }
+}
+
+impl Drop for FileDesc {
+ fn drop(&mut self) {
+ // closing stdio file handles makes no sense, so never do it. Also, note
+ // that errors are ignored when closing a file descriptor. The reason
+ // for this is that if an error occurs we don't actually know if the
+ // file descriptor was closed or not, and if we retried (for something
+ // like EINTR), we might close another valid file descriptor (opened
+ // after we closed ours.
+ if self.fd > libc::STDERR_FILENO {
+ let _ = unsafe { libc::close(self.fd) };
+ }
+ }
+}
--- /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.
+
+use core::prelude::*;
+use io::prelude::*;
+use os::unix::prelude::*;
+
+use ffi::{self, CString, OsString, AsOsStr, OsStr};
+use io::{self, Error, Seek, SeekFrom};
+use libc::{self, c_int, c_void, size_t, off_t, c_char, mode_t};
+use mem;
+use path::{Path, PathBuf};
+use ptr;
+use rc::Rc;
+use sys::fd::FileDesc;
+use sys::{c, cvt, cvt_r};
+use sys_common::FromInner;
+use vec::Vec;
+
+pub struct File(FileDesc);
+
+pub struct FileAttr {
+ stat: libc::stat,
+}
+
+pub struct ReadDir {
+ dirp: *mut libc::DIR,
+ root: Rc<PathBuf>,
+}
+
+pub struct DirEntry {
+ buf: Vec<u8>,
+ dirent: *mut libc::dirent_t,
+ root: Rc<PathBuf>,
+}
+
+#[derive(Clone)]
+pub struct OpenOptions {
+ flags: c_int,
+ read: bool,
+ write: bool,
+ mode: mode_t,
+}
+
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct FilePermissions { mode: mode_t }
+
+impl FileAttr {
+ pub fn is_dir(&self) -> bool {
+ (self.stat.st_mode as mode_t) & libc::S_IFMT == libc::S_IFDIR
+ }
+ pub fn is_file(&self) -> bool {
+ (self.stat.st_mode as mode_t) & libc::S_IFMT == libc::S_IFREG
+ }
+ pub fn size(&self) -> u64 { self.stat.st_size as u64 }
+ pub fn perm(&self) -> FilePermissions {
+ FilePermissions { mode: (self.stat.st_mode as mode_t) & 0o777 }
+ }
+
+ pub fn accessed(&self) -> u64 {
+ self.mktime(self.stat.st_atime as u64, self.stat.st_atime_nsec as u64)
+ }
+ pub fn modified(&self) -> u64 {
+ self.mktime(self.stat.st_mtime as u64, self.stat.st_mtime_nsec as u64)
+ }
+
+ // times are in milliseconds (currently)
+ fn mktime(&self, secs: u64, nsecs: u64) -> u64 {
+ secs * 1000 + nsecs / 1000000
+ }
+}
+
+impl FilePermissions {
+ pub fn readonly(&self) -> bool { self.mode & 0o222 == 0 }
+ pub fn set_readonly(&mut self, readonly: bool) {
+ if readonly {
+ self.mode &= !0o222;
+ } else {
+ self.mode |= 0o222;
+ }
+ }
+}
+
+impl FromInner<i32> for FilePermissions {
+ fn from_inner(mode: i32) -> FilePermissions {
+ FilePermissions { mode: mode as mode_t }
+ }
+}
+
+impl Iterator for ReadDir {
+ type Item = io::Result<DirEntry>;
+
+ fn next(&mut self) -> Option<io::Result<DirEntry>> {
+ extern {
+ fn rust_dirent_t_size() -> c_int;
+ }
+
+ let mut buf: Vec<u8> = Vec::with_capacity(unsafe {
+ rust_dirent_t_size() as usize
+ });
+ let ptr = buf.as_mut_ptr() as *mut libc::dirent_t;
+
+ let mut entry_ptr = ptr::null_mut();
+ loop {
+ if unsafe { libc::readdir_r(self.dirp, ptr, &mut entry_ptr) != 0 } {
+ return Some(Err(Error::last_os_error()))
+ }
+ if entry_ptr.is_null() {
+ return None
+ }
+
+ let entry = DirEntry {
+ buf: buf,
+ dirent: entry_ptr,
+ root: self.root.clone()
+ };
+ if entry.name_bytes() == b"." || entry.name_bytes() == b".." {
+ buf = entry.buf;
+ } else {
+ return Some(Ok(entry))
+ }
+ }
+ }
+}
+
+impl Drop for ReadDir {
+ fn drop(&mut self) {
+ let r = unsafe { libc::closedir(self.dirp) };
+ debug_assert_eq!(r, 0);
+ }
+}
+
+impl DirEntry {
+ pub fn path(&self) -> PathBuf {
+ self.root.join(<OsStr as OsStrExt>::from_byte_slice(self.name_bytes()))
+ }
+
+ fn name_bytes(&self) -> &[u8] {
+ extern {
+ fn rust_list_dir_val(ptr: *mut libc::dirent_t) -> *const c_char;
+ }
+ unsafe {
+ let ptr = rust_list_dir_val(self.dirent);
+ ffi::c_str_to_bytes(mem::copy_lifetime(self, &ptr))
+ }
+ }
+}
+
+impl OpenOptions {
+ pub fn new() -> OpenOptions {
+ OpenOptions {
+ flags: 0,
+ read: false,
+ write: false,
+ mode: libc::S_IRUSR | libc::S_IWUSR,
+ }
+ }
+
+ pub fn read(&mut self, read: bool) {
+ self.read = read;
+ }
+
+ pub fn write(&mut self, write: bool) {
+ self.write = write;
+ }
+
+ pub fn append(&mut self, append: bool) {
+ self.flag(libc::O_APPEND, append);
+ }
+
+ pub fn truncate(&mut self, truncate: bool) {
+ self.flag(libc::O_TRUNC, truncate);
+ }
+
+ pub fn create(&mut self, create: bool) {
+ self.flag(libc::O_CREAT, create);
+ }
+
+ pub fn mode(&mut self, mode: i32) {
+ self.mode = mode as mode_t;
+ }
+
+ fn flag(&mut self, bit: c_int, on: bool) {
+ if on {
+ self.flags |= bit;
+ } else {
+ self.flags &= !bit;
+ }
+ }
+}
+
+impl File {
+ pub fn open(path: &Path, opts: &OpenOptions) -> io::Result<File> {
+ let flags = opts.flags | match (opts.read, opts.write) {
+ (true, true) => libc::O_RDWR,
+ (false, true) => libc::O_WRONLY,
+ (true, false) |
+ (false, false) => libc::O_RDONLY,
+ };
+ let path = cstr(path);
+ let fd = try!(cvt_r(|| unsafe {
+ libc::open(path.as_ptr(), flags, opts.mode)
+ }));
+ Ok(File(FileDesc::new(fd)))
+ }
+
+ pub fn file_attr(&self) -> io::Result<FileAttr> {
+ let mut stat: libc::stat = unsafe { mem::zeroed() };
+ try!(cvt(unsafe { libc::fstat(self.0.raw(), &mut stat) }));
+ Ok(FileAttr { stat: stat })
+ }
+
+ pub fn fsync(&self) -> io::Result<()> {
+ try!(cvt_r(|| unsafe { libc::fsync(self.0.raw()) }));
+ Ok(())
+ }
+
+ pub fn datasync(&self) -> io::Result<()> {
+ try!(cvt_r(|| unsafe { os_datasync(self.0.raw()) }));
+ return Ok(());
+
+ #[cfg(any(target_os = "macos", target_os = "ios"))]
+ unsafe fn os_datasync(fd: c_int) -> c_int {
+ libc::fcntl(fd, libc::F_FULLFSYNC)
+ }
+ #[cfg(target_os = "linux")]
+ unsafe fn os_datasync(fd: c_int) -> c_int { libc::fdatasync(fd) }
+ #[cfg(not(any(target_os = "macos",
+ target_os = "ios",
+ target_os = "linux")))]
+ unsafe fn os_datasync(fd: c_int) -> c_int { libc::fsync(fd) }
+ }
+
+ pub fn truncate(&self, size: u64) -> io::Result<()> {
+ try!(cvt_r(|| unsafe {
+ libc::ftruncate(self.0.raw(), size as libc::off_t)
+ }));
+ Ok(())
+ }
+
+ pub fn read(&self, buf: &mut [u8]) -> io::Result<usize> {
+ self.0.read(buf)
+ }
+
+ pub fn write(&self, buf: &[u8]) -> io::Result<usize> {
+ self.0.write(buf)
+ }
+
+ pub fn flush(&self) -> io::Result<()> { Ok(()) }
+
+ pub fn seek(&self, pos: SeekFrom) -> io::Result<u64> {
+ let (whence, pos) = match pos {
+ SeekFrom::Start(off) => (libc::SEEK_SET, off as off_t),
+ SeekFrom::End(off) => (libc::SEEK_END, off as off_t),
+ SeekFrom::Current(off) => (libc::SEEK_CUR, off as off_t),
+ };
+ let n = try!(cvt(unsafe { libc::lseek(self.0.raw(), pos, whence) }));
+ Ok(n as u64)
+ }
+
+ pub fn fd(&self) -> &FileDesc { &self.0 }
+}
+
+fn cstr(path: &Path) -> CString {
+ CString::from_slice(path.as_os_str().as_byte_slice())
+}
+
+pub fn mkdir(p: &Path) -> io::Result<()> {
+ let p = cstr(p);
+ try!(cvt(unsafe { libc::mkdir(p.as_ptr(), 0o777) }));
+ Ok(())
+}
+
+pub fn readdir(p: &Path) -> io::Result<ReadDir> {
+ let root = Rc::new(p.to_path_buf());
+ let p = cstr(p);
+ unsafe {
+ let ptr = libc::opendir(p.as_ptr());
+ if ptr.is_null() {
+ Err(Error::last_os_error())
+ } else {
+ Ok(ReadDir { dirp: ptr, root: root })
+ }
+ }
+}
+
+pub fn unlink(p: &Path) -> io::Result<()> {
+ let p = cstr(p);
+ try!(cvt(unsafe { libc::unlink(p.as_ptr()) }));
+ Ok(())
+}
+
+pub fn rename(old: &Path, new: &Path) -> io::Result<()> {
+ let old = cstr(old);
+ let new = cstr(new);
+ try!(cvt(unsafe { libc::rename(old.as_ptr(), new.as_ptr()) }));
+ Ok(())
+}
+
+pub fn set_perm(p: &Path, perm: FilePermissions) -> io::Result<()> {
+ let p = cstr(p);
+ try!(cvt_r(|| unsafe { libc::chmod(p.as_ptr(), perm.mode) }));
+ Ok(())
+}
+
+pub fn rmdir(p: &Path) -> io::Result<()> {
+ let p = cstr(p);
+ try!(cvt(unsafe { libc::rmdir(p.as_ptr()) }));
+ Ok(())
+}
+
+pub fn chown(p: &Path, uid: isize, gid: isize) -> io::Result<()> {
+ let p = cstr(p);
+ try!(cvt_r(|| unsafe {
+ libc::chown(p.as_ptr(), uid as libc::uid_t, gid as libc::gid_t)
+ }));
+ Ok(())
+}
+
+pub fn readlink(p: &Path) -> io::Result<PathBuf> {
+ let c_path = cstr(p);
+ let p = c_path.as_ptr();
+ let mut len = unsafe { libc::pathconf(p as *mut _, libc::_PC_NAME_MAX) };
+ if len < 0 {
+ len = 1024; // FIXME: read PATH_MAX from C ffi?
+ }
+ let mut buf: Vec<u8> = Vec::with_capacity(len as usize);
+ unsafe {
+ let n = try!(cvt({
+ libc::readlink(p, buf.as_ptr() as *mut c_char, len as size_t)
+ }));
+ buf.set_len(n as usize);
+ }
+ let s: OsString = OsStringExt::from_vec(buf);
+ Ok(PathBuf::new(&s))
+}
+
+pub fn symlink(src: &Path, dst: &Path) -> io::Result<()> {
+ let src = cstr(src);
+ let dst = cstr(dst);
+ try!(cvt(unsafe { libc::symlink(src.as_ptr(), dst.as_ptr()) }));
+ Ok(())
+}
+
+pub fn link(src: &Path, dst: &Path) -> io::Result<()> {
+ let src = cstr(src);
+ let dst = cstr(dst);
+ try!(cvt(unsafe { libc::link(src.as_ptr(), dst.as_ptr()) }));
+ Ok(())
+}
+
+pub fn stat(p: &Path) -> io::Result<FileAttr> {
+ let p = cstr(p);
+ let mut stat: libc::stat = unsafe { mem::zeroed() };
+ try!(cvt(unsafe { libc::stat(p.as_ptr(), &mut stat) }));
+ Ok(FileAttr { stat: stat })
+}
+
+pub fn lstat(p: &Path) -> io::Result<FileAttr> {
+ let p = cstr(p);
+ let mut stat: libc::stat = unsafe { mem::zeroed() };
+ try!(cvt(unsafe { libc::lstat(p.as_ptr(), &mut stat) }));
+ Ok(FileAttr { stat: stat })
+}
+
+pub fn utimes(p: &Path, atime: u64, mtime: u64) -> io::Result<()> {
+ let p = cstr(p);
+ let buf = [super::ms_to_timeval(atime), super::ms_to_timeval(mtime)];
+ try!(cvt(unsafe { c::utimes(p.as_ptr(), buf.as_ptr()) }));
+ Ok(())
+}
use num::{Int, SignedInt};
use num;
use old_io::{self, IoResult, IoError};
+use io;
use str;
use sys_common::mkerr_libc;
pub mod backtrace;
pub mod c;
-pub mod ext;
pub mod condvar;
-pub mod fs;
+pub mod ext;
+pub mod fd;
+pub mod fs; // support for std::old_io
+pub mod fs2; // support for std::fs
pub mod helper_signal;
pub mod mutex;
pub mod os;
}
}
+pub fn cvt<T: SignedInt>(t: T) -> io::Result<T> {
+ let one: T = Int::one();
+ if t == -one {
+ Err(io::Error::last_os_error())
+ } else {
+ Ok(t)
+ }
+}
+
+pub fn cvt_r<T, F>(mut f: F) -> io::Result<T>
+ where T: SignedInt, F: FnMut() -> T
+{
+ loop {
+ match cvt(f()) {
+ Err(ref e) if e.kind() == ErrorKind::Interrupted => {}
+ other => return other,
+ }
+ }
+}
+
pub fn ms_to_timeval(ms: u64) -> libc::timeval {
libc::timeval {
tv_sec: (ms / 1000) as libc::time_t,
}
#[cfg(target_os = "openbsd")]
- fn errno_location() -> *const c_int {
- extern {
- fn __errno() -> *const c_int;
- }
- unsafe {
- __errno()
- }
+ unsafe fn errno_location() -> *const c_int {
+ extern { fn __errno() -> *const c_int; }
+ __errno()
}
#[cfg(any(target_os = "linux", target_os = "android"))]
}
#[cfg(target_os = "openbsd")]
-pub fn load_self() -> Option<Vec<u8>> {
+pub fn current_exe() -> IoResult<Path> {
use sync::{StaticMutex, MUTEX_INIT};
static LOCK: StaticMutex = MUTEX_INIT;
extern {
- fn rust_load_self() -> *const c_char;
+ fn rust_current_exe() -> *const c_char;
}
let _guard = LOCK.lock();
unsafe {
- let v = rust_load_self();
+ let v = rust_current_exe();
if v.is_null() {
- None
+ Err(IoError::last_error())
} else {
- Some(ffi::c_str_to_bytes(&v).to_vec())
+ Ok(Path::new(ffi::c_str_to_bytes(&v).to_vec()))
}
}
}
#[cfg(any(target_os = "linux",
target_os = "android",
target_os = "freebsd",
- target_os = "dragonfly"))]
+ target_os = "dragonfly",
+ target_os = "openbsd"))]
pub fn args() -> Args {
use rt;
let bytes = rt::args::clone().unwrap_or(Vec::new());
pub use sys_common::wtf8::{Wtf8Buf, EncodeWide};
-use sys::os_str::Buf;
-use sys_common::{AsInner, FromInner};
use ffi::{OsStr, OsString};
+use fs::{self, OpenOptions};
use libc;
+use sys::os_str::Buf;
+use sys_common::{AsInner, FromInner, AsInnerMut};
use old_io;
}
}
+impl AsRawHandle for fs::File {
+ fn as_raw_handle(&self) -> Handle {
+ self.as_inner().handle().raw()
+ }
+}
+
impl AsRawHandle for old_io::pipe::PipeStream {
fn as_raw_handle(&self) -> Handle {
self.as_inner().handle()
}
}
+// Windows-specific extensions to `OpenOptions`
+pub trait OpenOptionsExt {
+ /// Override the `dwDesiredAccess` argument to the call to `CreateFile` with
+ /// the specified value.
+ fn desired_access(&mut self, access: i32) -> &mut Self;
+
+ /// Override the `dwCreationDisposition` argument to the call to
+ /// `CreateFile` with the specified value.
+ ///
+ /// This will override any values of the standard `create` flags, for
+ /// example.
+ fn creation_disposition(&mut self, val: i32) -> &mut Self;
+
+ /// Override the `dwFlagsAndAttributes` argument to the call to
+ /// `CreateFile` with the specified value.
+ ///
+ /// This will override any values of the standard flags on the `OpenOptions`
+ /// structure.
+ fn flags_and_attributes(&mut self, val: i32) -> &mut Self;
+
+ /// Override the `dwShareMode` argument to the call to `CreateFile` with the
+ /// specified value.
+ ///
+ /// This will override any values of the standard flags on the `OpenOptions`
+ /// structure.
+ fn share_mode(&mut self, val: i32) -> &mut Self;
+}
+
+impl OpenOptionsExt for OpenOptions {
+ fn desired_access(&mut self, access: i32) -> &mut OpenOptions {
+ self.as_inner_mut().desired_access(access); self
+ }
+ fn creation_disposition(&mut self, access: i32) -> &mut OpenOptions {
+ self.as_inner_mut().creation_disposition(access); self
+ }
+ fn flags_and_attributes(&mut self, access: i32) -> &mut OpenOptions {
+ self.as_inner_mut().flags_and_attributes(access); self
+ }
+ fn share_mode(&mut self, access: i32) -> &mut OpenOptions {
+ self.as_inner_mut().share_mode(access); self
+ }
+}
+
/// A prelude for conveniently writing platform-specific code.
///
/// Includes all extension traits, and some important type definitions.
pub mod prelude {
- pub use super::{Socket, Handle, AsRawSocket, AsRawHandle, OsStrExt, OsStringExt};
+ #[doc(no_inline)]
+ pub use super::{Socket, Handle, AsRawSocket, AsRawHandle};
+ #[doc(no_inline)]
+ pub use super::{OsStrExt, OsStringExt};
+ #[doc(no_inline)]
+ pub use super::OpenOptionsExt;
}
--- /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 core::prelude::*;
+use io::prelude::*;
+use os::windows::prelude::*;
+
+use default::Default;
+use ffi::{OsString, AsOsStr};
+use io::{self, Error, SeekFrom};
+use libc::{self, HANDLE};
+use mem;
+use path::{Path, PathBuf};
+use ptr;
+use sys::handle::Handle as RawHandle;
+use sys::{c, cvt};
+use vec::Vec;
+
+pub struct File { handle: RawHandle }
+pub struct FileAttr { data: c::WIN32_FILE_ATTRIBUTE_DATA }
+
+pub struct ReadDir {
+ handle: libc::HANDLE,
+ root: PathBuf,
+ first: Option<libc::WIN32_FIND_DATAW>,
+}
+
+pub struct DirEntry { path: PathBuf }
+
+#[derive(Clone, Default)]
+pub struct OpenOptions {
+ create: bool,
+ append: bool,
+ read: bool,
+ write: bool,
+ truncate: bool,
+ desired_access: Option<libc::DWORD>,
+ share_mode: Option<libc::DWORD>,
+ creation_disposition: Option<libc::DWORD>,
+ flags_and_attributes: Option<libc::DWORD>,
+}
+
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct FilePermissions { attrs: libc::DWORD }
+
+impl Iterator for ReadDir {
+ type Item = io::Result<DirEntry>;
+ fn next(&mut self) -> Option<io::Result<DirEntry>> {
+ if let Some(first) = self.first.take() {
+ if let Some(e) = DirEntry::new(&self.root, &first) {
+ return Some(Ok(e));
+ }
+ }
+ unsafe {
+ let mut wfd = mem::zeroed();
+ loop {
+ if libc::FindNextFileW(self.handle, &mut wfd) == 0 {
+ if libc::GetLastError() ==
+ c::ERROR_NO_MORE_FILES as libc::DWORD {
+ return None
+ } else {
+ return Some(Err(Error::last_os_error()))
+ }
+ }
+ if let Some(e) = DirEntry::new(&self.root, &wfd) {
+ return Some(Ok(e))
+ }
+ }
+ }
+ }
+}
+
+impl Drop for ReadDir {
+ fn drop(&mut self) {
+ let r = unsafe { libc::FindClose(self.handle) };
+ debug_assert!(r != 0);
+ }
+}
+
+impl DirEntry {
+ fn new(root: &Path, wfd: &libc::WIN32_FIND_DATAW) -> Option<DirEntry> {
+ match &wfd.cFileName[0..3] {
+ // check for '.' and '..'
+ [46, 0, ..] |
+ [46, 46, 0, ..] => return None,
+ _ => {}
+ }
+
+ let filename = super::truncate_utf16_at_nul(&wfd.cFileName);
+ let filename: OsString = OsStringExt::from_wide(filename);
+ Some(DirEntry { path: root.join(&filename) })
+ }
+
+ pub fn path(&self) -> PathBuf {
+ self.path.clone()
+ }
+}
+
+impl OpenOptions {
+ pub fn new() -> OpenOptions { Default::default() }
+ pub fn read(&mut self, read: bool) { self.read = read; }
+ pub fn write(&mut self, write: bool) { self.write = write; }
+ pub fn append(&mut self, append: bool) { self.append = append; }
+ pub fn create(&mut self, create: bool) { self.create = create; }
+ pub fn truncate(&mut self, truncate: bool) { self.truncate = truncate; }
+ pub fn creation_disposition(&mut self, val: i32) {
+ self.creation_disposition = Some(val as libc::DWORD);
+ }
+ pub fn flags_and_attributes(&mut self, val: i32) {
+ self.flags_and_attributes = Some(val as libc::DWORD);
+ }
+ pub fn desired_access(&mut self, val: i32) {
+ self.desired_access = Some(val as libc::DWORD);
+ }
+ pub fn share_mode(&mut self, val: i32) {
+ self.share_mode = Some(val as libc::DWORD);
+ }
+
+ fn get_desired_access(&self) -> libc::DWORD {
+ self.desired_access.unwrap_or({
+ let mut base = if self.read {libc::FILE_GENERIC_READ} else {0} |
+ if self.write {libc::FILE_GENERIC_WRITE} else {0};
+ if self.append {
+ base &= !libc::FILE_WRITE_DATA;
+ base |= libc::FILE_APPEND_DATA;
+ }
+ base
+ })
+ }
+
+ fn get_share_mode(&self) -> libc::DWORD {
+ // libuv has a good comment about this, but the basic idea is that
+ // we try to emulate unix semantics by enabling all sharing by
+ // allowing things such as deleting a file while it's still open.
+ self.share_mode.unwrap_or(libc::FILE_SHARE_READ |
+ libc::FILE_SHARE_WRITE |
+ libc::FILE_SHARE_DELETE)
+ }
+
+ fn get_creation_disposition(&self) -> libc::DWORD {
+ self.creation_disposition.unwrap_or({
+ match (self.create, self.truncate) {
+ (true, true) => libc::CREATE_ALWAYS,
+ (true, false) => libc::OPEN_ALWAYS,
+ (false, false) => libc::OPEN_EXISTING,
+ (false, true) => {
+ if self.write && !self.append {
+ libc::CREATE_ALWAYS
+ } else {
+ libc::TRUNCATE_EXISTING
+ }
+ }
+ }
+ })
+ }
+
+ fn get_flags_and_attributes(&self) -> libc::DWORD {
+ self.flags_and_attributes.unwrap_or(libc::FILE_ATTRIBUTE_NORMAL)
+ }
+}
+
+impl File {
+ pub fn open(path: &Path, opts: &OpenOptions) -> io::Result<File> {
+ let path = to_utf16(path);
+ let handle = unsafe {
+ libc::CreateFileW(path.as_ptr(),
+ opts.get_desired_access(),
+ opts.get_share_mode(),
+ ptr::null_mut(),
+ opts.get_creation_disposition(),
+ opts.get_flags_and_attributes(),
+ ptr::null_mut())
+ };
+ if handle == libc::INVALID_HANDLE_VALUE {
+ Err(Error::last_os_error())
+ } else {
+ Ok(File { handle: RawHandle::new(handle) })
+ }
+ }
+
+ pub fn fsync(&self) -> io::Result<()> {
+ try!(cvt(unsafe { libc::FlushFileBuffers(self.handle.raw()) }));
+ Ok(())
+ }
+
+ pub fn datasync(&self) -> io::Result<()> { self.fsync() }
+
+ pub fn truncate(&self, size: u64) -> io::Result<()> {
+ let mut info = c::FILE_END_OF_FILE_INFO {
+ EndOfFile: size as libc::LARGE_INTEGER,
+ };
+ let size = mem::size_of_val(&info);
+ try!(cvt(unsafe {
+ c::SetFileInformationByHandle(self.handle.raw(),
+ c::FileEndOfFileInfo,
+ &mut info as *mut _ as *mut _,
+ size as libc::DWORD)
+ }));
+ Ok(())
+ }
+
+ pub fn file_attr(&self) -> io::Result<FileAttr> {
+ unsafe {
+ let mut info: c::BY_HANDLE_FILE_INFORMATION = mem::zeroed();
+ try!(cvt(c::GetFileInformationByHandle(self.handle.raw(),
+ &mut info)));
+ Ok(FileAttr {
+ data: c::WIN32_FILE_ATTRIBUTE_DATA {
+ dwFileAttributes: info.dwFileAttributes,
+ ftCreationTime: info.ftCreationTime,
+ ftLastAccessTime: info.ftLastAccessTime,
+ ftLastWriteTime: info.ftLastWriteTime,
+ nFileSizeHigh: info.nFileSizeHigh,
+ nFileSizeLow: info.nFileSizeLow,
+ }
+ })
+ }
+ }
+
+ pub fn read(&self, buf: &mut [u8]) -> io::Result<usize> {
+ let mut read = 0;
+ try!(cvt(unsafe {
+ libc::ReadFile(self.handle.raw(),
+ buf.as_ptr() as libc::LPVOID,
+ buf.len() as libc::DWORD,
+ &mut read,
+ ptr::null_mut())
+ }));
+ Ok(read as usize)
+ }
+
+ pub fn write(&self, buf: &[u8]) -> io::Result<usize> {
+ let mut amt = 0;
+ try!(cvt(unsafe {
+ libc::WriteFile(self.handle.raw(),
+ buf.as_ptr() as libc::LPVOID,
+ buf.len() as libc::DWORD,
+ &mut amt,
+ ptr::null_mut())
+ }));
+ Ok(amt as usize)
+ }
+
+ pub fn flush(&self) -> io::Result<()> { Ok(()) }
+
+ pub fn seek(&self, pos: SeekFrom) -> io::Result<u64> {
+ let (whence, pos) = match pos {
+ SeekFrom::Start(n) => (libc::FILE_BEGIN, n as i64),
+ SeekFrom::End(n) => (libc::FILE_END, n),
+ SeekFrom::Current(n) => (libc::FILE_CURRENT, n),
+ };
+ let pos = pos as libc::LARGE_INTEGER;
+ let mut newpos = 0;
+ try!(cvt(unsafe {
+ libc::SetFilePointerEx(self.handle.raw(), pos,
+ &mut newpos, whence)
+ }));
+ Ok(newpos as u64)
+ }
+
+ pub fn handle(&self) -> &RawHandle { &self.handle }
+}
+
+pub fn to_utf16(s: &Path) -> Vec<u16> {
+ s.as_os_str().encode_wide().chain(Some(0).into_iter()).collect()
+}
+
+impl FileAttr {
+ pub fn is_dir(&self) -> bool {
+ self.data.dwFileAttributes & c::FILE_ATTRIBUTE_DIRECTORY != 0
+ }
+ pub fn is_file(&self) -> bool {
+ !self.is_dir()
+ }
+ pub fn size(&self) -> u64 {
+ ((self.data.nFileSizeHigh as u64) << 32) | (self.data.nFileSizeLow as u64)
+ }
+ pub fn perm(&self) -> FilePermissions {
+ FilePermissions { attrs: self.data.dwFileAttributes }
+ }
+
+ pub fn accessed(&self) -> u64 { self.to_ms(&self.data.ftLastAccessTime) }
+ pub fn modified(&self) -> u64 { self.to_ms(&self.data.ftLastWriteTime) }
+
+ fn to_ms(&self, ft: &libc::FILETIME) -> u64 {
+ // FILETIME is in 100ns intervals and there are 10000 intervals in a
+ // millisecond.
+ let bits = (ft.dwLowDateTime as u64) | ((ft.dwHighDateTime as u64) << 32);
+ bits / 10000
+ }
+}
+
+impl FilePermissions {
+ pub fn readonly(&self) -> bool {
+ self.attrs & c::FILE_ATTRIBUTE_READONLY != 0
+ }
+
+ pub fn set_readonly(&mut self, readonly: bool) {
+ if readonly {
+ self.attrs |= c::FILE_ATTRIBUTE_READONLY;
+ } else {
+ self.attrs &= !c::FILE_ATTRIBUTE_READONLY;
+ }
+ }
+}
+
+pub fn mkdir(p: &Path) -> io::Result<()> {
+ let p = to_utf16(p);
+ try!(cvt(unsafe {
+ libc::CreateDirectoryW(p.as_ptr(), ptr::null_mut())
+ }));
+ Ok(())
+}
+
+pub fn readdir(p: &Path) -> io::Result<ReadDir> {
+ let root = p.to_path_buf();
+ let star = p.join("*");
+ let path = to_utf16(&star);
+
+ unsafe {
+ let mut wfd = mem::zeroed();
+ let find_handle = libc::FindFirstFileW(path.as_ptr(), &mut wfd);
+ if find_handle != libc::INVALID_HANDLE_VALUE {
+ Ok(ReadDir { handle: find_handle, root: root, first: Some(wfd) })
+ } else {
+ Err(Error::last_os_error())
+ }
+ }
+}
+
+pub fn unlink(p: &Path) -> io::Result<()> {
+ let p_utf16 = to_utf16(p);
+ try!(cvt(unsafe { libc::DeleteFileW(p_utf16.as_ptr()) }));
+ Ok(())
+}
+
+pub fn rename(old: &Path, new: &Path) -> io::Result<()> {
+ let old = to_utf16(old);
+ let new = to_utf16(new);
+ try!(cvt(unsafe {
+ libc::MoveFileExW(old.as_ptr(), new.as_ptr(),
+ libc::MOVEFILE_REPLACE_EXISTING)
+ }));
+ Ok(())
+}
+
+pub fn rmdir(p: &Path) -> io::Result<()> {
+ let p = to_utf16(p);
+ try!(cvt(unsafe { c::RemoveDirectoryW(p.as_ptr()) }));
+ Ok(())
+}
+
+pub fn readlink(p: &Path) -> io::Result<PathBuf> {
+ use sys::c::compat::kernel32::GetFinalPathNameByHandleW;
+ let mut opts = OpenOptions::new();
+ opts.read(true);
+ let file = try!(File::open(p, &opts));;
+
+ // Specify (sz - 1) because the documentation states that it's the size
+ // without the null pointer
+ //
+ // FIXME: I have a feeling that this reads intermediate symlinks as well.
+ let ret: OsString = try!(super::fill_utf16_buf_new(|buf, sz| unsafe {
+ GetFinalPathNameByHandleW(file.handle.raw(),
+ buf as *const u16,
+ sz - 1,
+ libc::VOLUME_NAME_DOS)
+ }, |s| OsStringExt::from_wide(s)));
+ Ok(PathBuf::new(&ret))
+}
+
+pub fn symlink(src: &Path, dst: &Path) -> io::Result<()> {
+ use sys::c::compat::kernel32::CreateSymbolicLinkW;
+ let src = to_utf16(src);
+ let dst = to_utf16(dst);
+ try!(cvt(unsafe {
+ CreateSymbolicLinkW(dst.as_ptr(), src.as_ptr(), 0) as libc::BOOL
+ }));
+ Ok(())
+}
+
+pub fn link(src: &Path, dst: &Path) -> io::Result<()> {
+ let src = to_utf16(src);
+ let dst = to_utf16(dst);
+ try!(cvt(unsafe {
+ libc::CreateHardLinkW(dst.as_ptr(), src.as_ptr(), ptr::null_mut())
+ }));
+ Ok(())
+}
+
+pub fn stat(p: &Path) -> io::Result<FileAttr> {
+ let p = to_utf16(p);
+ unsafe {
+ let mut attr: FileAttr = mem::zeroed();
+ try!(cvt(c::GetFileAttributesExW(p.as_ptr(),
+ c::GetFileExInfoStandard,
+ &mut attr.data as *mut _ as *mut _)));
+ Ok(attr)
+ }
+}
+
+pub fn set_perm(p: &Path, perm: FilePermissions) -> io::Result<()> {
+ let p = to_utf16(p);
+ unsafe {
+ try!(cvt(c::SetFileAttributesW(p.as_ptr(), perm.attrs)));
+ Ok(())
+ }
+}
+
+pub fn utimes(p: &Path, atime: u64, mtime: u64) -> io::Result<()> {
+ let atime = super::ms_to_filetime(atime);
+ let mtime = super::ms_to_filetime(mtime);
+
+ let mut o = OpenOptions::new();
+ o.write(true);
+ let f = try!(File::open(p, &o));
+ try!(cvt(unsafe {
+ c::SetFileTime(f.handle.raw(), 0 as *const _, &atime, &mtime)
+ }));
+ Ok(())
+}
pub fn new(handle: HANDLE) -> Handle {
Handle(handle)
}
+ pub fn raw(&self) -> HANDLE { self.0 }
}
impl Drop for Handle {
use prelude::v1::*;
use ffi::OsStr;
-use io::ErrorKind;
+use io::{self, ErrorKind};
use libc;
use mem;
use old_io::{self, IoResult, IoError};
+use num::Int;
use os::windows::OsStrExt;
use sync::{Once, ONCE_INIT};
pub mod condvar;
pub mod ext;
pub mod fs;
+pub mod fs2;
pub mod handle;
pub mod helper_signal;
pub mod mutex;
// Once the syscall has completed (errors bail out early) the second closure is
// yielded the data which has been read from the syscall. The return value
// from this closure is then the return value of the function.
-fn fill_utf16_buf<F1, F2, T>(mut f1: F1, f2: F2) -> IoResult<T>
+fn fill_utf16_buf_base<F1, F2, T>(mut f1: F1, f2: F2) -> Result<T, ()>
where F1: FnMut(*mut u16, libc::DWORD) -> libc::DWORD,
F2: FnOnce(&[u16]) -> T
{
c::SetLastError(0);
let k = match f1(buf.as_mut_ptr(), n as libc::DWORD) {
0 if libc::GetLastError() == 0 => 0,
- 0 => return Err(IoError::last_error()),
+ 0 => return Err(()),
n => n,
} as usize;
if k == n && libc::GetLastError() ==
}
}
+fn fill_utf16_buf<F1, F2, T>(f1: F1, f2: F2) -> IoResult<T>
+ where F1: FnMut(*mut u16, libc::DWORD) -> libc::DWORD,
+ F2: FnOnce(&[u16]) -> T
+{
+ fill_utf16_buf_base(f1, f2).map_err(|()| IoError::last_error())
+}
+
+fn fill_utf16_buf_new<F1, F2, T>(f1: F1, f2: F2) -> io::Result<T>
+ where F1: FnMut(*mut u16, libc::DWORD) -> libc::DWORD,
+ F2: FnOnce(&[u16]) -> T
+{
+ fill_utf16_buf_base(f1, f2).map_err(|()| io::Error::last_os_error())
+}
+
fn os2path(s: &[u16]) -> Path {
// FIXME: this should not be a panicking conversion (aka path reform)
Path::new(String::from_utf16(s).unwrap())
None => v
}
}
+
+fn cvt<I: Int>(i: I) -> io::Result<I> {
+ if i == Int::zero() {
+ Err(io::Error::last_os_error())
+ } else {
+ Ok(i)
+ }
+}
+
+fn ms_to_filetime(ms: u64) -> libc::FILETIME {
+ // A FILETIME is a count of 100 nanosecond intervals, so we multiply by
+ // 10000 b/c there are 10000 intervals in 1 ms
+ let ms = ms * 10000;
+ libc::FILETIME {
+ dwLowDateTime: ms as u32,
+ dwHighDateTime: (ms >> 32) as u32,
+ }
+}
len += 1;
}
let p = p as *const u16;
- let s = slice::from_raw_buf(&p, len as usize);
+ let s = slice::from_raw_parts(p, len as usize);
self.cur = self.cur.offset(len + 1);
let (k, v) = match s.iter().position(|&b| b == '=' as u16) {
}
}
-#[derive(Show)]
+#[derive(Debug)]
pub struct JoinPathsError;
pub fn join_paths<I, T>(paths: I) -> Result<OsString, JoinPathsError>
// Push it onto the list.
let ptr = ptr as *const u16;
- let buf = slice::from_raw_buf(&ptr, len as usize);
+ let buf = slice::from_raw_parts(ptr, len as usize);
OsStringExt::from_wide(buf)
})
}
// # What's up with this callback?
//
// The callback specified receives a number of parameters from... someone!
-// (the kernel? the runtime? I'm not qute sure!) There are a few events that
+// (the kernel? the runtime? I'm not quite sure!) There are a few events that
// this gets invoked for, but we're currently only interested on when a
// thread or a process "detaches" (exits). The process part happens for the
// last thread and the thread part happens for any normal thread.
secs_part.checked_add(nanos_part as i64)
}
- /// Add two durations, returning `None` if overflow occured.
+ /// Add two durations, returning `None` if overflow occurred.
#[unstable(feature = "std_misc")]
pub fn checked_add(&self, rhs: &Duration) -> Option<Duration> {
let mut secs = try_opt!(self.secs.checked_add(rhs.secs));
if d < MIN || d > MAX { None } else { Some(d) }
}
- /// Subtract two durations, returning `None` if overflow occured.
+ /// Subtract two durations, returning `None` if overflow occurred.
#[unstable(feature = "std_misc")]
pub fn checked_sub(&self, rhs: &Duration) -> Option<Duration> {
let mut secs = try_opt!(self.secs.checked_sub(rhs.secs));
impl fmt::Debug for Name {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let Name(nm) = *self;
- write!(f, "{:?}({})", token::get_name(*self).get(), nm)
+ write!(f, "{:?}({})", token::get_name(*self), nm)
}
}
impl fmt::Display for Name {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- fmt::Display::fmt(token::get_name(*self).get(), f)
+ fmt::Display::fmt(&token::get_name(*self), f)
}
}
pub fn as_str<'a>(&'a self) -> &'a str {
unsafe {
// FIXME #12938: can't use copy_lifetime since &str isn't a &T
- ::std::mem::transmute::<&str,&str>(token::get_name(*self).get())
+ ::std::mem::transmute::<&str,&str>(&token::get_name(*self))
}
}
impl Encodable for Ident {
fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
- s.emit_str(token::get_ident(*self).get())
+ s.emit_str(&token::get_ident(*self))
}
}
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
pub struct WhereBoundPredicate {
pub span: Span,
+ pub bound_lifetimes: Vec<LifetimeDef>,
pub bounded_ty: P<Ty>,
pub bounds: OwnedSlice<TyParamBound>,
}
let v = [TtToken(sp, token::Dollar),
TtToken(sp, token::Ident(token::str_to_ident(var.as_str()),
token::Plain))];
- v[index]
+ v[index].clone()
}
(&TtToken(sp, token::MatchNt(name, kind, name_st, kind_st)), _) => {
let v = [TtToken(sp, token::SubstNt(name, name_st)),
TtToken(sp, token::Colon),
TtToken(sp, token::Ident(kind, kind_st))];
- v[index]
+ v[index].clone()
}
(&TtSequence(_, ref seq), _) => {
seq.tts[index].clone()
/// The `Foo<&'a T>` in `<'a> Foo<&'a T>`
pub trait_ref: TraitRef,
+
+ pub span: Span,
}
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)]
pub fn path_name_i(idents: &[Ident]) -> String {
// FIXME: Bad copies (#2543 -- same for everything else that says "bad")
idents.iter().map(|i| {
- token::get_ident(*i).get().to_string()
+ token::get_ident(*i).to_string()
}).collect::<Vec<String>>().connect("::")
}
pub trait AttrMetaMethods {
fn check_name(&self, name: &str) -> bool {
- name == self.name().get()
+ name == &self.name()[]
}
/// Retrieve the name of the meta item, e.g. `foo` in `#[foo]`,
impl AttrMetaMethods for Attribute {
fn check_name(&self, name: &str) -> bool {
- let matches = name == self.name().get();
+ let matches = name == &self.name()[];
if matches {
mark_used(self);
}
let meta = mk_name_value_item_str(
InternedString::new("doc"),
token::intern_and_get_ident(&strip_doc_comment_decoration(
- comment.get())[]));
+ &comment)[]));
if self.node.style == ast::AttrOuter {
f(&mk_attr_outer(self.node.id, meta))
} else {
pub fn mk_sugared_doc_attr(id: AttrId, text: InternedString, lo: BytePos,
hi: BytePos)
-> Attribute {
- let style = doc_comment_style(text.get());
+ let style = doc_comment_style(&text);
let lit = spanned(lo, hi, ast::LitStr(text, ast::CookedStr));
let attr = Attribute_ {
id: id,
/// Tests if a cfg-pattern matches the cfg set
pub fn cfg_matches(diagnostic: &SpanHandler, cfgs: &[P<MetaItem>], cfg: &ast::MetaItem) -> bool {
match cfg.node {
- ast::MetaList(ref pred, ref mis) if pred.get() == "any" =>
+ ast::MetaList(ref pred, ref mis) if &pred[] == "any" =>
mis.iter().any(|mi| cfg_matches(diagnostic, cfgs, &**mi)),
- ast::MetaList(ref pred, ref mis) if pred.get() == "all" =>
+ ast::MetaList(ref pred, ref mis) if &pred[] == "all" =>
mis.iter().all(|mi| cfg_matches(diagnostic, cfgs, &**mi)),
- ast::MetaList(ref pred, ref mis) if pred.get() == "not" => {
+ ast::MetaList(ref pred, ref mis) if &pred[] == "not" => {
if mis.len() != 1 {
diagnostic.span_err(cfg.span, "expected 1 cfg-pattern");
return false;
'outer: for attr in attrs {
let tag = attr.name();
- let tag = tag.get();
+ let tag = &tag[];
if tag != "deprecated" && tag != "unstable" && tag != "stable" {
continue // not a stability level
}
let mut feature = None;
let mut since = None;
let mut reason = None;
- for meta in metas {
- if meta.name().get() == "feature" {
+ for meta in metas.iter() {
+ if meta.name() == "feature" {
match meta.value_str() {
Some(v) => feature = Some(v),
None => {
}
}
}
- if meta.name().get() == "since" {
+ if &meta.name()[] == "since" {
match meta.value_str() {
Some(v) => since = Some(v),
None => {
}
}
}
- if meta.name().get() == "reason" {
+ if &meta.name()[] == "reason" {
match meta.value_str() {
Some(v) => reason = Some(v),
None => {
for item in items {
match item.node {
ast::MetaWord(ref word) => {
- let hint = match word.get() {
+ let hint = match &word[] {
// Can't use "extern" because it's not a lexical identifier.
"C" => Some(ReprExtern),
"packed" => Some(ReprPacked),
- _ => match int_type_of_word(word.get()) {
+ _ => match int_type_of_word(&word) {
Some(ity) => Some(ReprInt(item.span, ity)),
None => {
// Not a word we recognize
FileLines {file: lo.file, lines: lines}
}
- pub fn span_to_snippet(&self, sp: Span) -> Option<String> {
+ pub fn span_to_snippet(&self, sp: Span) -> Result<String, SpanSnippetError> {
+ if sp.lo > sp.hi {
+ return Err(SpanSnippetError::IllFormedSpan(sp));
+ }
+
let begin = self.lookup_byte_offset(sp.lo);
let end = self.lookup_byte_offset(sp.hi);
- // FIXME #8256: this used to be an assert but whatever precondition
- // it's testing isn't true for all spans in the AST, so to allow the
- // caller to not have to panic (and it can't catch it since the CodeMap
- // isn't sendable), return None
if begin.fm.start_pos != end.fm.start_pos {
- None
+ return Err(SpanSnippetError::DistinctSources(DistinctSources {
+ begin: (begin.fm.name.clone(),
+ begin.fm.start_pos),
+ end: (end.fm.name.clone(),
+ end.fm.start_pos)
+ }));
} else {
- Some((&begin.fm.src[begin.pos.to_usize()..end.pos.to_usize()]).to_string())
+ let start = begin.pos.to_usize();
+ let limit = end.pos.to_usize();
+ if start > limit || limit > begin.fm.src.len() {
+ return Err(SpanSnippetError::MalformedForCodemap(
+ MalformedCodemapPositions {
+ name: begin.fm.name.clone(),
+ source_len: begin.fm.src.len(),
+ begin_pos: begin.pos,
+ end_pos: end.pos,
+ }));
+ }
+
+ return Ok((&begin.fm.src[start..limit]).to_string())
}
}
}
}
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub enum SpanSnippetError {
+ IllFormedSpan(Span),
+ DistinctSources(DistinctSources),
+ MalformedForCodemap(MalformedCodemapPositions),
+}
+
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct DistinctSources {
+ begin: (String, BytePos),
+ end: (String, BytePos)
+}
+
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct MalformedCodemapPositions {
+ name: String,
+ source_len: usize,
+ begin_pos: BytePos,
+ end_pos: BytePos
+}
+
#[cfg(test)]
mod test {
use super::*;
let span = Span {lo: BytePos(12), hi: BytePos(23), expn_id: NO_EXPANSION};
let snippet = cm.span_to_snippet(span);
- assert_eq!(snippet, Some("second line".to_string()));
+ assert_eq!(snippet, Ok("second line".to_string()));
}
#[test]
use std::cell::RefCell;
use std::collections::BTreeMap;
+
use ast;
use ast::{Ident, Name, TokenTree};
use codemap::Span;
match diagnostics.insert(code.name, span) {
Some(previous_span) => {
ecx.span_warn(span, &format!(
- "diagnostic code {} already used", token::get_ident(code).get()
+ "diagnostic code {} already used", &token::get_ident(code)
)[]);
ecx.span_note(previous_span, "previous invocation");
},
with_registered_diagnostics(|diagnostics| {
if !diagnostics.contains_key(&code.name) {
ecx.span_err(span, &format!(
- "used diagnostic code {} not registered", token::get_ident(code).get()
+ "used diagnostic code {} not registered", &token::get_ident(code)
)[]);
}
});
with_registered_diagnostics(|diagnostics| {
if diagnostics.insert(code.name, description).is_some() {
ecx.span_err(span, &format!(
- "diagnostic code {} already registered", token::get_ident(*code).get()
+ "diagnostic code {} already registered", &token::get_ident(*code)
)[]);
}
});
let sym = Ident::new(token::gensym(&(
- "__register_diagnostic_".to_string() + token::get_ident(*code).get()
+ "__register_diagnostic_".to_string() + &token::get_ident(*code)
)[]));
MacItems::new(vec![quote_item!(ecx, mod $sym {}).unwrap()].into_iter())
}
use std::collections::HashMap;
+#[derive(Clone)]
pub struct Registry {
descriptions: HashMap<&'static str, &'static str>
}
// It's the opposite of '=&' which means that the memory
// cannot be shared with any other operand (usually when
// a register is clobbered early.)
- let output = match constraint.get().slice_shift_char() {
+ let output = match constraint.slice_shift_char() {
Some(('=', _)) => None,
Some(('+', operand)) => {
Some(token::intern_and_get_ident(&format!(
let (constraint, _str_style) = p.parse_str();
- if constraint.get().starts_with("=") {
+ if constraint.starts_with("=") {
cx.span_err(p.last_span, "input operand constraint contains '='");
- } else if constraint.get().starts_with("+") {
+ } else if constraint.starts_with("+") {
cx.span_err(p.last_span, "input operand constraint contains '+'");
}
MacExpr::new(P(ast::Expr {
id: ast::DUMMY_NODE_ID,
node: ast::ExprInlineAsm(ast::InlineAsm {
- asm: token::intern_and_get_ident(asm.get()),
+ asm: token::intern_and_get_ident(&asm),
asm_str_style: asm_str_style.unwrap(),
outputs: outputs,
inputs: inputs,
pub cfg: ast::CrateConfig,
pub backtrace: ExpnId,
pub ecfg: expand::ExpansionConfig,
+ pub use_std: bool,
pub mod_path: Vec<ast::Ident> ,
pub trace_mac: bool,
backtrace: NO_EXPANSION,
mod_path: Vec::new(),
ecfg: ecfg,
+ use_std: true,
trace_mac: false,
exported_macros: Vec::new(),
syntax_env: env,
pub fn ident_of(&self, st: &str) -> ast::Ident {
str_to_ident(st)
}
+ pub fn ident_of_std(&self, st: &str) -> ast::Ident {
+ self.ident_of(if self.use_std { "std" } else { st })
+ }
pub fn name_of(&self, st: &str) -> ast::Name {
token::intern(st)
}
cx.span_err(sp, &format!("{} takes 1 argument", name)[]);
}
expr_to_string(cx, ret, "argument must be a string literal").map(|(s, _)| {
- s.get().to_string()
+ s.to_string()
})
}
use parse::token;
use ptr::P;
-
// Transitional reexports so qquote can find the paths it is looking for
mod syntax {
pub use ext;
default: Option<P<ast::Ty>>) -> ast::TyParam;
fn trait_ref(&self, path: ast::Path) -> ast::TraitRef;
- fn poly_trait_ref(&self, path: ast::Path) -> ast::PolyTraitRef;
+ fn poly_trait_ref(&self, span: Span, path: ast::Path) -> ast::PolyTraitRef;
fn typarambound(&self, path: ast::Path) -> ast::TyParamBound;
fn lifetime(&self, span: Span, ident: ast::Name) -> ast::Lifetime;
fn lifetime_def(&self,
self.path_all(DUMMY_SP,
true,
vec!(
- self.ident_of("std"),
+ self.ident_of_std("core"),
self.ident_of("option"),
self.ident_of("Option")
),
}
}
- fn poly_trait_ref(&self, path: ast::Path) -> ast::PolyTraitRef {
+ fn poly_trait_ref(&self, span: Span, path: ast::Path) -> ast::PolyTraitRef {
ast::PolyTraitRef {
bound_lifetimes: Vec::new(),
- trait_ref: self.trait_ref(path)
+ trait_ref: self.trait_ref(path),
+ span: span,
}
}
fn typarambound(&self, path: ast::Path) -> ast::TyParamBound {
- ast::TraitTyParamBound(self.poly_trait_ref(path), ast::TraitBoundModifier::None)
+ ast::TraitTyParamBound(self.poly_trait_ref(path.span, path), ast::TraitBoundModifier::None)
}
fn lifetime(&self, span: Span, name: ast::Name) -> ast::Lifetime {
fn expr_field_access(&self, sp: Span, expr: P<ast::Expr>, ident: ast::Ident) -> P<ast::Expr> {
let field_name = token::get_ident(ident);
let field_span = Span {
- lo: sp.lo - Pos::from_usize(field_name.get().len()),
+ lo: sp.lo - Pos::from_usize(field_name.len()),
hi: sp.hi,
expn_id: sp.expn_id,
};
}
fn expr_vec_ng(&self, sp: Span) -> P<ast::Expr> {
self.expr_call_global(sp,
- vec!(self.ident_of("std"),
+ vec!(self.ident_of_std("collections"),
self.ident_of("vec"),
self.ident_of("Vec"),
self.ident_of("new")),
fn expr_some(&self, sp: Span, expr: P<ast::Expr>) -> P<ast::Expr> {
let some = vec!(
- self.ident_of("std"),
+ self.ident_of_std("core"),
self.ident_of("option"),
self.ident_of("Option"),
self.ident_of("Some"));
fn expr_none(&self, sp: Span) -> P<ast::Expr> {
let none = self.path_global(sp, vec!(
- self.ident_of("std"),
+ self.ident_of_std("core"),
self.ident_of("option"),
self.ident_of("Option"),
self.ident_of("None")));
self.expr_call_global(
span,
vec!(
- self.ident_of("std"),
+ self.ident_of_std("core"),
self.ident_of("rt"),
self.ident_of("begin_unwind")),
vec!(
fn expr_ok(&self, sp: Span, expr: P<ast::Expr>) -> P<ast::Expr> {
let ok = vec!(
- self.ident_of("std"),
+ self.ident_of_std("core"),
self.ident_of("result"),
self.ident_of("Result"),
self.ident_of("Ok"));
fn expr_err(&self, sp: Span, expr: P<ast::Expr>) -> P<ast::Expr> {
let err = vec!(
- self.ident_of("std"),
+ self.ident_of_std("core"),
self.ident_of("result"),
self.ident_of("Result"),
self.ident_of("Err"));
}
fn expr_try(&self, sp: Span, head: P<ast::Expr>) -> P<ast::Expr> {
- let ok = self.ident_of("Ok");
- let ok_path = self.path_ident(sp, ok);
- let err = self.ident_of("Err");
- let err_path = self.path_ident(sp, err);
+ let ok = vec![
+ self.ident_of_std("core"),
+ self.ident_of("result"),
+ self.ident_of("Result"),
+ self.ident_of("Ok")
+ ];
+ let ok_path = self.path_global(sp, ok);
+ let err = vec![
+ self.ident_of_std("core"),
+ self.ident_of("result"),
+ self.ident_of("Result"),
+ self.ident_of("Err")
+ ];
+ let err_path = self.path_global(sp, err);
let binding_variable = self.ident_of("__try_var");
let binding_pat = self.pat_ident(sp, binding_variable);
let ok_pat = self.pat_enum(sp, ok_path, vec!(binding_pat.clone()));
// Err(__try_var) (pattern and expression resp.)
- let err_pat = self.pat_enum(sp, err_path, vec!(binding_pat));
- let err_inner_expr = self.expr_call_ident(sp, err, vec!(binding_expr.clone()));
+ let err_pat = self.pat_enum(sp, err_path.clone(), vec!(binding_pat));
+ let err_inner_expr = self.expr_call(sp, self.expr_path(err_path),
+ vec!(binding_expr.clone()));
// return Err(__try_var)
let err_expr = self.expr(sp, ast::ExprRet(Some(err_inner_expr)));
fn pat_some(&self, span: Span, pat: P<ast::Pat>) -> P<ast::Pat> {
let some = vec!(
- self.ident_of("std"),
+ self.ident_of_std("core"),
self.ident_of("option"),
self.ident_of("Option"),
self.ident_of("Some"));
fn pat_none(&self, span: Span) -> P<ast::Pat> {
let some = vec!(
- self.ident_of("std"),
+ self.ident_of_std("core"),
self.ident_of("option"),
self.ident_of("Option"),
self.ident_of("None"));
fn pat_ok(&self, span: Span, pat: P<ast::Pat>) -> P<ast::Pat> {
let some = vec!(
- self.ident_of("std"),
+ self.ident_of_std("core"),
self.ident_of("result"),
self.ident_of("Result"),
self.ident_of("Ok"));
fn pat_err(&self, span: Span, pat: P<ast::Pat>) -> P<ast::Pat> {
let some = vec!(
- self.ident_of("std"),
+ self.ident_of_std("core"),
self.ident_of("result"),
self.ident_of("Result"),
self.ident_of("Err"));
ast::LitStr(ref s, _) |
ast::LitFloat(ref s, _) |
ast::LitFloatUnsuffixed(ref s) => {
- accumulator.push_str(s.get());
+ accumulator.push_str(&s);
}
ast::LitChar(c) => {
accumulator.push(c);
} else {
match *e {
ast::TtToken(_, token::Ident(ident, _)) => {
- res_str.push_str(token::get_ident(ident).get())
+ res_str.push_str(&token::get_ident(ident))
},
_ => {
cx.span_err(sp, "concat_idents! requires ident args.");
{
let name = match mitem.node {
MetaWord(ref tname) => {
- match tname.get() {
+ match &tname[] {
"Copy" => "Copy",
"Send" | "Sync" => {
return cx.span_err(span,
}
};
+ let path = Path::new(vec![
+ if cx.use_std { "std" } else { "core" },
+ "marker",
+ name
+ ]);
+
let trait_def = TraitDef {
span: span,
attributes: Vec::new(),
- path: Path::new(vec!("std", "marker", name)),
+ path: path,
additional_bounds: Vec::new(),
generics: LifetimeBounds::empty(),
methods: Vec::new(),
let trait_def = TraitDef {
span: span,
attributes: Vec::new(),
- path: Path::new(vec!("std", "clone", "Clone")),
+ path: path_std!(cx, core::clone::Clone),
additional_bounds: Vec::new(),
generics: LifetimeBounds::empty(),
methods: vec!(
let ctor_path;
let all_fields;
let fn_path = vec![
- cx.ident_of("std"),
+ cx.ident_of_std("core"),
cx.ident_of("clone"),
cx.ident_of("Clone"),
cx.ident_of("clone"),
generics: LifetimeBounds::empty(),
explicit_self: borrowed_explicit_self(),
args: vec!(borrowed_self()),
- ret_ty: Literal(Path::new(vec!("bool"))),
+ ret_ty: Literal(path!(bool)),
attributes: attrs,
combine_substructure: combine_substructure(box |a, b, c| {
$f(a, b, c)
let trait_def = TraitDef {
span: span,
attributes: Vec::new(),
- path: Path::new(vec!("std", "cmp", "PartialEq")),
+ path: path_std!(cx, core::cmp::PartialEq),
additional_bounds: Vec::new(),
generics: LifetimeBounds::empty(),
methods: vec!(
generics: LifetimeBounds::empty(),
explicit_self: borrowed_explicit_self(),
args: vec!(borrowed_self()),
- ret_ty: Literal(Path::new(vec!("bool"))),
+ ret_ty: Literal(path!(bool)),
attributes: attrs,
combine_substructure: combine_substructure(box |cx, span, substr| {
cs_op($op, $equal, cx, span, substr)
} }
}
- let ordering_ty = Literal(Path::new(vec!["std", "cmp", "Ordering"]));
- let ret_ty = Literal(Path::new_(vec!["std", "option", "Option"],
+ let ordering_ty = Literal(path_std!(cx, core::cmp::Ordering));
+ let ret_ty = Literal(Path::new_(pathvec_std!(cx, core::option::Option),
None,
vec![box ordering_ty],
true));
let trait_def = TraitDef {
span: span,
attributes: vec![],
- path: Path::new(vec!["std", "cmp", "PartialOrd"]),
+ path: path_std!(cx, core::cmp::PartialOrd),
additional_bounds: vec![],
generics: LifetimeBounds::empty(),
methods: vec![
substr: &Substructure) -> P<Expr> {
let test_id = cx.ident_of("__test");
let ordering = cx.path_global(span,
- vec!(cx.ident_of("std"),
+ vec!(cx.ident_of_std("core"),
cx.ident_of("cmp"),
cx.ident_of("Ordering"),
cx.ident_of("Equal")));
let equals_expr = cx.expr_some(span, ordering);
let partial_cmp_path = vec![
- cx.ident_of("std"),
+ cx.ident_of_std("core"),
cx.ident_of("cmp"),
cx.ident_of("PartialOrd"),
cx.ident_of("partial_cmp"),
let trait_def = TraitDef {
span: span,
attributes: Vec::new(),
- path: Path::new(vec!("std", "cmp", "Eq")),
+ path: path_std!(cx, core::cmp::Eq),
additional_bounds: Vec::new(),
generics: LifetimeBounds::empty(),
methods: vec!(
let trait_def = TraitDef {
span: span,
attributes: Vec::new(),
- path: Path::new(vec!("std", "cmp", "Ord")),
+ path: path_std!(cx, core::cmp::Ord),
additional_bounds: Vec::new(),
generics: LifetimeBounds::empty(),
methods: vec!(
generics: LifetimeBounds::empty(),
explicit_self: borrowed_explicit_self(),
args: vec!(borrowed_self()),
- ret_ty: Literal(Path::new(vec!("std", "cmp", "Ordering"))),
+ ret_ty: Literal(path_std!(cx, core::cmp::Ordering)),
attributes: attrs,
combine_substructure: combine_substructure(box |a, b, c| {
cs_cmp(a, b, c)
substr: &Substructure) -> P<Expr> {
let test_id = cx.ident_of("__test");
let equals_path = cx.path_global(span,
- vec!(cx.ident_of("std"),
+ vec!(cx.ident_of_std("core"),
cx.ident_of("cmp"),
cx.ident_of("Ordering"),
cx.ident_of("Equal")));
let cmp_path = vec![
- cx.ident_of("std"),
+ cx.ident_of_std("core"),
cx.ident_of("cmp"),
cx.ident_of("Ord"),
cx.ident_of("cmp"),
krate: &'static str) where
F: FnOnce(P<Item>),
{
+ if !cx.use_std {
+ // FIXME(#21880): lift this requirement.
+ cx.span_err(span, "this trait cannot be derived with #![no_std]");
+ return;
+ }
+
let trait_def = TraitDef {
span: span,
attributes: Vec::new(),
args: vec!(Ptr(box Literal(Path::new_local("__D")),
Borrowed(None, MutMutable))),
ret_ty: Literal(Path::new_(
- vec!("std", "result", "Result"),
+ pathvec_std!(cx, core::result::Result),
None,
vec!(box Self, box Literal(Path::new_(
vec!["__D", "Error"], None, vec![], false
let trait_def = TraitDef {
span: span,
attributes: Vec::new(),
- path: Path::new(vec!("std", "default", "Default")),
+ path: path_std!(cx, core::default::Default),
additional_bounds: Vec::new(),
generics: LifetimeBounds::empty(),
methods: vec!(
fn default_substructure(cx: &mut ExtCtxt, trait_span: Span, substr: &Substructure) -> P<Expr> {
let default_ident = vec!(
- cx.ident_of("std"),
+ cx.ident_of_std("core"),
cx.ident_of("default"),
cx.ident_of("Default"),
cx.ident_of("default")
krate: &'static str) where
F: FnOnce(P<Item>),
{
+ if !cx.use_std {
+ // FIXME(#21880): lift this requirement.
+ cx.span_err(span, "this trait cannot be derived with #![no_std]");
+ return;
+ }
+
let trait_def = TraitDef {
span: span,
attributes: Vec::new(),
args: vec!(Ptr(box Literal(Path::new_local("__S")),
Borrowed(None, MutMutable))),
ret_ty: Literal(Path::new_(
- vec!("std", "result", "Result"),
+ pathvec_std!(cx, core::result::Result),
None,
vec!(box Tuple(Vec::new()), box Literal(Path::new_(
vec!["__S", "Error"], None, vec![], false
// generated implementations are linted
let mut attrs = newitem.attrs.clone();
attrs.extend(item.attrs.iter().filter(|a| {
- match a.name().get() {
+ match &a.name()[] {
"allow" | "warn" | "deny" | "forbid" => true,
_ => false,
}
ast::WherePredicate::BoundPredicate(ref wb) => {
ast::WherePredicate::BoundPredicate(ast::WhereBoundPredicate {
span: self.span,
+ bound_lifetimes: wb.bound_lifetimes.clone(),
bounded_ty: wb.bounded_ty.clone(),
bounds: OwnedSlice::from_vec(wb.bounds.iter().map(|b| b.clone()).collect())
})
F: FnOnce(P<Item>),
{
- let path = Path::new_(vec!("std", "hash", "Hash"), None,
+ let path = Path::new_(pathvec_std!(cx, core::hash::Hash), None,
vec!(box Literal(Path::new_local("__S"))), true);
let generics = LifetimeBounds {
lifetimes: Vec::new(),
bounds: vec!(("__S",
- vec!(Path::new(vec!("std", "hash", "Writer")),
- Path::new(vec!("std", "hash", "Hasher"))))),
+ vec!(path_std!(cx, core::hash::Writer),
+ path_std!(cx, core::hash::Hasher)))),
};
let args = Path::new_local("__S");
let inline = cx.meta_word(span, InternedString::new("inline"));
let call_hash = |span, thing_expr| {
let hash_path = {
let strs = vec![
- cx.ident_of("std"),
+ cx.ident_of_std("core"),
cx.ident_of("hash"),
cx.ident_of("Hash"),
cx.ident_of("hash"),
use codemap::Span;
use ptr::P;
+macro_rules! pathvec {
+ ($($x:ident)::+) => (
+ vec![ $( stringify!($x) ),+ ]
+ )
+}
+
+macro_rules! path {
+ ($($x:tt)*) => (
+ ::ext::deriving::generic::ty::Path::new( pathvec!( $($x)* ) )
+ )
+}
+
+macro_rules! pathvec_std {
+ ($cx:expr, $first:ident :: $($rest:ident)::+) => (
+ if $cx.use_std {
+ pathvec!(std :: $($rest)::+)
+ } else {
+ pathvec!($first :: $($rest)::+)
+ }
+ )
+}
+
+macro_rules! path_std {
+ ($($x:tt)*) => (
+ ::ext::deriving::generic::ty::Path::new( pathvec_std!( $($x)* ) )
+ )
+}
+
pub mod bounds;
pub mod clone;
pub mod encodable;
|i| push(i)))
}
- match tname.get() {
+ match &tname[] {
"Clone" => expand!(clone::expand_deriving_clone),
"Hash" => expand!(hash::expand_deriving_hash),
let trait_def = TraitDef {
span: span,
attributes: Vec::new(),
- path: Path::new(vec!("std", "num", "FromPrimitive")),
+ path: path_std!(cx, core::num::FromPrimitive),
additional_bounds: Vec::new(),
generics: LifetimeBounds::empty(),
methods: vec!(
name: "from_i64",
generics: LifetimeBounds::empty(),
explicit_self: None,
- args: vec!(
- Literal(Path::new(vec!("i64")))),
- ret_ty: Literal(Path::new_(vec!("std", "option", "Option"),
+ args: vec!(Literal(path!(i64))),
+ ret_ty: Literal(Path::new_(pathvec_std!(cx, core::option::Option),
None,
vec!(box Self),
true)),
name: "from_u64",
generics: LifetimeBounds::empty(),
explicit_self: None,
- args: vec!(
- Literal(Path::new(vec!("u64")))),
- ret_ty: Literal(Path::new_(vec!("std", "option", "Option"),
+ args: vec!(Literal(path!(u64))),
+ ret_ty: Literal(Path::new_(pathvec_std!(cx, core::option::Option),
None,
vec!(box Self),
true)),
"`#[derive(Rand)]` is deprecated in favour of `#[derive_Rand]` from \
`rand_macros` on crates.io");
+ if !cx.use_std {
+ // FIXME(#21880): lift this requirement.
+ cx.span_err(span, "this trait cannot be derived with #![no_std]");
+ return;
+ }
+
let trait_def = TraitDef {
span: span,
attributes: Vec::new(),
- path: Path::new(vec!("std", "rand", "Rand")),
+ path: path!(std::rand::Rand),
additional_bounds: Vec::new(),
generics: LifetimeBounds::empty(),
methods: vec!(
generics: LifetimeBounds {
lifetimes: Vec::new(),
bounds: vec!(("R",
- vec!( Path::new(vec!("std", "rand", "Rng")) )))
+ vec!( path!(std::rand::Rng) ))),
},
explicit_self: None,
args: vec!(
F: FnOnce(P<Item>),
{
// &mut ::std::fmt::Formatter
- let fmtr = Ptr(box Literal(Path::new(vec!("std", "fmt", "Formatter"))),
+ let fmtr = Ptr(box Literal(path_std!(cx, core::fmt::Formatter)),
Borrowed(None, ast::MutMutable));
let trait_def = TraitDef {
span: span,
attributes: Vec::new(),
- path: Path::new(vec!["std", "fmt", "Debug"]),
+ path: path_std!(cx, core::fmt::Debug),
additional_bounds: Vec::new(),
generics: LifetimeBounds::empty(),
methods: vec![
generics: LifetimeBounds::empty(),
explicit_self: borrowed_explicit_self(),
args: vec!(fmtr),
- ret_ty: Literal(Path::new(vec!("std", "fmt", "Result"))),
+ ret_ty: Literal(path_std!(cx, core::fmt::Result)),
attributes: Vec::new(),
combine_substructure: combine_substructure(box |a, b, c| {
show_substructure(a, b, c)
}
};
- let mut format_string = String::from_str(token::get_ident(name).get());
+ let mut format_string = String::from_str(&token::get_ident(name));
// the internal fields we're actually formatting
let mut exprs = Vec::new();
let name = token::get_ident(field.name.unwrap());
format_string.push_str(" ");
- format_string.push_str(name.get());
+ format_string.push_str(&name);
format_string.push_str(": {:?}");
exprs.push(field.self_.clone());
Err(..) => {
cx.expr_path(cx.path_all(sp,
true,
- vec!(cx.ident_of("std"),
+ vec!(cx.ident_of_std("core"),
cx.ident_of("option"),
cx.ident_of("Option"),
cx.ident_of("None")),
}
Ok(s) => {
cx.expr_call_global(sp,
- vec!(cx.ident_of("std"),
+ vec!(cx.ident_of_std("core"),
cx.ident_of("option"),
cx.ident_of("Option"),
cx.ident_of("Some")),
}
}
- let e = match env::var_string(var.get()) {
- Err(..) => {
- cx.span_err(sp, msg.get());
+ let e = match env::var_string(&var[]) {
+ Err(_) => {
+ cx.span_err(sp, &msg);
cx.expr_usize(sp, 0)
}
- Ok(s) => cx.expr_str(sp, token::intern_and_get_ident(&s[]))
+ Ok(s) => cx.expr_str(sp, token::intern_and_get_ident(&s))
};
MacExpr::new(e)
}
use util::small_vector::SmallVector;
use visit;
use visit::Visitor;
+use std_inject;
pub fn expand_type(t: P<ast::Ty>,
fld: &mut MacroExpander,
ast::ExprForLoop(pat, head, body, opt_ident) => {
// to:
//
- // match ::std::iter::IntoIterator::into_iter(<head>) {
- // mut iter => {
- // [opt_ident]: loop {
- // match ::std::iter::Iterator::next(&mut iter) {
- // ::std::option::Option::Some(<pat>) => <body>,
- // ::std::option::Option::None => break
+ // {
+ // let result = match ::std::iter::IntoIterator::into_iter(<head>) {
+ // mut iter => {
+ // [opt_ident]: loop {
+ // match ::std::iter::Iterator::next(&mut iter) {
+ // ::std::option::Option::Some(<pat>) => <body>,
+ // ::std::option::Option::None => break
+ // }
// }
// }
- // }
+ // };
+ // result
// }
// expand <head>
let match_expr = {
let next_path = {
let strs = vec![
- fld.cx.ident_of("std"),
+ fld.cx.ident_of_std("core"),
fld.cx.ident_of("iter"),
fld.cx.ident_of("Iterator"),
fld.cx.ident_of("next"),
let into_iter_expr = {
let into_iter_path = {
let strs = vec![
- fld.cx.ident_of("std"),
+ fld.cx.ident_of_std("core"),
fld.cx.ident_of("iter"),
fld.cx.ident_of("IntoIterator"),
fld.cx.ident_of("into_iter"),
fld.cx.expr_call(span, fld.cx.expr_path(into_iter_path), vec![head])
};
- fld.cx.expr_match(span, into_iter_expr, vec![iter_arm])
+
+ let match_expr = fld.cx.expr_match(span, into_iter_expr, vec![iter_arm]);
+
+ // `{ let result = ...; result }`
+ let result_ident = token::gensym_ident("result");
+ fld.cx.expr_block(
+ fld.cx.block_all(
+ span,
+ vec![fld.cx.stmt_let(span, false, result_ident, match_expr)],
+ Some(fld.cx.expr_ident(span, result_ident))))
}
ast::ExprClosure(capture_clause, fn_decl, block) => {
fld.cx.span_err(
pth.span,
&format!("macro undefined: '{}!'",
- extnamestr.get())[]);
+ &extnamestr)[]);
// let compilation continue
None
fld.cx.bt_push(ExpnInfo {
call_site: span,
callee: NameAndSpan {
- name: extnamestr.get().to_string(),
+ name: extnamestr.to_string(),
format: MacroBang,
span: exp_span,
},
fld.cx.span_err(
pth.span,
&format!("non-expression macro in expression position: {}",
- &extnamestr.get()[]
+ &extnamestr[]
)[]);
return None;
}
fld.cx.span_err(
pth.span,
&format!("'{}' is not a tt-style macro",
- extnamestr.get())[]);
+ &extnamestr)[]);
None
}
}
for attr in &modifiers {
let mname = attr.name();
- match fld.cx.syntax_env.find(&intern(mname.get())) {
+ match fld.cx.syntax_env.find(&intern(&mname)) {
Some(rc) => match *rc {
Modifier(ref mac) => {
attr::mark_used(attr);
fld.cx.bt_push(ExpnInfo {
call_site: attr.span,
callee: NameAndSpan {
- name: mname.get().to_string(),
+ name: mname.to_string(),
format: MacroAttribute,
span: None,
}
fld.cx.bt_push(ExpnInfo {
call_site: it.span,
callee: NameAndSpan {
- name: extnamestr.get().to_string(),
+ name: extnamestr.to_string(),
format: MacroBang,
span: span
}
if it.ident.name == parse::token::special_idents::invalid.name {
fld.cx.span_err(path_span,
&format!("macro {}! expects an ident argument",
- extnamestr.get())[]);
+ &extnamestr)[]);
return SmallVector::zero();
}
fld.cx.bt_push(ExpnInfo {
call_site: it.span,
callee: NameAndSpan {
- name: extnamestr.get().to_string(),
+ name: extnamestr.to_string(),
format: MacroBang,
span: span
}
fld.cx.bt_push(ExpnInfo {
call_site: it.span,
callee: NameAndSpan {
- name: extnamestr.get().to_string(),
+ name: extnamestr.to_string(),
format: MacroBang,
span: None,
}
_ => {
fld.cx.span_err(it.span,
&format!("{}! is not legal in item position",
- extnamestr.get())[]);
+ &extnamestr)[]);
return SmallVector::zero();
}
}
None => {
fld.cx.span_err(path_span,
&format!("non-item macro in item position: {}",
- extnamestr.get())[]);
+ &extnamestr)[]);
return SmallVector::zero();
}
};
fld.cx.bt_push(ExpnInfo {
call_site: span,
callee: NameAndSpan {
- name: extnamestr.get().to_string(),
+ name: extnamestr.to_string(),
format: MacroBang,
span: tt_span
}
pth.span,
&format!(
"non-pattern macro in pattern position: {}",
- extnamestr.get()
+ &extnamestr
)[]
);
return DummyResult::raw_pat(span);
_ => {
fld.cx.span_err(span,
&format!("{}! is not legal in pattern position",
- extnamestr.get())[]);
+ &extnamestr)[]);
return DummyResult::raw_pat(span);
}
}
for attr in a.attrs() {
let mname = attr.name();
- match fld.cx.syntax_env.find(&intern(mname.get())) {
+ match fld.cx.syntax_env.find(&intern(&mname)) {
Some(rc) => match *rc {
Decorator(ref dec) => {
let it = match a {
fld.cx.bt_push(ExpnInfo {
call_site: attr.span,
callee: NameAndSpan {
- name: mname.get().to_string(),
+ name: mname.to_string(),
format: MacroAttribute,
span: None
}
fld: &MacroExpander)
-> (Vec<ast::Attribute>, Vec<ast::Attribute>) {
attrs.iter().cloned().partition(|attr| {
- match fld.cx.syntax_env.find(&intern(attr.name().get())) {
+ match fld.cx.syntax_env.find(&intern(&attr.name())) {
Some(rc) => match *rc {
Modifier(_) => true,
_ => false
fld: &MacroExpander)
-> (Vec<ast::Attribute>, Vec<ast::Attribute>) {
attrs.iter().cloned().partition(|attr| {
- match fld.cx.syntax_env.find(&intern(attr.name().get())) {
+ match fld.cx.syntax_env.find(&intern(&attr.name())) {
Some(rc) => match *rc {
MultiModifier(_) => true,
_ => false
for attr in &modifiers {
let mname = attr.name();
- match fld.cx.syntax_env.find(&intern(mname.get())) {
+ match fld.cx.syntax_env.find(&intern(&mname)) {
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(),
+ name: mname.to_string(),
format: MacroAttribute,
span: None,
}
user_exts: Vec<NamedSyntaxExtension>,
c: Crate) -> Crate {
let mut cx = ExtCtxt::new(parse_sess, c.config.clone(), cfg);
+ cx.use_std = std_inject::use_std(&c);
+
let mut expander = MacroExpander::new(&mut cx);
for def in imported_macros {
.collect();
println!("varref #{}: {:?}, resolves to {}",idx, varref_idents, varref_name);
let string = token::get_ident(final_varref_ident);
- println!("varref's first segment's string: \"{}\"", string.get());
+ println!("varref's first segment's string: \"{}\"", &string[]);
println!("binding #{}: {}, resolves to {}",
binding_idx, bindings[binding_idx], binding_name);
mtwt::with_sctable(|x| mtwt::display_sctable(x));
let cxbinds: Vec<&ast::Ident> =
bindings.iter().filter(|b| {
let ident = token::get_ident(**b);
- let string = ident.get();
+ let string = &ident[];
"xx" == string
}).collect();
let cxbinds: &[&ast::Ident] = &cxbinds[];
// the xx binding should bind all of the xx varrefs:
for (idx,v) in varrefs.iter().filter(|p| {
p.segments.len() == 1
- && "xx" == token::get_ident(p.segments[0].identifier).get()
+ && "xx" == &token::get_ident(p.segments[0].identifier)[]
}).enumerate() {
if mtwt::resolve(v.segments[0].identifier) != resolved_binding {
println!("uh oh, xx binding didn't match xx varref:");
}
};
let interned_name = token::get_ident(ident);
- let name = interned_name.get();
+ let name = &interned_name[];
+
p.expect(&token::Eq);
let e = p.parse_expr();
match names.get(name) {
}
fn rtpath(ecx: &ExtCtxt, s: &str) -> Vec<ast::Ident> {
- vec![ecx.ident_of("std"), ecx.ident_of("fmt"), ecx.ident_of("rt"),
+ vec![ecx.ident_of_std("core"), ecx.ident_of("fmt"), ecx.ident_of("rt"),
ecx.ident_of("v1"), ecx.ident_of(s)]
}
};
self.ecx.expr_call_global(self.fmtsp, vec!(
- self.ecx.ident_of("std"),
+ self.ecx.ident_of_std("core"),
self.ecx.ident_of("fmt"),
self.ecx.ident_of("Arguments"),
self.ecx.ident_of(fn_name)), fn_args)
}
Unsigned => {
return ecx.expr_call_global(sp, vec![
- ecx.ident_of("std"),
+ ecx.ident_of_std("core"),
ecx.ident_of("fmt"),
ecx.ident_of("ArgumentV1"),
ecx.ident_of("from_uint")], vec![arg])
};
let format_fn = ecx.path_global(sp, vec![
- ecx.ident_of("std"),
+ ecx.ident_of_std("core"),
ecx.ident_of("fmt"),
ecx.ident_of(trait_),
ecx.ident_of("fmt")]);
ecx.expr_call_global(sp, vec![
- ecx.ident_of("std"),
+ ecx.ident_of_std("core"),
ecx.ident_of("fmt"),
ecx.ident_of("ArgumentV1"),
ecx.ident_of("new")], vec![arg, ecx.expr_path(format_fn)])
None => return DummyResult::raw_expr(sp)
};
- let mut parser = parse::Parser::new(fmt.get());
+ let mut parser = parse::Parser::new(&fmt);
+
loop {
match parser.next() {
Some(piece) => {
impl ToSource for ast::Ident {
fn to_source(&self) -> String {
- token::get_ident(*self).get().to_string()
+ token::get_ident(*self).to_string()
}
}
base::check_zero_tts(cx, sp, tts, "module_path!");
let string = cx.mod_path()
.iter()
- .map(|x| token::get_ident(*x).get().to_string())
+ .map(|x| token::get_ident(*x).to_string())
.collect::<Vec<String>>()
.connect("::");
base::MacExpr::new(cx.expr_str(
fn make_items(mut self: Box<ExpandResult<'a>>)
-> Option<SmallVector<P<ast::Item>>> {
let mut ret = SmallVector::zero();
- loop {
+ while self.p.token != token::Eof {
match self.p.parse_item_with_outer_attributes() {
Some(item) => ret.push(item),
- None => break
+ None => self.p.span_fatal(
+ self.p.span,
+ &format!("expected item, found `{}`",
+ self.p.this_token_to_string())[]
+ )
}
}
Some(ret)
p_s.span_diagnostic
.span_fatal(sp,
&format!("duplicated bind name: {}",
- string.get())[])
+ &string)[])
}
}
}
let name_string = token::get_ident(name);
let match_cur = ei.match_cur;
(&mut ei.matches[match_cur]).push(Rc::new(MatchedNonterminal(
- parse_nt(&mut rust_parser, span, name_string.get()))));
- ei.idx += 1;
+ parse_nt(&mut rust_parser, span, &name_string))));
+ ei.idx += 1us;
ei.match_cur += 1;
}
_ => panic!()
//! For the purpose of future feature-tracking, once code for detection of feature
//! gate usage is added, *do not remove it again* even once the feature
//! becomes stable.
+
use self::Status::*;
use abi::RustIntrinsic;
// int and uint are now deprecated
("int_uint", "1.0.0", Active),
- // macro reexport needs more discusion and stabilization
+ // macro reexport needs more discussion and stabilization
("macro_reexport", "1.0.0", Active),
// These are used to test this portion of the compiler, they don't actually
("staged_api", "1.0.0", Active),
// Allows using items which are missing stability attributes
- ("unmarked_api", "1.0.0", Active)
+ ("unmarked_api", "1.0.0", Active),
+
+ // Allows using #![no_std]
+ ("no_std", "1.0.0", Active),
];
enum Status {
pub old_orphan_check: bool,
pub simd_ffi: bool,
pub unmarked_api: bool,
- pub lib_features: Vec<(InternedString, Span)>
+ /// spans of #![feature] attrs for stable language features. for error reporting
+ pub declared_stable_lang_features: Vec<Span>,
+ /// #![feature] attrs for non-language (library) features
+ pub declared_lib_features: Vec<(InternedString, Span)>
}
impl Features {
old_orphan_check: false,
simd_ffi: false,
unmarked_api: false,
- lib_features: Vec::new()
+ declared_stable_lang_features: Vec::new(),
+ declared_lib_features: Vec::new()
}
}
}
impl<'a, 'v> Visitor<'v> for PostExpansionVisitor<'a> {
fn visit_name(&mut self, sp: Span, name: ast::Name) {
- if !token::get_name(name).get().is_ascii() {
+ if !token::get_name(name).is_ascii() {
self.gate_feature("non_ascii_idents", sp,
"non-ascii idents are not fully supported.");
}
}
match i.node {
ast::ItemExternCrate(_) => {
- if attr::contains_name(&i.attrs[], "plugin") {
- self.gate_feature("plugin", i.span,
- "compiler plugins are experimental \
- and possibly buggy");
- } else if attr::contains_name(&i.attrs[], "macro_reexport") {
+ if attr::contains_name(&i.attrs[], "macro_reexport") {
self.gate_feature("macro_reexport", i.span,
"macros reexports are experimental \
and possibly buggy");
let links_to_llvm = match attr::first_attr_value_str_by_name(&i.attrs,
"link_name") {
- Some(val) => val.get().starts_with("llvm."),
+ Some(val) => val.starts_with("llvm."),
_ => false
};
if links_to_llvm {
if attr.check_name("staged_api") {
self.gate_feature("staged_api", attr.span,
"staged_api is for use by rustc only");
+ } else if attr.check_name("plugin") {
+ self.gate_feature("plugin", attr.span,
+ "compiler plugins are experimental \
+ and possibly buggy");
}
if attr::contains_name(slice::ref_slice(attr), "lang") {
attr.span,
"language items are subject to change");
}
+
+ if attr.check_name("no_std") {
+ self.gate_feature("no_std", attr.span,
+ "no_std is experimental");
+ }
}
fn visit_pat(&mut self, pattern: &ast::Pat) {
cm: cm,
};
+ let mut accepted_features = Vec::new();
let mut unknown_features = Vec::new();
for attr in &krate.attrs {
span_handler.span_err(mi.span, "feature has been removed");
}
Some(&(_, _, Accepted)) => {
- span_handler.span_warn(mi.span, "feature has been added to Rust, \
- directive not necessary");
+ accepted_features.push(mi.span);
}
None => {
unknown_features.push((name, mi.span));
old_orphan_check: cx.has_feature("old_orphan_check"),
simd_ffi: cx.has_feature("simd_ffi"),
unmarked_api: cx.has_feature("unmarked_api"),
- lib_features: unknown_features
+ declared_stable_lang_features: accepted_features,
+ declared_lib_features: unknown_features
}
}
fld: &mut T)
-> WherePredicate {
match pred {
- ast::WherePredicate::BoundPredicate(ast::WhereBoundPredicate{bounded_ty,
+ ast::WherePredicate::BoundPredicate(ast::WhereBoundPredicate{bound_lifetimes,
+ bounded_ty,
bounds,
span}) => {
ast::WherePredicate::BoundPredicate(ast::WhereBoundPredicate {
+ bound_lifetimes: fld.fold_lifetime_defs(bound_lifetimes),
bounded_ty: fld.fold_ty(bounded_ty),
bounds: bounds.move_map(|x| fld.fold_ty_param_bound(x)),
span: fld.new_span(span)
pub fn noop_fold_poly_trait_ref<T: Folder>(p: PolyTraitRef, fld: &mut T) -> PolyTraitRef {
ast::PolyTraitRef {
bound_lifetimes: fld.fold_lifetime_defs(p.bound_lifetimes),
- trait_ref: fld.fold_trait_ref(p.trait_ref)
+ trait_ref: fld.fold_trait_ref(p.trait_ref),
+ span: fld.new_span(p.span),
}
}
}
pub fn float_lit(s: &str, suffix: Option<&str>, sd: &SpanHandler, sp: Span) -> ast::Lit_ {
debug!("float_lit: {:?}, {:?}", s, suffix);
- // FIXME #2252: bounds checking float literals is defered until trans
+ // FIXME #2252: bounds checking float literals is deferred until trans
let s = s.chars().filter(|&c| c != '_').collect::<String>();
let data = token::intern_and_get_ident(&*s);
filtered_float_lit(data, suffix, sd, sp)
let source = "/// doc comment\r\nfn foo() {}".to_string();
let item = parse_item_from_source_str(name.clone(), source, Vec::new(), &sess).unwrap();
let doc = first_attr_value_str_by_name(&item.attrs, "doc").unwrap();
- assert_eq!(doc.get(), "/// doc comment");
+ assert_eq!(&doc[], "/// doc comment");
let source = "/// doc comment\r\n/// line 2\r\nfn foo() {}".to_string();
let item = parse_item_from_source_str(name.clone(), source, Vec::new(), &sess).unwrap();
- let docs = item.attrs.iter().filter(|a| a.name().get() == "doc")
- .map(|a| a.value_str().unwrap().get().to_string()).collect::<Vec<_>>();
+ let docs = item.attrs.iter().filter(|a| &a.name()[] == "doc")
+ .map(|a| a.value_str().unwrap().to_string()).collect::<Vec<_>>();
let b: &[_] = &["/// doc comment".to_string(), "/// line 2".to_string()];
assert_eq!(&docs[], b);
let source = "/** doc comment\r\n * with CRLF */\r\nfn foo() {}".to_string();
let item = parse_item_from_source_str(name, source, Vec::new(), &sess).unwrap();
let doc = first_attr_value_str_by_name(&item.attrs, "doc").unwrap();
- assert_eq!(doc.get(), "/** doc comment\n * with CRLF */");
+ assert_eq!(&doc[], "/** doc comment\n * with CRLF */");
}
#[test]
let span = tts.iter().rev().next().unwrap().get_span();
match sess.span_diagnostic.cm.span_to_snippet(span) {
- Some(s) => assert_eq!(&s[], "{ body }"),
- None => panic!("could not get snippet"),
+ Ok(s) => assert_eq!(&s[], "{ body }"),
+ Err(_) => panic!("could not get snippet"),
}
}
}
"use a `move ||` expression instead",
),
ObsoleteSyntax::ClosureType => (
- "`|usize| -> bool` closure type syntax",
+ "`|usize| -> bool` closure type",
"use unboxed closures instead, no type annotation needed"
),
ObsoleteSyntax::ClosureKind => (
- "`:`, `&mut:`, or `&:` syntax",
+ "`:`, `&mut:`, or `&:`",
"rely on inference instead"
),
ObsoleteSyntax::Sized => (
- "`Sized? T` syntax for removing the `Sized` bound",
+ "`Sized? T` for removing the `Sized` bound",
"write `T: ?Sized` instead"
),
};
*/
// parse <'lt>
+ let lo = self.span.lo;
+
let lifetime_defs = self.parse_late_bound_lifetime_defs();
// examine next token to decide to do
self.token.is_ident() ||
self.token.is_path()
{
+ let hi = self.span.hi;
let trait_ref = self.parse_trait_ref();
let poly_trait_ref = ast::PolyTraitRef { bound_lifetimes: lifetime_defs,
- trait_ref: trait_ref };
+ trait_ref: trait_ref,
+ span: mk_sp(lo, hi)};
let other_bounds = if self.eat(&token::BinOp(token::Plus)) {
self.parse_ty_param_bounds(BoundParsingMode::Bare)
} else {
if let Some(unbound) = unbound {
let mut bounds_as_vec = bounds.into_vec();
bounds_as_vec.push(TraitTyParamBound(PolyTraitRef { bound_lifetimes: vec![],
- trait_ref: unbound },
+ trait_ref: unbound,
+ span: span },
TraitBoundModifier::Maybe));
bounds = OwnedSlice::from_vec(bounds_as_vec);
};
}
_ => {
+ let bound_lifetimes = if self.eat_keyword(keywords::For) {
+ // Higher ranked constraint.
+ self.expect(&token::Lt);
+ let lifetime_defs = self.parse_lifetime_defs();
+ self.expect_gt();
+ lifetime_defs
+ } else {
+ vec![]
+ };
+
let bounded_ty = self.parse_ty();
if self.eat(&token::Colon) {
if bounds.len() == 0 {
self.span_err(span,
"each predicate in a `where` clause must have \
- at least one bound in it");
+ at least one bound in it");
}
generics.where_clause.predicates.push(ast::WherePredicate::BoundPredicate(
ast::WhereBoundPredicate {
span: span,
+ bound_lifetimes: bound_lifetimes,
bounded_ty: bounded_ty,
bounds: bounds,
}));
/// Parse trait Foo { ... }
fn parse_item_trait(&mut self, unsafety: Unsafety) -> ItemInfo {
+
let ident = self.parse_ident();
let mut tps = self.parse_generics();
+ // This is not very accurate, but since unbound only exists to catch
+ // obsolete syntax, the span is unlikely to ever be used.
+ let unbound_span = self.span;
let unbound = self.parse_for_sized();
// Parse supertrait bounds.
if let Some(unbound) = unbound {
let mut bounds_as_vec = bounds.into_vec();
bounds_as_vec.push(TraitTyParamBound(PolyTraitRef { bound_lifetimes: vec![],
- trait_ref: unbound },
+ trait_ref: unbound,
+ span: unbound_span },
TraitBoundModifier::Maybe));
bounds = OwnedSlice::from_vec(bounds_as_vec);
};
/// Parse for<'l> a::B<String,i32>
fn parse_poly_trait_ref(&mut self) -> PolyTraitRef {
+ let lo = self.span.lo;
let lifetime_defs = self.parse_late_bound_lifetime_defs();
ast::PolyTraitRef {
bound_lifetimes: lifetime_defs,
- trait_ref: self.parse_trait_ref()
+ trait_ref: self.parse_trait_ref(),
+ span: mk_sp(lo, self.last_span.hi),
}
}
outer_attrs, "path") {
Some(d) => (dir_path.join(d), true),
None => {
- let mod_name = mod_string.get().to_string();
+ let mod_name = mod_string.to_string();
let default_path_str = format!("{}.rs", mod_name);
let secondary_path_str = format!("{}/mod.rs", mod_name);
let default_path = dir_path.join(&default_path_str[]);
self.span_err(id_sp,
"cannot declare a new module at this location");
let this_module = match self.mod_path_stack.last() {
- Some(name) => name.get().to_string(),
+ Some(name) => name.to_string(),
None => self.root_module_name.as_ref().unwrap().clone(),
};
self.span_note(id_sp,
};
self.eval_src_mod_from_path(file_path, owns_directory,
- mod_string.get().to_string(), id_sp)
+ mod_string.to_string(), id_sp)
}
fn eval_src_mod_from_path(&mut self,
string: string,
}
}
-
- #[inline]
- pub fn get<'a>(&'a self) -> &'a str {
- &self.string[]
- }
}
impl Deref for InternedString {
// of `BytesContainer`, which is itself a workaround for the lack of
// DST.
unsafe {
- let this = self.get();
+ let this = &self[];
mem::transmute::<&[u8],&[u8]>(this.container_as_bytes())
}
}
use ast::{MethodImplItem, RegionTyParamBound, TraitTyParamBound, TraitBoundModifier};
use ast::{RequiredMethod, ProvidedMethod, TypeImplItem, TypeTraitItem};
use ast_util;
+use attr;
use owned_slice::OwnedSlice;
use attr::{AttrMetaMethods, AttributeMethods};
use codemap::{self, CodeMap, BytePos};
use diagnostic;
-use parse::token::{self, BinOpToken, Token};
+use parse::token::{self, BinOpToken, Token, InternedString};
use parse::lexer::comments;
use parse;
use print::pp::{self, break_offset, word, space, zerobreak, hardbreak};
use print::pp::{Breaks, eof};
use print::pp::Breaks::{Consistent, Inconsistent};
use ptr::P;
+use std_inject;
use std::{ascii, mem};
use std::old_io::{self, IoResult};
out,
ann,
is_expanded);
+ if is_expanded && std_inject::use_std(krate) {
+ // We need to print `#![no_std]` (and its feature gate) so that
+ // compiling pretty-printed source won't inject libstd again.
+ // However we don't want these attributes in the AST because
+ // of the feature gate, so we fake them up here.
+
+ let no_std_meta = attr::mk_word_item(InternedString::new("no_std"));
+
+ // #![feature(no_std)]
+ let fake_attr = attr::mk_attr_inner(attr::mk_attr_id(),
+ attr::mk_list_item(InternedString::new("feature"),
+ vec![no_std_meta.clone()]));
+ try!(s.print_attribute(&fake_attr));
+
+ // #![no_std]
+ let fake_attr = attr::mk_attr_inner(attr::mk_attr_id(), no_std_meta);
+ try!(s.print_attribute(&fake_attr));
+ }
+
try!(s.print_mod(&krate.module, &krate.attrs[]));
try!(s.print_remaining_comments());
eof(&mut s.s)
}
/* Name components */
- token::Ident(s, _) => token::get_ident(s).get().to_string(),
+ token::Ident(s, _) => token::get_ident(s).to_string(),
token::Lifetime(s) => format!("{}", token::get_ident(s)),
token::Underscore => "_".to_string(),
try!(self.head(&visibility_qualified(item.vis,
"extern crate")[]));
if let Some((ref p, style)) = *optional_path {
- try!(self.print_string(p.get(), style));
+ try!(self.print_string(p, style));
try!(space(&mut self.s));
try!(word(&mut self.s, "as"));
try!(space(&mut self.s));
self.print_path(&t.path, false)
}
- fn print_poly_trait_ref(&mut self, t: &ast::PolyTraitRef) -> IoResult<()> {
- if !t.bound_lifetimes.is_empty() {
+ fn print_formal_lifetime_list(&mut self, lifetimes: &[ast::LifetimeDef]) -> IoResult<()> {
+ if !lifetimes.is_empty() {
try!(word(&mut self.s, "for<"));
let mut comma = false;
- for lifetime_def in &t.bound_lifetimes {
+ for lifetime_def in lifetimes {
if comma {
try!(self.word_space(","))
}
}
try!(word(&mut self.s, ">"));
}
+ Ok(())
+ }
+ fn print_poly_trait_ref(&mut self, t: &ast::PolyTraitRef) -> IoResult<()> {
+ try!(self.print_formal_lifetime_list(&t.bound_lifetimes));
self.print_trait_ref(&t.trait_ref)
}
try!(self.hardbreak_if_not_bol());
try!(self.maybe_print_comment(attr.span.lo));
if attr.node.is_sugared_doc {
- word(&mut self.s, attr.value_str().unwrap().get())
+ word(&mut self.s, &attr.value_str().unwrap())
} else {
match attr.node.style {
ast::AttrInner => try!(word(&mut self.s, "#![")),
ast::ExprInlineAsm(ref a) => {
try!(word(&mut self.s, "asm!"));
try!(self.popen());
- try!(self.print_string(a.asm.get(), a.asm_str_style));
+ try!(self.print_string(&a.asm, a.asm_str_style));
try!(self.word_space(":"));
try!(self.commasep(Inconsistent, &a.outputs[],
|s, &(ref co, ref o, is_rw)| {
- match co.get().slice_shift_char() {
+ match co.slice_shift_char() {
Some(('=', operand)) if is_rw => {
try!(s.print_string(&format!("+{}", operand)[],
ast::CookedStr))
}
- _ => try!(s.print_string(co.get(), ast::CookedStr))
+ _ => try!(s.print_string(&co, ast::CookedStr))
}
try!(s.popen());
try!(s.print_expr(&**o));
try!(self.commasep(Inconsistent, &a.inputs[],
|s, &(ref co, ref o)| {
- try!(s.print_string(co.get(), ast::CookedStr));
+ try!(s.print_string(&co, ast::CookedStr));
try!(s.popen());
try!(s.print_expr(&**o));
try!(s.pclose());
try!(self.commasep(Inconsistent, &a.clobbers[],
|s, co| {
- try!(s.print_string(co.get(), ast::CookedStr));
+ try!(s.print_string(&co, ast::CookedStr));
Ok(())
}));
let encoded = ident.encode_with_hygiene();
try!(word(&mut self.s, &encoded[]))
} else {
- try!(word(&mut self.s, token::get_ident(ident).get()))
+ try!(word(&mut self.s, &token::get_ident(ident)))
}
self.ann.post(self, NodeIdent(&ident))
}
}
pub fn print_name(&mut self, name: ast::Name) -> IoResult<()> {
- try!(word(&mut self.s, token::get_name(name).get()));
+ try!(word(&mut self.s, &token::get_name(name)));
self.ann.post(self, NodeName(&name))
}
}
match predicate {
- &ast::WherePredicate::BoundPredicate(ast::WhereBoundPredicate{ref bounded_ty,
+ &ast::WherePredicate::BoundPredicate(ast::WhereBoundPredicate{ref bound_lifetimes,
+ ref bounded_ty,
ref bounds,
..}) => {
+ try!(self.print_formal_lifetime_list(bound_lifetimes));
try!(self.print_type(&**bounded_ty));
try!(self.print_bounds(":", bounds));
}
try!(self.ibox(indent_unit));
match item.node {
ast::MetaWord(ref name) => {
- try!(word(&mut self.s, name.get()));
+ try!(word(&mut self.s, &name));
}
ast::MetaNameValue(ref name, ref value) => {
- try!(self.word_space(name.get()));
+ try!(self.word_space(&name[]));
try!(self.word_space("="));
try!(self.print_literal(value));
}
ast::MetaList(ref name, ref items) => {
- try!(word(&mut self.s, name.get()));
+ try!(word(&mut self.s, &name));
try!(self.popen());
try!(self.commasep(Consistent,
&items[],
_ => ()
}
match lit.node {
- ast::LitStr(ref st, style) => self.print_string(st.get(), style),
+ ast::LitStr(ref st, style) => self.print_string(&st, style),
ast::LitByte(byte) => {
let mut res = String::from_str("b'");
ascii::escape_default(byte, |c| res.push(c as char));
word(&mut self.s,
&format!(
"{}{}",
- f.get(),
+ &f,
&ast_util::float_ty_to_string(t)[])[])
}
- ast::LitFloatUnsuffixed(ref f) => word(&mut self.s, f.get()),
+ ast::LitFloatUnsuffixed(ref f) => word(&mut self.s, &f[]),
ast::LitBool(val) => {
if val { word(&mut self.s, "true") } else { word(&mut self.s, "false") }
}
}
}
-fn use_std(krate: &ast::Crate) -> bool {
+pub fn use_std(krate: &ast::Crate) -> bool {
!attr::contains_name(&krate.attrs[], "no_std")
}
span: DUMMY_SP
}));
- // don't add #![no_std] here, that will block the prelude injection later.
- // Add it during the prelude injection instead.
-
krate
}
}
impl<'a> fold::Folder for PreludeInjector<'a> {
fn fold_crate(&mut self, mut krate: ast::Crate) -> ast::Crate {
- // Add #![no_std] here, so we don't re-inject when compiling pretty-printed source.
- // This must happen here and not in StandardLibraryInjector because this
- // fold happens second.
-
- let no_std_attr = attr::mk_attr_inner(attr::mk_attr_id(),
- attr::mk_word_item(InternedString::new("no_std")));
- // std_inject runs after feature checking so manually mark this attr
- attr::mark_used(&no_std_attr);
- krate.attrs.push(no_std_attr);
-
// only add `use std::prelude::*;` if there wasn't a
// `#![no_implicit_prelude]` at the crate level.
// fold_mod() will insert glob path.
});
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());
+ let reexport_ident = token::str_to_ident(&s);
let use_path =
nospan(ast::ViewPathSimple(reexport_ident,
fn is_test_crate(krate: &ast::Crate) -> bool {
match attr::find_crate_name(&krate.attrs[]) {
- Some(ref s) if "test" == &s.get()[] => true,
+ Some(ref s) if "test" == &s[] => true,
_ => false
}
}
html_favicon_url = "http://www.rust-lang.org/favicon.ico",
html_root_url = "http://doc.rust-lang.org/nightly/",
html_playground_url = "http://play.rust-lang.org/")]
+#![feature(no_std)]
#![no_std]
#![feature(slicing_syntax)]
#![feature(int_uint)]
pub use u_str::{utf16_items, Utf16Encoder};
}
+// NOTE: remove after next snapshot
// this lets us use #[derive(..)]
+#[cfg(stage0)]
mod std {
pub use core::clone;
pub use core::cmp;
#include <sys/sysctl.h>
#include <limits.h>
-const char * rust_load_self() {
+const char * rust_current_exe() {
static char *self = NULL;
if (self == NULL) {
// of each of the sections.
// It works by extracting the current page based on the url and iterates over
// the menu links until it finds the menu item for the current page. We then
- // create a copy of the preceeding and following menu links and add the
+ // create a copy of the preceding and following menu links and add the
// correct css class and insert them into the bottom of the page.
var toc = document.getElementById('toc').getElementsByTagName('a');
var href = document.location.pathname.split('/').pop();
--- /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.
+
+// include file for issue-21146.rs
+
+parse_error
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#![feature(no_std)]
#![no_std]
#![feature(lang_items)]
fn check_item(&mut self, cx: &Context, it: &ast::Item) {
let name = token::get_ident(it.ident);
- if name.get() == "lintme" {
+ if &name[] == "lintme" {
cx.span_lint(TEST_LINT, it.span, "item is named 'lintme'");
- } else if name.get() == "pleaselintme" {
+ } else if &name[] == "pleaselintme" {
cx.span_lint(PLEASE_LINT, it.span, "item is named 'pleaselintme'");
}
}
fn check_item(&mut self, cx: &Context, it: &ast::Item) {
let name = token::get_ident(it.ident);
- if name.get() == "lintme" {
+ if &name[] == "lintme" {
cx.span_lint(TEST_LINT, it.span, "item is named 'lintme'");
}
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#![feature(no_std)]
#![no_std]
pub fn foo() {}
use rustc::plugin::Registry;
struct Expander {
- args: P<ast::MetaItem>,
+ args: Vec<P<ast::MetaItem>>,
}
impl TTMacroExpander for Expander {
ecx: &'cx mut ExtCtxt,
sp: Span,
_: &[ast::TokenTree]) -> Box<MacResult+'cx> {
-
- let attr = ecx.attribute(sp, self.args.clone());
- let src = pprust::attribute_to_string(&attr);
- let interned = token::intern_and_get_ident(&src);
+ let args = self.args.iter().map(|i| pprust::meta_item_to_string(&*i))
+ .collect::<Vec<_>>().connect(", ");
+ let interned = token::intern_and_get_ident(&args[]);
MacExpr::new(ecx.expr_str(sp, interned))
}
}
+++ /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.
-
-// force-host
-
-#![crate_type = "dylib"]
-
-pub fn the_answer() -> int {
- 2
-}
+++ /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.
-
-// force-host
-
-#![crate_type = "dylib"]
-#![feature(plugin_registrar, quote)]
-
-extern crate "syntax-extension-with-dll-deps-1" as other;
-extern crate syntax;
-extern crate rustc;
-
-use syntax::ast::{TokenTree, Item, MetaItem};
-use syntax::codemap::Span;
-use syntax::ext::base::*;
-use rustc::plugin::Registry;
-
-#[plugin_registrar]
-pub fn plugin_registrar(reg: &mut Registry) {
- reg.register_macro("foo", expand_foo);
-}
-
-fn expand_foo(cx: &mut ExtCtxt, sp: Span, tts: &[TokenTree])
- -> Box<MacResult+'static> {
- let answer = other::the_answer();
- MacExpr::new(quote_expr!(cx, $answer))
-}
--- /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.
+
+// force-host
+
+#![crate_type = "dylib"]
+
+pub fn the_answer() -> int {
+ 2
+}
--- /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.
+
+// force-host
+
+#![crate_type = "dylib"]
+#![feature(plugin_registrar, quote)]
+
+extern crate "syntax_extension_with_dll_deps_1" as other;
+extern crate syntax;
+extern crate rustc;
+
+use syntax::ast::{TokenTree, Item, MetaItem};
+use syntax::codemap::Span;
+use syntax::ext::base::*;
+use rustc::plugin::Registry;
+
+#[plugin_registrar]
+pub fn plugin_registrar(reg: &mut Registry) {
+ reg.register_macro("foo", expand_foo);
+}
+
+fn expand_foo(cx: &mut ExtCtxt, sp: Span, tts: &[TokenTree])
+ -> Box<MacResult+'static> {
+ let answer = other::the_answer();
+ MacExpr::new(quote_expr!(cx, $answer))
+}
// This aux-file will require the eh_personality function to be codegen'd, but
// it hasn't been defined just yet. Make sure we don't explode.
+#![feature(no_std)]
#![no_std]
#![crate_type = "rlib"]
}
}
- /// Retreives the complement for `i`.
+ /// Retrieves the complement for `i`.
fn cpl8(&self, i: u8) -> u8 {
self.table8[i as uint]
}
- /// Retreives the complement for `i`.
+ /// Retrieves the complement for `i`.
fn cpl16(&self, i: u16) -> u16 {
self.table16[i as uint]
}
// aux-build:macro_crate_test.rs
// ignore-stage1
-#[plugin] #[no_link] extern crate macro_crate_test;
+#![plugin(macro_crate_test)]
//~^ ERROR compiler plugins are experimental and possibly buggy
fn main() {}
// compile-flags: -D lint-me
#![feature(plugin)]
-
-#[plugin] #[no_link]
-extern crate lint_group_plugin_test;
+#![plugin(lint_group_plugin_test)]
fn lintme() { } //~ ERROR item is named 'lintme'
// ignore-stage1
#![feature(plugin)]
+#![plugin(lint_plugin_test)]
#![deny(test_lint)]
-#[plugin] #[no_link]
-extern crate lint_plugin_test;
-
fn lintme() { } //~ ERROR item is named 'lintme'
pub fn main() {
// compile-flags: -D test-lint
#![feature(plugin)]
-
-#[plugin] #[no_link]
-extern crate lint_plugin_test;
+#![plugin(lint_plugin_test)]
fn lintme() { } //~ ERROR item is named 'lintme'
// ignore-stage1
#![feature(plugin)]
+#![plugin(lint_plugin_test)]
#![forbid(test_lint)]
-#[plugin] #[no_link]
-extern crate lint_plugin_test;
-
fn lintme() { } //~ ERROR item is named 'lintme'
#[allow(test_lint)] //~ ERROR allow(test_lint) overruled by outer forbid(test_lint)
// compile-flags: -F test-lint
#![feature(plugin)]
-
-#[plugin] #[no_link]
-extern crate lint_plugin_test;
+#![plugin(lint_plugin_test)]
fn lintme() { } //~ ERROR item is named 'lintme'
// ident form.
#![feature(plugin)]
-
-#[plugin] #[no_link]
-extern crate macro_crate_test;
+#![plugin(macro_crate_test)]
fn main() {
let x = 0;
// ignore-cross-compile gives a different error message
#![feature(plugin)]
-#[plugin] #[no_link] extern crate rlib_crate_test;
+#![plugin(rlib_crate_test)]
//~^ ERROR: plugin crate `rlib_crate_test` only found in rlib format, but must be available in dylib format
fn main() {}
// error-pattern: plugin tried to register a new MacroRulesTT
#![feature(plugin)]
-
-#[plugin] #[no_link]
-extern crate macro_crate_MacroRulesTT;
+#![plugin(macro_crate_MacroRulesTT)]
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.
-
-// Test that the old fixed length array syntax is a parsing error.
-
-fn main() {
- let _x: [isize, ..3] = [0, 1, 2]; //~ ERROR
-}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// Test associated types are forbidden in inherant impls.
+// Test associated types are forbidden in inherent impls.
struct Foo;
#![crate_type = "lib"]
#![feature(lang_items)]
+#![feature(no_std)]
#![no_std]
#[lang="sized"]
+++ /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.
-
-// Test you can't use a higher-ranked trait bound inside of a qualified
-// path (just won't parse).
-
-pub trait Foo<T> {
- type A;
-
- fn get(&self, t: T) -> Self::A;
-}
-
-fn foo2<I>(x: <I as for<'x> Foo<&'x isize>>::A)
- //~^ ERROR expected identifier, found keyword `for`
- //~| ERROR expected one of `::` or `>`
-{
-}
-
-pub fn main() {}
+++ /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.
-
-// error-pattern:expected `]`
-
-// asterisk is bogus
-#[attr*]
-mod m {}
+++ /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.
-
-// error-pattern: expected
-
-fn main() {
- let isize x = 5;
- match x;
-}
-
-fn main() {
-}
// ignore-tidy-linelength
+#![feature(no_std)]
#![no_std]
#![feature(lang_items)]
+++ /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.
-
-// error-pattern: expected
-
-fn main() {
- let x.y::<isize>.z foo;
-}
+++ /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: [isize 3]; //~ ERROR expected one of `(`, `+`, `::`, `;`, `<`, or `]`, found `3`
-}
+++ /dev/null
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-fn main() {
- struct Foo { x: isize }
- match (Foo { x: 10 }) {
- Foo { ref x: ref x } => {}, //~ ERROR expected `,`, found `:`
- _ => {}
- }
-}
+++ /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.
-
-#![allow(unknown_features)]
-#![feature(box_syntax)]
-
-fn f() {
- let mut a = [box 0, box 1];
- drop(a[0]);
- a[1] = box 2;
- drop(a[0]); //~ ERROR use of moved value: `a[..]`
-}
-
-fn main() {
- f();
-}
-
}
impl IndexMut<String> for Foo {
- type Output = isize;
-
fn index_mut<'a>(&'a mut self, z: &String) -> &'a mut isize {
if *z == "x" {
&mut self.x
}
impl IndexMut<String> for Foo {
- type Output = isize;
-
fn index_mut<'a>(&'a mut self, z: &String) -> &'a mut isize {
if *z == "x" {
&mut self.x
fn test() {
let w: &mut [isize];
- w[5] = 0; //~ ERROR use of possibly uninitialized variable: `w`
+ w[5] = 0; //~ ERROR use of possibly uninitialized variable: `*w`
let mut w: &mut [isize];
- w[5] = 0; //~ ERROR use of possibly uninitialized variable: `w`
+ w[5] = 0; //~ ERROR use of possibly uninitialized variable: `*w`
}
fn main() { test(); }
[1, 2, tail..] => tail,
_ => unreachable!()
};
- a[0] = 0; //~ ERROR cannot assign to `a[..]` because it is borrowed
+ println!("t[0]: {}", t[0]);
+ a[2] = 0; //~ ERROR cannot assign to `a[..]` because it is borrowed
+ println!("t[0]: {}", t[0]);
t[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.
-
-
-// ignore-tidy-tab
-
-static FOO: u8 = b'\f'; //~ ERROR unknown byte escape
-
-pub fn main() {
- b'\f'; //~ ERROR unknown byte escape
- b'\x0Z'; //~ ERROR illegal character in numeric character escape: Z
- b' '; //~ ERROR byte constant must be escaped
- b'''; //~ ERROR byte constant must be escaped
- b'é'; //~ ERROR byte constant must be ASCII
- b'a //~ ERROR unterminated byte constant
-}
-
-
+++ /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-tab
-
-static FOO: &'static [u8] = b"\f"; //~ ERROR unknown byte escape
-
-pub fn main() {
- b"\f"; //~ ERROR unknown byte escape
- b"\x0Z"; //~ ERROR illegal character in numeric character escape: Z
- b"é"; //~ ERROR byte constant must be ASCII
- b"a //~ ERROR unterminated double quote byte string
-}
-
-
+++ /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-test: this is an auxiliary file for circular-modules-main.rs
-
-mod circular_modules_main;
-
-pub fn say_hello() {
- println!("{}", circular_modules_main::hi_str());
-}
+++ /dev/null
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#[path = "circular_modules_hello.rs"]
-mod circular_modules_hello; //~ERROR: circular modules
-
-pub fn hi_str() -> String {
- "Hi!".to_string()
-}
-
-fn main() {
- circular_modules_hello::say_hello();
-}
+++ /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.
-
-// error-pattern:nonexistent
-class cat : nonexistent {
- let meows: usize;
- new(in_x : usize) { self.meows = in_x; }
-}
-
-fn main() {
- let nyan = cat(0us);
-}
+++ /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.
-
-# //~ ERROR 11:1: 11:2 error: expected one of `!` or `[`, found `<eof>`
--- /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.
+
+#![feature(no_std)]
+#![no_std]
+
+extern crate core;
+extern crate rand;
+extern crate "serialize" as rustc_serialize;
+
+#[derive(Rand)] //~ ERROR this trait cannot be derived
+//~^ WARNING `#[derive(Rand)]` is deprecated
+struct Foo {
+ x: u32,
+}
+
+#[derive(RustcEncodable)] //~ ERROR this trait cannot be derived
+struct Bar {
+ x: u32,
+}
+
+#[derive(RustcDecodable)] //~ ERROR this trait cannot be derived
+struct Baz {
+ x: u32,
+}
+
+fn main() {
+ Foo { x: 0 };
+ Bar { x: 0 };
+ Baz { x: 0 };
+}
+++ /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.
-
-// error-pattern:unmatched visibility `pub`
-extern {
- pub pub fn foo();
-}
+++ /dev/null
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-impl Foo; //~ ERROR expected one of `(`, `+`, `::`, `<`, `for`, `where`, or `{`, found `;`
+++ /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.
-
-// Verifies that the expected token errors for `extern crate` are
-// raised
-
-extern "C" mod foo; //~ERROR expected `{` or `fn`, found `mod`
+++ /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.
-
-// Verifies that the expected token errors for `extern crate` are
-// raised
-
-extern crate foo {} //~ERROR expected `;`, found `{`
+++ /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.
-
-extern {
- f(); //~ ERROR expected one of `fn`, `pub`, `static`, `unsafe`, or `}`, found `f`
-}
-
-fn main() {
-}
#![feature = "foo"] //~ ERROR: malformed feature
#![feature(test_removed_feature)] //~ ERROR: feature has been removed
-#![feature(test_accepted_feature)] //~ WARNING: feature has been added
--- /dev/null
+// Copyright 2105 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.
+
+#![no_std] //~ ERROR no_std is experimental
+
+fn main() {}
+++ /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.
-
-// error-pattern:expected
-use foo::{bar}::baz
+++ /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.
-
-// error-pattern:expected
-
-use foo::{bar} as baz;
-
-mod foo {
- pub fn bar() {}
-}
-
-fn main() {
-}
+++ /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.
-
-// error-pattern:expected
-use foo::*::bar
+++ /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.
-
-// error-pattern:expected
-
-use foo::* as baz;
-
-mod foo {
- pub fn bar() {}
-}
-
-fn main() {
-}
+++ /dev/null
-// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-struct A { foo: isize }
-
-fn a() -> A { panic!() }
-
-fn main() {
- let A { .., } = a(); //~ ERROR: expected `}`
-}
-
+++ /dev/null
-// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-struct A { foo: isize }
-
-fn a() -> A { panic!() }
-
-fn main() {
- let A { , } = a(); //~ ERROR: expected ident
-}
+++ /dev/null
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-struct Obj { //~ NOTE: unclosed delimiter
- member: usize
-) //~ ERROR: incorrect close delimiter
+++ /dev/null
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-pub fn trace_option(option: Option<isize>) {
- option.map(|some| 42; //~ NOTE: unclosed delimiter
-} //~ ERROR: incorrect close delimiter
+++ /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.
-
-enum X<'a, T, 'b> {
-//~^ ERROR lifetime parameters must be declared prior to type parameters
- A(&'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.
-
-fn foo<'a, T, 'b>(x: &'a T) {}
-//~^ ERROR lifetime parameters must be declared prior to type parameters
+++ /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() {
- (0..4)
- .map(|x| x * 2)
- .collect::<Vec<'a, usize, 'b>>()
- //~^ ERROR lifetime parameters must be declared prior to type parameters
-}
+++ /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.
-
-struct X { x: isize }
-
-impl<'a, T, 'b> X {}
-//~^ ERROR lifetime parameters must be declared prior to type parameters
+++ /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 bar<'a, T>(x: mymodule::X<'a, T, 'b, 'c>) {}
-//~^ ERROR lifetime parameters must be declared prior to type parameters
+++ /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.
-
-struct X<'a, T, 'b> {
-//~^ ERROR lifetime parameters must be declared prior to type parameters
- x: &'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.
-
-trait Foo<'a, T, 'b> {}
-//~^ ERROR lifetime parameters must be declared prior to type parameters
+++ /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 ref
- (); //~ ERROR expected identifier, found `(`
-}
+++ /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.
-
-// error-pattern:expected one of `!` or `[`, found `vec`
-mod blade_runner {
- #vec[doc(
- brief = "Blade Runner is probably the best movie ever",
- desc = "I like that in the world of Blade Runner it is always
- raining, and that it's always night time. And Aliens
- was also a really good movie.
-
- Alien 3 was crap though."
- )]
-}
+++ /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.
-
-struct Baz<U> where U: Eq(U); //This is parsed as the new Fn* style parenthesis syntax.
-struct Baz<U> where U: Eq(U) -> R; // Notice this parses as well.
-struct Baz<U>(U) where U: Eq; // This rightfully signals no error as well.
-struct Foo<T> where T: Copy, (T); //~ ERROR unexpected token in `where` clause
-struct Bar<T> { x: T } where T: Copy //~ ERROR expected item, found `where`
-
-fn main() {}
+++ /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.
-
-// error-pattern:no valid digits found for number
-fn main() {
- log(error, 0b42);
-}
+++ /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.
-
-fn main() {
- let t = (42, 42);
- t.0::<isize>; //~ ERROR expected one of `.`, `;`, `}`, or an operator, found `::`
-}
+++ /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 T {
- extern "Rust" unsafe fn foo(); //~ ERROR expected `fn`, found `unsafe`
-}
-
-fn main() {}
// error-pattern: requires `copy` lang_item
-#![feature(lang_items, start)]
+#![feature(lang_items, start, no_std)]
#![no_std]
#[lang = "sized"]
+++ /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.
-
-struct Foo;
-
-impl Foo {
- fn foo() {}
-
- #[stable(feature = "rust1", since = "1.0.0")]
-} //~ ERROR expected one of `extern`, `fn`, `pub`, `type`, or `unsafe`, found `}`
-
-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.
-
-struct Foo;
-
-impl Foo {
- #[stable(feature = "rust1", since = "1.0.0")]
-} //~ ERROR expected one of `extern`, `fn`, `pub`, `type`, or `unsafe`, found `}`
-
-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.
+
+// error-pattern: expected item, found `parse_error`
+include!("../auxiliary/issue-21146-inc.rs");
+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.
-
-trait MyTrait<T>: Iterator {
- Item = T; //~ ERROR expected one of `extern`, `fn`, `pub`, `type`, or `unsafe`, found `Item`
-}
--- /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.
+
+// Test that (for now) we report an ambiguity error here, because
+// specific trait relationships are ignored for the purposes of trait
+// matching. This behavior should likely be improved such that this
+// test passes. See #21974 for more details.
+
+trait Foo {
+ fn foo(self);
+}
+
+fn foo<'a,'b,T>(x: &'a T, y: &'b T)
+ where &'a T : Foo,
+ &'b T : Foo
+{
+ x.foo(); //~ ERROR type annotations required
+ y.foo();
+}
+
+fn main() { }
+++ /dev/null
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-static foo: isize = 2; } //~ ERROR incorrect close delimiter:
-
+++ /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.
-
-fn foo() { //~ HELP did you mean to close this delimiter?
- match Some(x) {
- Some(y) { panic!(); }
- None { panic!(); }
-}
-
-fn bar() {
- let mut i = 0;
- while (i < 1000) {}
-}
-
-fn main() {} //~ ERROR this file contains an un-closed delimiter
+++ /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.
-
-// Testing that semicolon tokens are printed correctly in errors
-
-fn main()
-{
- let x = 3
-} //~ ERROR: expected one of `.`, `;`, or an operator, found `}`
+++ /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.
-
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#[path = "../compile-fail"]
-mod foo; //~ ERROR: a directory
-
-fn main() {}
+++ /dev/null
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-trait Foo { fn a() } //~ ERROR expected `;` or `{`, found `}`
-
-fn main() {}
use std::cell::RefCell;
-// Regresion test for issue 7364
+// Regression test for issue 7364
static boxed: Box<RefCell<isize>> = box RefCell::new(0);
//~^ ERROR statics are not allowed to have custom pointers
//~| ERROR: the trait `core::marker::Sync` is not implemented for the type
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// Regresion test for issue 9243
+// Regression test for issue 9243
struct Test {
mem: isize,
+++ /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 abstract = (); //~ ERROR `abstract` is a reserved keyword
-}
+++ /dev/null
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-fn main() {
- let do = "bar"; //~ error: ident
-}
+++ /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 final = (); //~ ERROR `final` is a reserved keyword
-}
+++ /dev/null
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// This file was auto-generated using 'src/etc/generate-keyword-tests.py mut'
-
-fn main() {
- let mut = "foo"; //~ error: ident
-}
+++ /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 override = (); //~ ERROR `override` is a reserved keyword
-}
+++ /dev/null
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// This file was auto-generated using 'src/etc/generate-keyword-tests.py priv'
-
-fn main() {
- let priv = "foo"; //~ error: ident
-}
+++ /dev/null
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// This file was auto-generated using 'src/etc/generate-keyword-tests.py ref'
-
-fn main() {
- let ref = "foo"; //~ error: ident
-}
+++ /dev/null
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-fn main() {
- let typeof = (); //~ ERROR `typeof` is a reserved keyword
-}
// error-pattern: requires `sized` lang_item
+#![feature(start, no_std)]
#![no_std]
-#![feature(start)]
#[start]
fn start(argc: isize, argv: *const *const u8) -> isize {
+++ /dev/null
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-static c: char =
- '\u539_' //~ ERROR: illegal character in numeric character escape
- //~^ WARNING: \uABCD escapes are deprecated
-;
-
-static c2: char =
- '\Uffffffff' //~ ERROR: illegal numeric character escape
- //~^ WARNING: \uABCD escapes are deprecated
-;
-
-static c3: char =
- '\x1' //~ ERROR: numeric character escape is too short
-;
-
-static c4: char =
- '\u23q' //~ ERROR: illegal character in numeric character escape
- //~^ WARNING: \uABCD escapes are deprecated
-;
-//~^^^ ERROR: numeric character escape is too short
-
-static s: &'static str =
- "\x1" //~ ERROR: numeric character escape is too short
-;
-
-static s2: &'static str =
- "\u23q" //~ ERROR: illegal character in numeric character escape
- //~^ ERROR: numeric character escape is too short
- //~^^ WARNING: \uABCD escapes are deprecated
-;
-
-static c: char =
- '\●' //~ ERROR: unknown character escape
-;
-
-static s: &'static str =
- "\●" //~ ERROR: unknown character escape
-;
-
-// THIS MUST BE LAST, since unterminated character constants kill the lexer
-
-static c: char =
- '● //~ ERROR: unterminated character constant
-;
+++ /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.
-
-● //~ ERROR: unknown start of token
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#![feature(no_std)]
#![no_std]
#![allow(unused_variables)]
#![allow(non_camel_case_types)]
#![allow(non_upper_case_globals)]
-#![allow(missing_copy_implementations)]
#![deny(dead_code)]
#![feature(core)]
// injected intrinsics by the compiler.
#![deny(missing_docs)]
#![allow(dead_code)]
-#![allow(missing_copy_implementations)]
//! Some garbage docs for the crate here
#![doc="More garbage"]
+++ /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.
-
-#[doc = $not_there] //~ error: unexpected token: `$`
-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.
-
-fn main() {
- foo! bar < //~ ERROR expected `(` or `{`, found `<`
-}
+++ /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.
-
-fn macro() { //~ ERROR `macro` is a reserved keyword
-}
-
-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.
-
-fn main() {
- foo! {
- bar, "baz", 1, 2.0
- ) //~ ERROR incorrect close delimiter
-}
+++ /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() {
- foo! (
- bar, "baz", 1, 2.0
- } //~ ERROR incorrect close delimiter
-}
+++ /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() {
- assert!(1 == 2)
- assert!(3 == 4) //~ ERROR expected one of `.`, `;`, `}`, or an operator, found `assert`
- println!("hello");
-}
-
--- /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.
+
+#![plugin] //~ ERROR malformed plugin attribute
+
+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.
+
+#![plugin="bleh"] //~ ERROR malformed plugin attribute
+
+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.
+
+#![plugin(foo="bleh")] //~ ERROR malformed plugin attribute
+
+fn main() {}
+++ /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.
-
-fn main() {
-
- match 0 {
- 0 => {
- } + 5 //~ ERROR unexpected token: `+`
- }
-}
+++ /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 a = Vec::new();
- match a {
- [1, tail.., tail..] => {}, //~ ERROR: expected one of `!`, `,`, or `@`, found `..`
- _ => ()
- }
-}
// compile-flags: --crate-type lib
#![deny(missing_debug_implementations)]
-#![allow(unused, missing_copy_implementations)]
+#![allow(unused)]
use std::fmt;
+++ /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.
-
-mod mod_file_disambig_aux; //~ ERROR file for module `mod_file_disambig_aux` found at both
-
-fn main() {
- assert_eq!(mod_file_aux::bar(), 10);
-}
+++ /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.
-
-mod not_a_real_file; //~ ERROR file not found for module `not_a_real_file`
-//~^ HELP name the file either not_a_real_file.rs or not_a_real_file/mod.rs inside the directory
-
-fn main() {
- assert_eq!(mod_file_aux::bar(), 10);
-}
+++ /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.
-
-// error-pattern: cannot declare a new module at this location
-
-mod mod_file_not_owning_aux1;
-
-fn main() {}
+++ /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.
-
-#[path = "not_a_real_file.rs"]
-mod m; //~ ERROR not_a_real_file.rs
-
-fn main() {
- assert_eq!(m::foo(), 10);
-}
*recv = a;
}
-#[rustc_move_fragments]
-pub fn test_extract_array_elem(a: [D; 3], i: usize) -> D {
- //~^ ERROR parent_of_fragments: `$(local a)`
- //~| ERROR assigned_leaf_path: `$(local i)`
- //~| ERROR moved_leaf_path: `$(local a).[]`
- //~| ERROR unmoved_fragment: `$(allbutone $(local a).[])`
- a[i]
-}
-
#[rustc_move_fragments]
pub fn test_overwrite_array_elem(mut a: [D; 3], i: usize, d: D) {
//~^ ERROR parent_of_fragments: `$(local mut a)`
a[i] = d;
}
-// FIXME (pnkfelix): Both test_move_array_then_overwrite_elem1 and
-// test_move_array_then_overwrite_elem2 illustrate a behavior that
-// we need to make illegal if we want to get rid of drop-flags.
-// See RFC PR 320 for more discussion.
-
-#[rustc_move_fragments]
-pub fn test_move_array_then_overwrite_elem1(mut a: [D; 3], i: usize, recv: &mut [D; 3], d: D) {
- //~^ ERROR parent_of_fragments: `$(local mut a)`
- //~| ERROR parent_of_fragments: `$(local recv)`
- //~| ERROR assigned_leaf_path: `$(local recv).*`
- //~| ERROR assigned_leaf_path: `$(local i)`
- //~| ERROR assigned_leaf_path: `$(local d)`
- //~| ERROR moved_leaf_path: `$(local d)`
- //~| ERROR assigned_leaf_path: `$(local mut a).[]`
- //~| ERROR unmoved_fragment: `$(allbutone $(local mut a).[])`
-
- // This test covers the case where the array contents have been all moved away, but
- // we still need to deal with new initializing writes into the array.
- *recv = a;
- a[i] = d;
-}
-
-#[rustc_move_fragments]
-pub fn test_move_array_then_overwrite_elem2(mut a: [D; 3], i: usize, j: usize,
- recv: &mut [D; 3], d1: D, d2: D) {
- //~^^ ERROR parent_of_fragments: `$(local mut a)`
- //~| ERROR parent_of_fragments: `$(local recv)`
- //~| ERROR assigned_leaf_path: `$(local recv).*`
- //~| ERROR assigned_leaf_path: `$(local i)`
- //~| ERROR assigned_leaf_path: `$(local j)`
- //~| ERROR assigned_leaf_path: `$(local d1)`
- //~| ERROR assigned_leaf_path: `$(local d2)`
- //~| ERROR moved_leaf_path: `$(local d1)`
- //~| ERROR moved_leaf_path: `$(local d2)`
- //~| ERROR assigned_leaf_path: `$(local mut a).[]`
- //~| ERROR unmoved_fragment: `$(allbutone $(local mut a).[])`
-
- // This test covers the case where the array contents have been all moved away, but
- // we still need to deal with new initializing writes into the array.
- *recv = a;
- a[i] = d1;
- a[j] = d2;
-}
-
pub 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.
+
+// Ensure that we cannot move into an uninitialized fixed-size array.
+
+struct D { _x: u8 }
+
+fn d() -> D { D { _x: 0 } }
+
+fn main() {
+ foo(1);
+ foo(3);
+}
+
+fn foo(i: usize) {
+ let mut a: [D; 4];
+ a[i] = d(); //~ ERROR use of possibly uninitialized variable: `a`
+}
--- /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.
+
+// Ensure that we cannot move into an uninitialized fixed-size array.
+
+struct D { _x: u8 }
+
+fn d() -> D { D { _x: 0 } }
+
+fn main() {
+ foo([d(), d(), d(), d()], 1);
+ foo([d(), d(), d(), d()], 3);
+}
+
+fn foo(mut a: [D; 4], i: usize) {
+ drop(a);
+ a[i] = d(); //~ ERROR use of moved value: `a`
+}
--- /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.
+
+// Ensure that we cannot move out of a fixed-size array (especially
+// when the element type has a destructor).
+
+
+struct D { _x: u8 }
+
+impl Drop for D { fn drop(&mut self) { } }
+
+fn main() {
+ fn d() -> D { D { _x: 0 } }
+
+ let _d1 = foo([d(), d(), d(), d()], 1);
+ let _d3 = foo([d(), d(), d(), d()], 3);
+}
+
+fn foo(a: [D; 4], i: usize) -> D {
+ a[i] //~ ERROR cannot move out of type `[D; 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.
-
-#[plugin]
-#[plugin] //~ ERROR #[plugin] specified multiple times
-extern crate std;
-
-fn main() {}
+++ /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.
-
-// error-pattern:18:3
-
-/* 1
- * 2
- * 3
- */
-fn main() {
- %; // parse error on line 18, but is reported on line 6 instead.
-}
+++ /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.
-
-struct S {
- y: isize
-}
-
-impl Cmp, ToString for S {
-//~^ ERROR: expected one of `(`, `+`, `::`, `<`, `for`, `where`, or `{`, found `,`
- fn eq(&&other: S) { false }
- fn to_string(&self) -> String { "hi".to_string() }
-}
+++ /dev/null
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// Can't put mut in non-ident pattern
-
-pub fn main() {
- struct Foo { x: isize }
- let mut Foo { x: x } = Foo { x: 3 }; //~ ERROR: expected one of `:`, `;`, `=`, or `@`, found `{`
-}
+++ /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.
-
-pub fn main() {
- let s = "\u{2603"; //~ ERROR unterminated unicode escape (needed a `}`)
-}
+++ /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.
-
-pub fn main() {
- let s = "\u{260311111111}"; //~ ERROR overlong unicode escape (can have at most 6 hex digits)
-}
+++ /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.
-
-pub fn main() {
- let s = "\u{d805}"; //~ ERROR illegal unicode character escape
-}
+++ /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.
-
-pub fn main() {
- let s = "\u{lol}"; //~ ERROR illegal character in unicode escape
-}
+++ /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.
-
-// error-pattern: lt
-
-fn f(a: isize, b: isize) : lt(a, b) { }
-
-fn lt(a: isize, b: isize) { }
-
-fn main() { let a: isize = 10; let b: isize = 23; check (lt(a, b)); f(a, b); }
+++ /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.
-
-fn foo(x) { //~ ERROR expected one of `!`, `:`, or `@`, found `)`
-}
+++ /dev/null
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// http://phpsadness.com/sad/1
-
-fn main() {
- ::; //~ ERROR expected ident, found `;`
-}
+++ /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() {
- box(1 + 1) //~ HELP perhaps you meant `box() (foo)` instead?
- ; //~ ERROR expected expression, found `;`
-}
+++ /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.
-
-pub fn main() {
- match 22 {
- 0 .. 3 => {} //~ ERROR expected one of `...`, `=>`, `if`, or `|`, found `..`
- _ => {}
- }
-}
+++ /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.
-
-fn matcher(x: Option<isize>) {
- match x {
- ref Some(i) => {} //~ ERROR expected identifier, found enum pattern
- None => {}
- }
-}
-
-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.
+
+#[plugin] //~ ERROR #[plugin] on `extern crate` is deprecated
+//~^ HELP use a crate attribute instead, i.e. #![plugin(std)]
+extern crate std;
+
+fn main() {}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-#![feature(lang_items, start)]
+#![feature(lang_items, start, no_std)]
#![no_std] // makes debugging this test *a lot* easier (during resolve)
#[lang="sized"]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-#![feature(start)]
+#![feature(start, no_std)]
#![no_std] // makes debugging this test *a lot* easier (during resolve)
// Test to make sure that globs don't leak in regular `use` statements.
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-#![feature(start)]
+#![feature(start, no_std)]
#![no_std] // makes debugging this test *a lot* easier (during resolve)
// Test to make sure that private items imported through globs remain private
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-#![feature(lang_items, start)]
+#![feature(lang_items, start, no_std)]
#![no_std] // makes debugging this test *a lot* easier (during resolve)
#[lang = "sized"] pub trait Sized {}
+++ /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.
-
-// Test range syntax - syntax errors.
-
-pub fn main() {
- let r = 1..2..3;
- //~^ ERROR expected one of `.`, `;`, or an operator, found `..`
-}
+++ /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.
-
-// Test range syntax - syntax errors.
-
-pub fn main() {
- let r = ..1..2;
- //~^ ERROR expected one of `.`, `;`, or an operator, found `..`
-}
+++ /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.
-
-
-pub fn main() {
- br##"a"#; //~ unterminated raw string
-}
-
-
+++ /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.
-
-
-pub fn main() {
- br"é"; //~ raw byte string must be ASCII
- br##~"a"~##; //~ only `#` is allowed in raw string delimitation
-}
-
-
+++ /dev/null
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-static s: &'static str =
- r#x"#"x# //~ ERROR only `#` is allowed in raw string delimitation; found illegal character
-;
+++ /dev/null
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-static s: &'static str =
- r#"
- "## //~ ERROR expected one of `.`, `;`, or an operator, found `#`
-;
+++ /dev/null
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-static s: &'static str =
- r#" string literal goes on
- and on
- //~^^ ERROR unterminated raw string
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#![feature(lang_items, no_std)]
#![no_std]
-#![feature(lang_items)]
// Check that explicit region bounds are allowed on the various
// nominal types (but not on other types) and that they are type
+++ /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-test
-// ignored due to problems with by value self.
-
-// 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.
-
-// Here: foo is parameterized because it contains a method that
-// refers to self.
-
-trait foo<'a> {
- fn self_int(self) -> &'a isize;
-
- fn any_int(self) -> &isize;
-}
-
-struct with_foo<'a> {
- f: @foo<'a>
-}
-
-trait set_foo_foo {
- fn set_foo(&mut self, f: @foo);
-}
-
-impl<'a> set_foo_foo for with_foo<'a> {
- fn set_foo(&mut self, f: @foo) {
- self.f = f; //~ ERROR mismatched types: expected `@foo/&self`, found `@foo/&`
- }
-}
-
-// Bar is not region parameterized.
-
-trait bar {
- fn any_int(&self) -> &isize;
-}
-
-struct with_bar {
- f: bar
-}
-
-trait set_foo_bar {
- fn set_foo(&mut self, f: bar);
-}
-
-impl set_foo_bar for with_bar {
- fn set_foo(&mut self, f: bar) {
- self.f = f;
- }
-}
-
-fn main() {}
+++ /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.
-
-// ignore-test blk region isn't supported in the front-end
-
-fn foo(cond: bool) {
- // Here we will infer a type that uses the
- // region of the if stmt then block, but in the scope:
- let mut x; //~ ERROR foo
-
- if cond {
- x = &'blk [1,2,3];
- }
-}
-
-fn main() {}
// Various examples of structs whose fields are not well-formed.
+#![feature(no_std)]
#![no_std]
#![allow(dead_code)]
+++ /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.
-
-// ignore-test #5723
-
-// Test that you cannot escape a reference
-// into a trait.
-
-struct ctxt { v: usize }
-
-trait get_ctxt {
- fn get_ctxt(&self) -> &'a ctxt;
-}
-
-struct has_ctxt<'a> { c: &'a ctxt }
-
-impl<'a> get_ctxt for has_ctxt<'a> {
- fn get_ctxt(&self) -> &'a ctxt { self.c }
-}
-
-fn make_gc() -> @get_ctxt {
- let ctxt = ctxt { v: 22us };
- let hc = has_ctxt { c: &ctxt };
- return @hc as @get_ctxt;
- //~^ ERROR source contains reference
-}
-
-fn main() {
- make_gc().get_ctxt().v;
-}
+++ /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-test
-// ignore'd due to problems with by-value self.
-
-// 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.
-
-trait get_ctxt<'a> {
- fn get_ctxt(self) -> &'a usize;
-}
-
-fn make_gc1(gc: @get_ctxt<'a>) -> @get_ctxt<'b> {
- return gc; //~ ERROR mismatched types: expected `@get_ctxt/&b`, found `@get_ctxt/&a`
-}
-
-struct Foo {
- r: &'a usize
-}
-
-impl get_ctxt for Foo<'a> {
- fn get_ctxt(&self) -> &'a usize { self.r }
-}
-
-fn make_gc2<'a,'b>(foo: Foo<'a>) -> @get_ctxt<'b> {
- return @foo as @get_ctxt; //~ ERROR cannot infer
-}
-
-fn main() {
-}
+++ /dev/null
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-type closure = Box<lt/fn()>; //~ ERROR expected one of `(`, `+`, `,`, `::`, `<`, or `>`, found `/`
+++ /dev/null
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-enum e = isize; //~ ERROR expected one of `<`, `where`, or `{`, found `=`
+++ /dev/null
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-extern {
- const i: isize;
- //~^ ERROR expected one of `fn`, `pub`, `static`, `unsafe`, or `}`, found `const`
-}
+++ /dev/null
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-struct s {
- let foo: (),
- //~^ ERROR expected identifier, found keyword `let`
- //~^^ ERROR expected `:`, found `foo`
-}
+++ /dev/null
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-struct s {
- bar: ();
- //~^ ERROR expected `,`, or `}`, found `;`
-}
+++ /dev/null
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-type v = [isize * 3]; //~ ERROR expected one of `(`, `+`, `::`, `;`, `<`, or `]`, found `*`
+++ /dev/null
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-pure fn f() {} //~ ERROR expected item, found `pure`
+++ /dev/null
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-fn f() {
- let x: fn~() = || (); //~ ERROR expected `(`, found `~`
-}
+++ /dev/null
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-fn removed_moves() {
- let mut x = 0;
- let y <- x;
- //~^ ERROR expected one of `!`, `:`, `;`, `=`, or `@`, found `<-`
-}
+++ /dev/null
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-fn removed_moves() {
- let mut x = 0;
- let y = 0;
- y <- x;
- //~^ ERROR expected one of `!`, `.`, `::`, `;`, `{`, `}`, or an operator, found `<-`
-}
+++ /dev/null
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-fn f(+x: isize) {} //~ ERROR unexpected token: `+`
+++ /dev/null
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-fn f() {
- let v = [mut 1, 2, 3, 4];
- //~^ ERROR expected identifier, found keyword `mut`
- //~^^ ERROR expected one of `!`, `,`, `.`, `::`, `;`, `]`, `{`, or an operator, found `1`
-}
+++ /dev/null
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-type v = [mut isize];
- //~^ ERROR expected identifier, found keyword `mut`
- //~^^ ERROR expected one of `(`, `+`, `::`, `;`, `<`, or `]`, found `isize`
+++ /dev/null
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-type bptr = &lifetime/isize; //~ ERROR expected one of `(`, `+`, `::`, `;`, or `<`, found `/`
+++ /dev/null
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-type t = { f: () }; //~ ERROR expected type, found `{`
+++ /dev/null
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-struct S;
-
-impl S {
- static fn f() {}
- //~^ ERROR expected one of `extern`, `fn`, `pub`, `type`, `unsafe`, or `}`, found `static`
-}
+++ /dev/null
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-fn f() {
- let a_box = box mut 42;
- //~^ ERROR expected identifier, found keyword `mut`
- //~^^ ERROR expected one of `!`, `.`, `::`, `;`, `{`, or an operator, found `42`
-}
+++ /dev/null
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-type mut_box = Box<mut isize>;
- //~^ ERROR expected identifier, found keyword `mut`
- //~^^ ERROR expected one of `(`, `+`, `,`, `::`, `<`, or `>`, found `isize`
+++ /dev/null
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-fn removed_with() {
- struct S {
- foo: (),
- bar: (),
- }
-
- let a = S { foo: (), bar: () };
- let b = S { foo: () with a };
- //~^ ERROR expected one of `,`, `.`, `}`, or an operator, found `with`
-}
+++ /dev/null
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-fn removed_with() {
- struct S {
- foo: (),
- bar: (),
- }
-
- let a = S { foo: (), bar: () };
- let b = S { foo: (), with a };
- //~^ ERROR expected `:`, found `a`
-}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-#![feature(lang_items)]
+#![feature(lang_items, no_std)]
#![no_std]
#[lang="sized"] pub trait Sized {}
+++ /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.
-
-fn main() {
- let be = 0;
- //~^ ERROR `be` is a reserved keyword
-}
--- /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.
+
+// Testing that the stable_features lint catches use of stable
+// language and lib features.
+
+#![deny(stable_features)]
+#![feature(test_accepted_feature)] //~ ERROR this feature is stable
+#![feature(rust1)] //~ ERROR this feature is stable
+
+fn main() {
+ let _foo: Vec<()> = Vec::new();
+}
+++ /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.
-
-struct Foo {
- x: isize,
-}
-
-impl Foo {
- fn hi(&self) -> bool {
- true
- }
-}
-
-fn main() {
- for x in Foo {
- x: 3 //~ ERROR expected one of `!`, `.`, `::`, `;`, `{`, `}`, or an operator, found `:`
- }.hi() {
- println!("yo");
- }
-}
-
+++ /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.
-
-struct Foo {
- x: isize,
-}
-
-impl Foo {
- fn hi(&self) -> bool {
- true
- }
-}
-
-fn main() {
- if Foo {
- x: 3 //~ ERROR expected one of `!`, `.`, `::`, `;`, `{`, `}`, or an operator, found `:`
- }.hi() {
- println!("yo");
- }
-}
-
+++ /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.
-
-struct Foo {
- x: isize,
-}
-
-fn main() {
- match Foo {
- x: 3 //~ ERROR expected one of `!`, `=>`, `@`, `if`, or `|`, found `:`
- } {
- Foo {
- x: x
- } => {}
- }
-}
-
+++ /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.
-
-struct Foo {
- x: isize,
-}
-
-impl Foo {
- fn hi(&self) -> bool {
- true
- }
-}
-
-fn main() {
- while Foo {
- x: 3 //~ ERROR expected one of `!`, `.`, `::`, `;`, `{`, `}`, or an operator, found `:`
- }.hi() {
- println!("yo");
- }
-}
-
+++ /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.
-
-struct Foo(); //~ ERROR unit-like struct definition should be written as `struct Foo;`
-
-fn main() {}
+++ /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.
-
-struct Foo {}
-//~^ ERROR: unit-like struct definition should be written as `struct Foo;`
-
-fn main() {}
+++ /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.
-
-iface foo { } //~ ERROR iface
-
-fn main() {}
+++ /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.
-
-
-// error-pattern: unterminated double quote string
-
-
-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.
-
-// Test that parentheses form doesn't work in expression paths.
-
-struct Bar<A,R> {
- f: A, r: R
-}
-
-impl<A,B> Bar<A,B> {
- fn new() -> Bar<A,B> { panic!() }
-}
-
-fn bar() {
- let b = Box::Bar::<isize,usize>::new(); // OK
-
- let b = Box::Bar::()::new();
- //~^ ERROR expected ident, found `(`
-}
-
-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.
-
-// Test syntax checks for `type` keyword.
-
-struct S1 for type; //~ ERROR expected `where`, `{`, `(`, or `;` after struct name, found `for`
-
-pub 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.
-
-use std::any:: as foo; //~ ERROR expected identifier, found keyword `as`
-//~^ ERROR: expected one of `::`, `;`, or `as`, found `foo`
+++ /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.
-
-use std::any::; //~ ERROR expected identifier or `{` or `*`, found `;`
+++ /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 foo::self;
-//~^ ERROR expected identifier, found keyword `self`
-
-fn main() {}
-
+++ /dev/null
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-extern {
- fn printf(...); //~ ERROR: variadic function must be declared with at least one named argument
- fn printf(..., foo: isize); //~ ERROR: `...` must be last in argument list for variadic function
-}
-
-fn main() {}
+++ /dev/null
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-fn foo(x: isize, ...) {
- //~^ ERROR: only foreign functions are allowed to be variadic
-}
-
-fn main() {}
+++ /dev/null
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-extern "C" fn foo(x: isize, ...) {
- //~^ ERROR: only foreign functions are allowed to be variadic
-}
-
-fn main() {}
// error-pattern: language item required, but not found: `stack_exhausted`
// error-pattern: language item required, but not found: `eh_personality`
+#![feature(no_std)]
#![no_std]
extern crate core;
--- /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 can quantify lifetimes outside a constraint (i.e., including
+// the self type) in a where clause. Specifically, test that implementing for a
+// specific lifetime is not enough to satisify the `for<'a> ...` constraint, which
+// should require *all* lifetimes.
+
+static X: &'static u32 = &42;
+
+trait Bar {
+ fn bar(&self);
+}
+
+impl Bar for &'static u32 {
+ fn bar(&self) {}
+}
+
+fn foo<T>(x: &T)
+ where for<'a> &'a T: Bar
+{}
+
+fn main() {
+ foo(&X);
+ //~^ error: `for<'a> Bar` is not implemented
+}
--- /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 can quantify lifetimes outside a constraint (i.e., including
+// the self type) in a where clause. Specifically, test that we cannot nest
+// quantification in constraints (to be clear, there is no reason this should not
+// we're testing we don't crash or do something stupid).
+
+trait Bar<'a> {
+ fn bar(&self);
+}
+
+impl<'a, 'b> Bar<'b> for &'a u32 {
+ fn bar(&self) {}
+}
+
+fn foo<T>(x: &T)
+ where for<'a> &'a T: for<'b> Bar<'b>
+ //~^ error: nested quantification of lifetimes
+{}
+
+fn main() {}
--- /dev/null
+// 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.
+//
+// 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
+
+#![allow(unused_variables)]
+#![allow(dead_code)]
+#![omit_gdb_pretty_printer_section]
+
+// This test makes sure that the compiler doesn't crash when trying to assign
+// debug locations to 'constant' patterns in match expressions.
+
+const CONSTANT: u64 = 3;
+
+struct Struct {
+ a: isize,
+ b: usize,
+}
+const STRUCT: Struct = Struct { a: 1, b: 2 };
+
+struct TupleStruct(u32);
+const TUPLE_STRUCT: TupleStruct = TupleStruct(4);
+
+enum Enum {
+ Variant1(char),
+ Variant2 { a: u8 },
+ Variant3
+}
+const VARIANT1: Enum = Enum::Variant1('v');
+const VARIANT2: Enum = Enum::Variant2 { a: 2 };
+const VARIANT3: Enum = Enum::Variant3;
+
+const STRING: &'static str = "String";
+
+fn main() {
+
+ match 1 {
+ CONSTANT => {}
+ _ => {}
+ };
+
+ // if let 3 = CONSTANT {}
+
+ match (Struct { a: 2, b: 2 }) {
+ STRUCT => {}
+ _ => {}
+ };
+
+ // if let STRUCT = STRUCT {}
+
+ match TupleStruct(3) {
+ TUPLE_STRUCT => {}
+ _ => {}
+ };
+
+ // if let TupleStruct(4) = TUPLE_STRUCT {}
+
+ match VARIANT3 {
+ VARIANT1 => {},
+ VARIANT2 => {},
+ VARIANT3 => {},
+ _ => {}
+ };
+
+ match (VARIANT3, VARIANT2) {
+ (VARIANT1, VARIANT3) => {},
+ (VARIANT2, VARIANT2) => {},
+ (VARIANT3, VARIANT1) => {},
+ _ => {}
+ };
+
+ // if let VARIANT1 = Enum::Variant3 {}
+ // if let VARIANT2 = Enum::Variant3 {}
+ // if let VARIANT3 = Enum::Variant3 {}
+
+ match "abc" {
+ STRING => {},
+ _ => {}
+ }
+
+ if let STRING = "def" {}
+}
--- /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.
+
+// Test that the old fixed length array syntax is a parsing error.
+
+fn main() {
+ let _x: [isize, ..3] = [0, 1, 2]; //~ ERROR
+}
--- /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.
+
+// Test you can't use a higher-ranked trait bound inside of a qualified
+// path (just won't parse).
+
+pub trait Foo<T> {
+ type A;
+
+ fn get(&self, t: T) -> Self::A;
+}
+
+fn foo2<I>(x: <I as for<'x> Foo<&'x isize>>::A)
+ //~^ ERROR expected identifier, found keyword `for`
+ //~| ERROR expected one of `::` or `>`
+{
+}
+
+pub fn main() {}
--- /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.
+
+// error-pattern:expected `]`
+
+// asterisk is bogus
+#[attr*]
+mod m {}
--- /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.
+
+// error-pattern: expected
+
+fn main() {
+ let isize x = 5;
+ match x;
+}
+
+fn main() {
+}
--- /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.
+
+// error-pattern: expected
+
+fn main() {
+ let x.y::<isize>.z foo;
+}
--- /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: [isize 3]; //~ ERROR expected one of `(`, `+`, `::`, `;`, `<`, or `]`, found `3`
+}
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn main() {
+ struct Foo { x: isize }
+ match (Foo { x: 10 }) {
+ Foo { ref x: ref x } => {}, //~ ERROR expected `,`, found `:`
+ _ => {}
+ }
+}
--- /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-tab
+
+static FOO: u8 = b'\f'; //~ ERROR unknown byte escape
+
+pub fn main() {
+ b'\f'; //~ ERROR unknown byte escape
+ b'\x0Z'; //~ ERROR illegal character in numeric character escape: Z
+ b' '; //~ ERROR byte constant must be escaped
+ b'''; //~ ERROR byte constant must be escaped
+ b'é'; //~ ERROR byte constant must be ASCII
+ b'a //~ ERROR unterminated byte constant
+}
+
+
--- /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-tab
+
+static FOO: &'static [u8] = b"\f"; //~ ERROR unknown byte escape
+
+pub fn main() {
+ b"\f"; //~ ERROR unknown byte escape
+ b"\x0Z"; //~ ERROR illegal character in numeric character escape: Z
+ b"é"; //~ ERROR byte constant must be ASCII
+ b"a //~ ERROR unterminated double quote byte string
+}
+
+
--- /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-test: this is an auxiliary file for circular-modules-main.rs
+
+mod circular_modules_main;
+
+pub fn say_hello() {
+ println!("{}", circular_modules_main::hi_str());
+}
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[path = "circular_modules_hello.rs"]
+mod circular_modules_hello; //~ERROR: circular modules
+
+pub fn hi_str() -> String {
+ "Hi!".to_string()
+}
+
+fn main() {
+ circular_modules_hello::say_hello();
+}
--- /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.
+
+// error-pattern:nonexistent
+class cat : nonexistent {
+ let meows: usize;
+ new(in_x : usize) { self.meows = in_x; }
+}
+
+fn main() {
+ let nyan = cat(0us);
+}
--- /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.
+
+# //~ ERROR 11:1: 11:2 error: expected one of `!` or `[`, found `<eof>`
--- /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.
+
+// error-pattern:unmatched visibility `pub`
+extern {
+ pub pub fn foo();
+}
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+impl Foo; //~ ERROR expected one of `(`, `+`, `::`, `<`, `for`, `where`, or `{`, found `;`
--- /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.
+
+// Verifies that the expected token errors for `extern crate` are
+// raised
+
+extern "C" mod foo; //~ERROR expected `{` or `fn`, found `mod`
--- /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.
+
+// Verifies that the expected token errors for `extern crate` are
+// raised
+
+extern crate foo {} //~ERROR expected `;`, found `{`
--- /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.
+
+extern {
+ f(); //~ ERROR expected one of `fn`, `pub`, `static`, `unsafe`, or `}`, found `f`
+}
+
+fn main() {
+}
--- /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.
+
+// error-pattern:expected
+use foo::{bar}::baz
--- /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.
+
+// error-pattern:expected
+
+use foo::{bar} as baz;
+
+mod foo {
+ pub fn bar() {}
+}
+
+fn main() {
+}
--- /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.
+
+// error-pattern:expected
+use foo::*::bar
--- /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.
+
+// error-pattern:expected
+
+use foo::* as baz;
+
+mod foo {
+ pub fn bar() {}
+}
+
+fn main() {
+}
--- /dev/null
+// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+struct A { foo: isize }
+
+fn a() -> A { panic!() }
+
+fn main() {
+ let A { .., } = a(); //~ ERROR: expected `}`
+}
+
--- /dev/null
+// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+struct A { foo: isize }
+
+fn a() -> A { panic!() }
+
+fn main() {
+ let A { , } = a(); //~ ERROR: expected ident
+}
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+struct Obj { //~ NOTE: unclosed delimiter
+ member: usize
+) //~ ERROR: incorrect close delimiter
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+pub fn trace_option(option: Option<isize>) {
+ option.map(|some| 42; //~ NOTE: unclosed delimiter
+} //~ ERROR: incorrect close delimiter
--- /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.
+
+enum X<'a, T, 'b> {
+//~^ ERROR lifetime parameters must be declared prior to type parameters
+ A(&'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.
+
+fn foo<'a, T, 'b>(x: &'a T) {}
+//~^ ERROR lifetime parameters must be declared prior to type parameters
--- /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() {
+ (0..4)
+ .map(|x| x * 2)
+ .collect::<Vec<'a, usize, 'b>>()
+ //~^ ERROR lifetime parameters must be declared prior to type parameters
+}
--- /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.
+
+struct X { x: isize }
+
+impl<'a, T, 'b> X {}
+//~^ ERROR lifetime parameters must be declared prior to type parameters
--- /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 bar<'a, T>(x: mymodule::X<'a, T, 'b, 'c>) {}
+//~^ ERROR lifetime parameters must be declared prior to type parameters
--- /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.
+
+struct X<'a, T, 'b> {
+//~^ ERROR lifetime parameters must be declared prior to type parameters
+ x: &'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.
+
+trait Foo<'a, T, 'b> {}
+//~^ ERROR lifetime parameters must be declared prior to type parameters
--- /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 ref
+ (); //~ ERROR expected identifier, found `(`
+}
--- /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.
+
+// error-pattern:expected one of `!` or `[`, found `vec`
+mod blade_runner {
+ #vec[doc(
+ brief = "Blade Runner is probably the best movie ever",
+ desc = "I like that in the world of Blade Runner it is always
+ raining, and that it's always night time. And Aliens
+ was also a really good movie.
+
+ Alien 3 was crap though."
+ )]
+}
--- /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.
+
+struct Baz<U> where U: Eq(U); //This is parsed as the new Fn* style parenthesis syntax.
+struct Baz<U> where U: Eq(U) -> R; // Notice this parses as well.
+struct Baz<U>(U) where U: Eq; // This rightfully signals no error as well.
+struct Foo<T> where T: Copy, (T); //~ ERROR unexpected token in `where` clause
+struct Bar<T> { x: T } where T: Copy //~ ERROR expected item, found `where`
+
+fn main() {}
--- /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.
+
+// error-pattern:no valid digits found for number
+fn main() {
+ log(error, 0b42);
+}
--- /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.
+
+fn main() {
+ let t = (42, 42);
+ t.0::<isize>; //~ ERROR expected one of `.`, `;`, `}`, or an operator, found `::`
+}
--- /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 T {
+ extern "Rust" unsafe fn foo(); //~ ERROR expected `fn`, found `unsafe`
+}
+
+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.
+
+struct Foo;
+
+impl Foo {
+ fn foo() {}
+
+ #[stable(feature = "rust1", since = "1.0.0")]
+} //~ ERROR expected one of `extern`, `fn`, `pub`, `type`, or `unsafe`, found `}`
+
+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.
+
+struct Foo;
+
+impl Foo {
+ #[stable(feature = "rust1", since = "1.0.0")]
+} //~ ERROR expected one of `extern`, `fn`, `pub`, `type`, or `unsafe`, found `}`
+
+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.
+
+trait MyTrait<T>: Iterator {
+ Item = T; //~ ERROR expected one of `extern`, `fn`, `pub`, `type`, or `unsafe`, found `Item`
+}
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+static foo: isize = 2; } //~ ERROR incorrect close delimiter:
+
--- /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.
+
+fn foo() { //~ HELP did you mean to close this delimiter?
+ match Some(x) {
+ Some(y) { panic!(); }
+ None { panic!(); }
+}
+
+fn bar() {
+ let mut i = 0;
+ while (i < 1000) {}
+}
+
+fn main() {} //~ ERROR this file contains an un-closed delimiter
--- /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.
+
+// Testing that semicolon tokens are printed correctly in errors
+
+fn main()
+{
+ let x = 3
+} //~ ERROR: expected one of `.`, `;`, or an operator, found `}`
--- /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.
+
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[path = "../compile-fail"]
+mod foo; //~ ERROR: a directory
+
+fn main() {}
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+trait Foo { fn a() } //~ ERROR expected `;` or `{`, found `}`
+
+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.
+
+fn main() {
+ let abstract = (); //~ ERROR `abstract` is a reserved keyword
+}
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn main() {
+ let do = "bar"; //~ error: ident
+}
--- /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 final = (); //~ ERROR `final` is a reserved keyword
+}
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// This file was auto-generated using 'src/etc/generate-keyword-tests.py mut'
+
+fn main() {
+ let mut = "foo"; //~ error: ident
+}
--- /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 override = (); //~ ERROR `override` is a reserved keyword
+}
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// This file was auto-generated using 'src/etc/generate-keyword-tests.py priv'
+
+fn main() {
+ let priv = "foo"; //~ error: ident
+}
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// This file was auto-generated using 'src/etc/generate-keyword-tests.py ref'
+
+fn main() {
+ let ref = "foo"; //~ error: ident
+}
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn main() {
+ let typeof = (); //~ ERROR `typeof` is a reserved keyword
+}
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+static c: char =
+ '\u539_' //~ ERROR: illegal character in numeric character escape
+ //~^ WARNING: \uABCD escapes are deprecated
+;
+
+static c2: char =
+ '\Uffffffff' //~ ERROR: illegal numeric character escape
+ //~^ WARNING: \uABCD escapes are deprecated
+;
+
+static c3: char =
+ '\x1' //~ ERROR: numeric character escape is too short
+;
+
+static c4: char =
+ '\u23q' //~ ERROR: illegal character in numeric character escape
+ //~^ WARNING: \uABCD escapes are deprecated
+;
+//~^^^ ERROR: numeric character escape is too short
+
+static s: &'static str =
+ "\x1" //~ ERROR: numeric character escape is too short
+;
+
+static s2: &'static str =
+ "\u23q" //~ ERROR: illegal character in numeric character escape
+ //~^ ERROR: numeric character escape is too short
+ //~^^ WARNING: \uABCD escapes are deprecated
+;
+
+static c: char =
+ '\●' //~ ERROR: unknown character escape
+;
+
+static s: &'static str =
+ "\●" //~ ERROR: unknown character escape
+;
+
+// THIS MUST BE LAST, since unterminated character constants kill the lexer
+
+static c: char =
+ '● //~ ERROR: unterminated character constant
+;
--- /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.
+
+● //~ ERROR: unknown start of token
--- /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.
+
+#[doc = $not_there] //~ error: unexpected token: `$`
+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.
+
+fn main() {
+ foo! bar < //~ ERROR expected `(` or `{`, found `<`
+}
--- /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.
+
+fn macro() { //~ ERROR `macro` is a reserved keyword
+}
+
+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.
+
+fn main() {
+ foo! {
+ bar, "baz", 1, 2.0
+ ) //~ ERROR incorrect close delimiter
+}
--- /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() {
+ foo! (
+ bar, "baz", 1, 2.0
+ } //~ ERROR incorrect close delimiter
+}
--- /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() {
+ assert!(1 == 2)
+ assert!(3 == 4) //~ ERROR expected one of `.`, `;`, `}`, or an operator, found `assert`
+ println!("hello");
+}
+
--- /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.
+
+fn main() {
+
+ match 0 {
+ 0 => {
+ } + 5 //~ ERROR unexpected token: `+`
+ }
+}
--- /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 a = Vec::new();
+ match a {
+ [1, tail.., tail..] => {}, //~ ERROR: expected one of `!`, `,`, or `@`, found `..`
+ _ => ()
+ }
+}
--- /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.
+
+mod mod_file_disambig_aux; //~ ERROR file for module `mod_file_disambig_aux` found at both
+
+fn main() {
+ assert_eq!(mod_file_aux::bar(), 10);
+}
--- /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.
+
+mod not_a_real_file; //~ ERROR file not found for module `not_a_real_file`
+//~^ HELP name the file either not_a_real_file.rs or not_a_real_file/mod.rs inside the directory
+
+fn main() {
+ assert_eq!(mod_file_aux::bar(), 10);
+}
--- /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.
+
+// error-pattern: cannot declare a new module at this location
+
+mod mod_file_not_owning_aux1;
+
+fn main() {}
--- /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.
+
+#[path = "not_a_real_file.rs"]
+mod m; //~ ERROR not_a_real_file.rs
+
+fn main() {
+ assert_eq!(m::foo(), 10);
+}
--- /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.
+
+// error-pattern:18:3
+
+/* 1
+ * 2
+ * 3
+ */
+fn main() {
+ %; // parse error on line 18, but is reported on line 6 instead.
+}
--- /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.
+
+struct S {
+ y: isize
+}
+
+impl Cmp, ToString for S {
+//~^ ERROR: expected one of `(`, `+`, `::`, `<`, `for`, `where`, or `{`, found `,`
+ fn eq(&&other: S) { false }
+ fn to_string(&self) -> String { "hi".to_string() }
+}
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// Can't put mut in non-ident pattern
+
+pub fn main() {
+ struct Foo { x: isize }
+ let mut Foo { x: x } = Foo { x: 3 }; //~ ERROR: expected one of `:`, `;`, `=`, or `@`, found `{`
+}
--- /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.
+
+pub fn main() {
+ let s = "\u{2603"; //~ ERROR unterminated unicode escape (needed a `}`)
+}
--- /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.
+
+pub fn main() {
+ let s = "\u{260311111111}"; //~ ERROR overlong unicode escape (can have at most 6 hex digits)
+}
--- /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.
+
+pub fn main() {
+ let s = "\u{d805}"; //~ ERROR illegal unicode character escape
+}
--- /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.
+
+pub fn main() {
+ let s = "\u{lol}"; //~ ERROR illegal character in unicode escape
+}
--- /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.
+
+// error-pattern: lt
+
+fn f(a: isize, b: isize) : lt(a, b) { }
+
+fn lt(a: isize, b: isize) { }
+
+fn main() { let a: isize = 10; let b: isize = 23; check (lt(a, b)); f(a, b); }
--- /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.
+
+fn foo(x) { //~ ERROR expected one of `!`, `:`, or `@`, found `)`
+}
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// http://phpsadness.com/sad/1
+
+fn main() {
+ ::; //~ ERROR expected ident, found `;`
+}
--- /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() {
+ box(1 + 1) //~ HELP perhaps you meant `box() (foo)` instead?
+ ; //~ ERROR expected expression, found `;`
+}
--- /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.
+
+pub fn main() {
+ match 22 {
+ 0 .. 3 => {} //~ ERROR expected one of `...`, `=>`, `if`, or `|`, found `..`
+ _ => {}
+ }
+}
--- /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.
+
+fn matcher(x: Option<isize>) {
+ match x {
+ ref Some(i) => {} //~ ERROR expected identifier, found enum pattern
+ None => {}
+ }
+}
+
+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.
+
+// Test range syntax - syntax errors.
+
+pub fn main() {
+ let r = 1..2..3;
+ //~^ ERROR expected one of `.`, `;`, or an operator, found `..`
+}
--- /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.
+
+// Test range syntax - syntax errors.
+
+pub fn main() {
+ let r = ..1..2;
+ //~^ ERROR expected one of `.`, `;`, or an operator, found `..`
+}
--- /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.
+
+
+pub fn main() {
+ br##"a"#; //~ unterminated raw string
+}
+
+
--- /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.
+
+
+pub fn main() {
+ br"é"; //~ raw byte string must be ASCII
+ br##~"a"~##; //~ only `#` is allowed in raw string delimitation
+}
+
+
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+static s: &'static str =
+ r#x"#"x# //~ ERROR only `#` is allowed in raw string delimitation; found illegal character
+;
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+static s: &'static str =
+ r#"
+ "## //~ ERROR expected one of `.`, `;`, or an operator, found `#`
+;
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+static s: &'static str =
+ r#" string literal goes on
+ and on
+ //~^^ ERROR unterminated raw string
--- /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-test
+// ignored due to problems with by value self.
+
+// 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.
+
+// Here: foo is parameterized because it contains a method that
+// refers to self.
+
+trait foo<'a> {
+ fn self_int(self) -> &'a isize;
+
+ fn any_int(self) -> &isize;
+}
+
+struct with_foo<'a> {
+ f: @foo<'a>
+}
+
+trait set_foo_foo {
+ fn set_foo(&mut self, f: @foo);
+}
+
+impl<'a> set_foo_foo for with_foo<'a> {
+ fn set_foo(&mut self, f: @foo) {
+ self.f = f; //~ ERROR mismatched types: expected `@foo/&self`, found `@foo/&`
+ }
+}
+
+// Bar is not region parameterized.
+
+trait bar {
+ fn any_int(&self) -> &isize;
+}
+
+struct with_bar {
+ f: bar
+}
+
+trait set_foo_bar {
+ fn set_foo(&mut self, f: bar);
+}
+
+impl set_foo_bar for with_bar {
+ fn set_foo(&mut self, f: bar) {
+ self.f = f;
+ }
+}
+
+fn main() {}
--- /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.
+
+// ignore-test blk region isn't supported in the front-end
+
+fn foo(cond: bool) {
+ // Here we will infer a type that uses the
+ // region of the if stmt then block, but in the scope:
+ let mut x; //~ ERROR foo
+
+ if cond {
+ x = &'blk [1,2,3];
+ }
+}
+
+fn main() {}
--- /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.
+
+// ignore-test #5723
+
+// Test that you cannot escape a reference
+// into a trait.
+
+struct ctxt { v: usize }
+
+trait get_ctxt {
+ fn get_ctxt(&self) -> &'a ctxt;
+}
+
+struct has_ctxt<'a> { c: &'a ctxt }
+
+impl<'a> get_ctxt for has_ctxt<'a> {
+ fn get_ctxt(&self) -> &'a ctxt { self.c }
+}
+
+fn make_gc() -> @get_ctxt {
+ let ctxt = ctxt { v: 22us };
+ let hc = has_ctxt { c: &ctxt };
+ return @hc as @get_ctxt;
+ //~^ ERROR source contains reference
+}
+
+fn main() {
+ make_gc().get_ctxt().v;
+}
--- /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-test
+// ignore'd due to problems with by-value self.
+
+// 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.
+
+trait get_ctxt<'a> {
+ fn get_ctxt(self) -> &'a usize;
+}
+
+fn make_gc1(gc: @get_ctxt<'a>) -> @get_ctxt<'b> {
+ return gc; //~ ERROR mismatched types: expected `@get_ctxt/&b`, found `@get_ctxt/&a`
+}
+
+struct Foo {
+ r: &'a usize
+}
+
+impl get_ctxt for Foo<'a> {
+ fn get_ctxt(&self) -> &'a usize { self.r }
+}
+
+fn make_gc2<'a,'b>(foo: Foo<'a>) -> @get_ctxt<'b> {
+ return @foo as @get_ctxt; //~ ERROR cannot infer
+}
+
+fn main() {
+}
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+type closure = Box<lt/fn()>; //~ ERROR expected one of `(`, `+`, `,`, `::`, `<`, or `>`, found `/`
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+enum e = isize; //~ ERROR expected one of `<`, `where`, or `{`, found `=`
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+extern {
+ const i: isize;
+ //~^ ERROR expected one of `fn`, `pub`, `static`, `unsafe`, or `}`, found `const`
+}
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+struct s {
+ let foo: (),
+ //~^ ERROR expected identifier, found keyword `let`
+ //~^^ ERROR expected `:`, found `foo`
+}
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+struct s {
+ bar: ();
+ //~^ ERROR expected `,`, or `}`, found `;`
+}
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+type v = [isize * 3]; //~ ERROR expected one of `(`, `+`, `::`, `;`, `<`, or `]`, found `*`
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+pure fn f() {} //~ ERROR expected item, found `pure`
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn f() {
+ let x: fn~() = || (); //~ ERROR expected `(`, found `~`
+}
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn removed_moves() {
+ let mut x = 0;
+ let y <- x;
+ //~^ ERROR expected one of `!`, `:`, `;`, `=`, or `@`, found `<-`
+}
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn removed_moves() {
+ let mut x = 0;
+ let y = 0;
+ y <- x;
+ //~^ ERROR expected one of `!`, `.`, `::`, `;`, `{`, `}`, or an operator, found `<-`
+}
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn f(+x: isize) {} //~ ERROR unexpected token: `+`
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn f() {
+ let v = [mut 1, 2, 3, 4];
+ //~^ ERROR expected identifier, found keyword `mut`
+ //~^^ ERROR expected one of `!`, `,`, `.`, `::`, `;`, `]`, `{`, or an operator, found `1`
+}
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+type v = [mut isize];
+ //~^ ERROR expected identifier, found keyword `mut`
+ //~^^ ERROR expected one of `(`, `+`, `::`, `;`, `<`, or `]`, found `isize`
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+type bptr = &lifetime/isize; //~ ERROR expected one of `(`, `+`, `::`, `;`, or `<`, found `/`
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+type t = { f: () }; //~ ERROR expected type, found `{`
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+struct S;
+
+impl S {
+ static fn f() {}
+ //~^ ERROR expected one of `extern`, `fn`, `pub`, `type`, `unsafe`, or `}`, found `static`
+}
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn f() {
+ let a_box = box mut 42;
+ //~^ ERROR expected identifier, found keyword `mut`
+ //~^^ ERROR expected one of `!`, `.`, `::`, `;`, `{`, or an operator, found `42`
+}
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+type mut_box = Box<mut isize>;
+ //~^ ERROR expected identifier, found keyword `mut`
+ //~^^ ERROR expected one of `(`, `+`, `,`, `::`, `<`, or `>`, found `isize`
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn removed_with() {
+ struct S {
+ foo: (),
+ bar: (),
+ }
+
+ let a = S { foo: (), bar: () };
+ let b = S { foo: () with a };
+ //~^ ERROR expected one of `,`, `.`, `}`, or an operator, found `with`
+}
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn removed_with() {
+ struct S {
+ foo: (),
+ bar: (),
+ }
+
+ let a = S { foo: (), bar: () };
+ let b = S { foo: (), with a };
+ //~^ ERROR expected `:`, found `a`
+}
--- /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.
+
+fn main() {
+ let be = 0;
+ //~^ ERROR `be` is a reserved keyword
+}
--- /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.
+
+struct Foo {
+ x: isize,
+}
+
+impl Foo {
+ fn hi(&self) -> bool {
+ true
+ }
+}
+
+fn main() {
+ for x in Foo {
+ x: 3 //~ ERROR expected one of `!`, `.`, `::`, `;`, `{`, `}`, or an operator, found `:`
+ }.hi() {
+ println!("yo");
+ }
+}
+
--- /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.
+
+struct Foo {
+ x: isize,
+}
+
+impl Foo {
+ fn hi(&self) -> bool {
+ true
+ }
+}
+
+fn main() {
+ if Foo {
+ x: 3 //~ ERROR expected one of `!`, `.`, `::`, `;`, `{`, `}`, or an operator, found `:`
+ }.hi() {
+ println!("yo");
+ }
+}
+
--- /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.
+
+struct Foo {
+ x: isize,
+}
+
+fn main() {
+ match Foo {
+ x: 3 //~ ERROR expected one of `!`, `=>`, `@`, `if`, or `|`, found `:`
+ } {
+ Foo {
+ x: x
+ } => {}
+ }
+}
+
--- /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.
+
+struct Foo {
+ x: isize,
+}
+
+impl Foo {
+ fn hi(&self) -> bool {
+ true
+ }
+}
+
+fn main() {
+ while Foo {
+ x: 3 //~ ERROR expected one of `!`, `.`, `::`, `;`, `{`, `}`, or an operator, found `:`
+ }.hi() {
+ println!("yo");
+ }
+}
+
--- /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.
+
+struct Foo(); //~ ERROR unit-like struct definition should be written as `struct Foo;`
+
+fn main() {}
--- /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.
+
+struct Foo {}
+//~^ ERROR: unit-like struct definition should be written as `struct Foo;`
+
+fn main() {}
--- /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.
+
+iface foo { } //~ ERROR iface
+
+fn main() {}
--- /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.
+
+
+// error-pattern: unterminated double quote string
+
+
+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.
+
+// Test that parentheses form doesn't work in expression paths.
+
+struct Bar<A,R> {
+ f: A, r: R
+}
+
+impl<A,B> Bar<A,B> {
+ fn new() -> Bar<A,B> { panic!() }
+}
+
+fn bar() {
+ let b = Box::Bar::<isize,usize>::new(); // OK
+
+ let b = Box::Bar::()::new();
+ //~^ ERROR expected ident, found `(`
+}
+
+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.
+
+// Test syntax checks for `type` keyword.
+
+struct S1 for type; //~ ERROR expected `where`, `{`, `(`, or `;` after struct name, found `for`
+
+pub 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.
+
+use std::any:: as foo; //~ ERROR expected identifier, found keyword `as`
+//~^ ERROR: expected one of `::`, `;`, or `as`, found `foo`
--- /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.
+
+use std::any::; //~ ERROR expected identifier or `{` or `*`, found `;`
--- /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 foo::self;
+//~^ ERROR expected identifier, found keyword `self`
+
+fn main() {}
+
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+extern {
+ fn printf(...); //~ ERROR: variadic function must be declared with at least one named argument
+ fn printf(..., foo: isize); //~ ERROR: `...` must be last in argument list for variadic function
+}
+
+fn main() {}
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn foo(x: isize, ...) {
+ //~^ ERROR: only foreign functions are allowed to be variadic
+}
+
+fn main() {}
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+extern "C" fn foo(x: isize, ...) {
+ //~^ ERROR: only foreign functions are allowed to be variadic
+}
+
+fn main() {}
+#![feature(no_std)]
#![no_std]
#[prelude_import]
use std::prelude::v1::*;
((::std::fmt::format as
- fn(core::fmt::Arguments<'_>) -> collections::string::String {std::fmt::format})(((::std::fmt::Arguments::new_v1
- as
- fn(&[&str], &[core::fmt::ArgumentV1<'_>]) -> core::fmt::Arguments<'_> {core::fmt::Arguments<'a>::new_v1})(({
- static __STATIC_FMTSTR:
- &'static [&'static str]
- =
- (&([("test"
+ fn(core::fmt::Arguments<'_>) -> collections::string::String {collections::fmt::format})(((::std::fmt::Arguments::new_v1
+ as
+ fn(&[&str], &[core::fmt::ArgumentV1<'_>]) -> core::fmt::Arguments<'_> {core::fmt::Arguments<'a>::new_v1})(({
+ static __STATIC_FMTSTR:
+ &'static [&'static str]
+ =
+ (&([("test"
+ as
+ &'static str)]
+ as
+ [&'static str; 1])
+ as
+ &'static [&'static str; 1]);
+ (__STATIC_FMTSTR
as
- &'static str)]
- as
- [&'static str; 1])
- as
- &'static [&'static str; 1]);
- (__STATIC_FMTSTR
- as
- &'static [&'static str])
- }
- as
- &[&str]),
- (&(match (()
- as
- ())
- {
- ()
- =>
- ([]
- as
- [core::fmt::ArgumentV1<'_>; 0]),
- }
- as
- [core::fmt::ArgumentV1<'_>; 0])
- as
- &[core::fmt::ArgumentV1<'_>; 0]))
- as
- core::fmt::Arguments<'_>))
+ &'static [&'static str])
+ }
+ as
+ &[&str]),
+ (&(match (()
+ as
+ ())
+ {
+ ()
+ =>
+ ([]
+ as
+ [core::fmt::ArgumentV1<'_>; 0]),
+ }
+ as
+ [core::fmt::ArgumentV1<'_>; 0])
+ as
+ &[core::fmt::ArgumentV1<'_>; 0]))
+ as
+ core::fmt::Arguments<'_>))
as collections::string::String);
}
pub type Foo = [i32; (3us as usize)];
--- /dev/null
+-include ../tools.mk
+
+all:
+ $(RUSTC) fakealloc.rs
+ $(RUSTC) ../../../liballoc/lib.rs --cfg feature=\"external_crate\" --extern external=$(TMPDIR)/$(shell $(RUSTC) --print file-names fakealloc.rs)
--- /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.
+
+#![crate_type = "rlib"]
+#![feature(no_std, core)]
+#![no_std]
+extern crate core;
+
+
+#[inline]
+pub unsafe fn allocate(_size: usize, _align: usize) -> *mut u8 { 0 as *mut u8 }
+
+#[inline]
+pub unsafe fn deallocate(_ptr: *mut u8, _old_size: usize, _align: usize) { }
+
+#[inline]
+pub unsafe fn reallocate(_ptr: *mut u8, _old_size: usize, _size: usize, _align: usize) -> *mut u8 {
+ 0 as *mut u8
+}
+
+#[inline]
+pub unsafe fn reallocate_inplace(_ptr: *mut u8, old_size: usize, _size: usize,
+ _align: usize) -> usize { old_size }
+
+#[inline]
+pub fn usable_size(size: usize, _align: usize) -> usize { size }
+
+#[inline]
+pub fn stats_print() { }
--- /dev/null
+-include ../tools.mk
+
+all:
+ $(RUSTC) foo.rs --crate-type staticlib
+ $(RUSTC) bar.rs 2>&1 | grep "error: found staticlib"
--- /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.
+
+extern crate foo;
+
+fn main() {
+ foo::foo();
+}
--- /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.
+
+pub fn foo() {}
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#![feature(no_std)]
#![no_std]
extern crate foo;
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#![feature(no_std)]
#![no_std]
#![crate_type = "lib"]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#![feature(lang_items, no_std)]
#![no_std]
-#![feature(lang_items)]
#![crate_type = "dylib"]
extern crate libc;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#![feature(lang_items, no_std)]
#![no_std]
-#![feature(lang_items)]
#![crate_type = "dylib"]
extern crate libc;
// except according to those terms.
// minimal junk
+#![feature(no_std)]
#![no_std]
// except according to those terms.
// minimal junk
+#![feature(no_std)]
#![no_std]
macro_rules! foo {
--- /dev/null
+-include ../tools.mk
+
+all: lib.rs
+ $(HOST_RPATH_ENV) $(RUSTDOC) -w html -o $(TMPDIR)/doc lib.rs
+ $(HTMLDOCCK) $(TMPDIR)/doc lib.rs
--- /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.
+
+#![crate_type="lib"]
+
+// @has lib/trait.Index.html
+pub trait Index<I: ?Sized> {
+ // @has - '//*[@id="associatedtype.Output"]//code' 'type Output: ?Sized'
+ type Output: ?Sized;
+ // @has - '//*[@id="tymethod.index"]//code' \
+ // "fn index<'a>(&'a self, index: I) -> &'a Self::Output"
+ fn index<'a>(&'a self, index: I) -> &'a Self::Output;
+}
--- /dev/null
+-include ../tools.mk
+
+all: foo.rs bar.rs
+ $(HOST_RPATH_ENV) $(RUSTC) foo.rs
+ $(HOST_RPATH_ENV) $(RUSTDOC) -w html -o $(TMPDIR)/doc foo.rs
+ $(HOST_RPATH_ENV) $(RUSTDOC) -L $(TMPDIR) -w html -o $(TMPDIR)/doc bar.rs
+ $(HTMLDOCCK) $(TMPDIR)/doc bar.rs
+
--- /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.
+
+extern crate foo;
+
+// @has bar/trait.Foo.html //pre "pub trait Foo"
+// @has - '//*[@id="tymethod.foo"]//code' 'extern "rust-call" fn foo'
+// @has - '//*[@id="tymethod.foo_"]//code' 'extern "rust-call" fn foo_'
+pub use foo::Foo;
+
+// @has bar/trait.Bar.html //pre "pub trait Bar"
+pub trait Bar {
+ // @has - '//*[@id="tymethod.bar"]//code' 'extern "rust-call" fn bar'
+ extern "rust-call" fn bar(&self, _: ());
+ // @has - '//*[@id="method.bar_"]//code' 'extern "rust-call" fn bar_'
+ extern "rust-call" fn bar_(&self, _: ()) { }
+}
--- /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.
+
+#![crate_type="lib"]
+
+pub trait Foo {
+ extern "rust-call" fn foo(&self, _: ()) -> i32;
+ extern "rust-call" fn foo_(&self, _: ()) -> i32 { 0 }
+}
--- /dev/null
+-include ../tools.mk
+
+all: lib.rs
+ $(HOST_RPATH_ENV) $(RUSTC) lib.rs
+ $(HOST_RPATH_ENV) $(RUSTDOC) -w html -o $(TMPDIR)/doc lib.rs
+ $(HOST_RPATH_ENV) $(RUSTDOC) -L $(TMPDIR) -w html -o $(TMPDIR)/doc user.rs
+ $(HTMLDOCCK) $(TMPDIR)/doc lib.rs
+ $(HTMLDOCCK) $(TMPDIR)/doc user.rs
--- /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.
+
+#![crate_type="lib"]
+
+extern "C" {
+ // @has lib/fn.foreigner.html //pre 'pub unsafe fn foreigner(cold_as_ice: u32)'
+ pub fn foreigner(cold_as_ice: u32);
+}
--- /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.
+
+#![crate_type="lib"]
+
+extern crate lib;
+
+// @has user/fn.foreigner.html //pre 'pub unsafe fn foreigner(cold_as_ice: u32)'
+pub use lib::foreigner;
pub fn foo() {}
// @!has foo/fn.foo.html invisible
-// @matches - //pre '#.*\[.*derive.*\(.*Eq.*\).*\].*//.*Bar'
-
+// @matches - //pre "#\[derive\(PartialEq\)\] // Bar"
// @matches foo/struct.Bravo.html '//pre' "pub struct Bravo<B>"
pub struct Bravo<B>;
-// @matches foo/struct.Alpha.html '//*[@class="impl"]//code' "impl !.*Send.* for .*Alpha"
+// @matches foo/struct.Alpha.html '//*[@class="impl"]//code' "impl !Send for Alpha"
impl !Send for Alpha {}
-// @matches foo/struct.Bravo.html '//*[@class="impl"]//code' "impl<B> !.*Send.* for .*Bravo.*<B>"
+// @matches foo/struct.Bravo.html '//*[@class="impl"]//code' "impl<B> !Send for Bravo<B>"
impl<B> !Send for Bravo<B> {}
pub trait MyTrait {}
-// @matches foo/struct.Alpha.html '//pre' "Alpha.*where.*A:.*MyTrait"
+// @has foo/struct.Alpha.html '//pre' "pub struct Alpha<A> where A: MyTrait"
pub struct Alpha<A> where A: MyTrait;
-// @matches foo/trait.Bravo.html '//pre' "Bravo.*where.*B:.*MyTrait"
+// @has foo/trait.Bravo.html '//pre' "pub trait Bravo<B> where B: MyTrait"
pub trait Bravo<B> where B: MyTrait {}
-// @matches foo/fn.charlie.html '//pre' "charlie.*where.*C:.*MyTrait"
+// @has foo/fn.charlie.html '//pre' "pub fn charlie<C>() where C: MyTrait"
pub fn charlie<C>() where C: MyTrait {}
pub struct Delta<D>;
-// @matches foo/struct.Delta.html '//*[@class="impl"]//code' "impl.*Delta.*where.*D:.*MyTrait"
+// @has foo/struct.Delta.html '//*[@class="impl"]//code' \
+// "impl<D> Delta<D> where D: MyTrait"
impl<D> Delta<D> where D: MyTrait {
pub fn delta() {}
}
pub struct Echo<E>;
-// @matches foo/struct.Echo.html '//*[@class="impl"]//code' \
-// "impl.*MyTrait.*for.*Echo.*where.*E:.*MyTrait"
-// @matches foo/trait.MyTrait.html '//*[@id="implementors-list"]//code' \
-// "impl.*MyTrait.*for.*Echo.*where.*E:.*MyTrait"
+// @has foo/struct.Echo.html '//*[@class="impl"]//code' \
+// "impl<E> MyTrait for Echo<E> where E: MyTrait"
+// @has foo/trait.MyTrait.html '//*[@id="implementors-list"]//code' \
+// "impl<E> MyTrait for Echo<E> where E: MyTrait"
impl<E> MyTrait for Echo<E> where E: MyTrait {}
pub enum Foxtrot<F> {}
-// @matches foo/enum.Foxtrot.html '//*[@class="impl"]//code' \
-// "impl.*MyTrait.*for.*Foxtrot.*where.*F:.*MyTrait"
-// @matches foo/trait.MyTrait.html '//*[@id="implementors-list"]//code' \
-// "impl.*MyTrait.*for.*Foxtrot.*where.*F:.*MyTrait"
+// @has foo/enum.Foxtrot.html '//*[@class="impl"]//code' \
+// "impl<F> MyTrait for Foxtrot<F> where F: MyTrait"
+// @has foo/trait.MyTrait.html '//*[@id="implementors-list"]//code' \
+// "impl<F> MyTrait for Foxtrot<F> where F: MyTrait"
impl<F> MyTrait for Foxtrot<F> where F: MyTrait {}
extern crate "flate" as myflate;
-use graphviz::maybe_owned_vec::MaybeOwnedVector;
use std::collections::{HashMap,HashSet};
use std::cell::RefCell;
use std::old_io::stdio::println;
static uni: &'static str = "Les Miséééééééérables";
static yy: usize = 25us;
-static bob: Option<graphviz::maybe_owned_vec::MaybeOwnedVector<'static, isize>> = None;
+static bob: Option<std::vec::CowVec<'static, isize>> = None;
// buglink test - see issue #1337.
#![crate_type = "lib"]
// we can compile to a variety of platforms, because we don't need
// cross-compiled standard libraries.
+#![feature(no_std)]
#![no_std]
#![feature(simd, simd_ffi, link_llvm_intrinsics, lang_items)]
#[lang = "copy"]
trait Copy {}
-mod std {
+mod core {
pub mod marker {
pub use Copy;
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-#![feature(lang_items)]
+#![feature(lang_items, no_std)]
#![no_std]
#[lang="copy"]
--- /dev/null
+-include ../tools.mk
+
+HOST := $(shell $(RUSTC) -vV | grep 'host:' | sed 's/host: //')
+ifeq ($(findstring i686,$(HOST)),i686)
+TARGET := $(subst i686,x86_64,$(HOST))
+else
+TARGET := $(subst x86_64,i686,$(HOST))
+endif
+
+all:
+ $(RUSTC) foo.rs -C extra-filename=-host
+ $(RUSTC) bar.rs -C extra-filename=-targ --target $(TARGET)
+ $(RUSTC) baz.rs --extern a=$(TMPDIR)/liba-targ.rlib --target $(TARGET)
--- /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.
+
+#![feature(no_std)]
+#![no_std]
+#![crate_type = "lib"]
+#![crate_name = "a"]
+
+#[macro_export]
+macro_rules! 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.
+
+#![feature(no_std)]
+#![no_std]
+#![crate_type = "lib"]
+
+#[macro_use]
+extern crate a;
+
+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.
+
+#![feature(no_std)]
+#![no_std]
+#![crate_type = "lib"]
+#![crate_name = "a"]
+
+#[macro_export]
+macro_rules! foo {
+ () => ()
+}
--- /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 the CompilerCalls interface to the compiler works.
+
+// ignore-android
+
+#![feature(rustc_private)]
+#![feature(core)]
+
+extern crate getopts;
+extern crate rustc;
+extern crate rustc_driver;
+extern crate syntax;
+
+use rustc::session::Session;
+use rustc::session::config::{self, Input};
+use rustc_driver::{driver, CompilerCalls, Compilation};
+use syntax::diagnostics;
+
+
+struct TestCalls {
+ count: u32
+}
+
+impl<'a> CompilerCalls<'a> for TestCalls {
+ fn early_callback(&mut self,
+ _: &getopts::Matches,
+ _: &diagnostics::registry::Registry)
+ -> Compilation {
+ self.count *= 2;
+ Compilation::Continue
+ }
+
+ fn late_callback(&mut self,
+ _: &getopts::Matches,
+ _: &Session,
+ _: &Input,
+ _: &Option<Path>,
+ _: &Option<Path>)
+ -> Compilation {
+ self.count *= 3;
+ Compilation::Stop
+ }
+
+ fn some_input(&mut self, input: Input, input_path: Option<Path>) -> (Input, Option<Path>) {
+ self.count *= 5;
+ (input, input_path)
+ }
+
+ fn no_input(&mut self,
+ _: &getopts::Matches,
+ _: &config::Options,
+ _: &Option<Path>,
+ _: &Option<Path>,
+ _: &diagnostics::registry::Registry)
+ -> Option<(Input, Option<Path>)> {
+ panic!("This shouldn't happen");
+ }
+
+ fn build_controller(&mut self, _: &Session) -> driver::CompileController<'a> {
+ panic!("This shouldn't be called");
+ }
+}
+
+
+fn main() {
+ let mut tc = TestCalls { count: 1 };
+ // we should never get use this filename, but lets make sure they are valid args.
+ let args = vec!["compiler-calls".to_string(), "foo.rs".to_string()];
+ rustc_driver::run_compiler(args.as_slice(), &mut tc);
+ assert!(tc.count == 30);
+}
+
// ignore-android
// aux-build:issue_16723_multiple_items_syntax_ext.rs
#![feature(plugin)]
-
-#[plugin] #[no_link] extern crate issue_16723_multiple_items_syntax_ext;
+#![plugin(issue_16723_multiple_items_syntax_ext)]
multiple_items!();
// ignore-pretty
#![feature(plugin)]
-
-#[plugin] #[no_link]
-extern crate lint_group_plugin_test;
+#![plugin(lint_group_plugin_test)]
fn lintme() { } //~ WARNING item is named 'lintme'
fn pleaselintme() { } //~ WARNING item is named 'pleaselintme'
// compile-flags: -A test-lint
#![feature(plugin)]
-
-#[plugin] #[no_link]
-extern crate lint_plugin_test;
+#![plugin(lint_plugin_test)]
fn lintme() { }
// ignore-pretty
#![feature(plugin)]
-
-#[plugin] #[no_link]
-extern crate lint_plugin_test;
+#![plugin(lint_plugin_test)]
fn lintme() { } //~ WARNING item is named 'lintme'
// uses `quote_expr!` to rearrange it should be hygiene-preserving.
#![feature(plugin)]
-
-#[plugin] #[no_link]
-extern crate macro_crate_test;
+#![plugin(macro_crate_test)]
fn main() {
let x = 3;
// ignore-stage1
#![feature(plugin)]
-
-#[plugin] #[no_link]
-extern crate plugin_crate_outlive_expansion_phase;
+#![plugin(plugin_crate_outlive_expansion_phase)]
pub fn main() {}
// ignore-stage1
#![feature(plugin)]
+#![plugin(macro_crate_test)]
-#[macro_use] #[plugin] #[no_link]
+#[macro_use] #[no_link]
extern crate macro_crate_test;
#[into_foo]
// ignore-stage1
#![feature(plugin)]
-
-#[no_link]
-#[plugin]
-extern crate plugin_args;
+#![plugin(plugin_args)]
fn main() {
- assert_eq!(plugin_args!(), "#[plugin]");
+ assert_eq!(plugin_args!(), "");
}
// ignore-stage1
#![feature(plugin)]
-
-#[no_link]
-#[plugin()]
-extern crate plugin_args;
+#![plugin(plugin_args())]
fn main() {
- assert_eq!(plugin_args!(), "#[plugin()]");
+ assert_eq!(plugin_args!(), "");
}
// ignore-stage1
#![feature(plugin)]
-
-#[no_link]
-#[plugin(hello(there), how(are="you"))]
-extern crate plugin_args;
+#![plugin(plugin_args(hello(there), how(are="you")))]
fn main() {
- assert_eq!(plugin_args!(), "#[plugin(hello(there), how(are = \"you\"))]");
+ assert_eq!(plugin_args!(), "hello(there), how(are = \"you\")");
}
+++ /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.
-
-// aux-build:plugin_args.rs
-// ignore-stage1
-
-#![feature(plugin)]
-
-#[no_link]
-#[plugin="foobar"]
-extern crate plugin_args;
-
-fn main() {
- assert_eq!(plugin_args!(), "#[plugin = \"foobar\"]");
-}
+++ /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.
-
-// aux-build:macro_crate_test.rs
-// ignore-stage1
-// ignore-cross-compile
-//
-// macro_crate_test will not compile on a cross-compiled target because
-// libsyntax is not compiled for it.
-
-#![feature(plugin)]
-
-#[plugin]
-extern crate macro_crate_test;
-
-fn main() {
- assert_eq!(1, make_a_1!());
- macro_crate_test::foo();
-}
--- /dev/null
+// 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.
+//
+// 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.
+
+// aux-build:macro_crate_test.rs
+// ignore-stage1
+// ignore-cross-compile
+//
+// macro_crate_test will not compile on a cross-compiled target because
+// libsyntax is not compiled for it.
+
+#![feature(plugin)]
+#![plugin(macro_crate_test)]
+
+extern crate macro_crate_test;
+
+fn main() {
+ assert_eq!(1, make_a_1!());
+ macro_crate_test::foo();
+}
// ignore-stage1
#![feature(plugin)]
-
-#[plugin] #[no_link]
-extern crate roman_numerals;
+#![plugin(roman_numerals)]
pub fn main() {
assert_eq!(rn!(MMXV), 2015);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// aux-build:syntax-extension-with-dll-deps-1.rs
-// aux-build:syntax-extension-with-dll-deps-2.rs
+// aux-build:syntax_extension_with_dll_deps_1.rs
+// aux-build:syntax_extension_with_dll_deps_2.rs
// ignore-stage1
#![feature(plugin)]
-
-#[plugin] #[no_link]
-extern crate "syntax-extension-with-dll-deps-2" as extension;
+#![plugin(syntax_extension_with_dll_deps_2)]
fn main() {
foo!();
--- /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.
+
+// Check that we do not report ambiguities when equivalent predicates
+// (modulo bound lifetime names) appears in the environment
+// twice. Issue #21965.
+
+fn foo<T>(t: T) -> i32
+ where T : for<'a> Fn(&'a u8) -> i32,
+ T : for<'b> Fn(&'b u8) -> i32,
+{
+ t(&3)
+}
+
+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.
+
+// Check that we do not report ambiguities when the same predicate
+// appears in the environment twice. Issue #21965.
+
+trait Foo {
+ type B;
+
+ fn get() -> Self::B;
+}
+
+fn foo<T>() -> ()
+ where T : Foo<B=()>, T : Foo<B=()>
+{
+ <T as Foo>::get()
+}
+
+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.
+
+// Ensure that we can copy out of a fixed-size array.
+//
+// (Compare with compile-fail/move-out-of-array-1.rs)
+
+struct C { _x: u8 }
+
+impl Copy for C { }
+
+fn main() {
+ fn d() -> C { C { _x: 0 } }
+
+ let _d1 = foo([d(), d(), d(), d()], 1);
+ let _d3 = foo([d(), d(), d(), d()], 3);
+}
+
+fn foo(a: [C; 4], i: usize) -> C {
+ a[i]
+}
--- /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.
+
+#![feature(no_std)]
+#![no_std]
+
+extern crate core;
+extern crate rand;
+extern crate "serialize" as rustc_serialize;
+extern crate collections;
+
+// Issue #16803
+
+#[derive(Clone, Hash, PartialEq, Eq, PartialOrd, Ord,
+ Debug, Default, Copy)]
+struct Foo {
+ x: u32,
+}
+
+#[derive(Clone, Hash, PartialEq, Eq, PartialOrd, Ord,
+ Debug, Copy)]
+enum Bar {
+ Qux,
+ Quux(u32),
+}
+
+#[derive(FromPrimitive)]
+enum Baz { A=0, B=5, }
+
+fn main() {
+ Foo { x: 0 };
+ Bar::Quux(3);
+ Baz::A;
+}
--- /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.
+
+// Ensure that we can do a destructuring bind of a fixed-size array,
+// even when the element type has a destructor.
+
+struct D { x: u8 }
+
+impl Drop for D { fn drop(&mut self) { } }
+
+fn main() {
+ fn d(x: u8) -> D { D { x: x } }
+
+ let d1 = foo([d(1), d(2), d(3), d(4)], 1);
+ let d3 = foo([d(5), d(6), d(7), d(8)], 3);
+ assert_eq!(d1.x, 2);
+ assert_eq!(d3.x, 8);
+}
+
+fn foo([a, b, c, d]: [D; 4], i: usize) -> D {
+ match i {
+ 0 => a,
+ 1 => b,
+ 2 => c,
+ 3 => d,
+ _ => panic!("unmatched"),
+ }
+}
--- /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.
+
+#![feature(lang_items, start, no_std)]
+#![no_std]
+
+extern crate "std" as other;
+
+#[macro_use] extern crate core;
+#[macro_use] extern crate collections;
+
+use core::slice::SliceExt;
+
+#[start]
+fn start(_argc: int, _argv: *const *const u8) -> int {
+ for _ in [1,2,3].iter() { }
+ 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.
+
+#![feature(lang_items, start, no_std)]
+#![no_std]
+
+extern crate "std" as other;
+
+#[macro_use] extern crate core;
+#[macro_use] extern crate collections;
+
+use collections::string::ToString;
+
+#[start]
+fn start(_argc: int, _argv: *const *const u8) -> int {
+ let s = format!("{}", 1i);
+ assert_eq!(s, "1".to_string());
+
+ let s = format!("test");
+ assert_eq!(s, "test".to_string());
+
+ let s = format!("{test}", test=3i);
+ assert_eq!(s, "3".to_string());
+
+ let s = format!("hello {}", "world");
+ assert_eq!(s, "hello world".to_string());
+
+ 0
+}
+// no-prefer-dynamic
+
// 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.
--- /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.
+
+static foo: [uint; 3] = [1, 2, 3];
+
+static slice_1: &'static [uint] = &foo;
+static slice_2: &'static [uint] = &foo;
+
+fn main() {}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// Regresion test for issue 7660
+// Regression test for issue 7660
// rvalue lifetime too short when equivalent `match` works
extern crate collections;
// ignore-android
// ignore-windows #13361
+#![feature(lang_items, start, no_std)]
#![no_std]
-#![feature(lang_items, start)]
extern crate "lang-item-public" as lang_lib;
fn main() {
let mut foo = Vec::new();
'foo: for i in &[1, 2, 3] {
- foo.push(i);
+ foo.push(*i);
}
}
// This tests that libraries built with #[no_std] can be linked to crates with
// #[no_std] and actually run.
+#![feature(no_std)]
#![no_std]
extern crate no_std_crate;
}
impl IndexMut<int> for Foo {
- type Output = int;
-
fn index_mut(&mut self, z: &int) -> &mut int {
if *z == 0 {
&mut self.x
}
impl IndexMut<int> for Foo {
- type Output = int;
-
fn index_mut(&mut self, z: &int) -> &mut int {
if *z == 0 {
&mut self.x
use TypeStructure::{TypeInt, TypeFunction};
use AstKind::{ExprInt, ExprVar, ExprLambda};
-use arena::Arena;
+use arena::TypedArena;
use std::collections::HashMap;
use std::mem;
impl<'tcx> Eq for TypeStructure<'tcx> {}
+type TyArena<'tcx> = TypedArena<TypeStructure<'tcx>>;
+type AstArena<'ast> = TypedArena<AstStructure<'ast>>;
+
struct TypeContext<'tcx, 'ast> {
- ty_arena: &'tcx Arena,
+ ty_arena: &'tcx TyArena<'tcx>,
types: Vec<Type<'tcx>> ,
type_table: HashMap<NodeId, Type<'tcx>>,
- ast_arena: &'ast Arena,
+ ast_arena: &'ast AstArena<'ast>,
ast_counter: uint,
}
impl<'tcx,'ast> TypeContext<'tcx, 'ast> {
- fn new(ty_arena: &'tcx Arena, ast_arena: &'ast Arena)
+ fn new(ty_arena: &'tcx TyArena<'tcx>, ast_arena: &'ast AstArena<'ast>)
-> TypeContext<'tcx, 'ast> {
TypeContext { ty_arena: ty_arena,
types: Vec::new(),
}
}
- let ty = self.ty_arena.alloc(|| s);
+ let ty = self.ty_arena.alloc(s);
self.types.push(ty);
ty
}
fn ast(&mut self, a: AstKind<'ast>) -> Ast<'ast> {
let id = self.ast_counter;
self.ast_counter += 1;
- self.ast_arena.alloc(|| AstStructure { id: NodeId {id:id}, kind: a })
+ self.ast_arena.alloc(AstStructure { id: NodeId {id:id}, kind: a })
}
}
}
pub fn main() {
- let ty_arena = arena::Arena::new();
- let ast_arena = arena::Arena::new();
+ let ty_arena = TypedArena::new();
+ let ast_arena = TypedArena::new();
let mut tcx = TypeContext::new(&ty_arena, &ast_arena);
let ast = tcx.ast(ExprInt);
let ty = compute_types(&mut tcx, ast);
}
impl IndexMut<Range<Foo>> for Foo {
- type Output = Foo;
fn index_mut(&mut self, index: &Range<Foo>) -> &mut Foo {
unsafe { COUNT += 1; }
self
}
}
impl IndexMut<RangeTo<Foo>> for Foo {
- type Output = Foo;
fn index_mut(&mut self, index: &RangeTo<Foo>) -> &mut Foo {
unsafe { COUNT += 1; }
self
}
}
impl IndexMut<RangeFrom<Foo>> for Foo {
- type Output = Foo;
fn index_mut(&mut self, index: &RangeFrom<Foo>) -> &mut Foo {
unsafe { COUNT += 1; }
self
}
}
impl IndexMut<RangeFull> for Foo {
- type Output = Foo;
fn index_mut(&mut self, _index: &RangeFull) -> &mut Foo {
unsafe { COUNT += 1; }
self
// Smallest "hello world" with a libc runtime
+#![feature(intrinsics, lang_items, start, no_std)]
#![no_std]
-#![feature(intrinsics, lang_items, start)]
extern crate libc;
// except according to those terms.
#![allow(unused_imports)]
-#![feature(start)]
+#![feature(start, no_std)]
#![no_std]
extern crate std;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-#![feature(lang_items, start)]
+#![feature(lang_items, start, no_std)]
#![no_std]
extern crate "std" as other;
--- /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 can quantify lifetimes outside a constraint (i.e., including
+// the self type) in a where clause.
+
+static mut COUNT: u32 = 1;
+
+trait Bar<'a> {
+ fn bar(&self);
+}
+
+trait Baz<'a> {
+ fn baz(&self);
+}
+
+impl<'a, 'b> Bar<'b> for &'a u32 {
+ fn bar(&self) {
+ unsafe { COUNT *= 2; }
+ }
+}
+
+impl<'a, 'b> Baz<'b> for &'a u32 {
+ fn baz(&self) {
+ unsafe { COUNT *= 3; }
+ }
+}
+
+// Test we can use the syntax for HRL including the self type.
+fn foo1<T>(x: &T)
+ where for<'a, 'b> &'a T: Bar<'b>
+{
+ x.bar()
+}
+
+// Test we can quantify multiple bounds (i.e., the precedence is sensible).
+fn foo2<T>(x: &T)
+ where for<'a, 'b> &'a T: Bar<'b> + Baz<'b>
+{
+ x.baz();
+ x.bar()
+}
+
+fn main() {
+ let x = 42u32;
+ foo1(&x);
+ foo2(&x);
+ unsafe {
+ assert!(COUNT == 12);
+ }
+}
+
projects / rust.git / commitdiff