`~[T]` in test, libgetopts, compiletest, librustdoc, and libnum.
extern crate log;
use std::os;
+use std::vec_ng::Vec;
use std::io;
use std::io::fs;
use getopts::{optopt, optflag, reqopt};
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"),
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!()
}
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
},
// 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"),
}
}
-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();
// 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;
// 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() {
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(); }
}
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});
}
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
// 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;
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(), ~""),
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();
#[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 {
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,
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,
use std::str;
use std::task;
use std::slice;
+use std::vec_ng;
use test::MetricMap;
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),
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
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};
}
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
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 {}/{}",
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
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
};
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);
}
}
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;
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 => {
}
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);
}
}
}
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
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; }
}
}
-fn check_expected_errors(expected_errors: ~[errors::ExpectedError],
+fn check_expected_errors(expected_errors: Vec<errors::ExpectedError> ,
testfile: &Path,
proc_res: &ProcRes) {
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 {
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;
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);
}
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}
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)
}
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(
}
}
- compose_and_run(config, testfile, args, ~[],
+ compose_and_run(config, testfile, args, Vec::new(),
config.compile_lib_path, input)
}
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,
fn make_compile_args(config: &config,
props: &TestProps,
- extras: ~[~str],
+ extras: Vec<~str> ,
xform: |&config, &Path| -> TargetLocation,
testfile: &Path)
-> ProcArgs {
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");
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,
}
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 {
logv(config, format!("executing ({}) {}", config.target, cmdline));
- let mut runargs = ~[];
+ let mut runargs = Vec::new();
// run test via adb_run_wrapper
runargs.push(~"shell");
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));
}
// 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);
// 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 {
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)
}
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,
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,
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)
}
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>,
}
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),
}
#[cfg(test)]
mod tests {
extern crate test;
+
+ use std::vec_ng::Vec;
+
use self::test::BenchHarness;
use super::{Arena, TypedArena};
struct Nonpod {
string: ~str,
- array: ~[int],
+ array: Vec<int> ,
}
#[test]
for _ in range(0, 100000) {
arena.alloc(Nonpod {
string: ~"hello world",
- array: ~[ 1, 2, 3, 4, 5 ],
+ array: vec!( 1, 2, 3, 4, 5 ),
});
}
}
bh.iter(|| {
arena.alloc(Nonpod {
string: ~"hello world",
- array: ~[ 1, 2, 3, 4, 5 ],
+ array: vec!( 1, 2, 3, 4, 5 ),
})
})
}
bh.iter(|| {
~Nonpod {
string: ~"hello world",
- array: ~[ 1, 2, 3, 4, 5 ],
+ array: vec!( 1, 2, 3, 4, 5 ),
}
})
}
bh.iter(|| {
arena.alloc(|| Nonpod {
string: ~"hello world",
- array: ~[ 1, 2, 3, 4, 5 ],
+ array: vec!( 1, 2, 3, 4, 5 ),
})
})
}
//! }
//! 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;
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)]
/// 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
#[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
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")
}
}
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)
}
}
if vals.is_empty() {
None
} else {
- Some(vals[0].clone())
+ Some((*vals.get(0)).clone())
}
}
/// 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,
_ => (),
};
}
/// 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 {
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
}
}
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())
}
}
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 {
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);
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()));
+ }
}
}
}
}
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 {
i += 1;
}
Ok(Matches {
- opts: opts.to_owned(),
+ opts: Vec::from_slice(opts),
vals: vals,
free: free
})
}
// 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
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 {
#[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));
}
use std::result::{Err, Ok};
use std::result;
+ use std::vec_ng::Vec;
fn check_fail_type(f: Fail_, ft: FailType) {
match f {
// 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"));
}
_ => { 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");
#[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!()
#[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!()
}
#[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!()
// 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"));
}
_ => 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");
#[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"));
#[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!()
}
#[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!()
// 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"));
}
_ => 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"));
#[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"));
#[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());
#[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!()
#[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!()
}
// 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);
#[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);
#[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);
#[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);
#[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);
#[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);
// 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")));
}
_ => 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");
#[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"));
#[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!()
}
#[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"));
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!()
}
#[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!()
}
#[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!()
#[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!()
};
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!()
};
#[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!()
};
#[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);
#[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
-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);
// 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
wrapped..+..
";
- let usage = usage("Usage: fruits", optgroups);
+ let usage = usage("Usage: fruits", optgroups.as_slice());
debug!("expected: <<{}>>", expected);
debug!("generated: <<{}>>", usage);
#[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
some parts of Europe.
";
- let usage = usage("Usage: fruits", optgroups);
+ let usage = usage("Usage: fruits", optgroups.as_slice());
debug!("expected: <<{}>>", expected);
debug!("generated: <<{}>>", usage);
#[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);
*/
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,
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,
}
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
}
-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()
}
}
*/
#[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)]
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() {
!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)
}
-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] == '-' {
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()))
})
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()))
})
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) {
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;
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();
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()
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> {
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"),
},
#[deriving(Clone, Encodable, Decodable)]
pub struct ExternalCrate {
name: ~str,
- attrs: ~[Attribute],
+ attrs: Vec<Attribute> ,
}
impl Clean<ExternalCrate> for cstore::crate_metadata {
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,
#[deriving(Clone, Encodable, Decodable)]
pub struct Module {
- items: ~[Item],
+ items: Vec<Item> ,
is_crate: bool,
}
} 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(),
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(),
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(),
})
}
}
#[deriving(Clone, Encodable, Decodable)]
pub enum Attribute {
Word(~str),
- List(~str, ~[Attribute]),
+ List(~str, Vec<Attribute> ),
NameValue(~str, ~str)
}
pub struct TyParam {
name: ~str,
id: ast::NodeId,
- bounds: ~[TyParamBound]
-}
+ bounds: Vec<TyParamBound> }
impl Clean<TyParam> for ast::TyParam {
fn clean(&self) -> TyParam {
// 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 {
},
output: (self.decl.output.clean()),
cf: self.decl.cf.clean(),
- attrs: ~[]
+ attrs: Vec::new()
};
Item {
name: Some(self.ident.clean()),
},
output: (self.decl.output.clean()),
cf: self.decl.cf.clean(),
- attrs: ~[]
+ attrs: Vec::new()
};
Item {
name: Some(self.ident.clean()),
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 {
purity: self.purity,
bounds: match self.bounds {
Some(ref x) => x.clean().move_iter().collect(),
- None => ~[]
+ None => Vec::new()
},
}
}
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 {
},
output: (self.output.clean()),
cf: self.cf.clean(),
- attrs: ~[]
+ attrs: Vec::new()
}
}
}
#[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 {
/// 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,
},
Closure(~ClosureDecl),
/// extern "ABI" fn
BareFunction(~BareFunctionDecl),
- Tuple(~[Type]),
+ Tuple(Vec<Type> ),
Vector(~Type),
FixedVector(~Type, ~str),
String,
pub struct Struct {
struct_type: doctree::StructType,
generics: Generics,
- fields: ~[Item],
+ fields: Vec<Item> ,
fields_stripped: bool,
}
#[deriving(Clone, Encodable, Decodable)]
pub struct VariantStruct {
struct_type: doctree::StructType,
- fields: ~[Item],
+ fields: Vec<Item> ,
fields_stripped: bool,
}
#[deriving(Clone, Encodable, Decodable)]
pub struct Enum {
- variants: ~[Item],
+ variants: Vec<Item> ,
generics: Generics,
variants_stripped: bool,
}
#[deriving(Clone, Encodable, Decodable)]
pub enum VariantKind {
CLikeVariant,
- TupleVariant(~[Type]),
+ TupleVariant(Vec<Type> ),
StructVariant(VariantStruct),
}
#[deriving(Clone, Encodable, Decodable)]
pub struct Path {
global: bool,
- segments: ~[PathSegment],
+ segments: Vec<PathSegment> ,
}
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 {
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(),
generics: Generics,
trait_: Option<Type>,
for_: Type,
- methods: ~[Item],
+ methods: Vec<Item> ,
}
impl Clean<Item> for doctree::Impl {
#[deriving(Clone, Encodable, Decodable)]
pub enum ViewItemInner {
ExternCrate(~str, Option<~str>, ast::NodeId),
- Import(~[ViewPath])
+ Import(Vec<ViewPath>)
}
impl Clean<ViewItemInner> for ast::ViewItem_ {
// use source::*;
GlobImport(ImportSource),
// use source::{a, b, c};
- ImportList(ImportSource, ~[ViewListIdent]),
+ ImportList(ImportSource, Vec<ViewListIdent> ),
}
#[deriving(Clone, Encodable, Decodable)]
}
/// 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 {
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,
+ }
}
}
}
/// 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,
})
}
-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);
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,
}
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,
}
}
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,
pub struct Variant {
name: Ident,
- attrs: ~[ast::Attribute],
+ attrs: Vec<ast::Attribute> ,
kind: ast::VariantKind,
id: ast::NodeId,
vis: ast::Visibility,
pub struct Function {
decl: ast::FnDecl,
- attrs: ~[ast::Attribute],
+ attrs: Vec<ast::Attribute> ,
id: NodeId,
name: Ident,
vis: ast::Visibility,
gen: ast::Generics,
name: Ident,
id: ast::NodeId,
- attrs: ~[ast::Attribute],
+ attrs: Vec<ast::Attribute> ,
where: Span,
vis: ast::Visibility,
}
mutability: ast::Mutability,
expr: @ast::Expr,
name: Ident,
- attrs: ~[ast::Attribute],
+ attrs: Vec<ast::Attribute> ,
vis: ast::Visibility,
id: ast::NodeId,
where: Span,
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,
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,
pub struct Macro {
name: Ident,
id: ast::NodeId,
- attrs: ~[ast::Attribute],
+ attrs: Vec<ast::Attribute> ,
where: Span,
}
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();
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();
},
}
}
- 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)
},
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));
}
},
|_cache| {
- Some((fqn.to_owned(), match kind {
+ Some((Vec::from_slice(fqn), match kind {
clean::TypeStruct => "struct",
clean::TypeEnum => "enum",
clean::TypeFunction => "fn",
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
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,
};
/// 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, "<"));
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)
}
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,
/// 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`.
///
/// 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
/// 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,
// 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 {
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,
match i.trait_ {
Some(clean::ResolvedPath{ id, .. }) => {
let v = self.implementors.find_or_insert_with(id, |_|{
- ~[]
+ Vec::new()
});
match i.for_ {
clean::ResolvedPath{..} => {
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| {
// 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| {
}
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());
});
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),
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));
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));
}
}
}
}
}
-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);
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;
}
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",
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());
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");
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")),
(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);
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);
};
// 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"),
/// 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,
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
};
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(
_ => ()
}
}
- 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();
}
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| {
});
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
/// 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,
}
/// Create a new plugin manager
pub fn new(prefix: Path) -> PluginManager {
PluginManager {
- dylibs: ~[],
- callbacks: ~[],
+ dylibs: Vec::new(),
+ callbacks: Vec::new(),
prefix: prefix,
}
}
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);
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());
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
}
}
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,
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,
pub struct RustdocVisitor<'a> {
module: Module,
- attrs: ~[ast::Attribute],
+ attrs: Vec<ast::Attribute> ,
cx: &'a core::DocContext,
analysis: Option<&'a core::CrateAnalysis>,
}
analysis: Option<&'b core::CrateAnalysis>) -> RustdocVisitor<'b> {
RustdocVisitor {
module: Module::new(None),
- attrs: ~[],
+ attrs: Vec::new(),
cx: cx,
analysis: analysis,
}
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,
}
}
- 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 {
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);
}
});
// 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();
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));
}
#[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)
}
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
}
// 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());
}
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());
}
// 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());
}
#[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 {
* 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 {
*/
pub struct RWLock {
priv order_lock: Semaphore,
- priv access_lock: Sem<~[WaitQueue]>,
+ priv access_lock: Sem<Vec<WaitQueue> >,
priv state: UnsafeArc<RWLockInner>,
}
use std::result;
use std::task;
use std::comm::Empty;
+ use std::vec_ng::Vec;
/************************************************************************
* Semaphore 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();
}
}
let x = RWLock::new();
- let mut rxs = ~[];
+ let mut rxs = vec!();
for _ in range(0, num_waiters) {
let xi = x.clone();
/// parallelism.
use std::task;
-use std::slice;
enum Msg<T> {
Execute(proc(&T)),
}
pub struct TaskPool<T> {
- priv channels: ~[Sender<Msg<T>>],
+ priv channels: Vec<Sender<Msg<T>>>,
priv next_index: uint,
}
-> 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();
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; }
}
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};
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)
}
}
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)
}
}
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)
}
}
}
}
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(())
}
/// 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;
//! Parameterized string expansion
-use std::{char, slice};
+use std::char;
use std::mem::replace;
#[deriving(Eq)]
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 = [
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();
(_,'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,'#') => {
}
}
-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(),
(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);
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_);
}
}
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);
}
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_;
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]
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]
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());
}
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());
}
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]));
}
}
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]
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()));
}
}
/// 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.
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
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()));
}
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;
}
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");
/// 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
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
// 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,
// 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() },
fail!("non-static tests passed to test::test_main_static");
}
}
- });
+ }).collect();
test_main(args, owned_tests)
}
/// 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)"),
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!("{}", "\
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()))
};
let filter =
if matches.free.len() > 0 {
- Some((matches).free[0].clone())
+ Some((*matches.free.get(0)).clone())
} else {
None
};
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
}
ignored: 0u,
measured: 0u,
metrics: MetricMap::new(),
- failures: ~[],
+ failures: Vec::new(),
max_name_len: 0u,
})
}
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");
}
}
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())));
}
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,
// 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() {
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();
#[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)));
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
// 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()
+ }
}
}
let TestDescAndFn {desc, testfn} = test;
if force_ignore || desc.ignore {
- monitor_ch.send((desc, TrIgnored, ~[]));
+ monitor_ch.send((desc, TrIgnored, Vec::new()));
return;
}
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));
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),
#[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")
};
#[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")
};
test_shard: None
};
- let tests = ~[
+ let tests = vec!(
TestDescAndFn {
desc: TestDesc {
name: StaticTestName("1"),
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]
};
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 {
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());
}
}
- let mut buf = ~[];
+ let mut buf = Vec::new();
let mut rdr = BufReader::new(format.as_bytes());
loop {
}
}
- str::from_utf8_owned(buf).unwrap()
+ str::from_utf8(buf.as_slice()).unwrap().to_str()
}
#[cfg(test)]
///
/// 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.
}
// 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
Version5Sha1};
use std::str;
use std::io::MemWriter;
+ use std::vec_ng::Vec;
#[test]
fn test_nil() {
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);
}
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();
#[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);
// except according to those terms.
pub mod kitties {
+ use std::vec_ng::Vec;
+
pub struct cat<U> {
priv info : Vec<U> ,
priv meows : uint,
#[feature(managed_boxes)];
use std::cell::RefCell;
+use std::vec_ng::Vec;
pub struct Entry<A,B> {
key: A,
#[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;
}
}
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();
}
// 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!(); } });
}
use std::mem::swap;
use std::os;
use std::str;
-use std::slice;
use std::vec;
use std::io::File;
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;
}
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;
}
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());
}
}
}
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");
}
}
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");
}
}
use std::os;
use std::uint;
+use std::vec_ng::Vec;
fn main() {
let args = os::args();
} 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();
use std::os;
use std::task;
use std::uint;
+use std::vec_ng::Vec;
fn move_out<T>(_x: T) {}
} else if args.len() <= 1u {
vec!(~"", ~"10000", ~"4")
} else {
- args.clone()
+ args.clone().move_iter().collect()
};
println!("{:?}", args);
- run(args);
+ run(args.as_slice());
}
use std::os;
use std::task;
use std::uint;
+use std::vec_ng::Vec;
fn move_out<T>(_x: T) {}
} else if args.len() <= 1u {
vec!(~"", ~"10000", ~"4")
} else {
- args.clone()
+ args.clone().move_iter().collect()
};
println!("{:?}", args);
- run(args);
+ run(args.as_slice());
}
use sync::Future;
use std::os;
use std::uint;
+use std::vec_ng::Vec;
// A poor man's pipe.
type pipe = MutexArc<Vec<uint> >;
} 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();
use sync::Future;
use std::os;
use std::uint;
+use std::vec_ng::Vec;
// A poor man's pipe.
type pipe = RWArc<Vec<uint> >;
} 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();
// except according to those terms.
use std::os;
+use std::vec_ng::Vec;
fn ack(m: int, n: int) -> int {
if m == 0 {
} 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));
}
use std::option;
use std::os;
use std::task;
+use std::vec_ng::Vec;
fn print_complements() {
let all = [Blue, Red, Yellow];
}
}
-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(' ');
}
}
-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>();
// 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
// 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
} 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!("");
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
}
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();
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;
// except according to those terms.
use std::os;
+use std::vec_ng::Vec;
fn fib(n: int) -> int {
if n < 2 {
} 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));
}
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));
}
}
// 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
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> {
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,
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;
});
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);
}
}
// 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());
}
}
}
result.reverse();
- str::from_utf8_owned(result).unwrap()
+ str::from_utf8_owned(result.move_iter().collect()).unwrap()
}
}
fn new() -> Table {
Table {
count: 0,
- items: slice::from_fn(TABLE_SIZE, |_| None),
+ items: Vec::from_fn(TABLE_SIZE, |_| None),
}
}
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;
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() {
// 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> {
// 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})
.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() {
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);
}
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;}
}
}
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.
// 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) {
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);
// 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;
} 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);
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) {
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")}
}
} else if args.len() <= 1u {
vec!(~"", ~"8")
} else {
- args
+ args.move_iter().collect()
};
let opts = parse_opts(args.clone());
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;
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
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) {
} 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;
use std::io::BufferedReader;
use std::os;
use std::intrinsics::cttz16;
-use std::slice;
// Computes a single solution to a given 9x9 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)
}
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;
}
}
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");
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");
}
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));
}
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 {
// 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
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));
}
}
}
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)
managed: @nillist,
unique: ~nillist,
tuple: (@nillist, ~nillist),
- vec: vec!(@nillist),
+ vec: Vec<@nillist>,
res: r
}
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))
}
}
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.
} 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");
}
use std::os;
use std::task;
use std::uint;
+use std::vec_ng::Vec;
fn f(n: uint) {
let mut i = 0u;
} 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; }
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+use std::vec_ng::Vec;
struct sty(Vec<int> );
// 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() {
mod m1 {}
-fn main(args: vec!(str)) { log(debug, m1::a); }
+fn main(args: Vec<~str>) { log(debug, m1::a); }
pub mod a {}
}
-fn main(args: vec!(str)) { log(debug, m1::a); }
+fn main(args: Vec<~str>) {
+ log(debug, m1::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);
}
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() {
}
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];
}
// 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`
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;
})
}
Foo { string: ~"bar" },
Foo { string: ~"baz" }
);
- let x: &[Foo] = x;
+ let x: &[Foo] = x.as_slice();
match x {
[_, ..tail] => {
match tail {
fn main() {
let v = vec!(1, 2, 3);
- write(v); //~ ERROR cannot borrow
+ write(v.as_mut_slice()); //~ ERROR cannot borrow
}
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")
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")
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")
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
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
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
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
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
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")
#[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");
}
+++ /dev/null
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-fn main() {
- let v = vec!(); //~ ERROR unexpected token: `,`
-}
+++ /dev/null
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#[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() {
-}
// 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(); }
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(); }
// error-pattern: import
+use std::vec_ng::Vec;
+
mod a { pub use b::foo; }
mod b { pub use a::foo; }
// 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(); }
+++ /dev/null
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#[feature(managed_boxes)];
-
-static x: Vec<int> = vec!(123, 456); //~ ERROR: static items are not allowed to have owned pointers
-
-fn main() {}
// 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> );
}
#[allow(dead_code)];
#[allow(deprecated_owned_vector)];
+use std::vec_ng::Vec;
+
fn fail_len(v: Vec<int> ) -> uint {
let mut i = 3;
fail!();
+++ /dev/null
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#[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);
-}
// 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> ,
}
// 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| {
// 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
// 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.
// Test which of the builtin types are considered freezeable.
+use std::vec_ng::Vec;
+
fn assert_freeze<T:Freeze>() { }
trait Dummy { }
#[feature(managed_boxes)];
use std::rc::Rc;
+use std::vec_ng::Vec;
fn assert_pod<T:Pod>() { }
trait Dummy { }
// Test which of the builtin types are considered sendable.
+use std::vec_ng::Vec;
+
fn assert_send<T:Send>() { }
trait Dummy { }
@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
#[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
#[deny(unused_unsafe)];
#[allow(deprecated_owned_vector)];
+use std::vec_ng::Vec;
+
mod foo {
extern {
pub fn bar();
// 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();
// 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
}
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
}
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
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() {}
fn f21() {
let x = vec!(1, 2, 3);
- let _y = (x[0], 3);
+ let _y = (*x.get(0), 3);
touch(&x);
}
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() {}
task::spawn(proc() {
let v = arc_v.get();
- assert_eq!(v[3], 4);
+ assert_eq!(*v.get(3), 4);
});
- assert_eq!((arc_v.get())[2], 3);
+ assert_eq!(*(arc_v.get()).get(2), 3);
println!("{:?}", arc_v);
}
task::spawn(proc() {
let v = arc_v.get();
- assert_eq!(v[3], 4);
+ assert_eq!(*v.get(3), 4);
});
- assert_eq!((arc_v.get())[2], 3); //~ ERROR use of moved value: `arc_v`
+ assert_eq!(*(arc_v.get()).get(2), 3); //~ ERROR use of moved value: `arc_v`
println!("{:?}", arc_v); //~ ERROR use of moved value: `arc_v`
}
enum State { ST_NULL, ST_WHITESPACE }
fn main() {
- vec!(ST_NULL, ..(ST_WHITESPACE as uint));
+ [ST_NULL, ..(ST_WHITESPACE as uint)];
//~^ ERROR expected constant integer for repeat count but found variable
}
// except according to those terms.
use std::libc;
+use std::vec_ng::Vec;
fn main() {
let x : *Vec<int> = &vec!(1,2,3);
(b, b) => {}
}
let vec = vec!(Some(42), None, Some(21));
- let vec: &[Option<int>] = vec;
+ let vec: &[Option<int>] = vec.as_slice();
match vec {
//~^ ERROR non-exhaustive patterns: vectors of length 0 not covered
[Some(..), None, ..tail] => {}
[None] => {}
}
let vec = vec!(1);
- let vec: &[int] = vec;
+ let vec: &[int] = vec.as_slice();
match vec {
[_, ..tail] => (),
[] => ()
}
let vec = vec!(0.5);
- let vec: &[f32] = vec;
+ let vec: &[f32] = vec.as_slice();
match vec { //~ ERROR non-exhaustive patterns: vectors of length 4 not covered
[0.1, 0.2, 0.3] => (),
[0.1, 0.2] => (),
[] => ()
}
let vec = vec!(Some(42), None, Some(21));
- let vec: &[Option<int>] = vec;
+ let vec: &[Option<int>] = vec.as_slice();
match vec {
[Some(..), None, ..tail] => {}
[Some(..), Some(..), ..tail] => {}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-
enum bar { t1((), Option<Vec<int>>), t2, }
// n.b. my change changes this error message, but I think it's right -- tjc
fn main() {
let n = 1;
- let a = vec!(0, ..n); //~ ERROR expected constant integer for repeat count but found variable
+ let a = [0, ..n]; //~ ERROR expected constant integer for repeat count but found variable
}
#[no_implicit_prelude];
+use std::vec_ng::Vec;
+
fn last<T>(v: Vec<&T> ) -> std::option::Option<T> {
fail!();
}
+++ /dev/null
-// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// issue #11659, the compiler needs to know that a fixed length vector
-// always requires instantiable contents to instantiable itself
-// (unlike a ~[] vector which can have length zero).
-
-// ~ to avoid infinite size.
-struct Uninstantiable { //~ ERROR cannot be instantiated without an instance of itself
- p: vec!(Uninstantiable, .. 1)
-}
-
-struct Instantiable { p: vec!(Instantiable, .. 0) }
-
-
-fn main() {
- let _ = None::<Uninstantiable>;
- let _ = Instantiable { p: ~([]) };
-}
#[feature(managed_boxes)];
use std::cell::Cell;
+use std::vec_ng::Vec;
struct r {
i: @Cell<int>,
// ignore-tidy-linelength
use std::fmt;
+use std::vec_ng::Vec;
struct Number {
n: i64
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+use std::vec_ng::Vec;
+
fn main() {
let _foo = Vec::new(); //~ ERROR unconstrained type
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+use std::vec_ng::Vec;
+
fn main() {
let v: Vec<int> = vec!(1, 2, 3);
- v[1] = 4; //~ ERROR cannot assign
+ *v.get(1) = 4; //~ ERROR cannot assign
}
#[feature(managed_boxes)];
use std::cell::Cell;
+use std::vec_ng::Vec;
fn test1() { let val = @0; { } *val; }
fn test10() -> int {
let regs = @vec!(0);
match true { true => { } _ => { } }
- (*regs)[0]
+ *(*regs).get(0)
}
fn test11() -> Vec<int> { if true { } vec!(1, 2) }
let x = Some(3);
let _y =
match x {
- Some(_) => vec!(~"some(_)", ~"not", ~"SO", ~"long", ~"string"),
- None => vec!(~"none")
+ Some(_) => [~"some(_)", ~"not", ~"SO", ~"long", ~"string"],
+ None => [~"none", ~"a", ~"a", ~"a", ~"a"]
};
}
// pp-exact:vec-comments.pp
fn main() {
let _v1 =
- ~[
- // Comment
- 0,
- // Comment
- 1,
- // Comment
- 2];
+ [
+ // Comment
+ 0,
+ // Comment
+ 1,
+ // Comment
+ 2];
let _v2 =
- ~[0, // Comment
- 1, // Comment
- 2]; // Comment
+ [0, // Comment
+ 1, // Comment
+ 2]; // Comment
let _v3 =
- ~[
- /* Comment */
- 0,
- /* Comment */
- 1,
- /* Comment */
- 2];
+ [
+ /* Comment */
+ 0,
+ /* Comment */
+ 1,
+ /* Comment */
+ 2];
let _v4 =
- ~[0, /* Comment */
- 1, /* Comment */
- 2]; /* Comment */
+ [0, /* Comment */
+ 1, /* Comment */
+ 2]; /* Comment */
}
// pp-exact:vec-comments.pp
fn main() {
let _v1 =
- vec!(
- // Comment
- 0,
- // Comment
- 1,
- // Comment
- 2);
+ [
+ // Comment
+ 0,
+ // Comment
+ 1,
+ // Comment
+ 2];
let _v2 =
- vec!(0, // Comment
- 1, // Comment
- 2); // Comment
+ [0, // Comment
+ 1, // Comment
+ 2]; // Comment
let _v3 =
- vec!(
- /* Comment */
- 0,
- /* Comment */
- 1,
- /* Comment */
- 2);
+ [
+ /* Comment */
+ 0,
+ /* Comment */
+ 1,
+ /* Comment */
+ 2];
let _v4 =
- vec!(0, /* Comment */
- 1, /* Comment */
- 2); /* Comment */
+ [0, /* Comment */
+ 1, /* Comment */
+ 2]; /* Comment */
}
+++ /dev/null
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// pp-exact:vec-type.pp
-
-fn f1(_x: ~[int]) { }
-
-fn g1() { f1(~[1, 2, 3]); }
+++ /dev/null
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// pp-exact:vec-type.pp
-
-fn f1(_x: Vec<int> ) { }
-
-fn g1() { f1(vec!(1, 2, 3)); }
idx * mem::size_of::<uint>());
// This should fail.
- println!("ov1 0x{:x}", x[idx]);
+ println!("ov1 0x{:x}", *x.get(idx));
}
#[allow(unreachable_code)];
#[allow(unused_variable)];
+use std::vec_ng::Vec;
+
// error-pattern:so long
fn main() {
let mut x = Vec::new();
extern crate collections;
+use std::vec_ng::Vec;
+use std::vec_ng;
+
fn main() {
let _count = @0u;
let mut map = collections::HashMap::new();
let mut arr = Vec::new();
for _i in range(0u, 10u) {
arr.push(@~"key stuff");
- map.insert(arr.clone(), arr + &[@~"value stuff"]);
+ map.insert(arr.clone(),
+ vec::append(arr.clone(), &[@~"value stuff"]));
if arr.len() == 5 {
fail!();
}
#[feature(managed_boxes)];
+use std::vec_ng::Vec;
+
fn f() -> Vec<int> { fail!(); }
// Voodoo. In unwind-alt we had to do this to trigger the bug. Might
#[feature(managed_boxes)];
+use std::vec_ng::Vec;
+
fn f() -> Vec<int> { fail!(); }
// Voodoo. In unwind-alt we had to do this to trigger the bug. Might
#[feature(managed_boxes)];
+use std::vec_ng::Vec;
+
fn f() -> Vec<int> { fail!(); }
// Voodoo. In unwind-alt we had to do this to trigger the bug. Might
// error-pattern:fail
+use std::vec_ng::Vec;
+
fn build() -> Vec<int> {
fail!();
}
// error-pattern:fail
+use std::vec_ng::Vec;
+
fn build1() -> Vec<int> {
vec!(0,0,0,0,0,0,0)
}
#[feature(managed_boxes)];
+use std::vec_ng::Vec;
+
// error-pattern:fail
fn fold_local() -> @Vec<int> {
#[feature(managed_boxes)];
+use std::vec_ng::Vec;
+
// error-pattern:fail
fn fold_local() -> @Vec<int> {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-
// error-pattern:index out of bounds: the len is 1 but the index is 2
+
+use std::vec_ng::Vec;
+
fn main() {
let v: Vec<int> = vec!(10);
- let x: int = 0;
- assert_eq!(v[x], 10);
+ let x: uint = 0;
+ assert_eq!(*v.get(x), 10);
// Bounds-check failure.
- assert_eq!(v[x + 2], 20);
+ assert_eq!(*v.get(x + 2), 20);
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+use std::vec_ng::Vec;
+
enum option<T> { some(T), none, }
struct R<T> {v: Vec<option<T>> }
// making method calls, but only if there aren't any matches without
// it.
+use std::vec_ng::Vec;
+
trait iterable<A> {
fn iterate(&self, blk: |x: &A| -> bool) -> bool;
}
}
pub fn main() {
- let x = vec!(0,1,2,3);
+ let x: Vec<int> = vec!(0,1,2,3);
// Call a method
- x.iterate(|y| { assert!(x[*y] == *y); true });
+ x.iterate(|y| { assert!(*x.get(*y as uint) == *y); true });
// Call a parameterized function
assert_eq!(length(x.clone()), x.len());
// Call a parameterized function, with type arguments that require
// a borrow
- assert_eq!(length::<int, &[int]>(x), x.len());
+ assert_eq!(length::<int, &[int]>(x.as_slice()), x.len());
// Now try it with a type that *needs* to be borrowed
let z = [0,1,2,3];
// NB: Associativity of ~, etc. in this context is surprising. These must be parenthesized
([1]).test_imm();
- (vec!(1)).test_imm();
+ (vec!(1)).as_slice().test_imm();
(&[1]).test_imm();
("test").test_imm();
(~"test").test_imm();
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+use std::vec_ng::Vec;
+
trait Pushable<T> {
fn push_val(&mut self, t: T);
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn f<T>(x: Vec<T> ) -> T { return x[0]; }
+use std::vec_ng::Vec;
+
+fn f<T>(x: Vec<T>) -> T { return x.move_iter().next().unwrap(); }
fn g(act: |Vec<int> | -> int) -> int { return act(vec!(1, 2, 3)); }
// ignore-fast
+use std::vec_ng::Vec;
+
fn iter_vec<T>(v: Vec<T> , f: |&T|) { for x in v.iter() { f(x); } }
pub fn main() {
// ignore-fast
+use std::vec_ng::Vec;
+
fn iter_vec<T>(v: Vec<T> , f: |&T|) { for x in v.iter() { f(x); } }
pub fn main() {
// 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);
}
pub fn main() {
let items = vec!( 3, 5, 1, 2, 4 );
- items.foo();
+ items.as_slice().foo();
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+use std::vec_ng::Vec;
+
struct F { f: Vec<int> }
fn impure(_v: &[int]) {
match x {
F {f: ref mut v} => {
- impure(*v);
+ impure(v.as_slice());
}
}
}
// except according to those terms.
use std::mem::swap;
+use std::vec_ng::Vec;
struct Ints {sum: ~int, values: Vec<int> }
fn iter_ints(x: &Ints, f: |x: &int| -> bool) -> bool {
let l = x.values.len();
- range(0u, l).advance(|i| f(&x.values[i]))
+ range(0u, l).advance(|i| f(x.values.get(i)))
}
pub fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+use std::vec_ng::Vec;
+
fn want_slice(v: &[int]) -> int {
let mut sum = 0;
for i in v.iter() { sum += *i; }
}
fn has_mut_vec(v: Vec<int> ) -> int {
- want_slice(v)
+ want_slice(v.as_slice())
}
pub fn main() {
#[feature(managed_boxes)];
+use std::vec_ng::Vec;
+
struct F { f: @G }
struct G { g: Vec<int> }
#[feature(managed_boxes)];
+use std::vec_ng::Vec;
+
fn borrow<'r,T>(x: &'r T) -> &'r T {x}
struct Rec { f: @int }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+use std::vec_ng::Vec;
+
fn foo() -> int { 22 }
pub fn main() {
- let mut x: vec!(extern "Rust" fn() -> int) = Vec::new();
+ let mut x: Vec<extern "Rust" fn() -> int> = Vec::new();
x.push(foo);
- assert_eq!((x[0])(), 22);
+ assert_eq!((*x.get(0))(), 22);
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+use std::vec_ng::Vec;
+
struct cat<U> {
info : Vec<U> ,
meows : uint,
#[feature(macro_rules)];
use std::ops::Drop;
+use std::vec_ng::Vec;
static mut FLAGS: u64 = 0;
end_of_block!(_, { { check_flags(0); &AddFlags(1) } });
end_of_block!(_, &((Box { f: AddFlags(1) }).f));
end_of_block!(_, &(([AddFlags(1)])[0]));
- end_of_block!(_, &((&vec!(AddFlags(1)))[0]));
// LHS does not create a ref binding, so temporary lives as long
// as statement, and we do not move the AddFlags out:
// scenario worth testing.
use std::task;
+use std::vec_ng::Vec;
enum Conzabble {
Bickwick(Foo)
pub fn fails() {
let x = 2;
let mut y = Vec::new();
- y.push(~Bickwick(do_it(get_bar(x))));
+ y.push(~Bickwick(do_it(get_bar(x).as_slice())));
}
pub fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+use std::vec_ng::Vec;
+
fn bar(v: &mut [uint]) -> Vec<uint> {
- v.to_owned()
+ Vec::from_slice(v)
}
fn bip(v: &[uint]) -> Vec<uint> {
- v.to_owned()
+ Vec::from_slice(v)
}
pub fn main() {
let mut the_vec = vec!(1u, 2, 3, 100);
- assert_eq!(the_vec.clone(), bar(the_vec));
- assert_eq!(the_vec.clone(), bip(the_vec));
+ assert_eq!(the_vec.clone(), bar(the_vec.as_mut_slice()));
+ assert_eq!(the_vec.clone(), bip(the_vec.as_slice()));
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+use std::vec_ng::Vec;
+
fn reverse(v: &mut [uint]) {
v.reverse();
}
pub fn main() {
let mut the_vec = vec!(1, 2, 3, 100);
- bar(the_vec);
+ bar(the_vec.as_mut_slice());
assert_eq!(the_vec, vec!(100, 3, 2, 1));
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+use std::vec_ng::Vec;
+
fn bar(v: &mut [uint]) {
v.reverse();
v.reverse();
pub fn main() {
let mut the_vec = vec!(1, 2, 3, 100);
- bar(the_vec);
+ bar(the_vec.as_mut_slice());
assert_eq!(the_vec, vec!(100, 3, 2, 1));
}
+++ /dev/null
-// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-enum State { ST_NULL, ST_WHITESPACE = 1 }
-
-pub fn main() {
- vec!(ST_NULL, ..(ST_WHITESPACE as uint));
-}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// ignore-test
+// ignore-fast
+//
+// Too big for our poor macro infrastructure.
+
pub fn main() {
- let _x = ~[
+ let _x = vec!(
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
- ];
+ );
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// ignore-test
+// ignore-fast
+//
+// Too big for our poor macro infrastructure.
+
pub fn main() {
- let _x = ~[
+ let _x = vec!(
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
- ];
+ );
}
#[allow(unused_mut)];
+use std::vec_ng::Vec;
+
pub fn main() { let mut _v: Vec<int> = Vec::new(); }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+use std::vec_ng::Vec;
+
fn test_int() {
fn f() -> int { 10 }
assert_eq!(f(), 10);
fn test_vec() {
fn f() -> Vec<int> { vec!(10, 11) }
- assert_eq!(f()[1], 11);
+ let vect = f();
+ assert_eq!(*vect.get(1), 11);
}
fn test_generic() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+use std::vec_ng::Vec;
+
fn test_simple() {
let r = match true { true => { true } false => { fail!() } };
assert_eq!(r, true);
fn test_box() {
let r = match true { true => { vec!(10) } false => { fail!() } };
- assert_eq!(r[0], 10);
+ assert_eq!(*r.get(0), 10);
}
pub fn main() { test_simple(); test_box(); }
+++ /dev/null
-// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#[feature(managed_boxes)];
-
-pub fn main() {
- let v: Vec<int> = vec!( 1, ..5 );
- println!("{}", v[0]);
- println!("{}", v[1]);
- println!("{}", v[2]);
- println!("{}", v[3]);
- println!("{}", v[4]);
-}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+use std::vec_ng::Vec;
+
pub fn main() { let x: Vec<int> = Vec::new(); for _ in x.iter() { fail!("moop"); } }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-
-
+use std::vec_ng::Vec;
fn two(it: |int|) { it(0); it(1); }
let mut a: Vec<int> = vec!(-1, -1, -1, -1);
let mut p: int = 0;
two(|i| {
- two(|j| { a[p] = 10 * i + j; p += 1; })
+ two(|j| { *a.get_mut(p as uint) = 10 * i + j; p += 1; })
});
- assert_eq!(a[0], 0);
- assert_eq!(a[1], 1);
- assert_eq!(a[2], 10);
- assert_eq!(a[3], 11);
+ assert_eq!(*a.get(0), 0);
+ assert_eq!(*a.get(1), 1);
+ assert_eq!(*a.get(2), 10);
+ assert_eq!(*a.get(3), 11);
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+use std::vec_ng::Vec;
+
trait vec_utils<T> {
fn map_<U>(x: &Self, f: |&T| -> U) -> Vec<U> ;
}
extern crate getopts;
use getopts::{optopt, getopts};
+use std::vec_ng::Vec;
pub fn main() {
let args = Vec::new();
let opts = vec!(optopt("b", "", "something", "SMTHNG"));
- match getopts(args, opts) {
+ match getopts(args.as_slice(), opts.as_slice()) {
Ok(ref m) =>
assert!(!m.opt_present("b")),
Err(ref f) => fail!("{:?}", (*f).clone().to_err_msg())
extern crate collections;
+use std::vec_ng::Vec;
+
/**
A somewhat reduced test case to expose some Valgrind issues.
use collections::HashMap;
use std::str;
use std::task;
+ use std::vec_ng::Vec;
pub type putter<'a> = 'a |~str, ~str|;
}
let (tx, rx) = channel();
println!("sending find_reducer");
- ctrl.send(find_reducer(key.as_bytes().to_owned(), tx));
+ ctrl.send(find_reducer(Vec::from_slice(key.as_bytes()), tx));
println!("receiving");
let c = rx.recv();
println!("{:?}", c);
mapper_done => { num_mappers -= 1; }
find_reducer(k, cc) => {
let mut c;
- match reducers.find(&str::from_utf8(k).unwrap().to_owned()) {
+ match reducers.find(&str::from_utf8(k.as_slice()).unwrap()
+ .to_owned()) {
Some(&_c) => { c = _c; }
None => { c = 0; }
}
#[feature(macro_rules)];
+use std::vec_ng::Vec;
+
/*
This is an HTML parser written as a macro. It's all CPS, and we have
// can do with them just yet (to test the output)
fn test_print() {
print!("hi");
- print!("{:?}", ~[0u8]);
+ print!("{:?}", vec!(0u8));
println!("hello");
println!("this is a {}", "test");
println!("{foo}", foo="bar");
#[feature(globs)];
#[allow(dead_assignment)];
-use std::slice::*;
+use std::mem::*;
pub fn main() {
- let mut v = from_elem(0u, 0);
- v = append(v, [4, 2]);
- assert_eq!(from_fn(2, |i| 2*(i+1)), vec!(2, 4));
+ assert_eq!(size_of::<u8>(), 1);
+ let (mut x, mut y) = (1, 2);
+ swap(&mut x, &mut y);
+ assert_eq!(x, 2);
+ assert_eq!(x, 1);
}
// issue #680
+use std::vec_ng::Vec;
+
fn f() -> Vec<int> { Vec::new() }
pub fn main() { }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-
-
+use std::vec_ng::Vec;
// This is a testcase for issue #94.
pub fn main() {
let v: Vec<int> = vec!(0, 1, 2, 3, 4, 5);
let s: ~str = ~"abcdef";
- assert_eq!(v[3u], 3);
- assert_eq!(v[3u8], 3);
- assert_eq!(v[3i8], 3);
- assert_eq!(v[3u32], 3);
- assert_eq!(v[3i32], 3);
- println!("{}", v[3u8]);
+ assert_eq!(v.as_slice()[3u], 3);
+ assert_eq!(v.as_slice()[3u8], 3);
+ assert_eq!(v.as_slice()[3i8], 3);
+ assert_eq!(v.as_slice()[3u32], 3);
+ assert_eq!(v.as_slice()[3i32], 3);
+ println!("{}", v.as_slice()[3u8]);
assert_eq!(s[3u], 'd' as u8);
assert_eq!(s[3u8], 'd' as u8);
assert_eq!(s[3i8], 'd' as u8);
// except according to those terms.
// Issue #1821 - Don't recurse trying to typecheck this
+
+use std::vec_ng::Vec;
+
enum t {
- foo(vec!(t))
+ foo(Vec<t>)
}
pub fn main() {}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+use std::vec_ng::Vec;
+
struct font<'a> {
fontbuf: &'a Vec<u8> ,
}
use collections::HashMap;
use serialize::json;
use std::option;
+use std::vec_ng::Vec;
enum object {
bool_value(bool),
{
&json::List(ref interfaces) =>
{
- interfaces.map(|interface| {
+ interfaces.iter().map(|interface| {
add_interface(store, managed_ip.clone(), (*interface).clone())
- })
+ }).collect()
}
_ =>
{
use std::io;
use std::fmt;
+use std::vec_ng::Vec;
enum square {
bot,
}
}
-fn read_board_grid<rdr:'static + io::Reader>(mut input: rdr) -> vec!(vec!(square)) {
+fn read_board_grid<rdr:'static + io::Reader>(mut input: rdr)
+ -> Vec<Vec<square>> {
let mut input: &mut io::Reader = &mut input;
let mut grid = Vec::new();
let mut line = [0, ..10];
row.push(square_from_char(*c as char))
}
grid.push(row);
- let width = grid[0].len();
+ let width = grid.get(0).len();
for row in grid.iter() { assert!(row.len() == width) }
grid
}
Vec::from_fn(8, |i| {
let w = i / 64;
let b = i % 64;
- let x = 1u64 & (bitv.storage[w] >> b);
+ let x = 1u64 & (*bitv.storage.get(w) >> b);
x == 1u64
})
}
let bools2 = to_bools(Storage{storage: vec!(0b01100100)});
for i in range(0u, 8) {
- println!("{} => {} vs {}", i, bools[i], bools2[i]);
+ println!("{} => {} vs {}", i, *bools.get(i), *bools2.get(i));
}
assert_eq!(bools, bools2);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+use std::vec_ng::Vec;
+
type Connection = 'static |Vec<u8> |;
fn f() -> Option<Connection> {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+use std::vec_ng::Vec;
+
struct trie_node {
content: Vec<~str> ,
children: Vec<trie_node> ,
// Extern mod controls linkage. Use controls the visibility of names to modules that are
// already linked in. Using WriterUtil allows us to use the write_line method.
+
use std::str;
use std::slice;
use std::fmt;
+use std::vec_ng::Vec;
// Represents a position on a canvas.
struct Point {
fn AsciiArt(width: uint, height: uint, fill: char) -> AsciiArt {
// Use an anonymous function to build a vector of vectors containing
// blank characters for each position in our canvas.
- let lines = slice::build(Some(height), |push| {
- for _ in range(0, height) { push(slice::from_elem(width, '.')); }
- });
+ let mut lines = Vec::new();
+ for _ in range(0, height) {
+ lines.push(Vec::from_elem(width, '.'));
+ }
// Rust code often returns values by omitting the trailing semi-colon
// instead of using an explicit return statement.
// element is:
// 1) potentially large
// 2) needs to be modified
- let row = &mut self.lines[v];
- row[h] = self.fill;
+ let row = self.lines.get_mut(v);
+ *row.get_mut(h) = self.fill;
}
}
}
impl fmt::Show for AsciiArt {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
// Convert each line into a string.
- let lines = self.lines.map(|line| str::from_chars(*line));
+ let lines = self.lines.map(|line| str::from_chars(line.as_slice()));
// Concatenate the lines together using a new-line.
write!(f.buf, "{}", lines.connect("\n"))
// except according to those terms.
use std::task;
+use std::vec_ng::Vec;
type RingBuffer = Vec<f64> ;
type SamplesFn = proc(samples: &RingBuffer);
let mut samples_chan = samples_chan;
let callback: SamplesFn = proc(buffer) {
for i in range(0u, buffer.len()) {
- println!("{}: {}", i, buffer[i])
+ println!("{}: {}", i, *buffer.get(i))
}
};
samples_chan.send(GetSamples(name.clone(), callback));
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+use std::vec_ng::Vec;
+
struct HasNested {
nest: Vec<Vec<int> > ,
}
impl HasNested {
fn method_push_local(&mut self) {
- self.nest[0].push(0);
+ self.nest.get_mut(0).push(0);
}
}
// byproducts in vtable records.
extern crate serialize;
+
use serialize::{json, Decodable};
+use std::vec_ng::Vec;
pub fn main() {
let json = json::from_str("[1]").unwrap();
to traits.
*/
+use std::vec_ng::Vec;
+
// original
trait Inner {
fn print(&self);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+use std::vec_ng::Vec;
+
fn swap(f: |Vec<int> | -> Vec<int> ) -> Vec<int> {
let x = vec!(1, 2, 3);
f(x)
#[feature(managed_boxes)];
fn assert_repr_eq<T>(obj : T, expected : ~str) {
-
assert_eq!(expected, format!("{:?}", obj));
}
let abc = [1, 2, 3];
let tf = [true, false];
let x = [(), ()];
- let y = vec!((), ());
let slice = x.slice(0,1);
let z = @x;
assert_repr_eq(abc, ~"[1, 2, 3]");
assert_repr_eq(tf, ~"[true, false]");
assert_repr_eq(x, ~"[(), ()]");
- assert_repr_eq(y, ~"~[(), ()]");
assert_repr_eq(slice, ~"&[()]");
assert_repr_eq(&x, ~"&[(), ()]");
assert_repr_eq(z, ~"@[(), ()]");
// from a vector to a slice. The drop glue was being invoked on
// the temporary slice with a wrong type, triggering an LLVM assert.
+use std::vec_ng::Vec;
+
struct Thing1<'a> {
baz: &'a [~int],
bar: ~u64,
bar: ~32,
};
Thing1 {
- baz: Vec::new(),
+ baz: Vec::new().as_slice(),
bar: ~32,
};
let _t2_fixed = Thing2 {
bar: 32,
};
Thing2 {
- baz: Vec::new(),
+ baz: Vec::new().as_slice(),
bar: 32,
};
}
+++ /dev/null
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-fn double<T:Clone>(a: T) -> Vec<T> { return vec!(a.clone()) + vec!(a); }
-
-fn double_int(a: int) -> Vec<int> { return vec!(a) + vec!(a); }
-
-pub fn main() {
- let mut d = double(1);
- assert_eq!(d[0], 1);
- assert_eq!(d[1], 1);
-
- d = double_int(1);
- assert_eq!(d[0], 1);
- assert_eq!(d[1], 1);
-}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+use std::vec_ng::Vec;
+
fn f(_a: Vec<int> ) { }
pub fn main() { f(vec!(1, 2, 3, 4, 5)); }
// except according to those terms.
use std::task;
+use std::vec_ng::Vec;
fn producer(tx: &Sender<Vec<u8>>) {
tx.send(
// This should typecheck even though the type of e is not fully
// resolved when we finish typechecking the ||.
+use std::vec_ng::Vec;
+
struct Refs { refs: Vec<int> , n: int }
pub fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+use std::vec_ng::Vec;
+
fn take(x: int) -> int {x}
fn the_loop() {
+++ /dev/null
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-use std::repr;
-
-pub fn main() {
- let act = repr::repr_to_str(&vec!(1, 2, 3));
- assert_eq!(~"~[1, 2, 3]", act);
-
- let act = format!("{:?}/{:6?}", vec!(1, 2, 3), ~"hi");
- assert_eq!(act, ~"~[1, 2, 3]/~\"hi\" ");
-}
// Tests that matching rvalues with drops does not crash.
+use std::vec_ng::Vec;
+
pub fn main() {
match vec!(1, 2, 3) {
x => {
assert_eq!(x.len(), 3);
- assert_eq!(x[0], 1);
- assert_eq!(x[1], 2);
- assert_eq!(x[2], 3);
+ assert_eq!(*x.get(0), 1);
+ assert_eq!(*x.get(1), 2);
+ assert_eq!(*x.get(2), 3);
}
}
}
// ignore-fast
+use std::vec_ng::Vec;
+
trait vec_monad<A> {
fn bind<B>(&self, f: |&A| -> Vec<B> ) -> Vec<B> ;
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn test(foo: ~Vec<int> ) { assert!((foo[0] == 10)); }
+use std::vec_ng::Vec;
+
+fn test(foo: ~Vec<int> ) { assert!((*foo.get(0) == 10)); }
pub fn main() {
let x = ~vec!(10);
#[feature(managed_boxes)];
-fn test(foo: @Vec<int> ) { assert!((foo[0] == 10)); }
+use std::vec_ng::Vec;
+
+fn test(foo: @Vec<int> ) { assert!((*foo.get(0) == 10)); }
pub fn main() {
let x = @vec!(10);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn grow(v: &mut Vec<int>) {
+fn grow(v: &mut Vec<int> ) {
v.push(1);
}
#[feature(managed_boxes)];
#[allow(unused_mut)];
+use std::vec_ng::Vec;
+
struct Pair { a: int, b: int}
pub fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+use std::vec_ng::Vec;
+
#[deriving(Clone)]
struct myvec<X>(Vec<X> );
fn myvec_elt<X>(mv: myvec<X>) -> X {
let myvec(v) = mv;
- return v[0];
+ return v.move_iter().next().unwrap();
}
pub fn main() {
let mv = myvec(vec!(1, 2, 3));
- assert_eq!(myvec_deref(mv.clone())[1], 2);
+ let mv_clone = mv.clone();
+ let mv_clone = myvec_deref(mv_clone);
+ assert_eq!(*mv_clone.get(1), 2);
assert_eq!(myvec_elt(mv.clone()), 1);
let myvec(v) = mv;
- assert_eq!(v[2], 3);
+ assert_eq!(*v.get(2), 3);
}
#[feature(macro_rules)];
use std::{option, cast};
+use std::vec_ng::Vec;
// Iota-reduction is a rule in the Calculus of (Co-)Inductive Constructions,
// which "says that a destructor applied to an object built from a constructor
#[feature(macro_rules)];
use std::mem;
+use std::vec_ng::Vec;
enum E<T> { Thing(int, T), Nothing((), ((), ()), [i8, ..0]) }
struct S<T>(int, T);
check_type!(~int);
check_type!(@int);
check_type!(~str);
- check_type!(Vec<int> );
check_type!(extern fn());
}
#[feature(managed_boxes)];
+use std::vec_ng::Vec;
+
// Test invoked `&self` methods on owned objects where the values
// closed over contain managed values. This implies that the ~ boxes
// will have headers that must be skipped over.
}
pub fn main() {
- let foos: vec!( ~FooTrait: ) = vec!(
+ let foos: Vec<~FooTrait:> = vec!(
~BarStruct{ x: @0 } as ~FooTrait:,
~BarStruct{ x: @1 } as ~FooTrait:,
~BarStruct{ x: @2 } as ~FooTrait:
);
for i in range(0u, foos.len()) {
- assert_eq!(i, foos[i].foo());
+ assert_eq!(i, foos.get(i).foo());
}
}
// closed over do not contain managed values, and thus the ~ boxes do
// not have headers.
+use std::vec_ng::Vec;
+
trait FooTrait {
fn foo(&self) -> uint;
}
}
pub fn main() {
- let foos: vec!( ~FooTrait ) = vec!(
+ let foos: Vec<~FooTrait> = vec!(
~BarStruct{ x: 0 } as ~FooTrait,
~BarStruct{ x: 1 } as ~FooTrait,
~BarStruct{ x: 2 } as ~FooTrait
);
for i in range(0u, foos.len()) {
- assert_eq!(i, foos[i].foo());
+ assert_eq!(i, foos.get(i).foo());
}
}
// takes its argument *by reference*.
use std::ops::Index;
+use std::vec_ng::Vec;
struct AssociationList<K,V> {
pairs: Vec<AssociationPair<K,V>> }
use std::cell::RefCell;
use std::rc::Rc;
+use std::vec_ng::Vec;
#[deriving(Eq, Show)]
struct Point {
assert_eq!(*(*p).borrow(), Point {x: 3, y: 5});
let v = Rc::new(RefCell::new(vec!(1, 2, 3)));
- (*(*v).borrow_mut())[0] = 3;
- (*(*v).borrow_mut())[1] += 3;
- assert_eq!(((*(*v).borrow())[0], (*(*v).borrow())[1], (*(*v).borrow())[2]), (3, 5, 3));
+ *(*(*v).borrow_mut()).get_mut(0) = 3;
+ *(*(*v).borrow_mut()).get_mut(1) += 3;
+ assert_eq!((*(*(*v).borrow()).get(0),
+ *(*(*v).borrow()).get(1),
+ *(*(*v).borrow()).get(2)), (3, 5, 3));
}
// except according to those terms.
use std::mem;
+use std::vec_ng::Vec;
#[packed]
struct S<T, S> {
// Check that functions can modify local state.
+use std::vec_ng::Vec;
+
fn sums_to(v: Vec<int> , sum: int) -> bool {
let mut i = 0u;
let mut sum0 = 0;
while i < v.len() {
- sum0 += v[i];
+ sum0 += *v.get(i);
i += 1u;
}
return sum0 == sum;
let mut i = 0u;
let mut sum0 = ~0;
while i < v.len() {
- *sum0 += v[i];
+ *sum0 += *v.get(i);
i += 1u;
}
return *sum0 == sum;
let mut i = 0u;
let mut sum0 = F {f: 0};
while i < v.len() {
- sum0.f += v[i];
+ sum0.f += *v.get(i);
i += 1u;
}
return sum0.f == sum;
let mut i = 0u;
let mut sum0 = F {f: ~0};
while i < v.len() {
- *sum0.f += v[i];
+ *sum0.f += *v.get(i);
i += 1u;
}
return *sum0.f == sum;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+use std::vec_ng::Vec;
+
trait sum {
fn sum_(self) -> int;
}
pub fn main() {
let x = vec!(1, 2, 3);
- let y = call_sum(x);
+ let y = call_sum(x.as_slice());
println!("y=={}", y);
assert_eq!(y, 6);
let x = vec!(1, 2, 3);
- let y = x.sum_();
+ let y = x..as_slice().sum_();
println!("y=={}", y);
assert_eq!(y, 6);
let x = vec!(1, 2, 3);
- let y = x.sum_();
+ let y = x.as_slice().sum_();
println!("y=={}", y);
assert_eq!(y, 6);
}
#[feature(managed_boxes)];
use std::intrinsics::{TyDesc, get_tydesc, visit_tydesc, TyVisitor, Disr, Opaque};
+use std::vec_ng::Vec;
struct MyVisitor {
types: Vec<~str> ,
visit_ty::<int>(&mut v);
visit_ty::<i8>(&mut v);
visit_ty::<i16>(&mut v);
- visit_ty::<Vec<int> >(&mut v);
for s in v.types.iter() {
println!("type: {}", (*s).clone());
}
- assert_eq!(v.types.clone(), vec!(~"bool", ~"int", ~"i8", ~"i16", ~"[", ~"int", ~"]"));
+
+ let vec_types: Vec<~str> = v.types.clone().move_iter().collect();
+ assert_eq!(vec_types, vec!(~"bool", ~"int", ~"i8", ~"i16"));
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+use std::vec_ng::Vec;
+
fn foo(x: &[int]) -> int {
x[0]
}
pub fn main() {
let p = vec!(1,2,3,4,5);
- let r = foo(p);
+ let r = foo(p.as_slice());
assert_eq!(r, 1);
let p = vec!(5,4,3,2,1);
- let r = foo(p);
+ let r = foo(p.as_slice());
assert_eq!(r, 5);
}
// Test lifetimes are linked properly when we create dependent region pointers.
// Issue #3148.
+use std::vec_ng::Vec;
+
struct A {
value: B
}
fn get_v3<'v>(a: &'v A, i: uint) -> &'v int {
let foo = &a.value;
- &foo.v3[i]
+ foo.v3.get(i)
}
fn get_v4<'v>(a: &'v A, _i: uint) -> &'v int {
assert_eq!(*p, a.value.v2[1]);
let p = get_v3(&a, 1);
- assert_eq!(*p, a.value.v3[1]);
+ assert_eq!(*p, *a.value.v3.get(1));
let p = get_v4(&a, 1);
assert_eq!(*p, a.value.v4.f);
// Test lifetimes are linked properly when we autoslice a vector.
// Issue #3148.
+use std::vec_ng::Vec;
+
fn subslice1<'r>(v: &'r [uint]) -> &'r [uint] { v }
fn both<'r>(v: &'r [uint]) -> &'r [uint] {
pub fn main() {
let v = vec!(1,2,3);
- both(v);
+ both(v.as_slice());
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+use std::vec_ng::Vec;
+
fn view<'r, T>(x: &'r [T]) -> &'r [T] {x}
pub fn main() {
let v = vec!(1, 2, 3);
- let x = view(v);
- let y = view(x);
- assert!((v[0] == x[0]) && (v[0] == y[0]));
+ let x = view(v.as_slice());
+ let y = view(x.as_slice());
+ assert!((*v.get(0) == x[0]) && (*v.get(0) == y[0]));
}
use std::cast;
use std::libc;
use std::mem;
+use std::vec_ng::Vec;
type Type<'tcx> = &'tcx TypeStructure<'tcx>;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-
+use std::vec_ng::Vec;
pub fn main() {
assert!((~"hello" < ~"hellr"));
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+use std::vec_ng::Vec;
+
fn foo(c: Vec<int> ) {
let a: int = 5;
let mut b: Vec<int> = Vec::new();
// interior record which is then itself interior to
// something else, shape calculations were off.
+use std::vec_ng::Vec;
+
#[deriving(Clone)]
enum opt_span {
//hack (as opposed to option), to make `span` compile
struct Path_ {
global: bool,
idents: Vec<~str> ,
- types: vec!(@ty),
+ types: Vec<@ty>,
}
type path = Spanned<Path_>;
pub fn main() {
let sp: Span = Span {lo: 57451u, hi: 57542u, expanded_from: os_none};
let t: @ty = @Spanned { data: 3u, span: sp };
- let p_: Path_ = Path_ { global: true, idents: vec!(~"hi"), types: Vec<t> };
+ let p_: Path_ = Path_ {
+ global: true,
+ idents: vec!(~"hi"),
+ types: vec!(t),
+ };
let p: path = Spanned { data: p_, span: sp };
let x = X { sp: sp, path: p };
println!("{:?}", x.path.clone());
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-
-
+use std::vec_ng::Vec;
enum clam<T> { a(T, int), b, }
fn uhoh<T>(v: Vec<clam<T>> ) {
- match v[1] {
+ match *v.get(1) {
a::<T>(ref _t, ref u) => {
println!("incorrect");
println!("{:?}", u);
// ignore-fast
+use std::vec_ng::Vec;
+
pub trait plus {
fn plus(&self) -> int;
}
assert_eq!((~"hi").plus(), 200);
assert_eq!((vec!(1)).length_().str(), ~"1");
- assert_eq!((vec!(3, 4)).map_(|a| *a + 4 )[0], 7);
- assert_eq!((vec!(3, 4)).map_::<uint>(|a| *a as uint + 4u )[0], 7u);
+ let vect = vec!(3, 4).map_(|a| *a + 4);
+ assert_eq!(*vect.get(0), 7);
+ let vect = (vec!(3, 4)).map_::<uint>(|a| *a as uint + 4u);
+ assert_eq!(*vect.get(0), 7u);
let mut x = 0u;
10u.multi(|_n| x += 2u );
assert_eq!(x, 20u);
// except according to those terms.
use std::mem::swap;
+use std::vec_ng::Vec;
pub fn main() {
let mut a: Vec<int> = vec!(0, 1, 2, 3, 4, 5, 6);
a.swap(2, 4);
- assert_eq!(a[2], 4);
- assert_eq!(a[4], 2);
+ assert_eq!(*a.get(2), 4);
+ assert_eq!(*a.get(4), 2);
let mut n = 42;
- swap(&mut n, &mut a[0]);
- assert_eq!(a[0], 42);
+ swap(&mut n, a.get_mut(0));
+ assert_eq!(*a.get(0), 42);
assert_eq!(n, 0);
}
// except according to those terms.
use std::cmp;
+use std::vec_ng::Vec;
// Tests of ports and channels on various types
fn test_rec() {
let v0: Vec<int> = vec!(0, 1, 2);
tx.send(v0);
let v1 = rx.recv();
- assert_eq!(v1[0], 0);
- assert_eq!(v1[1], 1);
- assert_eq!(v1[2], 2);
+ assert_eq!(*v1.get(0), 0);
+ assert_eq!(*v1.get(1), 1);
+ assert_eq!(*v1.get(2), 2);
}
fn test_str() {
// ignore-fast
use std::task;
+use std::vec_ng::Vec;
pub fn main() { println!("===== WITHOUT THREADS ====="); test00(); }
use sync::Arc;
use std::task;
+use std::vec_ng::Vec;
trait Pet {
fn name(&self, blk: |&str|);
}
assert!(legs == 12);
}
-<<<<<<< HEAD
-fn check_names(arc: Arc<~[~Pet:Share+Send]>) {
-=======
-fn check_names(arc: Arc<Vec<~Pet:Freeze+Send> >) {
->>>>>>> test: Automatically remove all `~[T]` from tests.
+fn check_names(arc: Arc<Vec<~Pet:Share+Send>>) {
for pet in arc.get().iter() {
pet.name(|name| {
assert!(name[0] == 'a' as u8 && name[1] == 'l' as u8);
})
}
}
-<<<<<<< HEAD
-fn check_pedigree(arc: Arc<~[~Pet:Share+Send]>) {
-=======
-fn check_pedigree(arc: Arc<Vec<~Pet:Freeze+Send> >) {
->>>>>>> test: Automatically remove all `~[T]` from tests.
+fn check_pedigree(arc: Arc<Vec<~Pet:Share+Send>>) {
for pet in arc.get().iter() {
assert!(pet.of_good_pedigree());
}
// ignore-fast
+use std::vec_ng::Vec;
+
trait to_str {
fn to_string(&self) -> ~str;
}
let mut r = Vec::new();
// FIXME: #7355 generates bad code with VecIterator
for i in range(0u, self.len()) {
- r.push(f(&self[i]));
+ r.push(f(self.get(i)));
}
r
}
assert_eq!(foo(vec!(1)), vec!(~"hi"));
assert_eq!(bar::<int, Vec<int> >(vec!(4, 5)), vec!(~"4", ~"5"));
assert_eq!(bar::<~str, Vec<~str> >(vec!(~"x", ~"y")), vec!(~"x", ~"y"));
- assert_eq!(bar::<(), vec!(())>(vec!(())), vec!(~"()"));
+ assert_eq!(bar::<(), Vec<()>>(vec!(())), vec!(~"()"));
}
// ignore-fast
+use std::vec_ng::Vec;
+
trait to_str {
fn to_string(&self) -> ~str;
}
pub fn main() {
unsafe {
assert_eq!((*get_tydesc::<int>()).name, "int");
- assert_eq!((*get_tydesc::<Vec<int> >()).name, "~[int]");
assert_eq!((*get_tydesc::<Foo<uint>>()).name, "Foo<uint>");
}
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+use std::vec_ng::Vec;
+
struct S<T> {
a: T,
b: uint,
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+use std::vec_ng::Vec;
+
pub fn main() {
let i = ~vec!(100);
- assert_eq!(i[0], 100);
+ assert_eq!(*i.get(0), 100);
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+use std::vec_ng::Vec;
+
pub fn main() {
let mut a = vec!(~10);
let b = a.clone();
- assert_eq!(*a[0], 10);
- assert_eq!(*b[0], 10);
+ assert_eq!(**a.get(0), 10);
+ assert_eq!(**b.get(0), 10);
// This should only modify the value in a, not b
- *a[0] = 20;
+ **a.get_mut(0) = 20;
- assert_eq!(*a[0], 20);
- assert_eq!(*b[0], 10);
+ assert_eq!(**a.get(0), 20);
+ assert_eq!(**b.get(0), 10);
}
// except according to those terms.
pub fn main() {
- assert!((vec!(~100))[0] == ~100);
+ let vect = vec!(~100);
+ assert!(*vect.get(0) == ~100);
}
// except according to those terms.
use std::str;
+use std::vec_ng::Vec;
pub fn main() {
// Chars of 1, 2, 3, and 4 bytes
- let chs: ~[char] = ~['e', 'é', '€', '\U00010000'];
- let s: ~str = str::from_chars(chs);
- let schs: ~[char] = s.chars().collect();
+ let chs: Vec<char> = vec!('e', 'é', '€', '\U00010000');
+ let s: ~str = str::from_chars(chs.as_slice());
+ let schs: Vec<char> = s.chars().collect();
assert!(s.len() == 10u);
assert!(s.char_len() == 4u);
assert!(schs.len() == 4u);
- assert!(str::from_chars(schs) == s);
+ assert!(str::from_chars(schs.as_slice()) == s);
assert!(s.char_at(0u) == 'e');
assert!(s.char_at(1u) == 'é');
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+use std::vec;
+
pub fn main() {
- let a: ~[int] = ~[1, 2, 3, 4, 5];
- let b: ~[int] = ~[6, 7, 8, 9, 0];
- let v: ~[int] = a + b;
+ let a: Vec<int> = vec!(1, 2, 3, 4, 5);
+ let b: Vec<int> = vec!(6, 7, 8, 9, 0);
+ let v: Vec<int> = vec::append(a, b.as_slice());
println!("{}", v[9]);
- assert_eq!(v[0], 1);
- assert_eq!(v[7], 8);
- assert_eq!(v[9], 0);
+ assert_eq!(*v.get(0), 1);
+ assert_eq!(*v.get(7), 8);
+ assert_eq!(*v.get(9), 0);
}
#[feature(managed_boxes)];
+use std::vec_ng::Vec;
+
struct Pair { x: int, y: int }
pub fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-
+use std::vec_ng::Vec;
pub fn main() {
let mut v = vec!(1);
v.push(3);
v.push(4);
v.push(5);
- assert_eq!(v[0], 1);
- assert_eq!(v[1], 2);
- assert_eq!(v[2], 3);
- assert_eq!(v[3], 4);
- assert_eq!(v[4], 5);
+ assert_eq!(*v.get(0), 1);
+ assert_eq!(*v.get(1), 2);
+ assert_eq!(*v.get(2), 3);
+ assert_eq!(*v.get(3), 4);
+ assert_eq!(*v.get(4), 5);
}
+++ /dev/null
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#[allow(dead_assignment)];
-
-pub fn main() {
- let a = vec!(1, 2, 3, 4, 5);
- let mut b = vec!(a.clone(), a.clone());
- b = b + b; // FIXME(#3387)---can't write b += b
-}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-
+use std::vec_ng::Vec;
pub fn main() {
let mut later: Vec<int> ;
if true { later = vec!(1); } else { later = vec!(2); }
- println!("{}", later[0]);
+ println!("{}", *later.get(0));
}
+++ /dev/null
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// Issue #2482.
-
-pub fn main() {
- let v1: Vec<int> = vec!(10, 20, 30);
- let v2: Vec<int> = vec!(10, 20, 30);
- assert_eq!(v1[2], v2[2]);
- let v3: Vec<int> = vec!(10);
- let v4: Vec<int> = vec!(10);
- assert_eq!(v3[0], v4[0]);
-}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-
-
+use std::vec_ng::Vec;
pub fn main() {
let v: Vec<int> = vec!(10, 20);
- assert_eq!(v[0], 10);
- assert_eq!(v[1], 20);
- let mut x: int = 0;
- assert_eq!(v[x], 10);
- assert_eq!(v[x + 1], 20);
+ assert_eq!(*v.get(0), 10);
+ assert_eq!(*v.get(1), 20);
+ let mut x: uint = 0;
+ assert_eq!(*v.get(x), 10);
+ assert_eq!(*v.get(x + 1), 20);
x = x + 1;
- assert_eq!(v[x], 20);
- assert_eq!(v[x - 1], 10);
+ assert_eq!(*v.get(x), 20);
+ assert_eq!(*v.get(x - 1), 10);
}
#[feature(managed_boxes)];
+use std::vec_ng::Vec;
+
pub fn main() { let _quux: @Vec<uint> = @Vec::new(); }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+use std::vec_ng::Vec;
pub fn main() {
let mut i: int = 90;
projects / rust.git / commitdiff