dnrops
/
rust
mirror of https://github.com/rust-lang/rust.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

test: Make manual changes to deal with the fallout from removal of 

`~[T]` in test, libgetopts, compiletest, librustdoc, and libnum.
This commit is contained in:
Patrick Walton 2014-03-05 15:28:08 -08:00 committed by Huon Wilson
parent 579eb2400b
commit af79a5aa7d
236 changed files with 1435 additions and 1311 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
src/compiletest/compiletest.rs
View File

@ -21,6 +21,7 @@ extern crate getopts;
extern crate log;
use std::os;
use std::vec_ng::Vec;
use std::io;
use std::io::fs;
use getopts::{optopt, optflag, reqopt};
@ -43,15 +44,15 @@ pub mod errors;
pub fn main() {
let args = os::args();
let config = parse_config(args);
let config = parse_config(args.move_iter().collect());
log_config(&config);
run_tests(&config);
}
pub fn parse_config(args: ~[~str]) -> config {
pub fn parse_config(args: Vec<~str> ) -> config {
let groups : ~[getopts::OptGroup] =
~[reqopt("", "compile-lib-path", "path to host shared libraries", "PATH"),
let groups : Vec<getopts::OptGroup> =
vec!(reqopt("", "compile-lib-path", "path to host shared libraries", "PATH"),
reqopt("", "run-lib-path", "path to target shared libraries", "PATH"),
reqopt("", "rustc-path", "path to rustc to use for compiling", "PATH"),
optopt("", "clang-path", "path to executable for codegen tests", "PATH"),
@ -79,28 +80,27 @@ pub fn parse_config(args: ~[~str]) -> config {
optopt("", "adb-path", "path to the android debugger", "PATH"),
optopt("", "adb-test-dir", "path to tests for the android debugger", "PATH"),
optopt("", "test-shard", "run shard A, of B shards, worth of the testsuite", "A.B"),
optflag("h", "help", "show this message"),
];
optflag("h", "help", "show this message"));
assert!(!args.is_empty());
let argv0 = args[0].clone();
let argv0 = (*args.get(0)).clone();
let args_ = args.tail();
if args[1] == ~"-h" || args[1] == ~"--help" {
if *args.get(1) == ~"-h" || *args.get(1) == ~"--help" {
let message = format!("Usage: {} [OPTIONS] [TESTNAME...]", argv0);
println!("{}", getopts::usage(message, groups));
println!("{}", getopts::usage(message, groups.as_slice()));
println!("");
fail!()
}
let matches =
&match getopts::getopts(args_, groups) {
&match getopts::getopts(args_, groups.as_slice()) {
Ok(m) => m,
Err(f) => fail!("{}", f.to_err_msg())
};
if matches.opt_present("h") || matches.opt_present("help") {
let message = format!("Usage: {} [OPTIONS] [TESTNAME...]", argv0);
println!("{}", getopts::usage(message, groups));
println!("{}", getopts::usage(message, groups.as_slice()));
println!("");
fail!()
}
@ -123,7 +123,7 @@ pub fn parse_config(args: ~[~str]) -> config {
run_ignored: matches.opt_present("ignored"),
filter:
if !matches.free.is_empty() {
Some(matches.free[0].clone())
Some((*matches.free.get(0)).clone())
} else {
None
},
@ -239,7 +239,7 @@ pub fn run_tests(config: &config) {
// parallel (especially when we have lots and lots of child processes).
// For context, see #8904
io::test::raise_fd_limit();
let res = test::run_tests_console(&opts, tests);
let res = test::run_tests_console(&opts, tests.move_iter().collect());
match res {
Ok(true) => {}
Ok(false) => fail!("Some tests failed"),
@ -263,10 +263,10 @@ pub fn test_opts(config: &config) -> test::TestOpts {
}
}
pub fn make_tests(config: &config) -> ~[test::TestDescAndFn] {
pub fn make_tests(config: &config) -> Vec<test::TestDescAndFn> {
debug!("making tests from {}",
config.src_base.display());
let mut tests = ~[];
let mut tests = Vec::new();
let dirs = fs::readdir(&config.src_base).unwrap();
for file in dirs.iter() {
let file = file.clone();
@ -288,10 +288,10 @@ pub fn is_test(config: &config, testfile: &Path) -> bool {
// Pretty-printer does not work with .rc files yet
let valid_extensions =
match config.mode {
mode_pretty => ~[~".rs"],
_ => ~[~".rc", ~".rs"]
mode_pretty => vec!(~".rs"),
_ => vec!(~".rc", ~".rs")
};
let invalid_prefixes = ~[~".", ~"#", ~"~"];
let invalid_prefixes = vec!(~".", ~"#", ~"~");
let name = testfile.filename_str().unwrap();
let mut valid = false;

13
src/compiletest/errors.rs
View File

@ -9,13 +9,14 @@
// except according to those terms.
use std::io::{BufferedReader, File};
use std::vec_ng::Vec;
pub struct ExpectedError { line: uint, kind: ~str, msg: ~str }
// Load any test directives embedded in the file
pub fn load_errors(testfile: &Path) -> ~[ExpectedError] {
pub fn load_errors(testfile: &Path) -> Vec<ExpectedError> {
let mut error_patterns = ~[];
let mut error_patterns = Vec::new();
let mut rdr = BufferedReader::new(File::open(testfile).unwrap());
let mut line_num = 1u;
for ln in rdr.lines() {
@ -25,12 +26,12 @@ pub fn load_errors(testfile: &Path) -> ~[ExpectedError] {
return error_patterns;
}
fn parse_expected(line_num: uint, line: ~str) -> ~[ExpectedError] {
fn parse_expected(line_num: uint, line: ~str) -> Vec<ExpectedError> {
let line = line.trim();
let error_tag = ~"//~";
let mut idx;
match line.find_str(error_tag) {
None => return ~[],
None => return Vec::new(),
Some(nn) => { idx = (nn as uint) + error_tag.len(); }
}
@ -57,6 +58,6 @@ fn parse_expected(line_num: uint, line: ~str) -> ~[ExpectedError] {
debug!("line={} kind={} msg={}", line_num - adjust_line, kind, msg);
return ~[ExpectedError{line: line_num - adjust_line, kind: kind,
msg: msg}];
return vec!(ExpectedError{line: line_num - adjust_line, kind: kind,
msg: msg});
}

24
src/compiletest/header.rs
View File

@ -12,22 +12,24 @@ use common::config;
use common;
use util;
use std::vec_ng::Vec;
pub struct TestProps {
// Lines that should be expected, in order, on standard out
error_patterns: ~[~str],
error_patterns: Vec<~str> ,
// Extra flags to pass to the compiler
compile_flags: Option<~str>,
// If present, the name of a file that this test should match when
// pretty-printed
pp_exact: Option<Path>,
// Modules from aux directory that should be compiled
aux_builds: ~[~str],
aux_builds: Vec<~str> ,
// Environment settings to use during execution
exec_env: ~[(~str,~str)],
exec_env: Vec<(~str,~str)> ,
// Commands to be given to the debugger, when testing debug info
debugger_cmds: ~[~str],
debugger_cmds: Vec<~str> ,
// Lines to check if they appear in the expected debugger output
check_lines: ~[~str],
check_lines: Vec<~str> ,
// Flag to force a crate to be built with the host architecture
force_host: bool,
// Check stdout for error-pattern output as well as stderr
@ -38,13 +40,13 @@ pub struct TestProps {
// Load any test directives embedded in the file
pub fn load_props(testfile: &Path) -> TestProps {
let mut error_patterns = ~[];
let mut aux_builds = ~[];
let mut exec_env = ~[];
let mut error_patterns = Vec::new();
let mut aux_builds = Vec::new();
let mut exec_env = Vec::new();
let mut compile_flags = None;
let mut pp_exact = None;
let mut debugger_cmds = ~[];
let mut check_lines = ~[];
let mut debugger_cmds = Vec::new();
let mut check_lines = Vec::new();
let mut force_host = false;
let mut check_stdout = false;
let mut no_prefer_dynamic = false;
@ -183,7 +185,7 @@ fn parse_no_prefer_dynamic(line: &str) -> bool {
fn parse_exec_env(line: &str) -> Option<(~str, ~str)> {
parse_name_value_directive(line, ~"exec-env").map(|nv| {
// nv is either FOO or FOO=BAR
let mut strs: ~[~str] = nv.splitn('=', 1).map(|s| s.to_owned()).collect();
let mut strs: Vec<~str> = nv.splitn('=', 1).map(|s| s.to_owned()).collect();
match strs.len() {
1u => (strs.pop().unwrap(), ~""),

17
src/compiletest/procsrv.rs
View File

@ -11,9 +11,10 @@
use std::os;
use std::str;
use std::io::process::{ProcessExit, Process, ProcessConfig, ProcessOutput};
use std::vec;
#[cfg(target_os = "win32")]
fn target_env(lib_path: &str, prog: &str) -> ~[(~str,~str)] {
fn target_env(lib_path: &str, prog: &str) -> Vec<(~str,~str)> {
let mut env = os::env();
@ -35,11 +36,11 @@ fn target_env(lib_path: &str, prog: &str) -> ~[(~str,~str)] {
#[cfg(target_os = "linux")]
#[cfg(target_os = "macos")]
#[cfg(target_os = "freebsd")]
fn target_env(lib_path: &str, prog: &str) -> ~[(~str,~str)] {
fn target_env(lib_path: &str, prog: &str) -> Vec<(~str,~str)> {
// Make sure we include the aux directory in the path
let aux_path = prog + ".libaux";
let mut env = os::env();
let mut env: Vec<(~str,~str)> = os::env().move_iter().collect();
let var = if cfg!(target_os = "macos") {
"DYLD_LIBRARY_PATH"
} else {
@ -62,10 +63,11 @@ pub struct Result {status: ProcessExit, out: ~str, err: ~str}
pub fn run(lib_path: &str,
prog: &str,
args: &[~str],
env: ~[(~str, ~str)],
env: Vec<(~str, ~str)> ,
input: Option<~str>) -> Option<Result> {
let env = env + target_env(lib_path, prog);
let env = vec::append(env.clone(),
target_env(lib_path, prog).as_slice());
let mut opt_process = Process::configure(ProcessConfig {
program: prog,
args: args,
@ -93,10 +95,11 @@ pub fn run(lib_path: &str,
pub fn run_background(lib_path: &str,
prog: &str,
args: &[~str],
env: ~[(~str, ~str)],
env: Vec<(~str, ~str)> ,
input: Option<~str>) -> Option<Process> {
let env = env + target_env(lib_path, prog);
let env = vec::append(env.clone(),
target_env(lib_path, prog).as_slice());
let opt_process = Process::configure(ProcessConfig {
program: prog,
args: args,

180
src/compiletest/runtest.rs
View File

@ -33,6 +33,7 @@ use std::os;
use std::str;
use std::task;
use std::slice;
use std::vec_ng;
use test::MetricMap;
@ -155,12 +156,14 @@ fn run_pretty_test(config: &config, props: &TestProps, testfile: &Path) {
let src = File::open(testfile).read_to_end().unwrap();
let src = str::from_utf8_owned(src).unwrap();
let mut srcs = ~[src];
let mut srcs = vec!(src);
let mut round = 0;
while round < rounds {
logv(config, format!("pretty-printing round {}", round));
let proc_res = print_source(config, testfile, srcs[round].clone());
let proc_res = print_source(config,
testfile,
(*srcs.get(round)).clone());
if !proc_res.status.success() {
fatal_ProcRes(format!("pretty-printing failed in round {}", round),
@ -178,9 +181,9 @@ fn run_pretty_test(config: &config, props: &TestProps, testfile: &Path) {
let s = File::open(&filepath).read_to_end().unwrap();
str::from_utf8_owned(s).unwrap()
}
None => { srcs[srcs.len() - 2u].clone() }
None => { (*srcs.get(srcs.len() - 2u)).clone() }
};
let mut actual = srcs[srcs.len() - 1u].clone();
let mut actual = (*srcs.get(srcs.len() - 1u)).clone();
if props.pp_exact.is_some() {
// Now we have to care about line endings
@ -202,12 +205,12 @@ fn run_pretty_test(config: &config, props: &TestProps, testfile: &Path) {
fn print_source(config: &config, testfile: &Path, src: ~str) -> ProcRes {
compose_and_run(config, testfile, make_pp_args(config, testfile),
~[], config.compile_lib_path, Some(src))
Vec::new(), config.compile_lib_path, Some(src))
}
fn make_pp_args(config: &config, _testfile: &Path) -> ProcArgs {
let args = ~[~"-", ~"--pretty", ~"normal",
~"--target=" + config.target];
let args = vec!(~"-", ~"--pretty", ~"normal",
~"--target=" + config.target);
// FIXME (#9639): This needs to handle non-utf8 paths
return ProcArgs {prog: config.rustc_path.as_str().unwrap().to_owned(), args: args};
}
@ -244,12 +247,12 @@ actual:\n\
config.target.as_slice()
};
// FIXME (#9639): This needs to handle non-utf8 paths
let mut args = ~[~"-",
let mut args = vec!(~"-",
~"--no-trans", ~"--crate-type=lib",
~"--target=" + target,
~"-L", config.build_base.as_str().unwrap().to_owned(),
~"-L",
aux_dir.as_str().unwrap().to_owned()];
aux_dir.as_str().unwrap().to_owned());
args.push_all_move(split_maybe_args(&config.target_rustcflags));
args.push_all_move(split_maybe_args(&props.compile_flags));
// FIXME (#9639): This needs to handle non-utf8 paths
@ -295,12 +298,12 @@ fn run_debuginfo_test(config: &config, props: &TestProps, testfile: &Path) {
procsrv::run("", config.adb_path,
[~"push", exe_file.as_str().unwrap().to_owned(),
config.adb_test_dir.clone()],
~[(~"",~"")], Some(~""))
vec!((~"",~"")), Some(~""))
.expect(format!("failed to exec `{}`", config.adb_path));
procsrv::run("", config.adb_path,
[~"forward", ~"tcp:5039", ~"tcp:5039"],
~[(~"",~"")], Some(~""))
vec!((~"",~"")), Some(~""))
.expect(format!("failed to exec `{}`", config.adb_path));
let adb_arg = format!("export LD_LIBRARY_PATH={}; gdbserver :5039 {}/{}",
@ -309,7 +312,7 @@ fn run_debuginfo_test(config: &config, props: &TestProps, testfile: &Path) {
let mut process = procsrv::run_background("", config.adb_path,
[~"shell",adb_arg.clone()],
~[(~"",~"")], Some(~""))
vec!((~"",~"")), Some(~""))
.expect(format!("failed to exec `{}`", config.adb_path));
loop {
//waiting 1 second for gdbserver start
@ -341,17 +344,21 @@ fn run_debuginfo_test(config: &config, props: &TestProps, testfile: &Path) {
let debugger_script = make_out_name(config, testfile, "debugger.script");
// FIXME (#9639): This needs to handle non-utf8 paths
let debugger_opts = ~[~"-quiet", ~"-batch", ~"-nx",
"-command=" + debugger_script.as_str().unwrap().to_owned()];
let debugger_opts = vec!(~"-quiet", ~"-batch", ~"-nx",
"-command=" + debugger_script.as_str().unwrap().to_owned());
let gdb_path = tool_path.append("/bin/arm-linux-androideabi-gdb");
let procsrv::Result{ out, err, status }=
procsrv::run("",
gdb_path,
debugger_opts, ~[(~"",~"")], None)
debugger_opts.as_slice(),
vec!((~"",~"")),
None)
.expect(format!("failed to exec `{}`", gdb_path));
let cmdline = {
let cmdline = make_cmdline("", "arm-linux-androideabi-gdb", debugger_opts);
let cmdline = make_cmdline("",
"arm-linux-androideabi-gdb",
debugger_opts.as_slice());
logv(config, format!("executing {}", cmdline));
cmdline
};
@ -380,11 +387,11 @@ fn run_debuginfo_test(config: &config, props: &TestProps, testfile: &Path) {
let debugger_script = make_out_name(config, testfile, "debugger.script");
// FIXME (#9639): This needs to handle non-utf8 paths
let debugger_opts = ~[~"-quiet", ~"-batch", ~"-nx",
let debugger_opts = vec!(~"-quiet", ~"-batch", ~"-nx",
"-command=" + debugger_script.as_str().unwrap().to_owned(),
exe_file.as_str().unwrap().to_owned()];
exe_file.as_str().unwrap().to_owned());
proc_args = ProcArgs {prog: debugger(), args: debugger_opts};
proc_res = compose_and_run(config, testfile, proc_args, ~[], "", None);
proc_res = compose_and_run(config, testfile, proc_args, Vec::new(), "", None);
}
}
@ -395,7 +402,10 @@ fn run_debuginfo_test(config: &config, props: &TestProps, testfile: &Path) {
if num_check_lines > 0 {
// Allow check lines to leave parts unspecified (e.g., uninitialized
// bits in the wrong case of an enum) with the notation "[...]".
let check_fragments: ~[~[&str]] = check_lines.map(|s| s.split_str("[...]").collect());
let check_fragments: Vec<Vec<~str>> =
check_lines.iter().map(|s| {
s.split_str("[...]").map(|x| x.to_str()).collect()
}).collect();
// check if each line in props.check_lines appears in the
// output (in order)
let mut i = 0u;
@ -403,11 +413,11 @@ fn run_debuginfo_test(config: &config, props: &TestProps, testfile: &Path) {
let mut rest = line.trim();
let mut first = true;
let mut failed = false;
for &frag in check_fragments[i].iter() {
for frag in check_fragments.get(i).iter() {
let found = if first {
if rest.starts_with(frag) { Some(0) } else { None }
if rest.starts_with(*frag) { Some(0) } else { None }
} else {
rest.find_str(frag)
rest.find_str(*frag)
};
match found {
None => {
@ -430,7 +440,7 @@ fn run_debuginfo_test(config: &config, props: &TestProps, testfile: &Path) {
}
if i != num_check_lines {
fatal_ProcRes(format!("line not found in debugger output: {}",
check_lines[i]), &proc_res);
*check_lines.get(i)), &proc_res);
}
}
@ -461,7 +471,7 @@ fn check_error_patterns(props: &TestProps,
}
let mut next_err_idx = 0u;
let mut next_err_pat = &props.error_patterns[next_err_idx];
let mut next_err_pat = props.error_patterns.get(next_err_idx);
let mut done = false;
let output_to_check = if props.check_stdout {
proc_res.stdout + proc_res.stderr
@ -477,7 +487,7 @@ fn check_error_patterns(props: &TestProps,
done = true;
break;
}
next_err_pat = &props.error_patterns[next_err_idx];
next_err_pat = props.error_patterns.get(next_err_idx);
}
}
if done { return; }
@ -495,7 +505,7 @@ fn check_error_patterns(props: &TestProps,
}
}
fn check_expected_errors(expected_errors: ~[errors::ExpectedError],
fn check_expected_errors(expected_errors: Vec<errors::ExpectedError> ,
testfile: &Path,
proc_res: &ProcRes) {
@ -509,12 +519,12 @@ fn check_expected_errors(expected_errors: ~[errors::ExpectedError],
let prefixes = expected_errors.iter().map(|ee| {
format!("{}:{}:", testfile.display(), ee.line)
}).collect::<~[~str]>();
}).collect::<Vec<~str> >();
#[cfg(target_os = "win32")]
fn to_lower( s : &str ) -> ~str {
let i = s.chars();
let c : ~[char] = i.map( |c| {
let c : Vec<char> = i.map( |c| {
if c.is_ascii() {
c.to_ascii().to_lower().to_char()
} else {
@ -547,8 +557,8 @@ fn check_expected_errors(expected_errors: ~[errors::ExpectedError],
for (i, ee) in expected_errors.iter().enumerate() {
if !found_flags[i] {
debug!("prefix={} ee.kind={} ee.msg={} line={}",
prefixes[i], ee.kind, ee.msg, line);
if prefix_matches(line, prefixes[i]) &&
*prefixes.get(i), ee.kind, ee.msg, line);
if prefix_matches(line, *prefixes.get(i)) &&
line.contains(ee.kind) &&
line.contains(ee.msg) {
found_flags[i] = true;
@ -572,7 +582,7 @@ fn check_expected_errors(expected_errors: ~[errors::ExpectedError],
for (i, &flag) in found_flags.iter().enumerate() {
if !flag {
let ee = &expected_errors[i];
let ee = expected_errors.get(i);
fatal_ProcRes(format!("expected {} on line {} not found: {}",
ee.kind, ee.line, ee.msg), proc_res);
}
@ -654,7 +664,7 @@ fn scan_string(haystack: &str, needle: &str, idx: &mut uint) -> bool {
return true;
}
struct ProcArgs {prog: ~str, args: ~[~str]}
struct ProcArgs {prog: ~str, args: Vec<~str> }
struct ProcRes {status: ProcessExit, stdout: ~str, stderr: ~str, cmdline: ~str}
@ -671,8 +681,10 @@ fn compile_test_(config: &config, props: &TestProps,
testfile: &Path, extra_args: &[~str]) -> ProcRes {
let aux_dir = aux_output_dir_name(config, testfile);
// FIXME (#9639): This needs to handle non-utf8 paths
let link_args = ~[~"-L", aux_dir.as_str().unwrap().to_owned()];
let args = make_compile_args(config, props, link_args + extra_args,
let link_args = vec!(~"-L", aux_dir.as_str().unwrap().to_owned());
let args = make_compile_args(config,
props,
vec::append(link_args, extra_args),
|a, b| ThisFile(make_exe_name(a, b)), testfile);
compose_and_run_compiler(config, props, testfile, args, None)
}
@ -710,23 +722,26 @@ fn compose_and_run_compiler(
let aux_dir = aux_output_dir_name(config, testfile);
// FIXME (#9639): This needs to handle non-utf8 paths
let extra_link_args = ~[~"-L", aux_dir.as_str().unwrap().to_owned()];
let extra_link_args = vec!(~"-L", aux_dir.as_str().unwrap().to_owned());
for rel_ab in props.aux_builds.iter() {
let abs_ab = config.aux_base.join(rel_ab.as_slice());
let aux_props = load_props(&abs_ab);
let crate_type = if aux_props.no_prefer_dynamic {
~[]
Vec::new()
} else {
~[~"--crate-type=dylib"]
vec!(~"--crate-type=dylib")
};
let aux_args =
make_compile_args(config, &aux_props, crate_type + extra_link_args,
make_compile_args(config,
&aux_props,
vec::append(crate_type,
extra_link_args.as_slice()),
|a,b| {
let f = make_lib_name(a, b, testfile);
ThisDirectory(f.dir_path())
}, &abs_ab);
let auxres = compose_and_run(config, &abs_ab, aux_args, ~[],
let auxres = compose_and_run(config, &abs_ab, aux_args, Vec::new(),
config.compile_lib_path, None);
if !auxres.status.success() {
fatal_ProcRes(
@ -745,7 +760,7 @@ fn compose_and_run_compiler(
}
}
compose_and_run(config, testfile, args, ~[],
compose_and_run(config, testfile, args, Vec::new(),
config.compile_lib_path, input)
}
@ -756,7 +771,7 @@ fn ensure_dir(path: &Path) {
fn compose_and_run(config: &config, testfile: &Path,
ProcArgs{ args, prog }: ProcArgs,
procenv: ~[(~str, ~str)],
procenv: Vec<(~str, ~str)> ,
lib_path: &str,
input: Option<~str>) -> ProcRes {
return program_output(config, testfile, lib_path,
@ -770,7 +785,7 @@ enum TargetLocation {
fn make_compile_args(config: &config,
props: &TestProps,
extras: ~[~str],
extras: Vec<~str> ,
xform: |&config, &Path| -> TargetLocation,
testfile: &Path)
-> ProcArgs {
@ -781,10 +796,10 @@ fn make_compile_args(config: &config,
config.target.as_slice()
};
// FIXME (#9639): This needs to handle non-utf8 paths
let mut args = ~[testfile.as_str().unwrap().to_owned(),
let mut args = vec!(testfile.as_str().unwrap().to_owned(),
~"-L", config.build_base.as_str().unwrap().to_owned(),
~"--target=" + target]
+ extras;
~"--target=" + target);
args.push_all(extras.as_slice());
if !props.no_prefer_dynamic {
args.push(~"-C");
args.push(~"prefer-dynamic");
@ -833,28 +848,28 @@ fn make_run_args(config: &config, _props: &TestProps, testfile: &Path) ->
return ProcArgs {prog: prog, args: args};
}
fn split_maybe_args(argstr: &Option<~str>) -> ~[~str] {
fn split_maybe_args(argstr: &Option<~str>) -> Vec<~str> {
match *argstr {
Some(ref s) => {
s.split(' ')
.filter_map(|s| if s.is_whitespace() {None} else {Some(s.to_owned())})
.collect()
}
None => ~[]
None => Vec::new()
}
}
fn program_output(config: &config, testfile: &Path, lib_path: &str, prog: ~str,
args: ~[~str], env: ~[(~str, ~str)],
args: Vec<~str> , env: Vec<(~str, ~str)> ,
input: Option<~str>) -> ProcRes {
let cmdline =
{
let cmdline = make_cmdline(lib_path, prog, args);
let cmdline = make_cmdline(lib_path, prog, args.as_slice());
logv(config, format!("executing {}", cmdline));
cmdline
};
let procsrv::Result{ out, err, status } =
procsrv::run(lib_path, prog, args, env, input)
procsrv::run(lib_path, prog, args.as_slice(), env, input)
.expect(format!("failed to exec `{}`", prog));
dump_output(config, testfile, out, err);
return ProcRes {status: status,
@ -951,19 +966,19 @@ stderr:\n\
}
fn _arm_exec_compiled_test(config: &config, props: &TestProps,
testfile: &Path, env: ~[(~str, ~str)]) -> ProcRes {
testfile: &Path, env: Vec<(~str, ~str)> ) -> ProcRes {
let args = make_run_args(config, props, testfile);
let cmdline = make_cmdline("", args.prog, args.args);
let cmdline = make_cmdline("", args.prog, args.args.as_slice());
// get bare program string
let mut tvec: ~[~str] = args.prog.split('/').map(|ts| ts.to_owned()).collect();
let mut tvec: Vec<~str> = args.prog.split('/').map(|ts| ts.to_owned()).collect();
let prog_short = tvec.pop().unwrap();
// copy to target
let copy_result = procsrv::run("", config.adb_path,
[~"push", args.prog.clone(), config.adb_test_dir.clone()],
~[(~"",~"")], Some(~""))
vec!((~"",~"")), Some(~""))
.expect(format!("failed to exec `{}`", config.adb_path));
if config.verbose {
@ -974,7 +989,7 @@ fn _arm_exec_compiled_test(config: &config, props: &TestProps,
logv(config, format!("executing ({}) {}", config.target, cmdline));
let mut runargs = ~[];
let mut runargs = Vec::new();
// run test via adb_run_wrapper
runargs.push(~"shell");
@ -988,17 +1003,20 @@ fn _arm_exec_compiled_test(config: &config, props: &TestProps,
for tv in args.args.iter() {
runargs.push(tv.to_owned());
}
procsrv::run("", config.adb_path, runargs, ~[(~"",~"")], Some(~""))
procsrv::run("",
config.adb_path,
runargs.as_slice(),
vec!((~"",~"")), Some(~""))
.expect(format!("failed to exec `{}`", config.adb_path));
// get exitcode of result
runargs = ~[];
runargs = Vec::new();
runargs.push(~"shell");
runargs.push(~"cat");
runargs.push(format!("{}/{}.exitcode", config.adb_test_dir, prog_short));
let procsrv::Result{ out: exitcode_out, err: _, status: _ } =
procsrv::run("", config.adb_path, runargs, ~[(~"",~"")],
procsrv::run("", config.adb_path, runargs.as_slice(), vec!((~"",~"")),
Some(~""))
.expect(format!("failed to exec `{}`", config.adb_path));
@ -1012,23 +1030,29 @@ fn _arm_exec_compiled_test(config: &config, props: &TestProps,
}
// get stdout of result
runargs = ~[];
runargs = Vec::new();
runargs.push(~"shell");
runargs.push(~"cat");
runargs.push(format!("{}/{}.stdout", config.adb_test_dir, prog_short));
let procsrv::Result{ out: stdout_out, err: _, status: _ } =
procsrv::run("", config.adb_path, runargs, ~[(~"",~"")], Some(~""))
procsrv::run("",
config.adb_path,
runargs.as_slice(),
vec!((~"",~"")), Some(~""))
.expect(format!("failed to exec `{}`", config.adb_path));
// get stderr of result
runargs = ~[];
runargs = Vec::new();
runargs.push(~"shell");
runargs.push(~"cat");
runargs.push(format!("{}/{}.stderr", config.adb_test_dir, prog_short));
let procsrv::Result{ out: stderr_out, err: _, status: _ } =
procsrv::run("", config.adb_path, runargs, ~[(~"",~"")], Some(~""))
procsrv::run("",
config.adb_path,
runargs.as_slice(),
vec!((~"",~"")), Some(~""))
.expect(format!("failed to exec `{}`", config.adb_path));
dump_output(config, testfile, stdout_out, stderr_out);
@ -1050,7 +1074,7 @@ fn _arm_push_aux_shared_library(config: &config, testfile: &Path) {
// FIXME (#9639): This needs to handle non-utf8 paths
let copy_result = procsrv::run("", config.adb_path,
[~"push", file.as_str().unwrap().to_owned(), config.adb_test_dir.clone()],
~[(~"",~"")], Some(~""))
vec!((~"",~"")), Some(~""))
.expect(format!("failed to exec `{}`", config.adb_path));
if config.verbose {
@ -1081,10 +1105,12 @@ fn compile_test_and_save_bitcode(config: &config, props: &TestProps,
testfile: &Path) -> ProcRes {
let aux_dir = aux_output_dir_name(config, testfile);
// FIXME (#9639): This needs to handle non-utf8 paths
let link_args = ~[~"-L", aux_dir.as_str().unwrap().to_owned()];
let llvm_args = ~[~"--emit=obj", ~"--crate-type=lib", ~"-C", ~"save-temps"];
let args = make_compile_args(config, props,
link_args + llvm_args,
let link_args = vec!(~"-L", aux_dir.as_str().unwrap().to_owned());
let llvm_args = vec!(~"--emit=obj", ~"--crate-type=lib", ~"-C", ~"save-temps");
let args = make_compile_args(config,
props,
vec::append(link_args,
llvm_args.as_slice()),
|a, b| ThisFile(make_o_name(a, b)), testfile);
compose_and_run_compiler(config, props, testfile, args, None)
}
@ -1097,12 +1123,12 @@ fn compile_cc_with_clang_and_save_bitcode(config: &config, _props: &TestProps,
let proc_args = ProcArgs {
// FIXME (#9639): This needs to handle non-utf8 paths
prog: config.clang_path.get_ref().as_str().unwrap().to_owned(),
args: ~[~"-c",
args: vec!(~"-c",
~"-emit-llvm",
~"-o", bitcodefile.as_str().unwrap().to_owned(),
testcc.as_str().unwrap().to_owned() ]
testcc.as_str().unwrap().to_owned() )
};
compose_and_run(config, testfile, proc_args, ~[], "", None)
compose_and_run(config, testfile, proc_args, Vec::new(), "", None)
}
fn extract_function_from_bitcode(config: &config, _props: &TestProps,
@ -1115,11 +1141,11 @@ fn extract_function_from_bitcode(config: &config, _props: &TestProps,
let proc_args = ProcArgs {
// FIXME (#9639): This needs to handle non-utf8 paths
prog: prog.as_str().unwrap().to_owned(),
args: ~["-func=" + fname,
args: vec!("-func=" + fname,
"-o=" + extracted_bc.as_str().unwrap(),
bitcodefile.as_str().unwrap().to_owned() ]
bitcodefile.as_str().unwrap().to_owned() )
};
compose_and_run(config, testfile, proc_args, ~[], "", None)
compose_and_run(config, testfile, proc_args, Vec::new(), "", None)
}
fn disassemble_extract(config: &config, _props: &TestProps,
@ -1132,10 +1158,10 @@ fn disassemble_extract(config: &config, _props: &TestProps,
let proc_args = ProcArgs {
// FIXME (#9639): This needs to handle non-utf8 paths
prog: prog.as_str().unwrap().to_owned(),
args: ~["-o=" + extracted_ll.as_str().unwrap(),
extracted_bc.as_str().unwrap().to_owned() ]
args: vec!("-o=" + extracted_ll.as_str().unwrap(),
extracted_bc.as_str().unwrap().to_owned() )
};
compose_and_run(config, testfile, proc_args, ~[], "", None)
compose_and_run(config, testfile, proc_args, Vec::new(), "", None)
}

18
src/libarena/lib.rs
View File

@ -42,14 +42,13 @@ use std::rc::Rc;
use std::rt::global_heap;
use std::intrinsics::{TyDesc, get_tydesc};
use std::intrinsics;
use std::slice;
// The way arena uses arrays is really deeply awful. The arrays are
// allocated, and have capacities reserved, but the fill for the array
// will always stay at 0.
#[deriving(Clone, Eq)]
struct Chunk {
data: Rc<RefCell<~[u8]>>,
data: Rc<RefCell<Vec<u8> >>,
fill: Cell<uint>,
is_pod: Cell<bool>,
}
@ -111,7 +110,7 @@ impl Arena {
fn chunk(size: uint, is_pod: bool) -> Chunk {
Chunk {
data: Rc::new(RefCell::new(slice::with_capacity(size))),
data: Rc::new(RefCell::new(Vec::with_capacity(size))),
fill: Cell::new(0u),
is_pod: Cell::new(is_pod),
}
@ -489,6 +488,9 @@ impl<T> Drop for TypedArena<T> {
#[cfg(test)]
mod tests {
extern crate test;
use std::vec_ng::Vec;
use self::test::BenchHarness;
use super::{Arena, TypedArena};
@ -549,7 +551,7 @@ mod tests {
struct Nonpod {
string: ~str,
array: ~[int],
array: Vec<int> ,
}
#[test]
@ -558,7 +560,7 @@ mod tests {
for _ in range(0, 100000) {
arena.alloc(Nonpod {
string: ~"hello world",
array: ~[ 1, 2, 3, 4, 5 ],
array: vec!( 1, 2, 3, 4, 5 ),
});
}
}
@ -569,7 +571,7 @@ mod tests {
bh.iter(|| {
arena.alloc(Nonpod {
string: ~"hello world",
array: ~[ 1, 2, 3, 4, 5 ],
array: vec!( 1, 2, 3, 4, 5 ),
})
})
}
@ -579,7 +581,7 @@ mod tests {
bh.iter(|| {
~Nonpod {
string: ~"hello world",
array: ~[ 1, 2, 3, 4, 5 ],
array: vec!( 1, 2, 3, 4, 5 ),
}
})
}
@ -590,7 +592,7 @@ mod tests {
bh.iter(|| {
arena.alloc(|| Nonpod {
string: ~"hello world",
array: ~[ 1, 2, 3, 4, 5 ],
array: vec!( 1, 2, 3, 4, 5 ),
})
})
}

373
src/libgetopts/lib.rs
View File

@ -67,7 +67,7 @@
//! }
//! let output = matches.opt_str("o");
//! let input: &str = if !matches.free.is_empty() {
//! matches.free[0].clone()
//! (*matches.free.get(0)).clone()
//! } else {
//! print_usage(program, opts);
//! return;
@ -92,8 +92,6 @@
use std::cmp::Eq;
use std::result::{Err, Ok};
use std::result;
use std::option::{Some, None};
use std::slice;
/// Name of an option. Either a string or a single char.
#[deriving(Clone, Eq)]
@ -138,7 +136,7 @@ pub struct Opt {
/// How often it can occur
occur: Occur,
/// Which options it aliases
priv aliases: ~[Opt],
priv aliases: Vec<Opt> ,
}
/// One group of options, e.g., both -h and --help, along with
@ -171,12 +169,11 @@ enum Optval {
#[deriving(Clone, Eq)]
pub struct Matches {
/// Options that matched
priv opts: ~[Opt],
priv opts: Vec<Opt> ,
/// Values of the Options that matched
priv vals: ~[~[Optval]],
priv vals: Vec<Vec<Optval> > ,
/// Free string fragments
free: ~[~str]
}
free: Vec<~str> }
/// The type returned when the command line does not conform to the
/// expected format. Call the `to_err_msg` method to retrieve the
@ -244,26 +241,26 @@ impl OptGroup {
name: Long((long_name)),
hasarg: hasarg,
occur: occur,
aliases: ~[]
aliases: Vec::new()
},
(1,0) => Opt {
name: Short(short_name.char_at(0)),
hasarg: hasarg,
occur: occur,
aliases: ~[]
aliases: Vec::new()
},
(1,_) => Opt {
name: Long((long_name)),
hasarg: hasarg,
occur: occur,
aliases: ~[
aliases: vec!(
Opt {
name: Short(short_name.char_at(0)),
hasarg: hasarg,
occur: occur,
aliases: ~[]
aliases: Vec::new()
}
]
)
},
(_,_) => fail!("something is wrong with the long-form opt")
}
@ -271,9 +268,9 @@ impl OptGroup {
}
impl Matches {
fn opt_vals(&self, nm: &str) -> ~[Optval] {
match find_opt(self.opts, Name::from_str(nm)) {
Some(id) => self.vals[id].clone(),
fn opt_vals(&self, nm: &str) -> Vec<Optval> {
match find_opt(self.opts.as_slice(), Name::from_str(nm)) {
Some(id) => (*self.vals.get(id)).clone(),
None => fail!("No option '{}' defined", nm)
}
}
@ -283,7 +280,7 @@ impl Matches {
if vals.is_empty() {
None
} else {
Some(vals[0].clone())
Some((*vals.get(0)).clone())
}
}
@ -300,8 +297,8 @@ impl Matches {
/// Returns true if any of several options were matched.
pub fn opts_present(&self, names: &[~str]) -> bool {
for nm in names.iter() {
match find_opt(self.opts, Name::from_str(*nm)) {
Some(id) if !self.vals[id].is_empty() => return true,
match find_opt(self.opts.as_slice(), Name::from_str(*nm)) {
Some(id) if !self.vals.get(id).is_empty() => return true,
_ => (),
};
}
@ -323,8 +320,8 @@ impl Matches {
/// option.
///
/// Used when an option accepts multiple values.
pub fn opt_strs(&self, nm: &str) -> ~[~str] {
let mut acc: ~[~str] = ~[];
pub fn opt_strs(&self, nm: &str) -> Vec<~str> {
let mut acc: Vec<~str> = Vec::new();
let r = self.opt_vals(nm);
for v in r.iter() {
match *v {
@ -341,8 +338,8 @@ impl Matches {
if vals.is_empty() {
return None::<~str>;
}
match vals[0] {
Val(ref s) => Some((*s).clone()),
match vals.get(0) {
&Val(ref s) => Some((*s).clone()),
_ => None
}
}
@ -356,8 +353,8 @@ impl Matches {
pub fn opt_default(&self, nm: &str, def: &str) -> Option<~str> {
let vals = self.opt_vals(nm);
if vals.is_empty() { return None; }
match vals[0] {
Val(ref s) => Some((*s).clone()),
match vals.get(0) {
&Val(ref s) => Some((*s).clone()),
_ => Some(def.to_owned())
}
}
@ -522,10 +519,10 @@ pub fn getopts(args: &[~str], optgrps: &[OptGroup]) -> Result {
let opts = optgrps.map(|x| x.long_to_short());
let n_opts = opts.len();
fn f(_x: uint) -> ~[Optval] { return ~[]; }
fn f(_x: uint) -> Vec<Optval> { return Vec::new(); }
let mut vals = slice::from_fn(n_opts, f);
let mut free: ~[~str] = ~[];
let mut vals = Vec::from_fn(n_opts, f);
let mut free: Vec<~str> = Vec::new();
let l = args.len();
let mut i = 0;
while i < l {
@ -542,18 +539,18 @@ pub fn getopts(args: &[~str], optgrps: &[OptGroup]) -> Result {
let mut i_arg = None;
if cur[1] == '-' as u8 {
let tail = cur.slice(2, curlen);
let tail_eq: ~[&str] = tail.split('=').collect();
let tail_eq: Vec<&str> = tail.split('=').collect();
if tail_eq.len() <= 1 {
names = ~[Long(tail.to_owned())];
names = vec!(Long(tail.to_owned()));
} else {
names =
~[Long(tail_eq[0].to_owned())];
i_arg = Some(tail_eq[1].to_owned());
vec!(Long((*tail_eq.get(0)).to_owned()));
i_arg = Some((*tail_eq.get(1)).to_owned());
}
} else {
let mut j = 1;
let mut last_valid_opt_id = None;
names = ~[];
names = Vec::new();
while j < curlen {
let range = cur.char_range_at(j);
let opt = Short(range.ch);
@ -600,22 +597,30 @@ pub fn getopts(args: &[~str], optgrps: &[OptGroup]) -> Result {
if !i_arg.is_none() {
return Err(UnexpectedArgument(nm.to_str()));
}
vals[optid].push(Given);
vals.get_mut(optid).push(Given);
}
Maybe => {
if !i_arg.is_none() {
vals[optid].push(Val((i_arg.clone()).unwrap()));
vals.get_mut(optid)
.push(Val((i_arg.clone())
.unwrap()));
} else if name_pos < names.len() ||
i + 1 == l || is_arg(args[i + 1]) {
vals[optid].push(Given);
} else { i += 1; vals[optid].push(Val(args[i].clone())); }
vals.get_mut(optid).push(Given);
} else {
i += 1;
vals.get_mut(optid).push(Val(args[i].clone()));
}
}
Yes => {
if !i_arg.is_none() {
vals[optid].push(Val(i_arg.clone().unwrap()));
vals.get_mut(optid).push(Val(i_arg.clone().unwrap()));
} else if i + 1 == l {
return Err(ArgumentMissing(nm.to_str()));
} else { i += 1; vals[optid].push(Val(args[i].clone())); }
} else {
i += 1;
vals.get_mut(optid).push(Val(args[i].clone()));
}
}
}
}
@ -624,7 +629,7 @@ pub fn getopts(args: &[~str], optgrps: &[OptGroup]) -> Result {
}
i = 0u;
while i < n_opts {
let n = vals[i].len();
let n = vals.get(i).len();
let occ = opts[i].occur;
if occ == Req {
if n == 0 {
@ -639,7 +644,7 @@ pub fn getopts(args: &[~str], optgrps: &[OptGroup]) -> Result {
i += 1;
}
Ok(Matches {
opts: opts.to_owned(),
opts: Vec::from_slice(opts),
vals: vals,
free: free
})
@ -711,7 +716,7 @@ pub fn usage(brief: &str, opts: &[OptGroup]) -> ~str {
}
// FIXME: #5516 should be graphemes not codepoints
let mut desc_rows = ~[];
let mut desc_rows = Vec::new();
each_split_within(desc_normalized_whitespace, 54, |substr| {
desc_rows.push(substr.to_owned());
true
@ -724,7 +729,7 @@ pub fn usage(brief: &str, opts: &[OptGroup]) -> ~str {
row
});
format!("{}\n\nOptions:\n{}\n", brief, rows.collect::<~[~str]>().connect("\n"))
format!("{}\n\nOptions:\n{}\n", brief, rows.collect::<Vec<~str> >().connect("\n"))
}
fn format_option(opt: &OptGroup) -> ~str {
@ -879,7 +884,7 @@ fn each_split_within<'a>(ss: &'a str, lim: uint, it: |&'a str| -> bool)
#[test]
fn test_split_within() {
fn t(s: &str, i: uint, u: &[~str]) {
let mut v = ~[];
let mut v = Vec::new();
each_split_within(s, i, |s| { v.push(s.to_owned()); true });
assert!(v.iter().zip(u.iter()).all(|(a,b)| a == b));
}
@ -898,6 +903,7 @@ mod tests {
use std::result::{Err, Ok};
use std::result;
use std::vec_ng::Vec;
fn check_fail_type(f: Fail_, ft: FailType) {
match f {
@ -912,9 +918,9 @@ mod tests {
// Tests for reqopt
#[test]
fn test_reqopt() {
let long_args = ~[~"--test=20"];
let opts = ~[reqopt("t", "test", "testing", "TEST")];
let rs = getopts(long_args, opts);
let long_args = vec!(~"--test=20");
let opts = vec!(reqopt("t", "test", "testing", "TEST"));
let rs = getopts(long_args.as_slice(), opts.as_slice());
match rs {
Ok(ref m) => {
assert!(m.opt_present("test"));
@ -924,8 +930,8 @@ mod tests {
}
_ => { fail!("test_reqopt failed (long arg)"); }
}
let short_args = ~[~"-t", ~"20"];
match getopts(short_args, opts) {
let short_args = vec!(~"-t", ~"20");
match getopts(short_args.as_slice(), opts.as_slice()) {
Ok(ref m) => {
assert!((m.opt_present("test")));
assert_eq!(m.opt_str("test").unwrap(), ~"20");
@ -938,9 +944,9 @@ mod tests {
#[test]
fn test_reqopt_missing() {
let args = ~[~"blah"];
let opts = ~[reqopt("t", "test", "testing", "TEST")];
let rs = getopts(args, opts);
let args = vec!(~"blah");
let opts = vec!(reqopt("t", "test", "testing", "TEST"));
let rs = getopts(args.as_slice(), opts.as_slice());
match rs {
Err(f) => check_fail_type(f, OptionMissing_),
_ => fail!()
@ -949,15 +955,15 @@ mod tests {
#[test]
fn test_reqopt_no_arg() {
let long_args = ~[~"--test"];
let opts = ~[reqopt("t", "test", "testing", "TEST")];
let rs = getopts(long_args, opts);
let long_args = vec!(~"--test");
let opts = vec!(reqopt("t", "test", "testing", "TEST"));
let rs = getopts(long_args.as_slice(), opts.as_slice());
match rs {
Err(f) => check_fail_type(f, ArgumentMissing_),
_ => fail!()
}
let short_args = ~[~"-t"];
match getopts(short_args, opts) {
let short_args = vec!(~"-t");
match getopts(short_args.as_slice(), opts.as_slice()) {
Err(f) => check_fail_type(f, ArgumentMissing_),
_ => fail!()
}
@ -965,9 +971,9 @@ mod tests {
#[test]
fn test_reqopt_multi() {
let args = ~[~"--test=20", ~"-t", ~"30"];
let opts = ~[reqopt("t", "test", "testing", "TEST")];
let rs = getopts(args, opts);
let args = vec!(~"--test=20", ~"-t", ~"30");
let opts = vec!(reqopt("t", "test", "testing", "TEST"));
let rs = getopts(args.as_slice(), opts.as_slice());
match rs {
Err(f) => check_fail_type(f, OptionDuplicated_),
_ => fail!()
@ -977,9 +983,9 @@ mod tests {
// Tests for optopt
#[test]
fn test_optopt() {
let long_args = ~[~"--test=20"];
let opts = ~[optopt("t", "test", "testing", "TEST")];
let rs = getopts(long_args, opts);
let long_args = vec!(~"--test=20");
let opts = vec!(optopt("t", "test", "testing", "TEST"));
let rs = getopts(long_args.as_slice(), opts.as_slice());
match rs {
Ok(ref m) => {
assert!(m.opt_present("test"));
@ -989,8 +995,8 @@ mod tests {
}
_ => fail!()
}
let short_args = ~[~"-t", ~"20"];
match getopts(short_args, opts) {
let short_args = vec!(~"-t", ~"20");
match getopts(short_args.as_slice(), opts.as_slice()) {
Ok(ref m) => {
assert!((m.opt_present("test")));
assert_eq!(m.opt_str("test").unwrap(), ~"20");
@ -1003,9 +1009,9 @@ mod tests {
#[test]
fn test_optopt_missing() {
let args = ~[~"blah"];
let opts = ~[optopt("t", "test", "testing", "TEST")];
let rs = getopts(args, opts);
let args = vec!(~"blah");
let opts = vec!(optopt("t", "test", "testing", "TEST"));
let rs = getopts(args.as_slice(), opts.as_slice());
match rs {
Ok(ref m) => {
assert!(!m.opt_present("test"));
@ -1017,15 +1023,15 @@ mod tests {
#[test]
fn test_optopt_no_arg() {
let long_args = ~[~"--test"];
let opts = ~[optopt("t", "test", "testing", "TEST")];
let rs = getopts(long_args, opts);
let long_args = vec!(~"--test");
let opts = vec!(optopt("t", "test", "testing", "TEST"));
let rs = getopts(long_args.as_slice(), opts.as_slice());
match rs {
Err(f) => check_fail_type(f, ArgumentMissing_),
_ => fail!()
}
let short_args = ~[~"-t"];
match getopts(short_args, opts) {
let short_args = vec!(~"-t");
match getopts(short_args.as_slice(), opts.as_slice()) {
Err(f) => check_fail_type(f, ArgumentMissing_),
_ => fail!()
}
@ -1033,9 +1039,9 @@ mod tests {
#[test]
fn test_optopt_multi() {
let args = ~[~"--test=20", ~"-t", ~"30"];
let opts = ~[optopt("t", "test", "testing", "TEST")];
let rs = getopts(args, opts);
let args = vec!(~"--test=20", ~"-t", ~"30");
let opts = vec!(optopt("t", "test", "testing", "TEST"));
let rs = getopts(args.as_slice(), opts.as_slice());
match rs {
Err(f) => check_fail_type(f, OptionDuplicated_),
_ => fail!()
@ -1045,9 +1051,9 @@ mod tests {
// Tests for optflag
#[test]
fn test_optflag() {
let long_args = ~[~"--test"];
let opts = ~[optflag("t", "test", "testing")];
let rs = getopts(long_args, opts);
let long_args = vec!(~"--test");
let opts = vec!(optflag("t", "test", "testing"));
let rs = getopts(long_args.as_slice(), opts.as_slice());
match rs {
Ok(ref m) => {
assert!(m.opt_present("test"));
@ -1055,8 +1061,8 @@ mod tests {
}
_ => fail!()
}
let short_args = ~[~"-t"];
match getopts(short_args, opts) {
let short_args = vec!(~"-t");
match getopts(short_args.as_slice(), opts.as_slice()) {
Ok(ref m) => {
assert!(m.opt_present("test"));
assert!(m.opt_present("t"));
@ -1067,9 +1073,9 @@ mod tests {
#[test]
fn test_optflag_missing() {
let args = ~[~"blah"];
let opts = ~[optflag("t", "test", "testing")];
let rs = getopts(args, opts);
let args = vec!(~"blah");
let opts = vec!(optflag("t", "test", "testing"));
let rs = getopts(args.as_slice(), opts.as_slice());
match rs {
Ok(ref m) => {
assert!(!m.opt_present("test"));
@ -1081,9 +1087,9 @@ mod tests {
#[test]
fn test_optflag_long_arg() {
let args = ~[~"--test=20"];
let opts = ~[optflag("t", "test", "testing")];
let rs = getopts(args, opts);
let args = vec!(~"--test=20");
let opts = vec!(optflag("t", "test", "testing"));
let rs = getopts(args.as_slice(), opts.as_slice());
match rs {
Err(f) => {
error!("{:?}", f.clone().to_err_msg());
@ -1095,9 +1101,9 @@ mod tests {
#[test]
fn test_optflag_multi() {
let args = ~[~"--test", ~"-t"];
let opts = ~[optflag("t", "test", "testing")];
let rs = getopts(args, opts);
let args = vec!(~"--test", ~"-t");
let opts = vec!(optflag("t", "test", "testing"));
let rs = getopts(args.as_slice(), opts.as_slice());
match rs {
Err(f) => check_fail_type(f, OptionDuplicated_),
_ => fail!()
@ -1106,14 +1112,14 @@ mod tests {
#[test]
fn test_optflag_short_arg() {
let args = ~[~"-t", ~"20"];
let opts = ~[optflag("t", "test", "testing")];
let rs = getopts(args, opts);
let args = vec!(~"-t", ~"20");
let opts = vec!(optflag("t", "test", "testing"));
let rs = getopts(args.as_slice(), opts.as_slice());
match rs {
Ok(ref m) => {
// The next variable after the flag is just a free argument
assert!(m.free[0] == ~"20");
assert!(*m.free.get(0) == ~"20");
}
_ => fail!()
}
@ -1122,9 +1128,9 @@ mod tests {
// Tests for optflagmulti
#[test]
fn test_optflagmulti_short1() {
let args = ~[~"-v"];
let opts = ~[optflagmulti("v", "verbose", "verbosity")];
let rs = getopts(args, opts);
let args = vec!(~"-v");
let opts = vec!(optflagmulti("v", "verbose", "verbosity"));
let rs = getopts(args.as_slice(), opts.as_slice());
match rs {
Ok(ref m) => {
assert_eq!(m.opt_count("v"), 1);
@ -1135,9 +1141,9 @@ mod tests {
#[test]
fn test_optflagmulti_short2a() {
let args = ~[~"-v", ~"-v"];
let opts = ~[optflagmulti("v", "verbose", "verbosity")];
let rs = getopts(args, opts);
let args = vec!(~"-v", ~"-v");
let opts = vec!(optflagmulti("v", "verbose", "verbosity"));
let rs = getopts(args.as_slice(), opts.as_slice());
match rs {
Ok(ref m) => {
assert_eq!(m.opt_count("v"), 2);
@ -1148,9 +1154,9 @@ mod tests {
#[test]
fn test_optflagmulti_short2b() {
let args = ~[~"-vv"];
let opts = ~[optflagmulti("v", "verbose", "verbosity")];
let rs = getopts(args, opts);
let args = vec!(~"-vv");
let opts = vec!(optflagmulti("v", "verbose", "verbosity"));
let rs = getopts(args.as_slice(), opts.as_slice());
match rs {
Ok(ref m) => {
assert_eq!(m.opt_count("v"), 2);
@ -1161,9 +1167,9 @@ mod tests {
#[test]
fn test_optflagmulti_long1() {
let args = ~[~"--verbose"];
let opts = ~[optflagmulti("v", "verbose", "verbosity")];
let rs = getopts(args, opts);
let args = vec!(~"--verbose");
let opts = vec!(optflagmulti("v", "verbose", "verbosity"));
let rs = getopts(args.as_slice(), opts.as_slice());
match rs {
Ok(ref m) => {
assert_eq!(m.opt_count("verbose"), 1);
@ -1174,9 +1180,9 @@ mod tests {
#[test]
fn test_optflagmulti_long2() {
let args = ~[~"--verbose", ~"--verbose"];
let opts = ~[optflagmulti("v", "verbose", "verbosity")];
let rs = getopts(args, opts);
let args = vec!(~"--verbose", ~"--verbose");
let opts = vec!(optflagmulti("v", "verbose", "verbosity"));
let rs = getopts(args.as_slice(), opts.as_slice());
match rs {
Ok(ref m) => {
assert_eq!(m.opt_count("verbose"), 2);
@ -1187,9 +1193,9 @@ mod tests {
#[test]
fn test_optflagmulti_mix() {
let args = ~[~"--verbose", ~"-v", ~"-vv", ~"verbose"];
let opts = ~[optflagmulti("v", "verbose", "verbosity")];
let rs = getopts(args, opts);
let args = vec!(~"--verbose", ~"-v", ~"-vv", ~"verbose");
let opts = vec!(optflagmulti("v", "verbose", "verbosity"));
let rs = getopts(args.as_slice(), opts.as_slice());
match rs {
Ok(ref m) => {
assert_eq!(m.opt_count("verbose"), 4);
@ -1202,9 +1208,9 @@ mod tests {
// Tests for optmulti
#[test]
fn test_optmulti() {
let long_args = ~[~"--test=20"];
let opts = ~[optmulti("t", "test", "testing", "TEST")];
let rs = getopts(long_args, opts);
let long_args = vec!(~"--test=20");
let opts = vec!(optmulti("t", "test", "testing", "TEST"));
let rs = getopts(long_args.as_slice(), opts.as_slice());
match rs {
Ok(ref m) => {
assert!((m.opt_present("test")));
@ -1214,8 +1220,8 @@ mod tests {
}
_ => fail!()
}
let short_args = ~[~"-t", ~"20"];
match getopts(short_args, opts) {
let short_args = vec!(~"-t", ~"20");
match getopts(short_args.as_slice(), opts.as_slice()) {
Ok(ref m) => {
assert!((m.opt_present("test")));
assert_eq!(m.opt_str("test").unwrap(), ~"20");
@ -1228,9 +1234,9 @@ mod tests {
#[test]
fn test_optmulti_missing() {
let args = ~[~"blah"];
let opts = ~[optmulti("t", "test", "testing", "TEST")];
let rs = getopts(args, opts);
let args = vec!(~"blah");
let opts = vec!(optmulti("t", "test", "testing", "TEST"));
let rs = getopts(args.as_slice(), opts.as_slice());
match rs {
Ok(ref m) => {
assert!(!m.opt_present("test"));
@ -1242,15 +1248,15 @@ mod tests {
#[test]
fn test_optmulti_no_arg() {
let long_args = ~[~"--test"];
let opts = ~[optmulti("t", "test", "testing", "TEST")];
let rs = getopts(long_args, opts);
let long_args = vec!(~"--test");
let opts = vec!(optmulti("t", "test", "testing", "TEST"));
let rs = getopts(long_args.as_slice(), opts.as_slice());
match rs {
Err(f) => check_fail_type(f, ArgumentMissing_),
_ => fail!()
}
let short_args = ~[~"-t"];
match getopts(short_args, opts) {
let short_args = vec!(~"-t");
match getopts(short_args.as_slice(), opts.as_slice()) {
Err(f) => check_fail_type(f, ArgumentMissing_),
_ => fail!()
}
@ -1258,9 +1264,9 @@ mod tests {
#[test]
fn test_optmulti_multi() {
let args = ~[~"--test=20", ~"-t", ~"30"];
let opts = ~[optmulti("t", "test", "testing", "TEST")];
let rs = getopts(args, opts);
let args = vec!(~"--test=20", ~"-t", ~"30");
let opts = vec!(optmulti("t", "test", "testing", "TEST"));
let rs = getopts(args.as_slice(), opts.as_slice());
match rs {
Ok(ref m) => {
assert!(m.opt_present("test"));
@ -1268,8 +1274,8 @@ mod tests {
assert!(m.opt_present("t"));
assert_eq!(m.opt_str("t").unwrap(), ~"20");
let pair = m.opt_strs("test");
assert!(pair[0] == ~"20");
assert!(pair[1] == ~"30");
assert!(*pair.get(0) == ~"20");
assert!(*pair.get(1) == ~"30");
}
_ => fail!()
}
@ -1277,15 +1283,15 @@ mod tests {
#[test]
fn test_unrecognized_option() {
let long_args = ~[~"--untest"];
let opts = ~[optmulti("t", "test", "testing", "TEST")];
let rs = getopts(long_args, opts);
let long_args = vec!(~"--untest");
let opts = vec!(optmulti("t", "test", "testing", "TEST"));
let rs = getopts(long_args.as_slice(), opts.as_slice());
match rs {
Err(f) => check_fail_type(f, UnrecognizedOption_),
_ => fail!()
}
let short_args = ~[~"-u"];
match getopts(short_args, opts) {
let short_args = vec!(~"-u");
match getopts(short_args.as_slice(), opts.as_slice()) {
Err(f) => check_fail_type(f, UnrecognizedOption_),
_ => fail!()
}
@ -1294,33 +1300,33 @@ mod tests {
#[test]
fn test_combined() {
let args =
~[~"prog", ~"free1", ~"-s", ~"20", ~"free2",
vec!(~"prog", ~"free1", ~"-s", ~"20", ~"free2",
~"--flag", ~"--long=30", ~"-f", ~"-m", ~"40",
~"-m", ~"50", ~"-n", ~"-A B", ~"-n", ~"-60 70"];
~"-m", ~"50", ~"-n", ~"-A B", ~"-n", ~"-60 70");
let opts =
~[optopt("s", "something", "something", "SOMETHING"),
vec!(optopt("s", "something", "something", "SOMETHING"),
optflag("", "flag", "a flag"),
reqopt("", "long", "hi", "LONG"),
optflag("f", "", "another flag"),
optmulti("m", "", "mmmmmm", "YUM"),
optmulti("n", "", "nothing", "NOTHING"),
optopt("", "notpresent", "nothing to see here", "NOPE")];
let rs = getopts(args, opts);
optopt("", "notpresent", "nothing to see here", "NOPE"));
let rs = getopts(args.as_slice(), opts.as_slice());
match rs {
Ok(ref m) => {
assert!(m.free[0] == ~"prog");
assert!(m.free[1] == ~"free1");
assert!(*m.free.get(0) == ~"prog");
assert!(*m.free.get(1) == ~"free1");
assert_eq!(m.opt_str("s").unwrap(), ~"20");
assert!(m.free[2] == ~"free2");
assert!(*m.free.get(2) == ~"free2");
assert!((m.opt_present("flag")));
assert_eq!(m.opt_str("long").unwrap(), ~"30");
assert!((m.opt_present("f")));
let pair = m.opt_strs("m");
assert!(pair[0] == ~"40");
assert!(pair[1] == ~"50");
assert!(*pair.get(0) == ~"40");
assert!(*pair.get(1) == ~"50");
let pair = m.opt_strs("n");
assert!(pair[0] == ~"-A B");
assert!(pair[1] == ~"-60 70");
assert!(*pair.get(0) == ~"-A B");
assert!(*pair.get(1) == ~"-60 70");
assert!((!m.opt_present("notpresent")));
}
_ => fail!()
@ -1329,12 +1335,13 @@ mod tests {
#[test]
fn test_multi() {
let opts = ~[optopt("e", "", "encrypt", "ENCRYPT"),
let opts = vec!(optopt("e", "", "encrypt", "ENCRYPT"),
optopt("", "encrypt", "encrypt", "ENCRYPT"),
optopt("f", "", "flag", "FLAG")];
optopt("f", "", "flag", "FLAG"));
let args_single = ~[~"-e", ~"foo"];
let matches_single = &match getopts(args_single, opts) {
let args_single = vec!(~"-e", ~"foo");
let matches_single = &match getopts(args_single.as_slice(),
opts.as_slice()) {
result::Ok(m) => m,
result::Err(_) => fail!()
};
@ -1349,8 +1356,9 @@ mod tests {
assert_eq!(matches_single.opts_str([~"e", ~"encrypt"]).unwrap(), ~"foo");
assert_eq!(matches_single.opts_str([~"encrypt", ~"e"]).unwrap(), ~"foo");
let args_both = ~[~"-e", ~"foo", ~"--encrypt", ~"foo"];
let matches_both = &match getopts(args_both, opts) {
let args_both = vec!(~"-e", ~"foo", ~"--encrypt", ~"foo");
let matches_both = &match getopts(args_both.as_slice(),
opts.as_slice()) {
result::Ok(m) => m,
result::Err(_) => fail!()
};
@ -1370,10 +1378,10 @@ mod tests {
#[test]
fn test_nospace() {
let args = ~[~"-Lfoo", ~"-M."];
let opts = ~[optmulti("L", "", "library directory", "LIB"),
optmulti("M", "", "something", "MMMM")];
let matches = &match getopts(args, opts) {
let args = vec!(~"-Lfoo", ~"-M.");
let opts = vec!(optmulti("L", "", "library directory", "LIB"),
optmulti("M", "", "something", "MMMM"));
let matches = &match getopts(args.as_slice(), opts.as_slice()) {
result::Ok(m) => m,
result::Err(_) => fail!()
};
@ -1386,14 +1394,16 @@ mod tests {
#[test]
fn test_long_to_short() {
let mut short = Opt { name: Long(~"banana"),
hasarg: Yes,
occur: Req,
aliases: ~[] };
short.aliases = ~[Opt { name: Short('b'),
let mut short = Opt {
name: Long(~"banana"),
hasarg: Yes,
occur: Req,
aliases: Vec::new(),
};
short.aliases = vec!(Opt { name: Short('b'),
hasarg: Yes,
occur: Req,
aliases: ~[] }];
aliases: Vec::new() });
let verbose = reqopt("b", "banana", "some bananas", "VAL");
assert!(verbose.long_to_short() == short);
@ -1401,27 +1411,25 @@ mod tests {
#[test]
fn test_aliases_long_and_short() {
let opts = ~[
optflagmulti("a", "apple", "Desc"),
];
let opts = vec!(
optflagmulti("a", "apple", "Desc"));
let args = ~[~"-a", ~"--apple", ~"-a"];
let args = vec!(~"-a", ~"--apple", ~"-a");
let matches = getopts(args, opts).unwrap();
let matches = getopts(args.as_slice(), opts.as_slice()).unwrap();
assert_eq!(3, matches.opt_count("a"));
assert_eq!(3, matches.opt_count("apple"));
}
#[test]
fn test_usage() {
let optgroups = ~[
let optgroups = vec!(
reqopt("b", "banana", "Desc", "VAL"),
optopt("a", "012345678901234567890123456789",
"Desc", "VAL"),
optflag("k", "kiwi", "Desc"),
optflagopt("p", "", "Desc", "VAL"),
optmulti("l", "", "Desc", "VAL"),
];
optmulti("l", "", "Desc", "VAL"));
let expected =
~"Usage: fruits
@ -1435,7 +1443,7 @@ Options:
-l VAL Desc
";
let generated_usage = usage("Usage: fruits", optgroups);
let generated_usage = usage("Usage: fruits", optgroups.as_slice());
debug!("expected: <<{}>>", expected);
debug!("generated: <<{}>>", generated_usage);
@ -1447,12 +1455,11 @@ Options:
// indentation should be 24 spaces
// lines wrap after 78: or rather descriptions wrap after 54
let optgroups = ~[
let optgroups = vec!(
optflag("k", "kiwi",
"This is a long description which won't be wrapped..+.."), // 54
optflag("a", "apple",
"This is a long description which _will_ be wrapped..+.."), // 55
];
"This is a long description which _will_ be wrapped..+.."));
let expected =
~"Usage: fruits
@ -1463,7 +1470,7 @@ Options:
wrapped..+..
";
let usage = usage("Usage: fruits", optgroups);
let usage = usage("Usage: fruits", optgroups.as_slice());
debug!("expected: <<{}>>", expected);
debug!("generated: <<{}>>", usage);
@ -1472,13 +1479,12 @@ Options:
#[test]
fn test_usage_description_multibyte_handling() {
let optgroups = ~[
let optgroups = vec!(
optflag("k", "k\u2013w\u2013",
"The word kiwi is normally spelled with two i's"),
optflag("a", "apple",
"This \u201Cdescription\u201D has some characters that could \
confuse the line wrapping; an apple costs 0.51€ in some parts of Europe."),
];
confuse the line wrapping; an apple costs 0.51€ in some parts of Europe."));
let expected =
~"Usage: fruits
@ -1490,7 +1496,7 @@ Options:
some parts of Europe.
";
let usage = usage("Usage: fruits", optgroups);
let usage = usage("Usage: fruits", optgroups.as_slice());
debug!("expected: <<{}>>", expected);
debug!("generated: <<{}>>", usage);
@ -1499,17 +1505,16 @@ Options:
#[test]
fn test_short_usage() {
let optgroups = ~[
let optgroups = vec!(
reqopt("b", "banana", "Desc", "VAL"),
optopt("a", "012345678901234567890123456789",
"Desc", "VAL"),
optflag("k", "kiwi", "Desc"),
optflagopt("p", "", "Desc", "VAL"),
optmulti("l", "", "Desc", "VAL"),
];
optmulti("l", "", "Desc", "VAL"));
let expected = ~"Usage: fruits -b VAL [-a VAL] [-k] [-p [VAL]] [-l VAL]..";
let generated_usage = short_usage("fruits", optgroups);
let generated_usage = short_usage("fruits", optgroups.as_slice());
debug!("expected: <<{}>>", expected);
debug!("generated: <<{}>>", generated_usage);

49
src/libglob/lib.rs
View File

@ -42,10 +42,9 @@ use std::path::is_sep;
*/
pub struct Paths {
priv root: Path,
priv dir_patterns: ~[Pattern],
priv dir_patterns: Vec<Pattern> ,
priv options: MatchOptions,
priv todo: ~[(Path,uint)]
}
priv todo: Vec<(Path,uint)> }
///
/// Return an iterator that produces all the Paths that match the given pattern,
@ -103,16 +102,23 @@ pub fn glob_with(pattern: &str, options: MatchOptions) -> Paths {
if check_windows_verbatim(pat_root.get_ref()) {
// FIXME: How do we want to handle verbatim paths? I'm inclined to return nothing,
// since we can't very well find all UNC shares with a 1-letter server name.
return Paths { root: root, dir_patterns: ~[], options: options, todo: ~[] };
return Paths {
root: root,
dir_patterns: Vec::new(),
options: options,
todo: Vec::new(),
};
}
root.push(pat_root.get_ref());
}
let root_len = pat_root.map_or(0u, |p| p.as_vec().len());
let dir_patterns = pattern.slice_from(cmp::min(root_len, pattern.len()))
.split_terminator(is_sep).map(|s| Pattern::new(s)).to_owned_vec();
.split_terminator(is_sep)
.map(|s| Pattern::new(s))
.collect();
let todo = list_dir_sorted(&root).move_iter().map(|x|(x,0u)).to_owned_vec();
let todo = list_dir_sorted(&root).move_iter().map(|x|(x,0u)).collect();
Paths {
root: root,
@ -131,7 +137,7 @@ impl Iterator<Path> for Paths {
}
let (path,idx) = self.todo.pop().unwrap();
let ref pattern = self.dir_patterns[idx];
let ref pattern = *self.dir_patterns.get(idx);
if pattern.matches_with(match path.filename_str() {
// this ugly match needs to go here to avoid a borrowck error
@ -155,13 +161,13 @@ impl Iterator<Path> for Paths {
}
fn list_dir_sorted(path: &Path) -> ~[Path] {
fn list_dir_sorted(path: &Path) -> Vec<Path> {
match fs::readdir(path) {
Ok(mut children) => {
children.sort_by(|p1, p2| p2.filename().cmp(&p1.filename()));
children
children.move_iter().collect()
}
Err(..) => ~[]
Err(..) => Vec::new()
}
}
@ -170,16 +176,15 @@ fn list_dir_sorted(path: &Path) -> ~[Path] {
*/
#[deriving(Clone, Eq, TotalEq, Ord, TotalOrd, Hash, Default)]
pub struct Pattern {
priv tokens: ~[PatternToken]
}
priv tokens: Vec<PatternToken> }
#[deriving(Clone, Eq, TotalEq, Ord, TotalOrd, Hash)]
enum PatternToken {
Char(char),
AnyChar,
AnySequence,
AnyWithin(~[CharSpecifier]),
AnyExcept(~[CharSpecifier])
AnyWithin(Vec<CharSpecifier> ),
AnyExcept(Vec<CharSpecifier> )
}
#[deriving(Clone, Eq, TotalEq, Ord, TotalOrd, Hash)]
@ -219,7 +224,7 @@ impl Pattern {
pub fn new(pattern: &str) -> Pattern {
let chars = pattern.chars().to_owned_vec();
let mut tokens = ~[];
let mut tokens = Vec::new();
let mut i = 0;
while i < chars.len() {
@ -392,10 +397,16 @@ impl Pattern {
!require_literal(c)
}
AnyWithin(ref specifiers) => {
!require_literal(c) && in_char_specifiers(*specifiers, c, options)
!require_literal(c) &&
in_char_specifiers(specifiers.as_slice(),
c,
options)
}
AnyExcept(ref specifiers) => {
!require_literal(c) && !in_char_specifiers(*specifiers, c, options)
!require_literal(c) &&
!in_char_specifiers(specifiers.as_slice(),
c,
options)
}
Char(c2) => {
chars_eq(c, c2, options.case_sensitive)
@ -422,8 +433,8 @@ impl Pattern {
}
fn parse_char_specifiers(s: &[char]) -> ~[CharSpecifier] {
let mut cs = ~[];
fn parse_char_specifiers(s: &[char]) -> Vec<CharSpecifier> {
let mut cs = Vec::new();
let mut i = 0;
while i < s.len() {
if i + 3 <= s.len() && s[i + 1] == '-' {

11
src/libnum/rational.rs
View File

@ -299,9 +299,9 @@ impl<T: FromStr + Clone + Integer + Ord>
if split.len() < 2 {
return None
}
let a_option: Option<T> = FromStr::from_str(split.as_slice()[0]);
let a_option: Option<T> = FromStr::from_str(*split.get(0));
a_option.and_then(|a| {
let b_option: Option<T> = FromStr::from_str(split.as_slice()[1]);
let b_option: Option<T> = FromStr::from_str(*split.get(1));
b_option.and_then(|b| {
Some(Ratio::new(a.clone(), b.clone()))
})
@ -316,11 +316,12 @@ impl<T: FromStrRadix + Clone + Integer + Ord>
if split.len() < 2 {
None
} else {
let a_option: Option<T> = FromStrRadix::from_str_radix(split.as_slice()[0],
radix);
let a_option: Option<T> = FromStrRadix::from_str_radix(
*split.get(0),
radix);
a_option.and_then(|a| {
let b_option: Option<T> =
FromStrRadix::from_str_radix(split.as_slice()[1], radix);
FromStrRadix::from_str_radix(*split.get(1), radix);
b_option.and_then(|b| {
Some(Ratio::new(a.clone(), b.clone()))
})

2
src/librustc/driver/driver.rs
View File

@ -837,7 +837,7 @@ pub fn build_session_options(matches: &getopts::Matches) -> session::Options {
let flags = vec::append(matches.opt_strs(level_short)
.move_iter()
.collect(),
matches.opt_strs(level_name));
matches.opt_strs(level_name).as_slice());
for lint_name in flags.iter() {
let lint_name = lint_name.replace("-", "_");
match lint_dict.find_equiv(&lint_name) {

4
src/librustc/lib.rs
View File

@ -243,7 +243,7 @@ pub fn run_compiler(args: &[~str]) {
let lint_flags = vec::append(matches.opt_strs("W")
.move_iter()
.collect(),
matches.opt_strs("warn"));
matches.opt_strs("warn").as_slice());
if lint_flags.iter().any(|x| x == &~"help") {
describe_warnings();
return;
@ -273,7 +273,7 @@ pub fn run_compiler(args: &[~str]) {
let (input, input_file_path) = match matches.free.len() {
0u => d::early_error("no input filename given"),
1u => {
let ifile = matches.free[0].as_slice();
let ifile = matches.free.get(0).as_slice();
if ifile == "-" {
let contents = io::stdin().read_to_end().unwrap();
let src = str::from_utf8_owned(contents).unwrap();

103
src/librustdoc/clean.rs
View File

@ -35,12 +35,6 @@ pub trait Clean<T> {
fn clean(&self) -> T;
}
impl<T: Clean<U>, U> Clean<~[U]> for ~[T] {
fn clean(&self) -> ~[U] {
self.iter().map(|x| x.clean()).collect()
}
}
impl<T: Clean<U>, U> Clean<Vec<U>> for Vec<T> {
fn clean(&self) -> Vec<U> {
self.iter().map(|x| x.clean()).collect()
@ -75,7 +69,7 @@ impl<T: Clean<U>, U> Clean<Vec<U>> for syntax::opt_vec::OptVec<T> {
pub struct Crate {
name: ~str,
module: Option<Item>,
externs: ~[(ast::CrateNum, ExternalCrate)],
externs: Vec<(ast::CrateNum, ExternalCrate)> ,
}
impl<'a> Clean<Crate> for visit_ast::RustdocVisitor<'a> {
@ -83,13 +77,13 @@ impl<'a> Clean<Crate> for visit_ast::RustdocVisitor<'a> {
use syntax::attr::find_crateid;
let cx = local_data::get(super::ctxtkey, |x| *x.unwrap());
let mut externs = ~[];
let mut externs = Vec::new();
cx.sess().cstore.iter_crate_data(|n, meta| {
externs.push((n, meta.clean()));
});
Crate {
name: match find_crateid(self.attrs) {
name: match find_crateid(self.attrs.as_slice()) {
Some(n) => n.name,
None => fail!("rustdoc requires a `crate_id` crate attribute"),
},
@ -102,7 +96,7 @@ impl<'a> Clean<Crate> for visit_ast::RustdocVisitor<'a> {
#[deriving(Clone, Encodable, Decodable)]
pub struct ExternalCrate {
name: ~str,
attrs: ~[Attribute],
attrs: Vec<Attribute> ,
}
impl Clean<ExternalCrate> for cstore::crate_metadata {
@ -125,7 +119,7 @@ pub struct Item {
source: Span,
/// Not everything has a name. E.g., impls
name: Option<~str>,
attrs: ~[Attribute],
attrs: Vec<Attribute> ,
inner: ItemEnum,
visibility: Option<Visibility>,
id: ast::NodeId,
@ -195,7 +189,7 @@ pub enum ItemEnum {
#[deriving(Clone, Encodable, Decodable)]
pub struct Module {
items: ~[Item],
items: Vec<Item> ,
is_crate: bool,
}
@ -206,13 +200,13 @@ impl Clean<Item> for doctree::Module {
} else {
~""
};
let mut foreigns = ~[];
let mut foreigns = Vec::new();
for subforeigns in self.foreigns.clean().move_iter() {
for foreign in subforeigns.move_iter() {
foreigns.push(foreign)
}
}
let items: ~[~[Item]] = ~[
let items: Vec<Vec<Item> > = vec!(
self.structs.clean().move_iter().collect(),
self.enums.clean().move_iter().collect(),
self.fns.clean().move_iter().collect(),
@ -224,7 +218,7 @@ impl Clean<Item> for doctree::Module {
self.impls.clean().move_iter().collect(),
self.view_items.clean().move_iter().collect(),
self.macros.clean().move_iter().collect()
];
);
Item {
name: Some(name),
attrs: self.attrs.clean(),
@ -233,7 +227,9 @@ impl Clean<Item> for doctree::Module {
id: self.id,
inner: ModuleItem(Module {
is_crate: self.is_crate,
items: items.concat_vec(),
items: items.iter()
.flat_map(|x| x.iter().map(|x| (*x).clone()))
.collect(),
})
}
}
@ -242,7 +238,7 @@ impl Clean<Item> for doctree::Module {
#[deriving(Clone, Encodable, Decodable)]
pub enum Attribute {
Word(~str),
List(~str, ~[Attribute]),
List(~str, Vec<Attribute> ),
NameValue(~str, ~str)
}
@ -292,8 +288,7 @@ impl<'a> attr::AttrMetaMethods for &'a Attribute {
pub struct TyParam {
name: ~str,
id: ast::NodeId,
bounds: ~[TyParamBound]
}
bounds: Vec<TyParamBound> }
impl Clean<TyParam> for ast::TyParam {
fn clean(&self) -> TyParam {
@ -340,9 +335,8 @@ impl Clean<Lifetime> for ast::Lifetime {
// maybe use a Generic enum and use ~[Generic]?
#[deriving(Clone, Encodable, Decodable)]
pub struct Generics {
lifetimes: ~[Lifetime],
type_params: ~[TyParam]
}
lifetimes: Vec<Lifetime> ,
type_params: Vec<TyParam> }
impl Clean<Generics> for ast::Generics {
fn clean(&self) -> Generics {
@ -373,7 +367,7 @@ impl Clean<Item> for ast::Method {
},
output: (self.decl.output.clean()),
cf: self.decl.cf.clean(),
attrs: ~[]
attrs: Vec::new()
};
Item {
name: Some(self.ident.clean()),
@ -411,7 +405,7 @@ impl Clean<Item> for ast::TypeMethod {
},
output: (self.decl.output.clean()),
cf: self.decl.cf.clean(),
attrs: ~[]
attrs: Vec::new()
};
Item {
name: Some(self.ident.clean()),
@ -476,12 +470,11 @@ impl Clean<Item> for doctree::Function {
pub struct ClosureDecl {
sigil: ast::Sigil,
region: Option<Lifetime>,
lifetimes: ~[Lifetime],
lifetimes: Vec<Lifetime> ,
decl: FnDecl,
onceness: ast::Onceness,
purity: ast::Purity,
bounds: ~[TyParamBound]
}
bounds: Vec<TyParamBound> }
impl Clean<ClosureDecl> for ast::ClosureTy {
fn clean(&self) -> ClosureDecl {
@ -494,7 +487,7 @@ impl Clean<ClosureDecl> for ast::ClosureTy {
purity: self.purity,
bounds: match self.bounds {
Some(ref x) => x.clean().move_iter().collect(),
None => ~[]
None => Vec::new()
},
}
}
@ -505,12 +498,11 @@ pub struct FnDecl {
inputs: Arguments,
output: Type,
cf: RetStyle,
attrs: ~[Attribute]
}
attrs: Vec<Attribute> }
#[deriving(Clone, Encodable, Decodable)]
pub struct Arguments {
values: ~[Argument],
values: Vec<Argument> ,
}
impl Clean<FnDecl> for ast::FnDecl {
@ -521,7 +513,7 @@ impl Clean<FnDecl> for ast::FnDecl {
},
output: (self.output.clean()),
cf: self.cf.clean(),
attrs: ~[]
attrs: Vec::new()
}
}
}
@ -560,9 +552,9 @@ impl Clean<RetStyle> for ast::RetStyle {
#[deriving(Clone, Encodable, Decodable)]
pub struct Trait {
methods: ~[TraitMethod],
methods: Vec<TraitMethod> ,
generics: Generics,
parents: ~[Type],
parents: Vec<Type> ,
}
impl Clean<Item> for doctree::Trait {
@ -632,14 +624,14 @@ pub enum Type {
/// structs/enums/traits (anything that'd be an ast::TyPath)
ResolvedPath {
path: Path,
typarams: Option<~[TyParamBound]>,
typarams: Option<Vec<TyParamBound> >,
id: ast::NodeId,
},
/// Same as above, but only external variants
ExternalPath {
path: Path,
typarams: Option<~[TyParamBound]>,
fqn: ~[~str],
typarams: Option<Vec<TyParamBound> >,
fqn: Vec<~str> ,
kind: TypeKind,
krate: ast::CrateNum,
},
@ -655,7 +647,7 @@ pub enum Type {
Closure(~ClosureDecl),
/// extern "ABI" fn
BareFunction(~BareFunctionDecl),
Tuple(~[Type]),
Tuple(Vec<Type> ),
Vector(~Type),
FixedVector(~Type, ~str),
String,
@ -746,7 +738,7 @@ impl Clean<Option<Visibility>> for ast::Visibility {
pub struct Struct {
struct_type: doctree::StructType,
generics: Generics,
fields: ~[Item],
fields: Vec<Item> ,
fields_stripped: bool,
}
@ -774,7 +766,7 @@ impl Clean<Item> for doctree::Struct {
#[deriving(Clone, Encodable, Decodable)]
pub struct VariantStruct {
struct_type: doctree::StructType,
fields: ~[Item],
fields: Vec<Item> ,
fields_stripped: bool,
}
@ -790,7 +782,7 @@ impl Clean<VariantStruct> for syntax::ast::StructDef {
#[deriving(Clone, Encodable, Decodable)]
pub struct Enum {
variants: ~[Item],
variants: Vec<Item> ,
generics: Generics,
variants_stripped: bool,
}
@ -835,7 +827,7 @@ impl Clean<Item> for doctree::Variant {
#[deriving(Clone, Encodable, Decodable)]
pub enum VariantKind {
CLikeVariant,
TupleVariant(~[Type]),
TupleVariant(Vec<Type> ),
StructVariant(VariantStruct),
}
@ -882,7 +874,7 @@ impl Clean<Span> for syntax::codemap::Span {
#[deriving(Clone, Encodable, Decodable)]
pub struct Path {
global: bool,
segments: ~[PathSegment],
segments: Vec<PathSegment> ,
}
impl Clean<Path> for ast::Path {
@ -897,8 +889,8 @@ impl Clean<Path> for ast::Path {
#[deriving(Clone, Encodable, Decodable)]
pub struct PathSegment {
name: ~str,
lifetimes: ~[Lifetime],
types: ~[Type],
lifetimes: Vec<Lifetime> ,
types: Vec<Type> ,
}
impl Clean<PathSegment> for ast::PathSegment {
@ -969,7 +961,7 @@ impl Clean<BareFunctionDecl> for ast::BareFnTy {
purity: self.purity,
generics: Generics {
lifetimes: self.lifetimes.clean().move_iter().collect(),
type_params: ~[],
type_params: Vec::new(),
},
decl: self.decl.clean(),
abi: self.abis.to_str(),
@ -1025,7 +1017,7 @@ pub struct Impl {
generics: Generics,
trait_: Option<Type>,
for_: Type,
methods: ~[Item],
methods: Vec<Item> ,
}
impl Clean<Item> for doctree::Impl {
@ -1069,7 +1061,7 @@ impl Clean<Item> for ast::ViewItem {
#[deriving(Clone, Encodable, Decodable)]
pub enum ViewItemInner {
ExternCrate(~str, Option<~str>, ast::NodeId),
Import(~[ViewPath])
Import(Vec<ViewPath>)
}
impl Clean<ViewItemInner> for ast::ViewItem_ {
@ -1096,7 +1088,7 @@ pub enum ViewPath {
// use source::*;
GlobImport(ImportSource),
// use source::{a, b, c};
ImportList(ImportSource, ~[ViewListIdent]),
ImportList(ImportSource, Vec<ViewListIdent> ),
}
#[deriving(Clone, Encodable, Decodable)]
@ -1231,7 +1223,7 @@ fn name_from_pat(p: &ast::Pat) -> ~str {
}
/// Given a Type, resolve it using the def_map
fn resolve_type(path: Path, tpbs: Option<~[TyParamBound]>,
fn resolve_type(path: Path, tpbs: Option<Vec<TyParamBound> >,
id: ast::NodeId) -> Type {
let cx = local_data::get(super::ctxtkey, |x| *x.unwrap());
let tycx = match cx.maybe_typed {
@ -1274,9 +1266,14 @@ fn resolve_type(path: Path, tpbs: Option<~[TyParamBound]>,
ResolvedPath{ path: path, typarams: tpbs, id: def_id.node }
} else {
let fqn = csearch::get_item_path(tycx, def_id);
let fqn = fqn.move_iter().map(|i| i.to_str()).to_owned_vec();
ExternalPath{ path: path, typarams: tpbs, fqn: fqn, kind: kind,
krate: def_id.krate }
let fqn = fqn.move_iter().map(|i| i.to_str()).collect();
ExternalPath {
path: path,
typarams: tpbs,
fqn: fqn,
kind: kind,
krate: def_id.krate,
}
}
}

7
src/librustdoc/core.rs
View File

@ -51,8 +51,8 @@ pub struct CrateAnalysis {
}
/// Parses, resolves, and typechecks the given crate
fn get_ast_and_resolve(cpath: &Path,
libs: HashSet<Path>, cfgs: ~[~str]) -> (DocContext, CrateAnalysis) {
fn get_ast_and_resolve(cpath: &Path, libs: HashSet<Path>, cfgs: Vec<~str>)
-> (DocContext, CrateAnalysis) {
use syntax::codemap::dummy_spanned;
use rustc::driver::driver::{FileInput, build_configuration,
phase_1_parse_input,
@ -101,7 +101,8 @@ fn get_ast_and_resolve(cpath: &Path,
})
}
pub fn run_core (libs: HashSet<Path>, cfgs: ~[~str], path: &Path) -> (clean::Crate, CrateAnalysis) {
pub fn run_core(libs: HashSet<Path>, cfgs: Vec<~str>, path: &Path)
-> (clean::Crate, CrateAnalysis) {
let (ctxt, analysis) = get_ast_and_resolve(path, libs, cfgs);
let ctxt = @ctxt;
local_data::set(super::ctxtkey, ctxt);

76
src/librustdoc/doctree.rs
View File

@ -18,21 +18,21 @@ use syntax::ast::{Ident, NodeId};
pub struct Module {
name: Option<Ident>,
attrs: ~[ast::Attribute],
attrs: Vec<ast::Attribute> ,
where: Span,
structs: ~[Struct],
enums: ~[Enum],
fns: ~[Function],
mods: ~[Module],
structs: Vec<Struct> ,
enums: Vec<Enum> ,
fns: Vec<Function> ,
mods: Vec<Module> ,
id: NodeId,
typedefs: ~[Typedef],
statics: ~[Static],
traits: ~[Trait],
typedefs: Vec<Typedef> ,
statics: Vec<Static> ,
traits: Vec<Trait> ,
vis: ast::Visibility,
impls: ~[Impl],
foreigns: ~[ast::ForeignMod],
view_items: ~[ast::ViewItem],
macros: ~[Macro],
impls: Vec<Impl> ,
foreigns: Vec<ast::ForeignMod> ,
view_items: Vec<ast::ViewItem> ,
macros: Vec<Macro> ,
is_crate: bool,
}
@ -43,18 +43,18 @@ impl Module {
id: 0,
vis: ast::Private,
where: syntax::codemap::DUMMY_SP,
attrs : ~[],
structs : ~[],
enums : ~[],
fns : ~[],
mods : ~[],
typedefs : ~[],
statics : ~[],
traits : ~[],
impls : ~[],
view_items : ~[],
foreigns : ~[],
macros : ~[],
attrs : Vec::new(),
structs : Vec::new(),
enums : Vec::new(),
fns : Vec::new(),
mods : Vec::new(),
typedefs : Vec::new(),
statics : Vec::new(),
traits : Vec::new(),
impls : Vec::new(),
view_items : Vec::new(),
foreigns : Vec::new(),
macros : Vec::new(),
is_crate : false,
}
}
@ -83,16 +83,16 @@ pub struct Struct {
struct_type: StructType,
name: Ident,
generics: ast::Generics,
attrs: ~[ast::Attribute],
fields: ~[ast::StructField],
attrs: Vec<ast::Attribute> ,
fields: Vec<ast::StructField> ,
where: Span,
}
pub struct Enum {
vis: ast::Visibility,
variants: ~[Variant],
variants: Vec<Variant> ,
generics: ast::Generics,
attrs: ~[ast::Attribute],
attrs: Vec<ast::Attribute> ,
id: NodeId,
where: Span,
name: Ident,
@ -100,7 +100,7 @@ pub struct Enum {
pub struct Variant {
name: Ident,
attrs: ~[ast::Attribute],
attrs: Vec<ast::Attribute> ,
kind: ast::VariantKind,
id: ast::NodeId,
vis: ast::Visibility,
@ -109,7 +109,7 @@ pub struct Variant {
pub struct Function {
decl: ast::FnDecl,
attrs: ~[ast::Attribute],
attrs: Vec<ast::Attribute> ,
id: NodeId,
name: Ident,
vis: ast::Visibility,
@ -123,7 +123,7 @@ pub struct Typedef {
gen: ast::Generics,
name: Ident,
id: ast::NodeId,
attrs: ~[ast::Attribute],
attrs: Vec<ast::Attribute> ,
where: Span,
vis: ast::Visibility,
}
@ -133,7 +133,7 @@ pub struct Static {
mutability: ast::Mutability,
expr: @ast::Expr,
name: Ident,
attrs: ~[ast::Attribute],
attrs: Vec<ast::Attribute> ,
vis: ast::Visibility,
id: ast::NodeId,
where: Span,
@ -141,10 +141,10 @@ pub struct Static {
pub struct Trait {
name: Ident,
methods: ~[ast::TraitMethod], //should be TraitMethod
methods: Vec<ast::TraitMethod> , //should be TraitMethod
generics: ast::Generics,
parents: ~[ast::TraitRef],
attrs: ~[ast::Attribute],
parents: Vec<ast::TraitRef> ,
attrs: Vec<ast::Attribute> ,
id: ast::NodeId,
where: Span,
vis: ast::Visibility,
@ -154,8 +154,8 @@ pub struct Impl {
generics: ast::Generics,
trait_: Option<ast::TraitRef>,
for_: ast::P<ast::Ty>,
methods: ~[@ast::Method],
attrs: ~[ast::Attribute],
methods: Vec<@ast::Method> ,
attrs: Vec<ast::Attribute> ,
where: Span,
vis: ast::Visibility,
id: ast::NodeId,
@ -164,7 +164,7 @@ pub struct Impl {
pub struct Macro {
name: Ident,
id: ast::NodeId,
attrs: ~[ast::Attribute],
attrs: Vec<ast::Attribute> ,
where: Span,
}

10
src/librustdoc/fold.rs
View File

@ -23,7 +23,7 @@ pub trait DocFolder {
let inner = inner;
let inner = match inner {
StructItem(mut i) => {
let mut foo = ~[]; swap(&mut foo, &mut i.fields);
let mut foo = Vec::new(); swap(&mut foo, &mut i.fields);
let num_fields = foo.len();
i.fields.extend(&mut foo.move_iter().filter_map(|x| self.fold_item(x)));
i.fields_stripped |= num_fields != i.fields.len();
@ -33,7 +33,7 @@ pub trait DocFolder {
ModuleItem(self.fold_mod(i))
},
EnumItem(mut i) => {
let mut foo = ~[]; swap(&mut foo, &mut i.variants);
let mut foo = Vec::new(); swap(&mut foo, &mut i.variants);
let num_variants = foo.len();
i.variants.extend(&mut foo.move_iter().filter_map(|x| self.fold_item(x)));
i.variants_stripped |= num_variants != i.variants.len();
@ -56,12 +56,12 @@ pub trait DocFolder {
},
}
}
let mut foo = ~[]; swap(&mut foo, &mut i.methods);
let mut foo = Vec::new(); swap(&mut foo, &mut i.methods);
i.methods.extend(&mut foo.move_iter().filter_map(|x| vtrm(self, x)));
TraitItem(i)
},
ImplItem(mut i) => {
let mut foo = ~[]; swap(&mut foo, &mut i.methods);
let mut foo = Vec::new(); swap(&mut foo, &mut i.methods);
i.methods.extend(&mut foo.move_iter().filter_map(|x| self.fold_item(x)));
ImplItem(i)
},
@ -69,7 +69,7 @@ pub trait DocFolder {
let i2 = i.clone(); // this clone is small
match i.kind {
StructVariant(mut j) => {
let mut foo = ~[]; swap(&mut foo, &mut j.fields);
let mut foo = Vec::new(); swap(&mut foo, &mut j.fields);
let num_fields = foo.len();
let c = |x| self.fold_item(x);
j.fields.extend(&mut foo.move_iter().filter_map(c));

16
src/librustdoc/html/format.rs
View File

@ -170,7 +170,7 @@ fn external_path(w: &mut io::Writer, p: &clean::Path, print_all: bool,
}
},
|_cache| {
Some((fqn.to_owned(), match kind {
Some((Vec::from_slice(fqn), match kind {
clean::TypeStruct => "struct",
clean::TypeEnum => "enum",
clean::TypeFunction => "fn",
@ -181,7 +181,7 @@ fn external_path(w: &mut io::Writer, p: &clean::Path, print_all: bool,
fn path(w: &mut io::Writer, path: &clean::Path, print_all: bool,
root: |&render::Cache, &[~str]| -> Option<~str>,
info: |&render::Cache| -> Option<(~[~str], &'static str)>)
info: |&render::Cache| -> Option<(Vec<~str> , &'static str)>)
-> fmt::Result
{
// The generics will get written to both the title and link
@ -210,7 +210,7 @@ fn path(w: &mut io::Writer, path: &clean::Path, print_all: bool,
local_data::get(cache_key, |cache| {
let cache = cache.unwrap().get();
let abs_root = root(cache, loc.as_slice());
let rel_root = match path.segments[0].name.as_slice() {
let rel_root = match path.segments.get(0).name.as_slice() {
"self" => Some(~"./"),
_ => None,
};
@ -279,7 +279,7 @@ fn path(w: &mut io::Writer, path: &clean::Path, print_all: bool,
/// Helper to render type parameters
fn typarams(w: &mut io::Writer,
typarams: &Option<~[clean::TyParamBound]>) -> fmt::Result {
typarams: &Option<Vec<clean::TyParamBound> >) -> fmt::Result {
match *typarams {
Some(ref params) => {
try!(write!(w, "&lt;"));
@ -536,11 +536,11 @@ impl fmt::Show for clean::ViewListIdent {
Some(did) if ast_util::is_local(did) => {
let path = clean::Path {
global: false,
segments: ~[clean::PathSegment {
segments: vec!(clean::PathSegment {
name: self.name.clone(),
lifetimes: ~[],
types: ~[],
}]
lifetimes: Vec::new(),
types: Vec::new(),
})
};
resolved_path(f.buf, did.node, &path, false)
}

66
src/librustdoc/html/render.rs
View File

@ -68,7 +68,7 @@ use html::highlight;
pub struct Context {
/// Current hierarchy of components leading down to what's currently being
/// rendered
current: ~[~str],
current: Vec<~str> ,
/// String representation of how to get back to the root path of the 'doc/'
/// folder in terms of a relative URL.
root_path: ~str,
@ -83,7 +83,7 @@ pub struct Context {
/// functions), and the value is the list of containers belonging to this
/// header. This map will change depending on the surrounding context of the
/// page.
sidebar: HashMap<~str, ~[~str]>,
sidebar: HashMap<~str, Vec<~str> >,
/// This flag indicates whether [src] links should be generated or not. If
/// the source files are present in the html rendering, then this will be
/// `true`.
@ -130,14 +130,14 @@ pub struct Cache {
///
/// The values of the map are a list of implementations and documentation
/// found on that implementation.
impls: HashMap<ast::NodeId, ~[(clean::Impl, Option<~str>)]>,
impls: HashMap<ast::NodeId, Vec<(clean::Impl, Option<~str>)> >,
/// Maintains a mapping of local crate node ids to the fully qualified name
/// and "short type description" of that node. This is used when generating
/// URLs when a type is being linked to. External paths are not located in
/// this map because the `External` type itself has all the information
/// necessary.
paths: HashMap<ast::NodeId, (~[~str], &'static str)>,
paths: HashMap<ast::NodeId, (Vec<~str> , &'static str)>,
/// This map contains information about all known traits of this crate.
/// Implementations of a crate should inherit the documentation of the
@ -148,16 +148,16 @@ pub struct Cache {
/// When rendering traits, it's often useful to be able to list all
/// implementors of the trait, and this mapping is exactly, that: a mapping
/// of trait ids to the list of known implementors of the trait
implementors: HashMap<ast::NodeId, ~[Implementor]>,
implementors: HashMap<ast::NodeId, Vec<Implementor> >,
/// Cache of where external crate documentation can be found.
extern_locations: HashMap<ast::CrateNum, ExternalLocation>,
// Private fields only used when initially crawling a crate to build a cache
priv stack: ~[~str],
priv parent_stack: ~[ast::NodeId],
priv search_index: ~[IndexItem],
priv stack: Vec<~str> ,
priv parent_stack: Vec<ast::NodeId> ,
priv search_index: Vec<IndexItem> ,
priv privmod: bool,
priv public_items: NodeSet,
@ -202,13 +202,13 @@ struct IndexItem {
// TLS keys used to carry information around during rendering.
local_data_key!(pub cache_key: Arc<Cache>)
local_data_key!(pub current_location_key: ~[~str])
local_data_key!(pub current_location_key: Vec<~str> )
/// Generates the documentation for `crate` into the directory `dst`
pub fn run(mut krate: clean::Crate, dst: Path) -> io::IoResult<()> {
let mut cx = Context {
dst: dst,
current: ~[],
current: Vec::new(),
root_path: ~"",
sidebar: HashMap::new(),
layout: layout::Layout {
@ -250,9 +250,9 @@ pub fn run(mut krate: clean::Crate, dst: Path) -> io::IoResult<()> {
paths: HashMap::new(),
traits: HashMap::new(),
implementors: HashMap::new(),
stack: ~[],
parent_stack: ~[],
search_index: ~[],
stack: Vec::new(),
parent_stack: Vec::new(),
search_index: Vec::new(),
extern_locations: HashMap::new(),
privmod: false,
public_items: public_items,
@ -563,7 +563,7 @@ impl DocFolder for Cache {
match i.trait_ {
Some(clean::ResolvedPath{ id, .. }) => {
let v = self.implementors.find_or_insert_with(id, |_|{
~[]
Vec::new()
});
match i.for_ {
clean::ResolvedPath{..} => {
@ -694,7 +694,7 @@ impl DocFolder for Cache {
match i.for_ {
clean::ResolvedPath { id, .. } => {
let v = self.impls.find_or_insert_with(id, |_| {
~[]
Vec::new()
});
// extract relevant documentation for this impl
match attrs.move_iter().find(|a| {
@ -787,7 +787,7 @@ impl Context {
// using a rwarc makes this parallelizable in the future
local_data::set(cache_key, Arc::new(cache));
let mut work = ~[(self, item)];
let mut work = vec!((self, item));
loop {
match work.pop() {
Some((mut cx, item)) => try!(cx.item(item, |cx, item| {
@ -919,7 +919,7 @@ impl<'a> fmt::Show for Item<'a> {
}
if self.cx.include_sources {
let mut path = ~[];
let mut path = Vec::new();
clean_srcpath(self.item.source.filename.as_bytes(), |component| {
path.push(component.to_owned());
});
@ -966,8 +966,9 @@ impl<'a> fmt::Show for Item<'a> {
shortty(self.item), self.item.name.get_ref().as_slice()));
match self.item.inner {
clean::ModuleItem(ref m) => item_module(fmt.buf, self.cx,
self.item, m.items),
clean::ModuleItem(ref m) => {
item_module(fmt.buf, self.cx, self.item, m.items.as_slice())
}
clean::FunctionItem(ref f) | clean::ForeignFunctionItem(ref f) =>
item_function(fmt.buf, self.item, f),
clean::TraitItem(ref t) => item_trait(fmt.buf, self.item, t),
@ -1319,8 +1320,14 @@ fn render_method(w: &mut Writer, meth: &clean::Item) -> fmt::Result {
fn item_struct(w: &mut Writer, it: &clean::Item,
s: &clean::Struct) -> fmt::Result {
try!(write!(w, "<pre class='rust struct'>"));
try!(render_struct(w, it, Some(&s.generics), s.struct_type, s.fields,
s.fields_stripped, "", true));
try!(render_struct(w,
it,
Some(&s.generics),
s.struct_type,
s.fields.as_slice(),
s.fields_stripped,
"",
true));
try!(write!(w, "</pre>"));
try!(document(w, it));
@ -1368,9 +1375,14 @@ fn item_enum(w: &mut Writer, it: &clean::Item, e: &clean::Enum) -> fmt::Result {
try!(write!(w, ")"));
}
clean::StructVariant(ref s) => {
try!(render_struct(w, v, None, s.struct_type,
s.fields, s.fields_stripped,
" ", false));
try!(render_struct(w,
v,
None,
s.struct_type,
s.fields.as_slice(),
s.fields_stripped,
" ",
false));
}
}
}
@ -1679,7 +1691,7 @@ impl<'a> fmt::Show for Sidebar<'a> {
}
}
fn build_sidebar(m: &clean::Module) -> HashMap<~str, ~[~str]> {
fn build_sidebar(m: &clean::Module) -> HashMap<~str, Vec<~str> > {
let mut map = HashMap::new();
for item in m.items.iter() {
let short = shortty(item);
@ -1687,12 +1699,12 @@ fn build_sidebar(m: &clean::Module) -> HashMap<~str, ~[~str]> {
None => continue,
Some(ref s) => s.to_owned(),
};
let v = map.find_or_insert_with(short.to_owned(), |_| ~[]);
let v = map.find_or_insert_with(short.to_owned(), |_| Vec::new());
v.push(myname);
}
for (_, items) in map.mut_iter() {
items.sort();
items.as_mut_slice().sort();
}
return map;
}

46
src/librustdoc/lib.rs
View File

@ -80,15 +80,15 @@ static DEFAULT_PASSES: &'static [&'static str] = &[
local_data_key!(pub ctxtkey: @core::DocContext)
local_data_key!(pub analysiskey: core::CrateAnalysis)
type Output = (clean::Crate, ~[plugins::PluginJson]);
type Output = (clean::Crate, Vec<plugins::PluginJson> );
pub fn main() {
std::os::set_exit_status(main_args(std::os::args()));
}
pub fn opts() -> ~[getopts::OptGroup] {
pub fn opts() -> Vec<getopts::OptGroup> {
use getopts::*;
~[
vec!(
optflag("h", "help", "show this help message"),
optflag("", "version", "print rustdoc's version"),
optopt("r", "input-format", "the input type of the specified file",
@ -121,16 +121,18 @@ pub fn opts() -> ~[getopts::OptGroup] {
optmulti("", "markdown-after-content",
"files to include inline between the content and </body> of a rendered \
Markdown file",
"FILES"),
]
"FILES")
)
}
pub fn usage(argv0: &str) {
println!("{}", getopts::usage(format!("{} [options] <input>", argv0), opts()));
println!("{}",
getopts::usage(format!("{} [options] <input>", argv0),
opts().as_slice()));
}
pub fn main_args(args: &[~str]) -> int {
let matches = match getopts::getopts(args.tail(), opts()) {
let matches = match getopts::getopts(args.tail(), opts().as_slice()) {
Ok(m) => m,
Err(err) => {
println!("{}", err.to_err_msg());
@ -152,12 +154,15 @@ pub fn main_args(args: &[~str]) -> int {
println!("only one input file may be specified");
return 1;
}
let input = matches.free[0].as_slice();
let input = matches.free.get(0).as_slice();
let libs = matches.opt_strs("L").map(|s| Path::new(s.as_slice())).move_iter().collect();
let libs = matches.opt_strs("L").iter().map(|s| Path::new(s.as_slice())).collect();
let test_args = matches.opt_strs("test-args");
let test_args = test_args.iter().flat_map(|s| s.words()).map(|s| s.to_owned()).to_owned_vec();
let test_args: Vec<~str> = test_args.iter()
.flat_map(|s| s.words())
.map(|s| s.to_owned())
.collect();
let should_test = matches.opt_present("test");
let markdown_input = input.ends_with(".md") || input.ends_with(".markdown");
@ -165,7 +170,11 @@ pub fn main_args(args: &[~str]) -> int {
let output = matches.opt_str("o").map(|s| Path::new(s));
match (should_test, markdown_input) {
(true, true) => return markdown::test(input, libs, test_args),
(true, true) => {
return markdown::test(input,
libs,
test_args.move_iter().collect())
}
(true, false) => return test::run(input, libs, test_args),
(false, true) => return markdown::render(input, output.unwrap_or(Path::new("doc")),
@ -173,7 +182,7 @@ pub fn main_args(args: &[~str]) -> int {
(false, false) => {}
}
if matches.opt_strs("passes") == ~[~"list"] {
if matches.opt_strs("passes").as_slice() == &[~"list"] {
println!("Available passes for running rustdoc:");
for &(name, _, description) in PASSES.iter() {
println!("{:>20s} - {}", name, description);
@ -248,13 +257,18 @@ fn rust_input(cratefile: &str, matches: &getopts::Matches) -> Output {
let mut plugins = matches.opt_strs("plugins");
// First, parse the crate and extract all relevant information.
let libs = matches.opt_strs("L").map(|s| Path::new(s.as_slice()));
let libs: Vec<Path> = matches.opt_strs("L")
.iter()
.map(|s| Path::new(s.as_slice()))
.collect();
let cfgs = matches.opt_strs("cfg");
let cr = Path::new(cratefile);
info!("starting to run rustc");
let (krate, analysis) = std::task::try(proc() {
let cr = cr;
core::run_core(libs.move_iter().collect(), cfgs, &cr)
core::run_core(libs.move_iter().collect(),
cfgs.move_iter().collect(),
&cr)
}).unwrap();
info!("finished with rustc");
local_data::set(analysiskey, analysis);
@ -344,7 +358,7 @@ fn json_input(input: &str) -> Result<Output, ~str> {
};
// FIXME: this should read from the "plugins" field, but currently
// Json doesn't implement decodable...
let plugin_output = ~[];
let plugin_output = Vec::new();
Ok((krate, plugin_output))
}
Ok(..) => Err(~"malformed json input: expected an object at the top"),
@ -353,7 +367,7 @@ fn json_input(input: &str) -> Result<Output, ~str> {
/// Outputs the crate/plugin json as a giant json blob at the specified
/// destination.
fn json_output(krate: clean::Crate, res: ~[plugins::PluginJson],
fn json_output(krate: clean::Crate, res: Vec<plugins::PluginJson> ,
dst: Path) -> io::IoResult<()> {
// {
// "schema": version,

9
src/librustdoc/markdown.rs
View File

@ -86,9 +86,12 @@ pub fn render(input: &str, mut output: Path, matches: &getopts::Matches) -> int
let input_str = load_or_return!(input, 1, 2);
let (in_header, before_content, after_content) =
match (load_external_files(matches.opt_strs("markdown-in-header")),
load_external_files(matches.opt_strs("markdown-before-content")),
load_external_files(matches.opt_strs("markdown-after-content"))) {
match (load_external_files(matches.opt_strs("markdown-in-header")
.as_slice()),
load_external_files(matches.opt_strs("markdown-before-content")
.as_slice()),
load_external_files(matches.opt_strs("markdown-after-content")
.as_slice())) {
(Some(a), Some(b), Some(c)) => (a,b,c),
_ => return 3
};

8
src/librustdoc/passes.rs
View File

@ -218,7 +218,7 @@ pub fn unindent_comments(krate: clean::Crate) -> plugins::PluginResult {
impl fold::DocFolder for CommentCleaner {
fn fold_item(&mut self, i: Item) -> Option<Item> {
let mut i = i;
let mut avec: ~[clean::Attribute] = ~[];
let mut avec: Vec<clean::Attribute> = Vec::new();
for attr in i.attrs.iter() {
match attr {
&clean::NameValue(ref x, ref s) if "doc" == *x => avec.push(
@ -250,7 +250,7 @@ pub fn collapse_docs(krate: clean::Crate) -> plugins::PluginResult {
_ => ()
}
}
let mut a: ~[clean::Attribute] = i.attrs.iter().filter(|&a| match a {
let mut a: Vec<clean::Attribute> = i.attrs.iter().filter(|&a| match a {
&clean::NameValue(ref x, _) if "doc" == *x => false,
_ => true
}).map(|x| x.clone()).collect();
@ -267,7 +267,7 @@ pub fn collapse_docs(krate: clean::Crate) -> plugins::PluginResult {
}
pub fn unindent(s: &str) -> ~str {
let lines = s.lines_any().collect::<~[&str]>();
let lines = s.lines_any().collect::<Vec<&str> >();
let mut saw_first_line = false;
let mut saw_second_line = false;
let min_indent = lines.iter().fold(uint::MAX, |min_indent, line| {
@ -311,7 +311,7 @@ pub fn unindent(s: &str) -> ~str {
});
if lines.len() >= 1 {
let mut unindented = ~[ lines[0].trim() ];
let mut unindented = vec!( lines.get(0).trim() );
unindented.push_all(lines.tail().map(|&line| {
if line.is_whitespace() {
line

12
src/librustdoc/plugins.rs
View File

@ -19,8 +19,8 @@ pub type PluginCallback = fn (clean::Crate) -> PluginResult;
/// Manages loading and running of plugins
pub struct PluginManager {
priv dylibs: ~[dl::DynamicLibrary],
priv callbacks: ~[PluginCallback],
priv dylibs: Vec<dl::DynamicLibrary> ,
priv callbacks: Vec<PluginCallback> ,
/// The directory plugins will be loaded from
prefix: Path,
}
@ -29,8 +29,8 @@ impl PluginManager {
/// Create a new plugin manager
pub fn new(prefix: Path) -> PluginManager {
PluginManager {
dylibs: ~[],
callbacks: ~[],
dylibs: Vec::new(),
callbacks: Vec::new(),
prefix: prefix,
}
}
@ -57,8 +57,8 @@ impl PluginManager {
self.callbacks.push(plugin);
}
/// Run all the loaded plugins over the crate, returning their results
pub fn run_plugins(&self, krate: clean::Crate) -> (clean::Crate, ~[PluginJson]) {
let mut out_json = ~[];
pub fn run_plugins(&self, krate: clean::Crate) -> (clean::Crate, Vec<PluginJson> ) {
let mut out_json = Vec::new();
let mut krate = krate;
for &callback in self.callbacks.iter() {
let (c, res) = callback(krate);

19
src/librustdoc/test.rs
View File

@ -33,7 +33,7 @@ use html::markdown;
use passes;
use visit_ast::RustdocVisitor;
pub fn run(input: &str, libs: HashSet<Path>, mut test_args: ~[~str]) -> int {
pub fn run(input: &str, libs: HashSet<Path>, mut test_args: Vec<~str>) -> int {
let input_path = Path::new(input);
let input = driver::FileInput(input_path.clone());
@ -71,13 +71,16 @@ pub fn run(input: &str, libs: HashSet<Path>, mut test_args: ~[~str]) -> int {
let (krate, _) = passes::unindent_comments(krate);
let (krate, _) = passes::collapse_docs(krate);
let mut collector = Collector::new(krate.name.to_owned(), libs, false, false);
let mut collector = Collector::new(krate.name.to_owned(),
libs,
false,
false);
collector.fold_crate(krate);
test_args.unshift(~"rustdoctest");
testing::test_main(test_args, collector.tests);
testing::test_main(test_args.as_slice(),
collector.tests.move_iter().collect());
0
}
@ -187,8 +190,8 @@ fn maketest(s: &str, cratename: &str, loose_feature_gating: bool) -> ~str {
}
pub struct Collector {
tests: ~[testing::TestDescAndFn],
priv names: ~[~str],
tests: Vec<testing::TestDescAndFn>,
priv names: Vec<~str>,
priv libs: HashSet<Path>,
priv cnt: uint,
priv use_headers: bool,
@ -202,8 +205,8 @@ impl Collector {
pub fn new(cratename: ~str, libs: HashSet<Path>,
use_headers: bool, loose_feature_gating: bool) -> Collector {
Collector {
tests: ~[],
names: ~[],
tests: Vec::new(),
names: Vec::new(),
libs: libs,
cnt: 0,
use_headers: use_headers,

8
src/librustdoc/visit_ast.rs
View File

@ -22,7 +22,7 @@ use doctree::*;
pub struct RustdocVisitor<'a> {
module: Module,
attrs: ~[ast::Attribute],
attrs: Vec<ast::Attribute> ,
cx: &'a core::DocContext,
analysis: Option<&'a core::CrateAnalysis>,
}
@ -32,7 +32,7 @@ impl<'a> RustdocVisitor<'a> {
analysis: Option<&'b core::CrateAnalysis>) -> RustdocVisitor<'b> {
RustdocVisitor {
module: Module::new(None),
attrs: ~[],
attrs: Vec::new(),
cx: cx,
analysis: analysis,
}
@ -72,7 +72,7 @@ impl<'a> RustdocVisitor<'a> {
pub fn visit_enum_def(&mut self, it: &ast::Item, def: &ast::EnumDef,
params: &ast::Generics) -> Enum {
debug!("Visiting enum");
let mut vars: ~[Variant] = ~[];
let mut vars: Vec<Variant> = Vec::new();
for x in def.variants.iter() {
vars.push(Variant {
name: x.node.name,
@ -110,7 +110,7 @@ impl<'a> RustdocVisitor<'a> {
}
}
pub fn visit_mod_contents(&mut self, span: Span, attrs: ~[ast::Attribute],
pub fn visit_mod_contents(&mut self, span: Span, attrs: Vec<ast::Attribute> ,
vis: ast::Visibility, id: ast::NodeId,
m: &ast::Mod,
name: Option<ast::Ident>) -> Module {

15
src/libsync/arc.rs
View File

@ -583,25 +583,26 @@ mod tests {
use super::{Arc, RWArc, MutexArc, CowArc};
use std::task;
use std::vec_ng::Vec;
#[test]
fn manually_share_arc() {
let v = ~[1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
let v = vec!(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
let arc_v = Arc::new(v);
let (tx, rx) = channel();
task::spawn(proc() {
let arc_v: Arc<~[int]> = rx.recv();
let arc_v: Arc<Vec<int>> = rx.recv();
let v = arc_v.get().clone();
assert_eq!(v[3], 4);
assert_eq!(*v.get(3), 4);
});
tx.send(arc_v.clone());
assert_eq!(arc_v.get()[2], 3);
assert_eq!(arc_v.get()[4], 5);
assert_eq!(*arc_v.get().get(2), 3);
assert_eq!(*arc_v.get().get(4), 5);
info!("{:?}", arc_v);
}
@ -803,7 +804,7 @@ mod tests {
});
// Readers try to catch the writer in the act
let mut children = ~[];
let mut children = Vec::new();
for _ in range(0, 5) {
let arc3 = arc.clone();
let mut builder = task::task();
@ -857,7 +858,7 @@ mod tests {
let arc = RWArc::new(0);
// Reader tasks
let mut reader_convos = ~[];
let mut reader_convos = Vec::new();
for _ in range(0, 10) {
let ((tx1, rx1), (tx2, rx2)) = (channel(), channel());
reader_convos.push((tx1, rx2));

25
src/libsync/sync/mod.rs
View File

@ -161,10 +161,10 @@ impl<Q:Send> Sem<Q> {
}
#[doc(hidden)]
impl Sem<~[WaitQueue]> {
impl Sem<Vec<WaitQueue> > {
fn new_and_signal(count: int, num_condvars: uint)
-> Sem<~[WaitQueue]> {
let mut queues = ~[];
-> Sem<Vec<WaitQueue> > {
let mut queues = Vec::new();
for _ in range(0, num_condvars) { queues.push(WaitQueue::new()); }
Sem::new(count, queues)
}
@ -182,7 +182,7 @@ enum ReacquireOrderLock<'a> {
pub struct Condvar<'a> {
// The 'Sem' object associated with this condvar. This is the one that's
// atomically-unlocked-and-descheduled upon and reacquired during wakeup.
priv sem: &'a Sem<~[WaitQueue]>,
priv sem: &'a Sem<Vec<WaitQueue> >,
// This is (can be) an extra semaphore which is held around the reacquire
// operation on the first one. This is only used in cvars associated with
// rwlocks, and is needed to ensure that, when a downgrader is trying to
@ -230,7 +230,7 @@ impl<'a> Condvar<'a> {
}
// Create waiter nobe, and enqueue ourself to
// be woken up by a signaller.
wait_end = Some(state.blocked[condvar_id].wait_end());
wait_end = Some(state.blocked.get(condvar_id).wait_end());
} else {
out_of_bounds = Some(state.blocked.len());
}
@ -265,7 +265,7 @@ impl<'a> Condvar<'a> {
let mut result = false;
self.sem.with(|state| {
if condvar_id < state.blocked.len() {
result = state.blocked[condvar_id].signal();
result = state.blocked.get(condvar_id).signal();
} else {
out_of_bounds = Some(state.blocked.len());
}
@ -290,7 +290,7 @@ impl<'a> Condvar<'a> {
// To avoid :broadcast_heavy, we make a new waitqueue,
// swap it out with the old one, and broadcast on the
// old one outside of the little-lock.
queue = Some(replace(&mut state.blocked[condvar_id],
queue = Some(replace(state.blocked.get_mut(condvar_id),
WaitQueue::new()));
} else {
out_of_bounds = Some(state.blocked.len());
@ -326,7 +326,7 @@ fn check_cvar_bounds<U>(
}
#[doc(hidden)]
impl Sem<~[WaitQueue]> {
impl Sem<Vec<WaitQueue> > {
// The only other places that condvars get built are rwlock.write_cond()
// and rwlock_write_mode.
pub fn access_cond<U>(&self, blk: |c: &Condvar| -> U) -> U {
@ -391,7 +391,7 @@ impl Semaphore {
* unwinds.
*/
pub struct Mutex { priv sem: Sem<~[WaitQueue]> }
pub struct Mutex { priv sem: Sem<Vec<WaitQueue> > }
impl Clone for Mutex {
/// Create a new handle to the mutex.
fn clone(&self) -> Mutex {
@ -461,7 +461,7 @@ struct RWLockInner {
*/
pub struct RWLock {
priv order_lock: Semaphore,
priv access_lock: Sem<~[WaitQueue]>,
priv access_lock: Sem<Vec<WaitQueue> >,
priv state: UnsafeArc<RWLockInner>,
}
@ -765,6 +765,7 @@ mod tests {
use std::result;
use std::task;
use std::comm::Empty;
use std::vec_ng::Vec;
/************************************************************************
* Semaphore tests
@ -931,7 +932,7 @@ mod tests {
#[cfg(test)]
fn test_mutex_cond_broadcast_helper(num_waiters: uint) {
let m = Mutex::new();
let mut rxs = ~[];
let mut rxs = vec!();
for _ in range(0, num_waiters) {
let mi = m.clone();
@ -1200,7 +1201,7 @@ mod tests {
}
}
let x = RWLock::new();
let mut rxs = ~[];
let mut rxs = vec!();
for _ in range(0, num_waiters) {
let xi = x.clone();

12
src/libsync/task_pool.rs
View File

@ -14,7 +14,6 @@
/// parallelism.
use std::task;
use std::slice;
enum Msg<T> {
Execute(proc(&T)),
@ -22,7 +21,7 @@ enum Msg<T> {
}
pub struct TaskPool<T> {
priv channels: ~[Sender<Msg<T>>],
priv channels: Vec<Sender<Msg<T>>>,
priv next_index: uint,
}
@ -46,7 +45,7 @@ impl<T> TaskPool<T> {
-> TaskPool<T> {
assert!(n_tasks >= 1);
let channels = slice::from_fn(n_tasks, |i| {
let channels = Vec::from_fn(n_tasks, |i| {
let (tx, rx) = channel::<Msg<T>>();
let init_fn = init_fn_factory();
@ -66,13 +65,16 @@ impl<T> TaskPool<T> {
tx
});
return TaskPool { channels: channels, next_index: 0 };
return TaskPool {
channels: channels,
next_index: 0,
};
}
/// Executes the function `f` on a task in the pool. The function
/// receives a reference to the local data returned by the `init_fn`.
pub fn execute(&mut self, f: proc(&T)) {
self.channels[self.next_index].send(Execute(f));
self.channels.get(self.next_index).send(Execute(f));
self.next_index += 1;
if self.next_index == self.channels.len() { self.next_index = 0; }
}

28
src/libterm/lib.rs
View File

@ -24,8 +24,8 @@
extern crate collections;
use std::os;
use std::io;
use std::os;
use terminfo::TermInfo;
use terminfo::searcher::open;
use terminfo::parser::compiled::{parse, msys_terminfo};
@ -149,10 +149,14 @@ impl<T: Writer> Terminal<T> {
pub fn fg(&mut self, color: color::Color) -> io::IoResult<bool> {
let color = self.dim_if_necessary(color);
if self.num_colors > color {
let s = expand(*self.ti.strings.find_equiv(&("setaf")).unwrap(),
let s = expand(self.ti
.strings
.find_equiv(&("setaf"))
.unwrap()
.as_slice(),
[Number(color as int)], &mut Variables::new());
if s.is_ok() {
try!(self.out.write(s.unwrap()));
try!(self.out.write(s.unwrap().as_slice()));
return Ok(true)
}
}
@ -168,10 +172,14 @@ impl<T: Writer> Terminal<T> {
pub fn bg(&mut self, color: color::Color) -> io::IoResult<bool> {
let color = self.dim_if_necessary(color);
if self.num_colors > color {
let s = expand(*self.ti.strings.find_equiv(&("setab")).unwrap(),
let s = expand(self.ti
.strings
.find_equiv(&("setab"))
.unwrap()
.as_slice(),
[Number(color as int)], &mut Variables::new());
if s.is_ok() {
try!(self.out.write(s.unwrap()));
try!(self.out.write(s.unwrap().as_slice()));
return Ok(true)
}
}
@ -189,9 +197,11 @@ impl<T: Writer> Terminal<T> {
let cap = cap_for_attr(attr);
let parm = self.ti.strings.find_equiv(&cap);
if parm.is_some() {
let s = expand(*parm.unwrap(), [], &mut Variables::new());
let s = expand(parm.unwrap().as_slice(),
[],
&mut Variables::new());
if s.is_ok() {
try!(self.out.write(s.unwrap()));
try!(self.out.write(s.unwrap().as_slice()));
return Ok(true)
}
}
@ -225,10 +235,10 @@ impl<T: Writer> Terminal<T> {
}
}
let s = cap.map_or(Err(~"can't find terminfo capability `sgr0`"), |op| {
expand(*op, [], &mut Variables::new())
expand(op.as_slice(), [], &mut Variables::new())
});
if s.is_ok() {
return self.out.write(s.unwrap())
return self.out.write(s.unwrap().as_slice())
}
Ok(())
}

4
src/libterm/terminfo/mod.rs
View File

@ -15,13 +15,13 @@ use collections::HashMap;
/// A parsed terminfo entry.
pub struct TermInfo {
/// Names for the terminal
priv names: ~[~str],
priv names: Vec<~str> ,
/// Map of capability name to boolean value
priv bools: HashMap<~str, bool>,
/// Map of capability name to numeric value
numbers: HashMap<~str, u16>,
/// Map of capability name to raw (unexpanded) string
strings: HashMap<~str, ~[u8]>
strings: HashMap<~str, Vec<u8> >
}
pub mod searcher;

94
src/libterm/terminfo/parm.rs
View File

@ -10,7 +10,7 @@
//! Parameterized string expansion
use std::{char, slice};
use std::char;
use std::mem::replace;
#[deriving(Eq)]
@ -89,13 +89,13 @@ impl Variables {
multiple capabilities for the same terminal.
*/
pub fn expand(cap: &[u8], params: &[Param], vars: &mut Variables)
-> Result<~[u8], ~str> {
-> Result<Vec<u8> , ~str> {
let mut state = Nothing;
// expanded cap will only rarely be larger than the cap itself
let mut output = slice::with_capacity(cap.len());
let mut output = Vec::with_capacity(cap.len());
let mut stack: ~[Param] = ~[];
let mut stack: Vec<Param> = Vec::new();
// Copy parameters into a local vector for mutability
let mut mparams = [
@ -248,7 +248,7 @@ pub fn expand(cap: &[u8], params: &[Param], vars: &mut Variables)
let flags = Flags::new();
let res = format(stack.pop().unwrap(), FormatOp::from_char(cur), flags);
if res.is_err() { return res }
output.push_all(res.unwrap())
output.push_all(res.unwrap().as_slice())
} else { return Err(~"stack is empty") },
':'|'#'|' '|'.'|'0'..'9' => {
let mut flags = Flags::new();
@ -343,7 +343,7 @@ pub fn expand(cap: &[u8], params: &[Param], vars: &mut Variables)
(_,'d')|(_,'o')|(_,'x')|(_,'X')|(_,'s') => if stack.len() > 0 {
let res = format(stack.pop().unwrap(), FormatOp::from_char(cur), *flags);
if res.is_err() { return res }
output.push_all(res.unwrap());
output.push_all(res.unwrap().as_slice());
old_state = state; // will cause state to go to Nothing
} else { return Err(~"stack is empty") },
(FormatStateFlags,'#') => {
@ -476,10 +476,10 @@ impl FormatOp {
}
}
fn format(val: Param, op: FormatOp, flags: Flags) -> Result<~[u8],~str> {
fn format(val: Param, op: FormatOp, flags: Flags) -> Result<Vec<u8> ,~str> {
let mut s = match val {
Number(d) => {
let mut s = match (op, flags.sign) {
let s = match (op, flags.sign) {
(FormatDigit, true) => format!("{:+d}", d).into_bytes(),
(FormatDigit, false) => format!("{:d}", d).into_bytes(),
(FormatOctal, _) => format!("{:o}", d).into_bytes(),
@ -487,8 +487,9 @@ fn format(val: Param, op: FormatOp, flags: Flags) -> Result<~[u8],~str> {
(FormatHEX, _) => format!("{:X}", d).into_bytes(),
(FormatString, _) => return Err(~"non-number on stack with %s"),
};
let mut s: Vec<u8> = s.move_iter().collect();
if flags.precision > s.len() {
let mut s_ = slice::with_capacity(flags.precision);
let mut s_ = Vec::with_capacity(flags.precision);
let n = flags.precision - s.len();
s_.grow(n, &('0' as u8));
s_.push_all_move(s);
@ -497,25 +498,31 @@ fn format(val: Param, op: FormatOp, flags: Flags) -> Result<~[u8],~str> {
assert!(!s.is_empty(), "string conversion produced empty result");
match op {
FormatDigit => {
if flags.space && !(s[0] == '-' as u8 || s[0] == '+' as u8) {
if flags.space && !(*s.get(0) == '-' as u8 ||
*s.get(0) == '+' as u8) {
s.unshift(' ' as u8);
}
}
FormatOctal => {
if flags.alternate && s[0] != '0' as u8 {
if flags.alternate && *s.get(0) != '0' as u8 {
s.unshift('0' as u8);
}
}
FormatHex => {
if flags.alternate {
let s_ = replace(&mut s, ~['0' as u8, 'x' as u8]);
let s_ = replace(&mut s, vec!('0' as u8, 'x' as u8));
s.push_all_move(s_);
}
}
FormatHEX => {
s = s.into_ascii().to_upper().into_bytes();
s = s.as_slice()
.to_ascii()
.to_upper()
.into_bytes()
.move_iter()
.collect();
if flags.alternate {
let s_ = replace(&mut s, ~['0' as u8, 'X' as u8]);
let s_ = replace(&mut s, vec!('0' as u8, 'X' as u8));
s.push_all_move(s_);
}
}
@ -526,7 +533,7 @@ fn format(val: Param, op: FormatOp, flags: Flags) -> Result<~[u8],~str> {
String(s) => {
match op {
FormatString => {
let mut s = s.as_bytes().to_owned();
let mut s = Vec::from_slice(s.as_bytes());
if flags.precision > 0 && flags.precision < s.len() {
s.truncate(flags.precision);
}
@ -543,7 +550,7 @@ fn format(val: Param, op: FormatOp, flags: Flags) -> Result<~[u8],~str> {
if flags.left {
s.grow(n, &(' ' as u8));
} else {
let mut s_ = slice::with_capacity(flags.width);
let mut s_ = Vec::with_capacity(flags.width);
s_.grow(n, &(' ' as u8));
s_.push_all_move(s);
s = s_;
@ -556,18 +563,19 @@ fn format(val: Param, op: FormatOp, flags: Flags) -> Result<~[u8],~str> {
mod test {
use super::{expand,String,Variables,Number};
use std::result::Ok;
use std::vec_ng;
#[test]
fn test_basic_setabf() {
let s = bytes!("\\E[48;5;%p1%dm");
assert_eq!(expand(s, [Number(1)], &mut Variables::new()).unwrap(),
bytes!("\\E[48;5;1m").to_owned());
bytes!("\\E[48;5;1m").iter().map(|x| *x).collect());
}
#[test]
fn test_multiple_int_constants() {
assert_eq!(expand(bytes!("%{1}%{2}%d%d"), [], &mut Variables::new()).unwrap(),
bytes!("21").to_owned());
bytes!("21").iter().map(|x| *x).collect());
}
#[test]
@ -575,9 +583,9 @@ mod test {
let mut vars = Variables::new();
assert_eq!(expand(bytes!("%p1%d%p2%d%p3%d%i%p1%d%p2%d%p3%d"),
[Number(1),Number(2),Number(3)], &mut vars),
Ok(bytes!("123233").to_owned()));
Ok(bytes!("123233").iter().map(|x| *x).collect()));
assert_eq!(expand(bytes!("%p1%d%p2%d%i%p1%d%p2%d"), [], &mut vars),
Ok(bytes!("0011").to_owned()));
Ok(bytes!("0011").iter().map(|x| *x).collect()));
}
#[test]
@ -590,7 +598,12 @@ mod test {
assert!(res.is_err(),
"Op {} succeeded incorrectly with 0 stack entries", *cap);
let p = if *cap == "%s" || *cap == "%l" { String(~"foo") } else { Number(97) };
let res = expand((bytes!("%p1")).to_owned() + cap.as_bytes(), [p], vars);
let res = expand(vec::append(bytes!("%p1").iter()
.map(|x| *x)
.collect(),
cap.as_bytes()).as_slice(),
[p],
vars);
assert!(res.is_ok(),
"Op {} failed with 1 stack entry: {}", *cap, res.unwrap_err());
}
@ -599,10 +612,20 @@ mod test {
let res = expand(cap.as_bytes(), [], vars);
assert!(res.is_err(),
"Binop {} succeeded incorrectly with 0 stack entries", *cap);
let res = expand((bytes!("%{1}")).to_owned() + cap.as_bytes(), [], vars);
let res = expand(vec::append(bytes!("%{1}").iter()
.map(|x| *x)
.collect(),
cap.as_bytes()).as_slice(),
[],
vars);
assert!(res.is_err(),
"Binop {} succeeded incorrectly with 1 stack entry", *cap);
let res = expand((bytes!("%{1}%{2}")).to_owned() + cap.as_bytes(), [], vars);
let res = expand(vec::append(bytes!("%{1}%{2}").iter()
.map(|x| *x)
.collect(),
cap.as_bytes()).as_slice(),
[],
vars);
assert!(res.is_ok(),
"Binop {} failed with 2 stack entries: {}", *cap, res.unwrap_err());
}
@ -620,15 +643,15 @@ mod test {
let s = format!("%\\{1\\}%\\{2\\}%{}%d", op);
let res = expand(s.as_bytes(), [], &mut Variables::new());
assert!(res.is_ok(), res.unwrap_err());
assert_eq!(res.unwrap(), ~['0' as u8 + bs[0]]);
assert_eq!(res.unwrap(), vec!('0' as u8 + bs[0]));
let s = format!("%\\{1\\}%\\{1\\}%{}%d", op);
let res = expand(s.as_bytes(), [], &mut Variables::new());
assert!(res.is_ok(), res.unwrap_err());
assert_eq!(res.unwrap(), ~['0' as u8 + bs[1]]);
assert_eq!(res.unwrap(), vec!('0' as u8 + bs[1]));
let s = format!("%\\{2\\}%\\{1\\}%{}%d", op);
let res = expand(s.as_bytes(), [], &mut Variables::new());
assert!(res.is_ok(), res.unwrap_err());
assert_eq!(res.unwrap(), ~['0' as u8 + bs[2]]);
assert_eq!(res.unwrap(), vec!('0' as u8 + bs[2]));
}
}
@ -638,13 +661,16 @@ mod test {
let s = bytes!("\\E[%?%p1%{8}%<%t3%p1%d%e%p1%{16}%<%t9%p1%{8}%-%d%e38;5;%p1%d%;m");
let res = expand(s, [Number(1)], &mut vars);
assert!(res.is_ok(), res.unwrap_err());
assert_eq!(res.unwrap(), bytes!("\\E[31m").to_owned());
assert_eq!(res.unwrap(),
bytes!("\\E[31m").iter().map(|x| *x).collect());
let res = expand(s, [Number(8)], &mut vars);
assert!(res.is_ok(), res.unwrap_err());
assert_eq!(res.unwrap(), bytes!("\\E[90m").to_owned());
assert_eq!(res.unwrap(),
bytes!("\\E[90m").iter().map(|x| *x).collect());
let res = expand(s, [Number(42)], &mut vars);
assert!(res.is_ok(), res.unwrap_err());
assert_eq!(res.unwrap(), bytes!("\\E[38;5;42m").to_owned());
assert_eq!(res.unwrap(),
bytes!("\\E[38;5;42m").iter().map(|x| *x).collect());
}
#[test]
@ -653,13 +679,15 @@ mod test {
let vars = &mut varstruct;
assert_eq!(expand(bytes!("%p1%s%p2%2s%p3%2s%p4%.2s"),
[String(~"foo"), String(~"foo"), String(~"f"), String(~"foo")], vars),
Ok(bytes!("foofoo ffo").to_owned()));
Ok(bytes!("foofoo ffo").iter().map(|x| *x).collect()));
assert_eq!(expand(bytes!("%p1%:-4.2s"), [String(~"foo")], vars),
Ok(bytes!("fo ").to_owned()));
Ok(bytes!("fo ").iter().map(|x| *x).collect()));
assert_eq!(expand(bytes!("%p1%d%p1%.3d%p1%5d%p1%:+d"), [Number(1)], vars),
Ok(bytes!("1001 1+1").to_owned()));
Ok(bytes!("1001 1+1").iter().map(|x| *x).collect()));
assert_eq!(expand(bytes!("%p1%o%p1%#o%p2%6.4x%p2%#6.4X"), [Number(15), Number(27)], vars),
Ok(bytes!("17017 001b0X001B").to_owned()));
Ok(bytes!("17017 001b0X001B").iter()
.map(|x| *x)
.collect()));
}
}

26
src/libterm/terminfo/parser/compiled.rs
View File

@ -12,10 +12,9 @@
/// ncurses-compatible compiled terminfo format parsing (term(5))
use std::{slice, str};
use std::io;
use collections::HashMap;
use std::io;
use std::str;
use super::super::TermInfo;
// These are the orders ncurses uses in its compiled format (as of 5.9). Not sure if portable.
@ -213,7 +212,7 @@ pub fn parse(file: &mut io::Reader,
Some(s) => s, None => return Err(~"input not utf-8"),
};
let term_names: ~[~str] = names_str.split('|').map(|s| s.to_owned()).collect();
let term_names: Vec<~str> = names_str.split('|').map(|s| s.to_owned()).collect();
try!(file.read_byte()); // consume NUL
@ -246,7 +245,7 @@ pub fn parse(file: &mut io::Reader,
let mut string_map = HashMap::new();
if string_offsets_count != 0 {
let mut string_offsets = slice::with_capacity(10);
let mut string_offsets = Vec::with_capacity(10);
for _ in range(0, string_offsets_count) {
string_offsets.push(try!(file.read_le_u16()));
}
@ -272,7 +271,7 @@ pub fn parse(file: &mut io::Reader,
if offset == 0xFFFE {
// undocumented: FFFE indicates cap@, which means the capability is not present
// unsure if the handling for this is correct
string_map.insert(name.to_owned(), ~[]);
string_map.insert(name.to_owned(), Vec::new());
continue;
}
@ -283,8 +282,9 @@ pub fn parse(file: &mut io::Reader,
match nulpos {
Some(len) => {
string_map.insert(name.to_owned(),
string_table.slice(offset as uint,
offset as uint + len).to_owned())
Vec::from_slice(
string_table.slice(offset as uint,
offset as uint + len)))
},
None => {
return Err(~"invalid file: missing NUL in string_table");
@ -300,12 +300,12 @@ pub fn parse(file: &mut io::Reader,
/// Create a dummy TermInfo struct for msys terminals
pub fn msys_terminfo() -> ~TermInfo {
let mut strings = HashMap::new();
strings.insert(~"sgr0", bytes!("\x1b[0m").to_owned());
strings.insert(~"bold", bytes!("\x1b[1m").to_owned());
strings.insert(~"setaf", bytes!("\x1b[3%p1%dm").to_owned());
strings.insert(~"setab", bytes!("\x1b[4%p1%dm").to_owned());
strings.insert(~"sgr0", Vec::from_slice(bytes!("\x1b[0m")));
strings.insert(~"bold", Vec::from_slice(bytes!("\x1b[1m")));
strings.insert(~"setaf", Vec::from_slice(bytes!("\x1b[3%p1%dm")));
strings.insert(~"setab", Vec::from_slice(bytes!("\x1b[4%p1%dm")));
~TermInfo {
names: ~[~"cygwin"], // msys is a fork of an older cygwin version
names: vec!(~"cygwin"), // msys is a fork of an older cygwin version
bools: HashMap::new(),
numbers: HashMap::new(),
strings: strings

2
src/libterm/terminfo/searcher.rs
View File

@ -23,7 +23,7 @@ pub fn get_dbpath_for_term(term: &str) -> Option<~Path> {
let homedir = os::homedir();
let mut dirs_to_search = ~[];
let mut dirs_to_search = Vec::new();
let first_char = term.char_at(0);
// Find search directory

93
src/libtest/lib.rs
View File

@ -203,7 +203,7 @@ pub type MetricDiff = TreeMap<~str,MetricChange>;
// The default console test runner. It accepts the command line
// arguments and a vector of test_descs.
pub fn test_main(args: &[~str], tests: ~[TestDescAndFn]) {
pub fn test_main(args: &[~str], tests: Vec<TestDescAndFn> ) {
let opts =
match parse_opts(args) {
Some(Ok(o)) => o,
@ -225,7 +225,7 @@ pub fn test_main(args: &[~str], tests: ~[TestDescAndFn]) {
// semantics into parallel test runners, which in turn requires a ~[]
// rather than a &[].
pub fn test_main_static(args: &[~str], tests: &[TestDescAndFn]) {
let owned_tests = tests.map(|t| {
let owned_tests = tests.iter().map(|t| {
match t.testfn {
StaticTestFn(f) =>
TestDescAndFn { testfn: StaticTestFn(f), desc: t.desc.clone() },
@ -237,7 +237,7 @@ pub fn test_main_static(args: &[~str], tests: &[TestDescAndFn]) {
fail!("non-static tests passed to test::test_main_static");
}
}
});
}).collect();
test_main(args, owned_tests)
}
@ -256,8 +256,8 @@ pub struct TestOpts {
/// Result of parsing the options.
pub type OptRes = Result<TestOpts, ~str>;
fn optgroups() -> ~[getopts::OptGroup] {
~[getopts::optflag("", "ignored", "Run ignored tests"),
fn optgroups() -> Vec<getopts::OptGroup> {
vec!(getopts::optflag("", "ignored", "Run ignored tests"),
getopts::optflag("", "test", "Run tests and not benchmarks"),
getopts::optflag("", "bench", "Run benchmarks instead of tests"),
getopts::optflag("h", "help", "Display this message (longer with --help)"),
@ -273,12 +273,12 @@ fn optgroups() -> ~[getopts::OptGroup] {
getopts::optopt("", "logfile", "Write logs to the specified file instead \
of stdout", "PATH"),
getopts::optopt("", "test-shard", "run shard A, of B shards, worth of the testsuite",
"A.B")]
"A.B"))
}
fn usage(binary: &str, helpstr: &str) {
let message = format!("Usage: {} [OPTIONS] [FILTER]", binary);
println!("{}", getopts::usage(message, optgroups()));
println!("{}", getopts::usage(message, optgroups().as_slice()));
println!("");
if helpstr == "help" {
println!("{}", "\
@ -308,7 +308,7 @@ Test Attributes:
pub fn parse_opts(args: &[~str]) -> Option<OptRes> {
let args_ = args.tail();
let matches =
match getopts::getopts(args_, optgroups()) {
match getopts::getopts(args_, optgroups().as_slice()) {
Ok(m) => m,
Err(f) => return Some(Err(f.to_err_msg()))
};
@ -318,7 +318,7 @@ pub fn parse_opts(args: &[~str]) -> Option<OptRes> {
let filter =
if matches.free.len() > 0 {
Some((matches).free[0].clone())
Some((*matches.free.get(0)).clone())
} else {
None
};
@ -408,7 +408,7 @@ struct ConsoleTestState<T> {
ignored: uint,
measured: uint,
metrics: MetricMap,
failures: ~[(TestDesc, ~[u8])],
failures: Vec<(TestDesc, Vec<u8> )> ,
max_name_len: uint, // number of columns to fill when aligning names
}
@ -433,7 +433,7 @@ impl<T: Writer> ConsoleTestState<T> {
ignored: 0u,
measured: 0u,
metrics: MetricMap::new(),
failures: ~[],
failures: Vec::new(),
max_name_len: 0u,
})
}
@ -547,14 +547,14 @@ impl<T: Writer> ConsoleTestState<T> {
pub fn write_failures(&mut self) -> io::IoResult<()> {
try!(self.write_plain("\nfailures:\n"));
let mut failures = ~[];
let mut failures = Vec::new();
let mut fail_out = ~"";
for &(ref f, ref stdout) in self.failures.iter() {
failures.push(f.name.to_str());
if stdout.len() > 0 {
fail_out.push_str(format!("---- {} stdout ----\n\t",
f.name.to_str()));
let output = str::from_utf8_lossy(*stdout);
let output = str::from_utf8_lossy(stdout.as_slice());
fail_out.push_str(output.as_slice().replace("\n", "\n\t"));
fail_out.push_str("\n");
}
@ -565,7 +565,7 @@ impl<T: Writer> ConsoleTestState<T> {
}
try!(self.write_plain("\nfailures:\n"));
failures.sort();
failures.as_mut_slice().sort();
for name in failures.iter() {
try!(self.write_plain(format!(" {}\n", name.to_str())));
}
@ -665,7 +665,7 @@ impl<T: Writer> ConsoleTestState<T> {
pub fn fmt_metrics(mm: &MetricMap) -> ~str {
let MetricMap(ref mm) = *mm;
let v : ~[~str] = mm.iter()
let v : Vec<~str> = mm.iter()
.map(|(k,v)| format!("{}: {} (+/- {})",
*k,
v.value as f64,
@ -689,7 +689,7 @@ pub fn fmt_bench_samples(bs: &BenchSamples) -> ~str {
// A simple console test runner
pub fn run_tests_console(opts: &TestOpts,
tests: ~[TestDescAndFn]) -> io::IoResult<bool> {
tests: Vec<TestDescAndFn> ) -> io::IoResult<bool> {
fn callback<T: Writer>(event: &TestEvent,
st: &mut ConsoleTestState<T>) -> io::IoResult<()> {
match (*event).clone() {
@ -779,7 +779,7 @@ fn should_sort_failures_before_printing_them() {
measured: 0u,
max_name_len: 10u,
metrics: MetricMap::new(),
failures: ~[(test_b, ~[]), (test_a, ~[])]
failures: vec!((test_b, Vec::new()), (test_a, Vec::new()))
};
st.write_failures().unwrap();
@ -797,18 +797,20 @@ fn use_color() -> bool { return get_concurrency() == 1; }
#[deriving(Clone)]
enum TestEvent {
TeFiltered(~[TestDesc]),
TeFiltered(Vec<TestDesc> ),
TeWait(TestDesc, NamePadding),
TeResult(TestDesc, TestResult, ~[u8] /* stdout */),
TeResult(TestDesc, TestResult, Vec<u8> ),
}
pub type MonitorMsg = (TestDesc, TestResult, ~[u8] /* stdout */);
pub type MonitorMsg = (TestDesc, TestResult, Vec<u8> );
fn run_tests(opts: &TestOpts,
tests: ~[TestDescAndFn],
tests: Vec<TestDescAndFn> ,
callback: |e: TestEvent| -> io::IoResult<()>) -> io::IoResult<()> {
let filtered_tests = filter_tests(opts, tests);
let filtered_descs = filtered_tests.map(|t| t.desc.clone());
let filtered_descs = filtered_tests.iter()
.map(|t| t.desc.clone())
.collect();
try!(callback(TeFiltered(filtered_descs)));
@ -880,8 +882,7 @@ fn get_concurrency() -> uint {
pub fn filter_tests(
opts: &TestOpts,
tests: ~[TestDescAndFn]) -> ~[TestDescAndFn]
{
tests: Vec<TestDescAndFn> ) -> Vec<TestDescAndFn> {
let mut filtered = tests;
// Remove tests that don't match the test filter
@ -929,11 +930,12 @@ pub fn filter_tests(
// Shard the remaining tests, if sharding requested.
match opts.test_shard {
None => filtered,
Some((a,b)) =>
Some((a,b)) => {
filtered.move_iter().enumerate()
.filter(|&(i,_)| i % b == a)
.map(|(_,t)| t)
.to_owned_vec()
.collect()
}
}
}
@ -944,7 +946,7 @@ pub fn run_test(force_ignore: bool,
let TestDescAndFn {desc, testfn} = test;
if force_ignore || desc.ignore {
monitor_ch.send((desc, TrIgnored, ~[]));
monitor_ch.send((desc, TrIgnored, Vec::new()));
return;
}
@ -965,7 +967,7 @@ pub fn run_test(force_ignore: bool,
let result_future = task.future_result();
task.spawn(testfn);
let stdout = reader.read_to_end().unwrap();
let stdout = reader.read_to_end().unwrap().move_iter().collect();
let task_result = result_future.recv();
let test_result = calc_result(&desc, task_result.is_ok());
monitor_ch.send((desc.clone(), test_result, stdout));
@ -975,24 +977,24 @@ pub fn run_test(force_ignore: bool,
match testfn {
DynBenchFn(bencher) => {
let bs = ::bench::benchmark(|harness| bencher.run(harness));
monitor_ch.send((desc, TrBench(bs), ~[]));
monitor_ch.send((desc, TrBench(bs), Vec::new()));
return;
}
StaticBenchFn(benchfn) => {
let bs = ::bench::benchmark(|harness| benchfn(harness));
monitor_ch.send((desc, TrBench(bs), ~[]));
monitor_ch.send((desc, TrBench(bs), Vec::new()));
return;
}
DynMetricFn(f) => {
let mut mm = MetricMap::new();
f(&mut mm);
monitor_ch.send((desc, TrMetrics(mm), ~[]));
monitor_ch.send((desc, TrMetrics(mm), Vec::new()));
return;
}
StaticMetricFn(f) => {
let mut mm = MetricMap::new();
f(&mut mm);
monitor_ch.send((desc, TrMetrics(mm), ~[]));
monitor_ch.send((desc, TrMetrics(mm), Vec::new()));
return;
}
DynTestFn(f) => run_test_inner(desc, monitor_ch, f),
@ -1369,8 +1371,8 @@ mod tests {
#[test]
fn first_free_arg_should_be_a_filter() {
let args = ~[~"progname", ~"filter"];
let opts = match parse_opts(args) {
let args = vec!(~"progname", ~"filter");
let opts = match parse_opts(args.as_slice()) {
Some(Ok(o)) => o,
_ => fail!("Malformed arg in first_free_arg_should_be_a_filter")
};
@ -1379,8 +1381,8 @@ mod tests {
#[test]
fn parse_ignored_flag() {
let args = ~[~"progname", ~"filter", ~"--ignored"];
let opts = match parse_opts(args) {
let args = vec!(~"progname", ~"filter", ~"--ignored");
let opts = match parse_opts(args.as_slice()) {
Some(Ok(o)) => o,
_ => fail!("Malformed arg in parse_ignored_flag")
};
@ -1404,7 +1406,7 @@ mod tests {
test_shard: None
};
let tests = ~[
let tests = vec!(
TestDescAndFn {
desc: TestDesc {
name: StaticTestName("1"),
@ -1420,13 +1422,12 @@ mod tests {
should_fail: false
},
testfn: DynTestFn(proc() {}),
},
];
});
let filtered = filter_tests(&opts, tests);
assert_eq!(filtered.len(), 1);
assert_eq!(filtered[0].desc.name.to_str(), ~"1");
assert!(filtered[0].desc.ignore == false);
assert_eq!(filtered.get(0).desc.name.to_str(), ~"1");
assert!(filtered.get(0).desc.ignore == false);
}
#[test]
@ -1444,16 +1445,16 @@ mod tests {
};
let names =
~[~"sha1::test", ~"int::test_to_str", ~"int::test_pow",
vec!(~"sha1::test", ~"int::test_to_str", ~"int::test_pow",
~"test::do_not_run_ignored_tests",
~"test::ignored_tests_result_in_ignored",
~"test::first_free_arg_should_be_a_filter",
~"test::parse_ignored_flag", ~"test::filter_for_ignored_option",
~"test::sort_tests"];
~"test::sort_tests");
let tests =
{
fn testfn() { }
let mut tests = ~[];
let mut tests = Vec::new();
for name in names.iter() {
let test = TestDescAndFn {
desc: TestDesc {
@ -1470,13 +1471,13 @@ mod tests {
let filtered = filter_tests(&opts, tests);
let expected =
~[~"int::test_pow", ~"int::test_to_str", ~"sha1::test",
vec!(~"int::test_pow", ~"int::test_to_str", ~"sha1::test",
~"test::do_not_run_ignored_tests",
~"test::filter_for_ignored_option",
~"test::first_free_arg_should_be_a_filter",
~"test::ignored_tests_result_in_ignored",
~"test::parse_ignored_flag",
~"test::sort_tests"];
~"test::sort_tests");
for (a, b) in expected.iter().zip(filtered.iter()) {
assert!(*a == b.desc.name.to_str());

4
src/libtime/lib.rs
View File

@ -1044,7 +1044,7 @@ pub fn strftime(format: &str, tm: &Tm) -> ~str {
}
}
let mut buf = ~[];
let mut buf = Vec::new();
let mut rdr = BufReader::new(format.as_bytes());
loop {
@ -1063,7 +1063,7 @@ pub fn strftime(format: &str, tm: &Tm) -> ~str {
}
}
str::from_utf8_owned(buf).unwrap()
str::from_utf8(buf.as_slice()).unwrap().to_str()
}
#[cfg(test)]

32
src/libuuid/lib.rs
View File

@ -327,13 +327,13 @@ impl Uuid {
///
/// Example: `936DA01F9ABD4d9d80C702AF85C822A8`
pub fn to_simple_str(&self) -> ~str {
let mut s: ~[u8] = slice::from_elem(32, 0u8);
let mut s: Vec<u8> = Vec::from_elem(32, 0u8);
for i in range(0u, 16u) {
let digit = format!("{:02x}", self.bytes[i] as uint);
s[i*2+0] = digit[0];
s[i*2+1] = digit[1];
*s.get_mut(i*2+0) = digit[0];
*s.get_mut(i*2+1) = digit[1];
}
str::from_utf8_owned(s).unwrap()
str::from_utf8(s.as_slice()).unwrap().to_str()
}
/// Returns a string of hexadecimal digits, separated into groups with a hyphen.
@ -397,17 +397,17 @@ impl Uuid {
}
// Split string up by hyphens into groups
let hex_groups: ~[&str] = us.split_str("-").collect();
let hex_groups: Vec<&str> = us.split_str("-").collect();
// Get the length of each group
let group_lens: ~[uint] = hex_groups.iter().map(|&v| v.len()).collect();
let group_lens: Vec<uint> = hex_groups.iter().map(|&v| v.len()).collect();
// Ensure the group lengths are valid
match group_lens.len() {
// Single group, no hyphens
1 => {
if group_lens[0] != 32 {
return Err(ErrorInvalidLength(group_lens[0]));
if *group_lens.get(0) != 32 {
return Err(ErrorInvalidLength(*group_lens.get(0)));
}
},
// Five groups, hyphens in between each
@ -538,6 +538,7 @@ mod test {
Version5Sha1};
use std::str;
use std::io::MemWriter;
use std::vec_ng::Vec;
#[test]
fn test_nil() {
@ -697,7 +698,10 @@ mod test {
let hs = uuid1.to_hyphenated_str();
let ss = uuid1.to_str();
let hsn = str::from_chars(hs.chars().filter(|&c| c != '-').collect::<~[char]>());
let hsn = str::from_chars(hs.chars()
.filter(|&c| c != '-')
.collect::<Vec<char>>()
.as_slice());
assert!(hsn == ss);
}
@ -731,9 +735,9 @@ mod test {
let d1: u32 = 0xa1a2a3a4;
let d2: u16 = 0xb1b2;
let d3: u16 = 0xc1c2;
let d4: ~[u8] = ~[0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8];
let d4: Vec<u8> = vec!(0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8);
let u = Uuid::from_fields(d1, d2, d3, d4);
let u = Uuid::from_fields(d1, d2, d3, d4.as_slice());
let expected = ~"a1a2a3a4b1b2c1c2d1d2d3d4d5d6d7d8";
let result = u.to_simple_str();
@ -742,10 +746,10 @@ mod test {
#[test]
fn test_from_bytes() {
let b = ~[ 0xa1, 0xa2, 0xa3, 0xa4, 0xb1, 0xb2, 0xc1, 0xc2,
0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8 ];
let b = vec!( 0xa1, 0xa2, 0xa3, 0xa4, 0xb1, 0xb2, 0xc1, 0xc2,
0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8 );
let u = Uuid::from_bytes(b).unwrap();
let u = Uuid::from_bytes(b.as_slice()).unwrap();
let expected = ~"a1a2a3a4b1b2c1c2d1d2d3d4d5d6d7d8";
assert!(u.to_simple_str() == expected);

2
src/test/auxiliary/cci_class_6.rs
View File

@ -9,6 +9,8 @@
// except according to those terms.
pub mod kitties {
use std::vec_ng::Vec;
pub struct cat<U> {
priv info : Vec<U> ,
priv meows : uint,

1
src/test/auxiliary/cci_nested_lib.rs
View File

@ -11,6 +11,7 @@
#[feature(managed_boxes)];
use std::cell::RefCell;
use std::vec_ng::Vec;
pub struct Entry<A,B> {
key: A,

4
src/test/auxiliary/cci_no_inline_lib.rs
View File

@ -10,12 +10,14 @@
#[crate_id="cci_no_inline_lib"];
use std::vec_ng::Vec;
// same as cci_iter_lib, more-or-less, but not marked inline
pub fn iter(v: Vec<uint> , f: |uint|) {
let mut i = 0u;
let n = v.len();
while i < n {
f(v[i]);
f(*v.get(i));
i += 1u;
}
}

5
src/test/auxiliary/issue-2631-a.rs
View File

@ -15,11 +15,12 @@
extern crate collections;
use std::cell::RefCell;
use std::vec_ng::Vec;
use collections::HashMap;
pub type header_map = HashMap<~str, @RefCell<vec!(@~str)>>;
pub type header_map = HashMap<~str, @RefCell<Vec<@~str>>>;
// the unused ty param is necessary so this gets monomorphized
pub fn request<T>(req: &header_map) {
let _x = (*((**req.get(&~"METHOD")).clone()).get()[0u]).clone();
let _x = (**((**req.get(&~"METHOD")).clone()).get().get(0)).clone();
}

2
src/test/auxiliary/issue_2723_a.rs
View File

@ -8,6 +8,8 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use std::vec_ng::Vec;
pub unsafe fn f(xs: Vec<int> ) {
xs.map(|_x| { unsafe fn q() { fail!(); } });
}

21
src/test/bench/core-std.rs
View File

@ -20,7 +20,6 @@ use rand::Rng;
use std::mem::swap;
use std::os;
use std::str;
use std::slice;
use std::vec;
use std::io::File;
@ -89,11 +88,11 @@ fn vec_plus() {
let mut v = Vec::new();
let mut i = 0;
while i < 1500 {
let rv = slice::from_elem(r.gen_range(0u, i + 1), i);
let rv = Vec::from_elem(r.gen_range(0u, i + 1), i);
if r.gen() {
v.push_all_move(rv);
} else {
v = rv + v;
v = vec::append(rv.clone(), v.as_slice());
}
i += 1;
}
@ -105,12 +104,12 @@ fn vec_append() {
let mut v = Vec::new();
let mut i = 0;
while i < 1500 {
let rv = slice::from_elem(r.gen_range(0u, i + 1), i);
let rv = Vec::from_elem(r.gen_range(0u, i + 1), i);
if r.gen() {
v = vec::append(v, rv);
v = vec::append(v.clone(), rv.as_slice());
}
else {
v = vec::append(rv, v);
v = vec::append(rv.clone(), v.as_slice());
}
i += 1;
}
@ -121,13 +120,13 @@ fn vec_push_all() {
let mut v = Vec::new();
for i in range(0u, 1500) {
let mut rv = slice::from_elem(r.gen_range(0u, i + 1), i);
let mut rv = Vec::from_elem(r.gen_range(0u, i + 1), i);
if r.gen() {
v.push_all(rv);
v.push_all(rv.as_slice());
}
else {
swap(&mut v, &mut rv);
v.push_all(rv);
v.push_all(rv.as_slice());
}
}
}
@ -136,7 +135,7 @@ fn is_utf8_ascii() {
let mut v : Vec<u8> = Vec::new();
for _ in range(0u, 20000) {
v.push('b' as u8);
if !str::is_utf8(v) {
if !str::is_utf8(v.as_slice()) {
fail!("is_utf8 failed");
}
}
@ -147,7 +146,7 @@ fn is_utf8_multibyte() {
let mut v : Vec<u8> = Vec::new();
for _ in range(0u, 5000) {
v.push_all(s.as_bytes());
if !str::is_utf8(v) {
if !str::is_utf8(v.as_slice()) {
fail!("is_utf8 failed");
}
}

5
src/test/bench/core-uint-to-str.rs
View File

@ -10,6 +10,7 @@
use std::os;
use std::uint;
use std::vec_ng::Vec;
fn main() {
let args = os::args();
@ -18,10 +19,10 @@ fn main() {
} else if args.len() <= 1u {
vec!(~"", ~"100000")
} else {
args
args.move_iter().collect()
};
let n = from_str::<uint>(args[1]).unwrap();
let n = from_str::<uint>(*args.get(1)).unwrap();
for i in range(0u, n) {
let x = i.to_str();

5
src/test/bench/msgsend-pipes-shared.rs
View File

@ -24,6 +24,7 @@ use std::comm;
use std::os;
use std::task;
use std::uint;
use std::vec_ng::Vec;
fn move_out<T>(_x: T) {}
@ -100,9 +101,9 @@ fn main() {
} else if args.len() <= 1u {
vec!(~"", ~"10000", ~"4")
} else {
args.clone()
args.clone().move_iter().collect()
};
println!("{:?}", args);
run(args);
run(args.as_slice());
}

5
src/test/bench/msgsend-pipes.rs
View File

@ -19,6 +19,7 @@ extern crate time;
use std::os;
use std::task;
use std::uint;
use std::vec_ng::Vec;
fn move_out<T>(_x: T) {}
@ -110,9 +111,9 @@ fn main() {
} else if args.len() <= 1u {
vec!(~"", ~"10000", ~"4")
} else {
args.clone()
args.clone().move_iter().collect()
};
println!("{:?}", args);
run(args);
run(args.as_slice());
}

7
src/test/bench/msgsend-ring-mutex-arcs.rs
View File

@ -23,6 +23,7 @@ use sync::MutexArc;
use sync::Future;
use std::os;
use std::uint;
use std::vec_ng::Vec;
// A poor man's pipe.
type pipe = MutexArc<Vec<uint> >;
@ -75,11 +76,11 @@ fn main() {
} else if args.len() <= 1u {
vec!(~"", ~"10", ~"100")
} else {
args.clone()
args.clone().move_iter().collect()
};
let num_tasks = from_str::<uint>(args[1]).unwrap();
let msg_per_task = from_str::<uint>(args[2]).unwrap();
let num_tasks = from_str::<uint>(*args.get(1)).unwrap();
let msg_per_task = from_str::<uint>(*args.get(2)).unwrap();
let (mut num_chan, num_port) = init();

7
src/test/bench/msgsend-ring-rw-arcs.rs
View File

@ -22,6 +22,7 @@ use sync::RWArc;
use sync::Future;
use std::os;
use std::uint;
use std::vec_ng::Vec;
// A poor man's pipe.
type pipe = RWArc<Vec<uint> >;
@ -70,11 +71,11 @@ fn main() {
} else if args.len() <= 1u {
vec!(~"", ~"10", ~"100")
} else {
args.clone()
args.clone().move_iter().collect()
};
let num_tasks = from_str::<uint>(args[1]).unwrap();
let msg_per_task = from_str::<uint>(args[2]).unwrap();
let num_tasks = from_str::<uint>(*args.get(1)).unwrap();
let msg_per_task = from_str::<uint>(*args.get(2)).unwrap();
let (mut num_chan, num_port) = init();

5
src/test/bench/shootout-ackermann.rs
View File

@ -9,6 +9,7 @@
// except according to those terms.
use std::os;
use std::vec_ng::Vec;
fn ack(m: int, n: int) -> int {
if m == 0 {
@ -29,8 +30,8 @@ fn main() {
} else if args.len() <= 1u {
vec!(~"", ~"8")
} else {
args
args.move_iter().collect()
};
let n = from_str::<int>(args[1]).unwrap();
let n = from_str::<int>(*args.get(1)).unwrap();
println!("Ack(3,{}): {}\n", n, ack(3, n));
}

19
src/test/bench/shootout-chameneos-redux.rs
View File

@ -13,6 +13,7 @@
use std::option;
use std::os;
use std::task;
use std::vec_ng::Vec;
fn print_complements() {
let all = [Blue, Red, Yellow];
@ -39,7 +40,7 @@ fn show_color(cc: color) -> ~str {
}
}
fn show_color_list(set: vec!(color)) -> ~str {
fn show_color_list(set: Vec<color>) -> ~str {
let mut out = ~"";
for col in set.iter() {
out.push_char(' ');
@ -132,7 +133,7 @@ fn creature(
}
}
fn rendezvous(nn: uint, set: vec!(color)) {
fn rendezvous(nn: uint, set: Vec<color>) {
// these ports will allow us to hear from the creatures
let (to_rendezvous, from_creatures) = channel::<CreatureInfo>();
@ -141,7 +142,7 @@ fn rendezvous(nn: uint, set: vec!(color)) {
// these channels will be passed to the creatures so they can talk to us
// these channels will allow us to talk to each creature by 'name'/index
let to_creature: Vec<Sender<Option<CreatureInfo>>> =
let mut to_creature: Vec<Sender<Option<CreatureInfo>>> =
set.iter().enumerate().map(|(ii, col)| {
// create each creature as a listener with a port, and
// give us a channel to talk to each
@ -164,13 +165,13 @@ fn rendezvous(nn: uint, set: vec!(color)) {
// set up meetings...
for _ in range(0, nn) {
let fst_creature: CreatureInfo = from_creatures.recv();
let snd_creature: CreatureInfo = from_creatures.recv();
let mut fst_creature: CreatureInfo = from_creatures.recv();
let mut snd_creature: CreatureInfo = from_creatures.recv();
creatures_met += 2;
to_creature[fst_creature.name].send(Some(snd_creature));
to_creature[snd_creature.name].send(Some(fst_creature));
to_creature.get_mut(fst_creature.name).send(Some(snd_creature));
to_creature.get_mut(snd_creature.name).send(Some(fst_creature));
}
// tell each creature to stop
@ -203,10 +204,10 @@ fn main() {
} else if args.len() <= 1u {
vec!(~"", ~"600")
} else {
args
args.move_iter().collect()
};
let nn = from_str::<uint>(args[1]).unwrap();
let nn = from_str::<uint>(*args.get(1)).unwrap();
print_complements();
println!("");

7
src/test/bench/shootout-fasta-redux.rs
View File

@ -68,7 +68,8 @@ fn sum_and_scale(a: &'static [AminoAcid]) -> Vec<AminoAcid> {
a_i.p = p * LOOKUP_SCALE;
result.push(a_i);
}
result[result.len() - 1].p = LOOKUP_SCALE;
let result_len = result.len();
result.get_mut(result_len - 1).p = LOOKUP_SCALE;
result
}
@ -193,12 +194,12 @@ fn main() {
out.write_line(">TWO IUB ambiguity codes").unwrap();
let iub = sum_and_scale(IUB);
let mut random = RandomFasta::new(&mut out, iub);
let mut random = RandomFasta::new(&mut out, iub.as_slice());
random.make(n * 3).unwrap();
random.out.write_line(">THREE Homo sapiens frequency").unwrap();
let homo_sapiens = sum_and_scale(HOMO_SAPIENS);
random.lookup = make_lookup(homo_sapiens);
random.lookup = make_lookup(homo_sapiens.as_slice());
random.make(n * 5).unwrap();
random.out.write_str("\n").unwrap();

1
src/test/bench/shootout-fasta.rs
View File

@ -18,6 +18,7 @@ use std::io;
use std::io::{BufferedWriter, File};
use std::cmp::min;
use std::os;
use std::vec_ng::Vec;
static LINE_LENGTH: uint = 60;
static IM: u32 = 139968;

5
src/test/bench/shootout-fibo.rs
View File

@ -9,6 +9,7 @@
// except according to those terms.
use std::os;
use std::vec_ng::Vec;
fn fib(n: int) -> int {
if n < 2 {
@ -25,8 +26,8 @@ fn main() {
} else if args.len() <= 1u {
vec!(~"", ~"30")
} else {
args
args.move_iter().collect()
};
let n = from_str::<int>(args[1]).unwrap();
let n = from_str::<int>(*args.get(1)).unwrap();
println!("{}\n", fib(n));
}

26
src/test/bench/shootout-k-nucleotide-pipes.rs
View File

@ -68,7 +68,10 @@ fn sort_and_fmt(mm: &HashMap<Vec<u8> , uint>, total: uint) -> ~str {
for &(ref k, v) in pairs_sorted.iter() {
unsafe {
buffer.push_str(format!("{} {:0.3f}\n",
k.to_ascii().to_upper().into_str(), v));
k.as_slice()
.to_ascii()
.to_upper()
.into_str(), v));
}
}
@ -86,7 +89,7 @@ fn find(mm: &HashMap<Vec<u8> , uint>, key: ~str) -> uint {
// given a map, increment the counter for a key
fn update_freq(mm: &mut HashMap<Vec<u8> , uint>, key: &[u8]) {
let key = key.to_owned();
let key = Vec::from_slice(key);
let newval = match mm.pop(&key) {
Some(v) => v + 1,
None => 1
@ -94,7 +97,7 @@ fn update_freq(mm: &mut HashMap<Vec<u8> , uint>, key: &[u8]) {
mm.insert(key, newval);
}
// given a ~[u8], for each window call a function
// given a Vec<u8>, for each window call a function
// i.e., for "hello" and windows of size four,
// run it("hell") and it("ello"), then return "llo"
fn windows_with_carry(bb: &[u8], nn: uint, it: |window: &[u8]|) -> Vec<u8> {
@ -106,7 +109,7 @@ fn windows_with_carry(bb: &[u8], nn: uint, it: |window: &[u8]|) -> Vec<u8> {
ii += 1u;
}
return bb.slice(len - (nn - 1u), len).to_owned();
return Vec::from_slice(bb.slice(len - (nn - 1u), len));
}
fn make_sequence_processor(sz: uint,
@ -116,14 +119,17 @@ fn make_sequence_processor(sz: uint,
let mut carry = Vec::new();
let mut total: uint = 0u;
let mut line: Vec<u8> ;
let mut line: Vec<u8>;
loop {
line = from_parent.recv();
if line == Vec::new() { break; }
carry = windows_with_carry(carry + line, sz, |window| {
carry = windows_with_carry(vec::append(carry,
line.as_slice()).as_slice(),
sz,
|window| {
update_freq(&mut freqs, window);
total += 1u;
});
@ -203,8 +209,8 @@ fn main() {
let line_bytes = line.as_bytes();
for (ii, _sz) in sizes.iter().enumerate() {
let lb = line_bytes.to_owned();
to_child[ii].send(lb);
let lb = Vec::from_slice(line_bytes);
to_child.get(ii).send(lb);
}
}
@ -215,11 +221,11 @@ fn main() {
// finish...
for (ii, _sz) in sizes.iter().enumerate() {
to_child[ii].send(Vec::new());
to_child.get(ii).send(Vec::new());
}
// now fetch and print result messages
for (ii, _sz) in sizes.iter().enumerate() {
println!("{}", from_child[ii].recv());
println!("{}", from_child.get(ii).recv());
}
}

12
src/test/bench/shootout-k-nucleotide.rs
View File

@ -57,7 +57,7 @@ impl Code {
}
result.reverse();
str::from_utf8_owned(result).unwrap()
str::from_utf8_owned(result.move_iter().collect()).unwrap()
}
}
@ -103,7 +103,7 @@ impl Table {
fn new() -> Table {
Table {
count: 0,
items: slice::from_fn(TABLE_SIZE, |_| None),
items: Vec::from_fn(TABLE_SIZE, |_| None),
}
}
@ -133,20 +133,20 @@ impl Table {
let index = key.hash() % (TABLE_SIZE as u64);
{
if self.items[index].is_none() {
if self.items.get(index as uint).is_none() {
let mut entry = ~Entry {
code: key,
count: 0,
next: None,
};
c.f(entry);
self.items[index] = Some(entry);
*self.items.get_mut(index as uint) = Some(entry);
return;
}
}
{
let entry = &mut *self.items[index].get_mut_ref();
let entry = &mut *self.items.get_mut(index as uint).get_mut_ref();
if entry.code == key {
c.f(*entry);
return;
@ -240,7 +240,7 @@ fn print_frequencies(frequencies: &Table, frame: i32) {
for entry in frequencies.iter() {
vector.push((entry.code, entry.count));
}
vector.sort();
vector.as_mut_slice().sort();
let mut total_count = 0;
for &(_, count) in vector.iter() {

26
src/test/bench/shootout-meteor.rs
View File

@ -12,6 +12,8 @@
// Utilities.
//
use std::vec_ng::Vec;
// returns an infinite iterator of repeated applications of f to x,
// i.e. [x, f(x), f(f(x)), ...], as haskell iterate function.
fn iterate<'a, T>(x: T, f: 'a |&T| -> T) -> Iterate<'a, T> {
@ -63,8 +65,8 @@ impl<'a, T> Iterator<&'a T> for ListIterator<'a, T> {
// corresponding mirrored piece), with, as minimum coordinates, (0,
// 0). If all is false, only generate half of the possibilities (used
// to break the symetry of the board).
fn transform(piece: Vec<(int, int)> , all: bool) -> vec!(Vec<(int, int)> ) {
let mut res =
fn transform(piece: Vec<(int, int)> , all: bool) -> Vec<Vec<(int, int)>> {
let mut res: Vec<Vec<(int, int)>> =
// rotations
iterate(piece, |rot| rot.iter().map(|&(y, x)| (x + y, -y)).collect())
.take(if all {6} else {3})
@ -72,7 +74,7 @@ fn transform(piece: Vec<(int, int)> , all: bool) -> vec!(Vec<(int, int)> ) {
.flat_map(|cur_piece| {
iterate(cur_piece, |mir| mir.iter().map(|&(y, x)| (x, y)).collect())
.take(2)
}).to_owned_vec();
}).collect();
// translating to (0, 0) as minimum coordinates.
for cur_piece in res.mut_iter() {
@ -130,7 +132,7 @@ fn make_masks() -> Vec<Vec<Vec<u64> > > {
for dx in range(0, 5) {
let masks =
trans.iter()
.filter_map(|t| mask(dy, dx, id, *t))
.filter_map(|t| mask(dy, dx, id, t.as_slice()))
.collect();
cur_piece.push(masks);
}
@ -147,7 +149,7 @@ fn is_board_unfeasible(board: u64, masks: &[Vec<Vec<u64> > ]) -> bool {
for i in range(0, 50).filter(|&i| board & 1 << i == 0) {
for (cur_id, pos_masks) in masks.iter().enumerate() {
if board & 1 << (50 + cur_id) != 0 {continue;}
for &cur_m in pos_masks[i].iter() {
for &cur_m in pos_masks.get(i as uint).iter() {
if cur_m & board == 0 {coverable |= cur_m;}
}
}
@ -184,10 +186,12 @@ fn to_utf8(raw_sol: &List<u64>) -> ~str {
for &m in raw_sol.iter() {
let id = get_id(m);
for i in range(0, 50) {
if m & 1 << i != 0 {sol[i] = '0' as u8 + id;}
if m & 1 << i != 0 {
*sol.get_mut(i as uint) = '0' as u8 + id;
}
}
}
std::str::from_utf8_owned(sol).unwrap()
std::str::from_utf8_owned(sol.move_iter().collect()).unwrap()
}
// Prints a solution in ~str form.
@ -252,7 +256,9 @@ fn search(
// for every unused piece
for id in range(0, 10).filter(|id| board & (1 << (id + 50)) == 0) {
// for each mask that fits on the board
for &m in masks[id][i].iter().filter(|&m| board & *m == 0) {
for &m in masks[id].get(i as uint)
.iter()
.filter(|&m| board & *m == 0) {
// This check is too costy.
//if is_board_unfeasible(board | m, masks) {continue;}
if !search(masks, board | m, i + 1, Cons(m, &cur), data) {
@ -271,9 +277,9 @@ fn main () {
from_str(args[1]).unwrap()
};
let masks = make_masks();
let masks = filter_masks(masks);
let masks = filter_masks(masks.as_slice());
let mut data = Data {stop_after: stop_after, nb: 0, min: ~"", max: ~""};
search(masks, 0, 0, Nil, &mut data);
search(masks.as_slice(), 0, 0, Nil, &mut data);
println!("{} solutions found", data.nb);
print_sol(data.min);
print_sol(data.max);

5
src/test/bench/shootout-nbody.rs
View File

@ -9,6 +9,7 @@
// except according to those terms.
use std::os;
use std::vec_ng::Vec;
static PI: f64 = 3.141592653589793;
static SOLAR_MASS: f64 = 4.0 * PI * PI;
@ -152,10 +153,10 @@ fn main() {
} else if args.len() <= 1u {
vec!(~"", ~"1000")
} else {
args
args.move_iter().collect()
};
let n: i32 = from_str::<i32>(args[1]).unwrap();
let n: i32 = from_str::<i32>(*args.get(1)).unwrap();
let mut bodies = BODIES;
offset_momentum(&mut bodies);

8
src/test/bench/shootout-pfib.rs
View File

@ -25,6 +25,7 @@ use std::os;
use std::result::{Ok, Err};
use std::task;
use std::uint;
use std::vec_ng::Vec;
fn fib(n: int) -> int {
fn pfib(tx: &Sender<int>, n: int) {
@ -56,7 +57,7 @@ fn parse_opts(argv: Vec<~str> ) -> Config {
let opt_args = argv.slice(1, argv.len());
match getopts::getopts(opt_args, opts) {
match getopts::getopts(opt_args, opts.as_slice()) {
Ok(ref m) => {
return Config {stress: m.opt_present("stress")}
}
@ -95,7 +96,7 @@ fn main() {
} else if args.len() <= 1u {
vec!(~"", ~"8")
} else {
args
args.move_iter().collect()
};
let opts = parse_opts(args.clone());
@ -103,7 +104,8 @@ fn main() {
if opts.stress {
stress(2);
} else {
let max = uint::parse_bytes(args[1].as_bytes(), 10u).unwrap() as int;
let max = uint::parse_bytes(args.get(1).as_bytes(), 10u).unwrap() as
int;
let num_trials = 10;

9
src/test/bench/shootout-threadring.rs
View File

@ -56,18 +56,17 @@ fn main() {
let args = if os::getenv("RUST_BENCH").is_some() {
vec!(~"", ~"2000000", ~"503")
}
else {
os::args()
} else {
os::args().move_iter().collect()
};
let token = if args.len() > 1u {
FromStr::from_str(args[1]).unwrap()
FromStr::from_str(*args.get(1)).unwrap()
}
else {
1000
};
let n_tasks = if args.len() > 2u {
FromStr::from_str(args[2]).unwrap()
FromStr::from_str(*args.get(2)).unwrap()
}
else {
503

7
src/test/bench/std-smallintmap.rs
View File

@ -16,6 +16,7 @@ extern crate time;
use collections::SmallIntMap;
use std::os;
use std::uint;
use std::vec_ng::Vec;
fn append_sequential(min: uint, max: uint, map: &mut SmallIntMap<uint>) {
for i in range(min, max) {
@ -36,10 +37,10 @@ fn main() {
} else if args.len() <= 1u {
vec!(~"", ~"10000", ~"50")
} else {
args
args.move_iter().collect()
};
let max = from_str::<uint>(args[1]).unwrap();
let rep = from_str::<uint>(args[2]).unwrap();
let max = from_str::<uint>(*args.get(1)).unwrap();
let rep = from_str::<uint>(*args.get(2)).unwrap();
let mut checkf = 0.0;
let mut appendf = 0.0;

47
src/test/bench/sudoku.rs
View File

@ -17,7 +17,6 @@ use std::io::stdio::StdReader;
use std::io::BufferedReader;
use std::os;
use std::intrinsics::cttz16;
use std::slice;
// Computes a single solution to a given 9x9 sudoku
//
@ -48,8 +47,8 @@ impl Sudoku {
}
pub fn from_vec(vec: &[[u8, ..9], ..9]) -> Sudoku {
let g = slice::from_fn(9u, |i| {
slice::from_fn(9u, |j| { vec[i][j] })
let g = Vec::from_fn(9u, |i| {
Vec::from_fn(9u, |j| { vec[i][j] })
});
return Sudoku::new(g)
}
@ -57,7 +56,8 @@ impl Sudoku {
pub fn equal(&self, other: &Sudoku) -> bool {
for row in range(0u8, 9u8) {
for col in range(0u8, 9u8) {
if self.grid[row][col] != other.grid[row][col] {
if *self.grid.get(row as uint).get(col as uint) !=
*other.grid.get(row as uint).get(col as uint) {
return false;
}
}
@ -68,14 +68,15 @@ impl Sudoku {
pub fn read(mut reader: BufferedReader<StdReader>) -> Sudoku {
assert!(reader.read_line().unwrap() == ~"9,9"); /* assert first line is exactly "9,9" */
let mut g = slice::from_fn(10u, { |_i| vec!(0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8) });
let mut g = Vec::from_fn(10u, { |_i| vec!(0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8) });
for line in reader.lines() {
let comps: Vec<&str> = line.trim().split(',').collect();
if comps.len() == 3u {
let row = from_str::<uint>(comps[0]).unwrap() as u8;
let col = from_str::<uint>(comps[1]).unwrap() as u8;
g[row][col] = from_str::<uint>(comps[2]).unwrap() as u8;
let row = from_str::<uint>(*comps.get(0)).unwrap() as u8;
let col = from_str::<uint>(*comps.get(1)).unwrap() as u8;
*g.get_mut(row as uint).get_mut(col as uint) =
from_str::<uint>(*comps.get(2)).unwrap() as u8;
}
else {
fail!("Invalid sudoku file");
@ -86,9 +87,11 @@ impl Sudoku {
pub fn write(&self, writer: &mut io::Writer) {
for row in range(0u8, 9u8) {
write!(writer, "{}", self.grid[row][0]);
write!(writer, "{}", *self.grid.get(row as uint).get(0));
for col in range(1u8, 9u8) {
write!(writer, " {}", self.grid[row][col]);
write!(writer, " {}", *self.grid
.get(row as uint)
.get(col as uint));
}
write!(writer, "\n");
}
@ -99,7 +102,7 @@ impl Sudoku {
let mut work: Vec<(u8, u8)> = Vec::new(); /* queue of uncolored fields */
for row in range(0u8, 9u8) {
for col in range(0u8, 9u8) {
let color = self.grid[row][col];
let color = *self.grid.get(row as uint).get(col as uint);
if color == 0u8 {
work.push((row, col));
}
@ -109,9 +112,11 @@ impl Sudoku {
let mut ptr = 0u;
let end = work.len();
while ptr < end {
let (row, col) = work[ptr];
let (row, col) = *work.get(ptr);
// is there another color to try?
if self.next_color(row, col, self.grid[row][col] + (1 as u8)) {
let the_color = *self.grid.get(row as uint).get(col as uint) +
(1 as u8);
if self.next_color(row, col, the_color) {
// yes: advance work list
ptr = ptr + 1u;
} else {
@ -132,18 +137,22 @@ impl Sudoku {
// find first remaining color that is available
let next = avail.next();
self.grid[row][col] = next;
*self.grid.get_mut(row as uint).get_mut(col as uint) = next;
return 0u8 != next;
}
self.grid[row][col] = 0u8;
*self.grid.get_mut(row as uint).get_mut(col as uint) = 0u8;
return false;
}
// find colors available in neighbourhood of (row, col)
fn drop_colors(&mut self, avail: &mut Colors, row: u8, col: u8) {
for idx in range(0u8, 9u8) {
avail.remove(self.grid[idx][col]); /* check same column fields */
avail.remove(self.grid[row][idx]); /* check same row fields */
avail.remove(*self.grid
.get(idx as uint)
.get(col as uint)); /* check same column fields */
avail.remove(*self.grid
.get(row as uint)
.get(idx as uint)); /* check same row fields */
}
// check same block fields
@ -151,7 +160,9 @@ impl Sudoku {
let col0 = (col / 3u8) * 3u8;
for alt_row in range(row0, row0 + 3u8) {
for alt_col in range(col0, col0 + 3u8) {
avail.remove(self.grid[alt_row][alt_col]);
avail.remove(*self.grid
.get(alt_row as uint)
.get(alt_col as uint));
}
}
}

7
src/test/bench/task-perf-alloc-unwind.rs
View File

@ -17,6 +17,8 @@ use collections::list::{List, Cons, Nil};
use time::precise_time_s;
use std::os;
use std::task;
use std::vec_ng::Vec;
use std::vec_ng;
enum UniqueList {
ULNil, ULCons(~UniqueList)
@ -50,7 +52,7 @@ struct State {
managed: @nillist,
unique: ~nillist,
tuple: (@nillist, ~nillist),
vec: vec!(@nillist),
vec: Vec<@nillist>,
res: r
}
@ -92,7 +94,8 @@ fn recurse_or_fail(depth: int, st: Option<State>) {
unique: ~Cons((), @*st.unique),
tuple: (@Cons((), st.tuple.ref0().clone()),
~Cons((), @*st.tuple.ref1().clone())),
vec: st.vec + &[@Cons((), *st.vec.last().unwrap())],
vec: vec::append(st.vec.clone(),
&[@Cons((), *st.vec.last().unwrap())]),
res: r(@Cons((), st.res._l))
}
}

5
src/test/bench/task-perf-jargon-metal-smoke.rs
View File

@ -21,6 +21,7 @@ use std::comm;
use std::os;
use std::task;
use std::uint;
use std::vec_ng::Vec;
fn child_generation(gens_left: uint, tx: comm::Sender<()>) {
// This used to be O(n^2) in the number of generations that ever existed.
@ -45,11 +46,11 @@ fn main() {
} else if args.len() <= 1 {
vec!(~"", ~"100")
} else {
args.clone()
args.clone().move_iter().collect()
};
let (tx, rx) = channel();
child_generation(from_str::<uint>(args[1]).unwrap(), tx);
child_generation(from_str::<uint>(*args.get(1)).unwrap(), tx);
if rx.recv_opt().is_none() {
fail!("it happened when we slumbered");
}

5
src/test/bench/task-perf-spawnalot.rs
View File

@ -11,6 +11,7 @@
use std::os;
use std::task;
use std::uint;
use std::vec_ng::Vec;
fn f(n: uint) {
let mut i = 0u;
@ -29,9 +30,9 @@ fn main() {
} else if args.len() <= 1u {
vec!(~"", ~"10")
} else {
args
args.move_iter().collect()
};
let n = from_str::<uint>(args[1]).unwrap();
let n = from_str::<uint>(*args.get(1)).unwrap();
let mut i = 0u;
while i < n { task::spawn(proc() f(n) ); i += 1u; }
}

1
src/test/compile-fail/access-mode-in-closures.rs
View File

@ -8,6 +8,7 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use std::vec_ng::Vec;
struct sty(Vec<int> );

6
src/test/compile-fail/ambig_impl_unify.rs
View File

@ -8,16 +8,18 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use std::vec_ng::Vec;
trait foo {
fn foo(&self) -> int;
}
impl foo for Vec<uint> {
fn foo(&self) -> int {1} //~ NOTE candidate #1 is `~[uint].foo::foo`
fn foo(&self) -> int {1} //~ NOTE candidate #1 is `Vec<uint>.foo::foo`
}
impl foo for Vec<int> {
fn foo(&self) -> int {2} //~ NOTE candidate #2 is `~[int].foo::foo`
fn foo(&self) -> int {2} //~ NOTE candidate #2 is `Vec<int>.foo::foo`
}
fn main() {

2
src/test/compile-fail/bad-expr-path.rs
View File

@ -12,4 +12,4 @@
mod m1 {}
fn main(args: vec!(str)) { log(debug, m1::a); }
fn main(args: Vec<~str>) { log(debug, m1::a); }

4
src/test/compile-fail/bad-expr-path2.rs
View File

@ -14,4 +14,6 @@ mod m1 {
pub mod a {}
}
fn main(args: vec!(str)) { log(debug, m1::a); }
fn main(args: Vec<~str>) {
log(debug, m1::a);
}

12
src/test/compile-fail/borrowck-assign-comp-idx.rs
View File

@ -17,9 +17,9 @@ fn a() {
let mut p = vec!(1);
// Create an immutable pointer into p's contents:
let q: &int = &p[0];
let q: &int = p.get(0);
p[0] = 5; //~ ERROR cannot assign
*p.get_mut(0) = 5; //~ ERROR cannot borrow
println!("{}", *q);
}
@ -33,16 +33,16 @@ fn b() {
let mut p = vec!(1);
borrow(
p,
|| p[0] = 5); //~ ERROR cannot borrow `p` as mutable
p.as_slice(),
|| *p.get_mut(0) = 5); //~ ERROR cannot borrow `p` as mutable
}
fn c() {
// Legal because the scope of the borrow does not include the
// modification:
let mut p = vec!(1);
borrow(p, ||{});
p[0] = 5;
borrow(p.as_slice(), ||{});
*p.get_mut(0) = 5;
}
fn main() {

3
src/test/compile-fail/borrowck-borrowed-uniq-rvalue-2.rs
View File

@ -28,6 +28,7 @@ fn defer<'r>(x: &'r [&'r str]) -> defer<'r> {
}
fn main() {
let x = defer(vec!("Goodbye", "world!")); //~ ERROR borrowed value does not live long enough
let x = defer(vec!("Goodbye", "world!").as_slice());
//~^ ERROR borrowed value does not live long enough
x.x[0];
}

2
src/test/compile-fail/borrowck-init-op-equal.rs
View File

@ -8,6 +8,8 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use std::vec_ng::Vec;
fn test() {
let v: int;
v += 1; //~ ERROR use of possibly uninitialized variable: `v`

6
src/test/compile-fail/borrowck-loan-vec-content.rs
View File

@ -18,15 +18,15 @@ fn takes_imm_elt(_v: &int, f: ||) {
fn has_mut_vec_and_does_not_try_to_change_it() {
let mut v = vec!(1, 2, 3);
takes_imm_elt(&v[0], || {})
takes_imm_elt(v.get(0), || {})
}
fn has_mut_vec_but_tries_to_change_it() {
let mut v = vec!(1, 2, 3);
takes_imm_elt(
&v[0],
v.get(0),
|| { //~ ERROR cannot borrow `v` as mutable
v[1] = 4;
*v.get_mut(1) = 4;
})
}

2
src/test/compile-fail/borrowck-move-out-of-vec-tail.rs
View File

@ -21,7 +21,7 @@ pub fn main() {
Foo { string: ~"bar" },
Foo { string: ~"baz" }
);
let x: &[Foo] = x;
let x: &[Foo] = x.as_slice();
match x {
[_, ..tail] => {
match tail {

2
src/test/compile-fail/borrowck-mut-slice-of-imm-vec.rs
View File

@ -14,5 +14,5 @@ fn write(v: &mut [int]) {
fn main() {
let v = vec!(1, 2, 3);
write(v); //~ ERROR cannot borrow
write(v.as_mut_slice()); //~ ERROR cannot borrow
}

6
src/test/compile-fail/borrowck-vec-pattern-element-loan.rs
View File

@ -10,7 +10,7 @@
fn a() -> &[int] {
let vec = vec!(1, 2, 3, 4);
let vec: &[int] = vec; //~ ERROR does not live long enough
let vec: &[int] = vec.as_slice(); //~ ERROR does not live long enough
let tail = match vec {
[_, ..tail] => tail,
_ => fail!("a")
@ -20,7 +20,7 @@ fn a() -> &[int] {
fn b() -> &[int] {
let vec = vec!(1, 2, 3, 4);
let vec: &[int] = vec; //~ ERROR does not live long enough
let vec: &[int] = vec.as_slice(); //~ ERROR does not live long enough
let init = match vec {
[..init, _] => init,
_ => fail!("b")
@ -30,7 +30,7 @@ fn b() -> &[int] {
fn c() -> &[int] {
let vec = vec!(1, 2, 3, 4);
let vec: &[int] = vec; //~ ERROR does not live long enough
let vec: &[int] = vec.as_slice(); //~ ERROR does not live long enough
let slice = match vec {
[_, ..slice, _] => slice,
_ => fail!("c")

2
src/test/compile-fail/borrowck-vec-pattern-loan-from-mut.rs
View File

@ -10,7 +10,7 @@
fn a() {
let mut v = vec!(1, 2, 3);
let vb: &mut [int] = v;
let vb: &mut [int] = v.as_mut_slice();
match vb {
[_a, ..tail] => {
v.push(tail[0] + tail[1]); //~ ERROR cannot borrow

8
src/test/compile-fail/borrowck-vec-pattern-nesting.rs
View File

@ -19,7 +19,7 @@ fn a() {
fn b() {
let mut vec = vec!(~1, ~2, ~3);
let vec: &mut [~int] = vec;
let vec: &mut [~int] = vec.as_mut_slice();
match vec {
[.._b] => {
vec[0] = ~4; //~ ERROR cannot assign
@ -29,7 +29,7 @@ fn b() {
fn c() {
let mut vec = vec!(~1, ~2, ~3);
let vec: &mut [~int] = vec;
let vec: &mut [~int] = vec.as_mut_slice();
match vec {
[_a, .._b] => {
//~^ ERROR cannot move out
@ -47,7 +47,7 @@ fn c() {
fn d() {
let mut vec = vec!(~1, ~2, ~3);
let vec: &mut [~int] = vec;
let vec: &mut [~int] = vec.as_mut_slice();
match vec {
[.._a, _b] => {
//~^ ERROR cannot move out
@ -59,7 +59,7 @@ fn d() {
fn e() {
let mut vec = vec!(~1, ~2, ~3);
let vec: &mut [~int] = vec;
let vec: &mut [~int] = vec.as_mut_slice();
match vec {
[_a, _b, _c] => {} //~ ERROR cannot move out
//~^ ERROR cannot move out

2
src/test/compile-fail/borrowck-vec-pattern-tail-element-loan.rs
View File

@ -10,7 +10,7 @@
fn a() -> &int {
let vec = vec!(1, 2, 3, 4);
let vec: &[int] = vec; //~ ERROR `vec[..]` does not live long enough
let vec: &[int] = vec.as_slice(); //~ ERROR `vec` does not live long enough
let tail = match vec {
[_a, ..tail] => &tail[0],
_ => fail!("foo")

7
src/test/compile-fail/drop-on-non-struct.rs
View File

@ -10,10 +10,13 @@
#[feature(managed_boxes)];
type Foo = Vec<u8> ;
use std::vec_ng::Vec;
impl Drop for Foo { //~ ERROR the Drop trait may only be implemented
type Foo = Vec<u8>;
impl Drop for Foo { //~ ERROR conflicting implementations
//~^ ERROR cannot provide an extension implementation
//~^^ ERROR multiple applicable methods
fn drop(&mut self) {
println!("kaboom");
}

13
src/test/compile-fail/empty-vec-trailing-comma.rs
View File

@ -1,13 +0,0 @@
// 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 v = vec!(); //~ ERROR unexpected token: `,`
}

32
src/test/compile-fail/evec-subtyping.rs
View File

@ -1,32 +0,0 @@
// 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.
#[feature(managed_boxes)];
fn wants_uniq(x: Vec<uint> ) { }
fn wants_three(x: [uint, ..3]) { }
fn has_uniq(x: Vec<uint> ) {
wants_uniq(x);
wants_three(x); //~ ERROR [] storage differs: expected `3` but found `~`
}
fn has_three(x: [uint, ..3]) {
wants_uniq(x); //~ ERROR [] storage differs: expected `~` but found `3`
wants_three(x);
}
fn has_four(x: [uint, ..4]) {
wants_uniq(x); //~ ERROR [] storage differs: expected `~` but found `4`
wants_three(x); //~ ERROR [] storage differs: expected `3` but found `4`
}
fn main() {
}

5
src/test/compile-fail/import.rs
View File

@ -11,7 +11,10 @@
// error-pattern:failed to resolve import
use zed::bar;
use zed::baz;
use std::vec_ng::Vec;
mod zed {
pub fn bar() { println!("bar"); }
}
fn main(args: vec!(str)) { bar(); }
fn main(args: Vec<~str>) { bar(); }

4
src/test/compile-fail/import2.rs
View File

@ -11,8 +11,10 @@
use baz::zed::bar; //~ ERROR unresolved import
//~^ ERROR failed to resolve import
use std::vec_ng::Vec;
mod baz {}
mod zed {
pub fn bar() { println!("bar3"); }
}
fn main(args: vec!(str)) { bar(); }
fn main(args: Vec<~str>) { bar(); }

2
src/test/compile-fail/import4.rs
View File

@ -10,6 +10,8 @@
// error-pattern: import
use std::vec_ng::Vec;
mod a { pub use b::foo; }
mod b { pub use a::foo; }

4
src/test/compile-fail/infinite-vec-type-recursion.rs
View File

@ -10,6 +10,8 @@
// error-pattern: illegal recursive type
type x = vec!(x);
use std::vec_ng::Vec;
type x = Vec<x>;
fn main() { let b: x = Vec::new(); }

15
src/test/compile-fail/issue-10487.rs
View File

@ -1,15 +0,0 @@
// 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.
#[feature(managed_boxes)];
static x: Vec<int> = vec!(123, 456); //~ ERROR: static items are not allowed to have owned pointers
fn main() {}

2
src/test/compile-fail/issue-2149.rs
View File

@ -8,6 +8,8 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use std::vec_ng::Vec;
trait vec_monad<A> {
fn bind<B>(&self, f: |A| -> Vec<B> );
}

2
src/test/compile-fail/issue-2150.rs
View File

@ -13,6 +13,8 @@
#[allow(dead_code)];
#[allow(deprecated_owned_vector)];
use std::vec_ng::Vec;
fn fail_len(v: Vec<int> ) -> uint {
let mut i = 3;
fail!();

47
src/test/compile-fail/issue-2548.rs
View File

@ -1,47 +0,0 @@
// 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.
#[feature(managed_boxes)];
// A test case for #2548.
use std::cell::Cell;
struct foo {
x: @Cell<int>,
}
#[unsafe_destructor]
impl Drop for foo {
fn drop(&mut self) {
unsafe {
println!("Goodbye, World!");
self.x.set(self.x.get() + 1);
}
}
}
fn foo(x: @Cell<int>) -> foo {
foo { x: x }
}
fn main() {
let x = @Cell::new(0);
{
let mut res = foo(x);
let mut v = Vec::new();
v = vec!((res)) + v; //~ failed to find an implementation of trait
assert_eq!(v.len(), 2);
}
assert_eq!(x.get(), 1);
}

2
src/test/compile-fail/issue-2590.rs
View File

@ -8,6 +8,8 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use std::vec_ng::Vec;
struct parser {
tokens: Vec<int> ,
}

2
src/test/compile-fail/issue-3044.rs
View File

@ -8,6 +8,8 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use std::vec_ng::Vec;
fn main() {
let needlesArr: Vec<char> = vec!('a', 'f');
needlesArr.iter().fold(|x, y| {

2
src/test/compile-fail/issue-7573.rs
View File

@ -8,6 +8,8 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use std::vec_ng::Vec;
pub struct CrateId {
local_path: ~str,
junk: ~str

2
src/test/compile-fail/issue-8727.rs
View File

@ -8,8 +8,6 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
#[allow(deprecated_owned_vector)];
// Verify the compiler fails with an error on infinite function
// recursions.

2
src/test/compile-fail/kindck-freeze.rs
View File

@ -10,6 +10,8 @@
// Test which of the builtin types are considered freezeable.
use std::vec_ng::Vec;
fn assert_freeze<T:Freeze>() { }
trait Dummy { }

1
src/test/compile-fail/kindck-pod.rs
View File

@ -13,6 +13,7 @@
#[feature(managed_boxes)];
use std::rc::Rc;
use std::vec_ng::Vec;
fn assert_pod<T:Pod>() { }
trait Dummy { }

2
src/test/compile-fail/kindck-send.rs
View File

@ -10,6 +10,8 @@
// Test which of the builtin types are considered sendable.
use std::vec_ng::Vec;
fn assert_send<T:Send>() { }
trait Dummy { }

2
src/test/compile-fail/lint-heap-memory.rs
View File

@ -25,8 +25,6 @@ fn main() {
@2; //~ ERROR type uses managed
~2; //~ ERROR type uses owned
vec!(1); //~ ERROR type uses owned
//~^ ERROR type uses owned
fn g(_: ~Clone) {} //~ ERROR type uses owned
~""; //~ ERROR type uses owned
//~^ ERROR type uses owned

2
src/test/compile-fail/lint-unused-mut-variables.rs
View File

@ -16,6 +16,8 @@
#[allow(deprecated_owned_vector)];
#[deny(unused_mut)];
use std::vec_ng::Vec;
fn main() {
// negative cases
let mut a = 3; //~ ERROR: variable does not need to be mutable

2
src/test/compile-fail/lint-unused-unsafe.rs
View File

@ -14,6 +14,8 @@
#[deny(unused_unsafe)];
#[allow(deprecated_owned_vector)];
use std::vec_ng::Vec;
mod foo {
extern {
pub fn bar();

2
src/test/compile-fail/liveness-issue-2163.rs
View File

@ -8,7 +8,7 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use std::slice;
use std::vec::Vec;
fn main() {
let a: Vec<int> = Vec::new();

8
src/test/compile-fail/match-vec-unreachable.rs
View File

@ -8,9 +8,11 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use std::vec_ng::Vec;
fn main() {
let x: Vec<(int, int)> = Vec::new();
let x: &[(int, int)] = x;
let x: &[(int, int)] = x.as_slice();
match x {
[a, (2, 3), _] => (),
[(1, 2), (2, 3), b] => (), //~ ERROR unreachable pattern
@ -18,7 +20,7 @@ fn main() {
}
let x: Vec<~str> = vec!(~"foo", ~"bar", ~"baz");
let x: &[~str] = x;
let x: &[~str] = x.as_slice();
match x {
[a, _, _, ..] => { println!("{}", a); }
[_, _, _, _, _] => { } //~ ERROR unreachable pattern
@ -26,7 +28,7 @@ fn main() {
}
let x: Vec<char> = vec!('a', 'b', 'c');
let x: &[char] = x;
let x: &[char] = x.as_slice();
match x {
['a', 'b', 'c', .._tail] => {}
['a', 'b', 'c'] => {} //~ ERROR unreachable pattern

4
src/test/compile-fail/moves-based-on-type-access-to-field.rs
View File

@ -23,8 +23,8 @@ fn f10() {
fn f20() {
let x = vec!(~"hi");
consume(x[0]);
touch(&x[0]); //~ ERROR use of partially moved value: `x`
consume(x.move_iter().next().unwrap());
touch(x.get(0)); //~ ERROR use of moved value: `x`
}
fn main() {}

14
src/test/compile-fail/moves-based-on-type-exprs.rs
View File

@ -31,7 +31,7 @@ fn f20() {
fn f21() {
let x = vec!(1, 2, 3);
let _y = (x[0], 3);
let _y = (*x.get(0), 3);
touch(&x);
}
@ -84,21 +84,21 @@ fn f80() {
fn f100() {
let x = vec!(~"hi");
let _y = x[0];
touch(&x); //~ ERROR use of partially moved value: `x`
let _y = x.move_iter().next().unwrap();
touch(&x); //~ ERROR use of moved value: `x`
}
fn f110() {
let x = vec!(~"hi");
let _y = [x[0], ..1];
touch(&x); //~ ERROR use of partially moved value: `x`
let _y = [x.move_iter().next().unwrap(), ..1];
touch(&x); //~ ERROR use of moved value: `x`
}
fn f120() {
let mut x = vec!(~"hi", ~"ho");
x.swap(0, 1);
touch(&x[0]);
touch(&x[1]);
touch(x.get(0));
touch(x.get(1));
}
fn main() {}

Some files were not shown because too many files have changed in this diff Show More