diff --git a/src/compiletest/compiletest.rs b/src/compiletest/compiletest.rs index 583d9249b3547..281cc54a3b7db 100644 --- a/src/compiletest/compiletest.rs +++ b/src/compiletest/compiletest.rs @@ -112,7 +112,7 @@ pub fn parse_config(args: Vec ) -> Config { } fn opt_path(m: &getopts::Matches, nm: &str) -> Path { - Path::new(m.opt_str(nm).unwrap()) + Path::new(m.opt_str(nm).assert()) } let filter = if !matches.free.is_empty() { @@ -129,21 +129,21 @@ pub fn parse_config(args: Vec ) -> Config { }; Config { - compile_lib_path: matches.opt_str("compile-lib-path").unwrap(), - run_lib_path: matches.opt_str("run-lib-path").unwrap(), + compile_lib_path: matches.opt_str("compile-lib-path").assert(), + run_lib_path: matches.opt_str("run-lib-path").assert(), rustc_path: opt_path(matches, "rustc-path"), clang_path: matches.opt_str("clang-path").map(|s| Path::new(s)), llvm_bin_path: matches.opt_str("llvm-bin-path").map(|s| Path::new(s)), src_base: opt_path(matches, "src-base"), build_base: opt_path(matches, "build-base"), aux_base: opt_path(matches, "aux-base"), - stage_id: matches.opt_str("stage-id").unwrap(), + stage_id: matches.opt_str("stage-id").assert(), mode: FromStr::from_str(matches.opt_str("mode") - .unwrap() + .assert() .as_slice()).expect("invalid mode"), run_ignored: matches.opt_present("ignored"), filter: filter, - cfail_regex: Regex::new(errors::EXPECTED_PATTERN).unwrap(), + cfail_regex: Regex::new(errors::EXPECTED_PATTERN).assert(), logfile: matches.opt_str("logfile").map(|s| Path::new(s)), save_metrics: matches.opt_str("save-metrics").map(|s| Path::new(s)), ratchet_metrics: @@ -257,7 +257,7 @@ pub fn run_tests(config: &Config) { // parallel (especially when we have lots and lots of child processes). // For context, see #8904 io::test::raise_fd_limit(); - let res = test::run_tests_console(&opts, tests.move_iter().collect()); + let res = test::run_tests_console(&opts, tests.iter_owned().collect()); match res { Ok(true) => {} Ok(false) => fail!("Some tests failed"), @@ -290,7 +290,7 @@ pub fn make_tests(config: &Config) -> Vec { debug!("making tests from {}", config.src_base.display()); let mut tests = Vec::new(); - let dirs = fs::readdir(&config.src_base).unwrap(); + let dirs = fs::readdir(&config.src_base).assert(); for file in dirs.iter() { let file = file.clone(); debug!("inspecting file {}", file.display()); @@ -315,7 +315,7 @@ pub fn is_test(config: &Config, testfile: &Path) -> bool { _ => vec!(".rc".to_string(), ".rs".to_string()) }; let invalid_prefixes = vec!(".".to_string(), "#".to_string(), "~".to_string()); - let name = testfile.filename_str().unwrap(); + let name = testfile.filename_str().assert(); let mut valid = false; @@ -362,7 +362,7 @@ pub fn make_test_name(config: &Config, testfile: &Path) -> test::TestName { pub fn make_test_closure(config: &Config, testfile: &Path) -> test::TestFn { let config = (*config).clone(); // FIXME (#9639): This needs to handle non-utf8 paths - let testfile = testfile.as_str().unwrap().to_string(); + let testfile = testfile.as_str().assert().to_string(); test::DynTestFn(proc() { runtest::run(config, testfile) }) @@ -371,7 +371,7 @@ pub fn make_test_closure(config: &Config, testfile: &Path) -> test::TestFn { pub fn make_metrics_test_closure(config: &Config, testfile: &Path) -> test::TestFn { let config = (*config).clone(); // FIXME (#9639): This needs to handle non-utf8 paths - let testfile = testfile.as_str().unwrap().to_string(); + let testfile = testfile.as_str().assert().to_string(); test::DynMetricFn(proc(mm) { runtest::run_metrics(config, testfile, mm) }) diff --git a/src/compiletest/errors.rs b/src/compiletest/errors.rs index 7681792bdf53d..4df269b4a921e 100644 --- a/src/compiletest/errors.rs +++ b/src/compiletest/errors.rs @@ -21,10 +21,10 @@ pub static EXPECTED_PATTERN : &'static str = r"//~(?P\^*)\s*(?P\S // Load any test directives embedded in the file pub fn load_errors(re: &Regex, testfile: &Path) -> Vec { - let mut rdr = BufferedReader::new(File::open(testfile).unwrap()); + let mut rdr = BufferedReader::new(File::open(testfile).assert()); rdr.lines().enumerate().filter_map(|(line_no, ln)| { - parse_expected(line_no + 1, ln.unwrap().as_slice(), re) + parse_expected(line_no + 1, ln.assert().as_slice(), re) }).collect() } diff --git a/src/compiletest/header.rs b/src/compiletest/header.rs index aa96f3e272712..1eea5b2027d09 100644 --- a/src/compiletest/header.rs +++ b/src/compiletest/header.rs @@ -140,7 +140,7 @@ pub fn is_test_ignored(config: &Config, testfile: &Path) -> bool { } fn ignore_stage(config: &Config) -> String { format!("ignore-{}", - config.stage_id.as_slice().split('-').next().unwrap()) + config.stage_id.as_slice().split('-').next().assert()) } let val = iter_header(testfile, |ln| { @@ -167,12 +167,12 @@ pub fn is_test_ignored(config: &Config, testfile: &Path) -> bool { fn iter_header(testfile: &Path, it: |&str| -> bool) -> bool { use std::io::{BufferedReader, File}; - let mut rdr = BufferedReader::new(File::open(testfile).unwrap()); + let mut rdr = BufferedReader::new(File::open(testfile).assert()); for ln in rdr.lines() { // Assume that any directives will be found before the first // module or function. This doesn't seem to be an optimization // with a warm page cache. Maybe with a cold one. - let ln = ln.unwrap(); + let ln = ln.assert(); if ln.as_slice().starts_with("fn") || ln.as_slice().starts_with("mod") { return true; @@ -238,10 +238,10 @@ fn parse_exec_env(line: &str) -> Option<(String, String)> { .collect(); match strs.len() { - 1u => (strs.pop().unwrap(), "".to_string()), + 1u => (strs.pop().assert(), "".to_string()), 2u => { - let end = strs.pop().unwrap(); - (strs.pop().unwrap(), end) + let end = strs.pop().assert(); + (strs.pop().assert(), end) } n => fail!("Expected 1 or 2 strings, not {}", n) } diff --git a/src/compiletest/procsrv.rs b/src/compiletest/procsrv.rs index 28ff2c18ad3ba..e44fff3e7895a 100644 --- a/src/compiletest/procsrv.rs +++ b/src/compiletest/procsrv.rs @@ -24,7 +24,7 @@ fn add_target_env(cmd: &mut Command, lib_path: &str, aux_path: Option<&str>) { // Add the new dylib search path var let var = DynamicLibrary::envvar(); let newpath = DynamicLibrary::create_path(path.as_slice()); - let newpath = String::from_utf8(newpath).unwrap(); + let newpath = String::from_utf8(newpath).assert(); cmd.env(var.to_string(), newpath); } @@ -40,22 +40,22 @@ pub fn run(lib_path: &str, let mut cmd = Command::new(prog); cmd.args(args); add_target_env(&mut cmd, lib_path, aux_path); - for (key, val) in env.move_iter() { + for (key, val) in env.iter_owned() { cmd.env(key, val); } match cmd.spawn() { Ok(mut process) => { for input in input.iter() { - process.stdin.get_mut_ref().write(input.as_bytes()).unwrap(); + process.stdin.as_mut().assert().write(input.as_bytes()).assert(); } let ProcessOutput { status, output, error } = - process.wait_with_output().unwrap(); + process.wait_with_output().assert(); Some(Result { status: status, - out: String::from_utf8(output).unwrap(), - err: String::from_utf8(error).unwrap() + out: String::from_utf8(output).assert(), + err: String::from_utf8(error).assert() }) }, Err(..) => None @@ -72,14 +72,14 @@ pub fn run_background(lib_path: &str, let mut cmd = Command::new(prog); cmd.args(args); add_target_env(&mut cmd, lib_path, aux_path); - for (key, val) in env.move_iter() { + for (key, val) in env.iter_owned() { cmd.env(key, val); } match cmd.spawn() { Ok(mut process) => { for input in input.iter() { - process.stdin.get_mut_ref().write(input.as_bytes()).unwrap(); + process.stdin.as_mut().assert().write(input.as_bytes()).assert(); } Some(process) diff --git a/src/compiletest/runtest.rs b/src/compiletest/runtest.rs index a9c7673d4ddfb..60b06469d6520 100644 --- a/src/compiletest/runtest.rs +++ b/src/compiletest/runtest.rs @@ -157,8 +157,8 @@ fn run_pretty_test(config: &Config, props: &TestProps, testfile: &Path) { let rounds = match props.pp_exact { Some(_) => 1, None => 2 }; - let src = File::open(testfile).read_to_end().unwrap(); - let src = String::from_utf8(src.clone()).unwrap(); + let src = File::open(testfile).read_to_end().assert(); + let src = String::from_utf8(src.clone()).assert(); let mut srcs = vec!(src); let mut round = 0; @@ -184,8 +184,8 @@ fn run_pretty_test(config: &Config, props: &TestProps, testfile: &Path) { let mut expected = match props.pp_exact { Some(ref file) => { let filepath = testfile.dir_path().join(file); - let s = File::open(&filepath).read_to_end().unwrap(); - String::from_utf8(s).unwrap() + let s = File::open(&filepath).read_to_end().assert(); + String::from_utf8(s).assert() } None => { srcs[srcs.len() - 2u].clone() } }; @@ -240,7 +240,7 @@ fn run_pretty_test(config: &Config, props: &TestProps, testfile: &Path) { pretty_type.to_string()), props.exec_env.clone(), config.compile_lib_path.as_slice(), - Some(aux_dir.as_str().unwrap()), + Some(aux_dir.as_str().assert()), Some(src)) } @@ -255,11 +255,11 @@ fn run_pretty_test(config: &Config, props: &TestProps, testfile: &Path) { pretty_type, format!("--target={}", config.target), "-L".to_string(), - aux_dir.as_str().unwrap().to_string()); + aux_dir.as_str().assert().to_string()); args.push_all_move(split_maybe_args(&config.target_rustcflags)); args.push_all_move(split_maybe_args(&props.compile_flags)); return ProcArgs { - prog: config.rustc_path.as_str().unwrap().to_string(), + prog: config.rustc_path.as_str().assert().to_string(), args: args, }; } @@ -301,14 +301,14 @@ actual:\n\ "--crate-type=lib".to_string(), format!("--target={}", target), "-L".to_string(), - config.build_base.as_str().unwrap().to_string(), + config.build_base.as_str().assert().to_string(), "-L".to_string(), - aux_dir.as_str().unwrap().to_string()); + aux_dir.as_str().assert().to_string()); 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 return ProcArgs { - prog: config.rustc_path.as_str().unwrap().to_string(), + prog: config.rustc_path.as_str().assert().to_string(), args: args, }; } @@ -342,7 +342,7 @@ fn run_debuginfo_gdb_test(config: &Config, props: &TestProps, testfile: &Path) { // write debugger script let script_str = ["set charset UTF-8".to_string(), - format!("file {}", exe_file.as_str().unwrap() + format!("file {}", exe_file.as_str().assert() .to_string()), "target remote :5039".to_string(), cmds, @@ -359,7 +359,7 @@ fn run_debuginfo_gdb_test(config: &Config, props: &TestProps, testfile: &Path) { None, [ "push".to_string(), - exe_file.as_str().unwrap().to_string(), + exe_file.as_str().assert().to_string(), config.adb_test_dir.clone() ], vec!(("".to_string(), "".to_string())), @@ -384,7 +384,7 @@ fn run_debuginfo_gdb_test(config: &Config, props: &TestProps, testfile: &Path) { config.adb_test_dir.clone(), str::from_utf8( exe_file.filename() - .unwrap()).unwrap()); + .assert()).assert()); let mut process = procsrv::run_background("", config.adb_path @@ -402,7 +402,7 @@ fn run_debuginfo_gdb_test(config: &Config, props: &TestProps, testfile: &Path) { //waiting 1 second for gdbserver start timer::sleep(1000); let result = task::try(proc() { - tcp::TcpStream::connect("127.0.0.1", 5039).unwrap(); + tcp::TcpStream::connect("127.0.0.1", 5039).assert(); }); if result.is_err() { continue; @@ -421,7 +421,7 @@ fn run_debuginfo_gdb_test(config: &Config, props: &TestProps, testfile: &Path) { vec!("-quiet".to_string(), "-batch".to_string(), "-nx".to_string(), - format!("-command={}", debugger_script.as_str().unwrap())); + format!("-command={}", debugger_script.as_str().assert())); let gdb_path = tool_path.append("/bin/arm-linux-androideabi-gdb"); let procsrv::Result { @@ -449,7 +449,7 @@ fn run_debuginfo_gdb_test(config: &Config, props: &TestProps, testfile: &Path) { stderr: err, cmdline: cmdline }; - process.signal_kill().unwrap(); + process.signal_kill().assert(); } _=> { @@ -482,8 +482,8 @@ fn run_debuginfo_gdb_test(config: &Config, props: &TestProps, testfile: &Path) { vec!("-quiet".to_string(), "-batch".to_string(), "-nx".to_string(), - format!("-command={}", debugger_script.as_str().unwrap()), - exe_file.as_str().unwrap().to_string()); + format!("-command={}", debugger_script.as_str().assert()), + exe_file.as_str().assert().to_string()); proc_args = ProcArgs { prog: debugger(), args: debugger_opts, @@ -587,16 +587,16 @@ fn run_debuginfo_lldb_test(config: &Config, props: &TestProps, testfile: &Path) cmd.arg("./src/etc/lldb_batchmode.py") .arg(test_executable) .arg(debugger_script) - .env_set_all([("PYTHONPATH", config.lldb_python_dir.clone().unwrap().as_slice())]); + .env_set_all([("PYTHONPATH", config.lldb_python_dir.clone().assert().as_slice())]); let (status, out, err) = match cmd.spawn() { Ok(process) => { let ProcessOutput { status, output, error } = - process.wait_with_output().unwrap(); + process.wait_with_output().assert(); (status, - String::from_utf8(output).unwrap(), - String::from_utf8(error).unwrap()) + String::from_utf8(output).assert(), + String::from_utf8(error).assert()) }, Err(e) => { fatal(format!("Failed to setup Python process for \ @@ -631,7 +631,7 @@ fn parse_debugger_commands(file_path: &Path, debugger_prefix: &str) let mut commands = vec!(); let mut check_lines = vec!(); let mut counter = 1; - let mut reader = BufferedReader::new(File::open(file_path).unwrap()); + let mut reader = BufferedReader::new(File::open(file_path).assert()); for line in reader.lines() { match line { Ok(line) => { @@ -678,7 +678,7 @@ fn cleanup_debug_info_options(options: &Option) -> Option { "--debuginfo".to_string() ]; let new_options = - split_maybe_args(options).move_iter() + split_maybe_args(options).iter_owned() .filter(|x| !options_to_remove.contains(x)) .collect::>() .connect(" "); @@ -736,7 +736,7 @@ fn check_debugger_output(debugger_run_result: &ProcRes, check_lines: &[String]) } if i != num_check_lines { fatal_proc_rec(format!("line not found in debugger output: {}", - check_lines.get(i).unwrap()).as_slice(), + check_lines.get(i).assert()).as_slice(), debugger_run_result); } } @@ -915,7 +915,7 @@ fn scan_until_char(haystack: &str, needle: char, idx: &mut uint) -> bool { if opt.is_none() { return false; } - *idx = opt.unwrap(); + *idx = opt.assert(); return true; } @@ -990,7 +990,7 @@ fn compile_test_(config: &Config, props: &TestProps, let aux_dir = aux_output_dir_name(config, testfile); // FIXME (#9639): This needs to handle non-utf8 paths let link_args = vec!("-L".to_string(), - aux_dir.as_str().unwrap().to_string()); + aux_dir.as_str().assert().to_string()); let args = make_compile_args(config, props, link_args.append(extra_args), @@ -1016,7 +1016,7 @@ fn exec_compiled_test(config: &Config, props: &TestProps, make_run_args(config, props, testfile), env, config.run_lib_path.as_slice(), - Some(aux_dir.as_str().unwrap()), + Some(aux_dir.as_str().assert()), None) } } @@ -1035,7 +1035,7 @@ fn compose_and_run_compiler( let aux_dir = aux_output_dir_name(config, testfile); // FIXME (#9639): This needs to handle non-utf8 paths - let extra_link_args = vec!("-L".to_string(), aux_dir.as_str().unwrap().to_string()); + let extra_link_args = vec!("-L".to_string(), aux_dir.as_str().assert().to_string()); for rel_ab in props.aux_builds.iter() { let abs_ab = config.aux_base.join(rel_ab.as_slice()); @@ -1060,7 +1060,7 @@ fn compose_and_run_compiler( aux_args, Vec::new(), config.compile_lib_path.as_slice(), - Some(aux_dir.as_str().unwrap()), + Some(aux_dir.as_str().assert()), None); if !auxres.status.success() { fatal_proc_rec( @@ -1082,13 +1082,13 @@ fn compose_and_run_compiler( args, Vec::new(), config.compile_lib_path.as_slice(), - Some(aux_dir.as_str().unwrap()), + Some(aux_dir.as_str().assert()), input) } fn ensure_dir(path: &Path) { if path.is_dir() { return; } - fs::mkdir(path, io::UserRWX).unwrap(); + fs::mkdir(path, io::UserRWX).assert(); } fn compose_and_run(config: &Config, testfile: &Path, @@ -1119,9 +1119,9 @@ fn make_compile_args(config: &Config, config.target.as_slice() }; // FIXME (#9639): This needs to handle non-utf8 paths - let mut args = vec!(testfile.as_str().unwrap().to_string(), + let mut args = vec!(testfile.as_str().assert().to_string(), "-L".to_string(), - config.build_base.as_str().unwrap().to_string(), + config.build_base.as_str().assert().to_string(), format!("--target={}", target)); args.push_all(extras.as_slice()); if !props.no_prefer_dynamic { @@ -1138,7 +1138,7 @@ fn make_compile_args(config: &Config, path } }; - args.push(path.as_str().unwrap().to_string()); + args.push(path.as_str().assert().to_string()); if props.force_host { args.push_all_move(split_maybe_args(&config.host_rustcflags)); } else { @@ -1146,7 +1146,7 @@ fn make_compile_args(config: &Config, } args.push_all_move(split_maybe_args(&props.compile_flags)); return ProcArgs { - prog: config.rustc_path.as_str().unwrap().to_string(), + prog: config.rustc_path.as_str().assert().to_string(), args: args, }; } @@ -1177,12 +1177,12 @@ fn make_run_args(config: &Config, props: &TestProps, testfile: &Path) -> let exe_file = make_exe_name(config, testfile); // FIXME (#9639): This needs to handle non-utf8 paths - args.push(exe_file.as_str().unwrap().to_string()); + args.push(exe_file.as_str().assert().to_string()); // Add the arguments in the run_flags directive args.push_all_move(split_maybe_args(&props.run_flags)); - let prog = args.remove(0).unwrap(); + let prog = args.remove(0).assert(); return ProcArgs { prog: prog, args: args, @@ -1267,7 +1267,7 @@ fn dump_output(config: &Config, testfile: &Path, out: &str, err: &str) { fn dump_output_file(config: &Config, testfile: &Path, out: &str, extension: &str) { let outfile = make_out_name(config, testfile, extension); - File::create(&outfile).write(out.as_bytes()).unwrap(); + File::create(&outfile).write(out.as_bytes()).assert(); } fn make_out_name(config: &Config, testfile: &Path, extension: &str) -> Path { @@ -1284,7 +1284,7 @@ fn aux_output_dir_name(config: &Config, testfile: &Path) -> Path { } fn output_testname(testfile: &Path) -> Path { - Path::new(testfile.filestem().unwrap()) + Path::new(testfile.filestem().assert()) } fn output_base_name(config: &Config, testfile: &Path) -> Path { @@ -1342,7 +1342,7 @@ fn _arm_exec_compiled_test(config: &Config, .split('/') .map(|ts| ts.to_string()) .collect(); - let prog_short = tvec.pop().unwrap(); + let prog_short = tvec.pop().assert(); // copy to target let copy_result = procsrv::run("", @@ -1371,7 +1371,7 @@ fn _arm_exec_compiled_test(config: &Config, // run test via adb_run_wrapper runargs.push("shell".to_string()); - for (key, val) in env.move_iter() { + for (key, val) in env.iter_owned() { runargs.push(format!("{}={}", key, val)); } runargs.push(format!("{}/adb_run_wrapper.sh", config.adb_test_dir)); @@ -1458,7 +1458,7 @@ fn _arm_exec_compiled_test(config: &Config, fn _arm_push_aux_shared_library(config: &Config, testfile: &Path) { let tdir = aux_output_dir_name(config, testfile); - let dirs = fs::readdir(&tdir).unwrap(); + let dirs = fs::readdir(&tdir).assert(); for file in dirs.iter() { if file.extension_str() == Some("so") { // FIXME (#9639): This needs to handle non-utf8 paths @@ -1468,7 +1468,7 @@ fn _arm_push_aux_shared_library(config: &Config, testfile: &Path) { [ "push".to_string(), file.as_str() - .unwrap() + .assert() .to_string(), config.adb_test_dir.to_string() ], @@ -1496,7 +1496,7 @@ fn append_suffix_to_stem(p: &Path, suffix: &str) -> Path { if suffix.len() == 0 { (*p).clone() } else { - let stem = p.filestem().unwrap(); + let stem = p.filestem().assert(); p.with_filename(Vec::from_slice(stem).append(b"-").append(suffix.as_bytes())) } } @@ -1506,7 +1506,7 @@ fn compile_test_and_save_bitcode(config: &Config, props: &TestProps, let aux_dir = aux_output_dir_name(config, testfile); // FIXME (#9639): This needs to handle non-utf8 paths let link_args = vec!("-L".to_string(), - aux_dir.as_str().unwrap().to_string()); + aux_dir.as_str().assert().to_string()); let llvm_args = vec!("--emit=obj".to_string(), "--crate-type=lib".to_string(), "-C".to_string(), @@ -1525,12 +1525,12 @@ fn compile_cc_with_clang_and_save_bitcode(config: &Config, _props: &TestProps, let testcc = testfile.with_extension("cc"); let proc_args = ProcArgs { // FIXME (#9639): This needs to handle non-utf8 paths - prog: config.clang_path.get_ref().as_str().unwrap().to_string(), + prog: config.clang_path.as_ref().assert().as_str().assert().to_string(), args: vec!("-c".to_string(), "-emit-llvm".to_string(), "-o".to_string(), - bitcodefile.as_str().unwrap().to_string(), - testcc.as_str().unwrap().to_string()) + bitcodefile.as_str().assert().to_string(), + testcc.as_str().assert().to_string()) }; compose_and_run(config, testfile, proc_args, Vec::new(), "", None, None) } @@ -1541,13 +1541,13 @@ fn extract_function_from_bitcode(config: &Config, _props: &TestProps, let bitcodefile = output_base_name(config, testfile).with_extension("bc"); let bitcodefile = append_suffix_to_stem(&bitcodefile, suffix); let extracted_bc = append_suffix_to_stem(&bitcodefile, "extract"); - let prog = config.llvm_bin_path.get_ref().join("llvm-extract"); + let prog = config.llvm_bin_path.as_ref().assert().join("llvm-extract"); let proc_args = ProcArgs { // FIXME (#9639): This needs to handle non-utf8 paths - prog: prog.as_str().unwrap().to_string(), + prog: prog.as_str().assert().to_string(), args: vec!(format!("-func={}", fname), - format!("-o={}", extracted_bc.as_str().unwrap()), - bitcodefile.as_str().unwrap().to_string()) + format!("-o={}", extracted_bc.as_str().assert()), + bitcodefile.as_str().assert().to_string()) }; compose_and_run(config, testfile, proc_args, Vec::new(), "", None, None) } @@ -1558,20 +1558,20 @@ fn disassemble_extract(config: &Config, _props: &TestProps, let bitcodefile = append_suffix_to_stem(&bitcodefile, suffix); let extracted_bc = append_suffix_to_stem(&bitcodefile, "extract"); let extracted_ll = extracted_bc.with_extension("ll"); - let prog = config.llvm_bin_path.get_ref().join("llvm-dis"); + let prog = config.llvm_bin_path.as_ref().assert().join("llvm-dis"); let proc_args = ProcArgs { // FIXME (#9639): This needs to handle non-utf8 paths - prog: prog.as_str().unwrap().to_string(), - args: vec!(format!("-o={}", extracted_ll.as_str().unwrap()), - extracted_bc.as_str().unwrap().to_string()) + prog: prog.as_str().assert().to_string(), + args: vec!(format!("-o={}", extracted_ll.as_str().assert()), + extracted_bc.as_str().assert().to_string()) }; compose_and_run(config, testfile, proc_args, Vec::new(), "", None, None) } fn count_extracted_lines(p: &Path) -> uint { - let x = File::open(&p.with_extension("ll")).read_to_end().unwrap(); - let x = str::from_utf8(x.as_slice()).unwrap(); + let x = File::open(&p.with_extension("ll")).read_to_end().assert(); + let x = str::from_utf8(x.as_slice()).assert(); x.lines().count() } diff --git a/src/doc/guide-container.md b/src/doc/guide-container.md index 1733f4934c0c2..c16fa730042c2 100644 --- a/src/doc/guide-container.md +++ b/src/doc/guide-container.md @@ -121,11 +121,11 @@ Containers implement iteration over the contained elements by returning an iterator object. For example, for vector slices several iterators are available: * `iter()` for immutable references to the elements -* `mut_iter()` for mutable references to the elements -* `move_iter()` to move the elements out by-value +* `iter_mut()` for mutable references to the elements +* `iter_owned()` to move the elements out by-value -A typical mutable container will implement at least `iter()`, `mut_iter()` and -`move_iter()`. If it maintains an order, the returned iterators will be +A typical mutable container will implement at least `iter()`, `iter_mut()` and +`iter_owned()`. If it maintains an order, the returned iterators will be `DoubleEndedIterator`s, which are described below. ### Freezing @@ -381,7 +381,7 @@ the trailing underscore is a workaround for issue #5898 and will be removed. ~~~ let mut ys = [1i, 2, 3, 4, 5]; -ys.mut_iter().reverse_(); +ys.iter_mut().reverse_(); assert!(ys == [5i, 4, 3, 2, 1]); ~~~ diff --git a/src/doc/guide-strings.md b/src/doc/guide-strings.md index 6c6d6e3689935..6c093aec57172 100644 --- a/src/doc/guide-strings.md +++ b/src/doc/guide-strings.md @@ -68,7 +68,7 @@ You can also get a `&str` from a stack-allocated array of bytes: use std::str; let x: &[u8] = &[b'a', b'b']; -let stack_str: &str = str::from_utf8(x).unwrap(); +let stack_str: &str = str::from_utf8(x).assert(); ``` # Best Practices diff --git a/src/doc/guide-tasks.md b/src/doc/guide-tasks.md index 6ef273e7a1a59..5b995df89d934 100644 --- a/src/doc/guide-tasks.md +++ b/src/doc/guide-tasks.md @@ -307,7 +307,7 @@ fn main() { let mut futures = Vec::from_fn(1000, |ind| Future::spawn( proc() { partial_sum(ind) })); let mut final_res = 0f64; - for ft in futures.mut_iter() { + for ft in futures.iter_mut() { final_res += ft.get(); } println!("π^2/6 is not far from : {}", final_res); diff --git a/src/doc/tutorial.md b/src/doc/tutorial.md index 889ffba65518e..2ccdd31a53321 100644 --- a/src/doc/tutorial.md +++ b/src/doc/tutorial.md @@ -1135,11 +1135,11 @@ let ys = xs; // copies `Cons(u32, pointer)` shallowly > *Note:* Names like `xs` and `ys` are a naming > convention for collection-like data structures -> (like our `List`). These collections are given -> names appended with 's' to signify plurality, -> i.e. that the data structure stores multiple -> elements. For example, `xs` in this case can -> be read as "a list of ex-es", where "x" here +> (like our `List`). These collections are given +> names appended with 's' to signify plurality, +> i.e. that the data structure stores multiple +> elements. For example, `xs` in this case can +> be read as "a list of ex-es", where "x" here > are elements of type `u32`. @@ -1648,7 +1648,7 @@ numbers.push(4); numbers.push(5); // The type of a unique vector is written as `Vec` -let more_numbers: Vec = numbers.move_iter().map(|i| i+1).collect(); +let more_numbers: Vec = numbers.iter_owned().map(|i| i+1).collect(); // The original `numbers` value can no longer be used, due to move semantics. @@ -1692,7 +1692,7 @@ alter the length. ~~~ let mut xs = [1i, 2i, 3i]; -let view = xs.mut_slice(0, 2); +let view = xs.slice_mut(0, 2); view[0] = 5; // The type of a mutable slice is written as `&mut [T]` diff --git a/src/grammar/verify.rs b/src/grammar/verify.rs index f2ae5a1ea4e51..aa1703e693d76 100644 --- a/src/grammar/verify.rs +++ b/src/grammar/verify.rs @@ -209,8 +209,8 @@ fn parse_antlr_token(s: &str, tokens: &HashMap) -> TokenAndSpan { }; let sp = syntax::codemap::Span { - lo: syntax::codemap::BytePos(from_str::(start).unwrap() - offset), - hi: syntax::codemap::BytePos(from_str::(end).unwrap() + 1), + lo: syntax::codemap::BytePos(from_str::(start).assert() - offset), + hi: syntax::codemap::BytePos(from_str::(end).assert() + 1), expn_info: None }; @@ -239,13 +239,13 @@ fn main() { let args = std::os::args(); let mut token_file = File::open(&Path::new(args.get(2).as_slice())); - let token_map = parse_token_list(token_file.read_to_string().unwrap().as_slice()); + let token_map = parse_token_list(token_file.read_to_string().assert().as_slice()); let mut stdin = std::io::stdin(); - let mut antlr_tokens = stdin.lines().map(|l| parse_antlr_token(l.unwrap().as_slice().trim(), + let mut antlr_tokens = stdin.lines().map(|l| parse_antlr_token(l.assert().as_slice().trim(), &token_map)); - let code = File::open(&Path::new(args.get(1).as_slice())).unwrap().read_to_string().unwrap(); + let code = File::open(&Path::new(args.get(1).as_slice())).assert().read_to_string().assert(); let options = config::basic_options(); let session = session::build_session(options, None, syntax::diagnostics::registry::Registry::new([])); diff --git a/src/liballoc/arc.rs b/src/liballoc/arc.rs index 1d6714430a8ed..48273d8b620e6 100644 --- a/src/liballoc/arc.rs +++ b/src/liballoc/arc.rs @@ -375,7 +375,7 @@ mod tests { let cow1_weak = cow0.downgrade(); assert!(75 == *cow0); - assert!(75 == *cow1_weak.upgrade().unwrap()); + assert!(75 == *cow1_weak.upgrade().assert()); *cow0.make_unique() += 1; diff --git a/src/liballoc/heap.rs b/src/liballoc/heap.rs index 3175c516d8eff..7b3a0f085e8b2 100644 --- a/src/liballoc/heap.rs +++ b/src/liballoc/heap.rs @@ -131,7 +131,7 @@ unsafe fn closure_exchange_malloc(drop_glue: fn(*mut u8), size: uint, #[cfg(jemalloc)] mod imp { use core::option::{None, Option}; - use core::ptr::{RawPtr, mut_null, null}; + use core::ptr::{RawPtr, null_mut, null}; use core::num::Int; use libc::{c_char, c_int, c_void, size_t}; @@ -201,7 +201,7 @@ mod imp { pub fn stats_print() { unsafe { - je_malloc_stats_print(None, mut_null(), null()) + je_malloc_stats_print(None, null_mut(), null()) } } } diff --git a/src/liballoc/libc_heap.rs b/src/liballoc/libc_heap.rs index 25938ba0d5448..87c515f306019 100644 --- a/src/liballoc/libc_heap.rs +++ b/src/liballoc/libc_heap.rs @@ -12,7 +12,7 @@ //! The global (exchange) heap. use libc::{c_void, size_t, free, malloc, realloc}; -use core::ptr::{RawPtr, mut_null}; +use core::ptr::{RawPtr, null_mut}; /// A wrapper around libc::malloc, aborting on out-of-memory #[inline] @@ -20,7 +20,7 @@ pub unsafe fn malloc_raw(size: uint) -> *mut u8 { // `malloc(0)` may allocate, but it may also return a null pointer // http://pubs.opengroup.org/onlinepubs/9699919799/functions/malloc.html if size == 0 { - mut_null() + null_mut() } else { let p = malloc(size as size_t); if p.is_null() { @@ -37,7 +37,7 @@ pub unsafe fn realloc_raw(ptr: *mut u8, size: uint) -> *mut u8 { // http://pubs.opengroup.org/onlinepubs/9699919799/functions/realloc.html if size == 0 { free(ptr as *mut c_void); - mut_null() + null_mut() } else { let p = realloc(ptr as *mut c_void, size as size_t); if p.is_null() { diff --git a/src/liballoc/rc.rs b/src/liballoc/rc.rs index 060f9875bfcf9..c4221b054c81b 100644 --- a/src/liballoc/rc.rs +++ b/src/liballoc/rc.rs @@ -135,7 +135,7 @@ fn main() { // that their object is still alive, we need to call upgrade() on them // to turn them into a strong reference. This returns an Option, which // contains a reference to our object if it still exists. - let gadget = gadget_opt.upgrade().unwrap(); + let gadget = gadget_opt.upgrade().assert(); println!("Gadget {} owned by {}", gadget.id, gadget.owner.name); } @@ -272,7 +272,7 @@ pub fn try_unwrap(rc: Rc) -> Result> { /// ``` /// use std::rc::{mod, Rc}; /// let mut x = Rc::new(3u); -/// *rc::get_mut(&mut x).unwrap() = 4u; +/// *rc::get_mut(&mut x).assert() = 4u; /// assert_eq!(*x, 4u); /// let _y = x.clone(); /// assert!(rc::get_mut(&mut x).is_none()); @@ -591,7 +591,7 @@ mod tests { #[test] fn get_mut() { let mut x = Rc::new(3u); - *super::get_mut(&mut x).unwrap() = 4u; + *super::get_mut(&mut x).assert() = 4u; assert_eq!(*x, 4u); let y = x.clone(); assert!(super::get_mut(&mut x).is_none()); @@ -654,7 +654,7 @@ mod tests { let cow1_weak = cow0.downgrade(); assert!(75 == *cow0); - assert!(75 == *cow1_weak.upgrade().unwrap()); + assert!(75 == *cow1_weak.upgrade().assert()); *cow0.make_unique() += 1; diff --git a/src/libarena/lib.rs b/src/libarena/lib.rs index 5d316cdb51e37..9157521eea0da 100644 --- a/src/libarena/lib.rs +++ b/src/libarena/lib.rs @@ -129,7 +129,7 @@ impl Drop for Arena { #[inline] fn round_up(base: uint, align: uint) -> uint { - (base.checked_add(&(align - 1))).unwrap() & !(&(align - 1)) + (base.checked_add(&(align - 1))).assert() & !(&(align - 1)) } // Walk down a chunk, running the destructors for any objects stored @@ -378,8 +378,8 @@ impl TypedArenaChunk { let mut size = mem::size_of::>(); size = round_up(size, mem::min_align_of::()); let elem_size = mem::size_of::(); - let elems_size = elem_size.checked_mul(&capacity).unwrap(); - size = size.checked_add(&elems_size).unwrap(); + let elems_size = elem_size.checked_mul(&capacity).assert(); + size = size.checked_add(&elems_size).assert(); let mut chunk = unsafe { let chunk = allocate(size, mem::min_align_of::>()); @@ -431,7 +431,7 @@ impl TypedArenaChunk { #[inline] fn end(&self) -> *const u8 { unsafe { - let size = mem::size_of::().checked_mul(&self.capacity).unwrap(); + let size = mem::size_of::().checked_mul(&self.capacity).assert(); self.start().offset(size as int) } } @@ -476,8 +476,8 @@ impl TypedArena { /// Grows the arena. #[inline(never)] fn grow(&self) { - let chunk = self.first.borrow_mut().take_unwrap(); - let new_capacity = chunk.capacity.checked_mul(&2).unwrap(); + let chunk = self.first.borrow_mut().take().assert(); + let new_capacity = chunk.capacity.checked_mul(&2).assert(); let chunk = TypedArenaChunk::::new(Some(chunk), new_capacity); self.ptr.set(chunk.start() as *const T); self.end.set(chunk.end() as *const T); @@ -489,13 +489,13 @@ impl TypedArena { impl Drop for TypedArena { fn drop(&mut self) { // Determine how much was filled. - let start = self.first.borrow().get_ref().start() as uint; + let start = self.first.borrow().as_ref().assert().start() as uint; let end = self.ptr.get() as uint; let diff = (end - start) / mem::size_of::(); // Pass that to the `destroy` method. unsafe { - self.first.borrow_mut().get_mut_ref().destroy(diff) + self.first.borrow_mut().as_mut().assert().destroy(diff) } } } diff --git a/src/libcollections/bitv.rs b/src/libcollections/bitv.rs index 14d4f90a077cf..8b4fc58835868 100644 --- a/src/libcollections/bitv.rs +++ b/src/libcollections/bitv.rs @@ -55,7 +55,7 @@ //! println!(""); //! //! // We can manipulate the internal Bitv -//! let num_primes = primes.get_ref().iter().filter(|x| *x).count(); +//! let num_primes = primes.as_bitv().iter().filter(|x| *x).count(); //! println!("There are {} primes below {}", num_primes, max_prime); //! ``` @@ -177,7 +177,7 @@ impl Bitv { // `op` is a bitwise operation, since any bits that should've // been masked were fine to change anyway. `b` is masked to // make sure its unmasked bits do not cause damage. - for (a, (_, b)) in self.storage.mut_iter() + for (a, (_, b)) in self.storage.iter_mut() .zip(other.mask_words(0)) { let w = op(*a, b); if *a != w { @@ -309,7 +309,7 @@ impl Bitv { /// ``` #[inline] pub fn set_all(&mut self) { - for w in self.storage.mut_iter() { *w = !0u; } + for w in self.storage.iter_mut() { *w = !0u; } } /// Flip all bits. @@ -328,7 +328,7 @@ impl Bitv { /// ``` #[inline] pub fn negate(&mut self) { - for w in self.storage.mut_iter() { *w = !*w; } + for w in self.storage.iter_mut() { *w = !*w; } } /// Calculate the union of two bitvectors, acts like bitwise or. @@ -793,7 +793,7 @@ impl Collection for Bitv { impl Mutable for Bitv { #[inline] fn clear(&mut self) { - for w in self.storage.mut_iter() { *w = 0u; } + for w in self.storage.iter_mut() { *w = 0u; } } } @@ -827,7 +827,7 @@ impl Clone for Bitv { fn clone_from(&mut self, source: &Bitv) { self.nbits = source.nbits; self.storage.reserve(source.storage.len()); - for (i, w) in self.storage.mut_iter().enumerate() { *w = *source.storage.get(i); } + for (i, w) in self.storage.iter_mut().enumerate() { *w = *source.storage.get(i); } } } @@ -966,7 +966,7 @@ impl<'a> RandomAccessIterator for Bits<'a> { /// } /// /// // Can convert back to a `Bitv` -/// let bv: Bitv = s.unwrap(); +/// let bv: Bitv = s.into_bitv(); /// assert!(bv.eq_vec([true, true, false, true, /// false, false, false, false])); /// ``` @@ -989,7 +989,7 @@ impl FromIterator for BitvSet { impl Extendable for BitvSet { #[inline] fn extend>(&mut self, iterator: I) { - self.get_mut_ref().extend(iterator); + self.as_bitv_mut().extend(iterator); } } @@ -1075,6 +1075,8 @@ impl BitvSet { bitv.reserve(size) } + /// Deprecated. Use `into_bitv` instead. + /// /// Consume this set to return the underlying bit vector. /// /// # Example @@ -1086,15 +1088,37 @@ impl BitvSet { /// s.insert(0); /// s.insert(3); /// - /// let bv = s.unwrap(); + /// let bv = s.assert(); /// assert!(bv.eq_vec([true, false, false, true])); /// ``` #[inline] + #[deprecated = "use into_bitv instead"] pub fn unwrap(self) -> Bitv { + self.into_bitv() + } + + /// Consume this set to return the underlying bit vector. + /// + /// # Example + /// + /// ``` + /// use std::collections::BitvSet; + /// + /// let mut s = BitvSet::new(); + /// s.insert(0); + /// s.insert(3); + /// + /// let bv = s.into_bitv(); + /// assert!(bv.eq_vec([true, false, false, true])); + /// ``` + #[inline] + pub fn into_bitv(self) -> Bitv { let BitvSet(bitv) = self; bitv } + /// Deprecated. Use `as_bitv` instead. + /// /// Return a reference to the underlying bit vector. /// /// # Example @@ -1105,15 +1129,59 @@ impl BitvSet { /// let mut s = BitvSet::new(); /// s.insert(0); /// - /// let bv = s.get_ref(); + /// let bv = s.as_bitv(); /// assert_eq!(bv[0], true); /// ``` #[inline] - pub fn get_ref<'a>(&'a self) -> &'a Bitv { + #[deprecated = "use as_bitv instead"] + pub fn get_ref(&self) -> &Bitv { + self.as_bitv() + } + + /// Return a reference to the underlying bit vector. + /// + /// # Example + /// + /// ``` + /// use std::collections::BitvSet; + /// + /// let mut s = BitvSet::new(); + /// s.insert(0); + /// + /// let bv = s.as_bitv(); + /// assert_eq!(bv[0], true); + /// ``` + #[inline] + pub fn as_bitv(&self) -> &Bitv { let &BitvSet(ref bitv) = self; bitv } + /// Deprecated. Use `as_bitv_mut` instead. + /// + /// Return a mutable reference to the underlying bit vector. + /// + /// # Example + /// + /// ``` + /// use std::collections::BitvSet; + /// + /// let mut s = BitvSet::new(); + /// s.insert(0); + /// assert_eq!(s.contains(&0), true); + /// { + /// // Will free the set during bv's lifetime + /// let bv = s.as_bitv_mut(); + /// bv.set(0, false); + /// } + /// assert_eq!(s.contains(&0), false); + /// ``` + #[inline] + #[deprecated = "use as_bitv_mut instead"] + pub fn get_mut_ref(&mut self) -> &mut Bitv { + self.as_bitv_mut() + } + /// Return a mutable reference to the underlying bit vector. /// /// # Example @@ -1126,13 +1194,13 @@ impl BitvSet { /// assert_eq!(s.contains(&0), true); /// { /// // Will free the set during bv's lifetime - /// let bv = s.get_mut_ref(); + /// let bv = s.as_bitv_mut(); /// bv.set(0, false); /// } /// assert_eq!(s.contains(&0), false); /// ``` #[inline] - pub fn get_mut_ref<'a>(&'a mut self) -> &'a mut Bitv { + pub fn as_bitv_mut(&mut self) -> &mut Bitv { let &BitvSet(ref mut bitv) = self; bitv } @@ -1340,7 +1408,7 @@ impl BitvSet { /// let b = BitvSet::from_bitv(bitv::from_bytes([b])); /// /// a.union_with(&b); - /// assert_eq!(a.unwrap(), bitv::from_bytes([res])); + /// assert_eq!(a.assert(), bitv::from_bytes([res])); /// ``` #[inline] pub fn union_with(&mut self, other: &BitvSet) { @@ -1363,7 +1431,7 @@ impl BitvSet { /// let b = BitvSet::from_bitv(bitv::from_bytes([b])); /// /// a.intersect_with(&b); - /// assert_eq!(a.unwrap(), bitv::from_bytes([res])); + /// assert_eq!(a.assert(), bitv::from_bytes([res])); /// ``` #[inline] pub fn intersect_with(&mut self, other: &BitvSet) { @@ -1387,13 +1455,13 @@ impl BitvSet { /// let bvb = BitvSet::from_bitv(bitv::from_bytes([b])); /// /// bva.difference_with(&bvb); - /// assert_eq!(bva.unwrap(), bitv::from_bytes([a_b])); + /// assert_eq!(bva.into_bitv(), bitv::from_bytes([a_b])); /// /// let bva = BitvSet::from_bitv(bitv::from_bytes([a])); /// let mut bvb = BitvSet::from_bitv(bitv::from_bytes([b])); /// /// bvb.difference_with(&bva); - /// assert_eq!(bvb.unwrap(), bitv::from_bytes([b_a])); + /// assert_eq!(bvb.into_bitv(), bitv::from_bytes([b_a])); /// ``` #[inline] pub fn difference_with(&mut self, other: &BitvSet) { @@ -1416,7 +1484,7 @@ impl BitvSet { /// let b = BitvSet::from_bitv(bitv::from_bytes([b])); /// /// a.symmetric_difference_with(&b); - /// assert_eq!(a.unwrap(), bitv::from_bytes([res])); + /// assert_eq!(a.into_bitv(), bitv::from_bytes([res])); /// ``` #[inline] pub fn symmetric_difference_with(&mut self, other: &BitvSet) { diff --git a/src/libcollections/btree.rs b/src/libcollections/btree.rs index 947c87daa8460..7f09719d4123c 100644 --- a/src/libcollections/btree.rs +++ b/src/libcollections/btree.rs @@ -378,7 +378,7 @@ impl Leaf { //upper bound), we return a new Branch with one element and two children. if self.elts.len() > ub { let midpoint_opt = self.elts.remove(ub / 2); - let midpoint = midpoint_opt.unwrap(); + let midpoint = midpoint_opt.assert(); let (left_leaf, right_leaf) = self.elts.partition(|le| le.key.cmp(&midpoint.key.clone()) == Less); @@ -568,11 +568,11 @@ impl Branch { //If we have a new leaf node, integrate it into the current branch //and return it, saying we have inserted a new element. LeafNode(..) => { - if index.unwrap() == self.elts.len() { + if index.assert() == self.elts.len() { self.rightmost_child = box new_branch; } else { - self.elts.get_mut(index.unwrap()).left = box new_branch; + self.elts.get_mut(index.assert()).left = box new_branch; } return (Node::new_branch(self.clone().elts, self.clone().rightmost_child), @@ -605,7 +605,7 @@ impl Branch { //If the current node is overfilled, create a new branch with one element //and two children. if self.elts.len() > ub { - let midpoint = self.elts.remove(ub / 2).unwrap(); + let midpoint = self.elts.remove(ub / 2).assert(); let (new_left, new_right) = self.clone().elts.partition(|le| midpoint.key.cmp(&le.key) == Greater); diff --git a/src/libcollections/dlist.rs b/src/libcollections/dlist.rs index 3d322729aab43..a4e28f254fa36 100644 --- a/src/libcollections/dlist.rs +++ b/src/libcollections/dlist.rs @@ -62,24 +62,32 @@ impl<'a, T> Clone for Items<'a, T> { } /// Double-ended mutable DList iterator -pub struct MutItems<'a, T> { +pub struct ItemsMut<'a, T> { list: &'a mut DList, head: Rawlink>, tail: Rawlink>, nelem: uint, } +/// Deprecated: renamed to `ItemsMut`. +#[deprecated = "renamed to ItemsMut"] +pub type MutItems<'a, T> = ItemsMut<'a, T>; + /// DList consuming iterator #[deriving(Clone)] -pub struct MoveItems { +pub struct ItemsOwned { list: DList } +/// Deprecated: renamed to `ItemsOwned`. +#[deprecated = "renamed to ItemsOwned"] +pub type MoveItems = ItemsOwned; + /// Rawlink is a type like Option but for holding a raw pointer impl Rawlink { /// Like Option::None for Rawlink fn none() -> Rawlink { - Rawlink{p: ptr::mut_null()} + Rawlink{p: ptr::null_mut()} } /// Like Option::Some for Rawlink @@ -421,7 +429,7 @@ impl DList { /// ``` pub fn insert_when(&mut self, elt: T, f: |&T, &T| -> bool) { { - let mut it = self.mut_iter(); + let mut it = self.iter_mut(); loop { match it.peek_next() { None => break, @@ -440,7 +448,7 @@ impl DList { /// O(max(N, M)) pub fn merge(&mut self, mut other: DList, f: |&T, &T| -> bool) { { - let mut it = self.mut_iter(); + let mut it = self.iter_mut(); loop { let take_a = match (it.peek_next(), other.front()) { (_ , None) => return, @@ -450,7 +458,7 @@ impl DList { if take_a { it.next(); } else { - it.insert_next_node(other.pop_front_node().unwrap()); + it.insert_next_node(other.pop_front_node().assert()); } } } @@ -460,18 +468,23 @@ impl DList { /// Provide a forward iterator #[inline] - pub fn iter<'a>(&'a self) -> Items<'a, T> { + pub fn iter(&self) -> Items { Items{nelem: self.len(), head: &self.list_head, tail: self.list_tail} } + /// Deprecated. Use `iter_mut` instead. + #[inline] + #[deprecated = "use iter_mut instead"] + pub fn mut_iter(&mut self) -> ItemsMut { self.iter_mut() } + /// Provide a forward iterator with mutable references #[inline] - pub fn mut_iter<'a>(&'a mut self) -> MutItems<'a, T> { + pub fn iter_mut(&mut self) -> ItemsMut { let head_raw = match self.list_head { Some(ref mut h) => Rawlink::some(&mut **h), None => Rawlink::none(), }; - MutItems{ + ItemsMut{ nelem: self.len(), head: head_raw, tail: self.list_tail, @@ -479,11 +492,14 @@ impl DList { } } + /// Deprecated. Use `iter_owned` instead. + #[inline] + pub fn move_iter(self) -> ItemsOwned { self.iter_owned() } /// Consume the list into an iterator yielding elements by value #[inline] - pub fn move_iter(self) -> MoveItems { - MoveItems{list: self} + pub fn iter_owned(self) -> ItemsOwned { + ItemsOwned{list: self} } } @@ -555,7 +571,7 @@ impl<'a, A> DoubleEndedIterator<&'a A> for Items<'a, A> { impl<'a, A> ExactSize<&'a A> for Items<'a, A> {} -impl<'a, A> Iterator<&'a mut A> for MutItems<'a, A> { +impl<'a, A> Iterator<&'a mut A> for ItemsMut<'a, A> { #[inline] fn next(&mut self) -> Option<&'a mut A> { if self.nelem == 0 { @@ -577,7 +593,7 @@ impl<'a, A> Iterator<&'a mut A> for MutItems<'a, A> { } } -impl<'a, A> DoubleEndedIterator<&'a mut A> for MutItems<'a, A> { +impl<'a, A> DoubleEndedIterator<&'a mut A> for ItemsMut<'a, A> { #[inline] fn next_back(&mut self) -> Option<&'a mut A> { if self.nelem == 0 { @@ -591,7 +607,7 @@ impl<'a, A> DoubleEndedIterator<&'a mut A> for MutItems<'a, A> { } } -impl<'a, A> ExactSize<&'a mut A> for MutItems<'a, A> {} +impl<'a, A> ExactSize<&'a mut A> for ItemsMut<'a, A> {} /// Allow mutating the DList while iterating pub trait ListInsertion { @@ -604,8 +620,8 @@ pub trait ListInsertion { fn peek_next<'a>(&'a mut self) -> Option<&'a mut A>; } -// private methods for MutItems -impl<'a, A> MutItems<'a, A> { +// private methods for ItemsMut +impl<'a, A> ItemsMut<'a, A> { fn insert_next_node(&mut self, mut ins_node: Box>) { // Insert before `self.head` so that it is between the // previously yielded element and self.head. @@ -618,7 +634,7 @@ impl<'a, A> MutItems<'a, A> { None => return self.list.push_front_node(ins_node), Some(prev) => prev, }; - let node_own = prev_node.next.take_unwrap(); + let node_own = prev_node.next.take().assert(); ins_node.next = link_with_prev(node_own, Rawlink::some(&mut *ins_node)); prev_node.next = link_with_prev(ins_node, Rawlink::some(prev_node)); self.list.length += 1; @@ -627,7 +643,7 @@ impl<'a, A> MutItems<'a, A> { } } -impl<'a, A> ListInsertion for MutItems<'a, A> { +impl<'a, A> ListInsertion for ItemsMut<'a, A> { #[inline] fn insert_next(&mut self, elt: A) { self.insert_next_node(box Node::new(elt)) @@ -642,7 +658,7 @@ impl<'a, A> ListInsertion for MutItems<'a, A> { } } -impl Iterator for MoveItems { +impl Iterator for ItemsOwned { #[inline] fn next(&mut self) -> Option { self.list.pop_front() } @@ -652,7 +668,7 @@ impl Iterator for MoveItems { } } -impl DoubleEndedIterator for MoveItems { +impl DoubleEndedIterator for ItemsOwned { #[inline] fn next_back(&mut self) -> Option { self.list.pop_back() } } @@ -795,14 +811,14 @@ mod tests { n.push_front(2i); n.push_front(3); { - assert_eq!(n.front().unwrap(), &3); - let x = n.front_mut().unwrap(); + assert_eq!(n.front().assert(), &3); + let x = n.front_mut().assert(); assert_eq!(*x, 3); *x = 0; } { - assert_eq!(n.back().unwrap(), &2); - let y = n.back_mut().unwrap(); + assert_eq!(n.back().assert(), &2); + let y = n.back_mut().assert(); assert_eq!(*y, 2); *y = 1; } @@ -848,7 +864,7 @@ mod tests { check_links(&m); let sum = v.append(u.as_slice()); assert_eq!(sum.len(), m.len()); - for elt in sum.move_iter() { + for elt in sum.iter_owned() { assert_eq!(m.pop_front(), Some(elt)) } } @@ -872,7 +888,7 @@ mod tests { check_links(&m); let sum = u.append(v.as_slice()); assert_eq!(sum.len(), m.len()); - for elt in sum.move_iter() { + for elt in sum.iter_owned() { assert_eq!(m.pop_front(), Some(elt)) } } @@ -897,7 +913,7 @@ mod tests { m.rotate_backward(); check_links(&m); m.push_front(9); check_links(&m); m.rotate_forward(); check_links(&m); - assert_eq!(vec![3i,9,5,1,2], m.move_iter().collect()); + assert_eq!(vec![3i,9,5,1,2], m.iter_owned().collect()); } #[test] @@ -911,7 +927,7 @@ mod tests { n.push_front(4i); let mut it = n.iter(); assert_eq!(it.size_hint(), (1, Some(1))); - assert_eq!(it.next().unwrap(), &4); + assert_eq!(it.next().assert(), &4); assert_eq!(it.size_hint(), (0, Some(0))); assert_eq!(it.next(), None); } @@ -939,11 +955,11 @@ mod tests { n.push_front(6); let mut it = n.iter(); assert_eq!(it.size_hint(), (3, Some(3))); - assert_eq!(it.next().unwrap(), &6); + assert_eq!(it.next().assert(), &6); assert_eq!(it.size_hint(), (2, Some(2))); - assert_eq!(it.next_back().unwrap(), &4); + assert_eq!(it.next_back().assert(), &4); assert_eq!(it.size_hint(), (1, Some(1))); - assert_eq!(it.next_back().unwrap(), &5); + assert_eq!(it.next_back().assert(), &5); assert_eq!(it.next_back(), None); assert_eq!(it.next(), None); } @@ -959,7 +975,7 @@ mod tests { n.push_front(4i); let mut it = n.iter().rev(); assert_eq!(it.size_hint(), (1, Some(1))); - assert_eq!(it.next().unwrap(), &4); + assert_eq!(it.next().assert(), &4); assert_eq!(it.size_hint(), (0, Some(0))); assert_eq!(it.next(), None); } @@ -968,16 +984,16 @@ mod tests { fn test_mut_iter() { let mut m = generate_test(); let mut len = m.len(); - for (i, elt) in m.mut_iter().enumerate() { + for (i, elt) in m.iter_mut().enumerate() { assert_eq!(i as int, *elt); len -= 1; } assert_eq!(len, 0); let mut n = DList::new(); - assert!(n.mut_iter().next().is_none()); + assert!(n.iter_mut().next().is_none()); n.push_front(4i); n.push_back(5); - let mut it = n.mut_iter(); + let mut it = n.iter_mut(); assert_eq!(it.size_hint(), (2, Some(2))); assert!(it.next().is_some()); assert!(it.next().is_some()); @@ -988,17 +1004,17 @@ mod tests { #[test] fn test_iterator_mut_double_end() { let mut n = DList::new(); - assert!(n.mut_iter().next_back().is_none()); + assert!(n.iter_mut().next_back().is_none()); n.push_front(4i); n.push_front(5); n.push_front(6); - let mut it = n.mut_iter(); + let mut it = n.iter_mut(); assert_eq!(it.size_hint(), (3, Some(3))); - assert_eq!(*it.next().unwrap(), 6); + assert_eq!(*it.next().assert(), 6); assert_eq!(it.size_hint(), (2, Some(2))); - assert_eq!(*it.next_back().unwrap(), 4); + assert_eq!(*it.next_back().assert(), 4); assert_eq!(it.size_hint(), (1, Some(1))); - assert_eq!(*it.next_back().unwrap(), 5); + assert_eq!(*it.next_back().assert(), 5); assert!(it.next_back().is_none()); assert!(it.next().is_none()); } @@ -1008,7 +1024,7 @@ mod tests { let mut m = list_from(&[0i,2,4,6,8]); let len = m.len(); { - let mut it = m.mut_iter(); + let mut it = m.iter_mut(); it.insert_next(-2); loop { match it.next() { @@ -1027,7 +1043,7 @@ mod tests { } check_links(&m); assert_eq!(m.len(), 3 + len * 2); - assert_eq!(m.move_iter().collect::>(), vec![-2,0,1,2,3,4,5,6,7,8,9,0,1]); + assert_eq!(m.iter_owned().collect::>(), vec![-2,0,1,2,3,4,5,6,7,8,9,0,1]); } #[test] @@ -1038,7 +1054,7 @@ mod tests { m.merge(n, |a, b| a <= b); assert_eq!(m.len(), len); check_links(&m); - let res = m.move_iter().collect::>(); + let res = m.iter_owned().collect::>(); assert_eq!(res, vec![-1, 0, 0, 0, 1, 3, 5, 6, 7, 2, 7, 7, 9]); } @@ -1054,19 +1070,19 @@ mod tests { m.push_back(4); m.insert_ordered(3); check_links(&m); - assert_eq!(vec![2,3,4], m.move_iter().collect::>()); + assert_eq!(vec![2,3,4], m.iter_owned().collect::>()); } #[test] fn test_mut_rev_iter() { let mut m = generate_test(); - for (i, elt) in m.mut_iter().rev().enumerate() { + for (i, elt) in m.iter_mut().rev().enumerate() { assert_eq!((6-i) as int, *elt); } let mut n = DList::new(); - assert!(n.mut_iter().rev().next().is_none()); + assert!(n.iter_mut().rev().next().is_none()); n.push_front(4i); - let mut it = n.mut_iter().rev(); + let mut it = n.iter_mut().rev(); assert!(it.next().is_some()); assert!(it.next().is_none()); } @@ -1205,7 +1221,7 @@ mod tests { check_links(&m); let mut i = 0u; - for (a, &b) in m.move_iter().zip(v.iter()) { + for (a, &b) in m.iter_owned().zip(v.iter()) { i += 1; assert_eq!(a, b); } @@ -1287,7 +1303,7 @@ mod tests { let v = &[0i, ..128]; let mut m: DList = v.iter().map(|&x|x).collect(); b.iter(|| { - assert!(m.mut_iter().count() == 128); + assert!(m.iter_mut().count() == 128); }) } #[bench] @@ -1303,7 +1319,7 @@ mod tests { let v = &[0i, ..128]; let mut m: DList = v.iter().map(|&x|x).collect(); b.iter(|| { - assert!(m.mut_iter().rev().count() == 128); + assert!(m.iter_mut().rev().count() == 128); }) } } diff --git a/src/libcollections/lib.rs b/src/libcollections/lib.rs index d2d8ad696d7c5..a708d07b2712f 100644 --- a/src/libcollections/lib.rs +++ b/src/libcollections/lib.rs @@ -366,7 +366,7 @@ pub trait MutableSeq: Mutable { /// /// // Will print 1, 2, 3 /// while !queue.is_empty() { -/// let x = queue.pop_front().unwrap(); +/// let x = queue.pop_front().assert(); /// println!("{}", x); /// } /// ``` @@ -383,7 +383,7 @@ pub trait MutableSeq: Mutable { /// /// // Will print 3, 2, 1 /// while !stack.is_empty() { -/// let x = stack.pop_front().unwrap(); +/// let x = stack.pop_front().assert(); /// println!("{}", x); /// } /// ``` @@ -403,8 +403,8 @@ pub trait MutableSeq: Mutable { /// /// // Will print (1, 4) and (2, 3) /// while !deque.is_empty() { -/// let f = deque.pop_front().unwrap(); -/// let b = deque.pop().unwrap(); +/// let f = deque.pop_front().assert(); +/// let b = deque.pop().assert(); /// println!("{}", (f, b)); /// } /// ``` diff --git a/src/libcollections/priority_queue.rs b/src/libcollections/priority_queue.rs index bf2c8c83d87b6..24959046b959c 100644 --- a/src/libcollections/priority_queue.rs +++ b/src/libcollections/priority_queue.rs @@ -377,7 +377,7 @@ impl PriorityQueue { /// assert_eq!(pq.top(), Some(&3i)); /// ``` pub fn push_pop(&mut self, mut item: T) -> T { - if !self.is_empty() && *self.top().unwrap() > item { + if !self.is_empty() && *self.top().assert() > item { swap(&mut item, self.data.get_mut(0)); self.siftdown(0); } @@ -574,8 +574,8 @@ mod tests { sorted.sort(); let mut heap = PriorityQueue::from_vec(data); while !heap.is_empty() { - assert_eq!(heap.top().unwrap(), sorted.last().unwrap()); - assert_eq!(heap.pop().unwrap(), sorted.pop().unwrap()); + assert_eq!(heap.top().assert(), sorted.last().assert()); + assert_eq!(heap.pop().assert(), sorted.pop().assert()); } } @@ -583,44 +583,44 @@ mod tests { fn test_push() { let mut heap = PriorityQueue::from_vec(vec!(2i, 4, 9)); assert_eq!(heap.len(), 3); - assert!(*heap.top().unwrap() == 9); + assert!(*heap.top().assert() == 9); heap.push(11); assert_eq!(heap.len(), 4); - assert!(*heap.top().unwrap() == 11); + assert!(*heap.top().assert() == 11); heap.push(5); assert_eq!(heap.len(), 5); - assert!(*heap.top().unwrap() == 11); + assert!(*heap.top().assert() == 11); heap.push(27); assert_eq!(heap.len(), 6); - assert!(*heap.top().unwrap() == 27); + assert!(*heap.top().assert() == 27); heap.push(3); assert_eq!(heap.len(), 7); - assert!(*heap.top().unwrap() == 27); + assert!(*heap.top().assert() == 27); heap.push(103); assert_eq!(heap.len(), 8); - assert!(*heap.top().unwrap() == 103); + assert!(*heap.top().assert() == 103); } #[test] fn test_push_unique() { let mut heap = PriorityQueue::from_vec(vec!(box 2i, box 4, box 9)); assert_eq!(heap.len(), 3); - assert!(*heap.top().unwrap() == box 9); + assert!(*heap.top().assert() == box 9); heap.push(box 11); assert_eq!(heap.len(), 4); - assert!(*heap.top().unwrap() == box 11); + assert!(*heap.top().assert() == box 11); heap.push(box 5); assert_eq!(heap.len(), 5); - assert!(*heap.top().unwrap() == box 11); + assert!(*heap.top().assert() == box 11); heap.push(box 27); assert_eq!(heap.len(), 6); - assert!(*heap.top().unwrap() == box 27); + assert!(*heap.top().assert() == box 27); heap.push(box 3); assert_eq!(heap.len(), 7); - assert!(*heap.top().unwrap() == box 27); + assert!(*heap.top().assert() == box 27); heap.push(box 103); assert_eq!(heap.len(), 8); - assert!(*heap.top().unwrap() == box 103); + assert!(*heap.top().assert() == box 103); } #[test] @@ -641,13 +641,13 @@ mod tests { fn test_replace() { let mut heap = PriorityQueue::from_vec(vec!(5i, 5, 2, 1, 3)); assert_eq!(heap.len(), 5); - assert_eq!(heap.replace(6).unwrap(), 5); + assert_eq!(heap.replace(6).assert(), 5); assert_eq!(heap.len(), 5); - assert_eq!(heap.replace(0).unwrap(), 6); + assert_eq!(heap.replace(0).assert(), 6); assert_eq!(heap.len(), 5); - assert_eq!(heap.replace(4).unwrap(), 5); + assert_eq!(heap.replace(4).assert(), 5); assert_eq!(heap.len(), 5); - assert_eq!(heap.replace(1).unwrap(), 4); + assert_eq!(heap.replace(1).assert(), 4); assert_eq!(heap.len(), 5); } @@ -703,7 +703,7 @@ mod tests { let mut q: PriorityQueue = xs.as_slice().iter().rev().map(|&x| x).collect(); for &x in xs.iter() { - assert_eq!(q.pop().unwrap(), x); + assert_eq!(q.pop().assert(), x); } } } diff --git a/src/libcollections/ringbuf.rs b/src/libcollections/ringbuf.rs index 84b5c5bb9985b..048b4bc34d3b1 100644 --- a/src/libcollections/ringbuf.rs +++ b/src/libcollections/ringbuf.rs @@ -44,7 +44,7 @@ impl Collection for RingBuf { impl Mutable for RingBuf { /// Clear the RingBuf, removing all values. fn clear(&mut self) { - for x in self.elts.mut_iter() { *x = None } + for x in self.elts.iter_mut() { *x = None } self.nelts = 0; self.lo = 0; } @@ -249,10 +249,14 @@ impl RingBuf { /// buf.push(4); /// assert_eq!(buf.iter().collect::>().as_slice(), &[&5, &3, &4]); /// ``` - pub fn iter<'a>(&'a self) -> Items<'a, T> { + pub fn iter(&self) -> Items { Items{index: 0, rindex: self.nelts, lo: self.lo, elts: self.elts.as_slice()} } + /// Deprecated. Use `iter_mut` instead. + #[deprecated = "use iter_mut instead"] + pub fn mut_iter(&mut self) -> ItemsMut { self.iter_mut() } + /// Front-to-back iterator which returns mutable values. /// /// # Example @@ -264,12 +268,12 @@ impl RingBuf { /// buf.push(5i); /// buf.push(3); /// buf.push(4); - /// for num in buf.mut_iter() { + /// for num in buf.iter_mut() { /// *num = *num - 2; /// } - /// assert_eq!(buf.mut_iter().collect::>().as_slice(), &[&mut 3, &mut 1, &mut 2]); + /// assert_eq!(buf.iter_mut().collect::>().as_slice(), &[&mut 3, &mut 1, &mut 2]); /// ``` - pub fn mut_iter<'a>(&'a mut self) -> MutItems<'a, T> { + pub fn iter_mut(&mut self) -> ItemsMut { let start_index = raw_index(self.lo, self.elts.len(), 0); let end_index = raw_index(self.lo, self.elts.len(), self.nelts); @@ -279,16 +283,16 @@ impl RingBuf { // start_index to self.elts.len() // and then // 0 to end_index - let (temp, remaining1) = self.elts.mut_split_at(start_index); - let (remaining2, _) = temp.mut_split_at(end_index); - MutItems { remaining1: remaining1, + let (temp, remaining1) = self.elts.split_at_mut(start_index); + let (remaining2, _) = temp.split_at_mut(end_index); + ItemsMut { remaining1: remaining1, remaining2: remaining2, nelts: self.nelts } } else { // Items to iterate goes from start_index to end_index: - let (empty, elts) = self.elts.mut_split_at(0); - let remaining1 = elts.mut_slice(start_index, end_index); - MutItems { remaining1: remaining1, + let (empty, elts) = self.elts.split_at_mut(0); + let remaining1 = elts.slice_mut(start_index, end_index); + ItemsMut { remaining1: remaining1, remaining2: empty, nelts: self.nelts } } @@ -311,7 +315,7 @@ impl<'a, T> Iterator<&'a T> for Items<'a, T> { } let raw_index = raw_index(self.lo, self.elts.len(), self.index); self.index += 1; - Some(self.elts[raw_index].get_ref()) + Some(self.elts[raw_index].as_ref().assert()) } #[inline] @@ -329,7 +333,7 @@ impl<'a, T> DoubleEndedIterator<&'a T> for Items<'a, T> { } self.rindex -= 1; let raw_index = raw_index(self.lo, self.elts.len(), self.rindex); - Some(self.elts[raw_index].get_ref()) + Some(self.elts[raw_index].as_ref().assert()) } } @@ -345,19 +349,19 @@ impl<'a, T> RandomAccessIterator<&'a T> for Items<'a, T> { None } else { let raw_index = raw_index(self.lo, self.elts.len(), self.index + j); - Some(self.elts[raw_index].get_ref()) + Some(self.elts[raw_index].as_ref().assert()) } } } /// RingBuf mutable iterator -pub struct MutItems<'a, T> { +pub struct ItemsMut<'a, T> { remaining1: &'a mut [Option], remaining2: &'a mut [Option], nelts: uint, } -impl<'a, T> Iterator<&'a mut T> for MutItems<'a, T> { +impl<'a, T> Iterator<&'a mut T> for ItemsMut<'a, T> { #[inline] fn next(&mut self) -> Option<&'a mut T> { if self.nelts == 0 { @@ -370,7 +374,7 @@ impl<'a, T> Iterator<&'a mut T> for MutItems<'a, T> { &mut self.remaining2 }; self.nelts -= 1; - Some(r.mut_shift_ref().unwrap().get_mut_ref()) + Some(r.shift_mut().assert().as_mut().assert()) } #[inline] @@ -379,7 +383,7 @@ impl<'a, T> Iterator<&'a mut T> for MutItems<'a, T> { } } -impl<'a, T> DoubleEndedIterator<&'a mut T> for MutItems<'a, T> { +impl<'a, T> DoubleEndedIterator<&'a mut T> for ItemsMut<'a, T> { #[inline] fn next_back(&mut self) -> Option<&'a mut T> { if self.nelts == 0 { @@ -392,11 +396,11 @@ impl<'a, T> DoubleEndedIterator<&'a mut T> for MutItems<'a, T> { &mut self.remaining1 }; self.nelts -= 1; - Some(r.mut_pop_ref().unwrap().get_mut_ref()) + Some(r.pop_mut().assert().as_mut().assert()) } } -impl<'a, T> ExactSize<&'a mut T> for MutItems<'a, T> {} +impl<'a, T> ExactSize<&'a mut T> for ItemsMut<'a, T> {} /// Grow is only called on full elts, so nelts is also len(elts), unlike /// elsewhere. @@ -530,9 +534,9 @@ mod tests { d.push_back(137); assert_eq!(d.len(), 4u); debug!("{:?}", d.front()); - assert_eq!(*d.front().unwrap(), 42); + assert_eq!(*d.front().assert(), 42); debug!("{:?}", d.back()); - assert_eq!(*d.back().unwrap(), 137); + assert_eq!(*d.back().assert(), 137); let mut i = d.pop_front(); debug!("{:?}", i); assert_eq!(i, Some(42)); @@ -610,12 +614,12 @@ mod tests { assert_eq!(deq.len(), 3); deq.push_back(d.clone()); assert_eq!(deq.len(), 4); - assert_eq!((*deq.front().unwrap()).clone(), b.clone()); - assert_eq!((*deq.back().unwrap()).clone(), d.clone()); - assert_eq!(deq.pop_front().unwrap(), b.clone()); - assert_eq!(deq.pop_back().unwrap(), d.clone()); - assert_eq!(deq.pop_back().unwrap(), c.clone()); - assert_eq!(deq.pop_back().unwrap(), a.clone()); + assert_eq!((*deq.front().assert()).clone(), b.clone()); + assert_eq!((*deq.back().assert()).clone(), d.clone()); + assert_eq!(deq.pop_front().assert(), b.clone()); + assert_eq!(deq.pop_back().assert(), d.clone()); + assert_eq!(deq.pop_back().assert(), c.clone()); + assert_eq!(deq.pop_back().assert(), a.clone()); assert_eq!(deq.len(), 0); deq.push_back(c.clone()); assert_eq!(deq.len(), 1); @@ -868,7 +872,7 @@ mod tests { #[test] fn test_mut_rev_iter_wrap() { let mut d = RingBuf::with_capacity(3); - assert!(d.mut_iter().rev().next().is_none()); + assert!(d.iter_mut().rev().next().is_none()); d.push_back(1i); d.push_back(2); @@ -876,29 +880,29 @@ mod tests { assert_eq!(d.pop_front(), Some(1)); d.push_back(4); - assert_eq!(d.mut_iter().rev().map(|x| *x).collect::>(), + assert_eq!(d.iter_mut().rev().map(|x| *x).collect::>(), vec!(4, 3, 2)); } #[test] fn test_mut_iter() { let mut d = RingBuf::new(); - assert!(d.mut_iter().next().is_none()); + assert!(d.iter_mut().next().is_none()); for i in range(0u, 3) { d.push_front(i); } - for (i, elt) in d.mut_iter().enumerate() { + for (i, elt) in d.iter_mut().enumerate() { assert_eq!(*elt, 2 - i); *elt = i; } { - let mut it = d.mut_iter(); - assert_eq!(*it.next().unwrap(), 0); - assert_eq!(*it.next().unwrap(), 1); - assert_eq!(*it.next().unwrap(), 2); + let mut it = d.iter_mut(); + assert_eq!(*it.next().assert(), 0); + assert_eq!(*it.next().assert(), 1); + assert_eq!(*it.next().assert(), 2); assert!(it.next().is_none()); } } @@ -906,22 +910,22 @@ mod tests { #[test] fn test_mut_rev_iter() { let mut d = RingBuf::new(); - assert!(d.mut_iter().rev().next().is_none()); + assert!(d.iter_mut().rev().next().is_none()); for i in range(0u, 3) { d.push_front(i); } - for (i, elt) in d.mut_iter().rev().enumerate() { + for (i, elt) in d.iter_mut().rev().enumerate() { assert_eq!(*elt, i); *elt = i; } { - let mut it = d.mut_iter().rev(); - assert_eq!(*it.next().unwrap(), 0); - assert_eq!(*it.next().unwrap(), 1); - assert_eq!(*it.next().unwrap(), 2); + let mut it = d.iter_mut().rev(); + assert_eq!(*it.next().assert(), 0); + assert_eq!(*it.next().assert(), 1); + assert_eq!(*it.next().assert(), 2); assert!(it.next().is_none()); } } diff --git a/src/libcollections/slice.rs b/src/libcollections/slice.rs index f6aaea79bbd31..c75f79ffbb9b3 100644 --- a/src/libcollections/slice.rs +++ b/src/libcollections/slice.rs @@ -79,7 +79,7 @@ for &x in numbers.iter() { } ``` -* `.mut_iter()` returns an iterator that allows modifying each value. +* `.iter_mut()` returns an iterator that allows modifying each value. * Further iterators exist that split, chunk or permute the slice. */ @@ -99,10 +99,13 @@ use vec::Vec; pub use core::slice::{ref_slice, mut_ref_slice, Splits, Windows}; pub use core::slice::{Chunks, Vector, ImmutableVector, ImmutableEqVector}; -pub use core::slice::{ImmutableOrdVector, MutableVector, Items, MutItems}; -pub use core::slice::{MutSplits, MutChunks}; +pub use core::slice::{ImmutableOrdVector, MutableVector, Items, ItemsMut}; +pub use core::slice::{SplitsMut, ChunksMut}; pub use core::slice::{bytes, MutableCloneableVector}; +// Deprecated items: +pub use core::slice::{MutItems, MutSplits, MutChunks}; + // Functional utilities #[allow(missing_doc)] @@ -198,7 +201,7 @@ impl Iterator<(uint, uint)> for ElementSwaps { self.sdir.as_mut_slice().swap(i, j); // Swap the direction of each larger SizeDirection - for x in self.sdir.mut_iter() { + for x in self.sdir.iter_mut() { if x.size > sd.size { x.dir = match x.dir { Pos => Neg, Neg => Pos }; } @@ -612,7 +615,7 @@ impl<'a,T> MutableVectorAllocating<'a, T> for &'a mut [T] { #[inline] fn move_from(self, mut src: Vec, start: uint, end: uint) -> uint { - for (a, b) in self.mut_iter().zip(src.mut_slice(start, end).mut_iter()) { + for (a, b) in self.iter_mut().zip(src.slice_mut(start, end).iter_mut()) { mem::swap(a, b); } cmp::min(self.len(), end-start) @@ -698,7 +701,7 @@ impl<'a, T: Ord> MutableOrdVector for &'a mut [T] { self.swap(j, i-1); // Step 4: Reverse the (previously) weakly decreasing part - self.mut_slice_from(i).reverse(); + self.slice_from_mut(i).reverse(); true } @@ -719,7 +722,7 @@ impl<'a, T: Ord> MutableOrdVector for &'a mut [T] { } // Step 2: Reverse the weakly increasing part - self.mut_slice_from(i).reverse(); + self.slice_from_mut(i).reverse(); // Step 3: Find the rightmost element equal to or bigger than the pivot (i-1) let mut j = self.len() - 1; @@ -831,9 +834,9 @@ mod tests { let mut a = vec![11i]; assert_eq!(a.as_slice().get(1), None); a = vec![11i, 12]; - assert_eq!(a.as_slice().get(1).unwrap(), &12); + assert_eq!(a.as_slice().get(1).assert(), &12); a = vec![11i, 12, 13]; - assert_eq!(a.as_slice().get(1).unwrap(), &12); + assert_eq!(a.as_slice().get(1).assert(), &12); } #[test] @@ -841,9 +844,9 @@ mod tests { let mut a = vec![]; assert_eq!(a.as_slice().head(), None); a = vec![11i]; - assert_eq!(a.as_slice().head().unwrap(), &11); + assert_eq!(a.as_slice().head().assert(), &11); a = vec![11i, 12]; - assert_eq!(a.as_slice().head().unwrap(), &11); + assert_eq!(a.as_slice().head().assert(), &11); } #[test] @@ -911,9 +914,9 @@ mod tests { let mut a = vec![]; assert_eq!(a.as_slice().last(), None); a = vec![11i]; - assert_eq!(a.as_slice().last().unwrap(), &11); + assert_eq!(a.as_slice().last().assert(), &11); a = vec![11i, 12]; - assert_eq!(a.as_slice().last().unwrap(), &12); + assert_eq!(a.as_slice().last().assert(), &12); } #[test] @@ -1163,7 +1166,7 @@ mod tests { let mut it = v.permutations(); let (min_size, max_opt) = it.size_hint(); assert_eq!(min_size, 1); - assert_eq!(max_opt.unwrap(), 1); + assert_eq!(max_opt.assert(), 1); assert_eq!(it.next(), Some(v.as_slice().to_vec())); assert_eq!(it.next(), None); } @@ -1172,7 +1175,7 @@ mod tests { let mut it = v.permutations(); let (min_size, max_opt) = it.size_hint(); assert_eq!(min_size, 1); - assert_eq!(max_opt.unwrap(), 1); + assert_eq!(max_opt.assert(), 1); assert_eq!(it.next(), Some(v.as_slice().to_vec())); assert_eq!(it.next(), None); } @@ -1181,13 +1184,13 @@ mod tests { let mut it = v.permutations(); let (min_size, max_opt) = it.size_hint(); assert_eq!(min_size, 3*2); - assert_eq!(max_opt.unwrap(), 3*2); + assert_eq!(max_opt.assert(), 3*2); assert_eq!(it.next(), Some(vec![1,2,3])); assert_eq!(it.next(), Some(vec![1,3,2])); assert_eq!(it.next(), Some(vec![3,1,2])); let (min_size, max_opt) = it.size_hint(); assert_eq!(min_size, 3); - assert_eq!(max_opt.unwrap(), 3); + assert_eq!(max_opt.assert(), 3); assert_eq!(it.next(), Some(vec![3,2,1])); assert_eq!(it.next(), Some(vec![2,3,1])); assert_eq!(it.next(), Some(vec![2,1,3])); @@ -1205,7 +1208,7 @@ mod tests { assert_eq!(amt, it.swaps.swaps_made); assert_eq!(amt, min_size); assert_eq!(amt, 2 * 3 * 4 * 5 * 6); - assert_eq!(amt, max_opt.unwrap()); + assert_eq!(amt, max_opt.assert()); } } @@ -1593,15 +1596,15 @@ mod tests { let xs = [1i, 2, 5, 10, 11]; let mut it = xs.iter(); assert_eq!(it.size_hint(), (5, Some(5))); - assert_eq!(it.next().unwrap(), &1); + assert_eq!(it.next().assert(), &1); assert_eq!(it.size_hint(), (4, Some(4))); - assert_eq!(it.next().unwrap(), &2); + assert_eq!(it.next().assert(), &2); assert_eq!(it.size_hint(), (3, Some(3))); - assert_eq!(it.next().unwrap(), &5); + assert_eq!(it.next().assert(), &5); assert_eq!(it.size_hint(), (2, Some(2))); - assert_eq!(it.next().unwrap(), &10); + assert_eq!(it.next().assert(), &10); assert_eq!(it.size_hint(), (1, Some(1))); - assert_eq!(it.next().unwrap(), &11); + assert_eq!(it.next().assert(), &11); assert_eq!(it.size_hint(), (0, Some(0))); assert!(it.next().is_none()); } @@ -1612,32 +1615,32 @@ mod tests { let mut it = xs.iter(); assert_eq!(it.indexable(), 5); - assert_eq!(it.idx(0).unwrap(), &1); - assert_eq!(it.idx(2).unwrap(), &5); - assert_eq!(it.idx(4).unwrap(), &11); + assert_eq!(it.idx(0).assert(), &1); + assert_eq!(it.idx(2).assert(), &5); + assert_eq!(it.idx(4).assert(), &11); assert!(it.idx(5).is_none()); - assert_eq!(it.next().unwrap(), &1); + assert_eq!(it.next().assert(), &1); assert_eq!(it.indexable(), 4); - assert_eq!(it.idx(0).unwrap(), &2); - assert_eq!(it.idx(3).unwrap(), &11); + assert_eq!(it.idx(0).assert(), &2); + assert_eq!(it.idx(3).assert(), &11); assert!(it.idx(4).is_none()); - assert_eq!(it.next().unwrap(), &2); + assert_eq!(it.next().assert(), &2); assert_eq!(it.indexable(), 3); - assert_eq!(it.idx(1).unwrap(), &10); + assert_eq!(it.idx(1).assert(), &10); assert!(it.idx(3).is_none()); - assert_eq!(it.next().unwrap(), &5); + assert_eq!(it.next().assert(), &5); assert_eq!(it.indexable(), 2); - assert_eq!(it.idx(1).unwrap(), &11); + assert_eq!(it.idx(1).assert(), &11); - assert_eq!(it.next().unwrap(), &10); + assert_eq!(it.next().assert(), &10); assert_eq!(it.indexable(), 1); - assert_eq!(it.idx(0).unwrap(), &11); + assert_eq!(it.idx(0).assert(), &11); assert!(it.idx(1).is_none()); - assert_eq!(it.next().unwrap(), &11); + assert_eq!(it.next().assert(), &11); assert_eq!(it.indexable(), 0); assert!(it.idx(0).is_none()); @@ -1648,7 +1651,7 @@ mod tests { fn test_iter_size_hints() { let mut xs = [1i, 2, 5, 10, 11]; assert_eq!(xs.iter().size_hint(), (5, Some(5))); - assert_eq!(xs.mut_iter().size_hint(), (5, Some(5))); + assert_eq!(xs.iter_mut().size_hint(), (5, Some(5))); } #[test] @@ -1665,7 +1668,7 @@ mod tests { #[test] fn test_mut_iterator() { let mut xs = [1i, 2, 3, 4, 5]; - for x in xs.mut_iter() { + for x in xs.iter_mut() { *x += 1; } assert!(xs == [2, 3, 4, 5, 6]) @@ -1687,7 +1690,7 @@ mod tests { #[test] fn test_mut_rev_iterator() { let mut xs = [1u, 2, 3, 4, 5]; - for (i,x) in xs.mut_iter().rev().enumerate() { + for (i,x) in xs.iter_mut().rev().enumerate() { *x += i; } assert!(xs == [5, 5, 5, 5, 5]) @@ -1696,13 +1699,13 @@ mod tests { #[test] fn test_move_iterator() { let xs = vec![1u,2,3,4,5]; - assert_eq!(xs.move_iter().fold(0, |a: uint, b: uint| 10*a + b), 12345); + assert_eq!(xs.iter_owned().fold(0, |a: uint, b: uint| 10*a + b), 12345); } #[test] fn test_move_rev_iterator() { let xs = vec![1u,2,3,4,5]; - assert_eq!(xs.move_iter().rev().fold(0, |a: uint, b: uint| 10*a + b), 54321); + assert_eq!(xs.iter_owned().rev().fold(0, |a: uint, b: uint| 10*a + b), 54321); } #[test] @@ -1798,9 +1801,9 @@ mod tests { assert_eq!(v.chunks(2).rev().collect::>().as_slice(), &[&[5i], &[3,4], &[1,2]]); let mut it = v.chunks(2); assert_eq!(it.indexable(), 3); - assert_eq!(it.idx(0).unwrap(), &[1,2]); - assert_eq!(it.idx(1).unwrap(), &[3,4]); - assert_eq!(it.idx(2).unwrap(), &[5]); + assert_eq!(it.idx(0).assert(), &[1,2]); + assert_eq!(it.idx(1).assert(), &[3,4]); + assert_eq!(it.idx(2).assert(), &[5]); assert_eq!(it.idx(3), None); } @@ -1827,7 +1830,7 @@ mod tests { assert!(a == [7i,2,3,4]); let mut a = [1i,2,3,4,5]; let b = vec![5i,6,7,8,9,0]; - assert_eq!(a.mut_slice(2,4).move_from(b,1,6), 2); + assert_eq!(a.slice_mut(2,4).move_from(b,1,6), 2); assert!(a == [1i,2,6,7,5]); } @@ -1846,7 +1849,7 @@ mod tests { #[test] fn test_reverse_part() { let mut values = [1i,2,3,4,5]; - values.mut_slice(1, 4).reverse(); + values.slice_mut(1, 4).reverse(); assert!(values == [1,4,3,2,5]); } @@ -1891,9 +1894,9 @@ mod tests { fn test_bytes_set_memory() { use slice::bytes::MutableByteVector; let mut values = [1u8,2,3,4,5]; - values.mut_slice(0,5).set_memory(0xAB); + values.slice_mut(0,5).set_memory(0xAB); assert!(values == [0xAB, 0xAB, 0xAB, 0xAB, 0xAB]); - values.mut_slice(2,4).set_memory(0xFF); + values.slice_mut(2,4).set_memory(0xFF); assert!(values == [0xAB, 0xAB, 0xFF, 0xFF, 0xAB]); } @@ -1915,17 +1918,17 @@ mod tests { } #[test] - fn test_mut_split_at() { + fn test_split_at_mut() { let mut values = [1u8,2,3,4,5]; { - let (left, right) = values.mut_split_at(2); + let (left, right) = values.split_at_mut(2); assert!(left.slice(0, left.len()) == [1, 2]); - for p in left.mut_iter() { + for p in left.iter_mut() { *p += 1; } assert!(right.slice(0, right.len()) == [3, 4, 5]); - for p in right.mut_iter() { + for p in right.iter_mut() { *p += 2; } } @@ -1954,13 +1957,13 @@ mod tests { } assert_eq!(cnt, 5); - for f in v.mut_iter() { + for f in v.iter_mut() { assert!(*f == Foo); cnt += 1; } assert_eq!(cnt, 8); - for f in v.move_iter() { + for f in v.iter_owned() { assert!(f == Foo); cnt += 1; } @@ -2019,7 +2022,7 @@ mod tests { fn test_shift_ref() { let mut x: &[int] = [1, 2, 3, 4, 5]; let h = x.shift_ref(); - assert_eq!(*h.unwrap(), 1); + assert_eq!(*h.assert(), 1); assert_eq!(x.len(), 4); assert_eq!(x[0], 2); assert_eq!(x[3], 5); @@ -2032,7 +2035,7 @@ mod tests { fn test_pop_ref() { let mut x: &[int] = [1, 2, 3, 4, 5]; let h = x.pop_ref(); - assert_eq!(*h.unwrap(), 5); + assert_eq!(*h.assert(), 5); assert_eq!(x.len(), 4); assert_eq!(x[0], 1); assert_eq!(x[3], 4); @@ -2044,14 +2047,14 @@ mod tests { #[test] fn test_mut_splitator() { let mut xs = [0i,1,0,2,3,0,0,4,5,0]; - assert_eq!(xs.mut_split(|x| *x == 0).count(), 6); - for slice in xs.mut_split(|x| *x == 0) { + assert_eq!(xs.split_mut(|x| *x == 0).count(), 6); + for slice in xs.split_mut(|x| *x == 0) { slice.reverse(); } assert!(xs == [0,1,0,3,2,0,0,5,4,0]); let mut xs = [0i,1,0,2,3,0,0,4,5,0,6,7]; - for slice in xs.mut_split(|x| *x == 0).take(5) { + for slice in xs.split_mut(|x| *x == 0).take(5) { slice.reverse(); } assert!(xs == [0,1,0,3,2,0,0,5,4,0,6,7]); @@ -2060,7 +2063,7 @@ mod tests { #[test] fn test_mut_splitator_rev() { let mut xs = [1i,2,0,3,4,0,0,5,6,0]; - for slice in xs.mut_split(|x| *x == 0).rev().take(4) { + for slice in xs.split_mut(|x| *x == 0).rev().take(4) { slice.reverse(); } assert!(xs == [1,2,0,4,3,0,0,6,5,0]); @@ -2079,8 +2082,8 @@ mod tests { #[test] fn test_mut_chunks() { let mut v = [0u8, 1, 2, 3, 4, 5, 6]; - for (i, chunk) in v.mut_chunks(3).enumerate() { - for x in chunk.mut_iter() { + for (i, chunk) in v.chunks_mut(3).enumerate() { + for x in chunk.iter_mut() { *x = i as u8; } } @@ -2091,8 +2094,8 @@ mod tests { #[test] fn test_mut_chunks_rev() { let mut v = [0u8, 1, 2, 3, 4, 5, 6]; - for (i, chunk) in v.mut_chunks(3).rev().enumerate() { - for x in chunk.mut_iter() { + for (i, chunk) in v.chunks_mut(3).rev().enumerate() { + for x in chunk.iter_mut() { *x = i as u8; } } @@ -2104,43 +2107,43 @@ mod tests { #[should_fail] fn test_mut_chunks_0() { let mut v = [1i, 2, 3, 4]; - let _it = v.mut_chunks(0); + let _it = v.chunks_mut(0); } #[test] fn test_mut_shift_ref() { let mut x: &mut [int] = [1, 2, 3, 4, 5]; - let h = x.mut_shift_ref(); - assert_eq!(*h.unwrap(), 1); + let h = x.shift_mut(); + assert_eq!(*h.assert(), 1); assert_eq!(x.len(), 4); assert_eq!(x[0], 2); assert_eq!(x[3], 5); let mut y: &mut [int] = []; - assert!(y.mut_shift_ref().is_none()); + assert!(y.shift_mut().is_none()); } #[test] fn test_mut_pop_ref() { let mut x: &mut [int] = [1, 2, 3, 4, 5]; - let h = x.mut_pop_ref(); - assert_eq!(*h.unwrap(), 5); + let h = x.pop_mut(); + assert_eq!(*h.assert(), 5); assert_eq!(x.len(), 4); assert_eq!(x[0], 1); assert_eq!(x[3], 4); let mut y: &mut [int] = []; - assert!(y.mut_pop_ref().is_none()); + assert!(y.pop_mut().is_none()); } #[test] fn test_mut_last() { let mut x = [1i, 2, 3, 4, 5]; - let h = x.mut_last(); - assert_eq!(*h.unwrap(), 5); + let h = x.last_mut(); + assert_eq!(*h.assert(), 5); let y: &mut [int] = []; - assert!(y.mut_last().is_none()); + assert!(y.last_mut().is_none()); } } @@ -2177,7 +2180,7 @@ mod bench { b.iter(|| { let mut i = 0i; - for x in v.mut_iter() { + for x in v.iter_mut() { *x = i; i += 1; } @@ -2311,7 +2314,7 @@ mod bench { unsafe { v.set_len(1024); } - for x in v.mut_iter() { + for x in v.iter_mut() { *x = 0i; } v diff --git a/src/libcollections/smallintmap.rs b/src/libcollections/smallintmap.rs index f567c5777b171..21643a934f587 100644 --- a/src/libcollections/smallintmap.rs +++ b/src/libcollections/smallintmap.rs @@ -163,7 +163,7 @@ impl Clone for SmallIntMap { #[inline] fn clone_from(&mut self, source: &SmallIntMap) { self.v.reserve(source.v.len()); - for (i, w) in self.v.mut_iter().enumerate() { + for (i, w) in self.v.iter_mut().enumerate() { *w = source.v[i].clone(); } } @@ -249,7 +249,7 @@ impl SmallIntMap { /// println!("{}: {}", key, value); /// } /// ``` - pub fn iter<'r>(&'r self) -> Entries<'r, V> { + pub fn iter(&self) -> Entries { Entries { front: 0, back: self.v.len(), @@ -257,6 +257,9 @@ impl SmallIntMap { } } + /// Deprecated. Use `iter_mut` instead. + pub fn mut_iter(&mut self) -> EntriesMut { self.iter_mut() } + /// An iterator visiting all key-value pairs in ascending order by the keys, /// with mutable references to the values /// Iterator element type is `(uint, &'r mut V)`. @@ -271,7 +274,7 @@ impl SmallIntMap { /// map.insert(2, "b"); /// map.insert(3, "c"); /// - /// for (key, value) in map.mut_iter() { + /// for (key, value) in map.iter_mut() { /// *value = "x"; /// } /// @@ -279,14 +282,19 @@ impl SmallIntMap { /// assert_eq!(value, &"x"); /// } /// ``` - pub fn mut_iter<'r>(&'r mut self) -> MutEntries<'r, V> { - MutEntries { + pub fn iter_mut(&mut self) -> EntriesMut { + EntriesMut { front: 0, back: self.v.len(), - iter: self.v.mut_iter() + iter: self.v.iter_mut() } } + /// Deprecated. Use `iter_owned` instead. + pub fn move_iter(&mut self) + -> FilterMap<(uint, Option), (uint, V), + Enumerate>>> { self.iter_owned() } + /// Empties the map, moving all values into the specified closure. /// /// # Example @@ -300,16 +308,16 @@ impl SmallIntMap { /// map.insert(2, "b"); /// /// // Not possible with .iter() - /// let vec: Vec<(uint, &str)> = map.move_iter().collect(); + /// let vec: Vec<(uint, &str)> = map.iter_owned().collect(); /// /// assert_eq!(vec, vec![(1, "a"), (2, "b"), (3, "c")]); /// ``` - pub fn move_iter(&mut self) + pub fn iter_owned(&mut self) -> FilterMap<(uint, Option), (uint, V), Enumerate>>> { let values = replace(&mut self.v, vec!()); - values.move_iter().enumerate().filter_map(|(i, v)| { + values.iter_owned().enumerate().filter_map(|(i, v)| { v.map(|v| (i, v)) }) } @@ -480,14 +488,18 @@ double_ended_iterator!(impl Entries -> (uint, &'a T), get_ref) /// Forward iterator over the key-value pairs of a map, with the /// values being mutable. -pub struct MutEntries<'a, T> { +pub struct EntriesMut<'a, T> { front: uint, back: uint, iter: slice::MutItems<'a, Option> } -iterator!(impl MutEntries -> (uint, &'a mut T), get_mut_ref) -double_ended_iterator!(impl MutEntries -> (uint, &'a mut T), get_mut_ref) +/// Deprecated: renamed to `EntriesMut`. +#[deprecated = "renamed to EntriesMut"] +pub type MutEntries<'a, T> = EntriesMut<'a, T>; + +iterator!(impl EntriesMut -> (uint, &'a mut T), get_mut_ref) +double_ended_iterator!(impl EntriesMut -> (uint, &'a mut T), get_mut_ref) /// Forward iterator over the keys of a map pub type Keys<'a, T> = @@ -570,9 +582,9 @@ mod test_map { map.update_with_key(3, 2, add_more_to_count); // check the total counts - assert_eq!(map.find(&3).unwrap(), &10); - assert_eq!(map.find(&5).unwrap(), &3); - assert_eq!(map.find(&9).unwrap(), &1); + assert_eq!(map.find(&3).assert(), &10); + assert_eq!(map.find(&5).assert(), &3); + assert_eq!(map.find(&9).assert(), &1); // sadly, no sevens were counted assert!(map.find(&7).is_none()); @@ -632,15 +644,15 @@ mod test_map { let mut it = m.iter(); assert_eq!(it.size_hint(), (0, Some(11))); - assert_eq!(it.next().unwrap(), (0, &1)); + assert_eq!(it.next().assert(), (0, &1)); assert_eq!(it.size_hint(), (0, Some(10))); - assert_eq!(it.next().unwrap(), (1, &2)); + assert_eq!(it.next().assert(), (1, &2)); assert_eq!(it.size_hint(), (0, Some(9))); - assert_eq!(it.next().unwrap(), (3, &5)); + assert_eq!(it.next().assert(), (3, &5)); assert_eq!(it.size_hint(), (0, Some(7))); - assert_eq!(it.next().unwrap(), (6, &10)); + assert_eq!(it.next().assert(), (6, &10)); assert_eq!(it.size_hint(), (0, Some(4))); - assert_eq!(it.next().unwrap(), (10, &11)); + assert_eq!(it.next().assert(), (10, &11)); assert_eq!(it.size_hint(), (0, Some(0))); assert!(it.next().is_none()); } @@ -657,8 +669,8 @@ mod test_map { assert_eq!(m.iter().size_hint(), (0, Some(11))); assert_eq!(m.iter().rev().size_hint(), (0, Some(11))); - assert_eq!(m.mut_iter().size_hint(), (0, Some(11))); - assert_eq!(m.mut_iter().rev().size_hint(), (0, Some(11))); + assert_eq!(m.iter_mut().size_hint(), (0, Some(11))); + assert_eq!(m.iter_mut().rev().size_hint(), (0, Some(11))); } #[test] @@ -671,16 +683,16 @@ mod test_map { assert!(m.insert(6, 10)); assert!(m.insert(10, 11)); - for (k, v) in m.mut_iter() { + for (k, v) in m.iter_mut() { *v += k as int; } let mut it = m.iter(); - assert_eq!(it.next().unwrap(), (0, &1)); - assert_eq!(it.next().unwrap(), (1, &3)); - assert_eq!(it.next().unwrap(), (3, &8)); - assert_eq!(it.next().unwrap(), (6, &16)); - assert_eq!(it.next().unwrap(), (10, &21)); + assert_eq!(it.next().assert(), (0, &1)); + assert_eq!(it.next().assert(), (1, &3)); + assert_eq!(it.next().assert(), (3, &8)); + assert_eq!(it.next().assert(), (6, &16)); + assert_eq!(it.next().assert(), (10, &21)); assert!(it.next().is_none()); } @@ -695,11 +707,11 @@ mod test_map { assert!(m.insert(10, 11)); let mut it = m.iter().rev(); - assert_eq!(it.next().unwrap(), (10, &11)); - assert_eq!(it.next().unwrap(), (6, &10)); - assert_eq!(it.next().unwrap(), (3, &5)); - assert_eq!(it.next().unwrap(), (1, &2)); - assert_eq!(it.next().unwrap(), (0, &1)); + assert_eq!(it.next().assert(), (10, &11)); + assert_eq!(it.next().assert(), (6, &10)); + assert_eq!(it.next().assert(), (3, &5)); + assert_eq!(it.next().assert(), (1, &2)); + assert_eq!(it.next().assert(), (0, &1)); assert!(it.next().is_none()); } @@ -713,16 +725,16 @@ mod test_map { assert!(m.insert(6, 10)); assert!(m.insert(10, 11)); - for (k, v) in m.mut_iter().rev() { + for (k, v) in m.iter_mut().rev() { *v += k as int; } let mut it = m.iter(); - assert_eq!(it.next().unwrap(), (0, &1)); - assert_eq!(it.next().unwrap(), (1, &3)); - assert_eq!(it.next().unwrap(), (3, &8)); - assert_eq!(it.next().unwrap(), (6, &16)); - assert_eq!(it.next().unwrap(), (10, &21)); + assert_eq!(it.next().assert(), (0, &1)); + assert_eq!(it.next().assert(), (1, &3)); + assert_eq!(it.next().assert(), (3, &8)); + assert_eq!(it.next().assert(), (6, &16)); + assert_eq!(it.next().assert(), (10, &21)); assert!(it.next().is_none()); } @@ -731,7 +743,7 @@ mod test_map { let mut m = SmallIntMap::new(); m.insert(1, box 2i); let mut called = false; - for (k, v) in m.move_iter() { + for (k, v) in m.iter_owned() { assert!(!called); called = true; assert_eq!(k, 1); diff --git a/src/libcollections/str.rs b/src/libcollections/str.rs index 270b76fd57fc9..50fd3b59f813f 100644 --- a/src/libcollections/str.rs +++ b/src/libcollections/str.rs @@ -336,7 +336,7 @@ impl<'a> Iterator for Recompositions<'a> { self.composee = Some(ch); continue; } - let k = self.composee.clone().unwrap(); + let k = self.composee.clone().assert(); match self.last_ccc { None => { @@ -1512,7 +1512,7 @@ mod tests { let s1: String = String::from_str("All mimsy were the borogoves"); let v: Vec = Vec::from_slice(s1.as_bytes()); - let s2: String = String::from_str(from_utf8(v.as_slice()).unwrap()); + let s2: String = String::from_str(from_utf8(v.as_slice()).assert()); let mut i: uint = 0u; let n1: uint = s1.len(); let n2: uint = v.len(); @@ -1681,7 +1681,7 @@ mod tests { let mut bytes = [0u8, ..4]; for c in range(0u32, 0x110000).filter_map(|c| ::core::char::from_u32(c)) { let len = c.encode_utf8(bytes); - let s = ::core::str::from_utf8(bytes.slice_to(len)).unwrap(); + let s = ::core::str::from_utf8(bytes.slice_to(len)).assert(); if Some(c) != s.chars().next() { fail!("character {:x}={} does not decode correctly", c as u32, c); } @@ -1693,7 +1693,7 @@ mod tests { let mut bytes = [0u8, ..4]; for c in range(0u32, 0x110000).filter_map(|c| ::core::char::from_u32(c)) { let len = c.encode_utf8(bytes); - let s = ::core::str::from_utf8(bytes.slice_to(len)).unwrap(); + let s = ::core::str::from_utf8(bytes.slice_to(len)).assert(); if Some(c) != s.chars().rev().next() { fail!("character {:x}={} does not decode correctly", c as u32, c); } diff --git a/src/libcollections/string.rs b/src/libcollections/string.rs index 9465fea6dcbee..c5b1bbd65fecb 100644 --- a/src/libcollections/string.rs +++ b/src/libcollections/string.rs @@ -974,7 +974,7 @@ mod tests { for p in pairs.iter() { let (s, u) = (*p).clone(); let s_as_utf16 = s.as_slice().utf16_units().collect::>(); - let u_as_string = String::from_utf16(u.as_slice()).unwrap(); + let u_as_string = String::from_utf16(u.as_slice()).assert(); assert!(str::is_utf16(u.as_slice())); assert_eq!(s_as_utf16, u); @@ -982,7 +982,7 @@ mod tests { assert_eq!(u_as_string, s); assert_eq!(String::from_utf16_lossy(u.as_slice()), s); - assert_eq!(String::from_utf16(s_as_utf16.as_slice()).unwrap(), s); + assert_eq!(String::from_utf16(s_as_utf16.as_slice()).assert(), s); assert_eq!(u_as_string.as_slice().utf16_units().collect::>(), u); } } @@ -1070,22 +1070,22 @@ mod tests { #[test] fn test_pop_char() { let mut data = String::from_str("ประเทศไทย中华b¢€𤭢"); - assert_eq!(data.pop_char().unwrap(), '𤭢'); // 4 bytes - assert_eq!(data.pop_char().unwrap(), '€'); // 3 bytes - assert_eq!(data.pop_char().unwrap(), '¢'); // 2 bytes - assert_eq!(data.pop_char().unwrap(), 'b'); // 1 bytes - assert_eq!(data.pop_char().unwrap(), '华'); + assert_eq!(data.pop_char().assert(), '𤭢'); // 4 bytes + assert_eq!(data.pop_char().assert(), '€'); // 3 bytes + assert_eq!(data.pop_char().assert(), '¢'); // 2 bytes + assert_eq!(data.pop_char().assert(), 'b'); // 1 bytes + assert_eq!(data.pop_char().assert(), '华'); assert_eq!(data.as_slice(), "ประเทศไทย中"); } #[test] fn test_shift_char() { let mut data = String::from_str("𤭢€¢b华ประเทศไทย中"); - assert_eq!(data.shift_char().unwrap(), '𤭢'); // 4 bytes - assert_eq!(data.shift_char().unwrap(), '€'); // 3 bytes - assert_eq!(data.shift_char().unwrap(), '¢'); // 2 bytes - assert_eq!(data.shift_char().unwrap(), 'b'); // 1 bytes - assert_eq!(data.shift_char().unwrap(), '华'); + assert_eq!(data.shift_char().assert(), '𤭢'); // 4 bytes + assert_eq!(data.shift_char().assert(), '€'); // 3 bytes + assert_eq!(data.shift_char().assert(), '¢'); // 2 bytes + assert_eq!(data.shift_char().assert(), 'b'); // 1 bytes + assert_eq!(data.shift_char().assert(), '华'); assert_eq!(data.as_slice(), "ประเทศไทย中"); } diff --git a/src/libcollections/treemap.rs b/src/libcollections/treemap.rs index 6299ecfc5fd56..c7b06f27852ba 100644 --- a/src/libcollections/treemap.rs +++ b/src/libcollections/treemap.rs @@ -343,6 +343,12 @@ impl TreeMap { RevEntries{iter: self.iter()} } + /// Deprecated: renamed to `iter_mut`. + #[deprecated = "renamed to iter_mut"] + pub fn mut_iter<'a>(&'a mut self) -> EntriesMut<'a, K, V> { + self.iter_mut() + } + /// Get a lazy forward iterator over the key-value pairs in the /// map, with the values being mutable. /// @@ -356,7 +362,7 @@ impl TreeMap { /// map.insert("b", 2i); /// /// // Add 10 until we find "b" - /// for (key, value) in map.mut_iter() { + /// for (key, value) in map.iter_mut() { /// *value += 10; /// if key == &"b" { break } /// } @@ -365,14 +371,21 @@ impl TreeMap { /// assert_eq!(map.find(&"b"), Some(&12)); /// assert_eq!(map.find(&"c"), Some(&3)); /// ``` - pub fn mut_iter<'a>(&'a mut self) -> MutEntries<'a, K, V> { - MutEntries { + pub fn iter_mut<'a>(&'a mut self) -> EntriesMut<'a, K, V> { + EntriesMut { stack: vec!(), - node: mut_deref(&mut self.root), + node: deref_mut(&mut self.root), remaining_min: self.length, remaining_max: self.length } } + + /// Deprecated: renamed to `rev_iter_mut`. + #[deprecated = "renamed to rev_iter_mut"] + pub fn mut_rev_iter<'a>(&'a mut self) -> RevEntriesMut<'a, K, V> { + self.rev_iter_mut() + } + /// Get a lazy reverse iterator over the key-value pairs in the /// map, with the values being mutable. /// @@ -386,7 +399,7 @@ impl TreeMap { /// map.insert("b", 2i); /// /// // Add 10 until we find "b" - /// for (key, value) in map.mut_rev_iter() { + /// for (key, value) in map.rev_iter_mut() { /// *value += 10; /// if key == &"b" { break } /// } @@ -395,10 +408,15 @@ impl TreeMap { /// assert_eq!(map.find(&"b"), Some(&12)); /// assert_eq!(map.find(&"c"), Some(&13)); /// ``` - pub fn mut_rev_iter<'a>(&'a mut self) -> RevMutEntries<'a, K, V> { - RevMutEntries{iter: self.mut_iter()} + pub fn rev_iter_mut<'a>(&'a mut self) -> RevEntriesMut<'a, K, V> { + RevEntriesMut{iter: self.iter_mut()} } + /// Deprecated: renamed to `iter_owned`. + #[deprecated = "renamed to iter_owned"] + pub fn move_iter(self) -> EntriesOwned { + self.iter_owned() + } /// Get a lazy iterator that consumes the treemap, it is not usable /// after calling this. @@ -413,16 +431,16 @@ impl TreeMap { /// map.insert("b", 2i); /// /// // Not possible with a regular `.iter()` - /// let vec: Vec<(&str, int)> = map.move_iter().collect(); + /// let vec: Vec<(&str, int)> = map.iter_owned().collect(); /// assert_eq!(vec, vec![("a", 1), ("b", 2), ("c", 3)]); /// ``` - pub fn move_iter(self) -> MoveEntries { + pub fn iter_owned(self) -> EntriesOwned { let TreeMap { root: root, length: length } = self; let stk = match root { None => vec!(), Some(box tn) => vec!(tn) }; - MoveEntries { + EntriesOwned { stack: stk, remaining: length } @@ -452,7 +470,7 @@ impl TreeMap { /// ua_key.cmp(&k.as_slice()) /// }); /// - /// assert_eq!((*ua.unwrap()).as_slice(), "Curl-Rust/0.1"); + /// assert_eq!((*ua.assert()).as_slice(), "Curl-Rust/0.1"); /// ``` #[inline] pub fn find_with<'a>(&'a self, f:|&K| -> Ordering) -> Option<&'a V> { @@ -576,15 +594,21 @@ impl TreeMap { /// Get a lazy iterator that should be initialized using /// `traverse_left`/`traverse_right`/`traverse_complete`. - fn mut_iter_for_traversal<'a>(&'a mut self) -> MutEntries<'a, K, V> { - MutEntries { + fn iter_for_traversal_mut<'a>(&'a mut self) -> EntriesMut<'a, K, V> { + EntriesMut { stack: vec!(), - node: mut_deref(&mut self.root), + node: deref_mut(&mut self.root), remaining_min: 0, remaining_max: self.length } } + /// Deprecated: renamed to `lower_bound_mut`. + #[deprecated = "renamed to lower_bound_mut"] + pub fn mut_lower_bound<'a>(&'a mut self, k: &K) -> EntriesMut<'a, K, V> { + self.lower_bound_mut(k) + } + /// Return a lazy value iterator to the first key-value pair (with /// the value being mutable) whose key is not less than `k`. /// @@ -602,11 +626,11 @@ impl TreeMap { /// map.insert(6, "c"); /// map.insert(8, "d"); /// - /// assert_eq!(map.mut_lower_bound(&4).next(), Some((&4, &mut "b"))); - /// assert_eq!(map.mut_lower_bound(&5).next(), Some((&6, &mut "c"))); - /// assert_eq!(map.mut_lower_bound(&10).next(), None); + /// assert_eq!(map.lower_bound_mut(&4).next(), Some((&4, &mut "b"))); + /// assert_eq!(map.lower_bound_mut(&5).next(), Some((&6, &mut "c"))); + /// assert_eq!(map.lower_bound_mut(&10).next(), None); /// - /// for (key, value) in map.mut_lower_bound(&4) { + /// for (key, value) in map.lower_bound_mut(&4) { /// *value = "changed"; /// } /// @@ -615,8 +639,14 @@ impl TreeMap { /// assert_eq!(map.find(&6), Some(&"changed")); /// assert_eq!(map.find(&8), Some(&"changed")); /// ``` - pub fn mut_lower_bound<'a>(&'a mut self, k: &K) -> MutEntries<'a, K, V> { - bound_setup!(self.mut_iter_for_traversal(), k, true) + pub fn lower_bound_mut<'a>(&'a mut self, k: &K) -> EntriesMut<'a, K, V> { + bound_setup!(self.iter_for_traversal_mut(), k, true) + } + + /// Deprecated: renamed to `upper_bound_mut`. + #[deprecated = "renamed to upper_bound_mut"] + pub fn mut_upper_bound<'a>(&'a mut self, k: &K) -> EntriesMut<'a, K, V> { + self.upper_bound_mut(k) } /// Return a lazy iterator to the first key-value pair (with the @@ -636,11 +666,11 @@ impl TreeMap { /// map.insert(6, "c"); /// map.insert(8, "d"); /// - /// assert_eq!(map.mut_upper_bound(&4).next(), Some((&6, &mut "c"))); - /// assert_eq!(map.mut_upper_bound(&5).next(), Some((&6, &mut "c"))); - /// assert_eq!(map.mut_upper_bound(&10).next(), None); + /// assert_eq!(map.upper_bound_mut(&4).next(), Some((&6, &mut "c"))); + /// assert_eq!(map.upper_bound_mut(&5).next(), Some((&6, &mut "c"))); + /// assert_eq!(map.upper_bound_mut(&10).next(), None); /// - /// for (key, value) in map.mut_upper_bound(&4) { + /// for (key, value) in map.upper_bound_mut(&4) { /// *value = "changed"; /// } /// @@ -649,15 +679,15 @@ impl TreeMap { /// assert_eq!(map.find(&6), Some(&"changed")); /// assert_eq!(map.find(&8), Some(&"changed")); /// ``` - pub fn mut_upper_bound<'a>(&'a mut self, k: &K) -> MutEntries<'a, K, V> { - bound_setup!(self.mut_iter_for_traversal(), k, false) + pub fn upper_bound_mut<'a>(&'a mut self, k: &K) -> EntriesMut<'a, K, V> { + bound_setup!(self.iter_for_traversal_mut(), k, false) } } /// Lazy forward iterator over a map pub struct Entries<'a, K, V> { stack: Vec<&'a TreeNode>, - // See the comment on MutEntries; this is just to allow + // See the comment on EntriesMut; this is just to allow // code-sharing (for this immutable-values iterator it *could* very // well be Option<&'a TreeNode>). node: *const TreeNode, @@ -672,7 +702,7 @@ pub struct RevEntries<'a, K, V> { /// Lazy forward iterator over a map that allows for the mutation of /// the values. -pub struct MutEntries<'a, K, V> { +pub struct EntriesMut<'a, K, V> { stack: Vec<&'a mut TreeNode>, // Unfortunately, we require some unsafe-ness to get around the // fact that we would be storing a reference *into* one of the @@ -698,11 +728,18 @@ pub struct MutEntries<'a, K, V> { remaining_max: uint } +/// Deprecated: renamed to `EntriesMut`. +#[deprecated = "renamed to EntriesMut"] +pub type MutEntries<'a, K, V> = EntriesMut<'a, K, V>; + /// Lazy backward iterator over a map -pub struct RevMutEntries<'a, K, V> { - iter: MutEntries<'a, K, V>, +pub struct RevEntriesMut<'a, K, V> { + iter: EntriesMut<'a, K, V>, } +/// Deprecated: renamed to `RevEntriesMut`. +#[deprecated = "renamed to RevEntriesMut"] +pub type RevMutEntries<'a, K, V> = RevEntriesMut<'a, K, V>; /// TreeMap keys iterator pub type Keys<'a, K, V> = @@ -751,7 +788,7 @@ macro_rules! define_iterator { } self.stack.push(node); } else { - let node = self.stack.pop().unwrap(); + let node = self.stack.pop().assert(); let next_node = if forward { addr!(& $($addr_mut)* node.right) } else { @@ -769,7 +806,7 @@ macro_rules! define_iterator { } /// traverse_left, traverse_right and traverse_complete are - /// used to initialize Entries/MutEntries + /// used to initialize Entries/EntriesMut /// pointing to element inside tree structure. /// /// They should be used in following manner: @@ -843,9 +880,9 @@ define_iterator! { addr_mut = } define_iterator! { - MutEntries, - RevMutEntries, - deref = mut_deref, + EntriesMut, + RevEntriesMut, + deref = deref_mut, addr_mut = mut } @@ -860,26 +897,26 @@ fn deref<'a, K, V>(node: &'a Option>>) -> *const TreeNode(x: &mut Option>>) +fn deref_mut(x: &mut Option>>) -> *mut TreeNode { match *x { Some(ref mut n) => { let n: &mut TreeNode = &mut **n; n as *mut TreeNode } - None => ptr::mut_null() + None => ptr::null_mut() } } /// Lazy forward iterator over a map that consumes the map while iterating -pub struct MoveEntries { +pub struct EntriesOwned { stack: Vec>, remaining: uint } -impl Iterator<(K, V)> for MoveEntries { +impl Iterator<(K, V)> for EntriesOwned { #[inline] fn next(&mut self) -> Option<(K, V)> { while !self.stack.is_empty() { @@ -889,7 +926,7 @@ impl Iterator<(K, V)> for MoveEntries { left: left, right: right, level: level - } = self.stack.pop().unwrap(); + } = self.stack.pop().assert(); match left { Some(box left) => { @@ -1078,8 +1115,8 @@ impl Set for TreeSet { return false; } - let a1 = a.unwrap(); - let b1 = b.unwrap(); + let a1 = a.assert(); + let b1 = b.assert(); match b1.cmp(a1) { Less => (), @@ -1154,6 +1191,12 @@ impl TreeSet { RevSetItems{iter: self.map.rev_iter()} } + /// Deprecated: renamed to `iter_owned`. + #[deprecated = "renamed to iter_owned"] + pub fn move_iter(self) -> SetItemsOwned { + self.iter_owned() + } + /// Creates a consuming iterator, that is, one that moves each value out of the /// set in ascending order. The set cannot be used after calling this. /// @@ -1164,12 +1207,12 @@ impl TreeSet { /// let set: TreeSet = [1i, 4, 3, 5, 2].iter().map(|&x| x).collect(); /// /// // Not possible with a regular `.iter()` - /// let v: Vec = set.move_iter().collect(); + /// let v: Vec = set.iter_owned().collect(); /// assert_eq!(v, vec![1, 2, 3, 4, 5]); /// ``` #[inline] - pub fn move_iter(self) -> MoveSetItems { - self.map.move_iter().map(|(value, _)| value) + pub fn iter_owned(self) -> SetItemsOwned { + self.map.iter_owned().map(|(value, _)| value) } /// Get a lazy iterator pointing to the first value not less than `v` (greater or equal). @@ -1319,7 +1362,11 @@ pub struct RevSetItems<'a, T> { } /// Lazy forward iterator over a set that consumes the set while iterating -pub type MoveSetItems = iter::Map<'static, (T, ()), T, MoveEntries>; +pub type SetItemsOwned = iter::Map<'static, (T, ()), T, EntriesOwned>; + +/// Deprecated: renamed to `SetItemsOwned`. +#[deprecated = "renamed to SetItemsOwned"] +pub type MoveSetItems = SetItemsOwned; /// Lazy iterator producing elements in the set difference (in-order) pub struct DifferenceItems<'a, T> { @@ -1432,7 +1479,7 @@ impl TreeNode { // Remove left horizontal link by rotating right fn skew(node: &mut Box>) { if node.left.as_ref().map_or(false, |x| x.level == node.level) { - let mut save = node.left.take_unwrap(); + let mut save = node.left.take().assert(); swap(&mut node.left, &mut save.right); // save.right now None swap(node, &mut save); node.right = Some(save); @@ -1444,7 +1491,7 @@ fn skew(node: &mut Box>) { fn split(node: &mut Box>) { if node.right.as_ref().map_or(false, |x| x.right.as_ref().map_or(false, |y| y.level == node.level)) { - let mut save = node.right.take_unwrap(); + let mut save = node.right.take().assert(); swap(&mut node.right, &mut save.left); // save.left now None save.level += 1; swap(node, &mut save); @@ -1527,7 +1574,7 @@ fn remove(node: &mut Option>>, fn heir_swap(node: &mut Box>, child: &mut Option>>) { // *could* be done without recursion, but it won't borrow check - for x in child.mut_iter() { + for x in child.iter_mut() { if x.right.is_some() { heir_swap(node, &mut x.right); } else { @@ -1548,7 +1595,7 @@ fn remove(node: &mut Option>>, Equal => { if save.left.is_some() { if save.right.is_some() { - let mut left = save.left.take_unwrap(); + let mut left = save.left.take().assert(); if left.right.is_some() { heir_swap(save, &mut left.right); } else { @@ -1558,13 +1605,13 @@ fn remove(node: &mut Option>>, save.left = Some(left); (remove(&mut save.left, key), true) } else { - let new = save.left.take_unwrap(); + let new = save.left.take().assert(); let box TreeNode{value, ..} = replace(save, new); - *save = save.left.take_unwrap(); + *save = save.left.take().assert(); (Some(value), true) } } else if save.right.is_some() { - let new = save.right.take_unwrap(); + let new = save.right.take().assert(); let box TreeNode{value, ..} = replace(save, new); (Some(value), true) } else { @@ -1583,18 +1630,18 @@ fn remove(node: &mut Option>>, if right_level > save.level { let save_level = save.level; - for x in save.right.mut_iter() { x.level = save_level } + for x in save.right.iter_mut() { x.level = save_level } } skew(save); - for right in save.right.mut_iter() { + for right in save.right.iter_mut() { skew(right); - for x in right.right.mut_iter() { skew(x) } + for x in right.right.iter_mut() { skew(x) } } split(save); - for x in save.right.mut_iter() { split(x) } + for x in save.right.iter_mut() { split(x) } } return ret; @@ -1736,7 +1783,7 @@ mod test_treemap { assert!(m.insert(5i, 2i)); assert!(m.insert(2, 9)); assert!(!m.insert(2, 11)); - assert_eq!(m.find(&2).unwrap(), &11); + assert_eq!(m.find(&2).assert(), &11); } #[test] @@ -1774,7 +1821,7 @@ mod test_treemap { assert_eq!(ctrl.is_empty(), map.is_empty()); for x in ctrl.iter() { let &(ref k, ref v) = x; - assert!(map.find(k).unwrap() == v) + assert!(map.find(k).assert() == v) } for (map_k, map_v) in map.iter() { let mut found = false; @@ -1854,7 +1901,7 @@ mod test_treemap { for _ in range(0u, 30) { let r = rng.gen_range(0, ctrl.len()); - let (key, _) = ctrl.remove(r).unwrap(); + let (key, _) = ctrl.remove(r).assert(); assert!(map.remove(&key)); check_structure(&map); check_equal(ctrl.as_slice(), &map); @@ -1909,13 +1956,13 @@ mod test_treemap { for i in range(1i, 198i) { let mut lb_it = m.lower_bound(&i); - let (&k, &v) = lb_it.next().unwrap(); + let (&k, &v) = lb_it.next().assert(); let lb = i + i % 2; assert_eq!(lb, k); assert_eq!(lb * 2, v); let mut ub_it = m.upper_bound(&i); - let (&k, &v) = ub_it.next().unwrap(); + let (&k, &v) = ub_it.next().assert(); let ub = i + 2 - i % 2; assert_eq!(ub, k); assert_eq!(ub * 2, v); @@ -1949,7 +1996,7 @@ mod test_treemap { assert!(m.insert(i, 100 * i)); } - for (i, (&k, v)) in m.mut_iter().enumerate() { + for (i, (&k, v)) in m.iter_mut().enumerate() { *v += k * 10 + i; // 000 + 00 + 0, 100 + 10 + 1, ... } @@ -1964,7 +2011,7 @@ mod test_treemap { assert!(m.insert(i, 100 * i)); } - for (i, (&k, v)) in m.mut_rev_iter().enumerate() { + for (i, (&k, v)) in m.rev_iter_mut().enumerate() { *v += k * 10 + (9 - i); // 900 + 90 + (9 - 0), 800 + 80 + (9 - 1), ... } @@ -1983,23 +2030,23 @@ mod test_treemap { } for i in range(1i, 199) { - let mut lb_it = m_lower.mut_lower_bound(&i); - let (&k, v) = lb_it.next().unwrap(); + let mut lb_it = m_lower.lower_bound_mut(&i); + let (&k, v) = lb_it.next().assert(); let lb = i + i % 2; assert_eq!(lb, k); *v -= k; } for i in range(0i, 198) { - let mut ub_it = m_upper.mut_upper_bound(&i); - let (&k, v) = ub_it.next().unwrap(); + let mut ub_it = m_upper.upper_bound_mut(&i); + let (&k, v) = ub_it.next().assert(); let ub = i + 2 - i % 2; assert_eq!(ub, k); *v -= k; } - assert!(m_lower.mut_lower_bound(&199).next().is_none()); + assert!(m_lower.lower_bound_mut(&199).next().is_none()); - assert!(m_upper.mut_upper_bound(&198).next().is_none()); + assert!(m_upper.upper_bound_mut(&198).next().is_none()); assert!(m_lower.iter().all(|(_, &x)| x == 0)); assert!(m_upper.iter().all(|(_, &x)| x == 0)); @@ -2008,7 +2055,7 @@ mod test_treemap { #[test] fn test_keys() { let vec = vec![(1i, 'a'), (2i, 'b'), (3i, 'c')]; - let map = vec.move_iter().collect::>(); + let map = vec.iter_owned().collect::>(); let keys = map.keys().map(|&k| k).collect::>(); assert_eq!(keys.len(), 3); assert!(keys.contains(&1)); @@ -2019,7 +2066,7 @@ mod test_treemap { #[test] fn test_values() { let vec = vec![(1i, 'a'), (2i, 'b'), (3i, 'c')]; - let map = vec.move_iter().collect::>(); + let map = vec.iter_owned().collect::>(); let values = map.values().map(|&v| v).collect::>(); assert_eq!(values.len(), 3); assert!(values.contains(&'a')); @@ -2109,11 +2156,11 @@ mod test_treemap { let m = m; let mut a = m.iter(); - assert_eq!(a.next().unwrap(), (&x1, &y1)); - assert_eq!(a.next().unwrap(), (&x2, &y2)); - assert_eq!(a.next().unwrap(), (&x3, &y3)); - assert_eq!(a.next().unwrap(), (&x4, &y4)); - assert_eq!(a.next().unwrap(), (&x5, &y5)); + assert_eq!(a.next().assert(), (&x1, &y1)); + assert_eq!(a.next().assert(), (&x2, &y2)); + assert_eq!(a.next().assert(), (&x3, &y3)); + assert_eq!(a.next().assert(), (&x4, &y4)); + assert_eq!(a.next().assert(), (&x5, &y5)); assert!(a.next().is_none()); @@ -2323,7 +2370,7 @@ mod test_set { let s: TreeSet = range(0i, 5).collect(); let mut n = 0; - for x in s.move_iter() { + for x in s.iter_owned() { assert_eq!(x, n); n += 1; } @@ -2331,9 +2378,9 @@ mod test_set { #[test] fn test_move_iter_size_hint() { - let s: TreeSet = vec!(0i, 1).move_iter().collect(); + let s: TreeSet = vec!(0i, 1).iter_owned().collect(); - let mut it = s.move_iter(); + let mut it = s.iter_owned(); assert_eq!(it.size_hint(), (2, Some(2))); assert!(it.next() != None); @@ -2470,10 +2517,10 @@ mod test_set { // FIXME: #5801: this needs a type hint to compile... let result: Option<(&uint, & &'static str)> = z.next(); - assert_eq!(result.unwrap(), (&5u, &("bar"))); + assert_eq!(result.assert(), (&5u, &("bar"))); let result: Option<(&uint, & &'static str)> = z.next(); - assert_eq!(result.unwrap(), (&11u, &("foo"))); + assert_eq!(result.assert(), (&11u, &("foo"))); let result: Option<(&uint, & &'static str)> = z.next(); assert!(result.is_none()); diff --git a/src/libcollections/trie.rs b/src/libcollections/trie.rs index ec7ed91917730..72d67fad2c0d4 100644 --- a/src/libcollections/trie.rs +++ b/src/libcollections/trie.rs @@ -262,6 +262,12 @@ impl TrieMap { iter } + /// Deprecated: renamed to `iter_mut`. + #[deprecated = "renamed to iter_mut"] + pub fn mut_iter<'a>(&'a mut self) -> EntriesMut<'a, T> { + self.iter_mut() + } + /// Get an iterator over the key-value pairs in the map, with the /// ability to mutate the values. /// @@ -271,7 +277,7 @@ impl TrieMap { /// use std::collections::TrieMap; /// let mut map: TrieMap = [(1, 2), (2, 4), (3, 6)].iter().map(|&x| x).collect(); /// - /// for (key, value) in map.mut_iter() { + /// for (key, value) in map.iter_mut() { /// *value = -(key as int); /// } /// @@ -279,9 +285,9 @@ impl TrieMap { /// assert_eq!(map.find(&2), Some(&-2)); /// assert_eq!(map.find(&3), Some(&-3)); /// ``` - pub fn mut_iter<'a>(&'a mut self) -> MutEntries<'a, T> { - let mut iter = unsafe {MutEntries::new()}; - iter.stack[0] = self.root.children.mut_iter(); + pub fn iter_mut<'a>(&'a mut self) -> EntriesMut<'a, T> { + let mut iter = unsafe {EntriesMut::new()}; + iter.stack[0] = self.root.children.iter_mut(); iter.length = 1; iter.remaining_min = self.length; iter.remaining_max = self.length; @@ -418,15 +424,22 @@ impl TrieMap { pub fn upper_bound<'a>(&'a self, key: uint) -> Entries<'a, T> { self.bound(key, true) } + // If `upper` is true then returns upper_bound else returns lower_bound. #[inline] - fn mut_bound<'a>(&'a mut self, key: uint, upper: bool) -> MutEntries<'a, T> { - bound!(MutEntries, self = self, + fn bound_mut<'a>(&'a mut self, key: uint, upper: bool) -> EntriesMut<'a, T> { + bound!(EntriesMut, self = self, key = key, is_upper = upper, slice_from = mut_slice_from, iter = mut_iter, mutability = mut) } + /// Deprecated: renamed to `lower_bound_mut`. + #[deprecated = "renamed to lower_bound_mut"] + pub fn mut_lower_bound<'a>(&'a mut self, key: uint) -> EntriesMut<'a, T> { + self.lower_bound_mut(key) + } + /// Get an iterator pointing to the first key-value pair whose key is not less than `key`. /// If all keys in the map are less than `key` an empty iterator is returned. /// @@ -436,11 +449,11 @@ impl TrieMap { /// use std::collections::TrieMap; /// let mut map: TrieMap<&str> = [(2, "a"), (4, "b"), (6, "c")].iter().map(|&x| x).collect(); /// - /// assert_eq!(map.mut_lower_bound(4).next(), Some((4, &mut "b"))); - /// assert_eq!(map.mut_lower_bound(5).next(), Some((6, &mut "c"))); - /// assert_eq!(map.mut_lower_bound(10).next(), None); + /// assert_eq!(map.lower_bound_mut(4).next(), Some((4, &mut "b"))); + /// assert_eq!(map.lower_bound_mut(5).next(), Some((6, &mut "c"))); + /// assert_eq!(map.lower_bound_mut(10).next(), None); /// - /// for (key, value) in map.mut_lower_bound(4) { + /// for (key, value) in map.lower_bound_mut(4) { /// *value = "changed"; /// } /// @@ -448,8 +461,14 @@ impl TrieMap { /// assert_eq!(map.find(&4), Some(&"changed")); /// assert_eq!(map.find(&6), Some(&"changed")); /// ``` - pub fn mut_lower_bound<'a>(&'a mut self, key: uint) -> MutEntries<'a, T> { - self.mut_bound(key, false) + pub fn lower_bound_mut<'a>(&'a mut self, key: uint) -> EntriesMut<'a, T> { + self.bound_mut(key, false) + } + + /// Deprecated: renamed to `upper_bound_mut`. + #[deprecated = "renamed to upper_bound_mut"] + pub fn mut_upper_bound<'a>(&'a mut self, key: uint) -> EntriesMut<'a, T> { + self.upper_bound_mut(key) } /// Get an iterator pointing to the first key-value pair whose key is greater than `key`. @@ -461,11 +480,11 @@ impl TrieMap { /// use std::collections::TrieMap; /// let mut map: TrieMap<&str> = [(2, "a"), (4, "b"), (6, "c")].iter().map(|&x| x).collect(); /// - /// assert_eq!(map.mut_upper_bound(4).next(), Some((6, &mut "c"))); - /// assert_eq!(map.mut_upper_bound(5).next(), Some((6, &mut "c"))); - /// assert_eq!(map.mut_upper_bound(10).next(), None); + /// assert_eq!(map.upper_bound_mut(4).next(), Some((6, &mut "c"))); + /// assert_eq!(map.upper_bound_mut(5).next(), Some((6, &mut "c"))); + /// assert_eq!(map.upper_bound_mut(10).next(), None); /// - /// for (key, value) in map.mut_upper_bound(4) { + /// for (key, value) in map.upper_bound_mut(4) { /// *value = "changed"; /// } /// @@ -473,8 +492,8 @@ impl TrieMap { /// assert_eq!(map.find(&4), Some(&"b")); /// assert_eq!(map.find(&6), Some(&"changed")); /// ``` - pub fn mut_upper_bound<'a>(&'a mut self, key: uint) -> MutEntries<'a, T> { - self.mut_bound(key, true) + pub fn upper_bound_mut<'a>(&'a mut self, key: uint) -> EntriesMut<'a, T> { + self.bound_mut(key, true) } } @@ -852,13 +871,17 @@ pub struct Entries<'a, T> { /// Forward iterator over the key-value pairs of a map, with the /// values being mutable. -pub struct MutEntries<'a, T> { +pub struct EntriesMut<'a, T> { stack: [slice::MutItems<'a, Child>, .. NUM_CHUNKS], length: uint, remaining_min: uint, remaining_max: uint } +/// Deprecated: renamed to `EntriesMut`. +#[deprecated = "renamed to EntriesMut"] +pub type MutEntries<'a, T> = EntriesMut<'a, T>; + /// Forward iterator over the keys of a map pub type Keys<'a, T> = iter::Map<'static, (uint, &'a T), uint, Entries<'a, T>>; @@ -982,7 +1005,7 @@ macro_rules! iterator_impl { } iterator_impl! { Entries, iter = iter, mutability = } -iterator_impl! { MutEntries, iter = mut_iter, mutability = mut } +iterator_impl! { EntriesMut, iter = mut_iter, mutability = mut } /// Forward iterator over a set. pub struct SetItems<'a> { @@ -1157,7 +1180,7 @@ mod test_map { #[test] fn test_keys() { let vec = vec![(1, 'a'), (2, 'b'), (3, 'c')]; - let map = vec.move_iter().collect::>(); + let map = vec.iter_owned().collect::>(); let keys = map.keys().collect::>(); assert_eq!(keys.len(), 3); assert!(keys.contains(&1)); @@ -1168,7 +1191,7 @@ mod test_map { #[test] fn test_values() { let vec = vec![(1, 'a'), (2, 'b'), (3, 'c')]; - let map = vec.move_iter().collect::>(); + let map = vec.iter_owned().collect::>(); let values = map.values().map(|&v| v).collect::>(); assert_eq!(values.len(), 3); assert!(values.contains(&'a')); @@ -1201,7 +1224,7 @@ mod test_map { #[test] fn test_mut_iter() { let mut empty_map : TrieMap = TrieMap::new(); - assert!(empty_map.mut_iter().next().is_none()); + assert!(empty_map.iter_mut().next().is_none()); let first = uint::MAX - 10000; let last = uint::MAX; @@ -1212,7 +1235,7 @@ mod test_map { } let mut i = 0; - for (k, v) in map.mut_iter() { + for (k, v) in map.iter_mut() { assert_eq!(k, first + i); *v -= k / 2; i += 1; @@ -1265,7 +1288,7 @@ mod test_map { } #[test] - fn test_mut_bound() { + fn test_bound_mut() { let empty_map : TrieMap = TrieMap::new(); assert_eq!(empty_map.lower_bound(0).next(), None); assert_eq!(empty_map.upper_bound(0).next(), None); @@ -1278,23 +1301,23 @@ mod test_map { } for i in range(0u, 199) { - let mut lb_it = m_lower.mut_lower_bound(i); - let (k, v) = lb_it.next().unwrap(); + let mut lb_it = m_lower.lower_bound_mut(i); + let (k, v) = lb_it.next().assert(); let lb = i + i % 2; assert_eq!(lb, k); *v -= k; } for i in range(0u, 198) { - let mut ub_it = m_upper.mut_upper_bound(i); - let (k, v) = ub_it.next().unwrap(); + let mut ub_it = m_upper.upper_bound_mut(i); + let (k, v) = ub_it.next().assert(); let ub = i + 2 - i % 2; assert_eq!(ub, k); *v -= k; } - assert!(m_lower.mut_lower_bound(199).next().is_none()); - assert!(m_upper.mut_upper_bound(198).next().is_none()); + assert!(m_lower.lower_bound_mut(199).next().is_none()); + assert!(m_upper.upper_bound_mut(198).next().is_none()); assert!(m_lower.iter().all(|(_, &x)| x == 0)); assert!(m_upper.iter().all(|(_, &x)| x == 0)); diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs index 39fe57038b0b2..2f606ee7c204c 100644 --- a/src/libcollections/vec.rs +++ b/src/libcollections/vec.rs @@ -255,7 +255,7 @@ impl Vec { let mut lefts = Vec::new(); let mut rights = Vec::new(); - for elt in self.move_iter() { + for elt in self.iter_owned() { if f(&elt) { lefts.push(elt); } else { @@ -440,7 +440,7 @@ impl Clone for Vec { } // reuse the contained values' allocations/resources. - for (place, thing) in self.mut_iter().zip(other.iter()) { + for (place, thing) in self.iter_mut().zip(other.iter()) { place.clone_from(thing) } @@ -726,6 +726,12 @@ impl Vec { } } + /// Deprecated: renamed to `iter_owned`. + #[deprecated = "renamed to iter_owned"] + pub fn move_iter(self) -> ItemsOwned { + self.iter_owned() + } + /// Creates a consuming iterator, that is, one that moves each /// value out of the vector (from start to end). The vector cannot /// be used after calling this. @@ -734,19 +740,19 @@ impl Vec { /// /// ``` /// let v = vec!["a".to_string(), "b".to_string()]; - /// for s in v.move_iter() { + /// for s in v.iter_owned() { /// // s has type String, not &String /// println!("{}", s); /// } /// ``` #[inline] - pub fn move_iter(self) -> MoveItems { + pub fn iter_owned(self) -> ItemsOwned { unsafe { let iter = mem::transmute(self.as_slice().iter()); let ptr = self.ptr; let cap = self.cap; mem::forget(self); - MoveItems { allocation: ptr, cap: cap, iter: iter } + ItemsOwned { allocation: ptr, cap: cap, iter: iter } } } @@ -824,6 +830,11 @@ impl Vec { self.as_slice().iter() } + /// Deprecated: renamed to `iter_mut`. + #[deprecated = "renamed to iter_mut"] + pub fn mut_iter<'a>(&'a mut self) -> MutItems<'a,T> { + self.iter_mut() + } /// Returns an iterator over mutable references to the elements of the /// vector in order. @@ -832,13 +843,13 @@ impl Vec { /// /// ``` /// let mut vec = vec![1i, 2, 3]; - /// for num in vec.mut_iter() { + /// for num in vec.iter_mut() { /// *num = 0; /// } /// ``` #[inline] - pub fn mut_iter<'a>(&'a mut self) -> MutItems<'a,T> { - self.as_mut_slice().mut_iter() + pub fn iter_mut<'a>(&'a mut self) -> MutItems<'a,T> { + self.as_mut_slice().iter_mut() } /// Sort the vector, in place, using `compare` to compare elements. @@ -928,6 +939,12 @@ impl Vec { self.as_slice().last() } + /// Deprecated: renamed to `last_mut`. + #[deprecated = "renamed to last_must"] + pub fn mut_last<'a>(&'a mut self) -> Option<&'a mut T> { + self.last_mut() + } + /// Returns a mutable reference to the last element of a vector, or `None` /// if it is empty. /// @@ -935,12 +952,12 @@ impl Vec { /// /// ``` /// let mut vec = vec![1i, 2, 3]; - /// *vec.mut_last().unwrap() = 4; + /// *vec.last_mut().assert() = 4; /// assert_eq!(vec, vec![1i, 2, 4]); /// ``` #[inline] - pub fn mut_last<'a>(&'a mut self) -> Option<&'a mut T> { - self.as_mut_slice().mut_last() + pub fn last_mut<'a>(&'a mut self) -> Option<&'a mut T> { + self.as_mut_slice().last_mut() } /// Remove an element from anywhere in the vector and return it, replacing @@ -1103,7 +1120,14 @@ impl Vec { /// ``` #[inline] pub fn push_all_move(&mut self, other: Vec) { - self.extend(other.move_iter()); + self.extend(other.iter_owned()); + } + + /// Deprecated: renamed to `slice_mut`. + #[deprecated = "renamed to slice_mut"] + pub fn mut_slice<'a>(&'a mut self, start: uint, end: uint) + -> &'a mut [T] { + self.slice_mut(start, end) } /// Returns a mutable slice of `self` between `start` and `end`. @@ -1117,12 +1141,18 @@ impl Vec { /// /// ``` /// let mut vec = vec![1i, 2, 3, 4]; - /// assert!(vec.mut_slice(0, 2) == [1, 2]); + /// assert!(vec.slice_mut(0, 2) == [1, 2]); /// ``` #[inline] - pub fn mut_slice<'a>(&'a mut self, start: uint, end: uint) + pub fn slice_mut<'a>(&'a mut self, start: uint, end: uint) -> &'a mut [T] { - self.as_mut_slice().mut_slice(start, end) + self.as_mut_slice().slice_mut(start, end) + } + + /// Deprecated: renamed to `slice_from_mut`. + #[deprecated = "renamed to slice_from_mut"] + pub fn mut_slice_from<'a>(&'a mut self, start: uint) -> &'a mut [T] { + self.slice_from_mut(start) } /// Returns a mutable slice of self from `start` to the end of the vec. @@ -1135,11 +1165,17 @@ impl Vec { /// /// ``` /// let mut vec = vec![1i, 2, 3, 4]; - /// assert!(vec.mut_slice_from(2) == [3, 4]); + /// assert!(vec.slice_from_mut(2) == [3, 4]); /// ``` #[inline] - pub fn mut_slice_from<'a>(&'a mut self, start: uint) -> &'a mut [T] { - self.as_mut_slice().mut_slice_from(start) + pub fn slice_from_mut<'a>(&'a mut self, start: uint) -> &'a mut [T] { + self.as_mut_slice().slice_from_mut(start) + } + + /// Deprecated: renamed to `slice_to_mut`. + #[deprecated = "renamed to slice_to_mut"] + pub fn mut_slice_to<'a>(&'a mut self, end: uint) -> &'a mut [T] { + self.slice_to_mut(end) } /// Returns a mutable slice of self from the start of the vec to `end`. @@ -1152,11 +1188,17 @@ impl Vec { /// /// ``` /// let mut vec = vec![1i, 2, 3, 4]; - /// assert!(vec.mut_slice_to(2) == [1, 2]); + /// assert!(vec.slice_to_mut(2) == [1, 2]); /// ``` #[inline] - pub fn mut_slice_to<'a>(&'a mut self, end: uint) -> &'a mut [T] { - self.as_mut_slice().mut_slice_to(end) + pub fn slice_to_mut<'a>(&'a mut self, end: uint) -> &'a mut [T] { + self.as_mut_slice().slice_to_mut(end) + } + + /// Deprecated: renamed to `split_at_mut`. + #[deprecated = "renamed to split_at_mut"] + pub fn mut_split_at<'a>(&'a mut self, mid: uint) -> (&'a mut [T], &'a mut [T]) { + self.split_at_mut(mid) } /// Returns a pair of mutable slices that divides the vec at an index. @@ -1176,26 +1218,26 @@ impl Vec { /// /// // scoped to restrict the lifetime of the borrows /// { - /// let (left, right) = vec.mut_split_at(0); + /// let (left, right) = vec.split_at_mut(0); /// assert!(left == &mut []); /// assert!(right == &mut [1, 2, 3, 4, 5, 6]); /// } /// /// { - /// let (left, right) = vec.mut_split_at(2); + /// let (left, right) = vec.split_at_mut(2); /// assert!(left == &mut [1, 2]); /// assert!(right == &mut [3, 4, 5, 6]); /// } /// /// { - /// let (left, right) = vec.mut_split_at(6); + /// let (left, right) = vec.split_at_mut(6); /// assert!(left == &mut [1, 2, 3, 4, 5, 6]); /// assert!(right == &mut []); /// } /// ``` #[inline] - pub fn mut_split_at<'a>(&'a mut self, mid: uint) -> (&'a mut [T], &'a mut [T]) { - self.as_mut_slice().mut_split_at(mid) + pub fn split_at_mut<'a>(&'a mut self, mid: uint) -> (&'a mut [T], &'a mut [T]) { + self.as_mut_slice().split_at_mut(mid) } /// Reverse the order of elements in a vector, in place. @@ -1611,13 +1653,17 @@ impl MutableSeq for Vec { } /// An iterator that moves out of a vector. -pub struct MoveItems { +pub struct ItemsOwned { allocation: *mut T, // the block of memory allocated for the vector cap: uint, // the capacity of the vector iter: Items<'static, T> } -impl Iterator for MoveItems { +/// Deprecated: renamed to `ItemsOwned`. +#[deprecated = "renamed to ItemsOwned"] +pub type MoveItems = ItemsOwned; + +impl Iterator for ItemsOwned { #[inline] fn next(&mut self) -> Option { unsafe { @@ -1631,7 +1677,7 @@ impl Iterator for MoveItems { } } -impl DoubleEndedIterator for MoveItems { +impl DoubleEndedIterator for ItemsOwned { #[inline] fn next_back(&mut self) -> Option { unsafe { @@ -1641,7 +1687,7 @@ impl DoubleEndedIterator for MoveItems { } #[unsafe_destructor] -impl Drop for MoveItems { +impl Drop for ItemsOwned { fn drop(&mut self) { // destroy the remaining elements if self.cap != 0 { @@ -1787,9 +1833,9 @@ mod tests { fn test_mut_slice_from() { let mut values = Vec::from_slice([1u8,2,3,4,5]); { - let slice = values.mut_slice_from(2); + let slice = values.slice_from_mut(2); assert!(slice == [3, 4, 5]); - for p in slice.mut_iter() { + for p in slice.iter_mut() { *p += 2; } } @@ -1801,9 +1847,9 @@ mod tests { fn test_mut_slice_to() { let mut values = Vec::from_slice([1u8,2,3,4,5]); { - let slice = values.mut_slice_to(2); + let slice = values.slice_to_mut(2); assert!(slice == [1, 2]); - for p in slice.mut_iter() { + for p in slice.iter_mut() { *p += 1; } } @@ -1812,17 +1858,17 @@ mod tests { } #[test] - fn test_mut_split_at() { + fn test_split_at_mut() { let mut values = Vec::from_slice([1u8,2,3,4,5]); { - let (left, right) = values.mut_split_at(2); + let (left, right) = values.split_at_mut(2); assert!(left.slice(0, left.len()) == [1, 2]); - for p in left.mut_iter() { + for p in left.iter_mut() { *p += 1; } assert!(right.slice(0, right.len()) == [3, 4, 5]); - for p in right.mut_iter() { + for p in right.iter_mut() { *p += 2; } } @@ -1899,15 +1945,15 @@ mod tests { for &() in v.iter() {} - assert_eq!(v.mut_iter().count(), 2); + assert_eq!(v.iter_mut().count(), 2); v.push(()); - assert_eq!(v.mut_iter().count(), 3); + assert_eq!(v.iter_mut().count(), 3); v.push(()); - assert_eq!(v.mut_iter().count(), 4); + assert_eq!(v.iter_mut().count(), 4); - for &() in v.mut_iter() {} + for &() in v.iter_mut() {} unsafe { v.set_len(0); } - assert_eq!(v.mut_iter().count(), 0); + assert_eq!(v.iter_mut().count(), 0); } #[test] @@ -2146,7 +2192,7 @@ mod tests { b.bytes = src_len as u64; b.iter(|| { - let dst: Vec = FromIterator::from_iter(src.clone().move_iter()); + let dst: Vec = FromIterator::from_iter(src.clone().iter_owned()); assert_eq!(dst.len(), src_len); assert!(dst.iter().enumerate().all(|(i, x)| i == *x)); }); @@ -2180,7 +2226,7 @@ mod tests { b.iter(|| { let mut dst = dst.clone(); - dst.extend(src.clone().move_iter()); + dst.extend(src.clone().iter_owned()); assert_eq!(dst.len(), dst_len + src_len); assert!(dst.iter().enumerate().all(|(i, x)| i == *x)); }); diff --git a/src/libcore/cell.rs b/src/libcore/cell.rs index 2a7b1630edf68..ab625b8caab60 100644 --- a/src/libcore/cell.rs +++ b/src/libcore/cell.rs @@ -99,7 +99,7 @@ //! // Take a reference to the inside of cache cell //! let mut cache = self.span_tree_cache.borrow_mut(); //! if cache.is_some() { -//! return cache.get_ref().clone(); +//! return cache.as_ref().assert().clone(); //! } //! //! let span_tree = self.calc_span_tree(); diff --git a/src/libcore/fmt/float.rs b/src/libcore/fmt/float.rs index 1bfa5168cf796..1a9b240b3b8d2 100644 --- a/src/libcore/fmt/float.rs +++ b/src/libcore/fmt/float.rs @@ -143,19 +143,19 @@ pub fn float_to_str_bytes_common( // otherwise as well. let mut buf = [0u8, ..1536]; let mut end = 0; - let radix_gen: T = cast(radix as int).unwrap(); + let radix_gen: T = cast(radix as int).assert(); let (num, exp) = match exp_format { ExpNone => (num, 0i32), ExpDec | ExpBin if num == _0 => (num, 0i32), ExpDec | ExpBin => { let (exp, exp_base) = match exp_format { - ExpDec => (num.abs().log10().floor(), cast::(10.0f64).unwrap()), - ExpBin => (num.abs().log2().floor(), cast::(2.0f64).unwrap()), + ExpDec => (num.abs().log10().floor(), cast::(10.0f64).assert()), + ExpBin => (num.abs().log2().floor(), cast::(2.0f64).assert()), ExpNone => fail!("unreachable"), }; - (num / exp_base.powf(exp), cast::(exp).unwrap()) + (num / exp_base.powf(exp), cast::(exp).assert()) } }; @@ -175,8 +175,8 @@ pub fn float_to_str_bytes_common( deccum = deccum / radix_gen; deccum = deccum.trunc(); - let c = char::from_digit(current_digit.to_int().unwrap() as uint, radix); - buf[end] = c.unwrap() as u8; + let c = char::from_digit(current_digit.to_int().assert() as uint, radix); + buf[end] = c.assert() as u8; end += 1; // No more digits to calculate for the non-fractional part -> break @@ -203,7 +203,7 @@ pub fn float_to_str_bytes_common( _ => () } - buf.mut_slice_to(end).reverse(); + buf.slice_to_mut(end).reverse(); // Remember start of the fractional digits. // Points one beyond end of buf if none get generated, @@ -235,9 +235,9 @@ pub fn float_to_str_bytes_common( // See note in first loop. let current_digit = deccum.trunc().abs(); - let c = char::from_digit(current_digit.to_int().unwrap() as uint, + let c = char::from_digit(current_digit.to_int().assert() as uint, radix); - buf[end] = c.unwrap() as u8; + buf[end] = c.assert() as u8; end += 1; // Decrease the deccumulator one fractional digit at a time @@ -250,10 +250,10 @@ pub fn float_to_str_bytes_common( // round the remaining ones. if limit_digits && dig == digit_count { let ascii2value = |chr: u8| { - char::to_digit(chr as char, radix).unwrap() + char::to_digit(chr as char, radix).assert() }; let value2ascii = |val: uint| { - char::from_digit(val, radix).unwrap() as u8 + char::from_digit(val, radix).assert() as u8 }; let extra_digit = ascii2value(buf[end - 1]); @@ -342,7 +342,7 @@ pub fn float_to_str_bytes_common( impl<'a> fmt::FormatWriter for Filler<'a> { fn write(&mut self, bytes: &[u8]) -> fmt::Result { - slice::bytes::copy_memory(self.buf.mut_slice_from(*self.end), + slice::bytes::copy_memory(self.buf.slice_from_mut(*self.end), bytes); *self.end += bytes.len(); Ok(()) diff --git a/src/libcore/fmt/mod.rs b/src/libcore/fmt/mod.rs index 48bbc8401fe96..752f8d2337481 100644 --- a/src/libcore/fmt/mod.rs +++ b/src/libcore/fmt/mod.rs @@ -300,7 +300,7 @@ impl<'a> Formatter<'a> { // Extract the correct argument let value = match arg.position { - rt::ArgumentNext => { *self.curarg.next().unwrap() } + rt::ArgumentNext => { *self.curarg.next().assert() } rt::ArgumentIs(i) => self.args[i], }; @@ -319,7 +319,7 @@ impl<'a> Formatter<'a> { unsafe { Some(*(v as *const _ as *const uint)) } } rt::CountIsNextParam => { - let v = self.curarg.next().unwrap().value; + let v = self.curarg.next().assert().value; unsafe { Some(*(v as *const _ as *const uint)) } } } @@ -361,7 +361,7 @@ impl<'a> Formatter<'a> { // Writes the sign if it exists, and then the prefix if it was requested let write_prefix = |f: &mut Formatter| { - for c in sign.move_iter() { + for c in sign.iter_owned() { let mut b = [0, ..4]; let n = c.encode_utf8(b); try!(f.buf.write(b.slice_to(n))); diff --git a/src/libcore/fmt/num.rs b/src/libcore/fmt/num.rs index bba3e4cb9afcc..a572d97dcba46 100644 --- a/src/libcore/fmt/num.rs +++ b/src/libcore/fmt/num.rs @@ -37,25 +37,25 @@ trait GenericRadix { // The radix can be as low as 2, so we need a buffer of at least 64 // characters for a base 2 number. let mut buf = [0u8, ..64]; - let base = cast(self.base()).unwrap(); + let base = cast(self.base()).assert(); let mut curr = buf.len(); let is_positive = x >= zero(); if is_positive { // Accumulate each digit of the number from the least significant // to the most significant figure. - for byte in buf.mut_iter().rev() { + for byte in buf.iter_mut().rev() { let n = x % base; // Get the current place value. x = x / base; // Deaccumulate the number. - *byte = self.digit(cast(n).unwrap()); // Store the digit in the buffer. + *byte = self.digit(cast(n).assert()); // Store the digit in the buffer. curr -= 1; if x == zero() { break; } // No more digits left to accumulate. } } else { // Do the same as above, but accounting for two's complement. - for byte in buf.mut_iter().rev() { + for byte in buf.iter_mut().rev() { let n = -(x % base); // Get the current place value. x = x / base; // Deaccumulate the number. - *byte = self.digit(cast(n).unwrap()); // Store the digit in the buffer. + *byte = self.digit(cast(n).assert()); // Store the digit in the buffer. curr -= 1; if x == zero() { break; } // No more digits left to accumulate. } diff --git a/src/libcore/iter.rs b/src/libcore/iter.rs index b8ed8bdf92394..497d79b2c2c94 100644 --- a/src/libcore/iter.rs +++ b/src/libcore/iter.rs @@ -117,8 +117,8 @@ pub trait Iterator { /// let a = [0i]; /// let b = [1i]; /// let mut it = a.iter().chain(b.iter()); - /// assert_eq!(it.next().unwrap(), &0); - /// assert_eq!(it.next().unwrap(), &1); + /// assert_eq!(it.next().assert(), &0); + /// assert_eq!(it.next().assert(), &1); /// assert!(it.next().is_none()); /// ``` #[inline] @@ -138,7 +138,7 @@ pub trait Iterator { /// let b = [1i]; /// let mut it = a.iter().zip(b.iter()); /// let (x0, x1) = (0i, 1i); - /// assert_eq!(it.next().unwrap(), (&x0, &x1)); + /// assert_eq!(it.next().assert(), (&x0, &x1)); /// assert!(it.next().is_none()); /// ``` #[inline] @@ -154,8 +154,8 @@ pub trait Iterator { /// ```rust /// let a = [1i, 2]; /// let mut it = a.iter().map(|&x| 2 * x); - /// assert_eq!(it.next().unwrap(), 2); - /// assert_eq!(it.next().unwrap(), 4); + /// assert_eq!(it.next().assert(), 2); + /// assert_eq!(it.next().assert(), 4); /// assert!(it.next().is_none()); /// ``` #[inline] @@ -172,7 +172,7 @@ pub trait Iterator { /// ```rust /// let a = [1i, 2]; /// let mut it = a.iter().filter(|&x| *x > 1); - /// assert_eq!(it.next().unwrap(), &2); + /// assert_eq!(it.next().assert(), &2); /// assert!(it.next().is_none()); /// ``` #[inline] @@ -189,7 +189,7 @@ pub trait Iterator { /// ```rust /// let a = [1i, 2]; /// let mut it = a.iter().filter_map(|&x| if x > 1 {Some(2 * x)} else {None}); - /// assert_eq!(it.next().unwrap(), 4); + /// assert_eq!(it.next().assert(), 4); /// assert!(it.next().is_none()); /// ``` #[inline] @@ -206,8 +206,8 @@ pub trait Iterator { /// let a = [100i, 200]; /// let mut it = a.iter().enumerate(); /// let (x100, x200) = (100i, 200i); - /// assert_eq!(it.next().unwrap(), (0, &x100)); - /// assert_eq!(it.next().unwrap(), (1, &x200)); + /// assert_eq!(it.next().assert(), (0, &x100)); + /// assert_eq!(it.next().assert(), (1, &x200)); /// assert!(it.next().is_none()); /// ``` #[inline] @@ -224,12 +224,12 @@ pub trait Iterator { /// ```rust /// let xs = [100i, 200, 300]; /// let mut it = xs.iter().map(|x| *x).peekable(); - /// assert_eq!(*it.peek().unwrap(), 100); - /// assert_eq!(it.next().unwrap(), 100); - /// assert_eq!(it.next().unwrap(), 200); - /// assert_eq!(*it.peek().unwrap(), 300); - /// assert_eq!(*it.peek().unwrap(), 300); - /// assert_eq!(it.next().unwrap(), 300); + /// assert_eq!(*it.peek().assert(), 100); + /// assert_eq!(it.next().assert(), 100); + /// assert_eq!(it.next().assert(), 200); + /// assert_eq!(*it.peek().assert(), 300); + /// assert_eq!(*it.peek().assert(), 300); + /// assert_eq!(it.next().assert(), 300); /// assert!(it.peek().is_none()); /// assert!(it.next().is_none()); /// ``` @@ -247,9 +247,9 @@ pub trait Iterator { /// ```rust /// let a = [1i, 2, 3, 2, 1]; /// let mut it = a.iter().skip_while(|&a| *a < 3); - /// assert_eq!(it.next().unwrap(), &3); - /// assert_eq!(it.next().unwrap(), &2); - /// assert_eq!(it.next().unwrap(), &1); + /// assert_eq!(it.next().assert(), &3); + /// assert_eq!(it.next().assert(), &2); + /// assert_eq!(it.next().assert(), &1); /// assert!(it.next().is_none()); /// ``` #[inline] @@ -266,8 +266,8 @@ pub trait Iterator { /// ```rust /// let a = [1i, 2, 3, 2, 1]; /// let mut it = a.iter().take_while(|&a| *a < 3); - /// assert_eq!(it.next().unwrap(), &1); - /// assert_eq!(it.next().unwrap(), &2); + /// assert_eq!(it.next().assert(), &1); + /// assert_eq!(it.next().assert(), &2); /// assert!(it.next().is_none()); /// ``` #[inline] @@ -283,8 +283,8 @@ pub trait Iterator { /// ```rust /// let a = [1i, 2, 3, 4, 5]; /// let mut it = a.iter().skip(3); - /// assert_eq!(it.next().unwrap(), &4); - /// assert_eq!(it.next().unwrap(), &5); + /// assert_eq!(it.next().assert(), &4); + /// assert_eq!(it.next().assert(), &5); /// assert!(it.next().is_none()); /// ``` #[inline] @@ -300,9 +300,9 @@ pub trait Iterator { /// ```rust /// let a = [1i, 2, 3, 4, 5]; /// let mut it = a.iter().take(3); - /// assert_eq!(it.next().unwrap(), &1); - /// assert_eq!(it.next().unwrap(), &2); - /// assert_eq!(it.next().unwrap(), &3); + /// assert_eq!(it.next().assert(), &1); + /// assert_eq!(it.next().assert(), &2); + /// assert_eq!(it.next().assert(), &3); /// assert!(it.next().is_none()); /// ``` #[inline] @@ -323,11 +323,11 @@ pub trait Iterator { /// *fac = *fac * x; /// Some(*fac) /// }); - /// assert_eq!(it.next().unwrap(), 1); - /// assert_eq!(it.next().unwrap(), 2); - /// assert_eq!(it.next().unwrap(), 6); - /// assert_eq!(it.next().unwrap(), 24); - /// assert_eq!(it.next().unwrap(), 120); + /// assert_eq!(it.next().assert(), 1); + /// assert_eq!(it.next().assert(), 2); + /// assert_eq!(it.next().assert(), 6); + /// assert_eq!(it.next().assert(), 24); + /// assert_eq!(it.next().assert(), 120); /// assert!(it.next().is_none()); /// ``` #[inline] @@ -383,7 +383,7 @@ pub trait Iterator { /// sum /// } /// let x = vec![1i,2,3,7,8,9]; - /// assert_eq!(process(x.move_iter()), 1006); + /// assert_eq!(process(x.iter_owned()), 1006); /// ``` #[inline] fn fuse(self) -> Fuse { @@ -476,7 +476,7 @@ pub trait Iterator { /// ```rust /// let a = [1i, 2, 3, 4, 5]; /// let mut it = a.iter(); - /// assert!(it.nth(2).unwrap() == &3); + /// assert!(it.nth(2).assert() == &3); /// assert!(it.nth(2) == None); /// ``` #[inline] @@ -495,7 +495,7 @@ pub trait Iterator { /// /// ```rust /// let a = [1i, 2, 3, 4, 5]; - /// assert!(a.iter().last().unwrap() == &5); + /// assert!(a.iter().last().assert() == &5); /// ``` #[inline] fn last(&mut self) -> Option { @@ -598,7 +598,7 @@ pub trait Iterator { /// /// ```rust /// let xs = [-3i, 0, 1, 5, -10]; - /// assert_eq!(*xs.iter().max_by(|x| x.abs()).unwrap(), -10); + /// assert_eq!(*xs.iter().max_by(|x| x.abs()).assert(), -10); /// ``` #[inline] fn max_by(&mut self, f: |&A| -> B) -> Option { @@ -622,7 +622,7 @@ pub trait Iterator { /// /// ```rust /// let xs = [-3i, 0, 1, 5, -10]; - /// assert_eq!(*xs.iter().min_by(|x| x.abs()).unwrap(), 0); + /// assert_eq!(*xs.iter().min_by(|x| x.abs()).assert(), 0); /// ``` #[inline] fn min_by(&mut self, f: |&A| -> B) -> Option { @@ -850,7 +850,7 @@ pub trait OrdIterator { /// /// ```rust /// let a = [1i, 2, 3, 4, 5]; - /// assert!(a.iter().max().unwrap() == &5); + /// assert!(a.iter().max().assert() == &5); /// ``` fn max(&mut self) -> Option; @@ -860,7 +860,7 @@ pub trait OrdIterator { /// /// ```rust /// let a = [1i, 2, 3, 4, 5]; - /// assert!(a.iter().min().unwrap() == &1); + /// assert!(a.iter().min().assert() == &1); /// ``` fn min(&mut self) -> Option; @@ -1686,7 +1686,7 @@ impl<'a, A, T: Iterator, B, U: Iterator> Iterator for FlatMap<'a, A, T, #[inline] fn next(&mut self) -> Option { loop { - for inner in self.frontiter.mut_iter() { + for inner in self.frontiter.iter_mut() { for x in *inner { return Some(x) } @@ -1717,7 +1717,7 @@ impl<'a, #[inline] fn next_back(&mut self) -> Option { loop { - for inner in self.backiter.mut_iter() { + for inner in self.backiter.iter_mut() { match inner.next_back() { None => (), y => return y diff --git a/src/libcore/num/mod.rs b/src/libcore/num/mod.rs index 2b7249aca1247..68d52f9ff0e51 100644 --- a/src/libcore/num/mod.rs +++ b/src/libcore/num/mod.rs @@ -1135,7 +1135,7 @@ impl_from_primitive!(f64, to_f64) /// ``` /// use std::num; /// -/// let twenty: f32 = num::cast(0x14i).unwrap(); +/// let twenty: f32 = num::cast(0x14i).assert(); /// assert_eq!(twenty, 20f32); /// ``` /// diff --git a/src/libcore/option.rs b/src/libcore/option.rs index f8293aeb03d19..df7c40af7c80b 100644 --- a/src/libcore/option.rs +++ b/src/libcore/option.rs @@ -230,7 +230,8 @@ impl Option { // Getting to contained values ///////////////////////////////////////////////////////////////////////// - /// Unwraps an option, yielding the content of a `Some` + /// Moves a value out of the `Some` variant and returns it, consuming the + /// `Option`. /// /// # Failure /// @@ -244,6 +245,8 @@ impl Option { } } + /// Deprecated. Use `assert` instead. + /// /// Moves a value out of an option type and returns it, consuming the `Option`. /// /// # Failure @@ -256,6 +259,7 @@ impl Option { /// Instead, prefer to use pattern matching and handle the `None` /// case explicitly. #[inline] + #[deprecated = "use assert instead"] pub fn unwrap(self) -> T { match self { Some(val) => val, @@ -263,6 +267,25 @@ impl Option { } } + /// Moves a value out of the `Some` variant and returns it, consuming the + /// `Option`. + /// + /// # Failure + /// + /// Fails if the self value equals `None`. + /// + /// # Safety note + /// + /// In general, because this function may fail, its use is discouraged. + /// Instead, prefer to use pattern matching and handle the `None` + /// case explicitly. + pub fn assert(self) -> T { + match self { + Some(val) => val, + None => fail!("called `Option::assert()` on a `None` value"), + } + } + /// Returns the contained value or a default. #[inline] pub fn unwrap_or(self, def: T) -> T { @@ -272,7 +295,7 @@ impl Option { } } - /// Returns the contained value or computes it from a closure. + /// Returns the contained value or computes a default from a closure. #[inline] pub fn unwrap_or_else(self, f: || -> T) -> T { match self { @@ -311,7 +334,7 @@ impl Option { /// Returns true if the contained value was mutated. pub fn mutate(&mut self, f: |T| -> T) -> bool { if self.is_some() { - *self = Some(f(self.take_unwrap())); + *self = Some(f(self.take().assert())); true } else { false } } @@ -320,7 +343,7 @@ impl Option { /// Returns true if the contained value was mutated, or false if set to the default. pub fn mutate_or_set(&mut self, def: T, f: |T| -> T) -> bool { if self.is_some() { - *self = Some(f(self.take_unwrap())); + *self = Some(f(self.take().assert())); true } else { *self = Some(def); @@ -338,15 +361,29 @@ impl Option { Item{opt: self.as_ref()} } - /// Returns a mutable iterator over the possibly contained value. + /// Deprecated: renamed to `iter_mut`. + #[deprecated = "renamed to iter_mut"] #[inline] pub fn mut_iter<'r>(&'r mut self) -> Item<&'r mut T> { + self.iter_mut() + } + + /// Returns a mutable iterator over the possibly contained value. + #[inline] + pub fn iter_mut<'r>(&'r mut self) -> Item<&'r mut T> { Item{opt: self.as_mut()} } - /// Returns a consuming iterator over the possibly contained value. + /// Deprecated: renamed to `iter_owned`. + #[deprecated = "renamed to iter_owned"] #[inline] pub fn move_iter(self) -> Item { + self.iter_owned() + } + + /// Returns a consuming iterator over the possibly contained value. + #[inline] + pub fn iter_owned(self) -> Item { Item{opt: self} } @@ -434,6 +471,7 @@ impl Option { /// /// Fails if the value equals `None`. #[inline] + #[deprecated = "use .take().assert() instead"] pub fn take_unwrap(&mut self) -> T { match self.take() { Some(x) => x, @@ -454,6 +492,7 @@ impl Option { /// Instead, prefer to use pattern matching and handle the `None` /// case explicitly. #[inline] + #[deprecated = "use .as_ref().assert() instead"] pub fn get_ref<'a>(&'a self) -> &'a T { match *self { Some(ref x) => x, @@ -474,6 +513,7 @@ impl Option { /// Instead, prefer to use pattern matching and handle the `None` /// case explicitly. #[inline] + #[deprecated = "use .as_mut().assert() instead"] pub fn get_mut_ref<'a>(&'a mut self) -> &'a mut T { match *self { Some(ref mut x) => x, diff --git a/src/libcore/ptr.rs b/src/libcore/ptr.rs index eb9bede85d8b2..05dfb478c4912 100644 --- a/src/libcore/ptr.rs +++ b/src/libcore/ptr.rs @@ -113,6 +113,11 @@ pub use intrinsics::set_memory; #[unstable = "may need a different name after pending changes to pointer types"] pub fn null() -> *const T { 0 as *const T } +/// Deprecated: renamed to `null_mut`. +#[inline] +#[deprecated = "renamed to null_mut"] +pub fn mut_null() -> *mut T { null_mut() } + /// Create an unsafe mutable null pointer. /// /// # Example @@ -120,12 +125,12 @@ pub fn null() -> *const T { 0 as *const T } /// ``` /// use std::ptr; /// -/// let p: *mut int = ptr::mut_null(); +/// let p: *mut int = ptr::null_mut(); /// assert!(p.is_null()); /// ``` #[inline] #[unstable = "may need a different name after pending changes to pointer types"] -pub fn mut_null() -> *mut T { 0 as *mut T } +pub fn null_mut() -> *mut T { 0 as *mut T } /// Zeroes out `count * size_of::` bytes of memory at `dst` #[inline] @@ -304,7 +309,7 @@ impl RawPtr for *const T { impl RawPtr for *mut T { #[inline] - fn null() -> *mut T { mut_null() } + fn null() -> *mut T { null_mut() } #[inline] fn is_null(&self) -> bool { *self == RawPtr::null() } diff --git a/src/libcore/result.rs b/src/libcore/result.rs index 980a9c7506f36..fe6c7ed2c7e3c 100644 --- a/src/libcore/result.rs +++ b/src/libcore/result.rs @@ -78,7 +78,7 @@ //! let bad_result: Result = bad_result.or_else(|i| Ok(11)); //! //! // Consume the result and return the contents with `unwrap`. -//! let final_awesome_result = good_result.ok().unwrap(); +//! let final_awesome_result = good_result.ok().assert(); //! ~~~ //! //! # Results must be used @@ -534,13 +534,17 @@ impl Result { } impl Result { - /// Unwraps a result, yielding the content of an `Ok`. + /// Deprecated. Use `assert` instead. + /// + /// Moves a value out of the `Ok` variant and returns it, consuming the + /// `Result`. /// /// # Failure /// /// Fails if the value is an `Err`, with a custom failure message provided /// by the `Err`'s value. #[inline] + #[deprecated = "use assert instead"] pub fn unwrap(self) -> T { match self { Ok(t) => t, @@ -548,16 +552,36 @@ impl Result { fail!("called `Result::unwrap()` on an `Err` value: {}", e) } } + + /// Moves a value out of the `Ok` variant and returns it, consuming the + /// `Result`. + /// + /// # Failure + /// + /// Fails if the value is an `Err`, with a custom failure message provided + /// by the `Err`'s value. + #[inline] + pub fn assert(self) -> T { + match self { + Ok(t) => t, + Err(e) => + fail!("called `Result::assert()` on an `Err` value: {}", e) + } + } } impl Result { - /// Unwraps a result, yielding the content of an `Err`. + /// Deprecated. Use `assert_err` instead. + /// + /// Moves a value out of the `Err` variant and returns it, consuming the + /// `Result`. /// /// # Failure /// /// Fails if the value is an `Ok`, with a custom failure message provided /// by the `Ok`'s value. #[inline] + #[deprecated = "use assert_err instead"] pub fn unwrap_err(self) -> E { match self { Ok(t) => @@ -565,6 +589,22 @@ impl Result { Err(e) => e } } + + /// Moves a value out of the `Err` variant and returns it, consuming the + /// `Result`. + /// + /// # Failure + /// + /// Fails if the value is an `Ok`, with a custom failure message provided + /// by the `Ok`'s value. + #[inline] + pub fn assert_err(self) -> E { + match self { + Ok(t) => + fail!("called `Result::assert_err()` on an `Ok` value: {}", t), + Err(e) => e + } + } } ///////////////////////////////////////////////////////////////////////////// diff --git a/src/libcore/slice.rs b/src/libcore/slice.rs index d3b761f9665d4..37515b9481e84 100644 --- a/src/libcore/slice.rs +++ b/src/libcore/slice.rs @@ -405,85 +405,76 @@ pub trait MutableVector<'a, T> { /// Returns a mutable reference to the element at the given index, /// or `None` if the index is out of bounds fn get_mut(self, index: uint) -> Option<&'a mut T>; + /// Work with `self` as a mut slice. /// Primarily intended for getting a &mut [T] from a [T, ..N]. fn as_mut_slice(self) -> &'a mut [T]; /// Return a slice that points into another slice. - fn mut_slice(self, start: uint, end: uint) -> &'a mut [T]; + fn slice_mut(self, start: uint, end: uint) -> &'a mut [T]; - /** - * Returns a slice of self from `start` to the end of the vec. - * - * Fails when `start` points outside the bounds of self. - */ - fn mut_slice_from(self, start: uint) -> &'a mut [T]; + /// Returns a slice of self from `start` to the end of the vec. + /// + /// Fails when `start` points outside the bounds of self. + fn slice_from_mut(self, start: uint) -> &'a mut [T]; - /** - * Returns a slice of self from the start of the vec to `end`. - * - * Fails when `end` points outside the bounds of self. - */ - fn mut_slice_to(self, end: uint) -> &'a mut [T]; + /// Returns a slice of self from the start of the vec to `end`. + /// + /// Fails when `end` points outside the bounds of self. + fn slice_to_mut(self, end: uint) -> &'a mut [T]; /// Returns an iterator that allows modifying each value - fn mut_iter(self) -> MutItems<'a, T>; + fn iter_mut(self) -> ItemsMut<'a, T>; /// Returns a mutable pointer to the last item in the vector. - fn mut_last(self) -> Option<&'a mut T>; + fn last_mut(self) -> Option<&'a mut T>; /// Returns an iterator over the mutable subslices of the vector /// which are separated by elements that match `pred`. The /// matched element is not contained in the subslices. - fn mut_split(self, pred: |&T|: 'a -> bool) -> MutSplits<'a, T>; + fn split_mut(self, pred: |&T|: 'a -> bool) -> SplitsMut<'a, T>; - /** - * Returns an iterator over `size` elements of the vector at a time. - * The chunks are mutable and do not overlap. If `size` does not divide the - * length of the vector, then the last chunk will not have length - * `size`. - * - * # Failure - * - * Fails if `size` is 0. - */ - fn mut_chunks(self, chunk_size: uint) -> MutChunks<'a, T>; + /// Returns an iterator over `size` elements of the vector at a time. + /// The chunks are mutable and do not overlap. If `size` does not divide the + /// length of the vector, then the last chunk will not have length + /// `size`. + /// + /// # Failure + /// + /// Fails if `size` is 0. + fn chunks_mut(self, chunk_size: uint) -> ChunksMut<'a, T>; - /** - * Returns a mutable reference to the first element in this slice - * and adjusts the slice in place so that it no longer contains - * that element. O(1). - * - * Equivalent to: - * - * ```ignore - * if self.len() == 0 { return None; } - * let head = &mut self[0]; - * *self = self.mut_slice_from(1); - * Some(head) - * ``` - * - * Returns `None` if slice is empty - */ - fn mut_shift_ref(&mut self) -> Option<&'a mut T>; + /// Returns a mutable reference to the first element in this slice + /// and adjusts the slice in place so that it no longer contains + /// that element. O(1). + /// + /// Equivalent to: + /// + /// ```ignore + /// if self.len() == 0 { return None; } + /// let head = &mut self[0]; + /// *self = self.slice_from_mut(1); + /// Some(head) + /// ``` + /// + /// Returns `None` if slice is empty + fn shift_mut(&mut self) -> Option<&'a mut T>; - /** - * Returns a mutable reference to the last element in this slice - * and adjusts the slice in place so that it no longer contains - * that element. O(1). - * - * Equivalent to: - * - * ```ignore - * if self.len() == 0 { return None; } - * let tail = &mut self[self.len() - 1]; - * *self = self.mut_slice_to(self.len() - 1); - * Some(tail) - * ``` - * - * Returns `None` if slice is empty. - */ - fn mut_pop_ref(&mut self) -> Option<&'a mut T>; + /// Returns a mutable reference to the last element in this slice + /// and adjusts the slice in place so that it no longer contains + /// that element. O(1). + /// + /// Equivalent to: + /// + /// ```ignore + /// if self.len() == 0 { return None; } + /// let tail = &mut self[self.len() - 1]; + /// *self = self.slice_to_mut(self.len() - 1); + /// Some(tail) + /// ``` + /// + /// Returns `None` if slice is empty. + fn pop_mut(&mut self) -> Option<&'a mut T>; /// Swaps two elements in a vector. /// @@ -519,24 +510,24 @@ pub trait MutableVector<'a, T> { /// /// // scoped to restrict the lifetime of the borrows /// { - /// let (left, right) = v.mut_split_at(0); + /// let (left, right) = v.split_at_mut(0); /// assert!(left == &mut []); /// assert!(right == &mut [1i, 2, 3, 4, 5, 6]); /// } /// /// { - /// let (left, right) = v.mut_split_at(2); + /// let (left, right) = v.split_at_mut(2); /// assert!(left == &mut [1i, 2]); /// assert!(right == &mut [3i, 4, 5, 6]); /// } /// /// { - /// let (left, right) = v.mut_split_at(6); + /// let (left, right) = v.split_at_mut(6); /// assert!(left == &mut [1i, 2, 3, 4, 5, 6]); /// assert!(right == &mut []); /// } /// ``` - fn mut_split_at(self, mid: uint) -> (&'a mut [T], &'a mut [T]); + fn split_at_mut(self, mid: uint) -> (&'a mut [T], &'a mut [T]); /// Reverse the order of elements in a vector, in place. /// @@ -605,6 +596,66 @@ pub trait MutableVector<'a, T> { /// ignores move semantics. `self` and `src` must not /// overlap. Fails if `self` is shorter than `src`. unsafe fn copy_memory(self, src: &[T]); + + /// Deprecated: renamed to `slice_mut`. + #[deprecated = "renamed to slice_mut"] + fn mut_slice(self, start: uint, end: uint) -> &'a mut [T] { + self.slice_mut(start, end) + } + + /// Deprecated: renamed to `slice_from_mut`. + #[deprecated = "renamed to slice_from_mut"] + fn mut_slice_from(self, start: uint) -> &'a mut [T] { + self.slice_from_mut(start) + } + + /// Deprecated: renamed to `slice_to_mut`. + #[deprecated = "renamed to slice_to_mut"] + fn mut_slice_to(self, end: uint) -> &'a mut [T] { + self.slice_to_mut(end) + } + + /// Deprecated: renamed to `iter_mut`. + #[deprecated = "renamed to iter_mut"] + fn mut_iter(self) -> ItemsMut<'a, T> { + self.iter_mut() + } + + /// Deprecated: renamed to `last_mut`. + #[deprecated = "renamed to last_mut"] + fn mut_last(self) -> Option<&'a mut T> { + self.last_mut() + } + + /// Deprecated: renamed to `split_mut`. + #[deprecated = "renamed to split_mut"] + fn mut_split(self, pred: |&T|: 'a -> bool) -> SplitsMut<'a, T> { + self.split_mut(pred) + } + + /// Deprecated: renamed to `chunks_mut`. + #[deprecated = "renamed to chunks_mut"] + fn mut_chunks(self, chunk_size: uint) -> ChunksMut<'a, T> { + self.chunks_mut(chunk_size) + } + + /// Deprecated: renamed to `shift_mut`. + #[deprecated = "renamed to shift_mut"] + fn mut_shift_ref(&mut self) -> Option<&'a mut T> { + self.shift_mut() + } + + /// Deprecated: renamed to `pop_mut`. + #[deprecated = "renamed to pop_mut"] + fn mut_pop_ref(&mut self) -> Option<&'a mut T> { + self.pop_mut() + } + + /// Deprecated: renamed to `split_at_mut` + #[deprecated = "renamed to split_at_mut"] + fn mut_split_at(self, mid: uint) -> (&'a mut [T], &'a mut [T]) { + self.split_at_mut(mid) + } } impl<'a,T> MutableVector<'a, T> for &'a mut [T] { @@ -616,7 +667,7 @@ impl<'a,T> MutableVector<'a, T> for &'a mut [T] { #[inline] fn as_mut_slice(self) -> &'a mut [T] { self } - fn mut_slice(self, start: uint, end: uint) -> &'a mut [T] { + fn slice_mut(self, start: uint, end: uint) -> &'a mut [T] { assert!(start <= end); assert!(end <= self.len()); unsafe { @@ -628,36 +679,36 @@ impl<'a,T> MutableVector<'a, T> for &'a mut [T] { } #[inline] - fn mut_slice_from(self, start: uint) -> &'a mut [T] { + fn slice_from_mut(self, start: uint) -> &'a mut [T] { let len = self.len(); - self.mut_slice(start, len) + self.slice_mut(start, len) } #[inline] - fn mut_slice_to(self, end: uint) -> &'a mut [T] { - self.mut_slice(0, end) + fn slice_to_mut(self, end: uint) -> &'a mut [T] { + self.slice_mut(0, end) } #[inline] - fn mut_split_at(self, mid: uint) -> (&'a mut [T], &'a mut [T]) { + fn split_at_mut(self, mid: uint) -> (&'a mut [T], &'a mut [T]) { unsafe { let len = self.len(); let self2: &'a mut [T] = mem::transmute_copy(&self); - (self.mut_slice(0, mid), self2.mut_slice(mid, len)) + (self.slice_mut(0, mid), self2.slice_mut(mid, len)) } } #[inline] - fn mut_iter(self) -> MutItems<'a, T> { + fn iter_mut(self) -> ItemsMut<'a, T> { unsafe { let p = self.as_mut_ptr(); if mem::size_of::() == 0 { - MutItems{ptr: p, + ItemsMut{ptr: p, end: (p as uint + self.len()) as *mut T, marker: marker::ContravariantLifetime::<'a>, marker2: marker::NoCopy} } else { - MutItems{ptr: p, + ItemsMut{ptr: p, end: p.offset(self.len() as int), marker: marker::ContravariantLifetime::<'a>, marker2: marker::NoCopy} @@ -666,24 +717,24 @@ impl<'a,T> MutableVector<'a, T> for &'a mut [T] { } #[inline] - fn mut_last(self) -> Option<&'a mut T> { + fn last_mut(self) -> Option<&'a mut T> { let len = self.len(); if len == 0 { return None; } Some(&mut self[len - 1]) } #[inline] - fn mut_split(self, pred: |&T|: 'a -> bool) -> MutSplits<'a, T> { - MutSplits { v: self, pred: pred, finished: false } + fn split_mut(self, pred: |&T|: 'a -> bool) -> SplitsMut<'a, T> { + SplitsMut { v: self, pred: pred, finished: false } } #[inline] - fn mut_chunks(self, chunk_size: uint) -> MutChunks<'a, T> { + fn chunks_mut(self, chunk_size: uint) -> ChunksMut<'a, T> { assert!(chunk_size > 0); - MutChunks { v: self, chunk_size: chunk_size } + ChunksMut { v: self, chunk_size: chunk_size } } - fn mut_shift_ref(&mut self) -> Option<&'a mut T> { + fn shift_mut(&mut self) -> Option<&'a mut T> { unsafe { let s: &mut Slice = transmute(self); match raw::shift_ptr(s) { @@ -695,7 +746,7 @@ impl<'a,T> MutableVector<'a, T> for &'a mut [T] { } } - fn mut_pop_ref(&mut self) -> Option<&'a mut T> { + fn pop_mut(&mut self) -> Option<&'a mut T> { unsafe { let s: &mut Slice = transmute(self); match raw::pop_ptr(s) { @@ -844,7 +895,7 @@ pub trait MutableCloneableVector { impl<'a, T:Clone> MutableCloneableVector for &'a mut [T] { #[inline] fn copy_from(self, src: &[T]) -> uint { - for (a, b) in self.mut_iter().zip(src.iter()) { + for (a, b) in self.iter_mut().zip(src.iter()) { a.clone_from(b); } cmp::min(self.len(), src.len()) @@ -888,7 +939,7 @@ impl<'a, T> Default for &'a [T] { // Iterators // -// The shared definition of the `Item` and `MutItems` iterators +// The shared definition of the `Item` and `ItemsMut` iterators macro_rules! iterator { (struct $name:ident -> $ptr:ty, $elem:ty) => { impl<'a, T> Iterator<$elem> for $name<'a, T> { @@ -992,16 +1043,20 @@ impl<'a, T> RandomAccessIterator<&'a T> for Items<'a, T> { } /// Mutable slice iterator -pub struct MutItems<'a, T> { +pub struct ItemsMut<'a, T> { ptr: *mut T, end: *mut T, marker: marker::ContravariantLifetime<'a>, marker2: marker::NoCopy } -iterator!{struct MutItems -> *mut T, &'a mut T} +/// Deprecated: renamed to `ItemsMut` +#[deprecated = "renamed to ItemsMut"] +pub type MutItems<'a, T> = ItemsMut<'a, T>; + +iterator!{struct ItemsMut -> *mut T, &'a mut T} -impl<'a, T> ExactSize<&'a mut T> for MutItems<'a, T> {} +impl<'a, T> ExactSize<&'a mut T> for ItemsMut<'a, T> {} /// An iterator over the slices of a vector separated by elements that /// match a predicate function. @@ -1060,13 +1115,17 @@ impl<'a, T> DoubleEndedIterator<&'a [T]> for Splits<'a, T> { /// An iterator over the subslices of the vector which are separated /// by elements that match `pred`. -pub struct MutSplits<'a, T> { +pub struct SplitsMut<'a, T> { v: &'a mut [T], pred: |t: &T|: 'a -> bool, finished: bool } -impl<'a, T> Iterator<&'a mut [T]> for MutSplits<'a, T> { +/// Deprecated: renamed to `SplitsMut` +#[deprecated = "renamed to SplitsMut"] +pub type MutSplits<'a, T> = SplitsMut<'a, T>; + +impl<'a, T> Iterator<&'a mut [T]> for SplitsMut<'a, T> { #[inline] fn next(&mut self) -> Option<&'a mut [T]> { if self.finished { return None; } @@ -1077,14 +1136,14 @@ impl<'a, T> Iterator<&'a mut [T]> for MutSplits<'a, T> { self.finished = true; let tmp = mem::replace(&mut self.v, &mut []); let len = tmp.len(); - let (head, tail) = tmp.mut_split_at(len); + let (head, tail) = tmp.split_at_mut(len); self.v = tail; Some(head) } Some(idx) => { let tmp = mem::replace(&mut self.v, &mut []); - let (head, tail) = tmp.mut_split_at(idx); - self.v = tail.mut_slice_from(1); + let (head, tail) = tmp.split_at_mut(idx); + self.v = tail.slice_from_mut(1); Some(head) } } @@ -1102,7 +1161,7 @@ impl<'a, T> Iterator<&'a mut [T]> for MutSplits<'a, T> { } } -impl<'a, T> DoubleEndedIterator<&'a mut [T]> for MutSplits<'a, T> { +impl<'a, T> DoubleEndedIterator<&'a mut [T]> for SplitsMut<'a, T> { #[inline] fn next_back(&mut self) -> Option<&'a mut [T]> { if self.finished { return None; } @@ -1116,9 +1175,9 @@ impl<'a, T> DoubleEndedIterator<&'a mut [T]> for MutSplits<'a, T> { } Some(idx) => { let tmp = mem::replace(&mut self.v, &mut []); - let (head, tail) = tmp.mut_split_at(idx); + let (head, tail) = tmp.split_at_mut(idx); self.v = head; - Some(tail.mut_slice_from(1)) + Some(tail.slice_from_mut(1)) } } } @@ -1263,12 +1322,16 @@ impl<'a, T> RandomAccessIterator<&'a [T]> for Chunks<'a, T> { /// An iterator over a vector in (non-overlapping) mutable chunks (`size` elements at a time). When /// the vector len is not evenly divided by the chunk size, the last slice of the iteration will be /// the remainder. -pub struct MutChunks<'a, T> { +pub struct ChunksMut<'a, T> { v: &'a mut [T], chunk_size: uint } -impl<'a, T> Iterator<&'a mut [T]> for MutChunks<'a, T> { +/// Deprecated: renamed to `ChunksMut` +#[deprecated = "renamed to ChunksMut"] +pub type MutChunks<'a, T> = ChunksMut<'a, T>; + +impl<'a, T> Iterator<&'a mut [T]> for ChunksMut<'a, T> { #[inline] fn next(&mut self) -> Option<&'a mut [T]> { if self.v.len() == 0 { @@ -1276,7 +1339,7 @@ impl<'a, T> Iterator<&'a mut [T]> for MutChunks<'a, T> { } else { let sz = cmp::min(self.v.len(), self.chunk_size); let tmp = mem::replace(&mut self.v, &mut []); - let (head, tail) = tmp.mut_split_at(sz); + let (head, tail) = tmp.split_at_mut(sz); self.v = tail; Some(head) } @@ -1294,7 +1357,7 @@ impl<'a, T> Iterator<&'a mut [T]> for MutChunks<'a, T> { } } -impl<'a, T> DoubleEndedIterator<&'a mut [T]> for MutChunks<'a, T> { +impl<'a, T> DoubleEndedIterator<&'a mut [T]> for ChunksMut<'a, T> { #[inline] fn next_back(&mut self) -> Option<&'a mut [T]> { if self.v.len() == 0 { @@ -1304,7 +1367,7 @@ impl<'a, T> DoubleEndedIterator<&'a mut [T]> for MutChunks<'a, T> { let sz = if remainder != 0 { remainder } else { self.chunk_size }; let tmp = mem::replace(&mut self.v, &mut []); let tmp_len = tmp.len(); - let (head, tail) = tmp.mut_split_at(tmp_len - sz); + let (head, tail) = tmp.split_at_mut(tmp_len - sz); self.v = head; Some(tail) } diff --git a/src/libcoretest/iter.rs b/src/libcoretest/iter.rs index d25ffb5b84c8a..c141276e9fe0b 100644 --- a/src/libcoretest/iter.rs +++ b/src/libcoretest/iter.rs @@ -119,16 +119,16 @@ fn test_iterator_enumerate() { fn test_iterator_peekable() { let xs = vec![0u, 1, 2, 3, 4, 5]; let mut it = xs.iter().map(|&x|x).peekable(); - assert_eq!(it.peek().unwrap(), &0); - assert_eq!(it.next().unwrap(), 0); - assert_eq!(it.next().unwrap(), 1); - assert_eq!(it.next().unwrap(), 2); - assert_eq!(it.peek().unwrap(), &3); - assert_eq!(it.peek().unwrap(), &3); - assert_eq!(it.next().unwrap(), 3); - assert_eq!(it.next().unwrap(), 4); - assert_eq!(it.peek().unwrap(), &5); - assert_eq!(it.next().unwrap(), 5); + assert_eq!(it.peek().assert(), &0); + assert_eq!(it.next().assert(), 0); + assert_eq!(it.next().assert(), 1); + assert_eq!(it.next().assert(), 2); + assert_eq!(it.peek().assert(), &3); + assert_eq!(it.peek().assert(), &3); + assert_eq!(it.next().assert(), 3); + assert_eq!(it.next().assert(), 4); + assert_eq!(it.peek().assert(), &5); + assert_eq!(it.next().assert(), 5); assert!(it.peek().is_none()); assert!(it.next().is_none()); } @@ -270,7 +270,7 @@ fn test_cycle() { fn test_iterator_nth() { let v = &[0i, 1, 2, 3, 4]; for i in range(0u, v.len()) { - assert_eq!(v.iter().nth(i).unwrap(), &v[i]); + assert_eq!(v.iter().nth(i).assert(), &v[i]); } assert_eq!(v.iter().nth(v.len()), None); } @@ -278,8 +278,8 @@ fn test_iterator_nth() { #[test] fn test_iterator_last() { let v = &[0i, 1, 2, 3, 4]; - assert_eq!(v.iter().last().unwrap(), &4); - assert_eq!(v.slice(0, 1).iter().last().unwrap(), &0); + assert_eq!(v.iter().last().assert(), &4); + assert_eq!(v.slice(0, 1).iter().last().assert(), &0); } #[test] @@ -387,16 +387,16 @@ fn test_any() { #[test] fn test_find() { let v: &[int] = &[1i, 3, 9, 27, 103, 14, 11]; - assert_eq!(*v.iter().find(|x| *x & 1 == 0).unwrap(), 14); - assert_eq!(*v.iter().find(|x| *x % 3 == 0).unwrap(), 3); + assert_eq!(*v.iter().find(|x| *x & 1 == 0).assert(), 14); + assert_eq!(*v.iter().find(|x| *x % 3 == 0).assert(), 3); assert!(v.iter().find(|x| *x % 12 == 0).is_none()); } #[test] fn test_position() { let v = &[1i, 3, 9, 27, 103, 14, 11]; - assert_eq!(v.iter().position(|x| *x & 1 == 0).unwrap(), 5); - assert_eq!(v.iter().position(|x| *x % 3 == 0).unwrap(), 1); + assert_eq!(v.iter().position(|x| *x & 1 == 0).assert(), 5); + assert_eq!(v.iter().position(|x| *x % 3 == 0).assert(), 1); assert!(v.iter().position(|x| *x % 12 == 0).is_none()); } @@ -411,13 +411,13 @@ fn test_count() { #[test] fn test_max_by() { let xs: &[int] = &[-3i, 0, 1, 5, -10]; - assert_eq!(*xs.iter().max_by(|x| x.abs()).unwrap(), -10); + assert_eq!(*xs.iter().max_by(|x| x.abs()).assert(), -10); } #[test] fn test_min_by() { let xs: &[int] = &[-3i, 0, 1, 5, -10]; - assert_eq!(*xs.iter().min_by(|x| x.abs()).unwrap(), 0); + assert_eq!(*xs.iter().min_by(|x| x.abs()).assert(), 0); } #[test] @@ -483,9 +483,9 @@ fn test_double_ended_zip() { fn test_double_ended_filter() { let xs = [1i, 2, 3, 4, 5, 6]; let mut it = xs.iter().filter(|&x| *x & 1 == 0); - assert_eq!(it.next_back().unwrap(), &6); - assert_eq!(it.next_back().unwrap(), &4); - assert_eq!(it.next().unwrap(), &2); + assert_eq!(it.next_back().assert(), &6); + assert_eq!(it.next_back().assert(), &4); + assert_eq!(it.next().assert(), &2); assert_eq!(it.next_back(), None); } @@ -493,9 +493,9 @@ fn test_double_ended_filter() { fn test_double_ended_filter_map() { let xs = [1i, 2, 3, 4, 5, 6]; let mut it = xs.iter().filter_map(|&x| if x & 1 == 0 { Some(x * 2) } else { None }); - assert_eq!(it.next_back().unwrap(), 12); - assert_eq!(it.next_back().unwrap(), 8); - assert_eq!(it.next().unwrap(), 4); + assert_eq!(it.next_back().assert(), 12); + assert_eq!(it.next_back().assert(), 8); + assert_eq!(it.next().assert(), 4); assert_eq!(it.next_back(), None); } @@ -504,14 +504,14 @@ fn test_double_ended_chain() { let xs = [1i, 2, 3, 4, 5]; let ys = [7i, 9, 11]; let mut it = xs.iter().chain(ys.iter()).rev(); - assert_eq!(it.next().unwrap(), &11) - assert_eq!(it.next().unwrap(), &9) - assert_eq!(it.next_back().unwrap(), &1) - assert_eq!(it.next_back().unwrap(), &2) - assert_eq!(it.next_back().unwrap(), &3) - assert_eq!(it.next_back().unwrap(), &4) - assert_eq!(it.next_back().unwrap(), &5) - assert_eq!(it.next_back().unwrap(), &7) + assert_eq!(it.next().assert(), &11) + assert_eq!(it.next().assert(), &9) + assert_eq!(it.next_back().assert(), &1) + assert_eq!(it.next_back().assert(), &2) + assert_eq!(it.next_back().assert(), &3) + assert_eq!(it.next_back().assert(), &4) + assert_eq!(it.next_back().assert(), &5) + assert_eq!(it.next_back().assert(), &7) assert_eq!(it.next_back(), None) } @@ -567,13 +567,13 @@ fn test_double_ended_flat_map() { let u = [0u,1]; let v = [5u,6,7,8]; let mut it = u.iter().flat_map(|x| v.slice(*x, v.len()).iter()); - assert_eq!(it.next_back().unwrap(), &8); - assert_eq!(it.next().unwrap(), &5); - assert_eq!(it.next_back().unwrap(), &7); - assert_eq!(it.next_back().unwrap(), &6); - assert_eq!(it.next_back().unwrap(), &8); - assert_eq!(it.next().unwrap(), &6); - assert_eq!(it.next_back().unwrap(), &7); + assert_eq!(it.next_back().assert(), &8); + assert_eq!(it.next().assert(), &5); + assert_eq!(it.next_back().assert(), &7); + assert_eq!(it.next_back().assert(), &6); + assert_eq!(it.next_back().assert(), &8); + assert_eq!(it.next().assert(), &6); + assert_eq!(it.next_back().assert(), &7); assert_eq!(it.next_back(), None); assert_eq!(it.next(), None); assert_eq!(it.next_back(), None); @@ -584,17 +584,17 @@ fn test_random_access_chain() { let xs = [1i, 2, 3, 4, 5]; let ys = [7i, 9, 11]; let mut it = xs.iter().chain(ys.iter()); - assert_eq!(it.idx(0).unwrap(), &1); - assert_eq!(it.idx(5).unwrap(), &7); - assert_eq!(it.idx(7).unwrap(), &11); + assert_eq!(it.idx(0).assert(), &1); + assert_eq!(it.idx(5).assert(), &7); + assert_eq!(it.idx(7).assert(), &11); assert!(it.idx(8).is_none()); it.next(); it.next(); it.next_back(); - assert_eq!(it.idx(0).unwrap(), &3); - assert_eq!(it.idx(4).unwrap(), &9); + assert_eq!(it.idx(0).assert(), &3); + assert_eq!(it.idx(4).assert(), &9); assert!(it.idx(6).is_none()); check_randacc_iter(it, xs.len() + ys.len() - 3); @@ -794,7 +794,7 @@ fn test_range_step_inclusive() { #[test] fn test_reverse() { let mut ys = [1i, 2, 3, 4, 5]; - ys.mut_iter().reverse_(); + ys.iter_mut().reverse_(); assert!(ys == [5, 4, 3, 2, 1]); } @@ -867,9 +867,9 @@ fn bench_skip_while(b: &mut Bencher) { fn bench_multiple_take(b: &mut Bencher) { let mut it = range(0u, 42).cycle(); b.iter(|| { - let n = it.next().unwrap(); + let n = it.next().assert(); for m in range(0u, n) { - it.take(it.next().unwrap()).all(|_| true); + it.take(it.next().assert()).all(|_| true); } }); } diff --git a/src/libcoretest/num/mod.rs b/src/libcoretest/num/mod.rs index 8bb238c0b66e8..785cd6e8c4b1b 100644 --- a/src/libcoretest/num/mod.rs +++ b/src/libcoretest/num/mod.rs @@ -25,11 +25,11 @@ mod uint; /// Helper function for testing numeric operations pub fn test_num(ten: T, two: T) { - assert_eq!(ten.add(&two), cast(12i).unwrap()); - assert_eq!(ten.sub(&two), cast(8i).unwrap()); - assert_eq!(ten.mul(&two), cast(20i).unwrap()); - assert_eq!(ten.div(&two), cast(5i).unwrap()); - assert_eq!(ten.rem(&two), cast(0i).unwrap()); + assert_eq!(ten.add(&two), cast(12i).assert()); + assert_eq!(ten.sub(&two), cast(8i).assert()); + assert_eq!(ten.mul(&two), cast(20i).assert()); + assert_eq!(ten.div(&two), cast(5i).assert()); + assert_eq!(ten.rem(&two), cast(0i).assert()); assert_eq!(ten.add(&two), ten + two); assert_eq!(ten.sub(&two), ten - two); diff --git a/src/libcoretest/option.rs b/src/libcoretest/option.rs index 776637f3be97d..af78f6a950d54 100644 --- a/src/libcoretest/option.rs +++ b/src/libcoretest/option.rs @@ -18,7 +18,7 @@ fn test_get_ptr() { let x = box 0i; let addr_x: *const int = mem::transmute(&*x); let opt = Some(x); - let y = opt.unwrap(); + let y = opt.assert(); let addr_y: *const int = mem::transmute(&*y); assert_eq!(addr_x, addr_y); } @@ -29,7 +29,7 @@ fn test_get_str() { let x = "test".to_string(); let addr_x = x.as_slice().as_ptr(); let opt = Some(x); - let y = opt.unwrap(); + let y = opt.assert(); let addr_y = y.as_slice().as_ptr(); assert_eq!(addr_x, addr_y); } @@ -62,7 +62,7 @@ fn test_get_resource() { { let x = r(i.clone()); let opt = Some(x); - let _y = opt.unwrap(); + let _y = opt.assert(); } assert_eq!(*i.borrow(), 1); } @@ -73,7 +73,7 @@ fn test_option_dance() { let mut y = Some(5i); let mut y2 = 0; for _x in x.iter() { - y2 = y.take_unwrap(); + y2 = y.take().assert(); } assert_eq!(y2, 5); assert!(y.is_none()); @@ -82,8 +82,8 @@ fn test_option_dance() { #[test] #[should_fail] fn test_option_too_much_dance() { let mut y = Some(marker::NoCopy); - let _y2 = y.take_unwrap(); - let _y3 = y.take_unwrap(); + let _y2 = y.take().assert(); + let _y3 = y.take().assert(); } #[test] @@ -146,8 +146,8 @@ fn test_option_while_some() { #[test] fn test_unwrap() { - assert_eq!(Some(1i).unwrap(), 1); - let s = Some("hello".to_string()).unwrap(); + assert_eq!(Some(1i).assert(), 1); + let s = Some("hello".to_string()).assert(); assert_eq!(s.as_slice(), "hello"); } @@ -155,14 +155,14 @@ fn test_unwrap() { #[should_fail] fn test_unwrap_fail1() { let x: Option = None; - x.unwrap(); + x.assert(); } #[test] #[should_fail] fn test_unwrap_fail2() { let x: Option = None; - x.unwrap(); + x.assert(); } #[test] @@ -187,7 +187,7 @@ fn test_unwrap_or_else() { fn test_filtered() { let some_stuff = Some(42i); let modified_stuff = some_stuff.filtered(|&x| {x < 10}); - assert_eq!(some_stuff.unwrap(), 42); + assert_eq!(some_stuff.assert(), 42); assert!(modified_stuff.is_none()); } @@ -211,7 +211,7 @@ fn test_mut_iter() { let mut x = Some(val); { - let mut it = x.mut_iter(); + let mut it = x.iter_mut(); assert_eq!(it.size_hint(), (1, Some(1))); @@ -272,7 +272,7 @@ fn test_collect() { // test that it does not take more elements than it needs let mut functions = [|| Some(()), || None, || fail!()]; - let v: Option> = collect(functions.mut_iter().map(|f| (*f)())); + let v: Option> = collect(functions.iter_mut().map(|f| (*f)())); assert!(v == None); } diff --git a/src/libcoretest/ptr.rs b/src/libcoretest/ptr.rs index 9058ae56c45e4..b31d54770b7b2 100644 --- a/src/libcoretest/ptr.rs +++ b/src/libcoretest/ptr.rs @@ -92,7 +92,7 @@ fn test_is_null() { assert!(!q.is_null()); assert!(q.is_not_null()); - let mp: *mut int = mut_null(); + let mp: *mut int = null_mut(); assert!(mp.is_null()); assert!(!mp.is_not_null()); @@ -108,13 +108,13 @@ fn test_to_option() { assert_eq!(p.to_option(), None); let q: *const int = &2; - assert_eq!(q.to_option().unwrap(), &2); + assert_eq!(q.to_option().assert(), &2); - let p: *mut int = mut_null(); + let p: *mut int = null_mut(); assert_eq!(p.to_option(), None); let q: *mut int = &mut 2; - assert_eq!(q.to_option().unwrap(), &2); + assert_eq!(q.to_option().assert(), &2); } } @@ -230,7 +230,7 @@ fn test_ptr_array_each() { fn test_ptr_array_each_with_len_null_ptr() { unsafe { array_each_with_len(0 as *const *const libc::c_char, 1, |e| { - CString::new(e, false).as_str().unwrap(); + CString::new(e, false).as_str().assert(); }); } } @@ -239,7 +239,7 @@ fn test_ptr_array_each_with_len_null_ptr() { fn test_ptr_array_each_null_ptr() { unsafe { array_each(0 as *const *const libc::c_char, |e| { - CString::new(e, false).as_str().unwrap(); + CString::new(e, false).as_str().assert(); }); } } diff --git a/src/libcoretest/result.rs b/src/libcoretest/result.rs index 7c7e0a542cd87..e35270ee5948a 100644 --- a/src/libcoretest/result.rs +++ b/src/libcoretest/result.rs @@ -16,43 +16,43 @@ pub fn op2() -> Result { Err("sadface") } #[test] pub fn test_and() { - assert_eq!(op1().and(Ok(667i)).unwrap(), 667); - assert_eq!(op1().and(Err::<(), &'static str>("bad")).unwrap_err(), + assert_eq!(op1().and(Ok(667i)).assert(), 667); + assert_eq!(op1().and(Err::<(), &'static str>("bad")).assert_err(), "bad"); - assert_eq!(op2().and(Ok(667i)).unwrap_err(), "sadface"); - assert_eq!(op2().and(Err::<(),&'static str>("bad")).unwrap_err(), + assert_eq!(op2().and(Ok(667i)).assert_err(), "sadface"); + assert_eq!(op2().and(Err::<(),&'static str>("bad")).assert_err(), "sadface"); } #[test] pub fn test_and_then() { - assert_eq!(op1().and_then(|i| Ok::(i + 1)).unwrap(), 667); - assert_eq!(op1().and_then(|_| Err::("bad")).unwrap_err(), + assert_eq!(op1().and_then(|i| Ok::(i + 1)).assert(), 667); + assert_eq!(op1().and_then(|_| Err::("bad")).assert_err(), "bad"); - assert_eq!(op2().and_then(|i| Ok::(i + 1)).unwrap_err(), + assert_eq!(op2().and_then(|i| Ok::(i + 1)).assert_err(), "sadface"); - assert_eq!(op2().and_then(|_| Err::("bad")).unwrap_err(), + assert_eq!(op2().and_then(|_| Err::("bad")).assert_err(), "sadface"); } #[test] pub fn test_or() { - assert_eq!(op1().or(Ok(667)).unwrap(), 666); - assert_eq!(op1().or(Err("bad")).unwrap(), 666); + assert_eq!(op1().or(Ok(667)).assert(), 666); + assert_eq!(op1().or(Err("bad")).assert(), 666); - assert_eq!(op2().or(Ok(667)).unwrap(), 667); - assert_eq!(op2().or(Err("bad")).unwrap_err(), "bad"); + assert_eq!(op2().or(Ok(667)).assert(), 667); + assert_eq!(op2().or(Err("bad")).assert_err(), "bad"); } #[test] pub fn test_or_else() { - assert_eq!(op1().or_else(|_| Ok::(667)).unwrap(), 666); - assert_eq!(op1().or_else(|e| Err::(e)).unwrap(), 666); + assert_eq!(op1().or_else(|_| Ok::(667)).assert(), 666); + assert_eq!(op1().or_else(|e| Err::(e)).assert(), 666); - assert_eq!(op2().or_else(|_| Ok::(667)).unwrap(), 667); - assert_eq!(op2().or_else(|e| Err::(e)).unwrap_err(), + assert_eq!(op2().or_else(|_| Ok::(667)).assert(), 667); + assert_eq!(op2().or_else(|e| Err::(e)).assert_err(), "sadface"); } @@ -83,7 +83,7 @@ fn test_collect() { // test that it does not take more elements than it needs let mut functions = [|| Ok(()), || Err(1i), || fail!()]; - let v: Result, int> = collect(functions.mut_iter().map(|f| (*f)())); + let v: Result, int> = collect(functions.iter_mut().map(|f| (*f)())); assert!(v == Err(1)); } @@ -103,7 +103,7 @@ fn test_fold() { // test that it does not take more elements than it needs let mut functions = [|| Ok(()), || Err(1i), || fail!()]; - assert_eq!(fold_(functions.mut_iter() + assert_eq!(fold_(functions.iter_mut() .map(|f| (*f)())), Err(1)); } diff --git a/src/libdebug/repr.rs b/src/libdebug/repr.rs index b85097e6623dc..74493a923a4f9 100644 --- a/src/libdebug/repr.rs +++ b/src/libdebug/repr.rs @@ -108,7 +108,7 @@ impl<'a> MovePtr for ReprVisitor<'a> { self.ptr_stk.push(self.ptr); } fn pop_ptr(&mut self) { - self.ptr = self.ptr_stk.pop().unwrap(); + self.ptr = self.ptr_stk.pop().assert(); } } @@ -438,7 +438,7 @@ impl<'a> TyVisitor for ReprVisitor<'a> { n_fields: uint, name: &str) -> bool { let mut write = false; - match self.var_stk.pop().unwrap() { + match self.var_stk.pop().assert() { SearchingFor(sought) => { if disr_val == sought { self.var_stk.push(Matched); @@ -501,7 +501,7 @@ impl<'a> TyVisitor for ReprVisitor<'a> { _sz: uint, _align: uint) -> bool { - match self.var_stk.pop().unwrap() { + match self.var_stk.pop().assert() { SearchingFor(..) => fail!("enum value matched no variant"), _ => true } @@ -566,8 +566,8 @@ pub fn write_repr(writer: &mut io::Writer, object: &T) -> io::IoResult<()> { pub fn repr_to_string(t: &T) -> String { let mut result = io::MemWriter::new(); - write_repr(&mut result as &mut io::Writer, t).unwrap(); - String::from_utf8(result.unwrap()).unwrap() + write_repr(&mut result as &mut io::Writer, t).assert(); + String::from_utf8(result.unwrap()).assert() } #[cfg(test)] @@ -582,8 +582,8 @@ fn test_repr() { fn exact_test(t: &T, e:&str) { let mut m = io::MemWriter::new(); - write_repr(&mut m as &mut io::Writer, t).unwrap(); - let s = String::from_utf8(m.unwrap()).unwrap(); + write_repr(&mut m as &mut io::Writer, t).assert(); + let s = String::from_utf8(m.assert()).assert(); assert_eq!(s.as_slice(), e); } diff --git a/src/libflate/lib.rs b/src/libflate/lib.rs index 4226ac14118a4..da653b4d04daa 100644 --- a/src/libflate/lib.rs +++ b/src/libflate/lib.rs @@ -124,7 +124,7 @@ mod tests { for _ in range(0u, 20) { let mut input = vec![]; for _ in range(0u, 2000) { - input.push_all(r.choose(words.as_slice()).unwrap().as_slice()); + input.push_all(r.choose(words.as_slice()).assert().as_slice()); } debug!("de/inflate of {} bytes of random word-sequences", input.len()); diff --git a/src/libgetopts/lib.rs b/src/libgetopts/lib.rs index 6339dc5844620..22a0a09389f9c 100644 --- a/src/libgetopts/lib.rs +++ b/src/libgetopts/lib.rs @@ -585,7 +585,7 @@ pub fn getopts(args: &[String], optgrps: &[OptGroup]) -> Result { None => { let arg_follows = last_valid_opt_id.is_some() && - match opts[last_valid_opt_id.unwrap()] + match opts[last_valid_opt_id.assert()] .hasarg { Yes | Maybe => true, @@ -622,7 +622,7 @@ pub fn getopts(args: &[String], optgrps: &[OptGroup]) -> Result { if !i_arg.is_none() { vals.get_mut(optid) .push(Val((i_arg.clone()) - .unwrap())); + .assert())); } else if name_pos < names.len() || i + 1 == l || is_arg(args[i + 1].as_slice()) { vals.get_mut(optid).push(Given); @@ -633,7 +633,7 @@ pub fn getopts(args: &[String], optgrps: &[OptGroup]) -> Result { } Yes => { if !i_arg.is_none() { - vals.get_mut(optid).push(Val(i_arg.clone().unwrap())); + vals.get_mut(optid).push(Val(i_arg.clone().assert())); } else if i + 1 == l { return Err(ArgumentMissing(nm.to_string())); } else { @@ -951,9 +951,9 @@ mod tests { match rs { Ok(ref m) => { assert!(m.opt_present("test")); - assert_eq!(m.opt_str("test").unwrap(), "20".to_string()); + assert_eq!(m.opt_str("test").assert(), "20".to_string()); assert!(m.opt_present("t")); - assert_eq!(m.opt_str("t").unwrap(), "20".to_string()); + assert_eq!(m.opt_str("t").assert(), "20".to_string()); } _ => { fail!("test_reqopt failed (long arg)"); } } @@ -961,9 +961,9 @@ mod tests { 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".to_string()); + assert_eq!(m.opt_str("test").assert(), "20".to_string()); assert!((m.opt_present("t"))); - assert_eq!(m.opt_str("t").unwrap(), "20".to_string()); + assert_eq!(m.opt_str("t").assert(), "20".to_string()); } _ => { fail!("test_reqopt failed (short arg)"); } } @@ -1016,9 +1016,9 @@ mod tests { match rs { Ok(ref m) => { assert!(m.opt_present("test")); - assert_eq!(m.opt_str("test").unwrap(), "20".to_string()); + assert_eq!(m.opt_str("test").assert(), "20".to_string()); assert!((m.opt_present("t"))); - assert_eq!(m.opt_str("t").unwrap(), "20".to_string()); + assert_eq!(m.opt_str("t").assert(), "20".to_string()); } _ => fail!() } @@ -1026,9 +1026,9 @@ mod tests { 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".to_string()); + assert_eq!(m.opt_str("test").assert(), "20".to_string()); assert!((m.opt_present("t"))); - assert_eq!(m.opt_str("t").unwrap(), "20".to_string()); + assert_eq!(m.opt_str("t").assert(), "20".to_string()); } _ => fail!() } @@ -1241,9 +1241,9 @@ mod tests { match rs { Ok(ref m) => { assert!((m.opt_present("test"))); - assert_eq!(m.opt_str("test").unwrap(), "20".to_string()); + assert_eq!(m.opt_str("test").assert(), "20".to_string()); assert!((m.opt_present("t"))); - assert_eq!(m.opt_str("t").unwrap(), "20".to_string()); + assert_eq!(m.opt_str("t").assert(), "20".to_string()); } _ => fail!() } @@ -1251,9 +1251,9 @@ mod tests { 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".to_string()); + assert_eq!(m.opt_str("test").assert(), "20".to_string()); assert!((m.opt_present("t"))); - assert_eq!(m.opt_str("t").unwrap(), "20".to_string()); + assert_eq!(m.opt_str("t").assert(), "20".to_string()); } _ => fail!() } @@ -1297,9 +1297,9 @@ mod tests { match rs { Ok(ref m) => { assert!(m.opt_present("test")); - assert_eq!(m.opt_str("test").unwrap(), "20".to_string()); + assert_eq!(m.opt_str("test").assert(), "20".to_string()); assert!(m.opt_present("t")); - assert_eq!(m.opt_str("t").unwrap(), "20".to_string()); + assert_eq!(m.opt_str("t").assert(), "20".to_string()); let pair = m.opt_strs("test"); assert!(*pair.get(0) == "20".to_string()); assert!(*pair.get(1) == "30".to_string()); @@ -1356,10 +1356,10 @@ mod tests { Ok(ref m) => { assert!(*m.free.get(0) == "prog".to_string()); assert!(*m.free.get(1) == "free1".to_string()); - assert_eq!(m.opt_str("s").unwrap(), "20".to_string()); + assert_eq!(m.opt_str("s").assert(), "20".to_string()); assert!(*m.free.get(2) == "free2".to_string()); assert!((m.opt_present("flag"))); - assert_eq!(m.opt_str("long").unwrap(), "30".to_string()); + assert_eq!(m.opt_str("long").assert(), "30".to_string()); assert!((m.opt_present("f"))); let pair = m.opt_strs("m"); assert!(*pair.get(0) == "40".to_string()); @@ -1392,10 +1392,10 @@ mod tests { assert!(!matches_single.opts_present(["thing".to_string()])); assert!(!matches_single.opts_present([])); - assert_eq!(matches_single.opts_str(["e".to_string()]).unwrap(), "foo".to_string()); - assert_eq!(matches_single.opts_str(["e".to_string(), "encrypt".to_string()]).unwrap(), + assert_eq!(matches_single.opts_str(["e".to_string()]).assert(), "foo".to_string()); + assert_eq!(matches_single.opts_str(["e".to_string(), "encrypt".to_string()]).assert(), "foo".to_string()); - assert_eq!(matches_single.opts_str(["encrypt".to_string(), "e".to_string()]).unwrap(), + assert_eq!(matches_single.opts_str(["encrypt".to_string(), "e".to_string()]).assert(), "foo".to_string()); let args_both = vec!("-e".to_string(), "foo".to_string(), "--encrypt".to_string(), @@ -1413,11 +1413,11 @@ mod tests { assert!(!matches_both.opts_present(["thing".to_string()])); assert!(!matches_both.opts_present([])); - assert_eq!(matches_both.opts_str(["e".to_string()]).unwrap(), "foo".to_string()); - assert_eq!(matches_both.opts_str(["encrypt".to_string()]).unwrap(), "foo".to_string()); - assert_eq!(matches_both.opts_str(["e".to_string(), "encrypt".to_string()]).unwrap(), + assert_eq!(matches_both.opts_str(["e".to_string()]).assert(), "foo".to_string()); + assert_eq!(matches_both.opts_str(["encrypt".to_string()]).assert(), "foo".to_string()); + assert_eq!(matches_both.opts_str(["e".to_string(), "encrypt".to_string()]).assert(), "foo".to_string()); - assert_eq!(matches_both.opts_str(["encrypt".to_string(), "e".to_string()]).unwrap(), + assert_eq!(matches_both.opts_str(["encrypt".to_string(), "e".to_string()]).assert(), "foo".to_string()); } @@ -1431,9 +1431,9 @@ mod tests { result::Err(_) => fail!() }; assert!(matches.opts_present(["L".to_string()])); - assert_eq!(matches.opts_str(["L".to_string()]).unwrap(), "foo".to_string()); + assert_eq!(matches.opts_str(["L".to_string()]).assert(), "foo".to_string()); assert!(matches.opts_present(["M".to_string()])); - assert_eq!(matches.opts_str(["M".to_string()]).unwrap(), ".".to_string()); + assert_eq!(matches.opts_str(["M".to_string()]).assert(), ".".to_string()); } @@ -1461,7 +1461,7 @@ mod tests { let args = vec!("-a".to_string(), "--apple".to_string(), "-a".to_string()); - let matches = getopts(args.as_slice(), opts.as_slice()).unwrap(); + let matches = getopts(args.as_slice(), opts.as_slice()).assert(); assert_eq!(3, matches.opt_count("a")); assert_eq!(3, matches.opt_count("apple")); } diff --git a/src/libglob/lib.rs b/src/libglob/lib.rs index d539283f0a717..e6db9b098d490 100644 --- a/src/libglob/lib.rs +++ b/src/libglob/lib.rs @@ -103,7 +103,7 @@ pub fn glob_with(pattern: &str, options: MatchOptions) -> Paths { let mut root = os::getcwd(); let pat_root = Path::new(pattern).root_path(); if pat_root.is_some() { - if check_windows_verbatim(pat_root.get_ref()) { + if check_windows_verbatim(pat_root.as_ref().assert()) { // 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 { @@ -113,7 +113,7 @@ pub fn glob_with(pattern: &str, options: MatchOptions) -> Paths { todo: Vec::new(), }; } - root.push(pat_root.get_ref()); + root.push(pat_root.as_ref().assert()); } let root_len = pat_root.map_or(0u, |p| p.as_vec().len()); @@ -147,7 +147,7 @@ impl Iterator for Paths { return None; } - let (path,idx) = self.todo.pop().unwrap(); + let (path,idx) = self.todo.pop().assert(); // idx -1: was already checked by fill_todo, maybe path was '.' or // '..' that we can't match here because of normalization. if idx == -1 as uint { @@ -186,7 +186,7 @@ fn list_dir_sorted(path: &Path) -> Option> { match fs::readdir(path) { Ok(mut children) => { children.sort_by(|p1, p2| p2.filename().cmp(&p1.filename())); - Some(children.move_iter().collect()) + Some(children.iter_owned().collect()) } Err(..) => None } @@ -400,7 +400,7 @@ impl Pattern { } let (some_c, next) = file.slice_shift_char(); - if require_literal(some_c.unwrap()) { + if require_literal(some_c.assert()) { return SubPatternDoesntMatch; } prev_char.set(some_c); @@ -413,7 +413,7 @@ impl Pattern { } let (some_c, next) = file.slice_shift_char(); - let c = some_c.unwrap(); + let c = some_c.assert(); let matches = match *token { AnyChar => { !require_literal(c) @@ -501,7 +501,7 @@ fn fill_todo(todo: &mut Vec<(Path, uint)>, patterns: &[Pattern], idx: uint, path None => { match list_dir_sorted(path) { Some(entries) => { - todo.extend(entries.move_iter().map(|x|(x, idx))); + todo.extend(entries.iter_owned().map(|x|(x, idx))); // Matching the special directory entries . and .. that refer to // the current and parent directory respectively requires that @@ -656,9 +656,9 @@ mod test { assert!(glob("//").next().is_some()); // check windows absolute paths with host/device components - let root_with_device = os::getcwd().root_path().unwrap().join("*"); + let root_with_device = os::getcwd().root_path().assert().join("*"); // FIXME (#9639): This needs to handle non-utf8 paths - assert!(glob(root_with_device.as_str().unwrap()).next().is_some()); + assert!(glob(root_with_device.as_str().assert()).next().is_some()); } #[test] @@ -880,7 +880,7 @@ mod test { #[test] fn test_matches_path() { - // on windows, (Path::new("a/b").as_str().unwrap() == "a\\b"), so this + // on windows, (Path::new("a/b").as_str().assert() == "a\\b"), so this // tests that / and \ are considered equivalent on windows assert!(Pattern::new("a/b").matches_path(&Path::new("a/b"))); } diff --git a/src/libgraphviz/lib.rs b/src/libgraphviz/lib.rs index f55a1ca62f72f..f1c7c08eaba0e 100644 --- a/src/libgraphviz/lib.rs +++ b/src/libgraphviz/lib.rs @@ -56,7 +56,7 @@ struct Edges(Vec); pub fn render_to(output: &mut W) { let edges = Edges(vec!((0,1), (0,2), (1,3), (2,3), (3,4), (4,4))); - dot::render(&edges, output).unwrap() + dot::render(&edges, output).assert() } impl<'a> dot::Labeller<'a, Nd, Ed> for Edges { @@ -159,7 +159,7 @@ pub fn render_to(output: &mut W) { let edges = vec!((0,1), (0,2), (1,3), (2,3)); let graph = Graph { nodes: nodes, edges: edges }; - dot::render(&graph, output).unwrap() + dot::render(&graph, output).assert() } impl<'a> dot::Labeller<'a, Nd, Ed<'a>> for Graph { @@ -215,7 +215,7 @@ pub fn render_to(output: &mut W) { let edges = vec!((0,1), (0,2), (1,3), (2,3)); let graph = Graph { nodes: nodes, edges: edges }; - dot::render(&graph, output).unwrap() + dot::render(&graph, output).assert() } impl<'a> dot::Labeller<'a, Nd<'a>, Ed<'a>> for Graph { @@ -355,7 +355,7 @@ impl<'a> Id<'a> { let name = name.into_maybe_owned(); { let mut chars = name.as_slice().chars(); - assert!(is_letter_or_underscore(chars.next().unwrap())); + assert!(is_letter_or_underscore(chars.next().assert())); assert!(chars.all(is_constituent)); } return Id{ name: name }; @@ -588,12 +588,12 @@ mod tests { fn to_opt_strs(self) -> Vec> { match self { UnlabelledNodes(len) - => Vec::from_elem(len, None).move_iter().collect(), + => Vec::from_elem(len, None).iter_owned().collect(), AllNodesLabelled(lbls) - => lbls.move_iter().map( + => lbls.iter_owned().map( |l|Some(l)).collect(), SomeNodesLabelled(lbls) - => lbls.move_iter().collect(), + => lbls.iter_owned().collect(), } } } @@ -689,8 +689,8 @@ mod tests { fn test_input(g: LabelledGraph) -> IoResult { let mut writer = MemWriter::new(); - render(&g, &mut writer).unwrap(); - let mut r = BufReader::new(writer.get_ref()); + render(&g, &mut writer).assert(); + let mut r = BufReader::new(writer.as_ref().assert()); r.read_to_string() } @@ -702,7 +702,7 @@ mod tests { fn empty_graph() { let labels : Trivial = UnlabelledNodes(0); let r = test_input(LabelledGraph::new("empty_graph", labels, vec!())); - assert_eq!(r.unwrap().as_slice(), + assert_eq!(r.assert().as_slice(), r#"digraph empty_graph { } "#); @@ -712,7 +712,7 @@ r#"digraph empty_graph { fn single_node() { let labels : Trivial = UnlabelledNodes(1); let r = test_input(LabelledGraph::new("single_node", labels, vec!())); - assert_eq!(r.unwrap().as_slice(), + assert_eq!(r.assert().as_slice(), r#"digraph single_node { N0[label="N0"]; } @@ -724,7 +724,7 @@ r#"digraph single_node { let labels : Trivial = UnlabelledNodes(2); let result = test_input(LabelledGraph::new("single_edge", labels, vec!(edge(0, 1, "E")))); - assert_eq!(result.unwrap().as_slice(), + assert_eq!(result.assert().as_slice(), r#"digraph single_edge { N0[label="N0"]; N1[label="N1"]; @@ -738,7 +738,7 @@ r#"digraph single_edge { let labels : Trivial = UnlabelledNodes(1); let r = test_input(LabelledGraph::new("single_cyclic_node", labels, vec!(edge(0, 0, "E")))); - assert_eq!(r.unwrap().as_slice(), + assert_eq!(r.assert().as_slice(), r#"digraph single_cyclic_node { N0[label="N0"]; N0 -> N0[label="E"]; @@ -753,7 +753,7 @@ r#"digraph single_cyclic_node { "hasse_diagram", labels, vec!(edge(0, 1, ""), edge(0, 2, ""), edge(1, 3, ""), edge(2, 3, "")))); - assert_eq!(r.unwrap().as_slice(), + assert_eq!(r.assert().as_slice(), r#"digraph hasse_diagram { N0[label="{x,y}"]; N1[label="{x}"]; @@ -788,11 +788,11 @@ r#"digraph hasse_diagram { vec!(edge(0, 1, "then"), edge(0, 2, "else"), edge(1, 3, ";"), edge(2, 3, ";" ))); - render(&g, &mut writer).unwrap(); - let mut r = BufReader::new(writer.get_ref()); + render(&g, &mut writer).assert(); + let mut r = BufReader::new(writer.as_ref().assert()); let r = r.read_to_string(); - assert_eq!(r.unwrap().as_slice(), + assert_eq!(r.assert().as_slice(), r#"digraph syntax_tree { N0[label="if test {\l branch1\l} else {\l branch2\l}\lafterward\l"]; N1[label="branch1"]; diff --git a/src/libgreen/basic.rs b/src/libgreen/basic.rs index e48786f33745f..c463f3849e408 100644 --- a/src/libgreen/basic.rs +++ b/src/libgreen/basic.rs @@ -53,7 +53,7 @@ impl BasicLoop { /// Process everything in the work queue (continually) fn work(&mut self) { while self.work.len() > 0 { - for work in mem::replace(&mut self.work, vec![]).move_iter() { + for work in mem::replace(&mut self.work, vec![]).iter_owned() { work(); } } @@ -63,7 +63,7 @@ impl BasicLoop { let messages = unsafe { mem::replace(&mut *self.messages.lock(), Vec::new()) }; - for message in messages.move_iter() { + for message in messages.iter_owned() { self.message(message); } } @@ -71,14 +71,14 @@ impl BasicLoop { fn message(&mut self, message: Message) { match message { RunRemote(i) => { - match self.remotes.mut_iter().find(|& &(id, _)| id == i) { + match self.remotes.iter_mut().find(|& &(id, _)| id == i) { Some(&(_, ref mut f)) => f.call(), None => unreachable!() } } RemoveRemote(i) => { match self.remotes.iter().position(|&(id, _)| id == i) { - Some(i) => { self.remotes.remove(i).unwrap(); } + Some(i) => { self.remotes.remove(i).assert(); } None => unreachable!() } } @@ -89,7 +89,7 @@ impl BasicLoop { fn idle(&mut self) { match self.idle { Some(ref mut idle) => { - if self.idle_active.get_ref().load(atomic::SeqCst) { + if self.idle_active.as_ref().assert().load(atomic::SeqCst) { idle.call(); } } @@ -98,7 +98,7 @@ impl BasicLoop { } fn has_idle(&self) -> bool { - self.idle.is_some() && self.idle_active.get_ref().load(atomic::SeqCst) + self.idle.is_some() && self.idle_active.as_ref().assert().load(atomic::SeqCst) } } diff --git a/src/libgreen/context.rs b/src/libgreen/context.rs index b63758cdcc5e7..0c283627e0aed 100644 --- a/src/libgreen/context.rs +++ b/src/libgreen/context.rs @@ -170,12 +170,12 @@ fn initialize_call_frame(regs: &mut Registers, fptr: InitFn, arg: uint, // x86 has interesting stack alignment requirements, so do some alignment // plus some offsetting to figure out what the actual stack should be. let sp = align_down(sp); - let sp = mut_offset(sp, -4); + let sp = offset_mut(sp, -4); - unsafe { *mut_offset(sp, 2) = procedure.env as uint }; - unsafe { *mut_offset(sp, 1) = procedure.code as uint }; - unsafe { *mut_offset(sp, 0) = arg as uint }; - let sp = mut_offset(sp, -1); + unsafe { *offset_mut(sp, 2) = procedure.env as uint }; + unsafe { *offset_mut(sp, 1) = procedure.code as uint }; + unsafe { *offset_mut(sp, 0) = arg as uint }; + let sp = offset_mut(sp, -1); unsafe { *sp = 0 }; // The final return address regs.esp = sp as u32; @@ -228,7 +228,7 @@ fn initialize_call_frame(regs: &mut Registers, fptr: InitFn, arg: uint, static RUSTRT_R15: uint = 7; let sp = align_down(sp); - let sp = mut_offset(sp, -1); + let sp = offset_mut(sp, -1); // The final return address. 0 indicates the bottom of the stack unsafe { *sp = 0; } @@ -269,7 +269,7 @@ fn initialize_call_frame(regs: &mut Registers, fptr: InitFn, arg: uint, let sp = align_down(sp); // sp of arm eabi is 8-byte aligned - let sp = mut_offset(sp, -2); + let sp = offset_mut(sp, -2); // The final return address. 0 indicates the bottom of the stack unsafe { *sp = 0; } @@ -299,7 +299,7 @@ fn initialize_call_frame(regs: &mut Registers, fptr: InitFn, arg: uint, procedure: raw::Procedure, sp: *mut uint) { let sp = align_down(sp); // sp of mips o32 is 8-byte aligned - let sp = mut_offset(sp, -2); + let sp = offset_mut(sp, -2); // The final return address. 0 indicates the bottom of the stack unsafe { *sp = 0; } @@ -317,9 +317,9 @@ fn align_down(sp: *mut uint) -> *mut uint { sp as *mut uint } -// ptr::mut_offset is positive ints only +// ptr::offset_mut is positive ints only #[inline] -pub fn mut_offset(ptr: *mut T, count: int) -> *mut T { +pub fn offset_mut(ptr: *mut T, count: int) -> *mut T { use std::mem::size_of; (ptr as int + count * (size_of::() as int)) as *mut T } diff --git a/src/libgreen/lib.rs b/src/libgreen/lib.rs index 5c280a31db792..bd0c6e27f5fbd 100644 --- a/src/libgreen/lib.rs +++ b/src/libgreen/lib.rs @@ -305,11 +305,11 @@ pub fn start(argc: int, argv: *const *const u8, let mut main = Some(main); let mut ret = None; simple::task().run(|| { - ret = Some(run(event_loop_factory, main.take_unwrap())); + ret = Some(run(event_loop_factory, main.take().assert())); }).destroy(); // unsafe is ok b/c we're sure that the runtime is gone unsafe { rt::cleanup() } - ret.unwrap() + ret.assert() } /// Execute the main function in a pool of M:N schedulers. @@ -435,7 +435,7 @@ impl SchedPool { // Now that we've got all our work queues, create one scheduler per // queue, spawn the scheduler into a thread, and be sure to keep a // handle to the scheduler and the thread to keep them alive. - for worker in workers.move_iter() { + for worker in workers.iter_owned() { rtdebug!("inserting a regular scheduler"); let mut sched = box Scheduler::new(pool.id, @@ -493,7 +493,7 @@ impl SchedPool { // Tell all existing schedulers about this new scheduler so they can all // steal work from it - for handle in self.handles.mut_iter() { + for handle in self.handles.iter_mut() { handle.send(NewNeighbor(stealer.clone())); } @@ -535,10 +535,10 @@ impl SchedPool { } // Now that everyone's gone, tell everything to shut down. - for mut handle in replace(&mut self.handles, vec![]).move_iter() { + for mut handle in replace(&mut self.handles, vec![]).iter_owned() { handle.send(Shutdown); } - for thread in replace(&mut self.threads, vec![]).move_iter() { + for thread in replace(&mut self.threads, vec![]).iter_owned() { thread.join(); } } @@ -623,7 +623,7 @@ mod test { let res = TaskBuilder::new().green(&mut pool).try(proc() { "Success!".to_string() }); - assert_eq!(res.ok().unwrap(), "Success!".to_string()); + assert_eq!(res.ok().assert(), "Success!".to_string()); pool.shutdown(); } } diff --git a/src/libgreen/sched.rs b/src/libgreen/sched.rs index b9144047df5c0..1307621208bd9 100644 --- a/src/libgreen/sched.rs +++ b/src/libgreen/sched.rs @@ -193,7 +193,7 @@ impl Scheduler { // Before starting our first task, make sure the idle callback // is active. As we do not start in the sleep state this is // important. - self.idle_callback.get_mut_ref().resume(); + self.idle_callback.as_mut().assert().resume(); // Now, as far as all the scheduler state is concerned, we are inside // the "scheduler" context. The scheduler immediately hands over control @@ -203,7 +203,7 @@ impl Scheduler { let mut sched_task = self.run(sched_task); // Close the idle callback. - let mut sched = sched_task.sched.take_unwrap(); + let mut sched = sched_task.sched.take().assert(); sched.idle_callback.take(); // Make one go through the loop to run the close callback. let mut stask = sched.run(sched_task); @@ -213,13 +213,13 @@ impl Scheduler { // cleaning up the memory it uses. As we didn't actually call // task.run() on the scheduler task we never get through all // the cleanup code it runs. - rtdebug!("stopping scheduler {}", stask.sched.get_ref().sched_id()); + rtdebug!("stopping scheduler {}", stask.sched.as_ref().assert().sched_id()); // Should not have any messages - let message = stask.sched.get_mut_ref().message_queue.pop(); + let message = stask.sched.as_mut().assert().message_queue.pop(); rtassert!(match message { msgq::Empty => true, _ => false }); - stask.task.take().unwrap().drop(); + stask.task.take().assert().drop(); } // This does not return a scheduler, as the scheduler is placed @@ -279,7 +279,7 @@ impl Scheduler { // Assume that we need to continue idling unless we reach the // end of this function without performing an action. - self.idle_callback.get_mut_ref().resume(); + self.idle_callback.as_mut().assert().resume(); // First we check for scheduler messages, these are higher // priority than regular tasks. @@ -333,12 +333,12 @@ impl Scheduler { let handle = sched.make_handle(); sched.sleeper_list.push(handle); // Since we are sleeping, deactivate the idle callback. - sched.idle_callback.get_mut_ref().pause(); + sched.idle_callback.as_mut().assert().pause(); } else { rtdebug!("not sleeping, already doing so or no_sleep set"); // We may not be sleeping, but we still need to deactivate // the idle callback. - sched.idle_callback.get_mut_ref().pause(); + sched.idle_callback.as_mut().assert().pause(); } // Finished a cycle without using the Scheduler. Place it back @@ -633,7 +633,7 @@ impl Scheduler { unsafe { let sched: &mut Scheduler = - mem::transmute(&**next_task.sched.get_mut_ref()); + mem::transmute(&**next_task.sched.as_mut().assert()); let current_task: &mut GreenTask = match sched.cleanup_job { Some(CleanupJob { task: ref mut task, .. }) => &mut **task, @@ -661,7 +661,7 @@ impl Scheduler { let mut current_task: Box = unsafe { mem::transmute(current_task_dupe) }; - current_task.sched.get_mut_ref().run_cleanup_job(); + current_task.sched.as_mut().assert().run_cleanup_job(); // See the comments in switch_running_tasks_and_then for why a lock // is acquired here. This is the resumption points and the "bounce" @@ -682,9 +682,9 @@ impl Scheduler { -> (&'a mut Context, &'a mut Context) { let current_task_context = - &mut current_task.coroutine.get_mut_ref().saved_context; + &mut current_task.coroutine.as_mut().assert().saved_context; let next_task_context = - &mut next_task.coroutine.get_mut_ref().saved_context; + &mut next_task.coroutine.as_mut().assert().saved_context; unsafe { (mem::transmute(current_task_context), mem::transmute(next_task_context)) @@ -702,7 +702,7 @@ impl Scheduler { assert!(sched.sched_task.is_none()); sched.sched_task = Some(stask); }); - (cur.sched.take_unwrap(), cur) + (cur.sched.take().assert(), cur) } fn resume_task_immediately_cl(sched: Box, @@ -738,7 +738,7 @@ impl Scheduler { f: |&mut Scheduler, BlockedTask|) { // Trickier - we need to get the scheduler task out of self // and use it as the destination. - let stask = self.sched_task.take_unwrap(); + let stask = self.sched_task.take().assert(); // Otherwise this is the same as below. self.switch_running_tasks_and_then(cur, stask, f) } @@ -788,7 +788,7 @@ impl Scheduler { sched.enqueue_task(last_task); } }); - (cur.sched.take_unwrap(), cur) + (cur.sched.take().assert(), cur) } // * Task Context Helpers @@ -800,9 +800,9 @@ impl Scheduler { -> ! { // Similar to deschedule running task and then, but cannot go through // the task-blocking path. The task is already dying. - let stask = self.sched_task.take_unwrap(); + let stask = self.sched_task.take().assert(); let _cur = self.change_task_context(cur, stask, |sched, mut dead_task| { - let coroutine = dead_task.coroutine.take_unwrap(); + let coroutine = dead_task.coroutine.take().assert(); coroutine.recycle(&mut sched.stack_pool); sched.task_state.decrement(); }); @@ -818,7 +818,7 @@ impl Scheduler { } pub fn run_task_later(mut cur: Box, next: Box) { - let mut sched = cur.sched.take_unwrap(); + let mut sched = cur.sched.take().assert(); sched.enqueue_task(next); cur.put_with_sched(sched); } @@ -838,7 +838,7 @@ impl Scheduler { self.yield_check_count = reset_yield_check(&mut self.rng); // Tell the scheduler to start stealing on the next iteration self.steal_for_yield = true; - let stask = self.sched_task.take_unwrap(); + let stask = self.sched_task.take().assert(); let cur = self.change_task_context(cur, stask, |sched, task| { sched.enqueue_task(task); }); @@ -878,7 +878,7 @@ impl Scheduler { pub fn sched_id(&self) -> uint { self as *const Scheduler as uint } pub fn run_cleanup_job(&mut self) { - let cleanup_job = self.cleanup_job.take_unwrap(); + let cleanup_job = self.cleanup_job.take().assert(); cleanup_job.run(self) } @@ -1052,7 +1052,7 @@ mod test { let mut task = Local::borrow(None::); match task.maybe_take_runtime::() { Some(green) => { - let ret = green.sched.get_ref().sched_id(); + let ret = green.sched.as_ref().assert().sched_id(); task.put_runtime(green); return ret; } @@ -1192,8 +1192,8 @@ mod test { fn on_appropriate_sched() -> bool { use task::{TypeGreen, TypeSched, HomeSched}; let task = GreenTask::convert(Local::take()); - let sched_id = task.sched.get_ref().sched_id(); - let run_any = task.sched.get_ref().run_anything; + let sched_id = task.sched.as_ref().assert().sched_id(); + let run_any = task.sched.as_ref().assert().run_anything; let ret = match task.task_type { TypeGreen(Some(AnySched)) => { run_any @@ -1234,7 +1234,7 @@ mod test { fn run(next: Box) { let mut task = GreenTask::convert(Local::take()); - let sched = task.sched.take_unwrap(); + let sched = task.sched.take().assert(); sched.run_task(task, next) } diff --git a/src/libgreen/stack.rs b/src/libgreen/stack.rs index 601758f8a25df..a81be446bdbd5 100644 --- a/src/libgreen/stack.rs +++ b/src/libgreen/stack.rs @@ -145,7 +145,7 @@ impl StackPool { pub fn take_stack(&mut self, min_size: uint) -> Stack { // Ideally this would be a binary search match self.stacks.iter().position(|s| min_size <= s.min_size) { - Some(idx) => self.stacks.swap_remove(idx).unwrap(), + Some(idx) => self.stacks.swap_remove(idx).assert(), None => Stack::new(min_size) } } diff --git a/src/libgreen/task.rs b/src/libgreen/task.rs index 73fe8f6a93f82..2f88577a4bc72 100644 --- a/src/libgreen/task.rs +++ b/src/libgreen/task.rs @@ -100,7 +100,7 @@ extern fn bootstrap_green_task(task: uint, code: *mut (), env: *mut ()) -> ! { // First code after swap to this new context. Run our cleanup job task.pool_id = { - let sched = task.sched.get_mut_ref(); + let sched = task.sched.as_mut().assert(); sched.run_cleanup_job(); sched.task_state.increment(); sched.pool_id @@ -110,7 +110,7 @@ extern fn bootstrap_green_task(task: uint, code: *mut (), env: *mut ()) -> ! { // requested. This is the "try/catch" block for this green task and // is the wrapper for *all* code run in the task. let mut start = Some(start); - let task = task.swap().run(|| start.take_unwrap()()).destroy(); + let task = task.swap().run(|| start.take().assert()()).destroy(); // Once the function has exited, it's time to run the termination // routine. This means we need to context switch one more time but @@ -179,7 +179,7 @@ impl GreenTask { let mut green = GreenTask::new(pool, stack_size, f); { - let task = green.task.get_mut_ref(); + let task = green.task.as_mut().assert(); task.name = name; task.death.on_exit = on_exit; } @@ -212,7 +212,7 @@ impl GreenTask { pub fn take_unwrap_home(&mut self) -> Home { match self.task_type { - TypeGreen(ref mut home) => home.take_unwrap(), + TypeGreen(ref mut home) => home.take().assert(), TypeSched => rtabort!("type error: used SchedTask as GreenTask"), } } @@ -277,7 +277,7 @@ impl GreenTask { } pub fn swap(mut self: Box) -> Box { - let mut task = self.task.take_unwrap(); + let mut task = self.task.take().assert(); task.put_runtime(self); return task; } @@ -288,7 +288,7 @@ impl GreenTask { } fn terminate(mut self: Box) -> ! { - let sched = self.sched.take_unwrap(); + let sched = self.sched.take().assert(); sched.terminate_current_task(self) } @@ -314,7 +314,7 @@ impl GreenTask { fn reawaken_remotely(mut self: Box) { unsafe { let mtx = &mut self.nasty_deschedule_lock as *mut NativeMutex; - let handle = self.handle.get_mut_ref() as *mut SchedHandle; + let handle = self.handle.as_mut().assert() as *mut SchedHandle; let _guard = (*mtx).lock(); (*handle).send(RunOnce(self)); } @@ -324,13 +324,13 @@ impl GreenTask { impl Runtime for GreenTask { fn yield_now(mut self: Box, cur_task: Box) { self.put_task(cur_task); - let sched = self.sched.take_unwrap(); + let sched = self.sched.take().assert(); sched.yield_now(self); } fn maybe_yield(mut self: Box, cur_task: Box) { self.put_task(cur_task); - let sched = self.sched.take_unwrap(); + let sched = self.sched.take().assert(); sched.maybe_yield(self); } @@ -339,7 +339,7 @@ impl Runtime for GreenTask { cur_task: Box, f: |BlockedTask| -> Result<(), BlockedTask>) { self.put_task(cur_task); - let mut sched = self.sched.take_unwrap(); + let mut sched = self.sched.take().assert(); // In order for this task to be reawoken in all possible contexts, we // may need a handle back in to the current scheduler. When we're woken @@ -418,7 +418,7 @@ impl Runtime for GreenTask { match running_task.maybe_take_runtime::() { Some(mut running_green_task) => { running_green_task.put_task(running_task); - let sched = running_green_task.sched.take_unwrap(); + let sched = running_green_task.sched.take().assert(); if sched.pool_id == self.pool_id { sched.run_task(running_green_task, self); @@ -460,17 +460,17 @@ impl Runtime for GreenTask { // // Upon returning, our task is back in TLS and we're good to return. let sibling = { - let sched = bomb.inner.get_mut_ref().sched.get_mut_ref(); + let sched = bomb.inner.as_mut().assert().sched.as_mut().assert(); GreenTask::configure(&mut sched.stack_pool, opts, f) }; - let mut me = bomb.inner.take().unwrap(); - let sched = me.sched.take().unwrap(); + let mut me = bomb.inner.take().assert(); + let sched = me.sched.take().assert(); sched.run_task(me, sibling) } // Local I/O is provided by the scheduler's event loop fn local_io<'a>(&'a mut self) -> Option> { - match self.sched.get_mut_ref().event_loop.io() { + match self.sched.as_mut().assert().event_loop.io() { Some(io) => Some(rtio::LocalIo::new(io)), None => None, } diff --git a/src/libnative/io/addrinfo.rs b/src/libnative/io/addrinfo.rs index 7a07b6221277f..560f9fcd8f815 100644 --- a/src/libnative/io/addrinfo.rs +++ b/src/libnative/io/addrinfo.rs @@ -11,7 +11,7 @@ use libc::{c_char, c_int}; use libc; use std::mem; -use std::ptr::{null, mut_null}; +use std::ptr::{null, null_mut}; use std::rt::rtio; use std::rt::rtio::IoError; @@ -38,16 +38,16 @@ impl GetAddrInfoRequest { ai_socktype: 0, ai_protocol: 0, ai_addrlen: 0, - ai_canonname: mut_null(), - ai_addr: mut_null(), - ai_next: mut_null() + ai_canonname: null_mut(), + ai_addr: null_mut(), + ai_next: null_mut() } }); let hint_ptr = hint.as_ref().map_or(null(), |x| { x as *const libc::addrinfo }); - let mut res = mut_null(); + let mut res = null_mut(); // Make the call let s = unsafe { @@ -106,7 +106,7 @@ fn get_error(s: c_int) -> IoError { use std::c_str::CString; let err_str = unsafe { - CString::new(gai_strerror(s), false).as_str().unwrap().to_string() + CString::new(gai_strerror(s), false).as_str().assert().to_string() }; IoError { code: s as uint, diff --git a/src/libnative/io/file_unix.rs b/src/libnative/io/file_unix.rs index ddcff2be5f340..ca3afee9c74f9 100644 --- a/src/libnative/io/file_unix.rs +++ b/src/libnative/io/file_unix.rs @@ -359,7 +359,7 @@ pub fn readdir(p: &CString) -> IoResult> { let root = unsafe { CString::new(root.as_ptr(), false) }; let root = Path::new(root); - dirs.move_iter().filter(|path| { + dirs.iter_owned().filter(|path| { path.as_vec() != b"." && path.as_vec() != b".." }).map(|path| root.join(path).to_c_str()).collect() } @@ -525,11 +525,11 @@ mod tests { fn test_file_desc() { // Run this test with some pipes so we don't have to mess around with // opening or closing files. - let os::Pipe { reader, writer } = unsafe { os::pipe().unwrap() }; + let os::Pipe { reader, writer } = unsafe { os::pipe().assert() }; let mut reader = FileDesc::new(reader, true); let mut writer = FileDesc::new(writer, true); - writer.inner_write(b"test").ok().unwrap(); + writer.inner_write(b"test").ok().assert(); let mut buf = [0u8, ..4]; match reader.inner_read(buf) { Ok(4) => { @@ -552,9 +552,9 @@ mod tests { assert!(!f.is_null()); let mut file = CFile::new(f); - file.write(b"test").ok().unwrap(); + file.write(b"test").ok().assert(); let mut buf = [0u8, ..4]; - let _ = file.seek(0, SeekSet).ok().unwrap(); + let _ = file.seek(0, SeekSet).ok().assert(); match file.read(buf) { Ok(4) => { assert_eq!(buf[0], 't' as u8); diff --git a/src/libnative/io/file_win32.rs b/src/libnative/io/file_win32.rs index fe29c0245297c..5857fa916dc13 100644 --- a/src/libnative/io/file_win32.rs +++ b/src/libnative/io/file_win32.rs @@ -54,7 +54,7 @@ impl FileDesc { let ret = unsafe { libc::ReadFile(self.handle(), buf.as_ptr() as libc::LPVOID, buf.len() as libc::DWORD, &mut read, - ptr::mut_null()) + ptr::null_mut()) }; if ret != 0 { Ok(read as uint) @@ -70,7 +70,7 @@ impl FileDesc { let ret = unsafe { libc::WriteFile(self.handle(), cur as libc::LPVOID, remaining as libc::DWORD, &mut amt, - ptr::mut_null()) + ptr::null_mut()) }; if ret != 0 { remaining -= amt as uint; @@ -315,10 +315,10 @@ pub fn open(path: &CString, fm: rtio::FileMode, fa: rtio::FileAccess) libc::CreateFileW(path.as_ptr(), dwDesiredAccess, dwShareMode, - ptr::mut_null(), + ptr::null_mut(), dwCreationDisposition, dwFlagsAndAttributes, - ptr::mut_null()) + ptr::null_mut()) }; if handle == libc::INVALID_HANDLE_VALUE { Err(super::last_error()) @@ -339,7 +339,7 @@ pub fn mkdir(p: &CString, _mode: uint) -> IoResult<()> { let p = try!(to_utf16(p)); super::mkerr_winbool(unsafe { // FIXME: turn mode into something useful? #2623 - libc::CreateDirectoryW(p.as_ptr(), ptr::mut_null()) + libc::CreateDirectoryW(p.as_ptr(), ptr::null_mut()) }) } @@ -350,7 +350,7 @@ pub fn readdir(p: &CString) -> IoResult> { let root = unsafe { CString::new(root.as_ptr(), false) }; let root = Path::new(root); - dirs.move_iter().filter(|path| { + dirs.iter_owned().filter(|path| { path.as_vec() != b"." && path.as_vec() != b".." }).map(|path| root.join(path).to_c_str()).collect() } @@ -435,10 +435,10 @@ pub fn readlink(p: &CString) -> IoResult { libc::CreateFileW(p.as_ptr(), libc::GENERIC_READ, libc::FILE_SHARE_READ, - ptr::mut_null(), + ptr::null_mut(), libc::OPEN_EXISTING, libc::FILE_ATTRIBUTE_NORMAL, - ptr::mut_null()) + ptr::null_mut()) }; if handle == libc::INVALID_HANDLE_VALUE { return Err(super::last_error()) @@ -475,7 +475,7 @@ pub fn link(src: &CString, dst: &CString) -> IoResult<()> { let src = try!(to_utf16(src)); let dst = try!(to_utf16(dst)); super::mkerr_winbool(unsafe { - libc::CreateHardLinkW(dst.as_ptr(), src.as_ptr(), ptr::mut_null()) + libc::CreateHardLinkW(dst.as_ptr(), src.as_ptr(), ptr::null_mut()) }) } diff --git a/src/libnative/io/helper_thread.rs b/src/libnative/io/helper_thread.rs index 8e92aa56d3c8f..d460fc36825bb 100644 --- a/src/libnative/io/helper_thread.rs +++ b/src/libnative/io/helper_thread.rs @@ -149,12 +149,12 @@ mod imp { pub type signal = libc::c_int; pub fn new() -> (signal, signal) { - let os::Pipe { reader, writer } = unsafe { os::pipe().unwrap() }; + let os::Pipe { reader, writer } = unsafe { os::pipe().assert() }; (reader, writer) } pub fn signal(fd: libc::c_int) { - FileDesc::new(fd, false).inner_write([0]).ok().unwrap(); + FileDesc::new(fd, false).inner_write([0]).ok().assert(); } pub fn close(fd: libc::c_int) { @@ -172,7 +172,7 @@ mod imp { pub fn new() -> (HANDLE, HANDLE) { unsafe { - let handle = CreateEventA(ptr::mut_null(), libc::FALSE, libc::FALSE, + let handle = CreateEventA(ptr::null_mut(), libc::FALSE, libc::FALSE, ptr::null()); (handle, handle) } diff --git a/src/libnative/io/mod.rs b/src/libnative/io/mod.rs index db5421481ee42..3c5371fc407d5 100644 --- a/src/libnative/io/mod.rs +++ b/src/libnative/io/mod.rs @@ -274,7 +274,7 @@ impl rtio::IoFactory for IoFactory { Vec>>)> { process::Process::spawn(cfg).map(|(p, io)| { (box p as Box, - io.move_iter().map(|p| p.map(|p| { + io.iter_owned().map(|p| p.map(|p| { box p as Box })).collect()) }) diff --git a/src/libnative/io/pipe_unix.rs b/src/libnative/io/pipe_unix.rs index bc3f917a3dcc3..5397b2ede2f8d 100644 --- a/src/libnative/io/pipe_unix.rs +++ b/src/libnative/io/pipe_unix.rs @@ -48,7 +48,7 @@ fn addr_to_sockaddr_un(addr: &CString, }) } s.sun_family = libc::AF_UNIX as libc::sa_family_t; - for (slot, value) in s.sun_path.mut_iter().zip(addr.iter()) { + for (slot, value) in s.sun_path.iter_mut().zip(addr.iter()) { *slot = value; } diff --git a/src/libnative/io/pipe_win32.rs b/src/libnative/io/pipe_win32.rs index 717915e5d23bd..8b056660efdae 100644 --- a/src/libnative/io/pipe_win32.rs +++ b/src/libnative/io/pipe_win32.rs @@ -104,7 +104,7 @@ struct Event(libc::HANDLE); impl Event { fn new(manual_reset: bool, initial_state: bool) -> IoResult { let event = unsafe { - libc::CreateEventW(ptr::mut_null(), + libc::CreateEventW(ptr::null_mut(), manual_reset as libc::BOOL, initial_state as libc::BOOL, ptr::null()) @@ -164,7 +164,7 @@ unsafe fn pipe(name: *const u16, init: bool) -> libc::HANDLE { 65536, 65536, 0, - ptr::mut_null() + ptr::null_mut() ) } @@ -218,10 +218,10 @@ impl UnixStream { libc::CreateFileW(p, libc::GENERIC_READ | libc::GENERIC_WRITE, 0, - ptr::mut_null(), + ptr::null_mut(), libc::OPEN_EXISTING, libc::FILE_FLAG_OVERLAPPED, - ptr::mut_null()) + ptr::null_mut()) }; if result != libc::INVALID_HANDLE_VALUE { return Some(result) @@ -233,10 +233,10 @@ impl UnixStream { libc::CreateFileW(p, libc::GENERIC_READ | libc::FILE_WRITE_ATTRIBUTES, 0, - ptr::mut_null(), + ptr::null_mut(), libc::OPEN_EXISTING, libc::FILE_FLAG_OVERLAPPED, - ptr::mut_null()) + ptr::null_mut()) }; if result != libc::INVALID_HANDLE_VALUE { return Some(result) @@ -248,10 +248,10 @@ impl UnixStream { libc::CreateFileW(p, libc::GENERIC_WRITE | libc::FILE_READ_ATTRIBUTES, 0, - ptr::mut_null(), + ptr::null_mut(), libc::OPEN_EXISTING, libc::FILE_FLAG_OVERLAPPED, - ptr::mut_null()) + ptr::null_mut()) }; if result != libc::INVALID_HANDLE_VALUE { return Some(result) @@ -273,8 +273,8 @@ impl UnixStream { let ret = unsafe { libc::SetNamedPipeHandleState(inner.handle, &mut mode, - ptr::mut_null(), - ptr::mut_null()) + ptr::null_mut(), + ptr::null_mut()) }; return if ret == 0 { Err(super::last_error()) @@ -334,7 +334,7 @@ impl UnixStream { } fn cancel_io(&self) -> IoResult<()> { - match unsafe { c::CancelIoEx(self.handle(), ptr::mut_null()) } { + match unsafe { c::CancelIoEx(self.handle(), ptr::null_mut()) } { 0 if os::errno() == libc::ERROR_NOT_FOUND as uint => { Ok(()) } @@ -352,7 +352,7 @@ impl rtio::RtioPipe for UnixStream { let mut bytes_read = 0; let mut overlapped: libc::OVERLAPPED = unsafe { mem::zeroed() }; - overlapped.hEvent = self.read.get_ref().handle(); + overlapped.hEvent = self.read.as_ref().assert().handle(); // Pre-flight check to see if the reading half has been closed. This // must be done before issuing the ReadFile request, but after we @@ -424,7 +424,7 @@ impl rtio::RtioPipe for UnixStream { let mut offset = 0; let mut overlapped: libc::OVERLAPPED = unsafe { mem::zeroed() }; - overlapped.hEvent = self.write.get_ref().handle(); + overlapped.hEvent = self.write.as_ref().assert().handle(); while offset < buf.len() { let mut bytes_written = 0; diff --git a/src/libnative/io/process.rs b/src/libnative/io/process.rs index 77822bbbc20ff..9bb350cd3f04f 100644 --- a/src/libnative/io/process.rs +++ b/src/libnative/io/process.rs @@ -312,7 +312,7 @@ fn spawn_process_os(cfg: ProcessConfig, if b"PATH" != key.as_bytes_no_nul() { continue } // Split the value and test each path to see if the program exists. - for path in os::split_paths(v.as_bytes_no_nul()).move_iter() { + for path in os::split_paths(v.as_bytes_no_nul()).iter_owned() { let path = path.join(cfg.program.as_bytes_no_nul()) .with_extension(os::consts::EXE_EXTENSION); if path.exists() { @@ -346,7 +346,7 @@ fn spawn_process_os(cfg: ProcessConfig, let size = mem::size_of::(); let mut sa = libc::SECURITY_ATTRIBUTES { nLength: size as libc::DWORD, - lpSecurityDescriptor: ptr::mut_null(), + lpSecurityDescriptor: ptr::null_mut(), bInheritHandle: 1, }; let filename: Vec = "NUL".utf16_units().collect(); @@ -358,7 +358,7 @@ fn spawn_process_os(cfg: ProcessConfig, &mut sa, libc::OPEN_EXISTING, 0, - ptr::mut_null()); + ptr::null_mut()); if *slot == INVALID_HANDLE_VALUE { return Err(super::last_error()) } @@ -398,8 +398,8 @@ fn spawn_process_os(cfg: ProcessConfig, cmd_str = cmd_str.append_one(0); let created = CreateProcessW(ptr::null(), cmd_str.as_mut_ptr(), - ptr::mut_null(), - ptr::mut_null(), + ptr::null_mut(), + ptr::null_mut(), TRUE, flags, envp, dirp, &mut si, &mut pi); @@ -436,9 +436,9 @@ fn spawn_process_os(cfg: ProcessConfig, fn zeroed_startupinfo() -> libc::types::os::arch::extra::STARTUPINFO { libc::types::os::arch::extra::STARTUPINFO { cb: 0, - lpReserved: ptr::mut_null(), - lpDesktop: ptr::mut_null(), - lpTitle: ptr::mut_null(), + lpReserved: ptr::null_mut(), + lpDesktop: ptr::null_mut(), + lpTitle: ptr::null_mut(), dwX: 0, dwY: 0, dwXSize: 0, @@ -449,7 +449,7 @@ fn zeroed_startupinfo() -> libc::types::os::arch::extra::STARTUPINFO { dwFlags: 0, wShowWindow: 0, cbReserved2: 0, - lpReserved2: ptr::mut_null(), + lpReserved2: ptr::null_mut(), hStdInput: libc::INVALID_HANDLE_VALUE, hStdOutput: libc::INVALID_HANDLE_VALUE, hStdError: libc::INVALID_HANDLE_VALUE, @@ -459,8 +459,8 @@ fn zeroed_startupinfo() -> libc::types::os::arch::extra::STARTUPINFO { #[cfg(windows)] fn zeroed_process_information() -> libc::types::os::arch::extra::PROCESS_INFORMATION { libc::types::os::arch::extra::PROCESS_INFORMATION { - hProcess: ptr::mut_null(), - hThread: ptr::mut_null(), + hProcess: ptr::null_mut(), + hThread: ptr::null_mut(), dwProcessId: 0, dwThreadId: 0 } @@ -595,7 +595,7 @@ fn spawn_process_os(cfg: ProcessConfig, Err(..) => { Ok(SpawnProcessResult { pid: pid, - handle: ptr::mut_null() + handle: ptr::null_mut() }) } Ok(..) => fail!("short read on the cloexec pipe"), @@ -795,8 +795,8 @@ fn with_envp(env: Option<&[(&CString, &CString)]>, cb: |*mut c_void| -> T) -> for pair in env.iter() { let kv = format!("{}={}", - pair.ref0().as_str().unwrap(), - pair.ref1().as_str().unwrap()); + pair.ref0().as_str().assert(), + pair.ref1().as_str().assert()); blk.extend(kv.as_slice().utf16_units()); blk.push(0); } @@ -805,7 +805,7 @@ fn with_envp(env: Option<&[(&CString, &CString)]>, cb: |*mut c_void| -> T) -> cb(blk.as_mut_ptr() as *mut c_void) } - _ => cb(ptr::mut_null()) + _ => cb(ptr::null_mut()) } } @@ -1010,8 +1010,8 @@ fn waitpid(pid: pid_t, deadline: u64) -> IoResult { unsafe { let mut pipes = [0, ..2]; assert_eq!(libc::pipe(pipes.as_mut_ptr()), 0); - util::set_nonblocking(pipes[0], true).ok().unwrap(); - util::set_nonblocking(pipes[1], true).ok().unwrap(); + util::set_nonblocking(pipes[0], true).ok().assert(); + util::set_nonblocking(pipes[1], true).ok().assert(); WRITE_FD = pipes[1]; let mut old: c::sigaction = mem::zeroed(); @@ -1027,7 +1027,7 @@ fn waitpid(pid: pid_t, deadline: u64) -> IoResult { fn waitpid_helper(input: libc::c_int, messages: Receiver, (read_fd, old): (libc::c_int, c::sigaction)) { - util::set_nonblocking(input, true).ok().unwrap(); + util::set_nonblocking(input, true).ok().assert(); let mut set: c::fd_set = unsafe { mem::zeroed() }; let mut tv: libc::timeval; let mut active = Vec::<(libc::pid_t, Sender, u64)>::new(); @@ -1049,14 +1049,14 @@ fn waitpid(pid: pid_t, deadline: u64) -> IoResult { tv = util::ms_to_timeval(ms); (&mut tv as *mut _, idx) } - None => (ptr::mut_null(), -1), + None => (ptr::null_mut(), -1), }; // Wait for something to happen c::fd_set(&mut set, input); c::fd_set(&mut set, read_fd); - match unsafe { c::select(max, &mut set, ptr::mut_null(), - ptr::mut_null(), p) } { + match unsafe { c::select(max, &mut set, ptr::null_mut(), + ptr::null_mut(), p) } { // interrupted, retry -1 if os::errno() == libc::EINTR as int => continue, @@ -1128,7 +1128,7 @@ fn waitpid(pid: pid_t, deadline: u64) -> IoResult { // Once this helper thread is done, we re-register the old sigchld // handler and close our intermediate file descriptors. unsafe { - assert_eq!(c::sigaction(c::SIGCHLD, &old, ptr::mut_null()), 0); + assert_eq!(c::sigaction(c::SIGCHLD, &old, ptr::null_mut()), 0); let _ = libc::close(read_fd); let _ = libc::close(WRITE_FD); WRITE_FD = -1; diff --git a/src/libnative/io/timer_unix.rs b/src/libnative/io/timer_unix.rs index 06d48f2f886b8..29772d075a632 100644 --- a/src/libnative/io/timer_unix.rs +++ b/src/libnative/io/timer_unix.rs @@ -88,7 +88,7 @@ pub enum Req { pub fn now() -> u64 { unsafe { let mut now: libc::timeval = mem::zeroed(); - assert_eq!(c::gettimeofday(&mut now, ptr::mut_null()), 0); + assert_eq!(c::gettimeofday(&mut now, ptr::null_mut()), 0); return (now.tv_sec as u64) * 1000 + (now.tv_usec as u64) / 1000; } } @@ -119,7 +119,7 @@ fn helper(input: libc::c_int, messages: Receiver, _: ()) { let mut timer = match active.shift() { Some(timer) => timer, None => return }; - let mut cb = timer.cb.take_unwrap(); + let mut cb = timer.cb.take().assert(); cb.call(); if timer.repeat { timer.cb = Some(cb); @@ -133,7 +133,7 @@ fn helper(input: libc::c_int, messages: Receiver, _: ()) { 'outer: loop { let timeout = if active.len() == 0 { // Empty array? no timeout (wait forever for the next request) - ptr::mut_null() + ptr::null_mut() } else { let now = now(); // If this request has already expired, then signal it and go @@ -154,8 +154,8 @@ fn helper(input: libc::c_int, messages: Receiver, _: ()) { c::fd_set(&mut set, input); match unsafe { - c::select(input + 1, &mut set, ptr::mut_null(), - ptr::mut_null(), timeout) + c::select(input + 1, &mut set, ptr::null_mut(), + ptr::null_mut(), timeout) } { // timed out 0 => signal(&mut active, &mut dead), @@ -174,7 +174,7 @@ fn helper(input: libc::c_int, messages: Receiver, _: ()) { Ok(RemoveTimer(id, ack)) => { match dead.iter().position(|&(i, _)| id == i) { Some(i) => { - let (_, i) = dead.remove(i).unwrap(); + let (_, i) = dead.remove(i).assert(); ack.send(i); continue } @@ -182,7 +182,7 @@ fn helper(input: libc::c_int, messages: Receiver, _: ()) { } let i = active.iter().position(|i| i.id == id); let i = i.expect("no timer found"); - let t = active.remove(i).unwrap(); + let t = active.remove(i).assert(); ack.send(t); } Err(..) => break @@ -191,7 +191,7 @@ fn helper(input: libc::c_int, messages: Receiver, _: ()) { // drain the file descriptor let mut buf = [0]; - assert_eq!(fd.inner_read(buf).ok().unwrap(), 1); + assert_eq!(fd.inner_read(buf).ok().assert(), 1); } -1 if os::errno() == libc::EINTR as int => {} diff --git a/src/libnative/io/timer_win32.rs b/src/libnative/io/timer_win32.rs index 1e5594126b10a..64aef92198f19 100644 --- a/src/libnative/io/timer_win32.rs +++ b/src/libnative/io/timer_win32.rs @@ -107,7 +107,7 @@ impl Timer { unsafe { HELPER.boot(|| {}, helper) } let obj = unsafe { - imp::CreateWaitableTimerA(ptr::mut_null(), 0, ptr::null()) + imp::CreateWaitableTimerA(ptr::null_mut(), 0, ptr::null()) }; if obj.is_null() { Err(super::last_error()) @@ -141,8 +141,8 @@ impl rtio::RtioTimer for Timer { // 100ns intervals, so we multiply by 10^4. let due = -(msecs as i64 * 10000) as libc::LARGE_INTEGER; assert_eq!(unsafe { - imp::SetWaitableTimer(self.obj, &due, 0, ptr::mut_null(), - ptr::mut_null(), 0) + imp::SetWaitableTimer(self.obj, &due, 0, ptr::null_mut(), + ptr::null_mut(), 0) }, 1); let _ = unsafe { imp::WaitForSingleObject(self.obj, libc::INFINITE) }; @@ -154,8 +154,8 @@ impl rtio::RtioTimer for Timer { // see above for the calculation let due = -(msecs as i64 * 10000) as libc::LARGE_INTEGER; assert_eq!(unsafe { - imp::SetWaitableTimer(self.obj, &due, 0, ptr::mut_null(), - ptr::mut_null(), 0) + imp::SetWaitableTimer(self.obj, &due, 0, ptr::null_mut(), + ptr::null_mut(), 0) }, 1); unsafe { HELPER.send(NewTimer(self.obj, cb, true)) } @@ -169,7 +169,7 @@ impl rtio::RtioTimer for Timer { let due = -(msecs as i64 * 10000) as libc::LARGE_INTEGER; assert_eq!(unsafe { imp::SetWaitableTimer(self.obj, &due, msecs as libc::LONG, - ptr::mut_null(), ptr::mut_null(), 0) + ptr::null_mut(), ptr::null_mut(), 0) }, 1); unsafe { HELPER.send(NewTimer(self.obj, cb, false)) } diff --git a/src/libnative/io/tty_win32.rs b/src/libnative/io/tty_win32.rs index e98fe1e20b19e..bf847bc551393 100644 --- a/src/libnative/io/tty_win32.rs +++ b/src/libnative/io/tty_win32.rs @@ -98,7 +98,7 @@ impl RtioTTY for WindowsTTY { utf16.as_mut_ptr() as LPVOID, utf16.len() as u32, &mut num as LPDWORD, - ptr::mut_null()) } { + ptr::null_mut()) } { 0 => return Err(super::last_error()), _ => (), }; @@ -110,7 +110,7 @@ impl RtioTTY for WindowsTTY { self.utf8 = MemReader::new(utf8); } // MemReader shouldn't error here since we just filled it - Ok(self.utf8.read(buf).unwrap()) + Ok(self.utf8.read(buf).assert()) } fn write(&mut self, buf: &[u8]) -> IoResult<()> { @@ -123,7 +123,7 @@ impl RtioTTY for WindowsTTY { utf16.as_ptr() as LPCVOID, utf16.len() as u32, &mut num as LPDWORD, - ptr::mut_null()) } { + ptr::null_mut()) } { 0 => Err(super::last_error()), _ => Ok(()), } diff --git a/src/libnative/io/util.rs b/src/libnative/io/util.rs index 97518bbf19995..02a03530b83a7 100644 --- a/src/libnative/io/util.rs +++ b/src/libnative/io/util.rs @@ -154,15 +154,15 @@ pub fn connect_timeout(fd: net::sock_t, // undefined what the value of the 'tv' is after select // returns EINTR). let mut tv = ms_to_timeval(timeout - (::io::timer::now() - start)); - c::select(fd + 1, ptr::mut_null(), set as *mut _, - ptr::mut_null(), &mut tv) + c::select(fd + 1, ptr::null_mut(), set as *mut _, + ptr::null_mut(), &mut tv) }) } #[cfg(windows)] fn await(_fd: net::sock_t, set: &mut c::fd_set, timeout: u64) -> libc::c_int { let mut tv = ms_to_timeval(timeout); - unsafe { c::select(1, ptr::mut_null(), set, ptr::mut_null(), &mut tv) } + unsafe { c::select(1, ptr::null_mut(), set, ptr::null_mut(), &mut tv) } } } @@ -171,15 +171,15 @@ pub fn await(fd: net::sock_t, deadline: Option, let mut set: c::fd_set = unsafe { mem::zeroed() }; c::fd_set(&mut set, fd); let (read, write) = match status { - Readable => (&mut set as *mut _, ptr::mut_null()), - Writable => (ptr::mut_null(), &mut set as *mut _), + Readable => (&mut set as *mut _, ptr::null_mut()), + Writable => (ptr::null_mut(), &mut set as *mut _), }; let mut tv: libc::timeval = unsafe { mem::zeroed() }; match retry(|| { let now = ::io::timer::now(); let tvp = match deadline { - None => ptr::mut_null(), + None => ptr::null_mut(), Some(deadline) => { // If we're past the deadline, then pass a 0 timeout to // select() so we can poll the status @@ -189,7 +189,7 @@ pub fn await(fd: net::sock_t, deadline: Option, } }; let n = if cfg!(windows) {1} else {fd as libc::c_int + 1}; - let r = unsafe { c::select(n, read, write, ptr::mut_null(), tvp) }; + let r = unsafe { c::select(n, read, write, ptr::null_mut(), tvp) }; r }) { -1 => Err(last_error()), diff --git a/src/libnative/lib.rs b/src/libnative/lib.rs index c7b89b6cb9153..f18829bda2bd5 100644 --- a/src/libnative/lib.rs +++ b/src/libnative/lib.rs @@ -139,7 +139,7 @@ pub fn start(argc: int, argv: *const *const u8, main: proc()) -> int { unsafe { rt::stack::record_os_managed_stack_bounds(my_stack_bottom, my_stack_top); } - exit_code = Some(run(main.take_unwrap())); + exit_code = Some(run(main.take().assert())); }).destroy()); unsafe { rt::cleanup(); } // If the exit code wasn't set, then the task block must have failed. diff --git a/src/libnative/task.rs b/src/libnative/task.rs index 55806caaf1352..e3b221a3a9b61 100644 --- a/src/libnative/task.rs +++ b/src/libnative/task.rs @@ -92,7 +92,7 @@ pub fn spawn_opts(opts: TaskOpts, f: proc():Send) { let mut f = Some(f); let mut task = task; task.put_runtime(ops); - drop(task.run(|| { f.take_unwrap()() }).destroy()); + drop(task.run(|| { f.take().assert()() }).destroy()); drop(token); }) } @@ -378,6 +378,6 @@ mod tests { let res = TaskBuilder::new().native().try(proc() { "Success!".to_string() }); - assert_eq!(res.ok().unwrap(), "Success!".to_string()); + assert_eq!(res.ok().assert(), "Success!".to_string()); } } diff --git a/src/libnum/bigint.rs b/src/libnum/bigint.rs index 3a5f7649201cb..b2baab6b0b3b8 100644 --- a/src/libnum/bigint.rs +++ b/src/libnum/bigint.rs @@ -48,8 +48,8 @@ //! let mut rng = rand::task_rng(); //! let a = rng.gen_bigint(1000u); //! -//! let low = -10000i.to_bigint().unwrap(); -//! let high = 10000i.to_bigint().unwrap(); +//! let low = -10000i.to_bigint().assert(); +//! let high = 10000i.to_bigint().assert(); //! let b = rng.gen_bigint_range(&low, &high); //! //! // Probably an even larger number. @@ -422,7 +422,7 @@ impl Integer for BigUint { } let mut shift = 0; - let mut n = *other.data.last().unwrap(); + let mut n = *other.data.last().assert(); while n < (1 << BigDigit::bits - 2) { n <<= 1; shift += 1; @@ -471,7 +471,7 @@ impl Integer for BigUint { } let an = a.data.tailn(a.data.len() - n); - let bn = *b.data.last().unwrap(); + let bn = *b.data.last().assert(); let mut d = Vec::with_capacity(an.len()); let mut carry = 0; for elt in an.iter().rev() { @@ -646,16 +646,16 @@ impl ToStrRadix for BigUint { return fill_concat(convert_base(self, base).as_slice(), radix, max_len); fn convert_base(n: &BigUint, base: DoubleBigDigit) -> Vec { - let divider = base.to_biguint().unwrap(); + let divider = base.to_biguint().assert(); let mut result = Vec::new(); let mut m = n.clone(); while m >= divider { let (d, m0) = m.div_mod_floor(÷r); - result.push(m0.to_uint().unwrap() as BigDigit); + result.push(m0.to_uint().assert() as BigDigit); m = d; } if !m.is_zero() { - result.push(m.to_uint().unwrap() as BigDigit); + result.push(m.to_uint().assert() as BigDigit); } return result; } @@ -789,7 +789,7 @@ impl BigUint { /// Determines the fewest bits necessary to express the `BigUint`. pub fn bits(&self) -> uint { if self.is_zero() { return 0; } - let zeros = self.data.last().unwrap().leading_zeros(); + let zeros = self.data.last().assert().leading_zeros(); return self.data.len()*BigDigit::bits - (zeros as uint); } } @@ -1340,8 +1340,8 @@ impl RandBigInt for R { ubound: &BigInt) -> BigInt { assert!(*lbound < *ubound); - let delta = (*ubound - *lbound).to_biguint().unwrap(); - return *lbound + self.gen_biguint_below(&delta).to_bigint().unwrap(); + let delta = (*ubound - *lbound).to_biguint().assert(); + return *lbound + self.gen_biguint_below(&delta).to_bigint().assert(); } } @@ -1506,7 +1506,7 @@ mod biguint_tests { fn test_shl() { fn check(s: &str, shift: uint, ans: &str) { let opt_biguint: Option = FromStrRadix::from_str_radix(s, 16); - let bu = (opt_biguint.unwrap() << shift).to_str_radix(16); + let bu = (opt_biguint.assert() << shift).to_str_radix(16); assert_eq!(bu.as_slice(), ans); } @@ -1628,7 +1628,7 @@ mod biguint_tests { fn check(s: &str, shift: uint, ans: &str) { let opt_biguint: Option = FromStrRadix::from_str_radix(s, 16); - let bu = (opt_biguint.unwrap() >> shift).to_str_radix(16); + let bu = (opt_biguint.assert() >> shift).to_str_radix(16); assert_eq!(bu.as_slice(), ans); } @@ -1745,14 +1745,14 @@ mod biguint_tests { #[test] fn test_convert_i64() { fn check(b1: BigUint, i: i64) { - let b2: BigUint = FromPrimitive::from_i64(i).unwrap(); + let b2: BigUint = FromPrimitive::from_i64(i).assert(); assert!(b1 == b2); - assert!(b1.to_i64().unwrap() == i); + assert!(b1.to_i64().assert() == i); } check(Zero::zero(), 0); check(One::one(), 1); - check(i64::MAX.to_biguint().unwrap(), i64::MAX); + check(i64::MAX.to_biguint().assert(), i64::MAX); check(BigUint::new(vec!( )), 0); check(BigUint::new(vec!( 1 )), (1 << (0*BigDigit::bits))); @@ -1770,15 +1770,15 @@ mod biguint_tests { #[test] fn test_convert_u64() { fn check(b1: BigUint, u: u64) { - let b2: BigUint = FromPrimitive::from_u64(u).unwrap(); + let b2: BigUint = FromPrimitive::from_u64(u).assert(); assert!(b1 == b2); - assert!(b1.to_u64().unwrap() == u); + assert!(b1.to_u64().assert() == u); } check(Zero::zero(), 0); check(One::one(), 1); - check(u64::MIN.to_biguint().unwrap(), u64::MIN); - check(u64::MAX.to_biguint().unwrap(), u64::MAX); + check(u64::MIN.to_biguint().assert(), u64::MIN); + check(u64::MAX.to_biguint().assert(), u64::MAX); check(BigUint::new(vec!( )), 0); check(BigUint::new(vec!( 1 )), (1 << (0*BigDigit::bits))); @@ -1793,8 +1793,8 @@ mod biguint_tests { #[test] fn test_convert_to_bigint() { fn check(n: BigUint, ans: BigInt) { - assert_eq!(n.to_bigint().unwrap(), ans); - assert_eq!(n.to_bigint().unwrap().to_biguint().unwrap(), n); + assert_eq!(n.to_bigint().assert(), ans); + assert_eq!(n.to_bigint().assert().to_biguint().assert(), n); } check(Zero::zero(), Zero::zero()); check(BigUint::new(vec!(1,2,3)), @@ -1945,8 +1945,8 @@ mod biguint_tests { let b = BigUint::from_slice(bVec); let c = BigUint::from_slice(cVec); - assert!(a.checked_add(&b).unwrap() == c); - assert!(b.checked_add(&a).unwrap() == c); + assert!(a.checked_add(&b).assert() == c); + assert!(b.checked_add(&a).assert() == c); } } @@ -1958,8 +1958,8 @@ mod biguint_tests { let b = BigUint::from_slice(bVec); let c = BigUint::from_slice(cVec); - assert!(c.checked_sub(&a).unwrap() == b); - assert!(c.checked_sub(&b).unwrap() == a); + assert!(c.checked_sub(&a).assert() == b); + assert!(c.checked_sub(&b).assert() == a); if a > c { assert!(a.checked_sub(&c).is_none()); @@ -1978,8 +1978,8 @@ mod biguint_tests { let b = BigUint::from_slice(bVec); let c = BigUint::from_slice(cVec); - assert!(a.checked_mul(&b).unwrap() == c); - assert!(b.checked_mul(&a).unwrap() == c); + assert!(a.checked_mul(&b).assert() == c); + assert!(b.checked_mul(&a).assert() == c); } for elm in div_rem_quadruples.iter() { @@ -1989,8 +1989,8 @@ mod biguint_tests { let c = BigUint::from_slice(cVec); let d = BigUint::from_slice(dVec); - assert!(a == b.checked_mul(&c).unwrap() + d); - assert!(a == c.checked_mul(&b).unwrap() + d); + assert!(a == b.checked_mul(&c).assert() + d); + assert!(a == c.checked_mul(&b).assert() + d); } } @@ -2003,10 +2003,10 @@ mod biguint_tests { let c = BigUint::from_slice(cVec); if !a.is_zero() { - assert!(c.checked_div(&a).unwrap() == b); + assert!(c.checked_div(&a).assert() == b); } if !b.is_zero() { - assert!(c.checked_div(&b).unwrap() == a); + assert!(c.checked_div(&b).assert() == a); } assert!(c.checked_div(&Zero::zero()).is_none()); @@ -2016,9 +2016,9 @@ mod biguint_tests { #[test] fn test_gcd() { fn check(a: uint, b: uint, c: uint) { - let big_a: BigUint = FromPrimitive::from_uint(a).unwrap(); - let big_b: BigUint = FromPrimitive::from_uint(b).unwrap(); - let big_c: BigUint = FromPrimitive::from_uint(c).unwrap(); + let big_a: BigUint = FromPrimitive::from_uint(a).assert(); + let big_b: BigUint = FromPrimitive::from_uint(b).assert(); + let big_c: BigUint = FromPrimitive::from_uint(c).assert(); assert_eq!(big_a.gcd(&big_b), big_c); } @@ -2033,9 +2033,9 @@ mod biguint_tests { #[test] fn test_lcm() { fn check(a: uint, b: uint, c: uint) { - let big_a: BigUint = FromPrimitive::from_uint(a).unwrap(); - let big_b: BigUint = FromPrimitive::from_uint(b).unwrap(); - let big_c: BigUint = FromPrimitive::from_uint(c).unwrap(); + let big_a: BigUint = FromPrimitive::from_uint(a).assert(); + let big_b: BigUint = FromPrimitive::from_uint(b).assert(); + let big_c: BigUint = FromPrimitive::from_uint(c).assert(); assert_eq!(big_a.lcm(&big_b), big_c); } @@ -2050,11 +2050,11 @@ mod biguint_tests { #[test] fn test_is_even() { - let one: BigUint = FromStr::from_str("1").unwrap(); - let two: BigUint = FromStr::from_str("2").unwrap(); - let thousand: BigUint = FromStr::from_str("1000").unwrap(); - let big: BigUint = FromStr::from_str("1000000000000000000000").unwrap(); - let bigger: BigUint = FromStr::from_str("1000000000000000000001").unwrap(); + let one: BigUint = FromStr::from_str("1").assert(); + let two: BigUint = FromStr::from_str("2").assert(); + let thousand: BigUint = FromStr::from_str("1000").assert(); + let big: BigUint = FromStr::from_str("1000000000000000000000").assert(); + let bigger: BigUint = FromStr::from_str("1000000000000000000001").assert(); assert!(one.is_odd()); assert!(two.is_even()); assert!(thousand.is_even()); @@ -2143,7 +2143,7 @@ mod biguint_tests { let &(ref radix, ref str) = str_pair; assert_eq!(n, &FromStrRadix::from_str_radix(str.as_slice(), - *radix).unwrap()); + *radix).assert()); } } @@ -2163,7 +2163,7 @@ mod biguint_tests { for i in range(2, n + 1) { // FIXME(#5992): assignment operator overloads // f *= FromPrimitive::from_uint(i); - f = f * FromPrimitive::from_uint(i).unwrap(); + f = f * FromPrimitive::from_uint(i).assert(); } return f; } @@ -2185,13 +2185,13 @@ mod biguint_tests { #[test] fn test_bits() { assert_eq!(BigUint::new(vec!(0,0,0,0)).bits(), 0); - let n: BigUint = FromPrimitive::from_uint(0).unwrap(); + let n: BigUint = FromPrimitive::from_uint(0).assert(); assert_eq!(n.bits(), 0); - let n: BigUint = FromPrimitive::from_uint(1).unwrap(); + let n: BigUint = FromPrimitive::from_uint(1).assert(); assert_eq!(n.bits(), 1); - let n: BigUint = FromPrimitive::from_uint(3).unwrap(); + let n: BigUint = FromPrimitive::from_uint(3).assert(); assert_eq!(n.bits(), 2); - let n: BigUint = FromStrRadix::from_str_radix("4000000000", 16).unwrap(); + let n: BigUint = FromStrRadix::from_str_radix("4000000000", 16).assert(); assert_eq!(n.bits(), 39); let one: BigUint = One::one(); assert_eq!((one << 426).bits(), 427); @@ -2209,13 +2209,13 @@ mod biguint_tests { let mut rng = task_rng(); for _ in range(0u, 10) { - assert_eq!(rng.gen_bigint_range(&FromPrimitive::from_uint(236).unwrap(), - &FromPrimitive::from_uint(237).unwrap()), - FromPrimitive::from_uint(236).unwrap()); + assert_eq!(rng.gen_bigint_range(&FromPrimitive::from_uint(236).assert(), + &FromPrimitive::from_uint(237).assert()), + FromPrimitive::from_uint(236).assert()); } - let l = FromPrimitive::from_uint(403469000 + 2352).unwrap(); - let u = FromPrimitive::from_uint(403469000 + 3513).unwrap(); + let l = FromPrimitive::from_uint(403469000 + 2352).assert(); + let u = FromPrimitive::from_uint(403469000 + 3513).assert(); for _ in range(0u, 1000) { let n: BigUint = rng.gen_biguint_below(&u); assert!(n < u); @@ -2229,16 +2229,16 @@ mod biguint_tests { #[test] #[should_fail] fn test_zero_rand_range() { - task_rng().gen_biguint_range(&FromPrimitive::from_uint(54).unwrap(), - &FromPrimitive::from_uint(54).unwrap()); + task_rng().gen_biguint_range(&FromPrimitive::from_uint(54).assert(), + &FromPrimitive::from_uint(54).assert()); } #[test] #[should_fail] fn test_negative_rand_range() { let mut rng = task_rng(); - let l = FromPrimitive::from_uint(2352).unwrap(); - let u = FromPrimitive::from_uint(3513).unwrap(); + let l = FromPrimitive::from_uint(2352).assert(); + let u = FromPrimitive::from_uint(3513).assert(); // Switching u and l should fail: let _n: BigUint = rng.gen_biguint_range(&u, &l); } @@ -2261,8 +2261,8 @@ mod bigint_tests { #[test] fn test_from_biguint() { fn check(inp_s: Sign, inp_n: uint, ans_s: Sign, ans_n: uint) { - let inp = BigInt::from_biguint(inp_s, FromPrimitive::from_uint(inp_n).unwrap()); - let ans = BigInt { sign: ans_s, data: FromPrimitive::from_uint(ans_n).unwrap()}; + let inp = BigInt::from_biguint(inp_s, FromPrimitive::from_uint(inp_n).assert()); + let ans = BigInt { sign: ans_s, data: FromPrimitive::from_uint(ans_n).assert()}; assert_eq!(inp, ans); } check(Plus, 1, Plus, 1); @@ -2317,18 +2317,18 @@ mod bigint_tests { #[test] fn test_convert_i64() { fn check(b1: BigInt, i: i64) { - let b2: BigInt = FromPrimitive::from_i64(i).unwrap(); + let b2: BigInt = FromPrimitive::from_i64(i).assert(); assert!(b1 == b2); - assert!(b1.to_i64().unwrap() == i); + assert!(b1.to_i64().assert() == i); } check(Zero::zero(), 0); check(One::one(), 1); - check(i64::MIN.to_bigint().unwrap(), i64::MIN); - check(i64::MAX.to_bigint().unwrap(), i64::MAX); + check(i64::MIN.to_bigint().assert(), i64::MIN); + check(i64::MAX.to_bigint().assert(), i64::MAX); assert_eq!( - (i64::MAX as u64 + 1).to_bigint().unwrap().to_i64(), + (i64::MAX as u64 + 1).to_bigint().assert().to_i64(), None); assert_eq!( @@ -2347,21 +2347,21 @@ mod bigint_tests { #[test] fn test_convert_u64() { fn check(b1: BigInt, u: u64) { - let b2: BigInt = FromPrimitive::from_u64(u).unwrap(); + let b2: BigInt = FromPrimitive::from_u64(u).assert(); assert!(b1 == b2); - assert!(b1.to_u64().unwrap() == u); + assert!(b1.to_u64().assert() == u); } check(Zero::zero(), 0); check(One::one(), 1); - check(u64::MIN.to_bigint().unwrap(), u64::MIN); - check(u64::MAX.to_bigint().unwrap(), u64::MAX); + check(u64::MIN.to_bigint().assert(), u64::MIN); + check(u64::MAX.to_bigint().assert(), u64::MAX); assert_eq!( BigInt::from_biguint(Plus, BigUint::new(vec!(1, 2, 3, 4, 5))).to_u64(), None); - let max_value: BigUint = FromPrimitive::from_u64(u64::MAX).unwrap(); + let max_value: BigUint = FromPrimitive::from_u64(u64::MAX).assert(); assert_eq!(BigInt::from_biguint(Minus, max_value).to_u64(), None); assert_eq!(BigInt::from_biguint(Minus, BigUint::new(vec!(1, 2, 3, 4, 5))).to_u64(), None); } @@ -2369,8 +2369,8 @@ mod bigint_tests { #[test] fn test_convert_to_biguint() { fn check(n: BigInt, ans_1: BigUint) { - assert_eq!(n.to_biguint().unwrap(), ans_1); - assert_eq!(n.to_biguint().unwrap().to_bigint().unwrap(), n); + assert_eq!(n.to_biguint().assert(), ans_1); + assert_eq!(n.to_biguint().assert().to_bigint().assert(), n); } let zero: BigInt = Zero::zero(); let unsigned_zero: BigUint = Zero::zero(); @@ -2602,14 +2602,14 @@ mod bigint_tests { let b = BigInt::from_slice(Plus, bVec); let c = BigInt::from_slice(Plus, cVec); - assert!(a.checked_add(&b).unwrap() == c); - assert!(b.checked_add(&a).unwrap() == c); - assert!(c.checked_add(&(-a)).unwrap() == b); - assert!(c.checked_add(&(-b)).unwrap() == a); - assert!(a.checked_add(&(-c)).unwrap() == (-b)); - assert!(b.checked_add(&(-c)).unwrap() == (-a)); - assert!((-a).checked_add(&(-b)).unwrap() == (-c)) - assert!(a.checked_add(&(-a)).unwrap() == Zero::zero()); + assert!(a.checked_add(&b).assert() == c); + assert!(b.checked_add(&a).assert() == c); + assert!(c.checked_add(&(-a)).assert() == b); + assert!(c.checked_add(&(-b)).assert() == a); + assert!(a.checked_add(&(-c)).assert() == (-b)); + assert!(b.checked_add(&(-c)).assert() == (-a)); + assert!((-a).checked_add(&(-b)).assert() == (-c)) + assert!(a.checked_add(&(-a)).assert() == Zero::zero()); } } @@ -2621,14 +2621,14 @@ mod bigint_tests { let b = BigInt::from_slice(Plus, bVec); let c = BigInt::from_slice(Plus, cVec); - assert!(c.checked_sub(&a).unwrap() == b); - assert!(c.checked_sub(&b).unwrap() == a); - assert!((-b).checked_sub(&a).unwrap() == (-c)) - assert!((-a).checked_sub(&b).unwrap() == (-c)) - assert!(b.checked_sub(&(-a)).unwrap() == c); - assert!(a.checked_sub(&(-b)).unwrap() == c); - assert!((-c).checked_sub(&(-a)).unwrap() == (-b)); - assert!(a.checked_sub(&a).unwrap() == Zero::zero()); + assert!(c.checked_sub(&a).assert() == b); + assert!(c.checked_sub(&b).assert() == a); + assert!((-b).checked_sub(&a).assert() == (-c)) + assert!((-a).checked_sub(&b).assert() == (-c)) + assert!(b.checked_sub(&(-a)).assert() == c); + assert!(a.checked_sub(&(-b)).assert() == c); + assert!((-c).checked_sub(&(-a)).assert() == (-b)); + assert!(a.checked_sub(&a).assert() == Zero::zero()); } } @@ -2640,11 +2640,11 @@ mod bigint_tests { let b = BigInt::from_slice(Plus, bVec); let c = BigInt::from_slice(Plus, cVec); - assert!(a.checked_mul(&b).unwrap() == c); - assert!(b.checked_mul(&a).unwrap() == c); + assert!(a.checked_mul(&b).assert() == c); + assert!(b.checked_mul(&a).assert() == c); - assert!((-a).checked_mul(&b).unwrap() == -c); - assert!((-b).checked_mul(&a).unwrap() == -c); + assert!((-a).checked_mul(&b).assert() == -c); + assert!((-b).checked_mul(&a).assert() == -c); } for elm in div_rem_quadruples.iter() { @@ -2654,8 +2654,8 @@ mod bigint_tests { let c = BigInt::from_slice(Plus, cVec); let d = BigInt::from_slice(Plus, dVec); - assert!(a == b.checked_mul(&c).unwrap() + d); - assert!(a == c.checked_mul(&b).unwrap() + d); + assert!(a == b.checked_mul(&c).assert() + d); + assert!(a == c.checked_mul(&b).assert() + d); } } #[test] @@ -2667,14 +2667,14 @@ mod bigint_tests { let c = BigInt::from_slice(Plus, cVec); if !a.is_zero() { - assert!(c.checked_div(&a).unwrap() == b); - assert!((-c).checked_div(&(-a)).unwrap() == b); - assert!((-c).checked_div(&a).unwrap() == -b); + assert!(c.checked_div(&a).assert() == b); + assert!((-c).checked_div(&(-a)).assert() == b); + assert!((-c).checked_div(&a).assert() == -b); } if !b.is_zero() { - assert!(c.checked_div(&b).unwrap() == a); - assert!((-c).checked_div(&(-b)).unwrap() == a); - assert!((-c).checked_div(&b).unwrap() == -a); + assert!(c.checked_div(&b).assert() == a); + assert!((-c).checked_div(&(-b)).assert() == a); + assert!((-c).checked_div(&b).assert() == -a); } assert!(c.checked_div(&Zero::zero()).is_none()); @@ -2685,9 +2685,9 @@ mod bigint_tests { #[test] fn test_gcd() { fn check(a: int, b: int, c: int) { - let big_a: BigInt = FromPrimitive::from_int(a).unwrap(); - let big_b: BigInt = FromPrimitive::from_int(b).unwrap(); - let big_c: BigInt = FromPrimitive::from_int(c).unwrap(); + let big_a: BigInt = FromPrimitive::from_int(a).assert(); + let big_b: BigInt = FromPrimitive::from_int(b).assert(); + let big_c: BigInt = FromPrimitive::from_int(c).assert(); assert_eq!(big_a.gcd(&big_b), big_c); } @@ -2705,9 +2705,9 @@ mod bigint_tests { #[test] fn test_lcm() { fn check(a: int, b: int, c: int) { - let big_a: BigInt = FromPrimitive::from_int(a).unwrap(); - let big_b: BigInt = FromPrimitive::from_int(b).unwrap(); - let big_c: BigInt = FromPrimitive::from_int(c).unwrap(); + let big_a: BigInt = FromPrimitive::from_int(a).assert(); + let big_b: BigInt = FromPrimitive::from_int(b).assert(); + let big_c: BigInt = FromPrimitive::from_int(c).assert(); assert_eq!(big_a.lcm(&big_b), big_c); } @@ -2734,14 +2734,14 @@ mod bigint_tests { let zero: BigInt = Zero::zero(); assert_eq!(one.abs_sub(&zero), one); let one: BigInt = One::one(); - let two: BigInt = FromPrimitive::from_int(2).unwrap(); + let two: BigInt = FromPrimitive::from_int(2).assert(); assert_eq!(one.abs_sub(&-one), two); } #[test] fn test_to_str_radix() { fn check(n: int, ans: &str) { - let n: BigInt = FromPrimitive::from_int(n).unwrap(); + let n: BigInt = FromPrimitive::from_int(n).assert(); assert!(ans == n.to_str_radix(10).as_slice()); } check(10, "10"); @@ -2756,7 +2756,7 @@ mod bigint_tests { fn test_from_str_radix() { fn check(s: &str, ans: Option) { let ans = ans.map(|n| { - let x: BigInt = FromPrimitive::from_int(n).unwrap(); + let x: BigInt = FromPrimitive::from_int(n).assert(); x }); assert_eq!(FromStrRadix::from_str_radix(s, 10), ans); @@ -2772,7 +2772,7 @@ mod bigint_tests { // issue 10522, this hit an edge case that caused it to // attempt to allocate a vector of size (-1u) == huge. let x: BigInt = - from_str(format!("1{}", "0".repeat(36)).as_slice()).unwrap(); + from_str(format!("1{}", "0".repeat(36)).as_slice()).assert(); let _y = x.to_string(); } @@ -2798,9 +2798,9 @@ mod bigint_tests { let mut rng = task_rng(); for _ in range(0u, 10) { - assert_eq!(rng.gen_bigint_range(&FromPrimitive::from_uint(236).unwrap(), - &FromPrimitive::from_uint(237).unwrap()), - FromPrimitive::from_uint(236).unwrap()); + assert_eq!(rng.gen_bigint_range(&FromPrimitive::from_uint(236).assert(), + &FromPrimitive::from_uint(237).assert()), + FromPrimitive::from_uint(236).assert()); } fn check(l: BigInt, u: BigInt) { @@ -2811,8 +2811,8 @@ mod bigint_tests { assert!(n < u); } } - let l: BigInt = FromPrimitive::from_uint(403469000 + 2352).unwrap(); - let u: BigInt = FromPrimitive::from_uint(403469000 + 3513).unwrap(); + let l: BigInt = FromPrimitive::from_uint(403469000 + 2352).assert(); + let u: BigInt = FromPrimitive::from_uint(403469000 + 3513).assert(); check( l.clone(), u.clone()); check(-l.clone(), u.clone()); check(-u.clone(), -l.clone()); @@ -2821,16 +2821,16 @@ mod bigint_tests { #[test] #[should_fail] fn test_zero_rand_range() { - task_rng().gen_bigint_range(&FromPrimitive::from_int(54).unwrap(), - &FromPrimitive::from_int(54).unwrap()); + task_rng().gen_bigint_range(&FromPrimitive::from_int(54).assert(), + &FromPrimitive::from_int(54).assert()); } #[test] #[should_fail] fn test_negative_rand_range() { let mut rng = task_rng(); - let l = FromPrimitive::from_uint(2352).unwrap(); - let u = FromPrimitive::from_uint(3513).unwrap(); + let l = FromPrimitive::from_uint(2352).assert(); + let u = FromPrimitive::from_uint(3513).assert(); // Switching u and l should fail: let _n: BigInt = rng.gen_bigint_range(&u, &l); } @@ -2848,7 +2848,7 @@ mod bench { fn factorial(n: uint) -> BigUint { let mut f: BigUint = One::one(); for i in iter::range_inclusive(1, n) { - f = f * FromPrimitive::from_uint(i).unwrap(); + f = f * FromPrimitive::from_uint(i).assert(); } f } diff --git a/src/libnum/lib.rs b/src/libnum/lib.rs index 5cc2eee7da75c..051ed9c1c5e89 100644 --- a/src/libnum/lib.rs +++ b/src/libnum/lib.rs @@ -24,12 +24,12 @@ //! use num::rational::{Ratio, BigRational}; //! //! fn approx_sqrt(number: u64, iterations: uint) -> BigRational { -//! let start: Ratio = Ratio::from_integer(FromPrimitive::from_u64(number).unwrap()); +//! let start: Ratio = Ratio::from_integer(FromPrimitive::from_u64(number).assert()); //! let mut approx = start.clone(); //! //! for _ in range(0, iterations) { //! approx = (approx + (start / approx)) / -//! Ratio::from_integer(FromPrimitive::from_u64(2).unwrap()); +//! Ratio::from_integer(FromPrimitive::from_u64(2).assert()); //! } //! //! approx diff --git a/src/libnum/rational.rs b/src/libnum/rational.rs index e0f6b4fb9af66..cb76dac7c08fc 100644 --- a/src/libnum/rational.rs +++ b/src/libnum/rational.rs @@ -173,10 +173,10 @@ impl Ratio { if exponent < 0 { let one: BigInt = One::one(); let denom: BigInt = one << ((-exponent) as uint); - let numer: BigUint = FromPrimitive::from_u64(mantissa).unwrap(); + let numer: BigUint = FromPrimitive::from_u64(mantissa).assert(); Some(Ratio::new(BigInt::from_biguint(bigint_sign, numer), denom)) } else { - let mut numer: BigUint = FromPrimitive::from_u64(mantissa).unwrap(); + let mut numer: BigUint = FromPrimitive::from_u64(mantissa).assert(); numer = numer << (exponent as uint); Some(Ratio::from_integer(BigInt::from_biguint(bigint_sign, numer))) } @@ -392,8 +392,8 @@ mod test { pub fn to_big(n: Rational) -> BigRational { Ratio::new( - FromPrimitive::from_int(n.numer).unwrap(), - FromPrimitive::from_int(n.denom).unwrap() + FromPrimitive::from_int(n.numer).assert(), + FromPrimitive::from_int(n.denom).assert() ) } @@ -682,10 +682,10 @@ mod test { #[test] fn test_from_float() { fn test(given: T, (numer, denom): (&str, &str)) { - let ratio: BigRational = Ratio::from_float(given).unwrap(); + let ratio: BigRational = Ratio::from_float(given).assert(); assert_eq!(ratio, Ratio::new( - FromStr::from_str(numer).unwrap(), - FromStr::from_str(denom).unwrap())); + FromStr::from_str(numer).assert(), + FromStr::from_str(denom).assert())); } // f32 diff --git a/src/librand/distributions/mod.rs b/src/librand/distributions/mod.rs index faafbc4421e24..184e05fcf0316 100644 --- a/src/librand/distributions/mod.rs +++ b/src/librand/distributions/mod.rs @@ -127,7 +127,7 @@ impl<'a, T: Clone> WeightedChoice<'a, T> { // we convert the list from individual weights to cumulative // weights so we can binary search. This *could* drop elements // with weight == 0 as an optimisation. - for item in items.mut_iter() { + for item in items.iter_mut() { running_total = match running_total.checked_add(&item.weight) { Some(n) => n, None => fail!("WeightedChoice::new called with a total weight \ diff --git a/src/librand/isaac.rs b/src/librand/isaac.rs index 134e7af507010..585e23464b95f 100644 --- a/src/librand/isaac.rs +++ b/src/librand/isaac.rs @@ -195,7 +195,7 @@ impl<'a> SeedableRng<&'a [u32]> for IsaacRng { // - 1], 0, 0, ...], to fill rng.rsl. let seed_iter = seed.iter().map(|&x| x).chain(Repeat::new(0u32)); - for (rsl_elem, seed_elem) in self.rsl.mut_iter().zip(seed_iter) { + for (rsl_elem, seed_elem) in self.rsl.iter_mut().zip(seed_iter) { *rsl_elem = seed_elem; } self.cnt = 0; @@ -426,7 +426,7 @@ impl<'a> SeedableRng<&'a [u64]> for Isaac64Rng { // - 1], 0, 0, ...], to fill rng.rsl. let seed_iter = seed.iter().map(|&x| x).chain(Repeat::new(0u64)); - for (rsl_elem, seed_elem) in self.rsl.mut_iter().zip(seed_iter) { + for (rsl_elem, seed_elem) in self.rsl.iter_mut().zip(seed_iter) { *rsl_elem = seed_elem; } self.cnt = 0; diff --git a/src/librand/lib.rs b/src/librand/lib.rs index 9c33b713e4a6b..4a9a5aae9d3af 100644 --- a/src/librand/lib.rs +++ b/src/librand/lib.rs @@ -113,7 +113,7 @@ pub trait Rng { // optimisations are on. let mut count = 0i; let mut num = 0; - for byte in dest.mut_iter() { + for byte in dest.iter_mut() { if count == 0 { // we could micro-optimise here by generating a u32 if // we only need a few more bytes to fill the vector @@ -295,7 +295,7 @@ impl<'a, R: Rng> Iterator for AsciiGenerator<'a, R> { b"ABCDEFGHIJKLMNOPQRSTUVWXYZ\ abcdefghijklmnopqrstuvwxyz\ 0123456789"; - Some(*self.rng.choose(GEN_ASCII_STR_CHARSET).unwrap() as char) + Some(*self.rng.choose(GEN_ASCII_STR_CHARSET).assert() as char) } } diff --git a/src/librand/reseeding.rs b/src/librand/reseeding.rs index 7a237670890ca..93d180e3fc97f 100644 --- a/src/librand/reseeding.rs +++ b/src/librand/reseeding.rs @@ -117,7 +117,7 @@ impl, Rsdr: Reseeder + Default> /// fn main() { /// let rsdr = TickTockReseeder { tick: true }; /// -/// let inner = StdRng::new().unwrap(); +/// let inner = StdRng::new().assert(); /// let mut rng = ReseedingRng::new(inner, 10, rsdr); /// /// // this will repeat, because it gets reseeded very regularly. diff --git a/src/librbml/io.rs b/src/librbml/io.rs index 9ab163c5f4740..a7da12ce8031d 100644 --- a/src/librbml/io.rs +++ b/src/librbml/io.rs @@ -101,7 +101,7 @@ impl Writer for SeekableMemWriter { // Do the necessary writes if left.len() > 0 { - slice::bytes::copy_memory(self.buf.mut_slice_from(self.pos), left); + slice::bytes::copy_memory(self.buf.slice_from_mut(self.pos), left); } if right.len() > 0 { self.buf.push_all(right); @@ -137,35 +137,35 @@ mod tests { fn test_seekable_mem_writer() { let mut writer = SeekableMemWriter::new(); assert_eq!(writer.tell(), Ok(0)); - writer.write([0]).unwrap(); + writer.write([0]).assert(); assert_eq!(writer.tell(), Ok(1)); - writer.write([1, 2, 3]).unwrap(); - writer.write([4, 5, 6, 7]).unwrap(); + writer.write([1, 2, 3]).assert(); + writer.write([4, 5, 6, 7]).assert(); assert_eq!(writer.tell(), Ok(8)); - assert_eq!(writer.get_ref(), &[0, 1, 2, 3, 4, 5, 6, 7]); + assert_eq!(writer.as_ref().assert(), &[0, 1, 2, 3, 4, 5, 6, 7]); - writer.seek(0, io::SeekSet).unwrap(); + writer.seek(0, io::SeekSet).assert(); assert_eq!(writer.tell(), Ok(0)); - writer.write([3, 4]).unwrap(); - assert_eq!(writer.get_ref(), &[3, 4, 2, 3, 4, 5, 6, 7]); + writer.write([3, 4]).assert(); + assert_eq!(writer.as_ref().assert(), &[3, 4, 2, 3, 4, 5, 6, 7]); - writer.seek(1, io::SeekCur).unwrap(); - writer.write([0, 1]).unwrap(); - assert_eq!(writer.get_ref(), &[3, 4, 2, 0, 1, 5, 6, 7]); + writer.seek(1, io::SeekCur).assert(); + writer.write([0, 1]).assert(); + assert_eq!(writer.as_ref().assert(), &[3, 4, 2, 0, 1, 5, 6, 7]); - writer.seek(-1, io::SeekEnd).unwrap(); - writer.write([1, 2]).unwrap(); - assert_eq!(writer.get_ref(), &[3, 4, 2, 0, 1, 5, 6, 1, 2]); + writer.seek(-1, io::SeekEnd).assert(); + writer.write([1, 2]).assert(); + assert_eq!(writer.as_ref().assert(), &[3, 4, 2, 0, 1, 5, 6, 1, 2]); - writer.seek(1, io::SeekEnd).unwrap(); - writer.write([1]).unwrap(); - assert_eq!(writer.get_ref(), &[3, 4, 2, 0, 1, 5, 6, 1, 2, 0, 1]); + writer.seek(1, io::SeekEnd).assert(); + writer.write([1]).assert(); + assert_eq!(writer.as_ref().assert(), &[3, 4, 2, 0, 1, 5, 6, 1, 2, 0, 1]); } #[test] fn seek_past_end() { let mut r = SeekableMemWriter::new(); - r.seek(10, io::SeekSet).unwrap(); + r.seek(10, io::SeekSet).assert(); assert!(r.write([3]).is_ok()); } @@ -182,10 +182,10 @@ mod tests { b.iter(|| { let mut wr = SeekableMemWriter::new(); for _ in range(0, times) { - wr.write(src.as_slice()).unwrap(); + wr.write(src.as_slice()).assert(); } - let v = wr.unwrap(); + let v = wr.assert(); assert_eq!(v.len(), times * len); assert!(v.iter().all(|x| *x == 5)); }); diff --git a/src/librbml/lib.rs b/src/librbml/lib.rs index 4927a8293a4da..eaa8e6e0ec8f9 100644 --- a/src/librbml/lib.rs +++ b/src/librbml/lib.rs @@ -54,7 +54,7 @@ impl<'doc> Doc<'doc> { } pub fn as_str_slice<'a>(&'a self) -> &'a str { - str::from_utf8(self.data.slice(self.start, self.end)).unwrap() + str::from_utf8(self.data.slice(self.start, self.end)).assert() } pub fn as_str(&self) -> String { @@ -453,7 +453,7 @@ pub mod reader { Ok(unsafe { transmute(bits) }) } fn read_char(&mut self) -> DecodeResult { - Ok(char::from_u32(doc_as_u32(try!(self.next_doc(EsChar)))).unwrap()) + Ok(char::from_u32(doc_as_u32(try!(self.next_doc(EsChar)))).assert()) } fn read_str(&mut self) -> DecodeResult { Ok(try!(self.next_doc(EsStr)).as_str()) @@ -725,7 +725,7 @@ pub mod writer { } pub fn end_tag(&mut self) -> EncodeResult { - let last_size_pos = self.size_positions.pop().unwrap(); + let last_size_pos = self.size_positions.pop().assert(); let cur_pos = try!(self.writer.tell()); try!(self.writer.seek(last_size_pos as i64, io::SeekSet)); let size = cur_pos as uint - last_size_pos - 4; @@ -1068,34 +1068,34 @@ mod tests { let mut res: reader::Res; // Class A - res = reader::vuint_at(data, 0).unwrap(); + res = reader::vuint_at(data, 0).assert(); assert_eq!(res.val, 0); assert_eq!(res.next, 1); - res = reader::vuint_at(data, res.next).unwrap(); + res = reader::vuint_at(data, res.next).assert(); assert_eq!(res.val, (1 << 7) - 1); assert_eq!(res.next, 2); // Class B - res = reader::vuint_at(data, res.next).unwrap(); + res = reader::vuint_at(data, res.next).assert(); assert_eq!(res.val, 0); assert_eq!(res.next, 4); - res = reader::vuint_at(data, res.next).unwrap(); + res = reader::vuint_at(data, res.next).assert(); assert_eq!(res.val, (1 << 14) - 1); assert_eq!(res.next, 6); // Class C - res = reader::vuint_at(data, res.next).unwrap(); + res = reader::vuint_at(data, res.next).assert(); assert_eq!(res.val, 0); assert_eq!(res.next, 9); - res = reader::vuint_at(data, res.next).unwrap(); + res = reader::vuint_at(data, res.next).assert(); assert_eq!(res.val, (1 << 21) - 1); assert_eq!(res.next, 12); // Class D - res = reader::vuint_at(data, res.next).unwrap(); + res = reader::vuint_at(data, res.next).assert(); assert_eq!(res.val, 0); assert_eq!(res.next, 16); - res = reader::vuint_at(data, res.next).unwrap(); + res = reader::vuint_at(data, res.next).assert(); assert_eq!(res.val, (1 << 28) - 1); assert_eq!(res.next, 20); } @@ -1109,9 +1109,9 @@ mod tests { let mut rbml_w = writer::Encoder::new(&mut wr); let _ = v.encode(&mut rbml_w); } - let rbml_doc = Doc::new(wr.get_ref()); + let rbml_doc = Doc::new(wr.as_ref().assert()); let mut deser = reader::Decoder::new(rbml_doc); - let v1 = Decodable::decode(&mut deser).unwrap(); + let v1 = Decodable::decode(&mut deser).assert(); debug!("v1 == {}", v1); assert_eq!(v, v1); } @@ -1140,7 +1140,7 @@ mod bench { b.iter(|| { let mut i = 0; while i < data.len() { - sum += reader::vuint_at(data.as_slice(), i).unwrap().val; + sum += reader::vuint_at(data.as_slice(), i).assert().val; i += 4; } }); @@ -1158,7 +1158,7 @@ mod bench { b.iter(|| { let mut i = 1; while i < data.len() { - sum += reader::vuint_at(data.as_slice(), i).unwrap().val; + sum += reader::vuint_at(data.as_slice(), i).assert().val; i += 4; } }); @@ -1177,7 +1177,7 @@ mod bench { b.iter(|| { let mut i = 0; while i < data.len() { - sum += reader::vuint_at(data.as_slice(), i).unwrap().val; + sum += reader::vuint_at(data.as_slice(), i).assert().val; i += 4; } }); @@ -1196,7 +1196,7 @@ mod bench { b.iter(|| { let mut i = 1; while i < data.len() { - sum += reader::vuint_at(data.as_slice(), i).unwrap().val; + sum += reader::vuint_at(data.as_slice(), i).assert().val; i += 4; } }); diff --git a/src/libregex/compile.rs b/src/libregex/compile.rs index ea472abeee690..e9e8d81310d92 100644 --- a/src/libregex/compile.rs +++ b/src/libregex/compile.rs @@ -165,7 +165,7 @@ impl<'r> Compiler<'r> { self.push(Save(2 * cap + 1)); } Cat(xs) => { - for x in xs.move_iter() { + for x in xs.iter_owned() { self.compile(x) } } diff --git a/src/libregex/lib.rs b/src/libregex/lib.rs index fae3e5986806d..8e1ecd88ac2b7 100644 --- a/src/libregex/lib.rs +++ b/src/libregex/lib.rs @@ -283,7 +283,7 @@ //! # extern crate regex; #[phase(plugin)] extern crate regex_macros; //! # fn main() { //! let re = regex!(r"(?i)a+(?-i)b+"); -//! let cap = re.captures("AaAaAbbBBBb").unwrap(); +//! let cap = re.captures("AaAaAbbBBBb").assert(); //! assert_eq!(cap.at(0), "AaAaAbb"); //! # } //! ``` diff --git a/src/libregex/parse.rs b/src/libregex/parse.rs index a1fd62cecbed9..8a8b818d34c47 100644 --- a/src/libregex/parse.rs +++ b/src/libregex/parse.rs @@ -245,7 +245,7 @@ impl<'a> Parser<'a> { // alternate and make it a capture. if cap.is_some() { let ast = try!(self.pop_ast()); - self.push(Capture(cap.unwrap(), cap_name, box ast)); + self.push(Capture(cap.assert(), cap_name, box ast)); } } '|' => { @@ -303,7 +303,7 @@ impl<'a> Parser<'a> { } fn pop_ast(&mut self) -> Result { - match self.stack.pop().unwrap().unwrap() { + match self.stack.pop().assert().unwrap() { Err(e) => Err(e), Ok(ast) => Ok(ast), } @@ -417,13 +417,13 @@ impl<'a> Parser<'a> { if ranges.len() > 0 { let flags = negated | (self.flags & FLAG_NOCASE); let mut ast = Class(combine_ranges(ranges), flags); - for alt in alts.move_iter() { + for alt in alts.iter_owned() { ast = Alt(box alt, box ast) } self.push(ast); } else if alts.len() > 0 { - let mut ast = alts.pop().unwrap(); - for alt in alts.move_iter() { + let mut ast = alts.pop().assert(); + for alt in alts.iter_owned() { ast = Alt(box alt, box ast) } self.push(ast); @@ -540,7 +540,7 @@ impl<'a> Parser<'a> { min, MAX_REPEAT).as_slice()); } if max.is_some() { - let m = max.unwrap(); + let m = max.assert(); if m > MAX_REPEAT { return self.err(format!( "{} exceeds maximum allowed repetitions ({})", @@ -569,7 +569,7 @@ impl<'a> Parser<'a> { self.push(ast.clone()) } if max.is_some() { - for _ in iter::range(min, max.unwrap()) { + for _ in iter::range(min, max.assert()) { self.push(Rep(box ast.clone(), ZeroOne, greed)) } } @@ -886,7 +886,7 @@ impl<'a> Parser<'a> { let mut i = self.stack.len(); while i > from { i = i - 1; - match self.stack.pop().unwrap() { + match self.stack.pop().assert() { Ast(x) => combined = mk(x, combined), _ => {}, } @@ -960,7 +960,7 @@ fn combine_ranges(unordered: Vec<(char, char)>) -> Vec<(char, char)> { // This is currently O(n^2), but I think with sufficient cleverness, // it can be reduced to O(n) **if necessary**. let mut ordered: Vec<(char, char)> = Vec::with_capacity(unordered.len()); - for (us, ue) in unordered.move_iter() { + for (us, ue) in unordered.iter_owned() { let (mut us, mut ue) = (us, ue); assert!(us <= ue); let mut which: Option = None; diff --git a/src/libregex/re.rs b/src/libregex/re.rs index 8e4145b2a3198..b98f85572157e 100644 --- a/src/libregex/re.rs +++ b/src/libregex/re.rs @@ -207,7 +207,7 @@ impl Regex { pub fn find(&self, text: &str) -> Option<(uint, uint)> { let caps = exec(self, Location, text); if has_match(&caps) { - Some((caps[0].unwrap(), caps[1].unwrap())) + Some((caps[0].assert(), caps[1].assert())) } else { None } @@ -267,7 +267,7 @@ impl Regex { /// # fn main() { /// let re = regex!(r"'([^']+)'\s+\((\d{4})\)"); /// let text = "Not my favorite movie: 'Citizen Kane' (1941)."; - /// let caps = re.captures(text).unwrap(); + /// let caps = re.captures(text).assert(); /// assert_eq!(caps.at(1), "Citizen Kane"); /// assert_eq!(caps.at(2), "1941"); /// assert_eq!(caps.at(0), "'Citizen Kane' (1941)"); @@ -285,7 +285,7 @@ impl Regex { /// # fn main() { /// let re = regex!(r"'(?P[^']+)'\s+\((?P<year>\d{4})\)"); /// let text = "Not my favorite movie: 'Citizen Kane' (1941)."; - /// let caps = re.captures(text).unwrap(); + /// let caps = re.captures(text).assert(); /// assert_eq!(caps.name("title"), "Citizen Kane"); /// assert_eq!(caps.name("year"), "1941"); /// assert_eq!(caps.at(0), "'Citizen Kane' (1941)"); @@ -499,7 +499,7 @@ impl Regex { break } - let (s, e) = cap.pos(0).unwrap(); // captures only reports matches + let (s, e) = cap.pos(0).assert(); // captures only reports matches new.push_str(text.slice(last_match, s)); new.push_str(rep.reg_replace(&cap).as_slice()); last_match = e; @@ -703,7 +703,7 @@ impl<'t> Captures<'t> { // VM guarantees that each pair of locations are both Some or None. return None } - Some((self.locs[s].unwrap(), self.locs[e].unwrap())) + Some((self.locs[s].assert(), self.locs[e].assert())) } /// Returns the matched string for the capture group `i`. @@ -761,7 +761,7 @@ impl<'t> Captures<'t> { pub fn expand(&self, text: &str) -> String { // How evil can you get? // FIXME: Don't use regexes for this. It's completely unnecessary. - let re = Regex::new(r"(^|[^$]|\b)\$(\w+)").unwrap(); + let re = Regex::new(r"(^|[^$]|\b)\$(\w+)").assert(); let text = re.replace_all(text, |refs: &Captures| -> String { let (pre, name) = (refs.at(1), refs.at(2)); format!("{}{}", pre, @@ -770,7 +770,7 @@ impl<'t> Captures<'t> { Some(i) => self.at(i).to_string(), }) }); - let re = Regex::new(r"\$\$").unwrap(); + let re = Regex::new(r"\$\$").assert(); re.replace_all(text.as_slice(), NoExpand("$")) } } @@ -851,7 +851,7 @@ impl<'r, 't> Iterator<Captures<'t>> for FindCaptures<'r, 't> { if !has_match(&caps) { return None } else { - (caps[0].unwrap(), caps[1].unwrap()) + (caps[0].assert(), caps[1].assert()) }; // Don't accept empty matches immediately following a match. @@ -893,7 +893,7 @@ impl<'r, 't> Iterator<(uint, uint)> for FindMatches<'r, 't> { if !has_match(&caps) { return None } else { - (caps[0].unwrap(), caps[1].unwrap()) + (caps[0].assert(), caps[1].assert()) }; // Don't accept empty matches immediately following a match. diff --git a/src/libregex/test/bench.rs b/src/libregex/test/bench.rs index 4bd9d1a8666c0..b29f8a79fb6ec 100644 --- a/src/libregex/test/bench.rs +++ b/src/libregex/test/bench.rs @@ -23,7 +23,7 @@ fn no_exponential(b: &mut Bencher) { let n = 100; let re = Regex::new(format!("{}{}", "a?".repeat(n), - "a".repeat(n)).as_slice()).unwrap(); + "a".repeat(n)).as_slice()).assert(); let text = "a".repeat(n); bench_assert_match(b, re, text.as_slice()); } @@ -157,12 +157,12 @@ fn gen_text(n: uint) -> String { let mut rng = task_rng(); let mut bytes = rng.gen_ascii_chars().map(|n| n as u8).take(n) .collect::<Vec<u8>>(); - for (i, b) in bytes.mut_iter().enumerate() { + for (i, b) in bytes.iter_mut().enumerate() { if i % 20 == 0 { *b = b'\n' } } - String::from_utf8(bytes).unwrap() + String::from_utf8(bytes).assert() } throughput!(easy0_32, easy0(), 32) diff --git a/src/libregex/vm.rs b/src/libregex/vm.rs index b37000df02dbe..72cc20d38bc3c 100644 --- a/src/libregex/vm.rs +++ b/src/libregex/vm.rs @@ -204,7 +204,7 @@ impl<'r, 't> Nfa<'r, 't> { return StepMatch } Submatches => { - for (slot, val) in groups.mut_iter().zip(caps.iter()) { + for (slot, val) in groups.iter_mut().zip(caps.iter()) { *slot = *val; } return StepMatch @@ -218,7 +218,7 @@ impl<'r, 't> Nfa<'r, 't> { } CharClass(ref ranges, flags) => { if self.chars.prev.is_some() { - let c = self.chars.prev.unwrap(); + let c = self.chars.prev.assert(); let negate = flags & FLAG_NEGATED > 0; let casei = flags & FLAG_NOCASE > 0; let found = ranges.as_slice(); @@ -470,7 +470,7 @@ impl Threads { *t.groups.get_mut(1) = groups[1]; } (false, Submatches) => { - for (slot, val) in t.groups.mut_iter().zip(groups.iter()) { + for (slot, val) in t.groups.iter_mut().zip(groups.iter()) { *slot = *val; } } diff --git a/src/libregex_macros/lib.rs b/src/libregex_macros/lib.rs index 8610621d30ae8..aae79e5627e0f 100644 --- a/src/libregex_macros/lib.rs +++ b/src/libregex_macros/lib.rs @@ -283,7 +283,7 @@ fn exec<'t>(which: ::regex::native::MatchKind, input: &'t str, t.groups[1] = groups[1]; } Submatches => { - for (slot, val) in t.groups.mut_iter().zip(groups.iter()) { + for (slot, val) in t.groups.iter_mut().zip(groups.iter()) { *slot = *val; } } @@ -449,7 +449,7 @@ fn exec<'t>(which: ::regex::native::MatchKind, input: &'t str, return StepMatch } Submatches => { - for (slot, val) in groups.mut_iter().zip(caps.iter()) { + for (slot, val) in groups.iter_mut().zip(caps.iter()) { *slot = *val; } return StepMatch @@ -479,9 +479,9 @@ fn exec<'t>(which: ::regex::native::MatchKind, input: &'t str, let casei = flags & FLAG_NOCASE > 0; let get_char = if casei { - quote_expr!(self.cx, self.chars.prev.unwrap().to_uppercase()) + quote_expr!(self.cx, self.chars.prev.assert().to_uppercase()) } else { - quote_expr!(self.cx, self.chars.prev.unwrap()) + quote_expr!(self.cx, self.chars.prev.assert()) }; let negcond = if negate { diff --git a/src/librustc/back/link.rs b/src/librustc/back/link.rs index 7c9844dbe33fb..de75fae100020 100644 --- a/src/librustc/back/link.rs +++ b/src/librustc/back/link.rs @@ -428,7 +428,7 @@ pub mod write { sess.note(format!("{}", &cmd).as_slice()); let mut note = prog.error.clone(); note.push_all(prog.output.as_slice()); - sess.note(str::from_utf8(note.as_slice()).unwrap()); + sess.note(str::from_utf8(note.as_slice()).assert()); sess.abort_if_errors(); } }, @@ -844,7 +844,7 @@ pub fn mangle_internal_name_by_type_and_seq(ccx: &CrateContext, } pub fn mangle_internal_name_by_path_and_seq(path: PathElems, flav: &str) -> String { - mangle(path.chain(Some(gensym_name(flav)).move_iter()), None) + mangle(path.chain(Some(gensym_name(flav)).iter_owned()), None) } pub fn get_cc_prog(sess: &Session) -> String { @@ -1039,7 +1039,7 @@ fn archive_search_paths(sess: &Session) -> Vec<Path> { // FIXME: Addl lib search paths are an unordered HashSet? // Shouldn't this search be done in some order? let addl_lib_paths: HashSet<Path> = sess.opts.addl_lib_search_paths.borrow().clone(); - let mut search: Vec<Path> = addl_lib_paths.move_iter().collect(); + let mut search: Vec<Path> = addl_lib_paths.iter_owned().collect(); search.push_all(rustpath.as_slice()); return search; } @@ -1063,12 +1063,12 @@ fn link_rlib<'a>(sess: &'a Session, maybe_ar_prog: sess.opts.cg.ar.clone() }; let mut ab = ArchiveBuilder::create(config); - ab.add_file(obj_filename).unwrap(); + ab.add_file(obj_filename).assert(); for &(ref l, kind) in sess.cstore.get_used_libraries().borrow().iter() { match kind { cstore::NativeStatic => { - ab.add_native_library(l.as_slice()).unwrap(); + ab.add_native_library(l.as_slice()).assert(); } cstore::NativeFramework | cstore::NativeUnknown => {} } @@ -1125,7 +1125,7 @@ fn link_rlib<'a>(sess: &'a Session, sess.abort_if_errors(); } } - ab.add_file(&metadata).unwrap(); + ab.add_file(&metadata).assert(); remove(sess, &metadata); // For LTO purposes, the bytecode of this library is also inserted @@ -1168,7 +1168,7 @@ fn link_rlib<'a>(sess: &'a Session, } }; - ab.add_file(&bc_deflated_filename).unwrap(); + ab.add_file(&bc_deflated_filename).assert(); remove(sess, &bc_deflated_filename); if !sess.opts.cg.save_temps && !sess.opts.output_types.contains(&OutputTypeBitcode) { @@ -1226,8 +1226,8 @@ fn link_staticlib(sess: &Session, obj_filename: &Path, out_filename: &Path) { abi::OsMacos | abi::OsiOS => ab.build().extend(), _ => ab, }; - ab.add_native_library("morestack").unwrap(); - ab.add_native_library("compiler-rt").unwrap(); + ab.add_native_library("morestack").assert(); + ab.add_native_library("compiler-rt").assert(); let crates = sess.cstore.get_used_crates(cstore::RequireStatic); let mut all_native_libs = vec![]; @@ -1241,10 +1241,10 @@ fn link_staticlib(sess: &Session, obj_filename: &Path, out_filename: &Path) { continue } }; - ab.add_rlib(&p, name.as_slice(), sess.lto()).unwrap(); + ab.add_rlib(&p, name.as_slice(), sess.lto()).assert(); let native_libs = csearch::get_native_libraries(&sess.cstore, cnum); - all_native_libs.extend(native_libs.move_iter()); + all_native_libs.extend(native_libs.iter_owned()); } ab.update_symbols(); @@ -1302,7 +1302,7 @@ fn link_natively(sess: &Session, trans: &CrateTranslation, dylib: bool, sess.note(format!("{}", &cmd).as_slice()); let mut output = prog.error.clone(); output.push_all(prog.output.as_slice()); - sess.note(str::from_utf8(output.as_slice()).unwrap()); + sess.note(str::from_utf8(output.as_slice()).assert()); sess.abort_if_errors(); } }, @@ -1526,7 +1526,7 @@ fn link_args(cmd: &mut Command, if sess.opts.cg.rpath { let mut v = Vec::from_slice("-Wl,-install_name,@rpath/".as_bytes()); - v.push_all(out_filename.filename().unwrap()); + v.push_all(out_filename.filename().assert()); cmd.arg(v.as_slice()); } } else { @@ -1701,13 +1701,13 @@ fn add_upstream_rust_crates(cmd: &mut Command, sess: &Session, Some(t) => t, None => continue }; - let src = sess.cstore.get_used_crate_source(cnum).unwrap(); + let src = sess.cstore.get_used_crate_source(cnum).assert(); match kind { cstore::RequireDynamic => { - add_dynamic_crate(cmd, sess, src.dylib.unwrap()) + add_dynamic_crate(cmd, sess, src.dylib.assert()) } cstore::RequireStatic => { - add_static_crate(cmd, sess, tmpdir, src.rlib.unwrap()) + add_static_crate(cmd, sess, tmpdir, src.rlib.assert()) } } @@ -1740,12 +1740,12 @@ fn add_upstream_rust_crates(cmd: &mut Command, sess: &Session, // If we're not doing LTO, then our job is simply to just link // against the archive. if sess.lto() { - let name = cratepath.filename_str().unwrap(); + let name = cratepath.filename_str().assert(); let name = name.slice(3, name.len() - 5); // chop off lib/.rlib time(sess.time_passes(), format!("altering {}.rlib", name).as_slice(), (), |()| { - let dst = tmpdir.join(cratepath.filename().unwrap()); + let dst = tmpdir.join(cratepath.filename().assert()); match fs::copy(&cratepath, &dst) { Ok(..) => {} Err(e) => { @@ -1788,7 +1788,7 @@ fn add_upstream_rust_crates(cmd: &mut Command, sess: &Session, if !dir.is_empty() { cmd.arg("-L").arg(dir); } let mut v = Vec::from_slice("-l".as_bytes()); - v.push_all(unlib(&sess.targ_cfg, cratepath.filestem().unwrap())); + v.push_all(unlib(&sess.targ_cfg, cratepath.filestem().assert())); cmd.arg(v.as_slice()); } } @@ -1822,7 +1822,7 @@ fn add_upstream_native_libraries(cmd: &mut Command, sess: &Session) { // we're just getting an ordering of crate numbers, we're not worried about // the paths. let crates = sess.cstore.get_used_crates(cstore::RequireStatic); - for (cnum, _) in crates.move_iter() { + for (cnum, _) in crates.iter_owned() { let libs = csearch::get_native_libraries(&sess.cstore, cnum); for &(kind, ref lib) in libs.iter() { match kind { diff --git a/src/librustc/back/lto.rs b/src/librustc/back/lto.rs index 4212513f56a40..0320391f24ff4 100644 --- a/src/librustc/back/lto.rs +++ b/src/librustc/back/lto.rs @@ -45,7 +45,7 @@ pub fn run(sess: &session::Session, llmod: ModuleRef, // load the bitcode from the archive. Then merge it into the current LLVM // module that we've got. let crates = sess.cstore.get_used_crates(cstore::RequireStatic); - for (cnum, path) in crates.move_iter() { + for (cnum, path) in crates.iter_owned() { let name = sess.cstore.get_crate_data(cnum).name.clone(); let path = match path { Some(p) => p, @@ -56,7 +56,7 @@ pub fn run(sess: &session::Session, llmod: ModuleRef, }; let archive = ArchiveRO::open(&path).expect("wanted an rlib"); - let file = path.filename_str().unwrap(); + let file = path.filename_str().assert(); let file = file.slice(3, file.len() - 5); // chop off lib/.rlib debug!("reading {}", file); let bc_encoded = time(sess.time_passes(), diff --git a/src/librustc/driver/config.rs b/src/librustc/driver/config.rs index f4309d9e51b56..1e5f02d343c74 100644 --- a/src/librustc/driver/config.rs +++ b/src/librustc/driver/config.rs @@ -352,9 +352,9 @@ cgoptions!( pub fn build_codegen_options(matches: &getopts::Matches) -> CodegenOptions { let mut cg = basic_codegen_options(); - for option in matches.opt_strs("C").move_iter() { + for option in matches.opt_strs("C").iter_owned() { let mut iter = option.as_slice().splitn('=', 1); - let key = iter.next().unwrap(); + let key = iter.next().assert(); let value = iter.next(); let option_to_lookup = key.replace("-", "_"); let mut found = false; @@ -442,7 +442,7 @@ pub fn build_configuration(sess: &Session) -> ast::CrateConfig { if sess.opts.test { append_configuration(&mut user_cfg, InternedString::new("test")) } - user_cfg.move_iter().collect::<Vec<_>>().append(default_cfg.as_slice()) + user_cfg.iter_owned().collect::<Vec<_>>().append(default_cfg.as_slice()) } pub fn get_os(triple: &str) -> Option<abi::Os> { @@ -585,7 +585,7 @@ pub fn optgroups() -> Vec<getopts::OptGroup> { // Convert strings provided as --cfg [cfgspec] into a crate_cfg fn parse_cfgspecs(cfgspecs: Vec<String> ) -> ast::CrateConfig { - cfgspecs.move_iter().map(|s| { + cfgspecs.iter_owned().map(|s| { parse::parse_meta_from_source_str("cfgspec".to_string(), s.to_string(), Vec::new(), @@ -607,7 +607,7 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options { let mut describe_lints = false; for &level in [lint::Allow, lint::Warn, lint::Deny, lint::Forbid].iter() { - for lint_name in matches.opt_strs(level.as_str()).move_iter() { + for lint_name in matches.opt_strs(level.as_str()).iter_owned() { if lint_name.as_slice() == "help" { describe_lints = true; } else { diff --git a/src/librustc/driver/driver.rs b/src/librustc/driver/driver.rs index 477fc5e1c0f30..475f01d6b1c16 100644 --- a/src/librustc/driver/driver.rs +++ b/src/librustc/driver/driver.rs @@ -129,7 +129,7 @@ pub fn anon_src() -> String { pub fn source_name(input: &Input) -> String { match *input { // FIXME (#9639): This needs to handle non-utf8 paths - FileInput(ref ifile) => ifile.as_str().unwrap().to_string(), + FileInput(ref ifile) => ifile.as_str().assert().to_string(), StrInput(_) => anon_src() } } @@ -144,7 +144,7 @@ pub enum Input { impl Input { fn filestem(&self) -> String { match *self { - FileInput(ref ifile) => ifile.filestem_str().unwrap().to_string(), + FileInput(ref ifile) => ifile.filestem_str().assert().to_string(), StrInput(_) => "rust_out".to_string(), } } @@ -171,7 +171,7 @@ pub fn phase_1_parse_input(sess: &Session, cfg: ast::CrateConfig, input: &Input) let mut stdout = io::BufferedWriter::new(io::stdout()); let mut json = json::PrettyEncoder::new(&mut stdout); // unwrapping so IoError isn't ignored - krate.encode(&mut json).unwrap(); + krate.encode(&mut json).assert(); } if sess.show_span() { @@ -223,7 +223,7 @@ pub fn phase_2_configure_and_expand(sess: &Session, let mut addl_plugins = Some(addl_plugins); let Plugins { macros, registrars } = time(time_passes, "plugin loading", (), |_| - plugin::load::load_plugins(sess, &krate, addl_plugins.take_unwrap())); + plugin::load::load_plugins(sess, &krate, addl_plugins.take().assert())); let mut registry = Registry::new(&krate); @@ -246,7 +246,7 @@ pub fn phase_2_configure_and_expand(sess: &Session, { let mut ls = sess.lint_store.borrow_mut(); - for pass in lint_passes.move_iter() { + for pass in lint_passes.iter_owned() { ls.register_pass(Some(sess), true, pass); } } @@ -302,7 +302,7 @@ pub fn phase_2_configure_and_expand(sess: &Session, let mut stdout = io::BufferedWriter::new(io::stdout()); let mut json = json::PrettyEncoder::new(&mut stdout); // unwrapping so IoError isn't ignored - krate.encode(&mut json).unwrap(); + krate.encode(&mut json).assert(); } time(time_passes, "checking that all macro invocations are gone", &krate, |krate| @@ -486,7 +486,7 @@ pub fn phase_5_run_llvm_passes(sess: &Session, // Remove assembly source, unless --save-temps was specified if !sess.opts.cg.save_temps { - fs::unlink(&outputs.temp_path(link::OutputTypeAssembly)).unwrap(); + fs::unlink(&outputs.temp_path(link::OutputTypeAssembly)).assert(); } } else { time(sess.time_passes(), "LLVM passes", (), |_| @@ -835,7 +835,7 @@ impl UserIdentifiedItem { fn all_matching_node_ids<'a>(&'a self, map: &'a ast_map::Map) -> NodesMatchingUII<'a> { match *self { ItemViaNode(node_id) => - NodesMatchingDirect(Some(node_id).move_iter()), + NodesMatchingDirect(Some(node_id).iter_owned()), ItemViaPath(ref parts) => NodesMatchingSuffix(map.nodes_matching_suffix(parts.as_slice())), } @@ -1039,7 +1039,7 @@ pub fn pretty_print_input(sess: Session, } } } - }.unwrap() + }.assert() } fn print_flowgraph<W:io::Writer>(variants: Vec<borrowck_dot::Variant>, @@ -1156,7 +1156,7 @@ pub fn collect_crate_types(session: &Session, // will be found in crate attributes. let mut base = session.opts.crate_types.clone(); if base.len() == 0 { - base.extend(attr_types.move_iter()); + base.extend(attr_types.iter_owned()); if base.len() == 0 { base.push(link::default_output_for_target(session)); } @@ -1164,7 +1164,7 @@ pub fn collect_crate_types(session: &Session, base.dedup(); } - base.move_iter().filter(|crate_type| { + base.iter_owned().filter(|crate_type| { let res = !link::invalid_output_for_target(session, *crate_type); if !res { @@ -1271,7 +1271,7 @@ pub fn build_output_filenames(input: &Input, } OutputFilenames { out_directory: out_file.dir_path(), - out_filestem: out_file.filestem_str().unwrap().to_string(), + out_filestem: out_file.filestem_str().assert().to_string(), single_output_file: ofile, extra: sess.opts.cg.extra_filename.clone(), } diff --git a/src/librustc/driver/mod.rs b/src/librustc/driver/mod.rs index 05762aa3db276..1c9c6760c8f61 100644 --- a/src/librustc/driver/mod.rs +++ b/src/librustc/driver/mod.rs @@ -80,8 +80,8 @@ fn run_compiler(args: &[String]) { 1u => { let ifile = matches.free.get(0).as_slice(); if ifile == "-" { - let contents = io::stdin().read_to_end().unwrap(); - let src = String::from_utf8(contents).unwrap(); + let contents = io::stdin().read_to_end().assert(); + let src = String::from_utf8(contents).assert(); (StrInput(src), None) } else { (FileInput(Path::new(ifile)), Some(Path::new(ifile))) @@ -111,7 +111,7 @@ fn run_compiler(args: &[String]) { match input { FileInput(ref ifile) => { let mut stdout = io::stdout(); - list_metadata(&sess, &(*ifile), &mut stdout).unwrap(); + list_metadata(&sess, &(*ifile), &mut stdout).assert(); } StrInput(_) => { early_error("can not list metadata for stdin"); @@ -169,7 +169,7 @@ Available lint options: "); fn sort_lints(lints: Vec<(&'static Lint, bool)>) -> Vec<&'static Lint> { - let mut lints: Vec<_> = lints.move_iter().map(|(x, _)| x).collect(); + let mut lints: Vec<_> = lints.iter_owned().map(|(x, _)| x).collect(); lints.sort_by(|x: &&Lint, y: &&Lint| { match x.default_level.cmp(&y.default_level) { // The sort doesn't case-fold but it's doubtful we care. @@ -198,7 +198,7 @@ Available lint options: println!(" {} {:7.7s} {}", padded("----"), "-------", "-------"); let print_lints = |lints: Vec<&Lint>| { - for lint in lints.move_iter() { + for lint in lints.iter_owned() { let name = lint.name_lower().replace("_", "-"); println!(" {} {:7.7s} {}", padded(name.as_slice()), lint.default_level.as_str(), lint.desc); @@ -255,7 +255,7 @@ fn describe_codegen_flags() { /// returns None. pub fn handle_options(mut args: Vec<String>) -> Option<getopts::Matches> { // Throw away the first argument, the name of the binary - let _binary = args.shift().unwrap(); + let _binary = args.shift().assert(); if args.is_empty() { usage(); @@ -357,7 +357,7 @@ pub enum PpMode { fn parse_pretty(sess: &Session, name: &str) -> (PpMode, Option<driver::UserIdentifiedItem>) { let mut split = name.splitn('=', 1); - let first = split.next().unwrap(); + let first = split.next().assert(); let opt_second = split.next(); let first = match first { "normal" => PpmSource(PpmNormal), @@ -393,7 +393,7 @@ fn parse_crate_attrs(sess: &Session, input: &Input) -> &sess.parse_sess) } }; - result.move_iter().collect() + result.iter_owned().collect() } pub fn early_error(msg: &str) -> ! { diff --git a/src/librustc/front/config.rs b/src/librustc/front/config.rs index ab363a88db2d9..0c86117a8f2f3 100644 --- a/src/librustc/front/config.rs +++ b/src/librustc/front/config.rs @@ -70,8 +70,8 @@ fn fold_mod(cx: &mut Context, m: &ast::Mod) -> ast::Mod { let filtered_items: Vec<&Gc<ast::Item>> = m.items.iter() .filter(|a| item_in_cfg(cx, &***a)) .collect(); - let flattened_items = filtered_items.move_iter() - .flat_map(|&x| cx.fold_item(x).move_iter()) + let flattened_items = filtered_items.iter_owned() + .flat_map(|&x| cx.fold_item(x).iter_owned()) .collect(); let filtered_view_items = m.view_items.iter().filter_map(|a| { filter_view_item(cx, a).map(|x| cx.fold_view_item(x)) @@ -184,8 +184,8 @@ fn retain_stmt(cx: &mut Context, stmt: Gc<ast::Stmt>) -> bool { fn fold_block(cx: &mut Context, b: ast::P<ast::Block>) -> ast::P<ast::Block> { let resulting_stmts: Vec<&Gc<ast::Stmt>> = b.stmts.iter().filter(|&a| retain_stmt(cx, *a)).collect(); - let resulting_stmts = resulting_stmts.move_iter() - .flat_map(|stmt| cx.fold_stmt(&**stmt).move_iter()) + let resulting_stmts = resulting_stmts.iter_owned() + .flat_map(|stmt| cx.fold_stmt(&**stmt).iter_owned()) .collect(); let filtered_view_items = b.view_items.iter().filter_map(|a| { filter_view_item(cx, a).map(|x| cx.fold_view_item(x)) diff --git a/src/librustc/front/feature_gate.rs b/src/librustc/front/feature_gate.rs index 99855c7345cb4..6b40ef41cda72 100644 --- a/src/librustc/front/feature_gate.rs +++ b/src/librustc/front/feature_gate.rs @@ -254,7 +254,7 @@ impl<'a> Visitor<()> for Context<'a> { fn visit_mac(&mut self, macro: &ast::Mac, _: ()) { let ast::MacInvocTT(ref path, _, _) = macro.node; - let id = path.segments.last().unwrap().identifier; + let id = path.segments.last().assert().identifier; let quotes = ["quote_tokens", "quote_expr", "quote_ty", "quote_item", "quote_pat", "quote_stmt"]; let msg = " is not stable enough for use and are subject to change"; diff --git a/src/librustc/front/test.rs b/src/librustc/front/test.rs index 14cda7d62c35d..018ed5801a91c 100644 --- a/src/librustc/front/test.rs +++ b/src/librustc/front/test.rs @@ -164,7 +164,7 @@ impl<'a> fold::Folder for TestHarnessGenerator<'a> { } } - for i in mod_folded.items.mut_iter() { + for i in mod_folded.items.iter_mut() { *i = nomain(*i); } if !tests.is_empty() || !tested_submods.is_empty() { @@ -184,11 +184,11 @@ fn mk_reexport_mod(cx: &mut TestCtxt, tests: Vec<ast::Ident>, let mut view_items = Vec::new(); let super_ = token::str_to_ident("super"); - view_items.extend(tests.move_iter().map(|r| { + view_items.extend(tests.iter_owned().map(|r| { cx.ext_cx.view_use_simple(DUMMY_SP, ast::Public, cx.ext_cx.path(DUMMY_SP, vec![super_, r])) })); - view_items.extend(tested_submods.move_iter().map(|r| { + view_items.extend(tested_submods.iter_owned().map(|r| { let path = cx.ext_cx.path(DUMMY_SP, vec![super_, r, cx.reexport_mod_ident]); cx.ext_cx.view_use_simple_(DUMMY_SP, ast::Public, r, path) })); @@ -382,7 +382,7 @@ fn mk_test_module(cx: &TestCtxt, reexport_test_harness_main: &Option<InternedStr use std::slice::Vector; test::test_main_static(::std::os::args().as_slice(), TESTS); } - )).unwrap(); + )).assert(); let testmod = ast::Mod { inner: DUMMY_SP, @@ -430,7 +430,7 @@ fn path_node(ids: Vec<ast::Ident> ) -> ast::Path { ast::Path { span: DUMMY_SP, global: false, - segments: ids.move_iter().map(|identifier| ast::PathSegment { + segments: ids.iter_owned().map(|identifier| ast::PathSegment { identifier: identifier, lifetimes: Vec::new(), types: OwnedSlice::empty(), @@ -530,7 +530,7 @@ fn mk_test_desc_and_fn_rec(cx: &TestCtxt, test: &Test) -> Gc<ast::Expr> { let mut visible_path = vec![cx.reexport_mod_ident.clone()]; - visible_path.extend(path.move_iter()); + visible_path.extend(path.iter_owned()); let fn_expr = ecx.expr_path(ecx.path_global(span, visible_path)); diff --git a/src/librustc/lint/context.rs b/src/librustc/lint/context.rs index 59a6b08638e91..354b8ea751ab4 100644 --- a/src/librustc/lint/context.rs +++ b/src/librustc/lint/context.rs @@ -120,7 +120,7 @@ impl LintStore { self.levels.insert(id, (lint.default_level, Default)); } } - self.passes.get_mut_ref().push(pass); + self.passes.as_mut().assert().push(pass); } pub fn register_builtin(&mut self, sess: Option<&Session>) { @@ -207,8 +207,8 @@ pub struct Context<'a> { macro_rules! run_lints ( ($cx:expr, $f:ident, $($args:expr),*) => ({ // Move the vector of passes out of `$cx` so that we can // iterate over it mutably while passing `$cx` to the methods. - let mut passes = $cx.lints.passes.take_unwrap(); - for obj in passes.mut_iter() { + let mut passes = $cx.lints.passes.take().assert(); + for obj in passes.iter_mut() { obj.$f($cx, $($args),*); } $cx.lints.passes = Some(passes); @@ -289,7 +289,7 @@ pub fn raw_emit_lint(sess: &Session, lint: &'static Lint, _ => sess.bug("impossible level in raw_emit_lint"), } - for span in note.move_iter() { + for span in note.iter_owned() { sess.span_note(span, "lint level defined here"); } } @@ -360,7 +360,7 @@ impl<'a> Context<'a> { // specified closure let mut pushed = 0u; - for result in gather_attrs(attrs).move_iter() { + for result in gather_attrs(attrs).iter_owned() { let (lint_id, level, span) = match result { Err(span) => { self.tcx.sess.span_err(span, "malformed lint attribute"); @@ -399,7 +399,7 @@ impl<'a> Context<'a> { // rollback for _ in range(0, pushed) { - let (lint, lvlsrc) = self.level_stack.pop().unwrap(); + let (lint, lvlsrc) = self.level_stack.pop().assert(); self.lints.set_level(lint, lvlsrc); } } @@ -606,7 +606,7 @@ impl<'a> IdVisitingOperation for Context<'a> { match self.tcx.sess.lints.borrow_mut().pop(&id) { None => {} Some(lints) => { - for (lint_id, span, msg) in lints.move_iter() { + for (lint_id, span, msg) in lints.iter_owned() { self.span_lint(lint_id.lint, span, msg.as_slice()) } } diff --git a/src/librustc/metadata/creader.rs b/src/librustc/metadata/creader.rs index 0445b4d4e9e1f..50d4977df6b5c 100644 --- a/src/librustc/metadata/creader.rs +++ b/src/librustc/metadata/creader.rs @@ -84,11 +84,11 @@ fn warn_if_multiple_versions(diag: &SpanHandler, cstore: &CStore) { map.find_or_insert_with(data.name(), |_| Vec::new()).push(cnum); }); - for (name, dupes) in map.move_iter() { + for (name, dupes) in map.iter_owned() { if dupes.len() == 1 { continue } diag.handler().warn( format!("using multiple versions of crate `{}`", name).as_slice()); - for dupe in dupes.move_iter() { + for dupe in dupes.iter_owned() { let data = cstore.get_crate_data(dupe); diag.span_note(data.span, "used here"); loader::note_crate_name(diag, data.name().as_slice()); @@ -297,7 +297,7 @@ fn existing_match(e: &Env, name: &str, // We're also sure to compare *paths*, not actual byte slices. The // `source` stores paths which are normalized which may be different // from the strings on the command line. - let source = e.sess.cstore.get_used_crate_source(cnum).unwrap(); + let source = e.sess.cstore.get_used_crate_source(cnum).assert(); match e.sess.opts.externs.find_equiv(&name) { Some(locs) => { let found = locs.iter().any(|l| { @@ -391,7 +391,7 @@ fn resolve_crate<'a>(e: &mut Env, } Some(cnum) => (cnum, e.sess.cstore.get_crate_data(cnum), - e.sess.cstore.get_used_crate_source(cnum).unwrap()) + e.sess.cstore.get_used_crate_source(cnum).assert()) } } @@ -429,11 +429,11 @@ impl<'a> PluginMetadataReader<'a> { } pub fn read_plugin_metadata(&mut self, krate: &ast::ViewItem) -> PluginMetadata { - let info = extract_crate_info(&self.env, krate).unwrap(); + let info = extract_crate_info(&self.env, krate).assert(); let target_triple = self.env.sess.targ_cfg.target_strs.target_triple.as_slice(); let is_cross = target_triple != driver::host_triple(); let mut should_link = info.should_link && !is_cross; - let os = config::get_os(driver::host_triple()).unwrap(); + let os = config::get_os(driver::host_triple()).assert(); let mut load_ctxt = loader::Context { sess: self.env.sess, span: krate.span, diff --git a/src/librustc/metadata/decoder.rs b/src/librustc/metadata/decoder.rs index c9807a18383e8..3fda0036a8388 100644 --- a/src/librustc/metadata/decoder.rs +++ b/src/librustc/metadata/decoder.rs @@ -62,7 +62,7 @@ fn lookup_hash<'a>(d: rbml::Doc<'a>, eq_fn: |&[u8]| -> bool, let table = reader::get_doc(index, tag_index_table); let hash_pos = table.start + (hash % 256 * 4) as uint; let pos = u64_from_be_bytes(d.data, hash_pos, 4) as uint; - let tagged_doc = reader::doc_at(d.data, pos).unwrap(); + let tagged_doc = reader::doc_at(d.data, pos).assert(); let belt = tag_index_buckets_bucket_elt; @@ -70,7 +70,7 @@ fn lookup_hash<'a>(d: rbml::Doc<'a>, eq_fn: |&[u8]| -> bool, reader::tagged_docs(tagged_doc.doc, belt, |elt| { let pos = u64_from_be_bytes(elt.data, elt.start, 4) as uint; if eq_fn(elt.data.slice(elt.start + 4, elt.end)) { - ret = Some(reader::doc_at(d.data, pos).unwrap().doc); + ret = Some(reader::doc_at(d.data, pos).assert().doc); false } else { true @@ -423,7 +423,7 @@ pub fn get_stability(cdata: Cmd, id: ast::NodeId) -> Option<attr::Stability> { let item = lookup_item(id, cdata.data()); reader::maybe_get_doc(item, tag_items_data_item_stability).map(|doc| { let mut decoder = reader::Decoder::new(doc); - Decodable::decode(&mut decoder).unwrap() + Decodable::decode(&mut decoder).assert() }) } @@ -831,7 +831,7 @@ pub fn get_item_variances(cdata: Cmd, id: ast::NodeId) -> ty::ItemVariances { let item_doc = lookup_item(id, data); let variance_doc = reader::get_doc(item_doc, tag_item_variances); let mut decoder = reader::Decoder::new(variance_doc); - Decodable::decode(&mut decoder).unwrap() + Decodable::decode(&mut decoder).assert() } pub fn get_provided_trait_methods(intr: Rc<IdentInterner>, cdata: Cmd, @@ -1045,7 +1045,7 @@ fn get_meta_items(md: rbml::Doc) -> Vec<Gc<ast::MetaItem>> { let nd = reader::get_doc(meta_item_doc, tag_meta_item_name); let n = token::intern_and_get_ident(nd.as_str_slice()); let subitems = get_meta_items(meta_item_doc); - items.push(attr::mk_list_item(n, subitems.move_iter().collect())); + items.push(attr::mk_list_item(n, subitems.iter_owned().collect())); true }); return items; @@ -1259,7 +1259,7 @@ pub fn get_native_libraries(cdata: Cmd) let kind_doc = reader::get_doc(lib_doc, tag_native_libraries_kind); let name_doc = reader::get_doc(lib_doc, tag_native_libraries_name); let kind: cstore::NativeLibaryKind = - FromPrimitive::from_u32(reader::doc_as_u32(kind_doc)).unwrap(); + FromPrimitive::from_u32(reader::doc_as_u32(kind_doc)).assert(); let name = name_doc.as_str().to_string(); result.push((kind, name)); true @@ -1269,7 +1269,7 @@ pub fn get_native_libraries(cdata: Cmd) pub fn get_plugin_registrar_fn(data: &[u8]) -> Option<ast::NodeId> { reader::maybe_get_doc(rbml::Doc::new(data), tag_plugin_registrar_fn) - .map(|doc| FromPrimitive::from_u32(reader::doc_as_u32(doc)).unwrap()) + .map(|doc| FromPrimitive::from_u32(reader::doc_as_u32(doc)).assert()) } pub fn get_exported_macros(data: &[u8]) -> Vec<String> { @@ -1293,9 +1293,9 @@ pub fn get_dylib_dependency_formats(cdata: Cmd) debug!("found dylib deps: {}", formats.as_str_slice()); for spec in formats.as_str_slice().split(',') { if spec.len() == 0 { continue } - let cnum = spec.split(':').nth(0).unwrap(); - let link = spec.split(':').nth(1).unwrap(); - let cnum = from_str(cnum).unwrap(); + let cnum = spec.split(':').nth(0).assert(); + let link = spec.split(':').nth(1).assert(); + let cnum = from_str(cnum).assert(); let cnum = match cdata.cnum_map.find(&cnum) { Some(&n) => n, None => fail!("didn't find a crate in the cnum_map") @@ -1316,7 +1316,7 @@ pub fn get_missing_lang_items(cdata: Cmd) let mut result = Vec::new(); reader::tagged_docs(items, tag_lang_items_missing, |missing_doc| { let item: lang_items::LangItem = - FromPrimitive::from_u32(reader::doc_as_u32(missing_doc)).unwrap(); + FromPrimitive::from_u32(reader::doc_as_u32(missing_doc)).assert(); result.push(item); true }); diff --git a/src/librustc/metadata/encoder.rs b/src/librustc/metadata/encoder.rs index 9b31d3a1b6460..5c1cb4a258e83 100644 --- a/src/librustc/metadata/encoder.rs +++ b/src/librustc/metadata/encoder.rs @@ -325,7 +325,7 @@ fn encode_enum_variant_info(ecx: &EncodeContext, let def_id = local_def(variant.node.id); index.push(entry { val: variant.node.id as i64, - pos: rbml_w.writer.tell().unwrap(), + pos: rbml_w.writer.tell().assert(), }); rbml_w.start_tag(tag_items_data_item); encode_def_id(rbml_w, def_id); @@ -695,10 +695,10 @@ fn encode_info_for_struct(ecx: &EncodeContext, let nm = field.name; let id = field.id.node; - index.push(entry {val: id as i64, pos: rbml_w.writer.tell().unwrap()}); + index.push(entry {val: id as i64, pos: rbml_w.writer.tell().assert()}); global_index.push(entry { val: id as i64, - pos: rbml_w.writer.tell().unwrap(), + pos: rbml_w.writer.tell().assert(), }); rbml_w.start_tag(tag_items_data_item); debug!("encode_info_for_struct: doing {} {}", @@ -724,7 +724,7 @@ fn encode_info_for_struct_ctor(ecx: &EncodeContext, struct_id: NodeId) { index.push(entry { val: ctor_id as i64, - pos: rbml_w.writer.tell().unwrap(), + pos: rbml_w.writer.tell().assert(), }); rbml_w.start_tag(tag_items_data_item); @@ -796,7 +796,7 @@ fn encode_info_for_method(ecx: &EncodeContext, encode_bounds_and_type(rbml_w, ecx, &pty); let elem = ast_map::PathName(m.ident.name); - encode_path(rbml_w, impl_path.chain(Some(elem).move_iter())); + encode_path(rbml_w, impl_path.chain(Some(elem).iter_owned())); match ast_method_opt { Some(ast_method) => { encode_attributes(rbml_w, ast_method.attrs.as_slice()) @@ -902,7 +902,7 @@ fn encode_extension_implementations(ecx: &EncodeContext, fn encode_stability(rbml_w: &mut Encoder, stab_opt: Option<attr::Stability>) { stab_opt.map(|stab| { rbml_w.start_tag(tag_items_data_item_stability); - stab.encode(rbml_w).unwrap(); + stab.encode(rbml_w).assert(); rbml_w.end_tag(); }); } @@ -919,7 +919,7 @@ fn encode_info_for_item(ecx: &EncodeContext, index: &mut Vec<entry<i64>>) { index.push(entry { val: item.id as i64, - pos: rbml_w.writer.tell().unwrap(), + pos: rbml_w.writer.tell().assert(), }); } @@ -1110,7 +1110,7 @@ fn encode_info_for_item(ecx: &EncodeContext, match ty.node { ast::TyPath(ref path, ref bounds, _) if path.segments .len() == 1 => { - let ident = path.segments.last().unwrap().identifier; + let ident = path.segments.last().assert().identifier; assert!(bounds.is_none()); encode_impl_type_basename(rbml_w, ident); } @@ -1145,7 +1145,7 @@ fn encode_info_for_item(ecx: &EncodeContext, index.push(entry { val: method_def_id.node as i64, - pos: rbml_w.writer.tell().unwrap(), + pos: rbml_w.writer.tell().assert(), }); encode_info_for_method(ecx, rbml_w, @@ -1204,7 +1204,7 @@ fn encode_info_for_item(ecx: &EncodeContext, index.push(entry { val: method_def_id.node as i64, - pos: rbml_w.writer.tell().unwrap(), + pos: rbml_w.writer.tell().assert(), }); rbml_w.start_tag(tag_items_data_item); @@ -1216,7 +1216,7 @@ fn encode_info_for_item(ecx: &EncodeContext, encode_stability(rbml_w, stab); let elem = ast_map::PathName(method_ty.ident.name); - encode_path(rbml_w, path.clone().chain(Some(elem).move_iter())); + encode_path(rbml_w, path.clone().chain(Some(elem).iter_owned())); match method_ty.explicit_self { ty::StaticExplicitSelfCategory => { @@ -1278,7 +1278,7 @@ fn encode_info_for_foreign_item(ecx: &EncodeContext, abi: abi::Abi) { index.push(entry { val: nitem.id as i64, - pos: rbml_w.writer.tell().unwrap(), + pos: rbml_w.writer.tell().assert(), }); rbml_w.start_tag(tag_items_data_item); @@ -1380,7 +1380,7 @@ fn encode_info_for_items(ecx: &EncodeContext, rbml_w.start_tag(tag_items_data); index.push(entry { val: CRATE_NODE_ID as i64, - pos: rbml_w.writer.tell().unwrap(), + pos: rbml_w.writer.tell().assert(), }); encode_info_for_mod(ecx, rbml_w, @@ -1409,7 +1409,7 @@ fn encode_info_for_items(ecx: &EncodeContext, fn encode_index<T: Hash>(rbml_w: &mut Encoder, index: Vec<entry<T>>, write_fn: |&mut SeekableMemWriter, &T|) { let mut buckets: Vec<Vec<entry<T>>> = Vec::from_fn(256, |_| Vec::new()); - for elt in index.move_iter() { + for elt in index.iter_owned() { let h = hash::hash(&elt.val) as uint; buckets.get_mut(h % 256).push(elt); } @@ -1418,7 +1418,7 @@ fn encode_index<T: Hash>(rbml_w: &mut Encoder, index: Vec<entry<T>>, let mut bucket_locs = Vec::new(); rbml_w.start_tag(tag_index_buckets); for bucket in buckets.iter() { - bucket_locs.push(rbml_w.writer.tell().unwrap()); + bucket_locs.push(rbml_w.writer.tell().assert()); rbml_w.start_tag(tag_index_buckets_bucket); for elt in bucket.iter() { rbml_w.start_tag(tag_index_buckets_bucket_elt); @@ -1822,7 +1822,7 @@ pub static metadata_encoding_version : &'static [u8] = &[b'r', b'u', b's', b't', pub fn encode_metadata(parms: EncodeParams, krate: &Crate) -> Vec<u8> { let mut wr = SeekableMemWriter::new(); encode_metadata_inner(&mut wr, parms, krate); - wr.unwrap().move_iter().collect() + wr.unwrap().iter_owned().collect() } fn encode_metadata_inner(wr: &mut SeekableMemWriter, parms: EncodeParams, krate: &Crate) { @@ -1893,64 +1893,64 @@ fn encode_metadata_inner(wr: &mut SeekableMemWriter, parms: EncodeParams, krate: encode_hash(&mut rbml_w, &ecx.link_meta.crate_hash); encode_dylib_dependency_formats(&mut rbml_w, &ecx); - let mut i = rbml_w.writer.tell().unwrap(); + let mut i = rbml_w.writer.tell().assert(); encode_attributes(&mut rbml_w, krate.attrs.as_slice()); - stats.attr_bytes = rbml_w.writer.tell().unwrap() - i; + stats.attr_bytes = rbml_w.writer.tell().assert() - i; - i = rbml_w.writer.tell().unwrap(); + i = rbml_w.writer.tell().assert(); encode_crate_deps(&mut rbml_w, ecx.cstore); - stats.dep_bytes = rbml_w.writer.tell().unwrap() - i; + stats.dep_bytes = rbml_w.writer.tell().assert() - i; // Encode the language items. - i = rbml_w.writer.tell().unwrap(); + i = rbml_w.writer.tell().assert(); encode_lang_items(&ecx, &mut rbml_w); - stats.lang_item_bytes = rbml_w.writer.tell().unwrap() - i; + stats.lang_item_bytes = rbml_w.writer.tell().assert() - i; // Encode the native libraries used - i = rbml_w.writer.tell().unwrap(); + i = rbml_w.writer.tell().assert(); encode_native_libraries(&ecx, &mut rbml_w); - stats.native_lib_bytes = rbml_w.writer.tell().unwrap() - i; + stats.native_lib_bytes = rbml_w.writer.tell().assert() - i; // Encode the plugin registrar function - i = rbml_w.writer.tell().unwrap(); + i = rbml_w.writer.tell().assert(); encode_plugin_registrar_fn(&ecx, &mut rbml_w); - stats.plugin_registrar_fn_bytes = rbml_w.writer.tell().unwrap() - i; + stats.plugin_registrar_fn_bytes = rbml_w.writer.tell().assert() - i; // Encode macro definitions - i = rbml_w.writer.tell().unwrap(); + i = rbml_w.writer.tell().assert(); encode_macro_defs(&ecx, krate, &mut rbml_w); - stats.macro_defs_bytes = rbml_w.writer.tell().unwrap() - i; + stats.macro_defs_bytes = rbml_w.writer.tell().assert() - i; // Encode the types of all unboxed closures in this crate. - i = rbml_w.writer.tell().unwrap(); + i = rbml_w.writer.tell().assert(); encode_unboxed_closures(&ecx, &mut rbml_w); - stats.unboxed_closure_bytes = rbml_w.writer.tell().unwrap() - i; + stats.unboxed_closure_bytes = rbml_w.writer.tell().assert() - i; // Encode the def IDs of impls, for coherence checking. - i = rbml_w.writer.tell().unwrap(); + i = rbml_w.writer.tell().assert(); encode_impls(&ecx, krate, &mut rbml_w); - stats.impl_bytes = rbml_w.writer.tell().unwrap() - i; + stats.impl_bytes = rbml_w.writer.tell().assert() - i; // Encode miscellaneous info. - i = rbml_w.writer.tell().unwrap(); + i = rbml_w.writer.tell().assert(); encode_misc_info(&ecx, krate, &mut rbml_w); encode_reachable_extern_fns(&ecx, &mut rbml_w); - stats.misc_bytes = rbml_w.writer.tell().unwrap() - i; + stats.misc_bytes = rbml_w.writer.tell().assert() - i; // Encode and index the items. rbml_w.start_tag(tag_items); - i = rbml_w.writer.tell().unwrap(); + i = rbml_w.writer.tell().assert(); let items_index = encode_info_for_items(&ecx, &mut rbml_w, krate); - stats.item_bytes = rbml_w.writer.tell().unwrap() - i; + stats.item_bytes = rbml_w.writer.tell().assert() - i; - i = rbml_w.writer.tell().unwrap(); + i = rbml_w.writer.tell().assert(); encode_index(&mut rbml_w, items_index, write_i64); - stats.index_bytes = rbml_w.writer.tell().unwrap() - i; + stats.index_bytes = rbml_w.writer.tell().assert() - i; rbml_w.end_tag(); encode_struct_field_attrs(&mut rbml_w, krate); - stats.total_bytes = rbml_w.writer.tell().unwrap(); + stats.total_bytes = rbml_w.writer.tell().assert(); if tcx.sess.meta_stats() { for e in rbml_w.writer.get_ref().iter() { @@ -1985,5 +1985,5 @@ pub fn encoded_ty(tcx: &ty::ctxt, t: ty::t) -> String { tcx: tcx, abbrevs: &RefCell::new(HashMap::new()) }, t); - String::from_utf8(wr.unwrap()).unwrap() + String::from_utf8(wr.unwrap()).assert() } diff --git a/src/librustc/metadata/filesearch.rs b/src/librustc/metadata/filesearch.rs index 99b98b690fa66..e3f6a691e81d0 100644 --- a/src/librustc/metadata/filesearch.rs +++ b/src/librustc/metadata/filesearch.rs @@ -214,7 +214,7 @@ pub fn rust_path() -> Vec<Path> { env_rust_path.push(cwd.clone()); } loop { - if { let f = cwd.filename(); f.is_none() || f.unwrap() == b".." } { + if { let f = cwd.filename(); f.is_none() || f.assert() == b".." } { break } cwd.set_filename(".rust"); diff --git a/src/librustc/metadata/loader.rs b/src/librustc/metadata/loader.rs index d2e1fca0da75d..7f3bf055f4bcb 100644 --- a/src/librustc/metadata/loader.rs +++ b/src/librustc/metadata/loader.rs @@ -416,11 +416,11 @@ impl<'a> Context<'a> { (file.slice(rlib_prefix.len(), file.len() - ".rlib".len()), true) } else if dypair.map_or(false, |(_, suffix)| { - file.starts_with(dylib_prefix.get_ref().as_slice()) && + file.starts_with(dylib_prefix.as_ref().assert().as_slice()) && file.ends_with(suffix) }) { - let (_, suffix) = dypair.unwrap(); - let dylib_prefix = dylib_prefix.get_ref().as_slice(); + let (_, suffix) = dypair.assert(); + let dylib_prefix = dylib_prefix.as_ref().assert().as_slice(); (file.slice(dylib_prefix.len(), file.len() - suffix.len()), false) } else { @@ -432,9 +432,9 @@ impl<'a> Context<'a> { }); let (ref mut rlibs, ref mut dylibs) = *slot; if rlib { - rlibs.insert(fs::realpath(path).unwrap()); + rlibs.insert(fs::realpath(path).assert()); } else { - dylibs.insert(fs::realpath(path).unwrap()); + dylibs.insert(fs::realpath(path).assert()); } FileMatches }); @@ -448,7 +448,7 @@ impl<'a> Context<'a> { // libraries corresponds to the crate id and hash criteria that this // search is being performed for. let mut libraries = Vec::new(); - for (_hash, (rlibs, dylibs)) in candidates.move_iter() { + for (_hash, (rlibs, dylibs)) in candidates.iter_owned() { let mut metadata = None; let rlib = self.extract_one(rlibs, "rlib", &mut metadata); let dylib = self.extract_one(dylibs, "dylib", &mut metadata); @@ -469,7 +469,7 @@ impl<'a> Context<'a> { // libraries or not. match libraries.len() { 0 => None, - 1 => Some(libraries.move_iter().next().unwrap()), + 1 => Some(libraries.iter_owned().next().assert()), _ => { self.sess.span_err(self.span, format!("multiple matching crates for `{}`", @@ -520,11 +520,11 @@ impl<'a> Context<'a> { if m.len() == 0 { return None } else if m.len() == 1 { - return Some(m.move_iter().next().unwrap()) + return Some(m.iter_owned().next().assert()) } } - for lib in m.move_iter() { + for lib in m.iter_owned() { info!("{} reading metadata from: {}", flavor, lib.display()); let metadata = match get_metadata_section(self.os, &lib) { Ok(blob) => { @@ -548,7 +548,7 @@ impl<'a> Context<'a> { self.crate_name).as_slice()); self.sess.span_note(self.span, format!(r"candidate #1: {}", - ret.get_ref() + ret.as_ref().assert() .display()).as_slice()); error = 1; ret = None; @@ -642,7 +642,7 @@ impl<'a> Context<'a> { loc.display()).as_slice()); return false; } - let file = loc.filename_str().unwrap(); + let file = loc.filename_str().assert(); if file.starts_with("lib") && file.ends_with(".rlib") { return true } else { @@ -665,7 +665,7 @@ impl<'a> Context<'a> { let mut rlibs = HashSet::new(); let mut dylibs = HashSet::new(); for loc in locs { - if loc.filename_str().unwrap().ends_with(".rlib") { + if loc.filename_str().assert().ends_with(".rlib") { rlibs.insert(loc.clone()); } else { dylibs.insert(loc.clone()); @@ -737,7 +737,7 @@ fn get_metadata_section_imp(os: abi::Os, filename: &Path) -> Result<MetadataBlob if !filename.exists() { return Err(format!("no such file: '{}'", filename.display())); } - if filename.filename_str().unwrap().ends_with(".rlib") { + if filename.filename_str().assert().ends_with(".rlib") { // Use ArchiveRO for speed here, it's backed by LLVM and uses mmap // internally to read the file. We also avoid even using a memcpy by // just keeping the archive along while the metadata is in use. diff --git a/src/librustc/metadata/tydecode.rs b/src/librustc/metadata/tydecode.rs index fed23185c5d27..2ba0a811aa463 100644 --- a/src/librustc/metadata/tydecode.rs +++ b/src/librustc/metadata/tydecode.rs @@ -101,7 +101,7 @@ pub fn parse_ident(st: &mut PState, last: char) -> ast::Ident { fn parse_ident_(st: &mut PState, is_last: |char| -> bool) -> ast::Ident { scan(st, is_last, |bytes| { - token::str_to_ident(str::from_utf8(bytes).unwrap()) + token::str_to_ident(str::from_utf8(bytes).assert()) }) } @@ -497,7 +497,7 @@ fn parse_fn_style(c: char) -> FnStyle { fn parse_abi_set(st: &mut PState) -> abi::Abi { assert_eq!(next(st), '['); scan(st, |c| c == ']', |bytes| { - let abi_str = str::from_utf8(bytes).unwrap(); + let abi_str = str::from_utf8(bytes).assert(); abi::lookup(abi_str.as_slice()).expect(abi_str) }) } diff --git a/src/librustc/metadata/tyencode.rs b/src/librustc/metadata/tyencode.rs index ba865c7ab04d0..23427f2d2345a 100644 --- a/src/librustc/metadata/tyencode.rs +++ b/src/librustc/metadata/tyencode.rs @@ -54,9 +54,9 @@ pub fn enc_ty(w: &mut SeekableMemWriter, cx: &ctxt, t: ty::t) { Some(a) => { w.write(a.s.as_bytes()); return; } None => {} } - let pos = w.tell().unwrap(); + let pos = w.tell().assert(); enc_sty(w, cx, &ty::get(t).sty); - let end = w.tell().unwrap(); + let end = w.tell().assert(); let len = end - pos; fn estimate_sz(u: u64) -> u64 { let mut n = u; diff --git a/src/librustc/middle/astencode.rs b/src/librustc/middle/astencode.rs index 33b663dea1557..0e5aca5b4013f 100644 --- a/src/librustc/middle/astencode.rs +++ b/src/librustc/middle/astencode.rs @@ -125,7 +125,7 @@ pub fn decode_inlined_item(cdata: &cstore::crate_metadata, path_as_str.as_ref().map(|x| x.as_slice()) }); let mut ast_dsr = reader::Decoder::new(ast_doc); - let from_id_range = Decodable::decode(&mut ast_dsr).unwrap(); + let from_id_range = Decodable::decode(&mut ast_dsr).assert(); let to_id_range = reserve_id_range(&dcx.tcx.sess, from_id_range); let xcx = &ExtendedDecodeContext { dcx: dcx, @@ -141,7 +141,7 @@ pub fn decode_inlined_item(cdata: &cstore::crate_metadata, }; debug!("Fn named: {}", token::get_ident(ident)); debug!("< Decoded inlined fn: {}::{}", - path_as_str.unwrap(), + path_as_str.assert(), token::get_ident(ident)); region::resolve_inlined_item(&tcx.sess, &tcx.region_maps, &ii); decode_side_tables(xcx, ast_doc); @@ -256,7 +256,7 @@ trait def_id_encoder_helpers { impl<S:serialize::Encoder<E>, E> def_id_encoder_helpers for S { fn emit_def_id(&mut self, did: ast::DefId) { - did.encode(self).ok().unwrap() + did.encode(self).ok().assert() } } @@ -268,13 +268,13 @@ trait def_id_decoder_helpers { impl<D:serialize::Decoder<E>, E> def_id_decoder_helpers for D { fn read_def_id(&mut self, xcx: &ExtendedDecodeContext) -> ast::DefId { - let did: ast::DefId = Decodable::decode(self).ok().unwrap(); + let did: ast::DefId = Decodable::decode(self).ok().assert(); did.tr(xcx) } fn read_def_id_noxcx(&mut self, cdata: &cstore::crate_metadata) -> ast::DefId { - let did: ast::DefId = Decodable::decode(self).ok().unwrap(); + let did: ast::DefId = Decodable::decode(self).ok().assert(); decoder::translate_def_id(cdata, did) } } @@ -356,7 +356,7 @@ fn simplify_ast(ii: e::InlinedItemRef) -> ast::InlinedItem { fn decode_ast(par_doc: rbml::Doc) -> ast::InlinedItem { let chi_doc = par_doc.get(c::tag_tree as uint); let mut d = reader::Decoder::new(chi_doc); - Decodable::decode(&mut d).unwrap() + Decodable::decode(&mut d).assert() } struct AstRenumberer<'a> { @@ -382,7 +382,7 @@ fn renumber_and_map_ast(xcx: &ExtendedDecodeContext, path: Vec<ast_map::PathElem> , ii: ast::InlinedItem) -> ast::InlinedItem { ast_map::map_decoded_item(map, - path.move_iter().collect(), + path.iter_owned().collect(), AstRenumberer { xcx: xcx }, |fld| { match ii { @@ -403,7 +403,7 @@ fn renumber_and_map_ast(xcx: &ExtendedDecodeContext, fn decode_def(xcx: &ExtendedDecodeContext, doc: rbml::Doc) -> def::Def { let mut dsr = reader::Decoder::new(doc); - let def: def::Def = Decodable::decode(&mut dsr).unwrap(); + let def: def::Def = Decodable::decode(&mut dsr).assert(); def.tr(xcx) } @@ -527,7 +527,7 @@ impl tr for ty::TraitStore { // Encoding and decoding of freevar information fn encode_freevar_entry(rbml_w: &mut Encoder, fv: &freevar_entry) { - (*fv).encode(rbml_w).unwrap(); + (*fv).encode(rbml_w).assert(); } trait rbml_decoder_helper { @@ -538,7 +538,7 @@ trait rbml_decoder_helper { impl<'a> rbml_decoder_helper for reader::Decoder<'a> { fn read_freevar_entry(&mut self, xcx: &ExtendedDecodeContext) -> freevar_entry { - let fv: freevar_entry = Decodable::decode(self).unwrap(); + let fv: freevar_entry = Decodable::decode(self).assert(); fv.tr(xcx) } } @@ -586,7 +586,7 @@ fn encode_method_callee(ecx: &e::EncodeContext, rbml_w.emit_struct_field("substs", 3u, |rbml_w| { Ok(rbml_w.emit_substs(ecx, &method.substs)) }) - }).unwrap(); + }).assert(); } impl<'a> read_method_callee_helper for reader::Decoder<'a> { @@ -596,21 +596,21 @@ impl<'a> read_method_callee_helper for reader::Decoder<'a> { self.read_struct("MethodCallee", 4, |this| { let adjustment = this.read_struct_field("adjustment", 0, |this| { Decodable::decode(this) - }).unwrap(); + }).assert(); Ok((adjustment, MethodCallee { origin: this.read_struct_field("origin", 1, |this| { let method_origin: MethodOrigin = - Decodable::decode(this).unwrap(); + Decodable::decode(this).assert(); Ok(method_origin.tr(xcx)) - }).unwrap(), + }).assert(), ty: this.read_struct_field("ty", 2, |this| { Ok(this.read_ty(xcx)) - }).unwrap(), + }).assert(), substs: this.read_struct_field("substs", 3, |this| { Ok(this.read_substs(xcx)) - }).unwrap() + }).assert() })) - }).unwrap() + }).assert() } } @@ -655,7 +655,7 @@ fn encode_vtable_res_with_key(ecx: &e::EncodeContext, rbml_w.emit_struct_field("vtable_res", 1u, |rbml_w| { Ok(encode_vtable_res(ecx, rbml_w, dr)) }) - }).unwrap() + }).assert() } pub fn encode_vtable_res(ecx: &e::EncodeContext, @@ -676,7 +676,7 @@ pub fn encode_vtable_param_res(ecx: &e::EncodeContext, param_tables: &typeck::vtable_param_res) { rbml_w.emit_from_vec(param_tables.as_slice(), |rbml_w, vtable_origin| { Ok(encode_vtable_origin(ecx, rbml_w, vtable_origin)) - }).unwrap() + }).assert() } @@ -724,7 +724,7 @@ pub fn encode_vtable_origin(ecx: &e::EncodeContext, }) } } - }).unwrap() + }).assert() } pub trait vtable_decoder_helpers { @@ -751,9 +751,9 @@ impl<'a> vtable_decoder_helpers for reader::Decoder<'a> { f: |&mut reader::Decoder<'a>| -> T) -> VecPerParamSpace<T> { - let types = self.read_to_vec(|this| Ok(f(this))).unwrap(); - let selfs = self.read_to_vec(|this| Ok(f(this))).unwrap(); - let fns = self.read_to_vec(|this| Ok(f(this))).unwrap(); + let types = self.read_to_vec(|this| Ok(f(this))).assert(); + let selfs = self.read_to_vec(|this| Ok(f(this))).assert(); + let fns = self.read_to_vec(|this| Ok(f(this))).assert(); VecPerParamSpace::new(types, selfs, fns) } @@ -764,11 +764,11 @@ impl<'a> vtable_decoder_helpers for reader::Decoder<'a> { self.read_struct("VtableWithKey", 2, |this| { let adjustment = this.read_struct_field("adjustment", 0, |this| { Decodable::decode(this) - }).unwrap(); + }).assert(); Ok((adjustment, this.read_struct_field("vtable_res", 1, |this| { Ok(this.read_vtable_res(tcx, cdata)) - }).unwrap())) - }).unwrap() + }).assert())) + }).assert() } fn read_vtable_res(&mut self, @@ -784,7 +784,7 @@ impl<'a> vtable_decoder_helpers for reader::Decoder<'a> { tcx: &ty::ctxt, cdata: &cstore::crate_metadata) -> typeck::vtable_param_res { self.read_to_vec(|this| Ok(this.read_vtable_origin(tcx, cdata))) - .unwrap().move_iter().collect() + .assert().iter_owned().collect() } fn read_vtable_origin(&mut self, @@ -801,30 +801,30 @@ impl<'a> vtable_decoder_helpers for reader::Decoder<'a> { typeck::vtable_static( this.read_enum_variant_arg(0u, |this| { Ok(this.read_def_id_noxcx(cdata)) - }).unwrap(), + }).assert(), this.read_enum_variant_arg(1u, |this| { Ok(this.read_substs_noxcx(tcx, cdata)) - }).unwrap(), + }).assert(), this.read_enum_variant_arg(2u, |this| { Ok(this.read_vtable_res(tcx, cdata)) - }).unwrap() + }).assert() ) } 1 => { typeck::vtable_param( this.read_enum_variant_arg(0u, |this| { Decodable::decode(this) - }).unwrap(), + }).assert(), this.read_enum_variant_arg(1u, |this| { this.read_uint() - }).unwrap() + }).assert() ) } 2 => { typeck::vtable_unboxed_closure( this.read_enum_variant_arg(0u, |this| { Ok(this.read_def_id_noxcx(cdata)) - }).unwrap() + }).assert() ) } 3 => { @@ -833,7 +833,7 @@ impl<'a> vtable_decoder_helpers for reader::Decoder<'a> { _ => fail!("bad enum variant") }) }) - }).unwrap() + }).assert() } } @@ -845,7 +845,7 @@ fn encode_vec_per_param_space<T>(rbml_w: &mut Encoder, f: |&mut Encoder, &T|) { for &space in subst::ParamSpace::all().iter() { rbml_w.emit_from_vec(v.get_slice(space), - |rbml_w, n| Ok(f(rbml_w, n))).unwrap(); + |rbml_w, n| Ok(f(rbml_w, n))).assert(); } } @@ -924,7 +924,7 @@ impl<'a> rbml_writer_helpers for Encoder<'a> { this.emit_struct_field("regions", 1, |this| { Ok(encode_vec_per_param_space( this, &pty.generics.regions, - |this, def| def.encode(this).unwrap())) + |this, def| def.encode(this).assert())) }) }) }); @@ -1041,7 +1041,7 @@ fn encode_side_tables_for_id(ecx: &e::EncodeContext, for def in tcx.def_map.borrow().find(&id).iter() { rbml_w.tag(c::tag_table_def, |rbml_w| { rbml_w.id(id); - rbml_w.tag(c::tag_table_val, |rbml_w| (*def).encode(rbml_w).unwrap()); + rbml_w.tag(c::tag_table_val, |rbml_w| (*def).encode(rbml_w).assert()); }) } @@ -1255,15 +1255,15 @@ impl<'a> rbml_decoder_decoder_helpers for reader::Decoder<'a> { doc.start, tcx, |_, id| decoder::translate_def_id(cdata, id))) - }).unwrap() + }).assert() } fn read_tys_noxcx(&mut self, tcx: &ty::ctxt, cdata: &cstore::crate_metadata) -> Vec<ty::t> { self.read_to_vec(|this| Ok(this.read_ty_noxcx(tcx, cdata)) ) - .unwrap() - .move_iter() + .assert() + .iter_owned() .collect() } @@ -1279,7 +1279,7 @@ impl<'a> rbml_decoder_decoder_helpers for reader::Decoder<'a> { doc.start, tcx, |_, id| decoder::translate_def_id(cdata, id))) - }).unwrap() + }).assert() } fn read_ty(&mut self, xcx: &ExtendedDecodeContext) -> ty::t { @@ -1299,7 +1299,7 @@ impl<'a> rbml_decoder_decoder_helpers for reader::Decoder<'a> { |s, a| this.convert_def_id(xcx, s, a)); Ok(ty) - }).unwrap(); + }).assert(); fn type_string(doc: rbml::Doc) -> String { let mut str = String::new(); @@ -1311,7 +1311,7 @@ impl<'a> rbml_decoder_decoder_helpers for reader::Decoder<'a> { } fn read_tys(&mut self, xcx: &ExtendedDecodeContext) -> Vec<ty::t> { - self.read_to_vec(|this| Ok(this.read_ty(xcx))).unwrap().move_iter().collect() + self.read_to_vec(|this| Ok(this.read_ty(xcx))).assert().iter_owned().collect() } fn read_type_param_def(&mut self, xcx: &ExtendedDecodeContext) @@ -1323,7 +1323,7 @@ impl<'a> rbml_decoder_decoder_helpers for reader::Decoder<'a> { xcx.dcx.cdata.cnum, xcx.dcx.tcx, |s, a| this.convert_def_id(xcx, s, a))) - }).unwrap() + }).assert() } fn read_polytype(&mut self, xcx: &ExtendedDecodeContext) @@ -1337,21 +1337,21 @@ impl<'a> rbml_decoder_decoder_helpers for reader::Decoder<'a> { this.read_struct_field("types", 0, |this| { Ok(this.read_vec_per_param_space( |this| this.read_type_param_def(xcx))) - }).unwrap(), + }).assert(), regions: this.read_struct_field("regions", 1, |this| { Ok(this.read_vec_per_param_space( - |this| Decodable::decode(this).unwrap())) - }).unwrap() + |this| Decodable::decode(this).assert())) + }).assert() }) }) - }).unwrap(), + }).assert(), ty: this.read_struct_field("ty", 1, |this| { Ok(this.read_ty(xcx)) - }).unwrap() + }).assert() }) - }).unwrap() + }).assert() } fn read_substs(&mut self, xcx: &ExtendedDecodeContext) -> subst::Substs { @@ -1361,7 +1361,7 @@ impl<'a> rbml_decoder_decoder_helpers for reader::Decoder<'a> { doc.start, xcx.dcx.tcx, |s, a| this.convert_def_id(xcx, s, a))) - }).unwrap() + }).assert() } fn read_auto_adjustment(&mut self, xcx: &ExtendedDecodeContext) -> ty::AutoAdjustment { @@ -1371,32 +1371,32 @@ impl<'a> rbml_decoder_decoder_helpers for reader::Decoder<'a> { Ok(match i { 0 => { let store: ty::TraitStore = - this.read_enum_variant_arg(0, |this| Decodable::decode(this)).unwrap(); + this.read_enum_variant_arg(0, |this| Decodable::decode(this)).assert(); ty:: AutoAddEnv(store.tr(xcx)) } 1 => { let auto_deref_ref: ty::AutoDerefRef = - this.read_enum_variant_arg(0, |this| Decodable::decode(this)).unwrap(); + this.read_enum_variant_arg(0, |this| Decodable::decode(this)).assert(); ty::AutoDerefRef(auto_deref_ref.tr(xcx)) } 2 => { let store: ty::TraitStore = - this.read_enum_variant_arg(0, |this| Decodable::decode(this)).unwrap(); + this.read_enum_variant_arg(0, |this| Decodable::decode(this)).assert(); let b: ty::BuiltinBounds = - this.read_enum_variant_arg(1, |this| Decodable::decode(this)).unwrap(); + this.read_enum_variant_arg(1, |this| Decodable::decode(this)).assert(); let def_id: ast::DefId = - this.read_enum_variant_arg(2, |this| Decodable::decode(this)).unwrap(); + this.read_enum_variant_arg(2, |this| Decodable::decode(this)).assert(); let substs = this.read_enum_variant_arg(3, |this| Ok(this.read_substs(xcx))) - .unwrap(); + .assert(); ty::AutoObject(store.tr(xcx), b, def_id.tr(xcx), substs) } _ => fail!("bad enum variant for ty::AutoAdjustment") }) }) - }).unwrap() + }).assert() } fn read_unboxed_closure_type(&mut self, xcx: &ExtendedDecodeContext) @@ -1408,7 +1408,7 @@ impl<'a> rbml_decoder_decoder_helpers for reader::Decoder<'a> { doc.start, xcx.dcx.tcx, |s, a| this.convert_def_id(xcx, s, a))) - }).unwrap() + }).assert() } fn convert_def_id(&mut self, @@ -1497,16 +1497,16 @@ fn decode_side_tables(xcx: &ExtendedDecodeContext, c::tag_table_freevars => { let fv_info = val_dsr.read_to_vec(|val_dsr| { Ok(val_dsr.read_freevar_entry(xcx)) - }).unwrap().move_iter().collect(); + }).assert().iter_owned().collect(); dcx.tcx.freevars.borrow_mut().insert(id, fv_info); } c::tag_table_upvar_borrow_map => { - let var_id: ast::NodeId = Decodable::decode(val_dsr).unwrap(); + let var_id: ast::NodeId = Decodable::decode(val_dsr).assert(); let upvar_id = ty::UpvarId { var_id: xcx.tr_id(var_id), closure_expr_id: id }; - let ub: ty::UpvarBorrow = Decodable::decode(val_dsr).unwrap(); + let ub: ty::UpvarBorrow = Decodable::decode(val_dsr).assert(); dcx.tcx.upvar_borrow_map.borrow_mut().insert(upvar_id, ub.tr(xcx)); } c::tag_table_tcache => { @@ -1577,7 +1577,7 @@ fn encode_item_ast(rbml_w: &mut Encoder, item: Gc<ast::Item>) { fn decode_item_ast(par_doc: rbml::Doc) -> Gc<ast::Item> { let chi_doc = par_doc.get(c::tag_tree as uint); let mut d = reader::Decoder::new(chi_doc); - box(GC) Decodable::decode(&mut d).unwrap() + box(GC) Decodable::decode(&mut d).assert() } #[cfg(test)] @@ -1613,13 +1613,13 @@ fn mk_ctxt() -> parse::ParseSess { #[cfg(test)] fn roundtrip(in_item: Option<Gc<ast::Item>>) { - let in_item = in_item.unwrap(); + let in_item = in_item.assert(); let mut wr = SeekableMemWriter::new(); { let mut rbml_w = writer::Encoder::new(&mut wr); encode_item_ast(&mut rbml_w, in_item); } - let rbml_doc = rbml::Doc::new(wr.get_ref()); + let rbml_doc = rbml::Doc::new(wr.as_ref().assert()); let out_item = decode_item_ast(rbml_doc); assert!(in_item == out_item); @@ -1661,14 +1661,14 @@ fn test_simplification() { fn eq_int(a: int, b: int) -> bool { a == b } return alist {eq_fn: eq_int, data: Vec::new()}; } - ).unwrap(); + ).assert(); let item_in = e::IIItemRef(&*item); let item_out = simplify_ast(item_in); let item_exp = ast::IIItem(quote_item!(cx, fn new_int_alist<B>() -> alist<int, B> { return alist {eq_fn: eq_int, data: Vec::new()}; } - ).unwrap()); + ).assert()); match (item_out, item_exp) { (ast::IIItem(item_out), ast::IIItem(item_exp)) => { assert!(pprust::item_to_string(&*item_out) == diff --git a/src/librustc/middle/borrowck/check_loans.rs b/src/librustc/middle/borrowck/check_loans.rs index 65c7e1a6031ee..03b7e7d80177d 100644 --- a/src/librustc/middle/borrowck/check_loans.rs +++ b/src/librustc/middle/borrowck/check_loans.rs @@ -732,7 +732,7 @@ impl<'a> CheckLoanCtxt<'a> { // if they cannot already have been assigned if self.is_local_variable_or_arg(assignee_cmt.clone()) { assert!(assignee_cmt.mutbl.is_immutable()); // no "const" locals - let lp = opt_loan_path(&assignee_cmt).unwrap(); + let lp = opt_loan_path(&assignee_cmt).assert(); self.move_data.each_assignment_of(assignment_id, &lp, |assign| { self.bccx.report_reassigned_immutable_variable( assignment_span, diff --git a/src/librustc/middle/borrowck/gather_loans/move_error.rs b/src/librustc/middle/borrowck/gather_loans/move_error.rs index 10f051f004f19..fe0272e3104c8 100644 --- a/src/librustc/middle/borrowck/gather_loans/move_error.rs +++ b/src/librustc/middle/borrowck/gather_loans/move_error.rs @@ -91,11 +91,11 @@ fn group_errors_with_same_origin(errors: &Vec<MoveError>) let move_from_id = error.move_from.id; debug!("append_to_grouped_errors(move_from_id={})", move_from_id); let move_to = if error.move_to.is_some() { - vec!(error.move_to.clone().unwrap()) + vec!(error.move_to.clone().assert()) } else { Vec::new() }; - for ge in grouped_errors.mut_iter() { + for ge in grouped_errors.iter_mut() { if move_from_id == ge.move_from.id && error.move_to.is_some() { debug!("appending move_to to list"); ge.move_to_places.push_all_move(move_to); diff --git a/src/librustc/middle/cfg/construct.rs b/src/librustc/middle/cfg/construct.rs index dba873a72b6b8..a376c828fd284 100644 --- a/src/librustc/middle/cfg/construct.rs +++ b/src/librustc/middle/cfg/construct.rs @@ -594,7 +594,7 @@ impl<'a> CFGBuilder<'a> { label: Option<ast::Ident>) -> LoopScope { match label { None => { - return *self.loop_scopes.last().unwrap(); + return *self.loop_scopes.last().assert(); } Some(_) => { diff --git a/src/librustc/middle/check_match.rs b/src/librustc/middle/check_match.rs index d8a88b66310d9..8f7d8c39bf357 100644 --- a/src/librustc/middle/check_match.rs +++ b/src/librustc/middle/check_match.rs @@ -66,9 +66,9 @@ impl fmt::Show for Matrix { let total_width = column_widths.iter().map(|n| *n).sum() + column_count * 3 + 1; let br = String::from_char(total_width, '+'); try!(write!(f, "{}\n", br)); - for row in pretty_printed_matrix.move_iter() { + for row in pretty_printed_matrix.iter_owned() { try!(write!(f, "+")); - for (column, pat_str) in row.move_iter().enumerate() { + for (column, pat_str) in row.iter_owned().enumerate() { try!(write!(f, " ")); f.width = Some(*column_widths.get(column)); try!(f.pad(pat_str.as_slice())); @@ -303,7 +303,7 @@ impl<'a> Folder for StaticInliner<'a> { let def = self.tcx.def_map.borrow().find_copy(&pat.id); match def { Some(DefStatic(did, _)) => { - let const_expr = lookup_const_by_id(self.tcx, did).unwrap(); + let const_expr = lookup_const_by_id(self.tcx, did).assert(); const_expr_to_pat(self.tcx, const_expr) }, _ => noop_fold_pat(pat, self) @@ -342,7 +342,7 @@ fn construct_witness(cx: &MatchCheckCtxt, ctor: &Constructor, }; if is_structure { let fields = ty::lookup_struct_fields(cx.tcx, vid); - let field_pats: Vec<FieldPat> = fields.move_iter() + let field_pats: Vec<FieldPat> = fields.iter_owned() .zip(pats.iter()) .filter(|&(_, pat)| pat.node != PatWild(PatWildSingle)) .map(|(field, pat)| FieldPat { @@ -409,10 +409,10 @@ fn construct_witness(cx: &MatchCheckCtxt, ctor: &Constructor, fn missing_constructor(cx: &MatchCheckCtxt, &Matrix(ref rows): &Matrix, left_ty: ty::t, max_slice_length: uint) -> Option<Constructor> { let used_constructors: Vec<Constructor> = rows.iter() - .flat_map(|row| pat_constructors(cx, *row.get(0), left_ty, max_slice_length).move_iter()) + .flat_map(|row| pat_constructors(cx, *row.get(0), left_ty, max_slice_length).iter_owned()) .collect(); all_constructors(cx, left_ty, max_slice_length) - .move_iter() + .iter_owned() .find(|c| !used_constructors.contains(c)) } @@ -495,7 +495,7 @@ fn is_useful(cx: &MatchCheckCtxt, if constructors.is_empty() { match missing_constructor(cx, matrix, left_ty, max_slice_length) { None => { - all_constructors(cx, left_ty, max_slice_length).move_iter().map(|c| { + all_constructors(cx, left_ty, max_slice_length).iter_owned().map(|c| { match is_useful_specialized(cx, matrix, v, c.clone(), left_ty, witness) { UsefulWithWitness(pats) => UsefulWithWitness({ let arity = constructor_arity(cx, &c, left_ty); @@ -507,7 +507,7 @@ fn is_useful(cx: &MatchCheckCtxt, }) }; let mut result = vec!(construct_witness(cx, &c, subpats, left_ty)); - result.extend(pats.move_iter().skip(arity)); + result.extend(pats.iter_owned().skip(arity)); result }), result => result @@ -529,7 +529,7 @@ fn is_useful(cx: &MatchCheckCtxt, } } } else { - constructors.move_iter().map(|c| + constructors.iter_owned().map(|c| is_useful_specialized(cx, matrix, v, c.clone(), left_ty, witness) ).find(|result| result != &NotUseful).unwrap_or(NotUseful) } @@ -892,7 +892,7 @@ fn check_legality_of_move_bindings(cx: &MatchCheckCtxt, } else if by_ref_span.is_some() { span_err!(cx.tcx.sess, p.span, E0009, "cannot bind by-move and by-ref in the same pattern"); - span_note!(cx.tcx.sess, by_ref_span.unwrap(), "by-ref binding occurs here"); + span_note!(cx.tcx.sess, by_ref_span.assert(), "by-ref binding occurs here"); } }; diff --git a/src/librustc/middle/const_eval.rs b/src/librustc/middle/const_eval.rs index 0b149f5b92e40..948737df82810 100644 --- a/src/librustc/middle/const_eval.rs +++ b/src/librustc/middle/const_eval.rs @@ -567,7 +567,7 @@ pub fn lit_to_const(lit: &Lit) -> const_val { LitInt(n, ast::UnsignedIntLit(_)) => const_uint(n), LitFloat(ref n, _) | LitFloatUnsuffixed(ref n) => { - const_float(from_str::<f64>(n.get()).unwrap() as f64) + const_float(from_str::<f64>(n.get()).assert() as f64) } LitNil => const_nil, LitBool(b) => const_bool(b) diff --git a/src/librustc/middle/dataflow.rs b/src/librustc/middle/dataflow.rs index 7c5b001354dbb..3306769efd55b 100644 --- a/src/librustc/middle/dataflow.rs +++ b/src/librustc/middle/dataflow.rs @@ -228,7 +228,7 @@ impl<'a, O:DataFlowOperator> DataFlowContext<'a, O> { let cfgidx = to_cfgidx_or_die(id, &self.nodeid_to_index); let (start, end) = self.compute_id_range(cfgidx); - let gens = self.gens.mut_slice(start, end); + let gens = self.gens.slice_mut(start, end); set_bit(gens, bit); } @@ -241,14 +241,14 @@ impl<'a, O:DataFlowOperator> DataFlowContext<'a, O> { let cfgidx = to_cfgidx_or_die(id, &self.nodeid_to_index); let (start, end) = self.compute_id_range(cfgidx); - let kills = self.kills.mut_slice(start, end); + let kills = self.kills.slice_mut(start, end); set_bit(kills, bit); } fn apply_gen_kill(&self, cfgidx: CFGIndex, bits: &mut [uint]) { //! Applies the gen and kill sets for `cfgidx` to `bits` debug!("{:s} apply_gen_kill(cfgidx={}, bits={}) [before]", - self.analysis_name, cfgidx, mut_bits_to_string(bits)); + self.analysis_name, cfgidx, bits_to_string_mut(bits)); assert!(self.bits_per_id > 0); let (start, end) = self.compute_id_range(cfgidx); @@ -258,7 +258,7 @@ impl<'a, O:DataFlowOperator> DataFlowContext<'a, O> { bitwise(bits, kills, &Subtract); debug!("{:s} apply_gen_kill(cfgidx={}, bits={}) [after]", - self.analysis_name, cfgidx, mut_bits_to_string(bits)); + self.analysis_name, cfgidx, bits_to_string_mut(bits)); } fn compute_id_range(&self, cfgidx: CFGIndex) -> (uint, uint) { @@ -414,12 +414,12 @@ impl<'a, O:DataFlowOperator> DataFlowContext<'a, O> { } if changed { - let bits = self.kills.mut_slice(start, end); + let bits = self.kills.slice_mut(start, end); debug!("{:s} add_kills_from_flow_exits flow_exit={} bits={} [before]", - self.analysis_name, flow_exit, mut_bits_to_string(bits)); + self.analysis_name, flow_exit, bits_to_string_mut(bits)); bits.copy_from(orig_kills.as_slice()); debug!("{:s} add_kills_from_flow_exits flow_exit={} bits={} [after]", - self.analysis_name, flow_exit, mut_bits_to_string(bits)); + self.analysis_name, flow_exit, bits_to_string_mut(bits)); } true }); @@ -453,7 +453,7 @@ impl<'a, O:DataFlowOperator+Clone+'static> DataFlowContext<'a, O> { debug!("Dataflow result for {:s}:", self.analysis_name); debug!("{}", { - self.pretty_print_to(box io::stderr(), blk).unwrap(); + self.pretty_print_to(box io::stderr(), blk).assert(); "" }); } @@ -497,7 +497,7 @@ impl<'a, 'b, O:DataFlowOperator> PropagationContext<'a, 'b, O> { fn reset(&mut self, bits: &mut [uint]) { let e = if self.dfcx.oper.initial_value() {uint::MAX} else {0}; - for b in bits.mut_iter() { + for b in bits.iter_mut() { *b = e; } } @@ -524,7 +524,7 @@ impl<'a, 'b, O:DataFlowOperator> PropagationContext<'a, 'b, O> { let (start, end) = self.dfcx.compute_id_range(cfgidx); let changed = { // (scoping mutable borrow of self.dfcx.on_entry) - let on_entry = self.dfcx.on_entry.mut_slice(start, end); + let on_entry = self.dfcx.on_entry.slice_mut(start, end); bitwise(on_entry, pred_bits, &self.dfcx.oper) }; if changed { @@ -536,7 +536,7 @@ impl<'a, 'b, O:DataFlowOperator> PropagationContext<'a, 'b, O> { } } -fn mut_bits_to_string(words: &mut [uint]) -> String { +fn bits_to_string_mut(words: &mut [uint]) -> String { bits_to_string(words) } @@ -565,7 +565,7 @@ fn bitwise<Op:BitwiseOperator>(out_vec: &mut [uint], op: &Op) -> bool { assert_eq!(out_vec.len(), in_vec.len()); let mut changed = false; - for (out_elt, in_elt) in out_vec.mut_iter().zip(in_vec.iter()) { + for (out_elt, in_elt) in out_vec.iter_mut().zip(in_vec.iter()) { let old_val = *out_elt; let new_val = op.join(old_val, *in_elt); *out_elt = new_val; @@ -576,7 +576,7 @@ fn bitwise<Op:BitwiseOperator>(out_vec: &mut [uint], fn set_bit(words: &mut [uint], bit: uint) -> bool { debug!("set_bit: words={} bit={}", - mut_bits_to_string(words), bit_str(bit)); + bits_to_string_mut(words), bit_str(bit)); let word = bit / uint::BITS; let bit_in_word = bit % uint::BITS; let bit_mask = 1 << bit_in_word; diff --git a/src/librustc/middle/dead.rs b/src/librustc/middle/dead.rs index 86fe6dc0ddc6c..d155c66e2c631 100644 --- a/src/librustc/middle/dead.rs +++ b/src/librustc/middle/dead.rs @@ -133,7 +133,7 @@ impl<'a> MarkSymbolVisitor<'a> { ty::ty_struct(id, _) => { let fields = ty::lookup_struct_fields(self.tcx, id); let field_id = fields.iter() - .find(|field| field.name == name.name).unwrap().id; + .find(|field| field.name == name.name).assert().id; self.live_symbols.insert(field_id.node); }, _ => () @@ -158,7 +158,7 @@ impl<'a> MarkSymbolVisitor<'a> { let fields = ty::lookup_struct_fields(self.tcx, id); for pat in pats.iter() { let field_id = fields.iter() - .find(|field| field.name == pat.ident.name).unwrap().id; + .find(|field| field.name == pat.ident.name).assert().id; self.live_symbols.insert(field_id.node); } } @@ -166,7 +166,7 @@ impl<'a> MarkSymbolVisitor<'a> { fn mark_live_symbols(&mut self) { let mut scanned = HashSet::new(); while self.worklist.len() > 0 { - let id = self.worklist.pop().unwrap(); + let id = self.worklist.pop().assert(); if scanned.contains(&id) { continue } @@ -283,7 +283,7 @@ fn has_allow_dead_code_or_lang_attr(attrs: &[ast::Attribute]) -> bool { } let dead_code = lint::builtin::DEAD_CODE.name_lower(); - for attr in lint::gather_attrs(attrs).move_iter() { + for attr in lint::gather_attrs(attrs).iter_owned() { match attr { Ok((ref name, lint::Allow, _)) if name.get() == dead_code.as_slice() => return true, @@ -509,7 +509,7 @@ impl<'a> Visitor<()> for DeadVisitor<'a> { fn visit_struct_field(&mut self, field: &ast::StructField, _: ()) { if self.should_warn_about_field(&field.node) { - self.warn_dead_code(field.node.id, field.span, field.node.ident().unwrap()); + self.warn_dead_code(field.node.id, field.span, field.node.ident().assert()); } visit::walk_struct_field(self, field, ()); diff --git a/src/librustc/middle/dependency_format.rs b/src/librustc/middle/dependency_format.rs index 38e4426e4c878..8c09fede0670b 100644 --- a/src/librustc/middle/dependency_format.rs +++ b/src/librustc/middle/dependency_format.rs @@ -115,7 +115,7 @@ fn calculate_type(sess: &session::Session, None => {} } sess.cstore.iter_crate_data(|cnum, data| { - let src = sess.cstore.get_used_crate_source(cnum).unwrap(); + let src = sess.cstore.get_used_crate_source(cnum).assert(); if src.rlib.is_some() { return } sess.err(format!("dependency `{}` not found in rlib format", data.name).as_slice()); @@ -133,7 +133,7 @@ fn calculate_type(sess: &session::Session, // dependencies, ensuring there are no conflicts. The only valid case for a // dependency to be relied upon twice is for both cases to rely on a dylib. sess.cstore.iter_crate_data(|cnum, data| { - let src = sess.cstore.get_used_crate_source(cnum).unwrap(); + let src = sess.cstore.get_used_crate_source(cnum).assert(); if src.dylib.is_some() { add_library(sess, cnum, cstore::RequireDynamic, &mut formats); debug!("adding dylib: {}", data.name); @@ -157,7 +157,7 @@ fn calculate_type(sess: &session::Session, // Run through the dependency list again, and add any missing libraries as // static libraries. sess.cstore.iter_crate_data(|cnum, data| { - let src = sess.cstore.get_used_crate_source(cnum).unwrap(); + let src = sess.cstore.get_used_crate_source(cnum).assert(); if src.dylib.is_none() && !formats.contains_key(&cnum) { assert!(src.rlib.is_some()); add_library(sess, cnum, cstore::RequireStatic, &mut formats); @@ -174,7 +174,7 @@ fn calculate_type(sess: &session::Session, // making sure that everything is available in the requested format. for (cnum, kind) in ret.iter().enumerate() { let cnum = cnum as ast::CrateNum; - let src = sess.cstore.get_used_crate_source(cnum + 1).unwrap(); + let src = sess.cstore.get_used_crate_source(cnum + 1).assert(); match *kind { None => continue, Some(cstore::RequireStatic) if src.rlib.is_some() => continue, @@ -224,7 +224,7 @@ fn add_library(sess: &session::Session, fn attempt_static(sess: &session::Session) -> Option<DependencyList> { let crates = sess.cstore.get_used_crates(cstore::RequireStatic); if crates.iter().all(|&(_, ref p)| p.is_some()) { - Some(crates.move_iter().map(|_| Some(cstore::RequireStatic)).collect()) + Some(crates.iter_owned().map(|_| Some(cstore::RequireStatic)).collect()) } else { None } diff --git a/src/librustc/middle/graph.rs b/src/librustc/middle/graph.rs index 78eeb26997d51..9e38cdcd087a1 100644 --- a/src/librustc/middle/graph.rs +++ b/src/librustc/middle/graph.rs @@ -127,7 +127,13 @@ impl<N,E> Graph<N,E> { idx } + /// Deprecated: renamed to `node_data_mut` + #[deprecated = "renamed to node_data_mut"] pub fn mut_node_data<'a>(&'a mut self, idx: NodeIndex) -> &'a mut N { + self.node_data_mut(idx) + } + + pub fn node_data_mut<'a>(&'a mut self, idx: NodeIndex) -> &'a mut N { &mut self.nodes.get_mut(idx.get()).data } @@ -174,7 +180,13 @@ impl<N,E> Graph<N,E> { return idx; } + /// Deprecated: renamed to `edge_data_mut` + #[deprecated = "renamed to edge_data_mut"] pub fn mut_edge_data<'a>(&'a mut self, idx: EdgeIndex) -> &'a mut E { + self.edge_data_mut(idx) + } + + pub fn edge_data_mut<'a>(&'a mut self, idx: EdgeIndex) -> &'a mut E { &mut self.edges.get_mut(idx.get()).data } diff --git a/src/librustc/middle/liveness.rs b/src/librustc/middle/liveness.rs index 1c31b671a947b..9c9d4fb17fadf 100644 --- a/src/librustc/middle/liveness.rs +++ b/src/librustc/middle/liveness.rs @@ -726,7 +726,7 @@ impl<'a> Liveness<'a> { if self.loop_scope.len() == 0 { self.ir.tcx.sess.span_bug(sp, "break outside loop"); } else { - *self.loop_scope.last().unwrap() + *self.loop_scope.last().assert() } } } @@ -743,7 +743,7 @@ impl<'a> Liveness<'a> { self.write_vars(wr, ln, |idx| self.users.get(idx).writer); write!(wr, " precedes {}]", self.successors.get(ln.get()).to_string()); } - str::from_utf8(wr.unwrap().as_slice()).unwrap().to_string() + str::from_utf8(wr.unwrap().as_slice()).assert().to_string() } fn init_empty(&mut self, ln: LiveNode, succ_ln: LiveNode) { @@ -1490,7 +1490,7 @@ impl<'a> Liveness<'a> { } else { let ends_with_stmt = match body.expr { None if body.stmts.len() > 0 => - match body.stmts.last().unwrap().node { + match body.stmts.last().assert().node { StmtSemi(ref e, _) => { let t_stmt = ty::expr_ty(self.ir.tcx, &**e); ty::get(t_stmt).sty == ty::get(t_ret).sty @@ -1502,7 +1502,7 @@ impl<'a> Liveness<'a> { self.ir.tcx.sess.span_err( sp, "not all control paths return a value"); if ends_with_stmt { - let last_stmt = body.stmts.last().unwrap(); + let last_stmt = body.stmts.last().assert(); let original_span = original_sp(last_stmt.span, sp); let span_semicolon = Span { lo: original_span.hi - BytePos(1), diff --git a/src/librustc/middle/pat_util.rs b/src/librustc/middle/pat_util.rs index 2d9e4ee45be95..73504fa438c9f 100644 --- a/src/librustc/middle/pat_util.rs +++ b/src/librustc/middle/pat_util.rs @@ -126,7 +126,7 @@ pub fn def_to_path(tcx: &ty::ctxt, id: DefId) -> Path { identifier: Ident::new(elem.name()), lifetimes: vec!(), types: OwnedSlice::empty() - }).move_iter().collect(), + }).iter_owned().collect(), span: DUMMY_SP, }) } diff --git a/src/librustc/middle/privacy.rs b/src/librustc/middle/privacy.rs index 62b5299f8fbc8..b5eddf82ab5d2 100644 --- a/src/librustc/middle/privacy.rs +++ b/src/librustc/middle/privacy.rs @@ -610,7 +610,7 @@ impl<'a> PrivacyVisitor<'a> { let field = match name { NamedField(ident) => { debug!("privacy - check named field {} in struct {}", ident.name, id); - fields.iter().find(|f| f.name == ident.name).unwrap() + fields.iter().find(|f| f.name == ident.name).assert() } UnnamedField(idx) => fields.get(idx) }; @@ -633,7 +633,7 @@ impl<'a> PrivacyVisitor<'a> { belong to an enum") }; format!("variant `{}` of enum `{}`", - ty::with_path(self.tcx, id, |mut p| p.last().unwrap()), + ty::with_path(self.tcx, id, |mut p| p.last().assert()), ty::item_path_str(self.tcx, enum_id)) } _ => self.tcx.sess.span_bug(span, "can't find struct for field") @@ -671,7 +671,7 @@ impl<'a> PrivacyVisitor<'a> { let ck_public = |def: ast::DefId| { let name = token::get_ident(path.segments .last() - .unwrap() + .assert() .identifier); let origdid = orig_def.def_id(); self.ensure_public(span, diff --git a/src/librustc/middle/reachable.rs b/src/librustc/middle/reachable.rs index 7ed1209bdf750..338df00ee9a5b 100644 --- a/src/librustc/middle/reachable.rs +++ b/src/librustc/middle/reachable.rs @@ -228,7 +228,7 @@ impl<'a> ReachableContext<'a> { if self.worklist.len() == 0 { break } - let search_item = self.worklist.pop().unwrap(); + let search_item = self.worklist.pop().assert(); if scanned.contains(&search_item) { continue } diff --git a/src/librustc/middle/resolve.rs b/src/librustc/middle/resolve.rs index 95c04ad6607d6..8da96a2f02045 100644 --- a/src/librustc/middle/resolve.rs +++ b/src/librustc/middle/resolve.rs @@ -1089,7 +1089,7 @@ impl<'a> Resolver<'a> { if duplicate_type != NoError { // Return an error here by looking up the namespace that // had the duplicate. - let ns = ns.unwrap(); + let ns = ns.assert(); self.resolve_error(sp, format!("duplicate definition of {} `{}`", namespace_error_to_string(duplicate_type), @@ -1275,7 +1275,7 @@ impl<'a> Resolver<'a> { // Create the module and add all methods. match ty.node { TyPath(ref path, _, _) if path.segments.len() == 1 => { - let name = path.segments.last().unwrap().identifier; + let name = path.segments.last().assert().identifier; let parent_opt = parent.module().children.borrow() .find_copy(&name.name); @@ -1476,7 +1476,7 @@ impl<'a> Resolver<'a> { match view_path.node { ViewPathSimple(binding, ref full_path, id) => { let source_ident = - full_path.segments.last().unwrap().identifier; + full_path.segments.last().assert().identifier; if token::get_ident(source_ident).get() == "mod" { self.resolve_error(view_path.span, "`mod` imports are only allowed within a { } list"); @@ -1964,7 +1964,7 @@ impl<'a> Resolver<'a> { csearch::each_top_level_item_of_crate(&self.session.cstore, root.def_id .get() - .unwrap() + .assert() .krate, |def_like, ident, visibility| { self.build_reduced_graph_for_external_crate_def(root.clone(), @@ -1994,7 +1994,7 @@ impl<'a> Resolver<'a> { SingleImport(target, _) => { debug!("(building import directive) building import \ directive: {}::{}", - self.idents_to_string(module_.imports.borrow().last().unwrap() + self.idents_to_string(module_.imports.borrow().last().assert() .module_path.as_slice()), token::get_ident(target)); @@ -2468,7 +2468,7 @@ impl<'a> Resolver<'a> { match type_result { BoundResult(ref target_module, ref name_bindings) => { debug!("(resolving single import) found type target: {:?}", - { name_bindings.type_def.borrow().clone().unwrap().type_def }); + { name_bindings.type_def.borrow().clone().assert().type_def }); import_resolution.type_target = Some(Target::new(target_module.clone(), name_bindings.clone())); import_resolution.type_id = directive.id; @@ -2498,7 +2498,7 @@ impl<'a> Resolver<'a> { // purposes it's good enough to just favor one over the other. let value_private = match import_resolution.value_target { Some(ref target) => { - let def = target.bindings.def_for_namespace(ValueNS).unwrap(); + let def = target.bindings.def_for_namespace(ValueNS).assert(); self.def_map.borrow_mut().insert(directive.id, def); let did = def.def_id(); if value_used_public {Some(lp)} else {Some(DependsOn(did))} @@ -2509,7 +2509,7 @@ impl<'a> Resolver<'a> { }; let type_private = match import_resolution.type_target { Some(ref target) => { - let def = target.bindings.def_for_namespace(TypeNS).unwrap(); + let def = target.bindings.def_for_namespace(TypeNS).assert(); self.def_map.borrow_mut().insert(directive.id, def); let did = def.def_id(); if type_used_public {Some(lp)} else {Some(DependsOn(did))} @@ -2692,7 +2692,7 @@ impl<'a> Resolver<'a> { match module.parent_link.clone() { ModuleParentLink(parent, _) => { search_parent_externals(needle, - &parent.upgrade().unwrap()) + &parent.upgrade().assert()) } _ => None } @@ -2906,7 +2906,7 @@ impl<'a> Resolver<'a> { start_index = index; last_private = LastMod(DependsOn(containing_module.def_id .get() - .unwrap())); + .assert())); } } @@ -3009,12 +3009,12 @@ impl<'a> Resolver<'a> { TraitModuleKind | ImplModuleKind | AnonymousModuleKind => { - search_module = parent_module_node.upgrade().unwrap(); + search_module = parent_module_node.upgrade().assert(); } } } BlockParentLink(ref parent_module_node, _) => { - search_module = parent_module_node.upgrade().unwrap(); + search_module = parent_module_node.upgrade().assert(); } } @@ -3100,7 +3100,7 @@ impl<'a> Resolver<'a> { NoParentLink => return None, ModuleParentLink(new_module, _) | BlockParentLink(new_module, _) => { - let new_module = new_module.upgrade().unwrap(); + let new_module = new_module.upgrade().assert(); match new_module.kind.get() { NormalModuleKind => return Some(new_module), ExternModuleKind | @@ -3272,7 +3272,7 @@ impl<'a> Resolver<'a> { let sn = self.session .codemap() .span_to_snippet(imports.get(index).span) - .unwrap(); + .assert(); if sn.as_slice().contains("::") { self.resolve_error(imports.get(index).span, "unresolved import"); @@ -4037,7 +4037,7 @@ impl<'a> Resolver<'a> { let def = DefStruct(def_id); debug!("(resolving struct) resolved `{}` to type {:?}", token::get_ident(path.segments - .last().unwrap() + .last().assert() .identifier), def); debug!("(resolving struct) writing resolution for `{}` (id {})", @@ -4317,7 +4317,7 @@ impl<'a> Resolver<'a> { // First, check to see whether the name is a primitive type. if path.segments.len() == 1 { - let id = path.segments.last().unwrap().identifier; + let id = path.segments.last().assert().identifier; match self.primitive_type_table .primitive_types @@ -4352,7 +4352,7 @@ impl<'a> Resolver<'a> { debug!("(resolving type) resolved `{}` to \ type {:?}", token::get_ident(path.segments - .last().unwrap() + .last().assert() .identifier), def); result_def = Some(def); @@ -4537,7 +4537,7 @@ impl<'a> Resolver<'a> { token::get_ident( path.segments .last() - .unwrap() + .assert() .identifier)).as_slice()); } None => { @@ -4546,7 +4546,7 @@ impl<'a> Resolver<'a> { token::get_ident( path.segments .last() - .unwrap() + .assert() .identifier)).as_slice()); } } @@ -4668,7 +4668,7 @@ impl<'a> Resolver<'a> { let unqualified_def = self.resolve_identifier(path.segments - .last().unwrap() + .last().assert() .identifier, namespace, check_ribs, @@ -4829,7 +4829,7 @@ impl<'a> Resolver<'a> { } } - let ident = path.segments.last().unwrap().identifier; + let ident = path.segments.last().assert().identifier; let def = match self.resolve_definition_of_name_in_module(containing_module.clone(), ident.name, namespace) { @@ -4909,7 +4909,7 @@ impl<'a> Resolver<'a> { } } - let name = path.segments.last().unwrap().identifier.name; + let name = path.segments.last().assert().identifier.name; match self.resolve_definition_of_name_in_module(containing_module, name, namespace) { @@ -5038,7 +5038,7 @@ impl<'a> Resolver<'a> { fn get_module(this: &mut Resolver, span: Span, ident_path: &[ast::Ident]) -> Option<Rc<Module>> { let root = this.current_module.clone(); - let last_name = ident_path.last().unwrap().name; + let last_name = ident_path.last().assert().name; if ident_path.len() == 1 { match this.primitive_type_table.primitive_types.find(&last_name) { @@ -5250,7 +5250,7 @@ impl<'a> Resolver<'a> { in a static method. Maybe a \ `self` argument is missing?"); } else { - let last_name = path.segments.last().unwrap().identifier.name; + let last_name = path.segments.last().assert().identifier.name; let mut msg = match self.find_fallback_in_self_type(last_name) { NoSuggestion => { // limit search to 5 to reduce the number @@ -5485,7 +5485,7 @@ impl<'a> Resolver<'a> { match search_module.parent_link.clone() { NoParentLink | ModuleParentLink(..) => break, BlockParentLink(parent_module, _) => { - search_module = parent_module.upgrade().unwrap(); + search_module = parent_module.upgrade().assert(); } } } @@ -5648,12 +5648,12 @@ impl<'a> Resolver<'a> { NoParentLink => {} ModuleParentLink(ref module, name) => { idents.push(name); - collect_mod(idents, &*module.upgrade().unwrap()); + collect_mod(idents, &*module.upgrade().assert()); } BlockParentLink(ref module, _) => { // danger, shouldn't be ident? idents.push(special_idents::opaque); - collect_mod(idents, &*module.upgrade().unwrap()); + collect_mod(idents, &*module.upgrade().assert()); } } } @@ -5662,7 +5662,7 @@ impl<'a> Resolver<'a> { if idents.len() == 0 { return "???".to_string(); } - self.idents_to_string(idents.move_iter().rev() + self.idents_to_string(idents.iter_owned().rev() .collect::<Vec<ast::Ident>>() .as_slice()) } diff --git a/src/librustc/middle/save/mod.rs b/src/librustc/middle/save/mod.rs index c4373a023ccb2..f0bead41a43ec 100644 --- a/src/librustc/middle/save/mod.rs +++ b/src/librustc/middle/save/mod.rs @@ -739,14 +739,14 @@ impl <'l> DxrVisitor<'l> { match provenence { def::FromTrait(def_id) => Some(ty::trait_methods(&self.analysis.ty_cx, def_id) - .iter().find(|mr| mr.ident.name == m.ident.name).unwrap().def_id), + .iter().find(|mr| mr.ident.name == m.ident.name).assert().def_id), def::FromImpl(def_id) => { let impl_methods = self.analysis.ty_cx.impl_methods.borrow(); Some(*impl_methods.get(&def_id) .iter().find(|mr| ty::method( &self.analysis.ty_cx, **mr).ident.name == m.ident.name) - .unwrap()) + .assert()) } } } else { diff --git a/src/librustc/middle/save/span_utils.rs b/src/librustc/middle/save/span_utils.rs index 57006d5e72b9b..5b3144eea5660 100644 --- a/src/librustc/middle/save/span_utils.rs +++ b/src/librustc/middle/save/span_utils.rs @@ -256,7 +256,7 @@ impl<'a> SpanUtils<'a> { }; if is_ident(&ts.tok) && bracket_count == nesting { - result.push(self.make_sub_span(span, Some(ts.sp)).unwrap()); + result.push(self.make_sub_span(span, Some(ts.sp)).assert()); } } } diff --git a/src/librustc/middle/subst.rs b/src/librustc/middle/subst.rs index 673872103af60..e0f95e891e513 100644 --- a/src/librustc/middle/subst.rs +++ b/src/librustc/middle/subst.rs @@ -18,7 +18,7 @@ use util::ppaux::Repr; use std::fmt; use std::mem; use std::raw; -use std::slice::{Items, MutItems}; +use std::slice::{Items, ItemsMut}; use std::vec::Vec; use syntax::codemap::{Span, DUMMY_SP}; @@ -32,7 +32,7 @@ trait HomogeneousTuple3<T> { fn as_slice<'a>(&'a self) -> &'a [T]; fn as_mut_slice<'a>(&'a mut self) -> &'a mut [T]; fn iter<'a>(&'a self) -> Items<'a, T>; - fn mut_iter<'a>(&'a mut self) -> MutItems<'a, T>; + fn iter_mut<'a>(&'a mut self) -> ItemsMut<'a, T>; fn get<'a>(&'a self, index: uint) -> Option<&'a T>; fn get_mut<'a>(&'a mut self, index: uint) -> Option<&'a mut T>; } @@ -63,8 +63,8 @@ impl<T> HomogeneousTuple3<T> for (T, T, T) { slice.iter() } - fn mut_iter<'a>(&'a mut self) -> MutItems<'a, T> { - self.as_mut_slice().mut_iter() + fn iter_mut<'a>(&'a mut self) -> ItemsMut<'a, T> { + self.as_mut_slice().iter_mut() } fn get<'a>(&'a self, index: uint) -> Option<&'a T> { @@ -177,7 +177,7 @@ impl Substs { } } - pub fn mut_regions<'a>(&'a mut self) -> &'a mut VecPerParamSpace<ty::Region> { + pub fn regions_mut<'a>(&'a mut self) -> &'a mut VecPerParamSpace<ty::Region> { /*! * Since ErasedRegions are only to be used in trans, most of * the compiler can use this method to easily access the set @@ -335,7 +335,7 @@ impl<T> VecPerParamSpace<T> { pub fn sort(t: Vec<T>, space: |&T| -> ParamSpace) -> VecPerParamSpace<T> { let mut result = VecPerParamSpace::empty(); - for t in t.move_iter() { + for t in t.iter_owned() { result.push(space(&t), t); } result @@ -379,7 +379,7 @@ impl<T> VecPerParamSpace<T> { pub fn replace(&mut self, space: ParamSpace, elems: Vec<T>) { // FIXME (#15435): slow; O(n^2); could enhance vec to make it O(n). self.truncate(space, 0); - for t in elems.move_iter() { + for t in elems.iter_owned() { self.push(space, t); } } @@ -405,7 +405,7 @@ impl<T> VecPerParamSpace<T> { fn get_mut_slice<'a>(&'a mut self, space: ParamSpace) -> &'a mut [T] { let (start, limit) = self.limits(space); - self.content.mut_slice(start, limit) + self.content.slice_mut(start, limit) } pub fn opt_get<'a>(&'a self, diff --git a/src/librustc/middle/trans/_match.rs b/src/librustc/middle/trans/_match.rs index 85b6294ae34e6..a6398f242975c 100644 --- a/src/librustc/middle/trans/_match.rs +++ b/src/librustc/middle/trans/_match.rs @@ -706,7 +706,7 @@ fn extract_vec_elems<'a>( } }); if slice.is_some() { - let n = slice.unwrap(); + let n = slice.assert(); let slice_byte_offset = Mul(bcx, vt.llunit_size, C_uint(bcx.ccx(), n)); let slice_begin = tvec::pointer_add_byte(bcx, base, slice_byte_offset); let slice_len_offset = C_uint(bcx.ccx(), elem_count - 1u); @@ -1439,7 +1439,7 @@ fn trans_match_inner<'a>(scope_cx: &'a Block<'a>, // to the default arm. let has_default = arms.last().map_or(false, |arm| { arm.pats.len() == 1 - && arm.pats.last().unwrap().node == ast::PatWild(ast::PatWildSingle) + && arm.pats.last().assert().node == ast::PatWild(ast::PatWildSingle) }); compile_submatch(bcx, matches.as_slice(), [discr_datum.val], &chk, has_default); @@ -1797,7 +1797,7 @@ fn bind_irrefutable_pat<'a>( ); bcx = before .iter().map(|v| Some(*v)) - .chain(Some(*slice).move_iter()) + .chain(Some(*slice).iter_owned()) .chain(after.iter().map(|v| Some(*v))) .zip(extracted.vals.iter()) .fold(bcx, |bcx, (inner, elem)| { diff --git a/src/librustc/middle/trans/adt.rs b/src/librustc/middle/trans/adt.rs index 9ec0407b5c3fc..e7b24d2640aa2 100644 --- a/src/librustc/middle/trans/adt.rs +++ b/src/librustc/middle/trans/adt.rs @@ -194,10 +194,10 @@ fn represent_type_uncached(cx: &CrateContext, t: ty::t) -> Repr { // All bodies empty -> intlike let discrs: Vec<u64> = cases.iter().map(|c| c.discr).collect(); let bounds = IntBounds { - ulo: *discrs.iter().min().unwrap(), - uhi: *discrs.iter().max().unwrap(), - slo: discrs.iter().map(|n| *n as i64).min().unwrap(), - shi: discrs.iter().map(|n| *n as i64).max().unwrap() + ulo: *discrs.iter().min().assert(), + uhi: *discrs.iter().max().assert(), + slo: discrs.iter().map(|n| *n as i64).min().assert(), + shi: discrs.iter().map(|n| *n as i64).max().assert() }; return mk_cenum(cx, hint, &bounds); } @@ -522,8 +522,8 @@ fn generic_type_of(cx: &CrateContext, r: &Repr, name: Option<&str>, sizing: bool // of the size. // // FIXME #10604: this breaks when vector types are present. - let size = sts.iter().map(|st| st.size).max().unwrap(); - let most_aligned = sts.iter().max_by(|st| st.align).unwrap(); + let size = sts.iter().map(|st| st.size).max().assert(); + let most_aligned = sts.iter().max_by(|st| st.align).assert(); let align = most_aligned.align; let discr_ty = ll_inttype(cx, ity); let discr_size = machine::llsize_of_alloc(cx, discr_ty) as u64; @@ -918,7 +918,7 @@ pub fn trans_const(ccx: &CrateContext, r: &Repr, discr: Disr, } General(ity, ref cases, _) => { let case = cases.get(discr as uint); - let max_sz = cases.iter().map(|x| x.size).max().unwrap(); + let max_sz = cases.iter().map(|x| x.size).max().assert(); let lldiscr = C_integral(ll_inttype(ccx, ity), discr as u64, true); let contents = build_const_struct(ccx, case, diff --git a/src/librustc/middle/trans/base.rs b/src/librustc/middle/trans/base.rs index 242a820c997ff..70b6f98cebf76 100644 --- a/src/librustc/middle/trans/base.rs +++ b/src/librustc/middle/trans/base.rs @@ -160,7 +160,7 @@ impl<'a> Drop for StatRecorder<'a> { let end = time::precise_time_ns(); let elapsed = ((end - self.start) / 1_000_000) as uint; let iend = self.ccx.stats.n_llvm_insns.get(); - self.ccx.stats.fn_stats.borrow_mut().push((self.name.take_unwrap(), + self.ccx.stats.fn_stats.borrow_mut().push((self.name.take().assert(), elapsed, iend - self.istart)); self.ccx.stats.n_fns.set(self.ccx.stats.n_fns.get() + 1); @@ -1192,7 +1192,7 @@ pub fn alloca_zeroed(cx: &Block, ty: Type, name: &str) -> ValueRef { } let p = alloca_no_lifetime(cx, ty, name); let b = cx.fcx.ccx.builder(); - b.position_before(cx.fcx.alloca_insert_pt.get().unwrap()); + b.position_before(cx.fcx.alloca_insert_pt.get().assert()); memzero(&b, p, ty); p } @@ -1434,7 +1434,7 @@ fn copy_args_to_allocas<'a>(fcx: &FunctionContext<'a>, let arg_scope_id = cleanup::CustomScope(arg_scope); - for (i, arg_datum) in arg_datums.move_iter().enumerate() { + for (i, arg_datum) in arg_datums.iter_owned().enumerate() { // For certain mode/type combinations, the raw llarg values are passed // by value. However, within the fn body itself, we want to always // have all locals and arguments be by-ref so that we can cancel the @@ -1465,7 +1465,7 @@ fn copy_unboxed_closure_args_to_allocas<'a>( assert_eq!(arg_datums.len(), 1); - let arg_datum = arg_datums.move_iter().next().unwrap(); + let arg_datum = arg_datums.iter_owned().next().assert(); // Untuple the rest of the arguments. let tuple_datum = @@ -1538,12 +1538,12 @@ pub fn build_return_block(fcx: &FunctionContext, ret_cx: &Block, retty: ty::t) { return RetVoid(ret_cx); } - let retptr = Value(fcx.llretptr.get().unwrap()); + let retptr = Value(fcx.llretptr.get().assert()); let retval = match retptr.get_dominating_store(ret_cx) { // If there's only a single store to the ret slot, we can directly return // the value that was stored and omit the store and the alloca Some(s) => { - let retval = s.get_operand(0).unwrap().get(); + let retval = s.get_operand(0).assert().get(); s.erase_from_parent(); if retptr.has_no_uses() { @@ -1557,7 +1557,7 @@ pub fn build_return_block(fcx: &FunctionContext, ret_cx: &Block, retty: ty::t) { } } // Otherwise, load the return value from the ret slot - None => load_ty(ret_cx, fcx.llretptr.get().unwrap(), retty) + None => load_ty(ret_cx, fcx.llretptr.get().assert(), retty) }; Ret(ret_cx, retval); @@ -1842,15 +1842,15 @@ fn trans_enum_variant_or_tuple_like_struct(ccx: &CrateContext, if !type_is_zero_size(fcx.ccx, result_ty) { let repr = adt::represent_type(ccx, result_ty); - for (i, arg_datum) in arg_datums.move_iter().enumerate() { + for (i, arg_datum) in arg_datums.iter_owned().enumerate() { let lldestptr = adt::trans_field_ptr(bcx, &*repr, - fcx.llretptr.get().unwrap(), + fcx.llretptr.get().assert(), disr, i); arg_datum.store_to(bcx, lldestptr); } - adt::trans_set_discr(bcx, &*repr, fcx.llretptr.get().unwrap(), disr); + adt::trans_set_discr(bcx, &*repr, fcx.llretptr.get().assert(), disr); } finish_fn(&fcx, bcx, result_ty); @@ -2246,7 +2246,7 @@ pub fn is_entry_fn(sess: &Session, node_id: ast::NodeId) -> bool { pub fn create_entry_wrapper(ccx: &CrateContext, _sp: Span, main_llfn: ValueRef) { - let et = ccx.sess().entry_type.get().unwrap(); + let et = ccx.sess().entry_type.get().assert(); match et { config::EntryMain => { create_entry_fn(ccx, main_llfn, true); @@ -2326,7 +2326,7 @@ fn exported_name(ccx: &CrateContext, id: ast::NodeId, _ => ccx.tcx.map.with_path(id, |mut path| { if attr::contains_name(attrs, "no_mangle") { // Don't mangle - path.last().unwrap().to_string() + path.last().assert().to_string() } else { match weak_lang_items::link_name(attrs) { Some(name) => name.get().to_string(), @@ -2731,7 +2731,7 @@ pub fn trans_crate(krate: ast::Crate, // the final product, so LTO needs to preserve them. ccx.sess().cstore.iter_crate_data(|cnum, _| { let syms = csearch::get_reachable_extern_fns(&ccx.sess().cstore, cnum); - reachable.extend(syms.move_iter().map(|did| { + reachable.extend(syms.iter_owned().map(|did| { csearch::get_symbol(&ccx.sess().cstore, did) })); }); diff --git a/src/librustc/middle/trans/basic_block.rs b/src/librustc/middle/trans/basic_block.rs index 013350717171c..1813b45600390 100644 --- a/src/librustc/middle/trans/basic_block.rs +++ b/src/librustc/middle/trans/basic_block.rs @@ -34,7 +34,7 @@ impl BasicBlock { pub fn pred_iter(self) -> Preds<'static> { self.as_value().user_iter() .filter(|user| user.is_a_terminator_inst()) - .map(|user| user.get_parent().unwrap()) + .map(|user| user.get_parent().assert()) } pub fn get_single_predecessor(self) -> Option<BasicBlock> { diff --git a/src/librustc/middle/trans/build.rs b/src/librustc/middle/trans/build.rs index d2ddf3ff69662..40e7c116e2bf7 100644 --- a/src/librustc/middle/trans/build.rs +++ b/src/librustc/middle/trans/build.rs @@ -326,7 +326,7 @@ pub fn Alloca(cx: &Block, ty: Type, name: &str) -> ValueRef { pub fn AllocaFcx(fcx: &FunctionContext, ty: Type, name: &str) -> ValueRef { let b = fcx.ccx.builder(); - b.position_before(fcx.alloca_insert_pt.get().unwrap()); + b.position_before(fcx.alloca_insert_pt.get().assert()); b.alloca(ty, name) } @@ -334,7 +334,7 @@ pub fn ArrayAlloca(cx: &Block, ty: Type, val: ValueRef) -> ValueRef { unsafe { if cx.unreachable.get() { return llvm::LLVMGetUndef(ty.ptr_to().to_ref()); } let b = cx.fcx.ccx.builder(); - b.position_before(cx.fcx.alloca_insert_pt.get().unwrap()); + b.position_before(cx.fcx.alloca_insert_pt.get().assert()); b.array_alloca(ty, val) } } diff --git a/src/librustc/middle/trans/builder.rs b/src/librustc/middle/trans/builder.rs index b3192a405be59..9e6896359c9d0 100644 --- a/src/librustc/middle/trans/builder.rs +++ b/src/librustc/middle/trans/builder.rs @@ -546,7 +546,7 @@ impl<'a> Builder<'a> { // we care about. if ixs.len() < 16 { let mut small_vec = [ C_i32(self.ccx, 0), ..16 ]; - for (small_vec_e, &ix) in small_vec.mut_iter().zip(ixs.iter()) { + for (small_vec_e, &ix) in small_vec.iter_mut().zip(ixs.iter()) { *small_vec_e = C_i32(self.ccx, ix as i32); } self.inbounds_gep(base, small_vec.slice(0, ixs.len())) diff --git a/src/librustc/middle/trans/cabi_x86_64.rs b/src/librustc/middle/trans/cabi_x86_64.rs index 493aca0ddf0c4..63c2dc43a8572 100644 --- a/src/librustc/middle/trans/cabi_x86_64.rs +++ b/src/librustc/middle/trans/cabi_x86_64.rs @@ -145,7 +145,7 @@ fn classify_ty(ty: Type) -> Vec<RegClass> { } fn all_mem(cls: &mut [RegClass]) { - for elt in cls.mut_iter() { + for elt in cls.iter_mut() { *elt = Memory; } } diff --git a/src/librustc/middle/trans/callee.rs b/src/librustc/middle/trans/callee.rs index f186af48321c3..66df3c2b86c97 100644 --- a/src/librustc/middle/trans/callee.rs +++ b/src/librustc/middle/trans/callee.rs @@ -760,7 +760,7 @@ pub fn trans_call_inner<'a>( return intrinsic::trans_intrinsic_call(bcx, node, callee_ty, arg_cleanup_scope, args, - dest.unwrap(), substs); + dest.assert(), substs); } NamedTupleConstructor(substs, disr) => { assert!(dest.is_some()); @@ -768,7 +768,7 @@ pub fn trans_call_inner<'a>( let ctor_ty = callee_ty.subst(bcx.tcx(), &substs); return base::trans_named_tuple_constructor(bcx, ctor_ty, disr, - args, dest.unwrap()); + args, dest.assert()); } }; @@ -815,7 +815,7 @@ pub fn trans_call_inner<'a>( // Push the out-pointer if we use an out-pointer for this // return type, otherwise push "undef". if type_of::return_uses_outptr(ccx, ret_ty) { - llargs.push(opt_llretslot.unwrap()); + llargs.push(opt_llretslot.assert()); } // Push the environment (or a trait object's self). @@ -878,7 +878,7 @@ pub fn trans_call_inner<'a>( abi); fcx.pop_custom_cleanup_scope(arg_cleanup_scope); bcx = foreign::trans_native_call(bcx, callee_ty, - llfn, opt_llretslot.unwrap(), + llfn, opt_llretslot.assert(), llargs.as_slice(), arg_tys); } diff --git a/src/librustc/middle/trans/cleanup.rs b/src/librustc/middle/trans/cleanup.rs index cf2410f657155..8ffa338109e8f 100644 --- a/src/librustc/middle/trans/cleanup.rs +++ b/src/librustc/middle/trans/cleanup.rs @@ -360,7 +360,7 @@ impl<'a> CleanupMethods<'a> for FunctionContext<'a> { debug!("schedule_clean_in_ast_scope(cleanup_scope={:?})", cleanup_scope); - for scope in self.scopes.borrow_mut().mut_iter().rev() { + for scope in self.scopes.borrow_mut().iter_mut().rev() { if scope.kind.is_ast_with_id(cleanup_scope) { scope.cleanups.push(cleanup); scope.clear_cached_exits(); @@ -500,11 +500,11 @@ impl<'a> CleanupHelperMethods<'a> for FunctionContext<'a> { self.top_scope(|s| s.block_name("")), self.scopes_len() - 1); - self.scopes.borrow_mut().pop().unwrap() + self.scopes.borrow_mut().pop().assert() } fn top_scope<R>(&self, f: |&CleanupScope<'a>| -> R) -> R { - f(self.scopes.borrow().last().unwrap()) + f(self.scopes.borrow().last().assert()) } fn trans_cleanups_to_exit_scope(&'a self, @@ -597,7 +597,7 @@ impl<'a> CleanupHelperMethods<'a> for FunctionContext<'a> { // and this scope is that loop, then stop popping and set // `prev_llbb` to the appropriate exit block from the loop. popped_scopes.push(self.pop_scope()); - let scope = popped_scopes.last().unwrap(); + let scope = popped_scopes.last().assert(); match label { UnwindExit | ReturnExit => { } LoopExit(id, exit) => { @@ -637,7 +637,7 @@ impl<'a> CleanupHelperMethods<'a> for FunctionContext<'a> { // At this point, `popped_scopes` is empty, and so the final block // that we return to the user is `Cleanup(AST 24)`. while !popped_scopes.is_empty() { - let mut scope = popped_scopes.pop().unwrap(); + let mut scope = popped_scopes.pop().assert(); if scope.cleanups.iter().any(|c| cleanup_is_suitable_for(*c, label)) { @@ -690,7 +690,7 @@ impl<'a> CleanupHelperMethods<'a> for FunctionContext<'a> { // Check if a landing pad block exists; if not, create one. { let mut scopes = self.scopes.borrow_mut(); - let last_scope = scopes.mut_last().unwrap(); + let last_scope = scopes.last_mut().assert(); match last_scope.cached_landing_pad { Some(llbb) => { return llbb; } None => { diff --git a/src/librustc/middle/trans/closure.rs b/src/librustc/middle/trans/closure.rs index 98b2ebb70f3cb..60c303a24c3c0 100644 --- a/src/librustc/middle/trans/closure.rs +++ b/src/librustc/middle/trans/closure.rs @@ -202,7 +202,7 @@ pub fn store_environment<'a>( // Copy expr values into boxed bindings. let mut bcx = bcx; - for (i, bv) in bound_values.move_iter().enumerate() { + for (i, bv) in bound_values.iter_owned().enumerate() { debug!("Copy {} into closure", bv.to_string(ccx)); if ccx.sess().asm_comments() { @@ -264,7 +264,7 @@ fn load_environment<'a>(bcx: &'a Block<'a>, } // Load a pointer to the closure data, skipping over the box header: - let llcdata = at_box_body(bcx, cdata_ty, bcx.fcx.llenv.unwrap()); + let llcdata = at_box_body(bcx, cdata_ty, bcx.fcx.llenv.assert()); // Store the pointer to closure data in an alloca for debug info because that's what the // llvm.dbg.declare intrinsic expects @@ -314,7 +314,7 @@ fn load_unboxed_closure_environment<'a>( return bcx } - let llenv = bcx.fcx.llenv.unwrap(); + let llenv = bcx.fcx.llenv.assert(); for (i, freevar) in freevars.iter().enumerate() { let upvar_ptr = GEPi(bcx, llenv, [0, i]); let def_id = freevar.def.def_id(); @@ -452,7 +452,7 @@ pub fn trans_unboxed_closure<'a>( let closure_id = ast_util::local_def(id); let llfn = get_or_create_declaration_if_unboxed_closure( bcx.ccx(), - closure_id).unwrap(); + closure_id).assert(); // Untuple the arguments. let unboxed_closure_types = bcx.tcx().unboxed_closure_types.borrow(); diff --git a/src/librustc/middle/trans/common.rs b/src/librustc/middle/trans/common.rs index 84f380e862a4d..9a87d0534ed86 100644 --- a/src/librustc/middle/trans/common.rs +++ b/src/librustc/middle/trans/common.rs @@ -328,7 +328,7 @@ impl<'a> FunctionContext<'a> { unsafe { llvm::LLVMInstructionEraseFromParent(self.alloca_insert_pt .get() - .unwrap()); + .assert()); } } @@ -342,7 +342,7 @@ impl<'a> FunctionContext<'a> { })) } - self.llreturn.get().unwrap() + self.llreturn.get().assert() } pub fn new_block(&'a self, @@ -624,7 +624,7 @@ pub fn C_str_slice(cx: &CrateContext, s: InternedString) -> ValueRef { let len = s.get().len(); let cs = llvm::LLVMConstPointerCast(C_cstr(cx, s, false), Type::i8p(cx).to_ref()); - C_named_struct(cx.tn.find_type("str_slice").unwrap(), [cs, C_uint(cx, len)]) + C_named_struct(cx.tn.find_type("str_slice").assert(), [cs, C_uint(cx, len)]) } } diff --git a/src/librustc/middle/trans/context.rs b/src/librustc/middle/trans/context.rs index bb528790314da..f864fde1ea44b 100644 --- a/src/librustc/middle/trans/context.rs +++ b/src/librustc/middle/trans/context.rs @@ -222,8 +222,8 @@ impl CrateContext { llvm_insns: RefCell::new(HashMap::new()), fn_stats: RefCell::new(Vec::new()), }, - int_type: Type::from_ref(ptr::mut_null()), - opaque_vec_type: Type::from_ref(ptr::mut_null()), + int_type: Type::from_ref(ptr::null_mut()), + opaque_vec_type: Type::from_ref(ptr::null_mut()), builder: BuilderRef_res(llvm::LLVMCreateBuilderInContext(llcx)), unboxed_closure_vals: RefCell::new(DefIdMap::new()), dbg_cx: dbg_cx, @@ -261,7 +261,7 @@ impl CrateContext { } pub fn tydesc_type(&self) -> Type { - self.tn.find_type("tydesc").unwrap() + self.tn.find_type("tydesc").assert() } pub fn get_intrinsic(&self, key: & &'static str) -> ValueRef { diff --git a/src/librustc/middle/trans/debuginfo.rs b/src/librustc/middle/trans/debuginfo.rs index c27b0bb8cb1eb..eebeb29963feb 100644 --- a/src/librustc/middle/trans/debuginfo.rs +++ b/src/librustc/middle/trans/debuginfo.rs @@ -828,7 +828,7 @@ pub fn create_global_var_metadata(cx: &CrateContext, type_metadata, is_local_to_unit, global, - ptr::mut_null()); + ptr::null_mut()); } }) }); @@ -1020,7 +1020,7 @@ pub fn create_argument_metadata(bcx: &Block, arg: &ast::Arg) { } }; - if unsafe { llvm::LLVMIsAAllocaInst(llarg.val) } == ptr::mut_null() { + if unsafe { llvm::LLVMIsAAllocaInst(llarg.val) } == ptr::null_mut() { cx.sess().span_bug(span, "debuginfo::create_argument_metadata() - \ Referenced variable location is not an alloca!"); } @@ -1260,7 +1260,7 @@ pub fn create_function_debug_context(cx: &CrateContext, cx.sess().opts.optimize != config::No, llfn, template_parameters, - ptr::mut_null()) + ptr::null_mut()) } }) }); @@ -1296,7 +1296,7 @@ pub fn create_function_debug_context(cx: &CrateContext, // Return type -- llvm::DIBuilder wants this at index 0 match fn_decl.output.node { ast::TyNil => { - signature.push(ptr::mut_null()); + signature.push(ptr::null_mut()); } _ => { assert_type_for_node_id(cx, fn_ast_id, error_span); @@ -1341,7 +1341,7 @@ pub fn create_function_debug_context(cx: &CrateContext, // Handle self type if has_self_type { - let actual_self_type = self_type.unwrap(); + let actual_self_type = self_type.assert(); // Add self type name to <...> clause of function name let actual_self_type_name = compute_debuginfo_type_name( cx, @@ -1370,7 +1370,7 @@ pub fn create_function_debug_context(cx: &CrateContext, file_metadata, name, actual_self_type_metadata, - ptr::mut_null(), + ptr::null_mut(), 0, 0) } @@ -1405,7 +1405,7 @@ pub fn create_function_debug_context(cx: &CrateContext, file_metadata, name, actual_type_metadata, - ptr::mut_null(), + ptr::null_mut(), 0, 0) } @@ -1598,7 +1598,7 @@ fn file_metadata(cx: &CrateContext, full_path: &str) -> DIFile { debug!("file_metadata: {}", full_path); // FIXME (#9639): This needs to handle non-utf8 paths - let work_dir = cx.sess().working_dir.as_str().unwrap(); + let work_dir = cx.sess().working_dir.as_str().assert(); let file_name = if full_path.starts_with(work_dir) { full_path.slice(work_dir.len() + 1u, full_path.len()) @@ -2385,7 +2385,7 @@ fn prepare_enum_metadata(cx: &CrateContext, bytes_to_bits(enum_type_size), bytes_to_bits(enum_type_align), 0, // Flags - ptr::mut_null(), + ptr::null_mut(), 0, // RuntimeLang unique_type_id_str) } @@ -2415,7 +2415,7 @@ fn prepare_enum_metadata(cx: &CrateContext, let name = if def_id.krate == ast::LOCAL_CRATE { cx.tcx.map.get_path_elem(def_id.node).name() } else { - csearch::get_item_path(&cx.tcx, def_id).last().unwrap().name() + csearch::get_item_path(&cx.tcx, def_id).last().assert().name() }; token::get_name(name) @@ -2556,10 +2556,10 @@ fn create_struct_stub(cx: &CrateContext, bytes_to_bits(struct_size), bytes_to_bits(struct_align), 0, - ptr::mut_null(), + ptr::null_mut(), empty_array, 0, - ptr::mut_null(), + ptr::null_mut(), unique_type_id) }) }) @@ -2841,7 +2841,7 @@ fn subroutine_type_metadata(cx: &CrateContext, // return type signature_metadata.push(match ty::get(signature.output).sty { - ty::ty_nil => ptr::mut_null(), + ty::ty_nil => ptr::null_mut(), _ => type_metadata(cx, signature.output, span) }); @@ -3143,7 +3143,7 @@ fn set_debug_location(cx: &CrateContext, debug_location: DebugLocation) { let col = UNKNOWN_COLUMN_NUMBER; debug!("setting debug location to {} {}", line, col); let elements = [C_i32(cx, line as i32), C_i32(cx, col as i32), - scope, ptr::mut_null()]; + scope, ptr::null_mut()]; unsafe { metadata_node = llvm::LLVMMDNodeInContext(debug_context(cx).llcontext, elements.as_ptr(), @@ -3152,7 +3152,7 @@ fn set_debug_location(cx: &CrateContext, debug_location: DebugLocation) { } UnknownLocation => { debug!("clearing debug location "); - metadata_node = ptr::mut_null(); + metadata_node = ptr::null_mut(); } }; @@ -3182,14 +3182,14 @@ fn bytes_to_bits(bytes: u64) -> c_ulonglong { #[inline] fn debug_context<'a>(cx: &'a CrateContext) -> &'a CrateDebugContext { - let debug_context: &'a CrateDebugContext = cx.dbg_cx.get_ref(); + let debug_context: &'a CrateDebugContext = cx.dbg_cx.as_ref().assert(); debug_context } #[inline] #[allow(non_snake_case_functions)] fn DIB(cx: &CrateContext) -> DIBuilderRef { - cx.dbg_cx.get_ref().builder + cx.dbg_cx.as_ref().assert().builder } fn fn_should_be_ignored(fcx: &FunctionContext) -> bool { @@ -3269,7 +3269,7 @@ fn populate_scope_map(cx: &CrateContext, // Create a new lexical scope and push it onto the stack let loc = cx.sess().codemap().lookup_char_pos(scope_span.lo); let file_metadata = file_metadata(cx, loc.file.name.as_slice()); - let parent_scope = scope_stack.last().unwrap().scope_metadata; + let parent_scope = scope_stack.last().assert().scope_metadata; let scope_metadata = unsafe { llvm::LLVMDIBuilderCreateLexicalBlock( @@ -3287,11 +3287,11 @@ fn populate_scope_map(cx: &CrateContext, inner_walk(cx, scope_stack, scope_map); // pop artificial scopes - while scope_stack.last().unwrap().ident.is_some() { + while scope_stack.last().assert().ident.is_some() { scope_stack.pop(); } - if scope_stack.last().unwrap().scope_metadata != scope_metadata { + if scope_stack.last().assert().scope_metadata != scope_metadata { cx.sess().span_bug(scope_span, "debuginfo: Inconsistency in scope management."); } @@ -3302,12 +3302,12 @@ fn populate_scope_map(cx: &CrateContext, block: &ast::Block, scope_stack: &mut Vec<ScopeStackEntry> , scope_map: &mut HashMap<ast::NodeId, DIScope>) { - scope_map.insert(block.id, scope_stack.last().unwrap().scope_metadata); + scope_map.insert(block.id, scope_stack.last().assert().scope_metadata); // The interesting things here are statements and the concluding expression. for statement in block.stmts.iter() { scope_map.insert(ast_util::stmt_id(&**statement), - scope_stack.last().unwrap().scope_metadata); + scope_stack.last().assert().scope_metadata); match statement.node { ast::StmtDecl(ref decl, _) => @@ -3330,7 +3330,7 @@ fn populate_scope_map(cx: &CrateContext, scope_map: &mut HashMap<ast::NodeId, DIScope>) { match *decl { codemap::Spanned { node: ast::DeclLocal(local), .. } => { - scope_map.insert(local.id, scope_stack.last().unwrap().scope_metadata); + scope_map.insert(local.id, scope_stack.last().assert().scope_metadata); walk_pattern(cx, local.pat, scope_stack, scope_map); @@ -3395,7 +3395,7 @@ fn populate_scope_map(cx: &CrateContext, loc.file .name .as_slice()); - let parent_scope = scope_stack.last().unwrap().scope_metadata; + let parent_scope = scope_stack.last().assert().scope_metadata; let scope_metadata = unsafe { llvm::LLVMDIBuilderCreateLexicalBlock( @@ -3414,7 +3414,7 @@ fn populate_scope_map(cx: &CrateContext, } else { // Push a new entry anyway so the name can be found - let prev_metadata = scope_stack.last().unwrap().scope_metadata; + let prev_metadata = scope_stack.last().assert().scope_metadata; scope_stack.push(ScopeStackEntry { scope_metadata: prev_metadata, ident: Some(ident) @@ -3422,7 +3422,7 @@ fn populate_scope_map(cx: &CrateContext, } } - scope_map.insert(pat.id, scope_stack.last().unwrap().scope_metadata); + scope_map.insert(pat.id, scope_stack.last().assert().scope_metadata); for &sub_pat in sub_pat_opt.iter() { walk_pattern(cx, sub_pat, scope_stack, scope_map); @@ -3430,11 +3430,11 @@ fn populate_scope_map(cx: &CrateContext, } ast::PatWild(_) => { - scope_map.insert(pat.id, scope_stack.last().unwrap().scope_metadata); + scope_map.insert(pat.id, scope_stack.last().assert().scope_metadata); } ast::PatEnum(_, ref sub_pats_opt) => { - scope_map.insert(pat.id, scope_stack.last().unwrap().scope_metadata); + scope_map.insert(pat.id, scope_stack.last().assert().scope_metadata); for ref sub_pats in sub_pats_opt.iter() { for &p in sub_pats.iter() { @@ -3444,7 +3444,7 @@ fn populate_scope_map(cx: &CrateContext, } ast::PatStruct(_, ref field_pats, _) => { - scope_map.insert(pat.id, scope_stack.last().unwrap().scope_metadata); + scope_map.insert(pat.id, scope_stack.last().assert().scope_metadata); for &ast::FieldPat { pat: sub_pat, .. } in field_pats.iter() { walk_pattern(cx, sub_pat, scope_stack, scope_map); @@ -3452,7 +3452,7 @@ fn populate_scope_map(cx: &CrateContext, } ast::PatTup(ref sub_pats) => { - scope_map.insert(pat.id, scope_stack.last().unwrap().scope_metadata); + scope_map.insert(pat.id, scope_stack.last().assert().scope_metadata); for sub_pat in sub_pats.iter() { walk_pattern(cx, sub_pat.clone(), scope_stack, scope_map); @@ -3460,23 +3460,23 @@ fn populate_scope_map(cx: &CrateContext, } ast::PatBox(ref sub_pat) | ast::PatRegion(ref sub_pat) => { - scope_map.insert(pat.id, scope_stack.last().unwrap().scope_metadata); + scope_map.insert(pat.id, scope_stack.last().assert().scope_metadata); walk_pattern(cx, sub_pat.clone(), scope_stack, scope_map); } ast::PatLit(ref exp) => { - scope_map.insert(pat.id, scope_stack.last().unwrap().scope_metadata); + scope_map.insert(pat.id, scope_stack.last().assert().scope_metadata); walk_expr(cx, &**exp, scope_stack, scope_map); } ast::PatRange(ref exp1, ref exp2) => { - scope_map.insert(pat.id, scope_stack.last().unwrap().scope_metadata); + scope_map.insert(pat.id, scope_stack.last().assert().scope_metadata); walk_expr(cx, &**exp1, scope_stack, scope_map); walk_expr(cx, &**exp2, scope_stack, scope_map); } ast::PatVec(ref front_sub_pats, ref middle_sub_pats, ref back_sub_pats) => { - scope_map.insert(pat.id, scope_stack.last().unwrap().scope_metadata); + scope_map.insert(pat.id, scope_stack.last().assert().scope_metadata); for &sub_pat in front_sub_pats.iter() { walk_pattern(cx, sub_pat, scope_stack, scope_map); @@ -3503,7 +3503,7 @@ fn populate_scope_map(cx: &CrateContext, scope_stack: &mut Vec<ScopeStackEntry> , scope_map: &mut HashMap<ast::NodeId, DIScope>) { - scope_map.insert(exp.id, scope_stack.last().unwrap().scope_metadata); + scope_map.insert(exp.id, scope_stack.last().assert().scope_metadata); match exp.node { ast::ExprLit(_) | @@ -3592,7 +3592,7 @@ fn populate_scope_map(cx: &CrateContext, |cx, scope_stack, scope_map| { scope_map.insert(exp.id, scope_stack.last() - .unwrap() + .assert() .scope_metadata); walk_pattern(cx, *pattern, @@ -3981,7 +3981,7 @@ impl NamespaceTreeNode { fn mangled_name_of_contained_item(&self, item_name: &str) -> String { fn fill_nested(node: &NamespaceTreeNode, output: &mut String) { match node.parent { - Some(ref parent) => fill_nested(&*parent.upgrade().unwrap(), output), + Some(ref parent) => fill_nested(&*parent.upgrade().assert(), output), None => {} } let string = token::get_name(node.name); @@ -4011,7 +4011,7 @@ fn namespace_for_item(cx: &CrateContext, def_id: ast::DefId) -> Rc<NamespaceTree } else { None }; - let mut path = krate.move_iter().chain(path).peekable(); + let mut path = krate.iter_owned().chain(path).peekable(); let mut current_key = Vec::new(); let mut parent_node: Option<Rc<NamespaceTreeNode>> = None; @@ -4039,7 +4039,7 @@ fn namespace_for_item(cx: &CrateContext, def_id: ast::DefId) -> Rc<NamespaceTree // create and insert let parent_scope = match parent_node { Some(ref node) => node.scope, - None => ptr::mut_null() + None => ptr::null_mut() }; let namespace_name = token::get_name(name); let scope = namespace_name.get().with_c_str(|namespace_name| { @@ -4049,7 +4049,7 @@ fn namespace_for_item(cx: &CrateContext, def_id: ast::DefId) -> Rc<NamespaceTree parent_scope, namespace_name, // cannot reconstruct file ... - ptr::mut_null(), + ptr::null_mut(), // ... or line information, but that's not so important. 0) } diff --git a/src/librustc/middle/trans/foreign.rs b/src/librustc/middle/trans/foreign.rs index 4ca2060ca866d..4556691fa3ca4 100644 --- a/src/librustc/middle/trans/foreign.rs +++ b/src/librustc/middle/trans/foreign.rs @@ -610,7 +610,7 @@ pub fn trans_rust_fn_with_foreign_abi(ccx: &CrateContext, let ps = ccx.tcx.map.with_path(id, |path| { let abi = Some(ast_map::PathName(special_idents::clownshoe_abi.name)); - link::mangle(path.chain(abi.move_iter()), hash) + link::mangle(path.chain(abi.iter_owned()), hash) }); // Compute the type that the function would have if it were just a @@ -811,7 +811,7 @@ pub fn trans_rust_fn_with_foreign_abi(ccx: &CrateContext, None if rust_uses_outptr => { // Rust uses an outpointer, but the foreign ABI does not. Load. - let llrust_outptr = return_alloca.unwrap(); + let llrust_outptr = return_alloca.assert(); let llforeign_outptr_casted = builder.bitcast(llrust_outptr, llforeign_ret_ty.ptr_to()); let llforeign_retval = builder.load(llforeign_outptr_casted); diff --git a/src/librustc/middle/trans/meth.rs b/src/librustc/middle/trans/meth.rs index 7f7b70e075d1d..43238e074b25c 100644 --- a/src/librustc/middle/trans/meth.rs +++ b/src/librustc/middle/trans/meth.rs @@ -177,7 +177,7 @@ pub fn trans_static_method_callee(bcx: &Block, _ => fail!("callee is not a trait method") } } else { - csearch::get_item_path(bcx.tcx(), method_id).last().unwrap().name() + csearch::get_item_path(bcx.tcx(), method_id).last().assert().name() }; debug!("trans_static_method_callee: method_id={:?}, expr_id={:?}, \ name={}", method_id, expr_id, token::get_name(mname)); @@ -187,7 +187,7 @@ pub fn trans_static_method_callee(bcx: &Block, bcx.fcx, ccx.tcx.vtable_map.borrow().get(&vtable_key)); - match *vtbls.get_self().unwrap().get(0) { + match *vtbls.get_self().assert().get(0) { typeck::vtable_static(impl_did, ref rcvr_substs, ref rcvr_origins) => { assert!(rcvr_substs.types.all(|t| !ty::type_needs_infer(*t))); @@ -484,10 +484,10 @@ fn get_vtable(bcx: &Block, } // Not in the cache. Actually build it. - let methods = origins.move_iter().flat_map(|origin| { + let methods = origins.iter_owned().flat_map(|origin| { match origin { typeck::vtable_static(id, substs, sub_vtables) => { - emit_vtable_methods(bcx, id, substs, sub_vtables).move_iter() + emit_vtable_methods(bcx, id, substs, sub_vtables).iter_owned() } typeck::vtable_unboxed_closure(closure_def_id) => { let callee_substs = @@ -502,7 +502,7 @@ fn get_vtable(bcx: &Block, callee_substs, VecPerParamSpace::empty()); - (vec!(llfn)).move_iter() + (vec!(llfn)).iter_owned() } _ => ccx.sess().bug("get_vtable: expected a static origin"), } @@ -523,7 +523,7 @@ pub fn make_vtable<I: Iterator<ValueRef>>(ccx: &CrateContext, -> ValueRef { let _icx = push_ctxt("meth::make_vtable"); - let components: Vec<_> = Some(drop_glue).move_iter().chain(ptrs).collect(); + let components: Vec<_> = Some(drop_glue).iter_owned().chain(ptrs).collect(); unsafe { let tbl = C_struct(ccx, components.as_slice(), false); @@ -626,7 +626,7 @@ pub fn trans_trait_cast<'a>(bcx: &'a Block<'a>, Some(&ty::AutoObject(..)) => MethodCall::autoobject(id), _ => MethodCall::expr(id) }; - let vres = vtable_map.get(&method_call).get_self().unwrap(); + let vres = vtable_map.get(&method_call).get_self().assert(); resolve_param_vtables_under_param_substs(ccx.tcx(), bcx.fcx.param_substs, vres) }; let vtable = get_vtable(bcx, v_ty, origins); diff --git a/src/librustc/middle/trans/monomorphize.rs b/src/librustc/middle/trans/monomorphize.rs index 070bd89d28963..66de98518067e 100644 --- a/src/librustc/middle/trans/monomorphize.rs +++ b/src/librustc/middle/trans/monomorphize.rs @@ -147,7 +147,7 @@ pub fn monomorphic_fn(ccx: &CrateContext, decl_internal_rust_fn(ccx, mono_ty, s.as_slice()) }; - ccx.monomorphized.borrow_mut().insert(hash_id.take_unwrap(), lldecl); + ccx.monomorphized.borrow_mut().insert(hash_id.take().assert(), lldecl); lldecl }; @@ -180,7 +180,7 @@ pub fn monomorphic_fn(ccx: &CrateContext, ast_map::NodeVariant(v) => { let parent = ccx.tcx.map.get_parent(fn_id.node); let tvs = ty::enum_variants(ccx.tcx(), local_def(parent)); - let this_tv = tvs.iter().find(|tv| { tv.id.node == fn_id.node}).unwrap(); + let this_tv = tvs.iter().find(|tv| { tv.id.node == fn_id.node}).assert(); let d = mk_lldecl(abi::Rust); set_inline_hint(d); match v.node.kind { diff --git a/src/librustc/middle/trans/reflect.rs b/src/librustc/middle/trans/reflect.rs index eb0d77da5519f..baaba043b7ab6 100644 --- a/src/librustc/middle/trans/reflect.rs +++ b/src/librustc/middle/trans/reflect.rs @@ -295,7 +295,7 @@ impl<'a, 'b> Reflector<'a, 'b> { let repr = adt::represent_type(bcx.ccx(), t); let variants = ty::substd_enum_variants(ccx.tcx(), did, substs); let llptrty = type_of(ccx, t).ptr_to(); - let opaquety = ty::get_opaque_ty(ccx.tcx()).unwrap(); + let opaquety = ty::get_opaque_ty(ccx.tcx()).assert(); let opaqueptrty = ty::mk_ptr(ccx.tcx(), ty::mt { ty: opaquety, mutbl: ast::MutImmutable }); @@ -321,7 +321,7 @@ impl<'a, 'b> Reflector<'a, 'b> { let arg = get_param(llfdecl, fcx.arg_pos(0u) as c_uint); let arg = BitCast(bcx, arg, llptrty); let ret = adt::trans_get_discr(bcx, &*repr, arg, Some(Type::i64(ccx))); - Store(bcx, ret, fcx.llretptr.get().unwrap()); + Store(bcx, ret, fcx.llretptr.get().assert()); match fcx.llreturn.get() { Some(llreturn) => Br(bcx, llreturn), None => {} @@ -393,7 +393,7 @@ pub fn emit_calls_to_trait_visit_ty<'a>( -> &'a Block<'a> { let fcx = bcx.fcx; let final = fcx.new_temp_block("final"); - let tydesc_ty = ty::get_tydesc_ty(bcx.tcx()).unwrap(); + let tydesc_ty = ty::get_tydesc_ty(bcx.tcx()).assert(); let tydesc_ty = type_of(bcx.ccx(), tydesc_ty); let visitor_methods = ty::trait_methods(bcx.tcx(), visitor_trait_id); let mut r = Reflector { diff --git a/src/librustc/middle/trans/type_of.rs b/src/librustc/middle/trans/type_of.rs index 94c376c09c86a..d8f11b584945f 100644 --- a/src/librustc/middle/trans/type_of.rs +++ b/src/librustc/middle/trans/type_of.rs @@ -301,7 +301,7 @@ pub fn type_of(cx: &CrateContext, t: ty::t) -> Type { } ty::ty_str => { // This means we get a nicer name in the output - cx.tn.find_type("str_slice").unwrap() + cx.tn.find_type("str_slice").assert() } ty::ty_trait(..) => Type::opaque_trait(cx), _ => type_of(cx, mt.ty).ptr_to(), diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index a4588da1bd7dd..3330ae7691302 100644 --- a/src/librustc/middle/ty.rs +++ b/src/librustc/middle/ty.rs @@ -2339,7 +2339,7 @@ pub fn is_instantiable(cx: &ctxt, r_ty: t) -> bool { seen.push(did); let fields = struct_fields(cx, did, substs); let r = fields.iter().any(|f| type_requires(cx, seen, r_ty, f.mt.ty)); - seen.pop().unwrap(); + seen.pop().assert(); r } @@ -2365,7 +2365,7 @@ pub fn is_instantiable(cx: &ctxt, r_ty: t) -> bool { type_requires(cx, seen, r_ty, sty) }) }); - seen.pop().unwrap(); + seen.pop().assert(); r } }; diff --git a/src/librustc/middle/typeck/astconv.rs b/src/librustc/middle/typeck/astconv.rs index 5e7426f3ae749..4b4aec8dfc2d8 100644 --- a/src/librustc/middle/typeck/astconv.rs +++ b/src/librustc/middle/typeck/astconv.rs @@ -180,9 +180,9 @@ fn ast_path_substs<AC:AstConv,RS:RegionScope>( // region with the current anon region binding (in other words, // whatever & would get replaced with). let expected_num_region_params = decl_generics.regions.len(TypeSpace); - let supplied_num_region_params = path.segments.last().unwrap().lifetimes.len(); + let supplied_num_region_params = path.segments.last().assert().lifetimes.len(); let regions = if expected_num_region_params == supplied_num_region_params { - path.segments.last().unwrap().lifetimes.iter().map( + path.segments.last().assert().lifetimes.iter().map( |l| ast_region_to_region(this.tcx(), l)).collect::<Vec<_>>() } else { let anon_regions = @@ -195,7 +195,7 @@ fn ast_path_substs<AC:AstConv,RS:RegionScope>( } match anon_regions { - Ok(v) => v.move_iter().collect(), + Ok(v) => v.iter_owned().collect(), Err(()) => Vec::from_fn(expected_num_region_params, |_| ty::ReStatic) // hokey } @@ -261,7 +261,7 @@ fn ast_path_substs<AC:AstConv,RS:RegionScope>( } for param in ty_param_defs.slice_from(supplied_ty_param_count).iter() { - let default = param.default.unwrap(); + let default = param.default.assert(); let default = default.subst_spanned(tcx, &substs, Some(path.span)); substs.types.push(TypeSpace, default); } @@ -327,7 +327,7 @@ pub fn ast_path_to_ty_relaxed<AC:AstConv, |_| this.ty_infer(path.span)); let region_params = rscope.anon_regions(path.span, generics.regions.len(TypeSpace)) - .unwrap(); + .assert(); Substs::new(VecPerParamSpace::params_from_type(type_params), VecPerParamSpace::params_from_type(region_params)) } else { @@ -355,7 +355,7 @@ fn check_path_args(tcx: &ty::ctxt, } if (flags & NO_REGIONS) != 0u { - if !path.segments.last().unwrap().lifetimes.is_empty() { + if !path.segments.last().assert().lifetimes.is_empty() { span_err!(tcx.sess, path.span, E0110, "region parameters are not allowed on this type"); } @@ -553,7 +553,7 @@ pub fn trait_ref_for_unboxed_function<AC:AstConv, let fn_mut_trait_did = this.tcx() .lang_items .require(FnMutTraitLangItem) - .unwrap(); + .assert(); let input_types = unboxed_function.decl .inputs @@ -922,7 +922,7 @@ pub fn ast_ty_to_ty<AC:AstConv, RS:RegionScope>( pub fn ty_of_arg<AC: AstConv, RS: RegionScope>(this: &AC, rscope: &RS, a: &ast::Arg, expected_ty: Option<ty::t>) -> ty::t { match a.ty.node { - ast::TyInfer if expected_ty.is_some() => expected_ty.unwrap(), + ast::TyInfer if expected_ty.is_some() => expected_ty.assert(), ast::TyInfer => this.ty_infer(a.ty.span), _ => ast_ty_to_ty(this, rscope, &*a.ty), } @@ -953,7 +953,7 @@ pub fn ty_of_method<AC:AstConv>( abi, self_info, decl); - (bare_fn_ty, optional_explicit_self_category.unwrap()) + (bare_fn_ty, optional_explicit_self_category.assert()) } pub fn ty_of_bare_fn<AC:AstConv>(this: &AC, id: ast::NodeId, @@ -1023,7 +1023,7 @@ fn ty_of_method_or_bare_fn<AC:AstConv>( }; let input_tys = input_tys.iter().map(|a| ty_of_arg(this, &rb, a, None)); let self_and_input_tys: Vec<_> = - self_ty.move_iter().chain(input_tys).collect(); + self_ty.iter_owned().chain(input_tys).collect(); // Second, if there was exactly one lifetime (either a substitution or a // reference) in the arguments, then any anonymous regions in the output @@ -1185,7 +1185,7 @@ pub fn ty_of_closure<AC:AstConv>( let expected_ret_ty = expected_sig.map(|e| e.output); let output_ty = match decl.output.node { - ast::TyInfer if expected_ret_ty.is_some() => expected_ret_ty.unwrap(), + ast::TyInfer if expected_ret_ty.is_some() => expected_ret_ty.assert(), ast::TyInfer => this.ty_infer(decl.output.span), _ => ast_ty_to_ty(this, &rb, &*decl.output) }; diff --git a/src/librustc/middle/typeck/check/_match.rs b/src/librustc/middle/typeck/check/_match.rs index 76823155155f6..f69214affa6e4 100644 --- a/src/librustc/middle/typeck/check/_match.rs +++ b/src/librustc/middle/typeck/check/_match.rs @@ -179,7 +179,7 @@ pub fn check_pat_variant(pcx: &pat_ctxt, pat: &ast::Pat, path: &ast::Path, kind_name = "[error]"; arg_types = subpats.clone() .unwrap_or_default() - .move_iter() + .iter_owned() .map(|_| ty::mk_err()) .collect(); } diff --git a/src/librustc/middle/typeck/check/method.rs b/src/librustc/middle/typeck/check/method.rs index 1805c18eaf10c..b787105c16ff1 100644 --- a/src/librustc/middle/typeck/check/method.rs +++ b/src/librustc/middle/typeck/check/method.rs @@ -263,7 +263,7 @@ fn construct_transformed_self_ty_for_object( // The subst we get in has Err as the "Self" type. For an object // type, we don't put any type into the Self paramspace, so let's // make a copy of rcvr_substs that has the Self paramspace empty. - obj_substs.types.pop(subst::SelfSpace).unwrap(); + obj_substs.types.pop(subst::SelfSpace).assert(); match method_ty.explicit_self { StaticExplicitSelfCategory => { @@ -502,7 +502,7 @@ impl<'a> LookupContext<'a> { // find all the impls of that trait. Each of those are // candidates. let opt_applicable_traits = self.fcx.ccx.trait_map.find(&expr_id); - for applicable_traits in opt_applicable_traits.move_iter() { + for applicable_traits in opt_applicable_traits.iter_owned() { for trait_did in applicable_traits.iter() { debug!("push_extension_candidates() found trait: {}", if trait_did.krate == ast::LOCAL_CRATE { @@ -1237,7 +1237,7 @@ impl<'a> LookupContext<'a> { let args = fn_sig.inputs.slice_from(1).iter().map(|t| { t.subst(tcx, &all_substs) }); - Some(*fn_sig.inputs.get(0)).move_iter().chain(args).collect() + Some(*fn_sig.inputs.get(0)).iter_owned().chain(args).collect() } _ => fn_sig.inputs.subst(tcx, &all_substs) }; diff --git a/src/librustc/middle/typeck/check/mod.rs b/src/librustc/middle/typeck/check/mod.rs index 787a4bebc559b..c1914521e406a 100644 --- a/src/librustc/middle/typeck/check/mod.rs +++ b/src/librustc/middle/typeck/check/mod.rs @@ -4494,14 +4494,14 @@ pub fn instantiate_path(fcx: &FnCtxt, for (i, lifetime) in segment.lifetimes.iter().enumerate() { let r = ast_region_to_region(fcx.tcx(), lifetime); if i < region_count { - substs.mut_regions().push(space, r); + substs.regions_mut().push(space, r); } else if i == region_count { span_err!(fcx.tcx().sess, lifetime.span, E0088, "too many lifetime parameters provided: \ expected {} parameter(s) but found {} parameter(s)", region_count, segment.lifetimes.len()); - substs.mut_regions().truncate(space, 0); + substs.regions_mut().truncate(space, 0); } } } @@ -4562,7 +4562,7 @@ pub fn instantiate_path(fcx: &FnCtxt, // parameters, so we have to substitute as we go with the // partial substitution that we have built up. for i in range(provided_len, desired.len()) { - let default = desired[i].default.unwrap(); + let default = desired[i].default.assert(); let default = default.subst_spanned(fcx.tcx(), substs, Some(span)); substs.types.push(space, default); } @@ -4578,7 +4578,7 @@ pub fn instantiate_path(fcx: &FnCtxt, defs: &VecPerParamSpace<ty::RegionParameterDef>, substs: &mut Substs) { - let provided_len = substs.mut_regions().len(space); + let provided_len = substs.regions_mut().len(space); let desired = defs.get_slice(space); // Enforced by `push_explicit_parameters_from_segment_to_substs()`. @@ -4586,7 +4586,7 @@ pub fn instantiate_path(fcx: &FnCtxt, // If nothing was provided, just use inference variables. if provided_len == 0 { - substs.mut_regions().replace( + substs.regions_mut().replace( space, fcx.infcx().region_vars_for_defs(span, desired)); return; @@ -4604,7 +4604,7 @@ pub fn instantiate_path(fcx: &FnCtxt, but found {} parameter(s)", desired.len(), provided_len); - substs.mut_regions().replace( + substs.regions_mut().replace( space, fcx.infcx().region_vars_for_defs(span, desired)); } @@ -5023,4 +5023,3 @@ pub fn check_intrinsic_type(ccx: &CrateCtxt, it: &ast::ForeignItem) { }); } } - diff --git a/src/librustc/middle/typeck/check/regionmanip.rs b/src/librustc/middle/typeck/check/regionmanip.rs index 53e26f8696f61..3704478bc7d95 100644 --- a/src/librustc/middle/typeck/check/regionmanip.rs +++ b/src/librustc/middle/typeck/check/regionmanip.rs @@ -104,7 +104,7 @@ pub fn relate_nested_regions(tcx: &ty::ctxt, self.relate(r); self.stack.push(r); ty_fold::super_fold_ty(self, ty); - self.stack.pop().unwrap(); + self.stack.pop().assert(); } _ => { diff --git a/src/librustc/middle/typeck/collect.rs b/src/librustc/middle/typeck/collect.rs index a81c6344cc9c6..0f36ab252c706 100644 --- a/src/librustc/middle/typeck/collect.rs +++ b/src/librustc/middle/typeck/collect.rs @@ -1048,7 +1048,7 @@ fn add_unsized_bound(ccx: &CrateCtxt, } _ if kind_id.is_ok() => { ty::try_add_builtin_trait(ccx.tcx, - kind_id.unwrap(), + kind_id.assert(), bounds); } // No lang item for Sized, so we can't add it as a bound. diff --git a/src/librustc/middle/typeck/infer/combine.rs b/src/librustc/middle/typeck/infer/combine.rs index 1aae97d3d83e9..d54f66a39eef6 100644 --- a/src/librustc/middle/typeck/infer/combine.rs +++ b/src/librustc/middle/typeck/infer/combine.rs @@ -144,7 +144,7 @@ pub trait Combine { b_regions)); substs.types.replace(space, tps); - substs.mut_regions().replace(space, regions); + substs.regions_mut().replace(space, regions); } return Ok(substs); diff --git a/src/librustc/middle/typeck/infer/error_reporting.rs b/src/librustc/middle/typeck/infer/error_reporting.rs index e191fb343b53a..33a65c75010fd 100644 --- a/src/librustc/middle/typeck/infer/error_reporting.rs +++ b/src/librustc/middle/typeck/infer/error_reporting.rs @@ -219,7 +219,7 @@ impl<'a> ErrorReporting for InferCtxt<'a> { }; match free_regions_from_same_fn(self.tcx, sub, sup) { Some(ref same_frs) if trace.is_some() => { - let trace = trace.unwrap(); + let trace = trace.assert(); let terr = ty::terr_regions_does_not_outlive(sup, sub); trace_origins.push((trace, terr)); @@ -321,7 +321,7 @@ impl<'a> ErrorReporting for InferCtxt<'a> { same_frs: &FreeRegionsFromSameFn) { let scope_id = same_frs.scope_id; let (sub_fr, sup_fr) = (same_frs.sub_fr, same_frs.sup_fr); - for sr in same_regions.mut_iter() { + for sr in same_regions.iter_mut() { if sr.contains(&sup_fr.bound_region) && scope_id == sr.scope_id { sr.push(sub_fr.bound_region); @@ -915,7 +915,7 @@ impl<'a> Rebuilder<'a> { ast::UnboxedFnTyParamBound(unboxed_function_type) } &ast::TraitTyParamBound(ref tr) => { - let last_seg = tr.path.segments.last().unwrap(); + let last_seg = tr.path.segments.last().assert(); let mut insert = Vec::new(); for (i, lt) in last_seg.lifetimes.iter().enumerate() { if region_names.contains(<.name) { @@ -1022,7 +1022,7 @@ impl<'a> Rebuilder<'a> { let mut ty_queue = vec!(ty); let mut cur_ty; while !ty_queue.is_empty() { - cur_ty = ty_queue.shift().unwrap(); + cur_ty = ty_queue.shift().assert(); match cur_ty.node { ast::TyRptr(lt_opt, mut_ty) => { match lt_opt { @@ -1063,7 +1063,7 @@ impl<'a> Rebuilder<'a> { let expected = generics.regions.len(subst::TypeSpace); let lifetimes = - &path.segments.last().unwrap().lifetimes; + &path.segments.last().assert().lifetimes; let mut insert = Vec::new(); if lifetimes.len() == 0 { let anon = self.cur_anon.get(); @@ -1182,7 +1182,7 @@ impl<'a> Rebuilder<'a> { region_names: region_names, } = rebuild_info; - let last_seg = path.segments.last().unwrap(); + let last_seg = path.segments.last().assert(); let mut new_lts = Vec::new(); if last_seg.lifetimes.len() == 0 { // traverse once to see if there's a need to insert lifetime @@ -1463,7 +1463,7 @@ fn lifetimes_in_scope(tcx: &ty::ctxt, None => None }; if method_id_opt.is_some() { - let method_id = method_id_opt.unwrap(); + let method_id = method_id_opt.assert(); let parent = tcx.map.get_parent(method_id); match tcx.map.find(parent) { Some(node) => match node { @@ -1527,7 +1527,7 @@ impl LifeGiver { fn num_to_string(counter: uint) -> String { let mut s = String::new(); let (n, r) = (counter/26 + 1, counter % 26); - let letter: char = from_u32((r+97) as u32).unwrap(); + let letter: char = from_u32((r+97) as u32).assert(); for _ in range(0, n) { s.push_char(letter); } diff --git a/src/librustc/middle/typeck/infer/glb.rs b/src/librustc/middle/typeck/infer/glb.rs index b6628c22ae60a..d69ab858331e9 100644 --- a/src/librustc/middle/typeck/infer/glb.rs +++ b/src/librustc/middle/typeck/infer/glb.rs @@ -225,7 +225,7 @@ impl<'f> Combine for Glb<'f> { if a_r.is_some() && b_r.is_some() && only_new_vars { // Related to exactly one bound variable from each fn: - return rev_lookup(this, a_map, new_binder_id, a_r.unwrap()); + return rev_lookup(this, a_map, new_binder_id, a_r.assert()); } else if a_r.is_none() && b_r.is_none() { // Not related to bound variables from either fn: assert!(!r0.is_bound()); diff --git a/src/librustc/middle/typeck/infer/region_inference/mod.rs b/src/librustc/middle/typeck/infer/region_inference/mod.rs index dc674da38af5b..c4f15f3c51fc5 100644 --- a/src/librustc/middle/typeck/infer/region_inference/mod.rs +++ b/src/librustc/middle/typeck/infer/region_inference/mod.rs @@ -209,7 +209,7 @@ impl<'a> RegionVarBindings<'a> { assert!(undo_log.len() > snapshot.length); assert!(*undo_log.get(snapshot.length) == OpenSnapshot); while undo_log.len() > snapshot.length + 1 { - match undo_log.pop().unwrap() { + match undo_log.pop().assert() { OpenSnapshot => { fail!("Failure to observe stack discipline"); } @@ -217,7 +217,7 @@ impl<'a> RegionVarBindings<'a> { AddVar(vid) => { let mut var_origins = self.var_origins.borrow_mut(); assert_eq!(var_origins.len(), vid.index + 1); - var_origins.pop().unwrap(); + var_origins.pop().assert(); } AddConstraint(ref constraint) => { self.constraints.borrow_mut().remove(constraint); @@ -230,7 +230,7 @@ impl<'a> RegionVarBindings<'a> { } } } - let c = undo_log.pop().unwrap(); + let c = undo_log.pop().assert(); assert!(c == OpenSnapshot); } @@ -1088,7 +1088,7 @@ impl<'a> RegionVarBindings<'a> { if opt_graph.is_none() { opt_graph = Some(self.construct_graph()); } - let graph = opt_graph.get_ref(); + let graph = opt_graph.as_ref().assert(); let node_vid = RegionVid { index: idx }; match var_data[idx].classification { @@ -1291,7 +1291,7 @@ impl<'a> RegionVarBindings<'a> { process_edges(self, &mut state, graph, orig_node_idx, dir); while !state.stack.is_empty() { - let node_idx = state.stack.pop().unwrap(); + let node_idx = state.stack.pop().assert(); let classification = var_data[node_idx.index].classification; // check whether we've visited this node on some previous walk diff --git a/src/librustc/middle/typeck/infer/resolve.rs b/src/librustc/middle/typeck/infer/resolve.rs index 2ae95309d41d9..d5b4b686bf91a 100644 --- a/src/librustc/middle/typeck/infer/resolve.rs +++ b/src/librustc/middle/typeck/infer/resolve.rs @@ -235,7 +235,7 @@ impl<'a> ResolveState<'a> { ty::mk_var(tcx, vid) } }; - self.v_seen.pop().unwrap(); + self.v_seen.pop().assert(); return t1; } } diff --git a/src/librustc/middle/typeck/infer/unify.rs b/src/librustc/middle/typeck/infer/unify.rs index 44afc04d3f0ef..fe1f3d2f1a611 100644 --- a/src/librustc/middle/typeck/infer/unify.rs +++ b/src/librustc/middle/typeck/infer/unify.rs @@ -185,7 +185,7 @@ impl<V:PartialEq+Clone+Repr,K:UnifyKey<V>> UnificationTable<K,V> { self.assert_open_snapshot(&snapshot); while self.undo_log.len() > snapshot.length + 1 { - match self.undo_log.pop().unwrap() { + match self.undo_log.pop().assert() { OpenSnapshot => { // This indicates a failure to obey the stack discipline. tcx.sess.bug("Cannot rollback an uncommitted snapshot"); @@ -207,7 +207,7 @@ impl<V:PartialEq+Clone+Repr,K:UnifyKey<V>> UnificationTable<K,V> { } } - let v = self.undo_log.pop().unwrap(); + let v = self.undo_log.pop().assert(); assert!(v == OpenSnapshot); assert!(self.undo_log.len() == snapshot.length); } diff --git a/src/librustc/plugin/build.rs b/src/librustc/plugin/build.rs index ad35c4efe1138..1302d6868e4d5 100644 --- a/src/librustc/plugin/build.rs +++ b/src/librustc/plugin/build.rs @@ -46,7 +46,7 @@ pub fn find_plugin_registrar(diagnostic: &diagnostic::SpanHandler, match finder.registrars.len() { 0 => None, 1 => { - let (node_id, _) = finder.registrars.pop().unwrap(); + let (node_id, _) = finder.registrars.pop().assert(); Some(node_id) }, _ => { diff --git a/src/librustc_back/archive.rs b/src/librustc_back/archive.rs index 85e0f2f10d8dc..d34483f37e42f 100644 --- a/src/librustc_back/archive.rs +++ b/src/librustc_back/archive.rs @@ -69,18 +69,18 @@ fn run_ar(handler: &ErrorHandler, maybe_ar_prog: &Option<String>, match cmd.spawn() { Ok(prog) => { - let o = prog.wait_with_output().unwrap(); + let o = prog.wait_with_output().assert(); if !o.status.success() { handler.err(format!("{} failed with: {}", cmd, o.status).as_slice()); handler.note(format!("stdout ---\n{}", str::from_utf8(o.output - .as_slice()).unwrap()) + .as_slice()).assert()) .as_slice()); handler.note(format!("stderr ---\n{}", str::from_utf8(o.error - .as_slice()).unwrap()) + .as_slice()).assert()) .as_slice()); handler.abort_if_errors(); } @@ -146,7 +146,7 @@ impl<'a> Archive<'a> { /// Lists all files in an archive pub fn files(&self) -> Vec<String> { let output = run_ar(self.handler, &self.maybe_ar_prog, "t", None, [&self.dst]); - let output = str::from_utf8(output.output.as_slice()).unwrap(); + let output = str::from_utf8(output.output.as_slice()).assert(); // use lines_any because windows delimits output with `\r\n` instead of // just `\n` output.lines_any().map(|s| s.to_string()).collect() @@ -162,7 +162,7 @@ impl<'a> ArchiveBuilder<'a> { fn new(archive: Archive<'a>) -> ArchiveBuilder<'a> { ArchiveBuilder { archive: archive, - work_dir: TempDir::new("rsar").unwrap(), + work_dir: TempDir::new("rsar").assert(), members: vec![], should_update_symbols: false, } @@ -201,7 +201,7 @@ impl<'a> ArchiveBuilder<'a> { /// Adds an arbitrary file to this archive pub fn add_file(&mut self, file: &Path) -> io::IoResult<()> { - let filename = Path::new(file.filename().unwrap()); + let filename = Path::new(file.filename().assert()); let new_file = self.work_dir.path().join(&filename); try!(fs::copy(file, &new_file)); self.members.push(filename); @@ -271,7 +271,7 @@ impl<'a> ArchiveBuilder<'a> { fn add_archive(&mut self, archive: &Path, name: &str, skip: &[&str]) -> io::IoResult<()> { - let loc = TempDir::new("rsar").unwrap(); + let loc = TempDir::new("rsar").assert(); // First, extract the contents of the archive to a temporary directory. // We don't unpack directly into `self.work_dir` due to the possibility @@ -291,7 +291,7 @@ impl<'a> ArchiveBuilder<'a> { // re-created when we make a new archive anyway. let files = try!(fs::readdir(loc.path())); for file in files.iter() { - let filename = file.filename_str().unwrap(); + let filename = file.filename_str().assert(); if skip.iter().any(|s| *s == filename) { continue } if filename.contains(".SYMDEF") { continue } diff --git a/src/librustc_back/fs.rs b/src/librustc_back/fs.rs index c051b8e60cd80..a8fb50cbc96a8 100644 --- a/src/librustc_back/fs.rs +++ b/src/librustc_back/fs.rs @@ -60,29 +60,29 @@ mod test { #[test] fn realpath_works() { - let tmpdir = TempDir::new("rustc-fs").unwrap(); - let tmpdir = realpath(tmpdir.path()).unwrap(); + let tmpdir = TempDir::new("rustc-fs").assert(); + let tmpdir = realpath(tmpdir.path()).assert(); let file = tmpdir.join("test"); let dir = tmpdir.join("test2"); let link = dir.join("link"); let linkdir = tmpdir.join("test3"); - File::create(&file).unwrap(); - mkdir(&dir, io::UserRWX).unwrap(); - symlink(&file, &link).unwrap(); - symlink(&dir, &linkdir).unwrap(); + File::create(&file).assert(); + mkdir(&dir, io::UserRWX).assert(); + symlink(&file, &link).assert(); + symlink(&dir, &linkdir).assert(); - assert!(realpath(&tmpdir).unwrap() == tmpdir); - assert!(realpath(&file).unwrap() == file); - assert!(realpath(&link).unwrap() == file); - assert!(realpath(&linkdir).unwrap() == dir); - assert!(realpath(&linkdir.join("link")).unwrap() == file); + assert!(realpath(&tmpdir).assert() == tmpdir); + assert!(realpath(&file).assert() == file); + assert!(realpath(&link).assert() == file); + assert!(realpath(&linkdir).assert() == dir); + assert!(realpath(&linkdir.join("link")).assert() == file); } #[test] fn realpath_works_tricky() { - let tmpdir = TempDir::new("rustc-fs").unwrap(); - let tmpdir = realpath(tmpdir.path()).unwrap(); + let tmpdir = TempDir::new("rustc-fs").assert(); + let tmpdir = realpath(tmpdir.path()).assert(); let a = tmpdir.join("a"); let b = a.join("b"); @@ -91,13 +91,13 @@ mod test { let e = d.join("e"); let f = a.join("f"); - mkdir_recursive(&b, io::UserRWX).unwrap(); - mkdir_recursive(&d, io::UserRWX).unwrap(); - File::create(&f).unwrap(); - symlink(&Path::new("../d/e"), &c).unwrap(); - symlink(&Path::new("../f"), &e).unwrap(); + mkdir_recursive(&b, io::UserRWX).assert(); + mkdir_recursive(&d, io::UserRWX).assert(); + File::create(&f).assert(); + symlink(&Path::new("../d/e"), &c).assert(); + symlink(&Path::new("../f"), &e).assert(); - assert!(realpath(&c).unwrap() == f); - assert!(realpath(&e).unwrap() == f); + assert!(realpath(&c).assert() == f); + assert!(realpath(&e).assert() == f); } } diff --git a/src/librustc_back/rpath.rs b/src/librustc_back/rpath.rs index 94d197ad06a8d..c04ca58c54546 100644 --- a/src/librustc_back/rpath.rs +++ b/src/librustc_back/rpath.rs @@ -47,7 +47,7 @@ pub fn get_rpath_flags(config: RPathConfig) -> Vec<String> { debug!("preparing the RPATH!"); let libs = config.used_crates.clone(); - let libs = libs.move_iter().filter_map(|(_, l)| { + let libs = libs.iter_owned().filter_map(|(_, l)| { l.map(|p| p.clone()) }).collect::<Vec<_>>(); @@ -117,9 +117,9 @@ fn get_rpath_relative_to_output(config: &mut RPathConfig, abi::OsWin32 | abi::OsiOS => unreachable!() }; - let mut lib = (config.realpath)(&os::make_absolute(lib)).unwrap(); + let mut lib = (config.realpath)(&os::make_absolute(lib)).assert(); lib.pop(); - let mut output = (config.realpath)(&os::make_absolute(&config.out_filename)).unwrap(); + let mut output = (config.realpath)(&os::make_absolute(&config.out_filename)).assert(); output.pop(); let relative = lib.path_relative_from(&output); let relative = relative.expect("could not create rpath relative to output"); diff --git a/src/librustc_back/sha2.rs b/src/librustc_back/sha2.rs index d24ff49c61558..13a47fb4748f8 100644 --- a/src/librustc_back/sha2.rs +++ b/src/librustc_back/sha2.rs @@ -136,14 +136,14 @@ impl FixedBuffer for FixedBuffer64 { let buffer_remaining = size - self.buffer_idx; if input.len() >= buffer_remaining { copy_memory( - self.buffer.mut_slice(self.buffer_idx, size), + self.buffer.slice_mut(self.buffer_idx, size), input.slice_to(buffer_remaining)); self.buffer_idx = 0; func(self.buffer); i += buffer_remaining; } else { copy_memory( - self.buffer.mut_slice(self.buffer_idx, self.buffer_idx + input.len()), + self.buffer.slice_mut(self.buffer_idx, self.buffer_idx + input.len()), input); self.buffer_idx += input.len(); return; @@ -162,7 +162,7 @@ impl FixedBuffer for FixedBuffer64 { // be empty. let input_remaining = input.len() - i; copy_memory( - self.buffer.mut_slice(0, input_remaining), + self.buffer.slice_mut(0, input_remaining), input.slice_from(i)); self.buffer_idx += input_remaining; } @@ -173,13 +173,13 @@ impl FixedBuffer for FixedBuffer64 { fn zero_until(&mut self, idx: uint) { assert!(idx >= self.buffer_idx); - self.buffer.mut_slice(self.buffer_idx, idx).set_memory(0); + self.buffer.slice_mut(self.buffer_idx, idx).set_memory(0); self.buffer_idx = idx; } fn next<'s>(&'s mut self, len: uint) -> &'s mut [u8] { self.buffer_idx += len; - return self.buffer.mut_slice(self.buffer_idx - len, self.buffer_idx); + return self.buffer.slice_mut(self.buffer_idx - len, self.buffer_idx); } fn full_buffer<'s>(&'s mut self) -> &'s [u8] { @@ -359,7 +359,7 @@ impl Engine256State { ) ) - read_u32v_be(w.mut_slice(0, 16), data); + read_u32v_be(w.slice_mut(0, 16), data); // Putting the message schedule inside the same loop as the round calculations allows for // the compiler to generate better code. @@ -495,14 +495,14 @@ impl Digest for Sha256 { fn result(&mut self, out: &mut [u8]) { self.engine.finish(); - write_u32_be(out.mut_slice(0, 4), self.engine.state.h0); - write_u32_be(out.mut_slice(4, 8), self.engine.state.h1); - write_u32_be(out.mut_slice(8, 12), self.engine.state.h2); - write_u32_be(out.mut_slice(12, 16), self.engine.state.h3); - write_u32_be(out.mut_slice(16, 20), self.engine.state.h4); - write_u32_be(out.mut_slice(20, 24), self.engine.state.h5); - write_u32_be(out.mut_slice(24, 28), self.engine.state.h6); - write_u32_be(out.mut_slice(28, 32), self.engine.state.h7); + write_u32_be(out.slice_mut(0, 4), self.engine.state.h0); + write_u32_be(out.slice_mut(4, 8), self.engine.state.h1); + write_u32_be(out.slice_mut(8, 12), self.engine.state.h2); + write_u32_be(out.slice_mut(12, 16), self.engine.state.h3); + write_u32_be(out.slice_mut(16, 20), self.engine.state.h4); + write_u32_be(out.slice_mut(20, 24), self.engine.state.h5); + write_u32_be(out.slice_mut(24, 28), self.engine.state.h6); + write_u32_be(out.slice_mut(28, 32), self.engine.state.h7); } fn reset(&mut self) { @@ -630,8 +630,8 @@ mod tests { assert_eq!(expected, result_str.as_slice()); let expected_vec: Vec<u8> = expected.from_hex() - .unwrap() - .move_iter() + .assert() + .iter_owned() .collect(); assert_eq!(expected_vec, result_bytes); } diff --git a/src/librustdoc/clean/inline.rs b/src/librustdoc/clean/inline.rs index 3c942d0791e77..5d9f7b7fae367 100644 --- a/src/librustdoc/clean/inline.rs +++ b/src/librustdoc/clean/inline.rs @@ -41,7 +41,7 @@ use super::Clean; /// of a vector of items if it was successfully expanded. pub fn try_inline(id: ast::NodeId, into: Option<ast::Ident>) -> Option<Vec<clean::Item>> { - let cx = ::ctxtkey.get().unwrap(); + let cx = ::ctxtkey.get().assert(); let tcx = match cx.maybe_typed { core::Typed(ref tycx) => tycx, core::NotTyped(_) => return None, @@ -53,7 +53,7 @@ pub fn try_inline(id: ast::NodeId, into: Option<ast::Ident>) let did = def.def_id(); if ast_util::is_local(did) { return None } try_inline_def(&**cx, tcx, def).map(|vec| { - vec.move_iter().map(|mut item| { + vec.iter_owned().map(|mut item| { match into { Some(into) if item.name.is_some() => { item.name = Some(into.clean()); @@ -86,12 +86,12 @@ fn try_inline_def(cx: &core::DocContext, } def::DefStruct(did) => { record_extern_fqn(cx, did, clean::TypeStruct); - ret.extend(build_impls(cx, tcx, did).move_iter()); + ret.extend(build_impls(cx, tcx, did).iter_owned()); clean::StructItem(build_struct(tcx, did)) } def::DefTy(did) => { record_extern_fqn(cx, did, clean::TypeEnum); - ret.extend(build_impls(cx, tcx, did).move_iter()); + ret.extend(build_impls(cx, tcx, did).iter_owned()); build_type(tcx, did) } // Assume that the enum type is reexported next to the variant, and @@ -108,10 +108,10 @@ fn try_inline_def(cx: &core::DocContext, _ => return None, }; let fqn = csearch::get_item_path(tcx, did); - cx.inlined.borrow_mut().get_mut_ref().insert(did); + cx.inlined.borrow_mut().as_mut().assert().insert(did); ret.push(clean::Item { source: clean::Span::empty(), - name: Some(fqn.last().unwrap().to_string()), + name: Some(fqn.last().assert().to_string()), attrs: load_attrs(tcx, did), inner: inner, visibility: Some(ast::Public), @@ -124,7 +124,7 @@ fn try_inline_def(cx: &core::DocContext, pub fn load_attrs(tcx: &ty::ctxt, did: ast::DefId) -> Vec<clean::Attribute> { let mut attrs = Vec::new(); csearch::get_item_attrs(&tcx.sess.cstore, did, |v| { - attrs.extend(v.move_iter().map(|mut a| { + attrs.extend(v.iter_owned().map(|mut a| { // FIXME this isn't quite always true, it's just true about 99% of // the time when dealing with documentation. For example, // this would treat doc comments of the form `#[doc = "foo"]` @@ -148,8 +148,8 @@ pub fn record_extern_fqn(cx: &core::DocContext, match cx.maybe_typed { core::Typed(ref tcx) => { let fqn = csearch::get_item_path(tcx, did); - let fqn = fqn.move_iter().map(|i| i.to_string()).collect(); - cx.external_paths.borrow_mut().get_mut_ref().insert(did, (fqn, kind)); + let fqn = fqn.iter_owned().map(|i| i.to_string()).collect(); + cx.external_paths.borrow_mut().as_mut().assert().insert(did, (fqn, kind)); } core::NotTyped(..) => {} } @@ -159,7 +159,7 @@ pub fn build_external_trait(tcx: &ty::ctxt, did: ast::DefId) -> clean::Trait { let def = ty::lookup_trait_def(tcx, did); let methods = ty::trait_methods(tcx, did).clean(); let provided = ty::provided_trait_methods(tcx, did); - let mut methods = methods.move_iter().map(|meth| { + let mut methods = methods.iter_owned().map(|meth| { if provided.iter().any(|a| a.def_id == meth.def_id) { clean::Provided(meth) } else { @@ -279,13 +279,13 @@ fn build_impls(cx: &core::DocContext, } } - impls.move_iter().filter_map(|a| a).collect() + impls.iter_owned().filter_map(|a| a).collect() } fn build_impl(cx: &core::DocContext, tcx: &ty::ctxt, did: ast::DefId) -> Option<clean::Item> { - if !cx.inlined.borrow_mut().get_mut_ref().insert(did) { + if !cx.inlined.borrow_mut().as_mut().assert().insert(did) { return None } @@ -381,7 +381,7 @@ fn build_module(cx: &core::DocContext, tcx: &ty::ctxt, } decoder::DlDef(def) if vis == ast::Public => { match try_inline_def(cx, tcx, def) { - Some(i) => items.extend(i.move_iter()), + Some(i) => items.extend(i.iter_owned()), None => {} } } diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index a1f486b3b31b8..cf4b6be4fac4d 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -48,7 +48,7 @@ mod inline; // load the current DocContext from TLD fn get_cx() -> Gc<core::DocContext> { - *super::ctxtkey.get().unwrap() + *super::ctxtkey.get().assert() } // extract the stability index for a node from TLD, if possible @@ -150,7 +150,7 @@ impl<'a> Clean<Crate> for visit_ast::RustdocVisitor<'a> { _ => unreachable!(), }; let mut tmp = Vec::new(); - for child in m.items.mut_iter() { + for child in m.items.iter_mut() { let inner = match child.inner { ModuleItem(ref mut m) => m, _ => continue, @@ -179,7 +179,7 @@ impl<'a> Clean<Crate> for visit_ast::RustdocVisitor<'a> { inner.items.push(i); } - m.items.extend(tmp.move_iter()); + m.items.extend(tmp.iter_owned()); } Crate { @@ -336,13 +336,13 @@ pub struct Module { impl Clean<Item> for doctree::Module { fn clean(&self) -> Item { let name = if self.name.is_some() { - self.name.unwrap().clean() + self.name.assert().clean() } else { "".to_string() }; let mut foreigns = Vec::new(); - for subforeigns in self.foreigns.clean().move_iter() { - for foreign in subforeigns.move_iter() { + for subforeigns in self.foreigns.clean().iter_owned() { + for foreign in subforeigns.iter_owned() { foreigns.push(foreign) } } @@ -356,15 +356,15 @@ impl Clean<Item> for doctree::Module { self.statics.clean(), self.traits.clean(), self.impls.clean(), - self.view_items.clean().move_iter() - .flat_map(|s| s.move_iter()).collect(), + self.view_items.clean().iter_owned() + .flat_map(|s| s.iter_owned()).collect(), self.macros.clean(), ); // determine if we should display the inner contents or // the outer `mod` item for the source code. let where = { - let ctxt = super::ctxtkey.get().unwrap(); + let ctxt = super::ctxtkey.get().assert(); let cm = ctxt.sess().codemap(); let outer = cm.lookup_char_pos(self.where_outer.lo); let inner = cm.lookup_char_pos(self.where_inner.lo); @@ -468,7 +468,7 @@ impl Clean<TyParam> for ast::TyParam { impl Clean<TyParam> for ty::TypeParameterDef { fn clean(&self) -> TyParam { - get_cx().external_typarams.borrow_mut().get_mut_ref() + get_cx().external_typarams.borrow_mut().as_mut().assert() .insert(self.def_id, self.ident.clean()); TyParam { name: self.ident.clean(), @@ -527,21 +527,21 @@ impl Clean<TyParamBound> for ty::BuiltinBound { let (did, path) = match *self { ty::BoundStatic => return RegionBound, ty::BoundSend => - (tcx.lang_items.send_trait().unwrap(), + (tcx.lang_items.send_trait().assert(), external_path("Send", &empty)), ty::BoundSized => - (tcx.lang_items.sized_trait().unwrap(), + (tcx.lang_items.sized_trait().assert(), external_path("Sized", &empty)), ty::BoundCopy => - (tcx.lang_items.copy_trait().unwrap(), + (tcx.lang_items.copy_trait().assert(), external_path("Copy", &empty)), ty::BoundSync => - (tcx.lang_items.sync_trait().unwrap(), + (tcx.lang_items.sync_trait().assert(), external_path("Sync", &empty)), }; let fqn = csearch::get_item_path(tcx, did); - let fqn = fqn.move_iter().map(|i| i.to_string()).collect(); - cx.external_paths.borrow_mut().get_mut_ref().insert(did, + let fqn = fqn.iter_owned().map(|i| i.to_string()).collect(); + cx.external_paths.borrow_mut().as_mut().assert().insert(did, (fqn, TypeTrait)); TraitBound(ResolvedPath { path: path, @@ -559,11 +559,11 @@ impl Clean<TyParamBound> for ty::TraitRef { core::NotTyped(_) => return RegionBound, }; let fqn = csearch::get_item_path(tcx, self.def_id); - let fqn = fqn.move_iter().map(|i| i.to_string()) + let fqn = fqn.iter_owned().map(|i| i.to_string()) .collect::<Vec<String>>(); - let path = external_path(fqn.last().unwrap().as_slice(), + let path = external_path(fqn.last().assert().as_slice(), &self.substs); - cx.external_paths.borrow_mut().get_mut_ref().insert(self.def_id, + cx.external_paths.borrow_mut().as_mut().assert().insert(self.def_id, (fqn, TypeTrait)); TraitBound(ResolvedPath { path: path, @@ -849,9 +849,9 @@ impl<'a> Clean<FnDecl> for (ast::DefId, &'a ty::FnSig) { let cx = get_cx(); let (did, sig) = *self; let mut names = if did.node != 0 { - csearch::get_method_arg_names(&cx.tcx().sess.cstore, did).move_iter() + csearch::get_method_arg_names(&cx.tcx().sess.cstore, did).iter_owned() } else { - Vec::new().move_iter() + Vec::new().iter_owned() }.peekable(); if names.peek().map(|s| s.as_slice()) == Some("self") { let _ = names.next(); @@ -1263,7 +1263,7 @@ impl Clean<Type> for ty::t { ty::ty_enum(did, ref substs) | ty::ty_trait(box ty::TyTrait { def_id: did, ref substs, .. }) => { let fqn = csearch::get_item_path(get_cx().tcx(), did); - let fqn: Vec<String> = fqn.move_iter().map(|i| { + let fqn: Vec<String> = fqn.iter_owned().map(|i| { i.to_string() }).collect(); let kind = match ty::get(*self).sty { @@ -1271,9 +1271,9 @@ impl Clean<Type> for ty::t { ty::ty_trait(..) => TypeTrait, _ => TypeEnum, }; - let path = external_path(fqn.last().unwrap().to_string().as_slice(), + let path = external_path(fqn.last().assert().to_string().as_slice(), substs); - get_cx().external_paths.borrow_mut().get_mut_ref() + get_cx().external_paths.borrow_mut().as_mut().assert() .insert(did, (fqn, kind)); ResolvedPath { path: path, @@ -1337,7 +1337,7 @@ impl Clean<Item> for ty::field_ty { attrs = None; None } else { - attrs = Some(attr_map.find(&self.id.node).unwrap()); + attrs = Some(attr_map.find(&self.id.node).assert()); Some(self.name) }; @@ -1547,7 +1547,7 @@ impl Span { impl Clean<Span> for syntax::codemap::Span { fn clean(&self) -> Span { - let ctxt = super::ctxtkey.get().unwrap(); + let ctxt = super::ctxtkey.get().assert(); let cm = ctxt.sess().codemap(); let filename = cm.span_to_filename(*self); let lo = cm.lookup_char_pos(self.lo); @@ -1781,7 +1781,7 @@ impl Clean<Vec<Item>> for ast::ViewItem { let remaining = list.iter().filter(|path| { match inline::try_inline(path.node.id(), None) { Some(items) => { - ret.extend(items.move_iter()); false + ret.extend(items.iter_owned()); false } None => true, } @@ -1796,7 +1796,7 @@ impl Clean<Vec<Item>> for ast::ViewItem { } ast::ViewPathSimple(ident, _, id) => { match inline::try_inline(id, Some(ident)) { - Some(items) => ret.extend(items.move_iter()), + Some(items) => ret.extend(items.iter_owned()), None => ret.push(convert(&self.node)), } } @@ -1928,7 +1928,7 @@ trait ToSource { impl ToSource for syntax::codemap::Span { fn to_src(&self) -> String { debug!("converting span {:?} to snippet", self.clean()); - let ctxt = super::ctxtkey.get().unwrap(); + let ctxt = super::ctxtkey.get().assert(); let cm = ctxt.sess().codemap().clone(); let sn = match cm.span_to_snippet(*self) { Some(x) => x.to_string(), @@ -2060,7 +2060,7 @@ fn register_def(cx: &core::DocContext, def: def::Def) -> ast::DefId { match kind { TypeTrait => { let t = inline::build_external_trait(tcx, did); - cx.external_traits.borrow_mut().get_mut_ref().insert(did, t); + cx.external_traits.borrow_mut().as_mut().assert().insert(did, t); } _ => {} } @@ -2124,10 +2124,10 @@ fn lang_struct(did: Option<ast::DefId>, t: ty::t, name: &str, None => return fallback(box t.clean()), }; let fqn = csearch::get_item_path(get_cx().tcx(), did); - let fqn: Vec<String> = fqn.move_iter().map(|i| { + let fqn: Vec<String> = fqn.iter_owned().map(|i| { i.to_string() }).collect(); - get_cx().external_paths.borrow_mut().get_mut_ref() + get_cx().external_paths.borrow_mut().as_mut().assert() .insert(did, (fqn, TypeStruct)); ResolvedPath { typarams: None, diff --git a/src/librustdoc/core.rs b/src/librustdoc/core.rs index 032189dca4877..bfa56911b7014 100644 --- a/src/librustdoc/core.rs +++ b/src/librustdoc/core.rs @@ -95,7 +95,7 @@ fn get_ast_and_resolve(cpath: &Path, libs: HashSet<Path>, cfgs: Vec<String>, let warning_lint = lint::builtin::WARNINGS.name_lower(); let sessopts = driver::config::Options { - maybe_sysroot: Some(os::self_exe_path().unwrap().dir_path()), + maybe_sysroot: Some(os::self_exe_path().assert().dir_path()), addl_lib_search_paths: RefCell::new(libs), crate_types: vec!(driver::config::CrateTypeRlib), lint_opts: vec!((warning_lint, lint::Allow)), @@ -115,7 +115,7 @@ fn get_ast_and_resolve(cpath: &Path, libs: HashSet<Path>, cfgs: Vec<String>, span_diagnostic_handler); let mut cfg = build_configuration(&sess); - for cfg_ in cfgs.move_iter() { + for cfg_ in cfgs.iter_owned() { let cfg_ = token::intern_and_get_ident(cfg_.as_slice()); cfg.push(box(GC) dummy_spanned(ast::MetaWord(cfg_))); } diff --git a/src/librustdoc/flock.rs b/src/librustdoc/flock.rs index cb8be9c899757..8ceb15a03d8a6 100644 --- a/src/librustdoc/flock.rs +++ b/src/librustdoc/flock.rs @@ -183,7 +183,7 @@ mod imp { impl Lock { pub fn new(p: &Path) -> Lock { - let p_16: Vec<u16> = p.as_str().unwrap().utf16_units().collect(); + let p_16: Vec<u16> = p.as_str().assert().utf16_units().collect(); let p_16 = p_16.append_one(0); let handle = unsafe { libc::CreateFileW(p_16.as_ptr(), @@ -192,10 +192,10 @@ mod imp { libc::FILE_SHARE_READ | libc::FILE_SHARE_DELETE | libc::FILE_SHARE_WRITE, - ptr::mut_null(), + ptr::null_mut(), libc::CREATE_ALWAYS, libc::FILE_ATTRIBUTE_NORMAL, - ptr::mut_null()) + ptr::null_mut()) }; if handle == libc::INVALID_HANDLE_VALUE { fail!("create file error: {}", os::last_os_error()); diff --git a/src/librustdoc/fold.rs b/src/librustdoc/fold.rs index 60853f450ab32..48175de694b4c 100644 --- a/src/librustdoc/fold.rs +++ b/src/librustdoc/fold.rs @@ -25,7 +25,7 @@ pub trait DocFolder { StructItem(mut i) => { let mut foo = Vec::new(); swap(&mut foo, &mut i.fields); let num_fields = foo.len(); - i.fields.extend(foo.move_iter().filter_map(|x| self.fold_item(x))); + i.fields.extend(foo.iter_owned().filter_map(|x| self.fold_item(x))); i.fields_stripped |= num_fields != i.fields.len(); StructItem(i) }, @@ -35,7 +35,7 @@ pub trait DocFolder { EnumItem(mut i) => { let mut foo = Vec::new(); swap(&mut foo, &mut i.variants); let num_variants = foo.len(); - i.variants.extend(foo.move_iter().filter_map(|x| self.fold_item(x))); + i.variants.extend(foo.iter_owned().filter_map(|x| self.fold_item(x))); i.variants_stripped |= num_variants != i.variants.len(); EnumItem(i) }, @@ -57,12 +57,12 @@ pub trait DocFolder { } } let mut foo = Vec::new(); swap(&mut foo, &mut i.methods); - i.methods.extend(foo.move_iter().filter_map(|x| vtrm(self, x))); + i.methods.extend(foo.iter_owned().filter_map(|x| vtrm(self, x))); TraitItem(i) }, ImplItem(mut i) => { let mut foo = Vec::new(); swap(&mut foo, &mut i.methods); - i.methods.extend(foo.move_iter().filter_map(|x| self.fold_item(x))); + i.methods.extend(foo.iter_owned().filter_map(|x| self.fold_item(x))); ImplItem(i) }, VariantItem(i) => { @@ -72,7 +72,7 @@ pub trait DocFolder { 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(foo.move_iter().filter_map(c)); + j.fields.extend(foo.iter_owned().filter_map(c)); j.fields_stripped |= num_fields != j.fields.len(); VariantItem(Variant {kind: StructVariant(j), ..i2}) }, @@ -89,7 +89,7 @@ pub trait DocFolder { fn fold_mod(&mut self, m: Module) -> Module { Module { is_crate: m.is_crate, - items: m.items.move_iter().filter_map(|i| self.fold_item(i)).collect() + items: m.items.iter_owned().filter_map(|i| self.fold_item(i)).collect() } } diff --git a/src/librustdoc/html/format.rs b/src/librustdoc/html/format.rs index 2fb3143b0bf6e..f630d2c9e293a 100644 --- a/src/librustdoc/html/format.rs +++ b/src/librustdoc/html/format.rs @@ -190,7 +190,7 @@ fn path(w: &mut fmt::Formatter, path: &clean::Path, print_all: bool, { // The generics will get written to both the title and link let mut generics = String::new(); - let last = path.segments.last().unwrap(); + let last = path.segments.last().assert(); if last.lifetimes.len() > 0 || last.types.len() > 0 { let mut counter = 0u; generics.push_str("<"); @@ -207,8 +207,8 @@ fn path(w: &mut fmt::Formatter, path: &clean::Path, print_all: bool, generics.push_str(">"); } - let loc = current_location_key.get().unwrap(); - let cache = cache_key.get().unwrap(); + let loc = current_location_key.get().assert(); + let cache = cache_key.get().assert(); let abs_root = root(&**cache, loc.as_slice()); let rel_root = match path.segments[0].name.as_slice() { "self" => Some("./".to_string()), @@ -245,7 +245,7 @@ fn path(w: &mut fmt::Formatter, path: &clean::Path, print_all: bool, match info(&**cache) { // This is a documented path, link to it! Some((ref fqp, shortty)) if abs_root.is_some() => { - let mut url = String::from_str(abs_root.unwrap().as_slice()); + let mut url = String::from_str(abs_root.assert().as_slice()); let to_link = fqp.slice_to(fqp.len() - 1); for component in to_link.iter() { url.push_str(component.as_slice()); @@ -253,13 +253,13 @@ fn path(w: &mut fmt::Formatter, path: &clean::Path, print_all: bool, } match shortty { item_type::Module => { - url.push_str(fqp.last().unwrap().as_slice()); + url.push_str(fqp.last().assert().as_slice()); url.push_str("/index.html"); } _ => { url.push_str(shortty.to_static_str()); url.push_str("."); - url.push_str(fqp.last().unwrap().as_slice()); + url.push_str(fqp.last().assert().as_slice()); url.push_str(".html"); } } @@ -279,11 +279,11 @@ fn path(w: &mut fmt::Formatter, path: &clean::Path, print_all: bool, fn primitive_link(f: &mut fmt::Formatter, prim: clean::Primitive, name: &str) -> fmt::Result { - let m = cache_key.get().unwrap(); + let m = cache_key.get().assert(); let mut needs_termination = false; match m.primitive_locations.find(&prim) { Some(&ast::LOCAL_CRATE) => { - let loc = current_location_key.get().unwrap(); + let loc = current_location_key.get().assert(); let len = if loc.len() == 0 {0} else {loc.len() - 1}; try!(write!(f, "<a href='{}primitive.{}.html'>", "../".repeat(len), @@ -298,7 +298,7 @@ fn primitive_link(f: &mut fmt::Formatter, let loc = match *m.extern_locations.get(&cnum) { render::Remote(ref s) => Some(s.to_string()), render::Local => { - let loc = current_location_key.get().unwrap(); + let loc = current_location_key.get().assert(); Some("../".repeat(loc.len())) } render::Unknown => None, @@ -307,7 +307,7 @@ fn primitive_link(f: &mut fmt::Formatter, Some(root) => { try!(write!(f, "<a href='{}{}/primitive.{}.html'>", root, - path.ref0().as_slice().head().unwrap(), + path.ref0().as_slice().head().assert(), prim.to_url_str())); needs_termination = true; } @@ -342,11 +342,11 @@ impl fmt::Show for clean::Type { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match *self { clean::TyParamBinder(id) => { - let m = cache_key.get().unwrap(); + let m = cache_key.get().assert(); f.write(m.typarams.get(&ast_util::local_def(id)).as_bytes()) } clean::Generic(did) => { - let m = cache_key.get().unwrap(); + let m = cache_key.get().assert(); f.write(m.typarams.get(&did).as_bytes()) } clean::ResolvedPath{ did, ref typarams, ref path } => { @@ -542,7 +542,7 @@ impl fmt::Show for clean::ViewPath { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match *self { clean::SimpleImport(ref name, ref src) => { - if *name == src.path.segments.last().unwrap().name { + if *name == src.path.segments.last().assert().name { write!(f, "use {};", *src) } else { write!(f, "use {} = {};", *name, *src) diff --git a/src/librustdoc/html/highlight.rs b/src/librustdoc/html/highlight.rs index ecdc736790dbe..1c239797b0482 100644 --- a/src/librustdoc/html/highlight.rs +++ b/src/librustdoc/html/highlight.rs @@ -35,7 +35,7 @@ pub fn highlight(src: &str, class: Option<&str>, id: Option<&str>) -> String { lexer::StringReader::new(&sess.span_diagnostic, fm), class, id, - &mut out).unwrap(); + &mut out).assert(); String::from_utf8_lossy(out.unwrap().as_slice()).into_string() } @@ -63,7 +63,7 @@ fn doit(sess: &parse::ParseSess, mut lexer: lexer::StringReader, loop { let next = lexer.next_token(); - let snip = |sp| sess.span_diagnostic.cm.span_to_snippet(sp).unwrap(); + let snip = |sp| sess.span_diagnostic.cm.span_to_snippet(sp).assert(); if next.tok == t::EOF { break } @@ -169,7 +169,7 @@ fn doit(sess: &parse::ParseSess, mut lexer: lexer::StringReader, // as mentioned above, use the original source code instead of // stringifying this token - let snip = sess.span_diagnostic.cm.span_to_snippet(next.sp).unwrap(); + let snip = sess.span_diagnostic.cm.span_to_snippet(next.sp).assert(); if klass == "" { try!(write!(out, "{}", Escape(snip.as_slice()))); } else { diff --git a/src/librustdoc/html/markdown.rs b/src/librustdoc/html/markdown.rs index 97fa58d507774..a0ada3c01732f 100644 --- a/src/librustdoc/html/markdown.rs +++ b/src/librustdoc/html/markdown.rs @@ -157,7 +157,7 @@ pub fn render(w: &mut fmt::Formatter, s: &str, print_toc: bool) -> fmt::Result { let opaque = opaque as *mut hoedown_html_renderer_state; let my_opaque: &MyOpaque = &*((*opaque).opaque as *const MyOpaque); slice::raw::buf_as_slice((*text).data, (*text).size as uint, |text| { - let origtext = str::from_utf8(text).unwrap(); + let origtext = str::from_utf8(text).assert(); debug!("docblock: ==============\n{}\n=======", text); let mut lines = origtext.lines().filter(|l| { stripped_filtered_line(*l).is_none() @@ -175,7 +175,7 @@ pub fn render(w: &mut fmt::Formatter, s: &str, print_toc: bool) -> fmt::Result { } else { slice::raw::buf_as_slice((*lang).data, (*lang).size as uint, |rlang| { - let rlang = str::from_utf8(rlang).unwrap(); + let rlang = str::from_utf8(rlang).assert(); if LangString::parse(rlang).notrust { (my_opaque.dfltblk)(ob, &buf, lang, opaque as *mut libc::c_void); @@ -189,7 +189,7 @@ pub fn render(w: &mut fmt::Formatter, s: &str, print_toc: bool) -> fmt::Result { if !rendered { let mut s = String::new(); let id = playground_krate.get().map(|krate| { - let idx = test_idx.get().unwrap(); + let idx = test_idx.get().assert(); let i = idx.get(); idx.set(i + 1); @@ -243,7 +243,7 @@ pub fn render(w: &mut fmt::Formatter, s: &str, print_toc: bool) -> fmt::Result { let opaque = unsafe { &mut *((*opaque).opaque as *mut MyOpaque) }; // Make sure our hyphenated ID is unique for this page - let map = used_header_map.get().unwrap(); + let map = used_header_map.get().assert(); let id = match map.borrow_mut().find_mut(&id) { None => id, Some(a) => { *a += 1; format!("{}-{}", id, *a - 1) } @@ -274,7 +274,7 @@ pub fn render(w: &mut fmt::Formatter, s: &str, print_toc: bool) -> fmt::Result { let ob = hoedown_buffer_new(DEF_OUNIT); let renderer = hoedown_html_renderer_new(0, 0); let mut opaque = MyOpaque { - dfltblk: (*renderer).blockcode.unwrap(), + dfltblk: (*renderer).blockcode.assert(), toc_builder: if print_toc {Some(TocBuilder::new())} else {None} }; (*(*renderer).opaque).opaque = &mut opaque as *mut _ as *mut libc::c_void; @@ -315,7 +315,7 @@ pub fn find_testable_code(doc: &str, tests: &mut ::test::Collector) { } else { slice::raw::buf_as_slice((*lang).data, (*lang).size as uint, |lang| { - let s = str::from_utf8(lang).unwrap(); + let s = str::from_utf8(lang).assert(); LangString::parse(s) }) }; @@ -323,7 +323,7 @@ pub fn find_testable_code(doc: &str, tests: &mut ::test::Collector) { slice::raw::buf_as_slice((*text).data, (*text).size as uint, |text| { let opaque = opaque as *mut hoedown_html_renderer_state; let tests = &mut *((*opaque).opaque as *mut ::test::Collector); - let text = str::from_utf8(text).unwrap(); + let text = str::from_utf8(text).assert(); let mut lines = text.lines().map(|l| { stripped_filtered_line(l).unwrap_or(l) }); @@ -345,7 +345,7 @@ pub fn find_testable_code(doc: &str, tests: &mut ::test::Collector) { tests.register_header("", level as u32); } else { slice::raw::buf_as_slice((*text).data, (*text).size as uint, |text| { - let text = str::from_utf8(text).unwrap(); + let text = str::from_utf8(text).assert(); tests.register_header(text, level as u32); }) } diff --git a/src/librustdoc/html/render.rs b/src/librustdoc/html/render.rs index eea594550398b..229b055683206 100644 --- a/src/librustdoc/html/render.rs +++ b/src/librustdoc/html/render.rs @@ -296,8 +296,8 @@ pub fn run(mut krate: clean::Crate, external_html: &ExternalHtml, dst: Path) -> let public_items = public_items.unwrap_or(NodeSet::new()); let paths: HashMap<ast::DefId, (Vec<String>, ItemType)> = analysis.as_ref().map(|a| { - let paths = a.external_paths.borrow_mut().take_unwrap(); - paths.move_iter().map(|(k, (v, t))| { + let paths = a.external_paths.borrow_mut().take().assert(); + paths.iter_owned().map(|(k, (v, t))| { (k, (v, match t { clean::TypeStruct => item_type::Struct, clean::TypeEnum => item_type::Enum, @@ -324,13 +324,13 @@ pub fn run(mut krate: clean::Crate, external_html: &ExternalHtml, dst: Path) -> public_items: public_items, orphan_methods: Vec::new(), traits: analysis.as_ref().map(|a| { - a.external_traits.borrow_mut().take_unwrap() + a.external_traits.borrow_mut().take().assert() }).unwrap_or(HashMap::new()), typarams: analysis.as_ref().map(|a| { - a.external_typarams.borrow_mut().take_unwrap() + a.external_typarams.borrow_mut().take().assert() }).unwrap_or(HashMap::new()), inlined: analysis.as_ref().map(|a| { - a.inlined.borrow_mut().take_unwrap() + a.inlined.borrow_mut().take().assert() }).unwrap_or(HashSet::new()), }; cache.stack.push(krate.name.clone()); @@ -389,7 +389,7 @@ fn build_index(krate: &clean::Crate, cache: &mut Cache) -> io::IoResult<String> Some(&(ref fqp, _)) => { search_index.push(IndexItem { ty: shortty(item), - name: item.name.clone().unwrap(), + name: item.name.clone().assert(), path: fqp.slice_to(fqp.len() - 1).connect("::"), desc: shorter(item.doc_value()).to_string(), parent: Some(did), @@ -439,7 +439,7 @@ fn build_index(krate: &clean::Crate, cache: &mut Cache) -> io::IoResult<String> item.desc.to_json().to_string())); match item.parent { Some(nodeid) => { - let pathid = *nodeid_to_pathid.find(&nodeid).unwrap(); + let pathid = *nodeid_to_pathid.find(&nodeid).assert(); try!(write!(&mut w, ",{}", pathid)); } None => {} @@ -450,17 +450,17 @@ fn build_index(krate: &clean::Crate, cache: &mut Cache) -> io::IoResult<String> try!(write!(&mut w, r#"],"paths":["#)); for (i, &did) in pathid_to_nodeid.iter().enumerate() { - let &(ref fqp, short) = cache.paths.find(&did).unwrap(); + let &(ref fqp, short) = cache.paths.find(&did).assert(); if i > 0 { try!(write!(&mut w, ",")); } try!(write!(&mut w, r#"[{:u},"{}"]"#, - short, *fqp.last().unwrap())); + short, *fqp.last().assert())); } try!(write!(&mut w, "]}};")); - Ok(String::from_utf8(w.unwrap()).unwrap()) + Ok(String::from_utf8(w.unwrap()).assert()) } fn write_shared(cx: &Context, @@ -627,7 +627,7 @@ fn mkdir(path: &Path) -> io::IoResult<()> { fn clean_srcpath(src: &[u8], f: |&str|) { let p = Path::new(src); if p.as_vec() != b"." { - for c in p.str_components().map(|x|x.unwrap()) { + for c in p.str_components().map(|x|x.assert()) { if ".." == c { f("up"); } else { @@ -719,7 +719,7 @@ impl<'a> SourceCollector<'a> { filename.ends_with("macros>") => return Ok(()), Err(e) => return Err(e) }; - let contents = str::from_utf8(contents.as_slice()).unwrap(); + let contents = str::from_utf8(contents.as_slice()).assert(); // Remove the utf-8 BOM if any let contents = if contents.starts_with("\ufeff") { @@ -733,7 +733,7 @@ impl<'a> SourceCollector<'a> { let mut root_path = String::from_str("../../"); clean_srcpath(p.dirname(), |component| { cur.push(component); - mkdir(&cur).unwrap(); + mkdir(&cur).assert(); root_path.push_str("../"); }); @@ -804,7 +804,7 @@ impl DocFolder for Cache { v.push(Implementor { def_id: item.def_id, generics: i.generics.clone(), - trait_: i.trait_.get_ref().clone(), + trait_: i.trait_.as_ref().assert().clone(), for_: i.for_.clone(), stability: item.stability.clone(), }); @@ -822,14 +822,14 @@ impl DocFolder for Cache { clean::TyMethodItem(..) | clean::StructFieldItem(..) | clean::VariantItem(..) => { - (Some(*self.parent_stack.last().unwrap()), + (Some(*self.parent_stack.last().assert()), Some(self.stack.slice_to(self.stack.len() - 1))) } clean::MethodItem(..) => { if self.parent_stack.len() == 0 { (None, None) } else { - let last = self.parent_stack.last().unwrap(); + let last = self.parent_stack.last().assert(); let did = *last; let path = match self.paths.find(&did) { Some(&(_, item_type::Trait)) => @@ -877,7 +877,7 @@ impl DocFolder for Cache { // Keep track of the fully qualified path for this item. let pushed = if item.name.is_some() { - let n = item.name.get_ref(); + let n = item.name.as_ref().assert(); if n.len() > 0 { self.stack.push(n.to_string()); true @@ -946,7 +946,7 @@ impl DocFolder for Cache { use clean::{FixedVector, Slice, Tuple, PrimitiveTuple}; // extract relevant documentation for this impl - let dox = match attrs.move_iter().find(|a| { + let dox = match attrs.iter_owned().find(|a| { match *a { clean::NameValue(ref x, _) if "doc" == x.as_slice() => { @@ -1013,8 +1013,8 @@ impl DocFolder for Cache { i => i, }; - if pushed { self.stack.pop().unwrap(); } - if parent_pushed { self.parent_stack.pop().unwrap(); } + if pushed { self.stack.pop().assert(); } + if parent_pushed { self.parent_stack.pop().assert(); } self.privmod = orig_privmod; return ret; } @@ -1042,7 +1042,7 @@ impl Context { info!("Recursing into {}", self.dst.display()); - mkdir(&self.dst).unwrap(); + mkdir(&self.dst).assert(); let ret = f(self); info!("Recursed; leaving {}", self.dst.display()); @@ -1051,7 +1051,7 @@ impl Context { self.dst = prev; let len = self.root_path.len(); self.root_path.truncate(len - 3); - self.current.pop().unwrap(); + self.current.pop().assert(); return ret; } @@ -1124,7 +1124,7 @@ impl Context { if title.len() > 0 { title.push_str("::"); } - title.push_str(it.name.get_ref().as_slice()); + title.push_str(it.name.as_ref().assert().as_slice()); } title.push_str(" - Rust"); let tyname = shortty(it).to_static_str(); @@ -1137,7 +1137,7 @@ impl Context { cx.layout.krate) } else { format!("API documentation for the Rust `{}` {} in crate `{}`.", - it.name.get_ref(), tyname, cx.layout.krate) + it.name.as_ref().assert(), tyname, cx.layout.krate) }; let keywords = make_item_keywords(it); let page = layout::Page { @@ -1160,7 +1160,7 @@ impl Context { &Item{ cx: cx, item: it })); } else { let mut url = "../".repeat(cx.current.len()); - match cache_key.get().unwrap().paths.find(&it.def_id) { + match cache_key.get().assert().paths.find(&it.def_id) { Some(&(ref names, _)) => { for name in names.slice_to(names.len() - 1).iter() { url.push_str(name.as_slice()); @@ -1190,10 +1190,10 @@ impl Context { // modules are special because they add a namespace. We also need to // recurse into the items of the module as well. clean::ModuleItem(..) => { - let name = item.name.get_ref().to_string(); + let name = item.name.as_ref().assert().to_string(); let mut item = Some(item); self.recurse(name, |this| { - let item = item.take_unwrap(); + let item = item.take().assert(); let dst = this.dst.join("index.html"); let dst = try!(File::create(&dst)); try!(render(dst, this, &item, false)); @@ -1203,7 +1203,7 @@ impl Context { _ => unreachable!() }; this.sidebar = build_sidebar(&m); - for item in m.items.move_iter() { + for item in m.items.iter_owned() { f(this,item); } Ok(()) @@ -1273,7 +1273,7 @@ impl<'a> Item<'a> { // If we don't know where the external documentation for this crate is // located, then we return `None`. } else { - let cache = cache_key.get().unwrap(); + let cache = cache_key.get().assert(); let path = cache.external_paths.get(&self.item.def_id); let root = match *cache.extern_locations.get(&self.item.def_id.krate) { Remote(ref s) => s.to_string(), @@ -1322,7 +1322,7 @@ impl<'a> fmt::Show for Item<'a> { } } try!(write!(fmt, "<a class='{}' href=''>{}</a>", - shortty(self.item), self.item.name.get_ref().as_slice())); + shortty(self.item), self.item.name.as_ref().assert().as_slice())); // Write stability level try!(write!(fmt, "​{}", Stability(&self.item.stability))); @@ -1384,12 +1384,12 @@ impl<'a> fmt::Show for Item<'a> { fn item_path(item: &clean::Item) -> String { match item.inner { clean::ModuleItem(..) => { - format!("{}/index.html", item.name.get_ref()) + format!("{}/index.html", item.name.as_ref().assert()) } _ => { format!("{}.{}.html", shortty(item).to_static_str(), - *item.name.get_ref()) + *item.name.as_ref().assert()) } } } @@ -1397,7 +1397,7 @@ fn item_path(item: &clean::Item) -> String { fn full_path(cx: &Context, item: &clean::Item) -> String { let mut s = cx.current.connect("::"); s.push_str("::"); - s.push_str(item.name.get_ref().as_slice()); + s.push_str(item.name.as_ref().assert().as_slice()); return s } @@ -1545,7 +1545,7 @@ fn item_module(w: &mut fmt::Formatter, cx: &Context, ConciseStability(&myitem.stability), VisSpace(myitem.visibility), MutableSpace(s.mutability), - *myitem.name.get_ref(), + *myitem.name.as_ref().assert(), s.type_, Initializer(s.expr.as_slice(), Item { cx: cx, item: myitem }), Markdown(blank(myitem.doc_value())))); @@ -1582,7 +1582,7 @@ fn item_module(w: &mut fmt::Formatter, cx: &Context, <td class='docblock short'>{}</td> </tr> ", - *myitem.name.get_ref(), + *myitem.name.as_ref().assert(), Markdown(shorter(myitem.doc_value())), class = shortty(myitem), href = item_path(myitem), @@ -1601,7 +1601,7 @@ fn item_function(w: &mut fmt::Formatter, it: &clean::Item, {name}{generics}{decl}</pre>", vis = VisSpace(it.visibility), fn_style = FnStyleSpace(f.fn_style), - name = it.name.get_ref().as_slice(), + name = it.name.as_ref().assert().as_slice(), generics = f.generics, decl = f.decl)); document(w, it) @@ -1621,7 +1621,7 @@ fn item_trait(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item, // Output the trait definition try!(write!(w, "<pre class='rust trait'>{}trait {}{}{} ", VisSpace(it.visibility), - it.name.get_ref().as_slice(), + it.name.as_ref().assert().as_slice(), t.generics, parents)); let required = t.methods.iter().filter(|m| m.is_req()).collect::<Vec<&clean::TraitMethod>>(); @@ -1654,7 +1654,7 @@ fn item_trait(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item, fn meth(w: &mut fmt::Formatter, m: &clean::TraitMethod) -> fmt::Result { try!(write!(w, "<h3 id='{}.{}' class='method'>{}<code>", shortty(m.item()), - *m.item().name.get_ref(), + *m.item().name.as_ref().assert(), ConciseStability(&m.item().stability))); try!(render_method(w, m.item())); try!(write!(w, "</code></h3>")); @@ -1684,7 +1684,7 @@ fn item_trait(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item, try!(write!(w, "</div>")); } - let cache = cache_key.get().unwrap(); + let cache = cache_key.get().assert(); try!(write!(w, " <h2 id='implementors'>Implementors</h2> <ul class='item-list' id='implementors-list'> @@ -1711,7 +1711,7 @@ fn item_trait(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item, path.slice_to(path.len() - 1).connect("/") }, ty = shortty(it).to_static_str(), - name = *it.name.get_ref())); + name = *it.name.as_ref().assert())); Ok(()) } @@ -1726,7 +1726,7 @@ fn render_method(w: &mut fmt::Formatter, meth: &clean::Item) -> fmt::Result { _ => "", }, ty = shortty(it), - name = it.name.get_ref().as_slice(), + name = it.name.as_ref().assert().as_slice(), generics = *g, decl = Method(selfty, d)) } @@ -1769,7 +1769,7 @@ fn item_struct(w: &mut fmt::Formatter, it: &clean::Item, try!(write!(w, "<tr><td id='structfield.{name}'>\ {stab}<code>{name}</code></td><td>", stab = ConciseStability(&field.stability), - name = field.name.get_ref().as_slice())); + name = field.name.as_ref().assert().as_slice())); try!(document(w, field)); try!(write!(w, "</td></tr>")); } @@ -1785,7 +1785,7 @@ fn item_enum(w: &mut fmt::Formatter, it: &clean::Item, e: &clean::Enum) -> fmt::Result { try!(write!(w, "<pre class='rust enum'>{}enum {}{}", VisSpace(it.visibility), - it.name.get_ref().as_slice(), + it.name.as_ref().assert().as_slice(), e.generics)); if e.variants.len() == 0 && !e.variants_stripped { try!(write!(w, " {{}}")); @@ -1793,7 +1793,7 @@ fn item_enum(w: &mut fmt::Formatter, it: &clean::Item, try!(write!(w, " {{\n")); for v in e.variants.iter() { try!(write!(w, " ")); - let name = v.name.get_ref().as_slice(); + let name = v.name.as_ref().assert().as_slice(); match v.inner { clean::VariantItem(ref var) => { match var.kind { @@ -1837,7 +1837,7 @@ fn item_enum(w: &mut fmt::Formatter, it: &clean::Item, for variant in e.variants.iter() { try!(write!(w, "<tr><td id='variant.{name}'>{stab}<code>{name}</code></td><td>", stab = ConciseStability(&variant.stability), - name = variant.name.get_ref().as_slice())); + name = variant.name.as_ref().assert().as_slice())); try!(document(w, variant)); match variant.inner { clean::VariantItem(ref var) => { @@ -1858,8 +1858,8 @@ fn item_enum(w: &mut fmt::Formatter, it: &clean::Item, try!(write!(w, "<tr><td \ id='variant.{v}.field.{f}'>\ <code>{f}</code></td><td>", - v = variant.name.get_ref().as_slice(), - f = field.name.get_ref().as_slice())); + v = variant.name.as_ref().assert().as_slice(), + f = field.name.as_ref().assert().as_slice())); try!(document(w, field)); try!(write!(w, "</td></tr>")); } @@ -1888,7 +1888,7 @@ fn render_struct(w: &mut fmt::Formatter, it: &clean::Item, try!(write!(w, "{}{}{}", VisSpace(it.visibility), if structhead {"struct "} else {""}, - it.name.get_ref().as_slice())); + it.name.as_ref().assert().as_slice())); match g { Some(g) => try!(write!(w, "{}", *g)), None => {} @@ -1905,7 +1905,7 @@ fn render_struct(w: &mut fmt::Formatter, it: &clean::Item, clean::StructFieldItem(clean::TypedStructField(ref ty)) => { try!(write!(w, " {}{}: {},\n{}", VisSpace(field.visibility), - field.name.get_ref().as_slice(), + field.name.as_ref().assert().as_slice(), *ty, tab)); } @@ -1944,7 +1944,7 @@ fn render_struct(w: &mut fmt::Formatter, it: &clean::Item, } fn render_methods(w: &mut fmt::Formatter, it: &clean::Item) -> fmt::Result { - match cache_key.get().unwrap().impls.find(&it.def_id) { + match cache_key.get().assert().impls.find(&it.def_id) { Some(v) => { let (non_trait, traits) = v.partitioned(|i| i.impl_.trait_.is_none()); if non_trait.len() > 0 { @@ -1994,7 +1994,7 @@ fn render_impl(w: &mut fmt::Formatter, i: &Impl) -> fmt::Result { fn docmeth(w: &mut fmt::Formatter, item: &clean::Item, dox: bool) -> fmt::Result { try!(write!(w, "<h4 id='method.{}' class='method'>{}<code>", - *item.name.get_ref(), + *item.name.as_ref().assert(), ConciseStability(&item.stability))); try!(render_method(w, item)); try!(write!(w, "</code></h4>\n")); @@ -2032,7 +2032,7 @@ fn render_impl(w: &mut fmt::Formatter, i: &Impl) -> fmt::Result { match i.impl_.trait_ { Some(clean::ResolvedPath { did, .. }) => { try!({ - match cache_key.get().unwrap().traits.find(&did) { + match cache_key.get().assert().traits.find(&did) { Some(t) => try!(render_default_methods(w, t, &i.impl_)), None => {} } @@ -2048,7 +2048,7 @@ fn render_impl(w: &mut fmt::Formatter, i: &Impl) -> fmt::Result { fn item_typedef(w: &mut fmt::Formatter, it: &clean::Item, t: &clean::Typedef) -> fmt::Result { try!(write!(w, "<pre class='rust typedef'>type {}{} = {};</pre>", - it.name.get_ref().as_slice(), + it.name.as_ref().assert().as_slice(), t.generics, t.type_)); @@ -2082,7 +2082,7 @@ impl<'a> fmt::Show for Sidebar<'a> { try!(write!(w, "<div class='block {}'><h2>{}</h2>", short, longty)); for item in items.iter() { let curty = shortty(cur).to_static_str(); - let class = if cur.name.get_ref() == item && + let class = if cur.name.as_ref().assert() == item && short == curty { "current" } else { "" }; try!(write!(w, "<a class='{ty} {class}' href='{href}{path}'>\ {name}</a>", @@ -2124,7 +2124,7 @@ fn build_sidebar(m: &clean::Module) -> HashMap<String, Vec<String>> { v.push(myname); } - for (_, items) in map.mut_iter() { + for (_, items) in map.iter_mut() { items.as_mut_slice().sort(); } return map; @@ -2180,5 +2180,5 @@ fn get_basic_keywords() -> &'static str { } fn make_item_keywords(it: &clean::Item) -> String { - format!("{}, {}", get_basic_keywords(), it.name.get_ref()) + format!("{}, {}", get_basic_keywords(), it.name.as_ref().assert()) } diff --git a/src/librustdoc/html/toc.rs b/src/librustdoc/html/toc.rs index 45c75ccd1ab42..b2cc53c9ebea0 100644 --- a/src/librustdoc/html/toc.rs +++ b/src/librustdoc/html/toc.rs @@ -167,7 +167,7 @@ impl TocBuilder { // get the thing we just pushed, so we can borrow the string // out of it with the right lifetime - let just_inserted = self.chain.mut_last().unwrap(); + let just_inserted = self.chain.last_mut().assert(); just_inserted.sec_number.as_slice() } } diff --git a/src/librustdoc/lib.rs b/src/librustdoc/lib.rs index 6c254b621775c..109304a51ae2a 100644 --- a/src/librustdoc/lib.rs +++ b/src/librustdoc/lib.rs @@ -369,12 +369,12 @@ fn rust_input(cratefile: &str, externs: core::Externs, matches: &getopts::Matche info!("starting to run rustc"); let (mut krate, analysis) = std::task::try(proc() { let cr = cr; - core::run_core(libs.move_iter().collect(), + core::run_core(libs.iter_owned().collect(), cfgs, externs, &cr, triple) - }).map_err(|boxed_any|format!("{:?}", boxed_any)).unwrap(); + }).map_err(|boxed_any|format!("{:?}", boxed_any)).assert(); info!("finished with rustc"); analysiskey.replace(Some(analysis)); @@ -385,7 +385,7 @@ fn rust_input(cratefile: &str, externs: core::Externs, matches: &getopts::Matche // Process all of the crate attributes, extracting plugin metadata along // with the passes which we are supposed to run. - match krate.module.get_ref().doc_list() { + match krate.module.as_ref().assert().doc_list() { Some(nested) => { for inner in nested.iter() { match *inner { @@ -435,7 +435,7 @@ fn rust_input(cratefile: &str, externs: core::Externs, matches: &getopts::Matche pm.add_plugin(plugin); } info!("loading plugins..."); - for pname in plugins.move_iter() { + for pname in plugins.iter_owned() { pm.load_plugin(pname); } @@ -472,7 +472,7 @@ fn json_input(input: &str) -> Result<Output, String> { let krate = match obj.pop(&"crate".to_string()) { Some(json) => { let mut d = json::Decoder::new(json); - Decodable::decode(&mut d).unwrap() + Decodable::decode(&mut d).assert() } None => return Err("malformed json".to_string()), }; @@ -499,7 +499,7 @@ fn json_output(krate: clean::Crate, res: Vec<plugins::PluginJson> , // } let mut json = std::collections::TreeMap::new(); json.insert("schema".to_string(), json::String(SCHEMA_VERSION.to_string())); - let plugins_json = res.move_iter() + let plugins_json = res.iter_owned() .filter_map(|opt| { match opt { None => None, @@ -515,9 +515,9 @@ fn json_output(krate: clean::Crate, res: Vec<plugins::PluginJson> , let mut w = MemWriter::new(); { let mut encoder = json::Encoder::new(&mut w as &mut io::Writer); - krate.encode(&mut encoder).unwrap(); + krate.encode(&mut encoder).assert(); } - String::from_utf8(w.unwrap()).unwrap() + String::from_utf8(w.unwrap()).assert() }; let crate_json = match json::from_str(crate_json_str.as_slice()) { Ok(j) => j, diff --git a/src/librustdoc/markdown.rs b/src/librustdoc/markdown.rs index 98b902f45048c..f397f6dca36e0 100644 --- a/src/librustdoc/markdown.rs +++ b/src/librustdoc/markdown.rs @@ -44,7 +44,7 @@ fn extract_leading_metadata<'a>(s: &'a str) -> (Vec<&'a str>, &'a str) { pub fn render(input: &str, mut output: Path, matches: &getopts::Matches, external_html: &ExternalHtml, include_toc: bool) -> int { let input_p = Path::new(input); - output.push(input_p.filestem().unwrap()); + output.push(input_p.filestem().assert()); output.set_extension("html"); let mut css = String::new(); diff --git a/src/librustdoc/passes.rs b/src/librustdoc/passes.rs index cc5bc5cb7c170..ef539e3abde43 100644 --- a/src/librustdoc/passes.rs +++ b/src/librustdoc/passes.rs @@ -101,7 +101,7 @@ pub fn strip_hidden(krate: clean::Crate) -> plugins::PluginResult { pub fn strip_private(mut krate: clean::Crate) -> plugins::PluginResult { // This stripper collects all *retained* nodes. let mut retained = HashSet::new(); - let analysis = super::analysiskey.get().unwrap(); + let analysis = super::analysiskey.get().assert(); let exported_items = analysis.exported_items.clone(); // strip all private items diff --git a/src/librustdoc/plugins.rs b/src/librustdoc/plugins.rs index 9ac366655636c..8310db67dfdb0 100644 --- a/src/librustdoc/plugins.rs +++ b/src/librustdoc/plugins.rs @@ -45,9 +45,9 @@ impl PluginManager { pub fn load_plugin(&mut self, name: String) { let x = self.prefix.join(libname(name)); let lib_result = dl::DynamicLibrary::open(Some(&x)); - let lib = lib_result.unwrap(); + let lib = lib_result.assert(); unsafe { - let plugin = lib.symbol("rustdoc_plugin_entrypoint").unwrap(); + let plugin = lib.symbol("rustdoc_plugin_entrypoint").assert(); self.callbacks.push(mem::transmute::<*mut u8,PluginCallback>(plugin)); } self.dylibs.push(lib); diff --git a/src/librustdoc/stability_summary.rs b/src/librustdoc/stability_summary.rs index 60db4fda05190..c33f43e79b0d5 100644 --- a/src/librustdoc/stability_summary.rs +++ b/src/librustdoc/stability_summary.rs @@ -168,7 +168,7 @@ pub fn build(krate: &Crate) -> ModuleSummary { submodules: Vec::new(), }, Some(ref item) => ModuleSummary { - name: krate.name.clone(), .. summarize_item(item).val1().unwrap() + name: krate.name.clone(), .. summarize_item(item).val1().assert() } } } diff --git a/src/librustdoc/test.rs b/src/librustdoc/test.rs index 9df748e74e8ba..16a044b933b4f 100644 --- a/src/librustdoc/test.rs +++ b/src/librustdoc/test.rs @@ -48,7 +48,7 @@ pub fn run(input: &str, let input = driver::FileInput(input_path.clone()); let sessopts = config::Options { - maybe_sysroot: Some(os::self_exe_path().unwrap().dir_path()), + maybe_sysroot: Some(os::self_exe_path().assert().dir_path()), addl_lib_search_paths: RefCell::new(libs.clone()), crate_types: vec!(config::CrateTypeDylib), externs: externs.clone(), @@ -65,7 +65,7 @@ pub fn run(input: &str, span_diagnostic_handler); let mut cfg = config::build_configuration(&sess); - cfg.extend(cfgs.move_iter().map(|cfg_| { + cfg.extend(cfgs.iter_owned().map(|cfg_| { let cfg_ = token::intern_and_get_ident(cfg_.as_slice()); box(GC) dummy_spanned(ast::MetaWord(cfg_)) })); @@ -105,7 +105,7 @@ pub fn run(input: &str, test_args.insert(0, "rustdoctest".to_string()); testing::test_main(test_args.as_slice(), - collector.tests.move_iter().collect()); + collector.tests.iter_owned().collect()); 0 } @@ -117,7 +117,7 @@ fn runtest(test: &str, cratename: &str, libs: HashSet<Path>, externs: core::Exte let input = driver::StrInput(test.to_string()); let sessopts = config::Options { - maybe_sysroot: Some(os::self_exe_path().unwrap().dir_path()), + maybe_sysroot: Some(os::self_exe_path().assert().dir_path()), addl_lib_search_paths: RefCell::new(libs), crate_types: vec!(config::CrateTypeExecutable), output_types: vec!(link::OutputTypeExe), @@ -156,7 +156,7 @@ fn runtest(test: &str, cratename: &str, libs: HashSet<Path>, externs: core::Exte } None => box io::stderr() as Box<Writer>, }; - io::util::copy(&mut p, &mut err).unwrap(); + io::util::copy(&mut p, &mut err).assert(); }); let emitter = diagnostic::EmitterWriter::new(box w2, None); diff --git a/src/librustrt/at_exit_imp.rs b/src/librustrt/at_exit_imp.rs index 8137669298124..98f15786e3d71 100644 --- a/src/librustrt/at_exit_imp.rs +++ b/src/librustrt/at_exit_imp.rs @@ -59,7 +59,7 @@ pub fn run() { v }; - for to_run in cur.move_iter() { + for to_run in cur.iter_owned() { to_run(); } } diff --git a/src/librustrt/c_str.rs b/src/librustrt/c_str.rs index 5dd61c03d17e7..b2044e77ffdc2 100644 --- a/src/librustrt/c_str.rs +++ b/src/librustrt/c_str.rs @@ -263,7 +263,7 @@ impl CString { /// Any ownership of the buffer by the `CString` wrapper is /// forgotten, meaning that the backing allocation of this /// `CString` is not automatically freed if it owns the - /// allocation. In this case, a user of `.unwrap()` should ensure + /// allocation. In this case, a user of `.assert()` should ensure /// the allocation is freed, to avoid leaking memory. /// /// Prefer `.as_ptr()` when just retrieving a pointer to the @@ -531,7 +531,7 @@ mod tests { let mut it = expected.iter(); let result = from_c_multistring(ptr as *const libc::c_char, None, |c| { let cbytes = c.as_bytes_no_nul(); - assert_eq!(cbytes, it.next().unwrap().as_bytes()); + assert_eq!(cbytes, it.next().assert().as_bytes()); }); assert_eq!(result, 2); assert!(it.next().is_none()); @@ -590,7 +590,7 @@ mod tests { #[test] fn test_unwrap() { let c_str = "hello".to_c_str(); - unsafe { libc::free(c_str.unwrap() as *mut libc::c_void) } + unsafe { libc::free(c_str.assert() as *mut libc::c_void) } } #[test] @@ -699,7 +699,7 @@ mod tests { // force a copy, reading the memory c.as_bytes().to_vec(); }); - let c_ = c_.unwrap(); + let c_ = c_.assert(); // force a copy, reading the memory c_.as_bytes().to_vec(); } diff --git a/src/librustrt/exclusive.rs b/src/librustrt/exclusive.rs index 179d050f598bf..21987322a6465 100644 --- a/src/librustrt/exclusive.rs +++ b/src/librustrt/exclusive.rs @@ -107,7 +107,7 @@ mod tests { }); }; - for f in futures.mut_iter() { f.recv() } + for f in futures.iter_mut() { f.recv() } assert_eq!(**total.lock(), num_tasks * count); } diff --git a/src/librustrt/local.rs b/src/librustrt/local.rs index e2a5eef0d99e1..8b4448a60ef86 100644 --- a/src/librustrt/local.rs +++ b/src/librustrt/local.rs @@ -117,7 +117,7 @@ mod test { let task = box Task::new(); Local::put(task); - let t: Box<Task> = Local::try_take().unwrap(); + let t: Box<Task> = Local::try_take().assert(); let u: Option<Box<Task>> = Local::try_take(); assert!(u.is_none()); diff --git a/src/librustrt/local_data.rs b/src/librustrt/local_data.rs index 27858b025c6cb..a3c58d304182d 100644 --- a/src/librustrt/local_data.rs +++ b/src/librustrt/local_data.rs @@ -27,10 +27,10 @@ local_data_key!(key_int: int) local_data_key!(key_vector: Vec<int>) key_int.replace(Some(3)); -assert_eq!(*key_int.get().unwrap(), 3); +assert_eq!(*key_int.get().assert(), 3); key_vector.replace(Some(vec![4])); -assert_eq!(*key_vector.get().unwrap(), vec![4]); +assert_eq!(*key_vector.get().assert(), vec![4]); ``` */ @@ -258,7 +258,7 @@ impl<T: 'static> KeyValue<T> { /// assert!(key.get().is_none()); /// /// key.replace(Some(3)); - /// assert_eq!(*key.get().unwrap(), 3); + /// assert_eq!(*key.get().assert(), 3); /// ``` pub fn get(&'static self) -> Option<Ref<T>> { let map = match unsafe { get_local_map() } { @@ -421,14 +421,14 @@ mod tests { // TLD shouldn't carry over. assert!(my_key.get().is_none()); my_key.replace(Some("child data".to_string())); - assert!(my_key.get().get_ref().as_slice() == "child data"); + assert!(my_key.get().as_ref().assert().as_slice() == "child data"); // should be cleaned up for us }); // Must work multiple times - assert!(my_key.get().unwrap().as_slice() == "parent data"); - assert!(my_key.get().unwrap().as_slice() == "parent data"); - assert!(my_key.get().unwrap().as_slice() == "parent data"); + assert!(my_key.get().assert().as_slice() == "parent data"); + assert!(my_key.get().assert().as_slice() == "parent data"); + assert!(my_key.get().assert().as_slice() == "parent data"); } #[test] @@ -436,14 +436,14 @@ mod tests { static my_key: Key<String> = &Key; my_key.replace(Some("first data".to_string())); my_key.replace(Some("next data".to_string())); // Shouldn't leak. - assert!(my_key.get().unwrap().as_slice() == "next data"); + assert!(my_key.get().assert().as_slice() == "next data"); } #[test] fn test_tls_pop() { static my_key: Key<String> = &Key; my_key.replace(Some("weasel".to_string())); - assert!(my_key.replace(None).unwrap() == "weasel".to_string()); + assert!(my_key.replace(None).assert() == "weasel".to_string()); // Pop must remove the data from the map. assert!(my_key.replace(None).is_none()); } @@ -544,15 +544,15 @@ mod tests { key.replace(Some(box 1)); { - let k1 = key.get().unwrap(); - let k2 = key.get().unwrap(); - let k3 = key.get().unwrap(); + let k1 = key.get().assert(); + let k2 = key.get().assert(); + let k3 = key.get().assert(); assert_eq!(**k1, 1); assert_eq!(**k2, 1); assert_eq!(**k3, 1); } key.replace(Some(box 2)); - assert_eq!(**key.get().unwrap(), 2); + assert_eq!(**key.get().assert(), 2); } #[test] @@ -568,11 +568,11 @@ mod tests { key4.replace(Some(4)); key5.replace(Some(5)); - assert_eq!(*key1.get().unwrap(), 1); - assert_eq!(*key2.get().unwrap(), 2); - assert_eq!(*key3.get().unwrap(), 3); - assert_eq!(*key4.get().unwrap(), 4); - assert_eq!(*key5.get().unwrap(), 5); + assert_eq!(*key1.get().assert(), 1); + assert_eq!(*key2.get().assert(), 2); + assert_eq!(*key3.get().assert(), 3); + assert_eq!(*key4.get().assert(), 4); + assert_eq!(*key5.get().assert(), 5); } #[test] @@ -624,7 +624,7 @@ mod tests { let _clear = ClearKey(key); key.replace(Some(0u)); b.iter(|| { - let old = key.replace(None).unwrap(); + let old = key.replace(None).assert(); let new = old + 1; key.replace(Some(new)) }); diff --git a/src/librustrt/local_heap.rs b/src/librustrt/local_heap.rs index 273505c416a3c..fe377d9e75b87 100644 --- a/src/librustrt/local_heap.rs +++ b/src/librustrt/local_heap.rs @@ -39,7 +39,7 @@ impl LocalHeap { pub fn new() -> LocalHeap { LocalHeap { memory_region: MemoryRegion { live_allocations: 0 }, - live_allocs: ptr::mut_null(), + live_allocs: ptr::null_mut(), } } @@ -58,7 +58,7 @@ impl LocalHeap { // allocations list mybox.drop_glue = drop_glue; mybox.ref_count = 1; - mybox.prev = ptr::mut_null(); + mybox.prev = ptr::null_mut(); mybox.next = self.live_allocs; if !self.live_allocs.is_null() { unsafe { (*self.live_allocs).prev = alloc; } @@ -165,7 +165,7 @@ impl LocalHeap { //! Walks the internal list of allocations let mut alloc = self.live_allocs; - while alloc != ptr::mut_null() { + while alloc != ptr::null_mut() { let next_before = (*alloc).next; f(self, alloc); diff --git a/src/librustrt/local_ptr.rs b/src/librustrt/local_ptr.rs index c94e5c6187b3a..0f23c5bc44e81 100644 --- a/src/librustrt/local_ptr.rs +++ b/src/librustrt/local_ptr.rs @@ -282,7 +282,7 @@ pub mod native { rtabort!("thread-local pointer is null. bogus!"); } let ptr: Box<T> = mem::transmute(void_ptr); - tls::set(key, ptr::mut_null()); + tls::set(key, ptr::null_mut()); return ptr; } @@ -300,7 +300,7 @@ pub mod native { None } else { let ptr: Box<T> = mem::transmute(void_ptr); - tls::set(key, ptr::mut_null()); + tls::set(key, ptr::null_mut()); Some(ptr) } } diff --git a/src/librustrt/mutex.rs b/src/librustrt/mutex.rs index 08da9b8aad1b0..349816094d887 100644 --- a/src/librustrt/mutex.rs +++ b/src/librustrt/mutex.rs @@ -615,7 +615,7 @@ mod imp { } pub unsafe fn init_cond() -> uint { - return CreateEventA(ptr::mut_null(), libc::FALSE, libc::FALSE, + return CreateEventA(ptr::null_mut(), libc::FALSE, libc::FALSE, ptr::null()) as uint; } diff --git a/src/librustrt/task.rs b/src/librustrt/task.rs index 881756c5266fc..9a8e08a97b58a 100644 --- a/src/librustrt/task.rs +++ b/src/librustrt/task.rs @@ -362,7 +362,7 @@ impl Task { /// caller. pub fn take_runtime(&mut self) -> Box<Runtime + Send> { assert!(self.imp.is_some()); - self.imp.take().unwrap() + self.imp.take().assert() } /// Attempts to extract the runtime as a specific type. If the runtime does @@ -384,7 +384,7 @@ impl Task { // function, and I would be saddened if more usage of the function // crops up. unsafe { - let imp = self.imp.take_unwrap(); + let imp = self.imp.take().assert(); let vtable = mem::transmute::<_, &raw::TraitObject>(&imp).vtable; match imp.wrap().downcast::<T>() { Ok(t) => Some(t), @@ -407,7 +407,7 @@ impl Task { pub fn spawn_sibling(mut self: Box<Task>, opts: TaskOpts, f: proc(): Send) { - let ops = self.imp.take_unwrap(); + let ops = self.imp.take().assert(); ops.spawn_sibling(self, opts, f) } @@ -417,7 +417,7 @@ impl Task { pub fn deschedule(mut self: Box<Task>, amt: uint, f: |BlockedTask| -> ::core::result::Result<(), BlockedTask>) { - let ops = self.imp.take_unwrap(); + let ops = self.imp.take().assert(); ops.deschedule(amt, self, f) } @@ -425,7 +425,7 @@ impl Task { /// current task can accept a change in scheduling. This function can only /// be called on tasks that were previously blocked in `deschedule`. pub fn reawaken(mut self: Box<Task>) { - let ops = self.imp.take_unwrap(); + let ops = self.imp.take().assert(); ops.reawaken(self); } @@ -433,14 +433,14 @@ impl Task { /// eventually return, but possibly not immediately. This is used as an /// opportunity to allow other tasks a chance to run. pub fn yield_now(mut self: Box<Task>) { - let ops = self.imp.take_unwrap(); + let ops = self.imp.take().assert(); ops.yield_now(self); } /// Similar to `yield_now`, except that this function may immediately return /// without yielding (depending on what the runtime decides to do). pub fn maybe_yield(mut self: Box<Task>) { - let ops = self.imp.take_unwrap(); + let ops = self.imp.take().assert(); ops.maybe_yield(self); } @@ -448,20 +448,20 @@ impl Task { /// stored in the task's runtime. This factory may not always be available, /// which is why the return type is `Option` pub fn local_io<'a>(&'a mut self) -> Option<LocalIo<'a>> { - self.imp.get_mut_ref().local_io() + self.imp.as_mut().assert().local_io() } /// Returns the stack bounds for this task in (lo, hi) format. The stack /// bounds may not be known for all tasks, so the return value may be /// `None`. pub fn stack_bounds(&self) -> (uint, uint) { - self.imp.get_ref().stack_bounds() + self.imp.as_ref().assert().stack_bounds() } /// Returns whether it is legal for this task to block the OS thread that it /// is running on. pub fn can_block(&self) -> bool { - self.imp.get_ref().can_block() + self.imp.as_ref().assert().can_block() } /// Consume this task, flagging it as a candidate for destruction. @@ -591,10 +591,10 @@ mod test { fn tls() { local_data_key!(key: Gc<String>) key.replace(Some(box(GC) "data".to_string())); - assert_eq!(key.get().unwrap().as_slice(), "data"); + assert_eq!(key.get().assert().as_slice(), "data"); local_data_key!(key2: Gc<String>) key2.replace(Some(box(GC) "data".to_string())); - assert_eq!(key2.get().unwrap().as_slice(), "data"); + assert_eq!(key2.get().assert().as_slice(), "data"); } #[test] @@ -610,7 +610,7 @@ mod test { #[test] fn rng() { use std::rand::{StdRng, Rng}; - let mut r = StdRng::new().ok().unwrap(); + let mut r = StdRng::new().ok().assert(); let _ = r.next_u32(); } @@ -662,7 +662,7 @@ mod test { #[test] fn block_and_wake() { let task = box Task::new(); - let mut task = BlockedTask::block(task).wake().unwrap(); + let mut task = BlockedTask::block(task).wake().assert(); task.drop(); } } diff --git a/src/librustrt/thread.rs b/src/librustrt/thread.rs index 43364466dbe39..b884fcb6659b7 100644 --- a/src/librustrt/thread.rs +++ b/src/librustrt/thread.rs @@ -128,7 +128,7 @@ impl<T: Send> Thread<T> { unsafe { imp::join(self.native) }; self.joined = true; assert!(self.packet.is_some()); - self.packet.take_unwrap() + self.packet.take().assert() } } @@ -171,8 +171,8 @@ mod imp { // kernel does, might as well make it explicit. With the current // 20 kB red zone, that makes for a 64 kB minimum stack. let stack_size = (cmp::max(stack, RED_ZONE) + 0xfffe) & (-0xfffe - 1); - let ret = CreateThread(ptr::mut_null(), stack_size as libc::size_t, - super::thread_start, arg, 0, ptr::mut_null()); + let ret = CreateThread(ptr::null_mut(), stack_size as libc::size_t, + super::thread_start, arg, 0, ptr::null_mut()); if ret as uint == 0 { // be sure to not leak the closure @@ -268,7 +268,7 @@ mod imp { } pub unsafe fn join(native: rust_thread) { - assert_eq!(pthread_join(native, ptr::mut_null()), 0); + assert_eq!(pthread_join(native, ptr::null_mut()), 0); } pub unsafe fn detach(native: rust_thread) { diff --git a/src/librustrt/unwind.rs b/src/librustrt/unwind.rs index 79f83df5be809..f726dc80f707f 100644 --- a/src/librustrt/unwind.rs +++ b/src/librustrt/unwind.rs @@ -145,7 +145,7 @@ pub unsafe fn try(f: ||) -> ::core::result::Result<(), Box<Any + Send>> { rtdebug!("caught {}", (*my_ep).uwe.exception_class); let cause = (*my_ep).cause.take(); uw::_Unwind_DeleteException(ep); - Err(cause.unwrap()) + Err(cause.assert()) }; extern fn try_fn(code: *mut c_void, env: *mut c_void) { @@ -519,7 +519,7 @@ pub fn begin_unwind_fmt(msg: &fmt::Arguments, file_line: &(&'static str, uint)) let mut v = Vec::new(); let _ = write!(&mut VecWriter { v: &mut v }, "{}", msg); - begin_unwind_inner(box String::from_utf8(v).unwrap(), file_line) + begin_unwind_inner(box String::from_utf8(v).assert(), file_line) } /// This is the entry point of unwinding for fail!() and assert!(). diff --git a/src/librustrt/util.rs b/src/librustrt/util.rs index 1334000ed1f5c..77e3e25eb0e7e 100644 --- a/src/librustrt/util.rs +++ b/src/librustrt/util.rs @@ -62,7 +62,7 @@ pub fn abort(args: &fmt::Arguments) -> ! { } impl<'a> FormatWriter for BufWriter<'a> { fn write(&mut self, bytes: &[u8]) -> fmt::Result { - let left = self.buf.mut_slice_from(self.pos); + let left = self.buf.slice_from_mut(self.pos); let to_write = bytes.slice_to(cmp::min(bytes.len(), left.len())); slice::bytes::copy_memory(left, to_write); self.pos += to_write.len(); diff --git a/src/librustuv/access.rs b/src/librustuv/access.rs index 9bd8af6419e0b..8998ac43aebb5 100644 --- a/src/librustuv/access.rs +++ b/src/librustuv/access.rs @@ -84,7 +84,7 @@ impl Access { pub unsafe fn dequeue(&mut self, token: uint) -> Option<BlockedTask> { let inner: &mut Inner = &mut *self.inner.get(); match inner.queue.iter().position(|&(_, t)| t == token) { - Some(i) => Some(inner.queue.remove(i).unwrap().val0()), + Some(i) => Some(inner.queue.remove(i).assert().val0()), None => None, } } diff --git a/src/librustuv/addrinfo.rs b/src/librustuv/addrinfo.rs index 6eaab1c096170..be73410e8e699 100644 --- a/src/librustuv/addrinfo.rs +++ b/src/librustuv/addrinfo.rs @@ -11,7 +11,7 @@ use libc::c_int; use libc; use std::mem; -use std::ptr::{null, mut_null}; +use std::ptr::{null, null_mut}; use std::rt::task::BlockedTask; use std::rt::rtio; @@ -62,9 +62,9 @@ impl GetAddrInfoRequest { ai_socktype: 0, ai_protocol: 0, ai_addrlen: 0, - ai_canonname: mut_null(), - ai_addr: mut_null(), - ai_next: mut_null(), + ai_canonname: null_mut(), + ai_addr: null_mut(), + ai_next: null_mut(), } }); let hint_ptr = hint.as_ref().map_or(null(), |x| { @@ -86,7 +86,7 @@ impl GetAddrInfoRequest { }); match cx.status { - 0 => Ok(accum_addrinfo(cx.addrinfo.get_ref())), + 0 => Ok(accum_addrinfo(cx.addrinfo.as_ref().assert())), n => Err(UvError(n)) } } diff --git a/src/librustuv/async.rs b/src/librustuv/async.rs index 97f95145b8992..25fd289f5fe53 100644 --- a/src/librustuv/async.rs +++ b/src/librustuv/async.rs @@ -136,7 +136,7 @@ mod test_remote { // once let MyCallback(ref mut s) = *self; if s.is_some() { - s.take_unwrap().send(1); + s.take().assert().send(1); } } } diff --git a/src/librustuv/file.rs b/src/librustuv/file.rs index f42f42d211160..8d0f25fff8626 100644 --- a/src/librustuv/file.rs +++ b/src/librustuv/file.rs @@ -483,7 +483,7 @@ mod test { let result = FsRequest::open(local_loop(), &path_str.to_c_str(), create_flags as int, mode as int); assert!(result.is_ok()); - let result = result.unwrap(); + let result = result.assert(); let fd = result.fd; // write @@ -496,7 +496,7 @@ mod test { let result = FsRequest::open(local_loop(), &path_str.to_c_str(), read_flags as int, 0); assert!(result.is_ok()); - let result = result.unwrap(); + let result = result.assert(); let fd = result.fd; // read @@ -504,9 +504,9 @@ mod test { let result = FsRequest::read(l(), fd, read_mem.as_mut_slice(), 0); assert!(result.is_ok()); - let nread = result.unwrap(); + let nread = result.assert(); assert!(nread > 0); - let read_str = str::from_utf8(read_mem.slice_to(nread as uint)).unwrap(); + let read_str = str::from_utf8(read_mem.slice_to(nread as uint)).assert(); assert_eq!(read_str, "hello"); } // unlink @@ -522,18 +522,18 @@ mod test { let result = FsRequest::open(local_loop(), path, create_flags, mode); assert!(result.is_ok()); - let file = result.unwrap(); + let file = result.assert(); let result = FsRequest::write(l(), file.fd, "hello".as_bytes(), 0); assert!(result.is_ok()); let result = FsRequest::stat(l(), path); assert!(result.is_ok()); - assert_eq!(result.unwrap().size, 5); + assert_eq!(result.assert().size, 5); let result = FsRequest::fstat(l(), file.fd); assert!(result.is_ok()); - assert_eq!(result.unwrap().size, 5); + assert_eq!(result.assert().size, 5); fn free<T>(_: T) {} free(file); diff --git a/src/librustuv/homing.rs b/src/librustuv/homing.rs index 91614763ce52f..5b17ae36caa32 100644 --- a/src/librustuv/homing.rs +++ b/src/librustuv/homing.rs @@ -172,7 +172,7 @@ mod test { pool.spawn(TaskOpts::new(), proc() { let listener = UdpWatcher::bind(local_loop(), ::next_test_ip4()); - tx.send(listener.unwrap()); + tx.send(listener.assert()); }); let task = pool.task(TaskOpts::new(), proc() { @@ -195,15 +195,15 @@ mod test { let addr1 = ::next_test_ip4(); let addr2 = ::next_test_ip4(); let listener = UdpWatcher::bind(local_loop(), addr2); - tx.send((listener.unwrap(), addr1)); - let mut listener = UdpWatcher::bind(local_loop(), addr1).unwrap(); - listener.send_to([1, 2, 3, 4], addr2).ok().unwrap(); + tx.send((listener.assert(), addr1)); + let mut listener = UdpWatcher::bind(local_loop(), addr1).assert(); + listener.send_to([1, 2, 3, 4], addr2).ok().assert(); }); let task = pool.task(TaskOpts::new(), proc() { let (mut watcher, addr) = rx.recv(); let mut buf = [0, ..10]; - assert!(watcher.recv_from(buf).ok().unwrap() == (4, addr)); + assert!(watcher.recv_from(buf).ok().assert() == (4, addr)); }); pool.spawn_sched().send(sched::TaskFromFriend(task)); diff --git a/src/librustuv/lib.rs b/src/librustuv/lib.rs index dd80ab3ee78a1..d576926929245 100644 --- a/src/librustuv/lib.rs +++ b/src/librustuv/lib.rs @@ -168,7 +168,7 @@ pub trait UvHandle<T> { } unsafe { - uvll::set_data_for_uv_handle(self.uv_handle(), ptr::mut_null::<()>()); + uvll::set_data_for_uv_handle(self.uv_handle(), ptr::null_mut::<()>()); uvll::uv_close(self.uv_handle() as *mut uvll::uv_handle_t, close_cb) } } @@ -179,7 +179,7 @@ pub trait UvHandle<T> { unsafe { uvll::uv_close(self.uv_handle() as *mut uvll::uv_handle_t, close_cb); uvll::set_data_for_uv_handle(self.uv_handle(), - ptr::mut_null::<()>()); + ptr::null_mut::<()>()); wait_until_woken_after(&mut slot, &self.uv_loop(), || { uvll::set_data_for_uv_handle(self.uv_handle(), &mut slot); @@ -190,7 +190,7 @@ pub trait UvHandle<T> { unsafe { let data = uvll::get_data_for_uv_handle(handle); uvll::free_handle(handle); - if data == ptr::mut_null() { return } + if data == ptr::null_mut() { return } let slot: &mut Option<BlockedTask> = mem::transmute(data); wakeup(slot); } @@ -259,7 +259,7 @@ fn wait_until_woken_after(slot: *mut Option<BlockedTask>, fn wakeup(slot: &mut Option<BlockedTask>) { assert!(slot.is_some()); - let _ = slot.take_unwrap().wake().map(|t| t.reawaken()); + let _ = slot.take().assert().wake().map(|t| t.reawaken()); } pub struct Request { @@ -271,7 +271,7 @@ impl Request { pub fn new(ty: uvll::uv_req_type) -> Request { unsafe { let handle = uvll::malloc_req(ty); - uvll::set_data_for_req(handle, ptr::mut_null::<()>()); + uvll::set_data_for_req(handle, ptr::null_mut::<()>()); Request::wrap(handle) } } @@ -286,7 +286,7 @@ impl Request { pub unsafe fn get_data<T>(&self) -> &'static mut T { let data = uvll::get_data_for_req(self.handle); - assert!(data != ptr::mut_null()); + assert!(data != ptr::null_mut()); mem::transmute(data) } @@ -448,7 +448,7 @@ pub type Buf = uvll::uv_buf_t; pub fn empty_buf() -> Buf { uvll::uv_buf_t { - base: ptr::mut_null(), + base: ptr::null_mut(), len: 0, } } @@ -465,7 +465,7 @@ fn local_loop() -> &'static mut uvio::UvIoFactory { unsafe { mem::transmute({ let mut task = Local::borrow(None::<Task>); - let mut io = task.local_io().unwrap(); + let mut io = task.local_io().assert(); let (_vtable, uvio): (uint, &'static mut uvio::UvIoFactory) = mem::transmute(io.get()); uvio diff --git a/src/librustuv/net.rs b/src/librustuv/net.rs index 0da8d0d2108ea..3439d63e371b3 100644 --- a/src/librustuv/net.rs +++ b/src/librustuv/net.rs @@ -563,10 +563,10 @@ impl rtio::RtioUdpSocket for UdpWatcher { wait_until_woken_after(&mut cx.task, &loop_, || { unsafe { uvll::set_data_for_uv_handle(handle, &mut cx) } }); - match cx.result.take_unwrap() { + match cx.result.take().assert() { (n, _) if n < 0 => Err(uv_error_to_io_error(UvError(n as c_int))), - (n, addr) => Ok((n as uint, addr.unwrap())) + (n, addr) => Ok((n as uint, addr.assert())) } } n => Err(uv_error_to_io_error(UvError(n))) @@ -624,7 +624,7 @@ impl rtio::RtioUdpSocket for UdpWatcher { // here. let data = if guard.can_timeout {Some(Vec::from_slice(buf))} else {None}; let uv_buf = if guard.can_timeout { - slice_to_uv_buf(data.get_ref().as_slice()) + slice_to_uv_buf(data.as_ref().assert().as_slice()) } else { slice_to_uv_buf(buf) }; @@ -1024,10 +1024,10 @@ mod test { let (tx, rx) = channel(); spawn(proc() { - let listener = TcpListener::bind(local_loop(), addr).unwrap(); - let mut acceptor = listener.listen().ok().unwrap(); + let listener = TcpListener::bind(local_loop(), addr).assert(); + let mut acceptor = listener.listen().ok().assert(); tx.send(()); - let mut stream = acceptor.accept().ok().unwrap(); + let mut stream = acceptor.accept().ok().assert(); let buf = [1, .. 2048]; let mut total_bytes_written = 0; while total_bytes_written < MAX { @@ -1038,11 +1038,11 @@ mod test { }); rx.recv(); - let mut stream = TcpWatcher::connect(local_loop(), addr, None).unwrap(); + let mut stream = TcpWatcher::connect(local_loop(), addr, None).assert(); let mut buf = [0, .. 2048]; let mut total_bytes_read = 0; while total_bytes_read < MAX { - let nread = stream.read(buf).ok().unwrap(); + let nread = stream.read(buf).ok().assert(); total_bytes_read += nread; for i in range(0u, nread) { assert_eq!(buf[i], 1); @@ -1059,18 +1059,18 @@ mod test { let (tx, rx) = channel(); spawn(proc() { - let mut client = UdpWatcher::bind(local_loop(), client_addr).unwrap(); + let mut client = UdpWatcher::bind(local_loop(), client_addr).assert(); rx.recv(); assert!(client.send_to([1], server_addr).is_ok()); assert!(client.send_to([2], server_addr).is_ok()); }); - let mut server = UdpWatcher::bind(local_loop(), server_addr).unwrap(); + let mut server = UdpWatcher::bind(local_loop(), server_addr).assert(); tx.send(()); let mut buf1 = [0]; let mut buf2 = [0]; - let (nread1, src1) = server.recv_from(buf1).ok().unwrap(); - let (nread2, src2) = server.recv_from(buf2).ok().unwrap(); + let (nread1, src1) = server.recv_from(buf1).ok().assert(); + let (nread2, src2) = server.recv_from(buf2).ok().assert(); assert_eq!(nread1, 1); assert_eq!(nread2, 1); assert!(src1 == client_addr); @@ -1092,8 +1092,8 @@ mod test { spawn(proc() { let l = local_loop(); - let mut server_out = UdpWatcher::bind(l, server_out_addr).unwrap(); - let mut server_in = UdpWatcher::bind(l, server_in_addr).unwrap(); + let mut server_out = UdpWatcher::bind(l, server_out_addr).assert(); + let mut server_in = UdpWatcher::bind(l, server_in_addr).assert(); let (tx, rx) = (tx2, rx1); tx.send(()); rx.recv(); @@ -1107,7 +1107,7 @@ mod test { // check if the client has received enough let res = server_in.recv_from(buf); assert!(res.is_ok()); - let (nread, src) = res.ok().unwrap(); + let (nread, src) = res.ok().assert(); assert_eq!(nread, 1); assert!(src == client_out_addr); } @@ -1115,8 +1115,8 @@ mod test { }); let l = local_loop(); - let mut client_out = UdpWatcher::bind(l, client_out_addr).unwrap(); - let mut client_in = UdpWatcher::bind(l, client_in_addr).unwrap(); + let mut client_out = UdpWatcher::bind(l, client_out_addr).assert(); + let mut client_in = UdpWatcher::bind(l, client_in_addr).assert(); let (tx, rx) = (tx1, rx2); rx.recv(); tx.send(()); @@ -1128,7 +1128,7 @@ mod test { // wait for data let res = client_in.recv_from(buf); assert!(res.is_ok()); - let (nread, src) = res.ok().unwrap(); + let (nread, src) = res.ok().assert(); assert!(src == server_out_addr); total_bytes_recv += nread; for i in range(0u, nread) { @@ -1146,20 +1146,20 @@ mod test { spawn(proc() { let rx = rx.recv(); - let mut stream = TcpWatcher::connect(local_loop(), addr, None).unwrap(); - stream.write([0, 1, 2, 3, 4, 5, 6, 7]).ok().unwrap(); - stream.write([0, 1, 2, 3, 4, 5, 6, 7]).ok().unwrap(); + let mut stream = TcpWatcher::connect(local_loop(), addr, None).assert(); + stream.write([0, 1, 2, 3, 4, 5, 6, 7]).ok().assert(); + stream.write([0, 1, 2, 3, 4, 5, 6, 7]).ok().assert(); rx.recv(); - stream.write([0, 1, 2, 3, 4, 5, 6, 7]).ok().unwrap(); - stream.write([0, 1, 2, 3, 4, 5, 6, 7]).ok().unwrap(); + stream.write([0, 1, 2, 3, 4, 5, 6, 7]).ok().assert(); + stream.write([0, 1, 2, 3, 4, 5, 6, 7]).ok().assert(); rx.recv(); }); - let listener = TcpListener::bind(local_loop(), addr).unwrap(); - let mut acceptor = listener.listen().ok().unwrap(); + let listener = TcpListener::bind(local_loop(), addr).assert(); + let mut acceptor = listener.listen().ok().assert(); let (tx2, rx2) = channel(); tx.send(rx2); - let mut stream = acceptor.accept().ok().unwrap(); + let mut stream = acceptor.accept().ok().assert(); let mut buf = [0, .. 2048]; let expected = 32; @@ -1167,7 +1167,7 @@ mod test { let mut reads = 0u; while current < expected { - let nread = stream.read(buf).ok().unwrap(); + let nread = stream.read(buf).ok().assert(); for i in range(0u, nread) { let val = buf[i] as uint; assert_eq!(val, current % 8); @@ -1187,11 +1187,11 @@ mod test { let addr = ::next_test_ip4(); spawn(proc() { - let listener = TcpListener::bind(local_loop(), addr).unwrap(); - let mut acceptor = listener.listen().ok().unwrap(); - let mut stream = acceptor.accept().ok().unwrap(); + let listener = TcpListener::bind(local_loop(), addr).assert(); + let mut acceptor = listener.listen().ok().assert(); + let mut stream = acceptor.accept().ok().assert(); let mut buf = [0, .. 2048]; - let nread = stream.read(buf).ok().unwrap(); + let nread = stream.read(buf).ok().assert(); assert_eq!(nread, 8); for i in range(0u, nread) { assert_eq!(buf[i], i as u8); @@ -1202,14 +1202,14 @@ mod test { while stream.is_err() { stream = TcpWatcher::connect(local_loop(), addr, None); } - stream.unwrap().write([0, 1, 2, 3, 4, 5, 6, 7]).ok().unwrap(); + stream.assert().write([0, 1, 2, 3, 4, 5, 6, 7]).ok().assert(); } #[should_fail] #[test] fn tcp_listener_fail_cleanup() { let addr = ::next_test_ip4(); - let w = TcpListener::bind(local_loop(), addr).unwrap(); - let _w = w.listen().ok().unwrap(); + let w = TcpListener::bind(local_loop(), addr).assert(); + let _w = w.listen().ok().assert(); fail!(); } @@ -1219,20 +1219,20 @@ mod test { let addr = ::next_test_ip4(); spawn(proc() { - let w = TcpListener::bind(local_loop(), addr).unwrap(); - let mut w = w.listen().ok().unwrap(); + let w = TcpListener::bind(local_loop(), addr).assert(); + let mut w = w.listen().ok().assert(); tx.send(()); - drop(w.accept().ok().unwrap()); + drop(w.accept().ok().assert()); }); rx.recv(); - let _w = TcpWatcher::connect(local_loop(), addr, None).unwrap(); + let _w = TcpWatcher::connect(local_loop(), addr, None).assert(); fail!(); } #[should_fail] #[test] fn udp_listener_fail_cleanup() { let addr = ::next_test_ip4(); - let _w = UdpWatcher::bind(local_loop(), addr).unwrap(); + let _w = UdpWatcher::bind(local_loop(), addr).assert(); fail!(); } @@ -1245,7 +1245,7 @@ mod test { // the original task will force a homing operation back to this // scheduler. spawn(proc() { - let w = UdpWatcher::bind(local_loop(), addr).unwrap(); + let w = UdpWatcher::bind(local_loop(), addr).assert(); tx.send(w); }); diff --git a/src/librustuv/pipe.rs b/src/librustuv/pipe.rs index f0a57546ed43e..6f70676c223c1 100644 --- a/src/librustuv/pipe.rs +++ b/src/librustuv/pipe.rs @@ -354,7 +354,7 @@ mod tests { #[test] #[should_fail] fn bind_fail() { let p = next_test_unix().to_c_str(); - let _w = PipeListener::bind(local_loop(), &p).unwrap(); + let _w = PipeListener::bind(local_loop(), &p).assert(); fail!(); } @@ -365,20 +365,20 @@ mod tests { let (tx, rx) = channel(); spawn(proc() { - let p = PipeListener::bind(local_loop(), &path2.to_c_str()).unwrap(); - let mut p = p.listen().ok().unwrap(); + let p = PipeListener::bind(local_loop(), &path2.to_c_str()).assert(); + let mut p = p.listen().ok().assert(); tx.send(()); - let mut client = p.accept().ok().unwrap(); + let mut client = p.accept().ok().assert(); let mut buf = [0]; - assert!(client.read(buf).ok().unwrap() == 1); + assert!(client.read(buf).ok().assert() == 1); assert_eq!(buf[0], 1); assert!(client.write([2]).is_ok()); }); rx.recv(); - let mut c = PipeWatcher::connect(local_loop(), &path.to_c_str(), None).unwrap(); + let mut c = PipeWatcher::connect(local_loop(), &path.to_c_str(), None).assert(); assert!(c.write([1]).is_ok()); let mut buf = [0]; - assert!(c.read(buf).ok().unwrap() == 1); + assert!(c.read(buf).ok().assert() == 1); assert_eq!(buf[0], 2); } @@ -389,13 +389,13 @@ mod tests { let (tx, rx) = channel(); spawn(proc() { - let p = PipeListener::bind(local_loop(), &path2.to_c_str()).unwrap(); - let mut p = p.listen().ok().unwrap(); + let p = PipeListener::bind(local_loop(), &path2.to_c_str()).assert(); + let mut p = p.listen().ok().assert(); tx.send(()); - drop(p.accept().ok().unwrap()); + drop(p.accept().ok().assert()); }); rx.recv(); - let _c = PipeWatcher::connect(local_loop(), &path.to_c_str(), None).unwrap(); + let _c = PipeWatcher::connect(local_loop(), &path.to_c_str(), None).assert(); fail!() } diff --git a/src/librustuv/process.rs b/src/librustuv/process.rs index 0486f376bc806..96b50d79aa6c6 100644 --- a/src/librustuv/process.rs +++ b/src/librustuv/process.rs @@ -60,7 +60,7 @@ impl Process { let mut ret_io = Vec::with_capacity(io.len()); unsafe { stdio.set_len(io.len()); - for (slot, other) in stdio.mut_iter().zip(io.iter()) { + for (slot, other) in stdio.iter_mut().zip(io.iter()) { let io = set_stdio(slot as *mut uvll::uv_stdio_container_t, other, io_loop); ret_io.push(io); @@ -297,7 +297,7 @@ impl rtio::RtioProcess for Process { self.timer = Some(timer); } - let timer = self.timer.get_mut_ref(); + let timer = self.timer.as_mut().assert(); timer.stop(); timer.start(timer_cb, ms, 0); self.timeout_state = TimeoutPending; diff --git a/src/librustuv/stream.rs b/src/librustuv/stream.rs index c49e557a3237d..076378ed5e6c0 100644 --- a/src/librustuv/stream.rs +++ b/src/librustuv/stream.rs @@ -136,7 +136,7 @@ impl StreamWatcher { let mut req = match self.last_write_req.take() { Some(req) => req, None => Request::new(uvll::UV_WRITE), }; - req.set_data(ptr::mut_null::<()>()); + req.set_data(ptr::null_mut::<()>()); // And here's where timeouts get a little interesting. Currently, libuv // does not support canceling an in-flight write request. Consequently, @@ -161,7 +161,7 @@ impl StreamWatcher { // bytes. let data = if may_timeout {Some(Vec::from_slice(buf))} else {None}; let uv_buf = if may_timeout { - slice_to_uv_buf(data.get_ref().as_slice()) + slice_to_uv_buf(data.as_ref().assert().as_slice()) } else { slice_to_uv_buf(buf) }; diff --git a/src/librustuv/timeout.rs b/src/librustuv/timeout.rs index 1caaf5e0fc75d..500f2272ab768 100644 --- a/src/librustuv/timeout.rs +++ b/src/librustuv/timeout.rs @@ -131,7 +131,7 @@ impl AccessTimeout { self.timer = Some(timer); } - let timer = self.timer.get_mut_ref(); + let timer = self.timer.as_mut().assert(); unsafe { let cx = uvll::get_data_for_uv_handle(timer.handle); let cx = cx as *mut TimerContext; @@ -374,7 +374,7 @@ impl AcceptTimeout { // Once we've got a timer, stop any previous timeout, reset it for the // current one, and install some new channels to send/receive data on - let timer = self.timer.get_mut_ref(); + let timer = self.timer.as_mut().assert(); timer.stop(); timer.start(timer_cb, ms, 0); let (tx, rx) = channel(); @@ -387,7 +387,7 @@ impl AcceptTimeout { }; // This send can never fail because if this timer is active then the // receiving channel is guaranteed to be alive - acceptor.timeout_tx.get_ref().send(()); + acceptor.timeout_tx.as_ref().assert().send(()); } } } diff --git a/src/librustuv/timer.rs b/src/librustuv/timer.rs index f6c1cdd297754..9ff787edbd787 100644 --- a/src/librustuv/timer.rs +++ b/src/librustuv/timer.rs @@ -132,9 +132,9 @@ extern fn timer_cb(handle: *mut uvll::uv_timer_t) { let _f = ForbidSwitch::new("timer callback can't switch"); let timer: &mut TimerWatcher = unsafe { UvHandle::from_uv_handle(&handle) }; - match timer.action.take_unwrap() { + match timer.action.take().assert() { WakeTask => { - let task = timer.blocker.take_unwrap(); + let task = timer.blocker.take().assert(); let _ = task.wake().map(|t| t.reawaken()); } CallOnce(mut cb) => { cb.call() } diff --git a/src/librustuv/tty.rs b/src/librustuv/tty.rs index 70b17db8dcfdd..43973f2fb8e50 100644 --- a/src/librustuv/tty.rs +++ b/src/librustuv/tty.rs @@ -70,7 +70,7 @@ impl TtyWatcher { // handle, so our only cleanup is to free the handle itself if cfg!(windows) { unsafe { uvll::free_handle(handle); } - watcher.tty = ptr::mut_null(); + watcher.tty = ptr::null_mut(); } Err(UvError(n)) } diff --git a/src/librustuv/uvio.rs b/src/librustuv/uvio.rs index 61e52a3abd19c..59f04c78025ee 100644 --- a/src/librustuv/uvio.rs +++ b/src/librustuv/uvio.rs @@ -66,7 +66,7 @@ impl Drop for UvEventLoop { // Lastly, after we've closed the pool of handles we pump the event loop // one last time to run any closing callbacks to make sure the loop // shuts down cleanly. - let handle = self.uvio.handle_pool.get_ref().handle(); + let handle = self.uvio.handle_pool.as_ref().assert().handle(); drop(self.uvio.handle_pool.take()); self.run(); @@ -132,7 +132,7 @@ impl UvIoFactory { // It's understood by the homing code that the "local id" is just the // pointer of the local I/O factory cast to a uint. let id: uint = unsafe { mem::transmute_copy(&self) }; - HomeHandle::new(id, &mut **self.handle_pool.get_mut_ref()) + HomeHandle::new(id, &mut **self.handle_pool.as_mut().assert()) } } @@ -270,7 +270,7 @@ impl IoFactory for UvIoFactory { match Process::spawn(self, cfg) { Ok((p, io)) => { Ok((p as Box<rtio::RtioProcess + Send>, - io.move_iter().map(|i| i.map(|p| { + io.iter_owned().map(|i| i.map(|p| { box p as Box<rtio::RtioPipe + Send> })).collect())) } diff --git a/src/libsemver/lib.rs b/src/libsemver/lib.rs index 3cc5189c024db..76a2491faf88c 100644 --- a/src/libsemver/lib.rs +++ b/src/libsemver/lib.rs @@ -381,22 +381,22 @@ fn test_ne() { #[test] fn test_show() { - assert_eq!(format!("{}", parse("1.2.3").unwrap()), + assert_eq!(format!("{}", parse("1.2.3").assert()), "1.2.3".to_string()); - assert_eq!(format!("{}", parse("1.2.3-alpha1").unwrap()), + assert_eq!(format!("{}", parse("1.2.3-alpha1").assert()), "1.2.3-alpha1".to_string()); - assert_eq!(format!("{}", parse("1.2.3+build.42").unwrap()), + assert_eq!(format!("{}", parse("1.2.3+build.42").assert()), "1.2.3+build.42".to_string()); - assert_eq!(format!("{}", parse("1.2.3-alpha1+42").unwrap()), + assert_eq!(format!("{}", parse("1.2.3-alpha1+42").assert()), "1.2.3-alpha1+42".to_string()); } #[test] fn test_to_string() { - assert_eq!(parse("1.2.3").unwrap().to_string(), "1.2.3".to_string()); - assert_eq!(parse("1.2.3-alpha1").unwrap().to_string(), "1.2.3-alpha1".to_string()); - assert_eq!(parse("1.2.3+build.42").unwrap().to_string(), "1.2.3+build.42".to_string()); - assert_eq!(parse("1.2.3-alpha1+42").unwrap().to_string(), "1.2.3-alpha1+42".to_string()); + assert_eq!(parse("1.2.3").assert().to_string(), "1.2.3".to_string()); + assert_eq!(parse("1.2.3-alpha1").assert().to_string(), "1.2.3-alpha1".to_string()); + assert_eq!(parse("1.2.3+build.42").assert().to_string(), "1.2.3+build.42".to_string()); + assert_eq!(parse("1.2.3-alpha1+42").assert().to_string(), "1.2.3-alpha1+42".to_string()); } #[test] @@ -453,8 +453,8 @@ fn test_spec_order() { "1.0.0"]; let mut i = 1; while i < vs.len() { - let a = parse(vs[i-1]).unwrap(); - let b = parse(vs[i]).unwrap(); + let a = parse(vs[i-1]).assert(); + let b = parse(vs[i]).assert(); assert!(a < b); i += 1; } diff --git a/src/libserialize/base64.rs b/src/libserialize/base64.rs index f85f3a43974b9..54d010ef209d1 100644 --- a/src/libserialize/base64.rs +++ b/src/libserialize/base64.rs @@ -199,9 +199,9 @@ impl<'a> FromBase64 for &'a str { * println!("base64 output: {}", hello_str); * let res = hello_str.as_slice().from_base64(); * if res.is_ok() { - * let opt_bytes = String::from_utf8(res.unwrap()); + * let opt_bytes = String::from_utf8(res.assert()); * if opt_bytes.is_ok() { - * println!("decoded from base64: {}", opt_bytes.unwrap()); + * println!("decoded from base64: {}", opt_bytes.assert()); * } * } * } @@ -308,31 +308,31 @@ mod tests { #[test] fn test_from_base64_basic() { - assert_eq!("".from_base64().unwrap().as_slice(), "".as_bytes()); - assert_eq!("Zg==".from_base64().unwrap().as_slice(), "f".as_bytes()); - assert_eq!("Zm8=".from_base64().unwrap().as_slice(), "fo".as_bytes()); - assert_eq!("Zm9v".from_base64().unwrap().as_slice(), "foo".as_bytes()); - assert_eq!("Zm9vYg==".from_base64().unwrap().as_slice(), "foob".as_bytes()); - assert_eq!("Zm9vYmE=".from_base64().unwrap().as_slice(), "fooba".as_bytes()); - assert_eq!("Zm9vYmFy".from_base64().unwrap().as_slice(), "foobar".as_bytes()); + assert_eq!("".from_base64().assert().as_slice(), "".as_bytes()); + assert_eq!("Zg==".from_base64().assert().as_slice(), "f".as_bytes()); + assert_eq!("Zm8=".from_base64().assert().as_slice(), "fo".as_bytes()); + assert_eq!("Zm9v".from_base64().assert().as_slice(), "foo".as_bytes()); + assert_eq!("Zm9vYg==".from_base64().assert().as_slice(), "foob".as_bytes()); + assert_eq!("Zm9vYmE=".from_base64().assert().as_slice(), "fooba".as_bytes()); + assert_eq!("Zm9vYmFy".from_base64().assert().as_slice(), "foobar".as_bytes()); } #[test] fn test_from_base64_bytes() { - assert_eq!(b"Zm9vYmFy".from_base64().unwrap().as_slice(), "foobar".as_bytes()); + assert_eq!(b"Zm9vYmFy".from_base64().assert().as_slice(), "foobar".as_bytes()); } #[test] fn test_from_base64_newlines() { - assert_eq!("Zm9v\r\nYmFy".from_base64().unwrap().as_slice(), + assert_eq!("Zm9v\r\nYmFy".from_base64().assert().as_slice(), "foobar".as_bytes()); - assert_eq!("Zm9vYg==\r\n".from_base64().unwrap().as_slice(), + assert_eq!("Zm9vYg==\r\n".from_base64().assert().as_slice(), "foob".as_bytes()); } #[test] fn test_from_base64_urlsafe() { - assert_eq!("-_8".from_base64().unwrap(), "+/8=".from_base64().unwrap()); + assert_eq!("-_8".from_base64().assert(), "+/8=".from_base64().assert()); } #[test] @@ -357,7 +357,7 @@ mod tests { .to_base64(STANDARD) .as_slice() .from_base64() - .unwrap() + .assert() .as_slice(), v.as_slice()); } @@ -379,7 +379,7 @@ mod tests { ウヰノオクヤマ ケフコエテ アサキユメミシ ヱヒモセスン"; let sb = s.as_bytes().to_base64(STANDARD); b.iter(|| { - sb.as_slice().from_base64().unwrap(); + sb.as_slice().from_base64().assert(); }); b.bytes = sb.len() as u64; } diff --git a/src/libserialize/hex.rs b/src/libserialize/hex.rs index f33ecb5f19bc8..e682d9b1d738e 100644 --- a/src/libserialize/hex.rs +++ b/src/libserialize/hex.rs @@ -96,9 +96,9 @@ impl<'a> FromHex for &'a str { * fn main () { * let hello_str = "Hello, World".as_bytes().to_hex(); * println!("{}", hello_str); - * let bytes = hello_str.as_slice().from_hex().unwrap(); + * let bytes = hello_str.as_slice().from_hex().assert(); * println!("{}", bytes); - * let result_str = String::from_utf8(bytes).unwrap(); + * let result_str = String::from_utf8(bytes).assert(); * println!("{}", result_str); * } * ``` @@ -131,7 +131,7 @@ impl<'a> FromHex for &'a str { } match modulus { - 0 => Ok(b.move_iter().collect()), + 0 => Ok(b.iter_owned().collect()), _ => Err(InvalidHexLength), } } @@ -150,9 +150,9 @@ mod tests { #[test] pub fn test_from_hex_okay() { - assert_eq!("666f6f626172".from_hex().unwrap().as_slice(), + assert_eq!("666f6f626172".from_hex().assert().as_slice(), "foobar".as_bytes()); - assert_eq!("666F6F626172".from_hex().unwrap().as_slice(), + assert_eq!("666F6F626172".from_hex().assert().as_slice(), "foobar".as_bytes()); } @@ -169,7 +169,7 @@ mod tests { #[test] pub fn test_from_hex_ignores_whitespace() { - assert_eq!("666f 6f6\r\n26172 ".from_hex().unwrap().as_slice(), + assert_eq!("666f 6f6\r\n26172 ".from_hex().assert().as_slice(), "foobar".as_bytes()); } @@ -185,12 +185,12 @@ mod tests { for i in range(0u, 256) { assert_eq!(format!("{:02x}", i as uint).as_slice() .from_hex() - .unwrap() + .assert() .as_slice(), &[i as u8]); assert_eq!(format!("{:02X}", i as uint).as_slice() .from_hex() - .unwrap() + .assert() .as_slice(), &[i as u8]); } @@ -212,7 +212,7 @@ mod tests { ウヰノオクヤマ ケフコエテ アサキユメミシ ヱヒモセスン"; let sb = s.as_bytes().to_hex(); b.iter(|| { - sb.as_slice().from_hex().unwrap(); + sb.as_slice().from_hex().assert(); }); b.bytes = sb.len() as u64; } diff --git a/src/libserialize/json.rs b/src/libserialize/json.rs index 58d69e38cc6e0..8cbf9eb0beac2 100644 --- a/src/libserialize/json.rs +++ b/src/libserialize/json.rs @@ -100,7 +100,7 @@ fn main() { let encoded = json::encode(&object); // Deserialize using `json::decode` - let decoded: TestStruct = json::decode(encoded.as_slice()).unwrap(); + let decoded: TestStruct = json::decode(encoded.as_slice()).assert(); } ``` @@ -188,7 +188,7 @@ fn main() { let json_str: String = json_obj.to_string(); // Deserialize like before - let decoded: TestStruct = json::decode(json_str.as_slice()).unwrap(); + let decoded: TestStruct = json::decode(json_str.as_slice()).assert(); } ``` @@ -296,7 +296,7 @@ pub fn decode<T: ::Decodable<Decoder, DecoderError>>(s: &str) -> DecodeResult<T> /// Shortcut function to encode a `T` into a JSON `String` pub fn encode<'a, T: Encodable<Encoder<'a>, io::IoError>>(object: &T) -> String { let buff = Encoder::buffer_encode(object); - String::from_utf8(buff).unwrap() + String::from_utf8(buff).assert() } impl fmt::Show for ErrorCode { @@ -573,7 +573,7 @@ impl<'a> ::Encoder<io::IoError> for Encoder<'a> { let mut check_encoder = Encoder::new(&mut buf); try!(f(transmute(&mut check_encoder))); } - let out = str::from_utf8(buf.get_ref()).unwrap(); + let out = str::from_utf8(buf.get_ref()).assert(); let needs_wrapping = out.char_at(0) != '"' && out.char_at_reverse(out.len()) != '"'; if needs_wrapping { try!(write!(self.writer, "\"")); } try!(f(self)); @@ -817,7 +817,7 @@ impl<'a> ::Encoder<io::IoError> for PrettyEncoder<'a> { let mut check_encoder = PrettyEncoder::new(&mut buf); try!(f(transmute(&mut check_encoder))); } - let out = str::from_utf8(buf.get_ref()).unwrap(); + let out = str::from_utf8(buf.get_ref()).assert(); let needs_wrapping = out.char_at(0) != '"' && out.char_at_reverse(out.len()) != '"'; if needs_wrapping { try!(write!(self.writer, "\"")); } try!(f(self)); @@ -863,8 +863,8 @@ impl Json { /// Encodes a json value into a string pub fn to_pretty_str(&self) -> String { let mut s = MemWriter::new(); - self.to_pretty_writer(&mut s as &mut io::Writer).unwrap(); - String::from_utf8(s.unwrap()).unwrap() + self.to_pretty_writer(&mut s as &mut io::Writer).assert(); + String::from_utf8(s.unwrap()).assert() } /// If the Json value is an Object, returns the value associated with the provided key. @@ -1075,7 +1075,7 @@ impl Stack { InternalIndex(i) => { Index(i) } InternalKey(start, size) => { Key(str::from_utf8( - self.str_buffer.slice(start as uint, start as uint + size as uint)).unwrap()) + self.str_buffer.slice(start as uint, start as uint + size as uint)).assert()) } } } @@ -1118,7 +1118,7 @@ impl Stack { Some(&InternalKey(start, size)) => { Some(Key(str::from_utf8( self.str_buffer.slice(start as uint, (start+size) as uint) - ).unwrap())) + ).assert())) } } } @@ -1139,7 +1139,7 @@ impl Stack { // Used by Parser to remove the top-most element of the stack. fn pop(&mut self) { assert!(!self.is_empty()); - match *self.stack.last().unwrap() { + match *self.stack.last().assert() { InternalKey(_, sz) => { let new_size = self.str_buffer.len() - sz as uint; self.str_buffer.truncate(new_size); @@ -1152,7 +1152,7 @@ impl Stack { // Used by Parser to test whether the top-most element is an index. fn last_is_index(&self) -> bool { if self.is_empty() { return false; } - return match *self.stack.last().unwrap() { + return match *self.stack.last().assert() { InternalIndex(_) => true, _ => false, } @@ -1161,7 +1161,7 @@ impl Stack { // Used by Parser to increment the index of the top-most element. fn bump_index(&mut self) { let len = self.stack.len(); - let idx = match *self.stack.last().unwrap() { + let idx = match *self.stack.last().assert() { InternalIndex(i) => { i + 1 } _ => { fail!(); } }; @@ -1743,7 +1743,7 @@ impl<T: Iterator<char>> Builder<T> { loop { if self.token == Some(ListEnd) { - return Ok(List(values.move_iter().collect())); + return Ok(List(values.iter_owned().collect())); } match self.build_value() { Ok(v) => values.push(v), @@ -1813,7 +1813,7 @@ impl Decoder { impl Decoder { fn pop(&mut self) -> Json { - self.stack.pop().unwrap() + self.stack.pop().assert() } } @@ -1866,7 +1866,7 @@ impl ::Decoder<DecoderError> for Decoder { String(s) => { // re: #12967.. a type w/ numeric keys (ie HashMap<uint, V> etc) // is going to have a string here, as per JSON spec. - Ok(std::from_str::from_str(s.as_slice()).unwrap()) + Ok(std::from_str::from_str(s.as_slice()).assert()) }, Null => Ok(f64::NAN), value => Err(ExpectedError("Number".to_string(), format!("{}", value))) @@ -1919,7 +1919,7 @@ impl ::Decoder<DecoderError> for Decoder { }; match o.pop(&"fields".to_string()) { Some(List(l)) => { - for field in l.move_iter().rev() { + for field in l.iter_owned().rev() { self.stack.push(field); } }, @@ -2037,7 +2037,7 @@ impl ::Decoder<DecoderError> for Decoder { debug!("read_seq()"); let list = try!(expect!(self.pop(), List)); let len = list.len(); - for v in list.move_iter().rev() { + for v in list.iter_owned().rev() { self.stack.push(v); } f(self, len) @@ -2054,7 +2054,7 @@ impl ::Decoder<DecoderError> for Decoder { debug!("read_map()"); let obj = try!(expect!(self.pop(), Object)); let len = obj.len(); - for (key, value) in obj.move_iter() { + for (key, value) in obj.iter_owned() { self.stack.push(value); self.stack.push(String(key)); } @@ -2255,7 +2255,7 @@ mod tests { #[test] fn test_from_str_trait() { let s = "null"; - assert!(::std::from_str::from_str::<Json>(s).unwrap() == from_str(s).unwrap()); + assert!(::std::from_str::from_str::<Json>(s).assert() == from_str(s).assert()); } #[test] @@ -2402,9 +2402,9 @@ mod tests { // We can't compare the strings directly because the object fields be // printed in a different order. - assert_eq!(a.clone(), from_str(a.to_string().as_slice()).unwrap()); + assert_eq!(a.clone(), from_str(a.to_string().as_slice()).assert()); assert_eq!(a.clone(), - from_str(a.to_pretty_str().as_slice()).unwrap()); + from_str(a.to_pretty_str().as_slice()).assert()); } fn with_str_writer(f: |&mut io::Writer|) -> String { @@ -2413,7 +2413,7 @@ mod tests { let mut m = MemWriter::new(); f(&mut m as &mut io::Writer); - str::from_utf8(m.unwrap().as_slice()).unwrap().to_string() + str::from_utf8(m.assert().as_slice()).assert().to_string() } #[test] @@ -2422,14 +2422,14 @@ mod tests { assert_eq!( with_str_writer(|writer| { let mut encoder = Encoder::new(writer); - animal.encode(&mut encoder).unwrap(); + animal.encode(&mut encoder).assert(); }), "\"Dog\"".to_string() ); assert_eq!( with_str_writer(|writer| { let mut encoder = PrettyEncoder::new(writer); - animal.encode(&mut encoder).unwrap(); + animal.encode(&mut encoder).assert(); }), "\"Dog\"".to_string() ); @@ -2438,14 +2438,14 @@ mod tests { assert_eq!( with_str_writer(|writer| { let mut encoder = Encoder::new(writer); - animal.encode(&mut encoder).unwrap(); + animal.encode(&mut encoder).assert(); }), "{\"variant\":\"Frog\",\"fields\":[\"Henry\",349]}".to_string() ); assert_eq!( with_str_writer(|writer| { let mut encoder = PrettyEncoder::new(writer); - animal.encode(&mut encoder).unwrap(); + animal.encode(&mut encoder).assert(); }), "\ [\n \ @@ -2461,14 +2461,14 @@ mod tests { let value = Some("jodhpurs".to_string()); let s = with_str_writer(|writer| { let mut encoder = Encoder::new(writer); - value.encode(&mut encoder).unwrap(); + value.encode(&mut encoder).assert(); }); assert_eq!(s, "\"jodhpurs\"".to_string()); let value = Some("jodhpurs".to_string()); let s = with_str_writer(|writer| { let mut encoder = PrettyEncoder::new(writer); - value.encode(&mut encoder).unwrap(); + value.encode(&mut encoder).assert(); }); assert_eq!(s, "\"jodhpurs\"".to_string()); } @@ -2478,13 +2478,13 @@ mod tests { let value: Option<String> = None; let s = with_str_writer(|writer| { let mut encoder = Encoder::new(writer); - value.encode(&mut encoder).unwrap(); + value.encode(&mut encoder).assert(); }); assert_eq!(s, "null".to_string()); let s = with_str_writer(|writer| { let mut encoder = Encoder::new(writer); - value.encode(&mut encoder).unwrap(); + value.encode(&mut encoder).assert(); }); assert_eq!(s, "null".to_string()); } @@ -2518,13 +2518,13 @@ mod tests { #[test] fn test_decode_identifiers() { - let v: () = super::decode("null").unwrap(); + let v: () = super::decode("null").assert(); assert_eq!(v, ()); - let v: bool = super::decode("true").unwrap(); + let v: bool = super::decode("true").assert(); assert_eq!(v, true); - let v: bool = super::decode("false").unwrap(); + let v: bool = super::decode("false").assert(); assert_eq!(v, false); } @@ -2551,25 +2551,25 @@ mod tests { #[test] fn test_decode_numbers() { - let v: f64 = super::decode("3").unwrap(); + let v: f64 = super::decode("3").assert(); assert_eq!(v, 3.0); - let v: f64 = super::decode("3.1").unwrap(); + let v: f64 = super::decode("3.1").assert(); assert_eq!(v, 3.1); - let v: f64 = super::decode("-1.2").unwrap(); + let v: f64 = super::decode("-1.2").assert(); assert_eq!(v, -1.2); - let v: f64 = super::decode("0.4").unwrap(); + let v: f64 = super::decode("0.4").assert(); assert_eq!(v, 0.4); - let v: f64 = super::decode("0.4e5").unwrap(); + let v: f64 = super::decode("0.4e5").assert(); assert_eq!(v, 0.4e5); - let v: f64 = super::decode("0.4e15").unwrap(); + let v: f64 = super::decode("0.4e15").assert(); assert_eq!(v, 0.4e15); - let v: f64 = super::decode("0.4e-01").unwrap(); + let v: f64 = super::decode("0.4e-01").assert(); assert_eq!(v, 0.4e-01); } @@ -2603,7 +2603,7 @@ mod tests { ("\"\\uAB12\"", "\uAB12")]; for &(i, o) in s.iter() { - let v: String = super::decode(i).unwrap(); + let v: String = super::decode(i).assert(); assert_eq!(v.as_slice(), o); } } @@ -2631,19 +2631,19 @@ mod tests { #[test] fn test_decode_list() { - let v: Vec<()> = super::decode("[]").unwrap(); + let v: Vec<()> = super::decode("[]").assert(); assert_eq!(v, vec![]); - let v: Vec<()> = super::decode("[null]").unwrap(); + let v: Vec<()> = super::decode("[null]").assert(); assert_eq!(v, vec![()]); - let v: Vec<bool> = super::decode("[true]").unwrap(); + let v: Vec<bool> = super::decode("[true]").assert(); assert_eq!(v, vec![true]); - let v: Vec<int> = super::decode("[3, 1]").unwrap(); + let v: Vec<int> = super::decode("[3, 1]").assert(); assert_eq!(v, vec![3, 1]); - let v: Vec<Vec<uint>> = super::decode("[[3], [1, 2]]").unwrap(); + let v: Vec<Vec<uint>> = super::decode("[[3], [1, 2]]").assert(); assert_eq!(v, vec![vec![3], vec![1, 2]]); } @@ -2662,21 +2662,21 @@ mod tests { assert_eq!(from_str("{\"a\":1 1"), Err(SyntaxError(InvalidSyntax, 1, 8))); assert_eq!(from_str("{\"a\":1,"), Err(SyntaxError(EOFWhileParsingObject, 1, 8))); - assert_eq!(from_str("{}").unwrap(), mk_object([])); - assert_eq!(from_str("{\"a\": 3}").unwrap(), + assert_eq!(from_str("{}").assert(), mk_object([])); + assert_eq!(from_str("{\"a\": 3}").assert(), mk_object([("a".to_string(), Number(3.0))])); assert_eq!(from_str( - "{ \"a\": null, \"b\" : true }").unwrap(), + "{ \"a\": null, \"b\" : true }").assert(), mk_object([ ("a".to_string(), Null), ("b".to_string(), Boolean(true))])); - assert_eq!(from_str("\n{ \"a\": null, \"b\" : true }\n").unwrap(), + assert_eq!(from_str("\n{ \"a\": null, \"b\" : true }\n").assert(), mk_object([ ("a".to_string(), Null), ("b".to_string(), Boolean(true))])); assert_eq!(from_str( - "{\"a\" : 1.0 ,\"b\": [ true ]}").unwrap(), + "{\"a\" : 1.0 ,\"b\": [ true ]}").assert(), mk_object([ ("a".to_string(), Number(1.0)), ("b".to_string(), List(vec![Boolean(true)])) @@ -2689,7 +2689,7 @@ mod tests { \"foo\\nbar\", \ { \"c\": {\"d\": null} } \ ]\ - }").unwrap(), + }").assert(), mk_object([ ("a".to_string(), Number(1.0)), ("b".to_string(), List(vec![ @@ -2710,7 +2710,7 @@ mod tests { ] }"; - let v: Outer = super::decode(s).unwrap(); + let v: Outer = super::decode(s).assert(); assert_eq!( v, Outer { @@ -2729,7 +2729,7 @@ mod tests { #[test] fn test_decode_struct_with_nan() { let s = "{\"f\":null,\"a\":[null,123]}"; - let obj: FloatStruct = super::decode(s).unwrap(); + let obj: FloatStruct = super::decode(s).assert(); assert!(obj.f.is_nan()); assert!(obj.a.get(0).is_nan()); assert_eq!(obj.a.get(1), &123f64); @@ -2737,20 +2737,20 @@ mod tests { #[test] fn test_decode_option() { - let value: Option<String> = super::decode("null").unwrap(); + let value: Option<String> = super::decode("null").assert(); assert_eq!(value, None); - let value: Option<String> = super::decode("\"jodhpurs\"").unwrap(); + let value: Option<String> = super::decode("\"jodhpurs\"").assert(); assert_eq!(value, Some("jodhpurs".to_string())); } #[test] fn test_decode_enum() { - let value: Animal = super::decode("\"Dog\"").unwrap(); + let value: Animal = super::decode("\"Dog\"").assert(); assert_eq!(value, Dog); let s = "{\"variant\":\"Frog\",\"fields\":[\"Henry\",349]}"; - let value: Animal = super::decode(s).unwrap(); + let value: Animal = super::decode(s).assert(); assert_eq!(value, Frog("Henry".to_string(), 349)); } @@ -2758,7 +2758,7 @@ mod tests { fn test_decode_map() { let s = "{\"a\": \"Dog\", \"b\": {\"variant\":\"Frog\",\ \"fields\":[\"Henry\", 349]}}"; - let mut map: TreeMap<String, Animal> = super::decode(s).unwrap(); + let mut map: TreeMap<String, Animal> = super::decode(s).assert(); assert_eq!(map.pop(&"a".to_string()), Some(Dog)); assert_eq!(map.pop(&"b".to_string()), Some(Frog("Henry".to_string(), 349))); @@ -2830,63 +2830,63 @@ mod tests { #[test] fn test_find(){ - let json_value = from_str("{\"dog\" : \"cat\"}").unwrap(); + let json_value = from_str("{\"dog\" : \"cat\"}").assert(); let found_str = json_value.find(&"dog".to_string()); - assert!(found_str.is_some() && found_str.unwrap().as_string().unwrap() == "cat"); + assert!(found_str.is_some() && found_str.assert().as_string().assert() == "cat"); } #[test] fn test_find_path(){ - let json_value = from_str("{\"dog\":{\"cat\": {\"mouse\" : \"cheese\"}}}").unwrap(); + let json_value = from_str("{\"dog\":{\"cat\": {\"mouse\" : \"cheese\"}}}").assert(); let found_str = json_value.find_path(&[&"dog".to_string(), &"cat".to_string(), &"mouse".to_string()]); - assert!(found_str.is_some() && found_str.unwrap().as_string().unwrap() == "cheese"); + assert!(found_str.is_some() && found_str.assert().as_string().assert() == "cheese"); } #[test] fn test_search(){ - let json_value = from_str("{\"dog\":{\"cat\": {\"mouse\" : \"cheese\"}}}").unwrap(); + let json_value = from_str("{\"dog\":{\"cat\": {\"mouse\" : \"cheese\"}}}").assert(); let found_str = json_value.search(&"mouse".to_string()).and_then(|j| j.as_string()); assert!(found_str.is_some()); - assert!(found_str.unwrap() == "cheese"); + assert!(found_str.assert() == "cheese"); } #[test] fn test_is_object(){ - let json_value = from_str("{}").unwrap(); + let json_value = from_str("{}").assert(); assert!(json_value.is_object()); } #[test] fn test_as_object(){ - let json_value = from_str("{}").unwrap(); + let json_value = from_str("{}").assert(); let json_object = json_value.as_object(); assert!(json_object.is_some()); } #[test] fn test_is_list(){ - let json_value = from_str("[1, 2, 3]").unwrap(); + let json_value = from_str("[1, 2, 3]").assert(); assert!(json_value.is_list()); } #[test] fn test_as_list(){ - let json_value = from_str("[1, 2, 3]").unwrap(); + let json_value = from_str("[1, 2, 3]").assert(); let json_list = json_value.as_list(); let expected_length = 3; - assert!(json_list.is_some() && json_list.unwrap().len() == expected_length); + assert!(json_list.is_some() && json_list.assert().len() == expected_length); } #[test] fn test_is_string(){ - let json_value = from_str("\"dog\"").unwrap(); + let json_value = from_str("\"dog\"").assert(); assert!(json_value.is_string()); } #[test] fn test_as_string(){ - let json_value = from_str("\"dog\"").unwrap(); + let json_value = from_str("\"dog\"").assert(); let json_str = json_value.as_string(); let expected_str = "dog"; assert_eq!(json_str, Some(expected_str)); @@ -2894,44 +2894,44 @@ mod tests { #[test] fn test_is_number(){ - let json_value = from_str("12").unwrap(); + let json_value = from_str("12").assert(); assert!(json_value.is_number()); } #[test] fn test_as_number(){ - let json_value = from_str("12").unwrap(); + let json_value = from_str("12").assert(); let json_num = json_value.as_number(); let expected_num = 12f64; - assert!(json_num.is_some() && json_num.unwrap() == expected_num); + assert!(json_num.is_some() && json_num.assert() == expected_num); } #[test] fn test_is_boolean(){ - let json_value = from_str("false").unwrap(); + let json_value = from_str("false").assert(); assert!(json_value.is_boolean()); } #[test] fn test_as_boolean(){ - let json_value = from_str("false").unwrap(); + let json_value = from_str("false").assert(); let json_bool = json_value.as_boolean(); let expected_bool = false; - assert!(json_bool.is_some() && json_bool.unwrap() == expected_bool); + assert!(json_bool.is_some() && json_bool.assert() == expected_bool); } #[test] fn test_is_null(){ - let json_value = from_str("null").unwrap(); + let json_value = from_str("null").assert(); assert!(json_value.is_null()); } #[test] fn test_as_null(){ - let json_value = from_str("null").unwrap(); + let json_value = from_str("null").assert(); let json_null = json_value.as_null(); let expected_null = (); - assert!(json_null.is_some() && json_null.unwrap() == expected_null); + assert!(json_null.is_some() && json_null.assert() == expected_null); } #[test] @@ -2945,10 +2945,10 @@ mod tests { let mut mem_buf = MemWriter::new(); { let mut encoder = Encoder::new(&mut mem_buf as &mut io::Writer); - hm.encode(&mut encoder).unwrap(); + hm.encode(&mut encoder).assert(); } - let bytes = mem_buf.unwrap(); - let json_str = from_utf8(bytes.as_slice()).unwrap(); + let bytes = mem_buf.assert(); + let json_str = from_utf8(bytes.as_slice()).assert(); match from_str(json_str) { Err(_) => fail!("Unable to parse json_str: {}", json_str), _ => {} // it parsed and we are good to go @@ -2965,10 +2965,10 @@ mod tests { let mut mem_buf = MemWriter::new(); { let mut encoder = PrettyEncoder::new(&mut mem_buf as &mut io::Writer); - hm.encode(&mut encoder).unwrap() + hm.encode(&mut encoder).assert() } - let bytes = mem_buf.unwrap(); - let json_str = from_utf8(bytes.as_slice()).unwrap(); + let bytes = mem_buf.assert(); + let json_str = from_utf8(bytes.as_slice()).assert(); match from_str(json_str) { Err(_) => fail!("Unable to parse json_str: {}", json_str), _ => {} // it parsed and we are good to go @@ -2984,7 +2984,7 @@ mod tests { Ok(o) => o }; let mut decoder = Decoder::new(json_obj); - let _hm: HashMap<uint, bool> = Decodable::decode(&mut decoder).unwrap(); + let _hm: HashMap<uint, bool> = Decodable::decode(&mut decoder).assert(); } fn assert_stream_equal(src: &str, diff --git a/src/libstd/ascii.rs b/src/libstd/ascii.rs index e8352dcd40cdc..cdd51889a044c 100644 --- a/src/libstd/ascii.rs +++ b/src/libstd/ascii.rs @@ -464,7 +464,7 @@ impl<'a> AsciiExt<Vec<u8>> for &'a [u8] { impl OwnedAsciiExt for Vec<u8> { #[inline] fn into_ascii_upper(mut self) -> Vec<u8> { - for byte in self.mut_iter() { + for byte in self.iter_mut() { *byte = ASCII_UPPER_MAP[*byte as uint]; } self @@ -472,7 +472,7 @@ impl OwnedAsciiExt for Vec<u8> { #[inline] fn into_ascii_lower(mut self) -> Vec<u8> { - for byte in self.mut_iter() { + for byte in self.iter_mut() { *byte = ASCII_LOWER_MAP[*byte as uint]; } self @@ -714,8 +714,8 @@ mod tests { while i <= 500 { let upper = if 'a' as u32 <= i && i <= 'z' as u32 { i + 'A' as u32 - 'a' as u32 } else { i }; - assert_eq!((from_u32(i).unwrap()).to_string().as_slice().to_ascii_upper(), - (from_u32(upper).unwrap()).to_string()) + assert_eq!((from_u32(i).assert()).to_string().as_slice().to_ascii_upper(), + (from_u32(upper).assert()).to_string()) i += 1; } } @@ -730,8 +730,8 @@ mod tests { while i <= 500 { let lower = if 'A' as u32 <= i && i <= 'Z' as u32 { i + 'a' as u32 - 'A' as u32 } else { i }; - assert_eq!((from_u32(i).unwrap()).to_string().as_slice().to_ascii_lower(), - (from_u32(lower).unwrap()).to_string()) + assert_eq!((from_u32(i).assert()).to_string().as_slice().to_ascii_lower(), + (from_u32(lower).assert()).to_string()) i += 1; } } @@ -746,8 +746,8 @@ mod tests { while i <= 500 { let upper = if 'a' as u32 <= i && i <= 'z' as u32 { i + 'A' as u32 - 'a' as u32 } else { i }; - assert_eq!((from_u32(i).unwrap()).to_string().into_ascii_upper(), - (from_u32(upper).unwrap()).to_string()) + assert_eq!((from_u32(i).assert()).to_string().into_ascii_upper(), + (from_u32(upper).assert()).to_string()) i += 1; } } @@ -763,8 +763,8 @@ mod tests { while i <= 500 { let lower = if 'A' as u32 <= i && i <= 'Z' as u32 { i + 'a' as u32 - 'A' as u32 } else { i }; - assert_eq!((from_u32(i).unwrap()).to_string().into_ascii_lower(), - (from_u32(lower).unwrap()).to_string()) + assert_eq!((from_u32(i).assert()).to_string().into_ascii_lower(), + (from_u32(lower).assert()).to_string()) i += 1; } } @@ -784,8 +784,8 @@ mod tests { let c = i; let lower = if 'A' as u32 <= c && c <= 'Z' as u32 { c + 'a' as u32 - 'A' as u32 } else { c }; - assert!((from_u32(i).unwrap()).to_string().as_slice().eq_ignore_ascii_case( - (from_u32(lower).unwrap()).to_string().as_slice())); + assert!((from_u32(i).assert()).to_string().as_slice().eq_ignore_ascii_case( + (from_u32(lower).assert()).to_string().as_slice())); i += 1; } } diff --git a/src/libstd/c_vec.rs b/src/libstd/c_vec.rs index 80fe05fcea5cd..932cd9d2806d8 100644 --- a/src/libstd/c_vec.rs +++ b/src/libstd/c_vec.rs @@ -73,7 +73,7 @@ impl<T> CVec<T> { /// * base - A raw pointer to a buffer /// * len - The number of elements in the buffer pub unsafe fn new(base: *mut T, len: uint) -> CVec<T> { - assert!(base != ptr::mut_null()); + assert!(base != ptr::null_mut()); CVec { base: base, len: len, @@ -94,7 +94,7 @@ impl<T> CVec<T> { /// for freeing the buffer, etc. pub unsafe fn new_with_dtor(base: *mut T, len: uint, dtor: proc():Send) -> CVec<T> { - assert!(base != ptr::mut_null()); + assert!(base != ptr::null_mut()); CVec { base: base, len: len, @@ -180,10 +180,10 @@ mod tests { fn test_basic() { let mut cv = malloc(16); - *cv.get_mut(3).unwrap() = 8; - *cv.get_mut(4).unwrap() = 9; - assert_eq!(*cv.get(3).unwrap(), 8); - assert_eq!(*cv.get(4).unwrap(), 9); + *cv.get_mut(3).assert() = 8; + *cv.get_mut(4).assert() = 9; + assert_eq!(*cv.get(3).assert(), 8); + assert_eq!(*cv.get(4).assert(), 9); assert_eq!(cv.len(), 16); } diff --git a/src/libstd/collections/hashmap.rs b/src/libstd/collections/hashmap.rs index e95a5305bc770..f13a63ed824d5 100644 --- a/src/libstd/collections/hashmap.rs +++ b/src/libstd/collections/hashmap.rs @@ -385,12 +385,12 @@ mod table { Entries { table: self, idx: 0, elems_seen: 0 } } - pub fn mut_iter<'a>(&'a mut self) -> MutEntries<'a, K, V> { - MutEntries { table: self, idx: 0, elems_seen: 0 } + pub fn iter_mut<'a>(&'a mut self) -> EntriesMut<'a, K, V> { + EntriesMut { table: self, idx: 0, elems_seen: 0 } } - pub fn move_iter(self) -> MoveEntries<K, V> { - MoveEntries { table: self, idx: 0 } + pub fn iter_owned(self) -> EntriesOwned<K, V> { + EntriesOwned { table: self, idx: 0 } } } @@ -416,18 +416,26 @@ mod table { } /// Iterator over mutable references to entries in a table. - pub struct MutEntries<'a, K, V> { + pub struct EntriesMut<'a, K, V> { table: &'a mut RawTable<K, V>, idx: uint, elems_seen: uint, } + /// Deprecated: renamed to `EntriesMut` + #[deprecated = "renamed to EntriesMut"] + pub type MutEntries<'a, K, V> = EntriesMut<'a, K, V>; + /// Iterator over the entries in a table, consuming the table. - pub struct MoveEntries<K, V> { + pub struct EntriesOwned<K, V> { table: RawTable<K, V>, idx: uint } + /// Deprecated: renamed to `EntriesOwned` + #[deprecated = "renamed to EntriesOwned"] + pub type MoveEntries<K, V> = EntriesOwned<K, V>; + impl<'a, K, V> Iterator<(&'a K, &'a V)> for Entries<'a, K, V> { fn next(&mut self) -> Option<(&'a K, &'a V)> { while self.idx < self.table.capacity() { @@ -452,7 +460,7 @@ mod table { } } - impl<'a, K, V> Iterator<(&'a K, &'a mut V)> for MutEntries<'a, K, V> { + impl<'a, K, V> Iterator<(&'a K, &'a mut V)> for EntriesMut<'a, K, V> { fn next(&mut self) -> Option<(&'a K, &'a mut V)> { while self.idx < self.table.capacity() { let i = self.idx; @@ -479,7 +487,7 @@ mod table { } } - impl<K, V> Iterator<(SafeHash, K, V)> for MoveEntries<K, V> { + impl<K, V> Iterator<(SafeHash, K, V)> for EntriesOwned<K, V> { fn next(&mut self) -> Option<(SafeHash, K, V)> { while self.idx < self.table.capacity() { let i = self.idx; @@ -535,7 +543,7 @@ mod table { impl<K, V> Drop for RawTable<K, V> { fn drop(&mut self) { // This is in reverse because we're likely to have partially taken - // some elements out with `.move_iter()` from the front. + // some elements out with `.iter_owned()` from the front. for i in range_step_inclusive(self.capacity as int - 1, 0, -1) { // Check if the size is 0, so we don't do a useless scan when // dropping empty tables such as on resize. @@ -1147,7 +1155,7 @@ impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> HashMap<K, V, H> { let old_table = replace(&mut self.table, table::RawTable::new(new_capacity)); let old_size = old_table.size(); - for (h, k, v) in old_table.move_iter() { + for (h, k, v) in old_table.iter_owned() { self.insert_hashed_nocheck(h, k, v); } @@ -1374,7 +1382,7 @@ impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> HashMap<K, V, H> { /// /// let new = vec!["a key", "b key", "z key"]; /// - /// for k in new.move_iter() { + /// for k in new.iter_owned() { /// map.find_with_or_insert_with( /// k, "new value", /// // if the key does exist either prepend or append this @@ -1618,6 +1626,12 @@ impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> HashMap<K, V, H> { self.table.iter() } + /// Deprecated: renamed to `iter_mut` + #[deprecated = "renamed to iter_mut"] + pub fn mut_iter<'a>(&'a mut self) -> EntriesMut<'a, K, V> { + self.iter_mut() + } + /// An iterator visiting all key-value pairs in arbitrary order, /// with mutable references to the values. /// Iterator element type is `(&'a K, &'a mut V)`. @@ -1633,7 +1647,7 @@ impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> HashMap<K, V, H> { /// map.insert("c", 3); /// /// // Update all values - /// for (_, val) in map.mut_iter() { + /// for (_, val) in map.iter_mut() { /// *val *= 2; /// } /// @@ -1641,8 +1655,14 @@ impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> HashMap<K, V, H> { /// println!("key: {} val: {}", key, val); /// } /// ``` - pub fn mut_iter<'a>(&'a mut self) -> MutEntries<'a, K, V> { - self.table.mut_iter() + pub fn iter_mut<'a>(&'a mut self) -> EntriesMut<'a, K, V> { + self.table.iter_mut() + } + + /// Deprecated: renamed to `iter_owned`. + #[deprecated = "renamed to iter_owned"] + pub fn move_iter(self) -> EntriesOwned<K, V> { + self.iter_owned() } /// Creates a consuming iterator, that is, one that moves each key-value @@ -1660,10 +1680,10 @@ impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> HashMap<K, V, H> { /// map.insert("c", 3); /// /// // Not possible with .iter() - /// let vec: Vec<(&str, int)> = map.move_iter().collect(); + /// let vec: Vec<(&str, int)> = map.iter_owned().collect(); /// ``` - pub fn move_iter(self) -> MoveEntries<K, V> { - self.table.move_iter().map(|(_, k, v)| (k, v)) + pub fn iter_owned(self) -> EntriesOwned<K, V> { + self.table.iter_owned().map(|(_, k, v)| (k, v)) } } @@ -1677,7 +1697,7 @@ impl<K: Eq + Hash<S>, V: Clone, S, H: Hasher<S>> HashMap<K, V, H> { /// /// let mut map: HashMap<uint, String> = HashMap::new(); /// map.insert(1u, "foo".to_string()); - /// let s: String = map.find_copy(&1).unwrap(); + /// let s: String = map.find_copy(&1).assert(); /// ``` pub fn find_copy(&self, k: &K) -> Option<V> { self.find(k).map(|v| (*v).clone()) @@ -1742,11 +1762,11 @@ impl<K: Eq + Hash<S>, V, S, H: Hasher<S> + Default> Default for HashMap<K, V, H> pub type Entries<'a, K, V> = table::Entries<'a, K, V>; /// HashMap mutable values iterator -pub type MutEntries<'a, K, V> = table::MutEntries<'a, K, V>; +pub type EntriesMut<'a, K, V> = table::EntriesMut<'a, K, V>; /// HashMap move iterator -pub type MoveEntries<K, V> = - iter::Map<'static, (table::SafeHash, K, V), (K, V), table::MoveEntries<K, V>>; +pub type EntriesOwned<K, V> = + iter::Map<'static, (table::SafeHash, K, V), (K, V), table::EntriesOwned<K, V>>; /// HashMap keys iterator pub type Keys<'a, K, V> = @@ -1778,8 +1798,12 @@ pub type SetItems<'a, K> = iter::Map<'static, (&'a K, &'a ()), &'a K, Entries<'a, K, ()>>; /// HashSet move iterator -pub type SetMoveItems<K> = - iter::Map<'static, (K, ()), K, MoveEntries<K, ()>>; +pub type SetItemsOwned<K> = + iter::Map<'static, (K, ()), K, EntriesOwned<K, ()>>; + +/// Deprecated: renamed to `SetItemsOwned`. +#[deprecated = "renamed to SetItemsOwned"] +pub type SetMoveItems<K> = SetItemsOwned<K>; /// An implementation of a hash set using the underlying representation of a /// HashMap where the value is (). As with the `HashMap` type, a `HashSet` @@ -1996,6 +2020,12 @@ impl<T: Eq + Hash<S>, S, H: Hasher<S>> HashSet<T, H> { self.map.keys() } + /// Deprecated: renamed to `iter_owned`. + #[deprecated = "renamed to iter_owned"] + pub fn move_iter(self) -> SetItemsOwned<T> { + self.iter_owned() + } + /// Creates a consuming iterator, that is, one that moves each value out /// of the set in arbitrary order. The set cannot be used after calling /// this. @@ -2009,15 +2039,15 @@ impl<T: Eq + Hash<S>, S, H: Hasher<S>> HashSet<T, H> { /// set.insert("b".to_string()); /// /// // Not possible to collect to a Vec<String> with a regular `.iter()`. - /// let v: Vec<String> = set.move_iter().collect(); + /// let v: Vec<String> = set.iter_owned().collect(); /// /// // Will print in an arbitrary order. /// for x in v.iter() { /// println!("{}", x); /// } /// ``` - pub fn move_iter(self) -> SetMoveItems<T> { - self.map.move_iter().map(|(k, _)| k) + pub fn iter_owned(self) -> SetItemsOwned<T> { + self.map.iter_owned().map(|(k, _)| k) } /// Visit the values representing the difference. @@ -2245,8 +2275,8 @@ mod test_map { assert_eq!(m.len(), 1); assert!(m.insert(2i, 4i)); assert_eq!(m.len(), 2); - assert_eq!(*m.find(&1).unwrap(), 2); - assert_eq!(*m.find(&2).unwrap(), 4); + assert_eq!(*m.find(&1).assert(), 2); + assert_eq!(*m.find(&2).assert(), 4); } local_data_key!(drop_vector: RefCell<Vec<int>>) @@ -2259,7 +2289,7 @@ mod test_map { impl Dropable { fn new(k: uint) -> Dropable { - let v = drop_vector.get().unwrap(); + let v = drop_vector.get().assert(); v.borrow_mut().as_mut_slice()[k] += 1; Dropable { k: k } @@ -2268,7 +2298,7 @@ mod test_map { impl Drop for Dropable { fn drop(&mut self) { - let v = drop_vector.get().unwrap(); + let v = drop_vector.get().assert(); v.borrow_mut().as_mut_slice()[self.k] -= 1; } } @@ -2280,7 +2310,7 @@ mod test_map { { let mut m = HashMap::new(); - let v = drop_vector.get().unwrap(); + let v = drop_vector.get().assert(); for i in range(0u, 200) { assert_eq!(v.borrow().as_slice()[i], 0); } @@ -2292,7 +2322,7 @@ mod test_map { m.insert(d1, d2); } - let v = drop_vector.get().unwrap(); + let v = drop_vector.get().assert(); for i in range(0u, 200) { assert_eq!(v.borrow().as_slice()[i], 1); } @@ -2304,12 +2334,12 @@ mod test_map { assert!(v.is_some()); - let v = drop_vector.get().unwrap(); + let v = drop_vector.get().assert(); assert_eq!(v.borrow().as_slice()[i], 1); assert_eq!(v.borrow().as_slice()[i+100], 1); } - let v = drop_vector.get().unwrap(); + let v = drop_vector.get().assert(); for i in range(0u, 50) { assert_eq!(v.borrow().as_slice()[i], 0); assert_eq!(v.borrow().as_slice()[i+100], 0); @@ -2321,7 +2351,7 @@ mod test_map { } } - let v = drop_vector.get().unwrap(); + let v = drop_vector.get().assert(); for i in range(0u, 200) { assert_eq!(v.borrow().as_slice()[i], 0); } @@ -2413,9 +2443,9 @@ mod test_map { fn test_insert_overwrite() { let mut m = HashMap::new(); assert!(m.insert(1i, 2i)); - assert_eq!(*m.find(&1).unwrap(), 2); + assert_eq!(*m.find(&1).assert(), 2); assert!(!m.insert(1i, 3i)); - assert_eq!(*m.find(&1).unwrap(), 3); + assert_eq!(*m.find(&1).assert(), 3); } #[test] @@ -2424,26 +2454,26 @@ mod test_map { assert!(m.insert(1i, 2i)); assert!(m.insert(5i, 3i)); assert!(m.insert(9i, 4i)); - assert_eq!(*m.find(&9).unwrap(), 4); - assert_eq!(*m.find(&5).unwrap(), 3); - assert_eq!(*m.find(&1).unwrap(), 2); + assert_eq!(*m.find(&9).assert(), 4); + assert_eq!(*m.find(&5).assert(), 3); + assert_eq!(*m.find(&1).assert(), 2); } #[test] fn test_conflict_remove() { let mut m = HashMap::with_capacity(4); assert!(m.insert(1i, 2i)); - assert_eq!(*m.find(&1).unwrap(), 2); + assert_eq!(*m.find(&1).assert(), 2); assert!(m.insert(5, 3)); - assert_eq!(*m.find(&1).unwrap(), 2); - assert_eq!(*m.find(&5).unwrap(), 3); + assert_eq!(*m.find(&1).assert(), 2); + assert_eq!(*m.find(&5).assert(), 3); assert!(m.insert(9, 4)); - assert_eq!(*m.find(&1).unwrap(), 2); - assert_eq!(*m.find(&5).unwrap(), 3); - assert_eq!(*m.find(&9).unwrap(), 4); + assert_eq!(*m.find(&1).assert(), 2); + assert_eq!(*m.find(&5).assert(), 3); + assert_eq!(*m.find(&9).assert(), 4); assert!(m.remove(&1)); - assert_eq!(*m.find(&9).unwrap(), 4); - assert_eq!(*m.find(&5).unwrap(), 3); + assert_eq!(*m.find(&9).assert(), 4); + assert_eq!(*m.find(&5).assert(), 3); } #[test] @@ -2491,7 +2521,7 @@ mod test_map { hm }; - let v = hm.move_iter().collect::<Vec<(char, int)>>(); + let v = hm.iter_owned().collect::<Vec<(char, int)>>(); assert!([('a', 1), ('b', 2)] == v.as_slice() || [('b', 2), ('a', 1)] == v.as_slice()); } @@ -2515,7 +2545,7 @@ mod test_map { #[test] fn test_keys() { let vec = vec![(1i, 'a'), (2i, 'b'), (3i, 'c')]; - let map = vec.move_iter().collect::<HashMap<int, char>>(); + let map = vec.iter_owned().collect::<HashMap<int, char>>(); let keys = map.keys().map(|&k| k).collect::<Vec<int>>(); assert_eq!(keys.len(), 3); assert!(keys.contains(&1)); @@ -2526,7 +2556,7 @@ mod test_map { #[test] fn test_values() { let vec = vec![(1i, 'a'), (2i, 'b'), (3i, 'c')]; - let map = vec.move_iter().collect::<HashMap<int, char>>(); + let map = vec.iter_owned().collect::<HashMap<int, char>>(); let values = map.values().map(|&v| v).collect::<Vec<char>>(); assert_eq!(values.len(), 3); assert!(values.contains(&'a')); @@ -2688,7 +2718,7 @@ mod test_map { let mut map: HashMap<int, int> = xs.iter().map(|&x| x).collect(); - let mut iter = map.mut_iter(); + let mut iter = map.iter_mut(); for _ in iter.by_ref().take(3) {} @@ -2899,7 +2929,7 @@ mod test_set { hs }; - let v = hs.move_iter().collect::<Vec<char>>(); + let v = hs.iter_owned().collect::<Vec<char>>(); assert!(['a', 'b'] == v.as_slice() || ['b', 'a'] == v.as_slice()); } diff --git a/src/libstd/collections/lru_cache.rs b/src/libstd/collections/lru_cache.rs index 32a16053fffcf..a39857b47916e 100644 --- a/src/libstd/collections/lru_cache.rs +++ b/src/libstd/collections/lru_cache.rs @@ -24,11 +24,11 @@ //! cache.put(2, 20); //! cache.put(3, 30); //! assert!(cache.get(&1).is_none()); -//! assert_eq!(*cache.get(&2).unwrap(), 20); -//! assert_eq!(*cache.get(&3).unwrap(), 30); +//! assert_eq!(*cache.get(&2).assert(), 20); +//! assert_eq!(*cache.get(&3).assert(), 30); //! //! cache.put(2, 22); -//! assert_eq!(*cache.get(&2).unwrap(), 22); +//! assert_eq!(*cache.get(&2).assert(), 22); //! //! cache.put(6, 60); //! assert!(cache.get(&3).is_none()); @@ -84,8 +84,8 @@ impl<K, V> LruEntry<K, V> { LruEntry { key: k, value: v, - next: ptr::mut_null(), - prev: ptr::mut_null(), + next: ptr::null_mut(), + prev: ptr::null_mut(), } } } @@ -346,7 +346,7 @@ mod tests { fn assert_opt_eq<V: PartialEq>(opt: Option<&V>, v: V) { assert!(opt.is_some()); - assert!(opt.unwrap() == &v); + assert!(opt.assert() == &v); } #[test] @@ -388,7 +388,7 @@ mod tests { assert_eq!(cache.len(), 2); let opt1 = cache.pop(&1); assert!(opt1.is_some()); - assert_eq!(opt1.unwrap(), 10); + assert_eq!(opt1.assert(), 10); assert!(cache.get(&1).is_none()); assert_eq!(cache.len(), 1); } diff --git a/src/libstd/dynamic_lib.rs b/src/libstd/dynamic_lib.rs index 1ac37458e2493..3005ba4751f78 100644 --- a/src/libstd/dynamic_lib.rs +++ b/src/libstd/dynamic_lib.rs @@ -87,7 +87,7 @@ impl DynamicLibrary { search_path.insert(0, path.clone()); let newval = DynamicLibrary::create_path(search_path.as_slice()); os::setenv(DynamicLibrary::envvar(), - str::from_utf8(newval.as_slice()).unwrap()); + str::from_utf8(newval.as_slice()).assert()); } /// From a slice of paths, create a new vector which is suitable to be an @@ -245,7 +245,7 @@ pub mod dl { Ok(result) } else { Err(String::from_str(CString::new(last_error, false).as_str() - .unwrap())) + .assert())) }; ret @@ -294,14 +294,14 @@ pub mod dl { pub unsafe fn open_external<T: ToCStr>(filename: T) -> *mut u8 { // Windows expects Unicode data let filename_cstr = filename.to_c_str(); - let filename_str = str::from_utf8(filename_cstr.as_bytes_no_nul()).unwrap(); + let filename_str = str::from_utf8(filename_cstr.as_bytes_no_nul()).assert(); let filename_str: Vec<u16> = filename_str.utf16_units().collect(); let filename_str = filename_str.append_one(0); LoadLibraryW(filename_str.as_ptr() as *const libc::c_void) as *mut u8 } pub unsafe fn open_internal() -> *mut u8 { - let mut handle = ptr::mut_null(); + let mut handle = ptr::null_mut(); GetModuleHandleExW(0 as libc::DWORD, ptr::null(), &mut handle); handle as *mut u8 } diff --git a/src/libstd/fmt.rs b/src/libstd/fmt.rs index 2182c43d4a0c2..20376e062fe6b 100644 --- a/src/libstd/fmt.rs +++ b/src/libstd/fmt.rs @@ -463,7 +463,7 @@ pub use core::fmt::{secret_pointer}; pub fn format(args: &Arguments) -> string::String{ let mut output = io::MemWriter::new(); let _ = write!(&mut output, "{}", args); - string::String::from_utf8(output.unwrap()).unwrap() + string::String::from_utf8(output.unwrap()).assert() } impl<'a> Writer for Formatter<'a> { diff --git a/src/libstd/io/buffered.rs b/src/libstd/io/buffered.rs index 71ec524211824..ecafb4413d5ea 100644 --- a/src/libstd/io/buffered.rs +++ b/src/libstd/io/buffered.rs @@ -162,7 +162,7 @@ impl<W: Writer> BufferedWriter<W> { fn flush_buf(&mut self) -> IoResult<()> { if self.pos != 0 { - let ret = self.inner.get_mut_ref().write(self.buf.slice_to(self.pos)); + let ret = self.inner.as_mut().assert().write(self.buf.slice_to(self.pos)); self.pos = 0; ret } else { @@ -174,15 +174,15 @@ impl<W: Writer> BufferedWriter<W> { /// /// This type does not expose the ability to get a mutable reference to the /// underlying reader because that could possibly corrupt the buffer. - pub fn get_ref<'a>(&'a self) -> &'a W { self.inner.get_ref() } + pub fn get_ref<'a>(&'a self) -> &'a W { self.inner.as_ref().assert() } /// Unwraps this `BufferedWriter`, returning the underlying writer. /// /// The buffer is flushed before returning the writer. pub fn unwrap(mut self) -> W { // FIXME(#12628): is failing the right thing to do if flushing fails? - self.flush_buf().unwrap(); - self.inner.take_unwrap() + self.flush_buf().assert(); + self.inner.take().assert() } } @@ -193,9 +193,9 @@ impl<W: Writer> Writer for BufferedWriter<W> { } if buf.len() > self.buf.len() { - self.inner.get_mut_ref().write(buf) + self.inner.as_mut().assert().write(buf) } else { - let dst = self.buf.mut_slice_from(self.pos); + let dst = self.buf.slice_from_mut(self.pos); slice::bytes::copy_memory(dst, buf); self.pos += buf.len(); Ok(()) @@ -203,7 +203,7 @@ impl<W: Writer> Writer for BufferedWriter<W> { } fn flush(&mut self) -> IoResult<()> { - self.flush_buf().and_then(|()| self.inner.get_mut_ref().flush()) + self.flush_buf().and_then(|()| self.inner.as_mut().assert().flush()) } } @@ -439,35 +439,35 @@ mod test { let inner = MemWriter::new(); let mut writer = BufferedWriter::with_capacity(2, inner); - writer.write([0, 1]).unwrap(); + writer.write([0, 1]).assert(); assert_eq!(writer.get_ref().get_ref(), &[]); - writer.write([2]).unwrap(); + writer.write([2]).assert(); assert_eq!(writer.get_ref().get_ref(), &[0, 1]); - writer.write([3]).unwrap(); + writer.write([3]).assert(); assert_eq!(writer.get_ref().get_ref(), &[0, 1]); - writer.flush().unwrap(); + writer.flush().assert(); assert_eq!(&[0, 1, 2, 3], writer.get_ref().get_ref()); - writer.write([4]).unwrap(); - writer.write([5]).unwrap(); + writer.write([4]).assert(); + writer.write([5]).assert(); assert_eq!(&[0, 1, 2, 3], writer.get_ref().get_ref()); - writer.write([6]).unwrap(); + writer.write([6]).assert(); assert_eq!(&[0, 1, 2, 3, 4, 5], writer.get_ref().get_ref()); - writer.write([7, 8]).unwrap(); + writer.write([7, 8]).assert(); assert_eq!(&[0, 1, 2, 3, 4, 5, 6], writer.get_ref().get_ref()); - writer.write([9, 10, 11]).unwrap(); + writer.write([9, 10, 11]).assert(); assert_eq!(&[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], writer.get_ref().get_ref()); - writer.flush().unwrap(); + writer.flush().assert(); assert_eq!(&[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], writer.get_ref().get_ref()); } @@ -475,7 +475,7 @@ mod test { #[test] fn test_buffered_writer_inner_flushes() { let mut w = BufferedWriter::with_capacity(3, MemWriter::new()); - w.write([0, 1]).unwrap(); + w.write([0, 1]).assert(); assert_eq!(&[], w.get_ref().get_ref()); let w = w.unwrap(); assert_eq!(&[0, 1], w.get_ref()); @@ -500,8 +500,8 @@ mod test { let mut stream = BufferedStream::new(S); let mut buf = []; assert!(stream.read(buf).is_err()); - stream.write(buf).unwrap(); - stream.flush().unwrap(); + stream.write(buf).assert(); + stream.flush().assert(); } #[test] @@ -518,19 +518,19 @@ mod test { #[test] fn test_line_buffer() { let mut writer = LineBufferedWriter::new(MemWriter::new()); - writer.write([0]).unwrap(); + writer.write([0]).assert(); assert_eq!(writer.get_ref().get_ref(), &[]); - writer.write([1]).unwrap(); + writer.write([1]).assert(); assert_eq!(writer.get_ref().get_ref(), &[]); - writer.flush().unwrap(); + writer.flush().assert(); assert_eq!(writer.get_ref().get_ref(), &[0, 1]); - writer.write([0, b'\n', 1, b'\n', 2]).unwrap(); + writer.write([0, b'\n', 1, b'\n', 2]).assert(); assert_eq!(writer.get_ref().get_ref(), &[0, 1, 0, b'\n', 1, b'\n']); - writer.flush().unwrap(); + writer.flush().assert(); assert_eq!(writer.get_ref().get_ref(), &[0, 1, 0, b'\n', 1, b'\n', 2]); - writer.write([3, b'\n']).unwrap(); + writer.write([3, b'\n']).assert(); assert_eq!(writer.get_ref().get_ref(), &[0, 1, 0, b'\n', 1, b'\n', 2, 3, b'\n']); } diff --git a/src/libstd/io/comm_adapters.rs b/src/libstd/io/comm_adapters.rs index cd5887b7add00..c1760cbf55b08 100644 --- a/src/libstd/io/comm_adapters.rs +++ b/src/libstd/io/comm_adapters.rs @@ -62,7 +62,7 @@ impl Reader for ChanReader { loop { match self.buf { Some(ref prev) => { - let dst = buf.mut_slice_from(num_read); + let dst = buf.slice_from_mut(num_read); let src = prev.slice_from(self.pos); let count = cmp::min(dst.len(), src.len()); bytes::copy_memory(dst, src.slice_to(count)); @@ -180,7 +180,7 @@ mod test { fn test_chan_writer() { let (tx, rx) = channel(); let mut writer = ChanWriter::new(tx); - writer.write_be_u32(42).unwrap(); + writer.write_be_u32(42).assert(); let wanted = vec![0u8, 0u8, 0u8, 42u8]; let got = match task::try(proc() { rx.recv() }) { diff --git a/src/libstd/io/extensions.rs b/src/libstd/io/extensions.rs index 5215aec5dfbfa..e9379ea5cac82 100644 --- a/src/libstd/io/extensions.rs +++ b/src/libstd/io/extensions.rs @@ -316,13 +316,13 @@ mod test { let mut reader = ErroringReader; let mut it = reader.bytes(); let byte = it.next(); - assert!(byte.unwrap().is_err()); + assert!(byte.assert().is_err()); } #[test] fn read_bytes() { let mut reader = MemReader::new(vec!(10, 11, 12, 13)); - let bytes = reader.read_exact(4).unwrap(); + let bytes = reader.read_exact(4).assert(); assert!(bytes == vec!(10, 11, 12, 13)); } @@ -331,7 +331,7 @@ mod test { let mut reader = PartialReader { count: 0, }; - let bytes = reader.read_exact(4).unwrap(); + let bytes = reader.read_exact(4).assert(); assert!(bytes == vec!(10, 11, 12, 13)); } @@ -382,7 +382,7 @@ mod test { let mut reader = ThreeChunkReader { count: 0, }; - let buf = reader.read_to_end().unwrap(); + let buf = reader.read_to_end().assert(); assert!(buf == vec!(10, 11, 12, 13)); } @@ -392,7 +392,7 @@ mod test { let mut reader = ThreeChunkReader { count: 0, }; - let buf = reader.read_to_end().unwrap(); + let buf = reader.read_to_end().assert(); assert!(buf == vec!(10, 11)); } @@ -402,12 +402,12 @@ mod test { let mut writer = MemWriter::new(); for i in uints.iter() { - writer.write_le_u64(*i).unwrap(); + writer.write_le_u64(*i).assert(); } let mut reader = MemReader::new(writer.unwrap()); for i in uints.iter() { - assert!(reader.read_le_u64().unwrap() == *i); + assert!(reader.read_le_u64().assert() == *i); } } @@ -418,12 +418,12 @@ mod test { let mut writer = MemWriter::new(); for i in uints.iter() { - writer.write_be_u64(*i).unwrap(); + writer.write_be_u64(*i).assert(); } let mut reader = MemReader::new(writer.unwrap()); for i in uints.iter() { - assert!(reader.read_be_u64().unwrap() == *i); + assert!(reader.read_be_u64().assert() == *i); } } @@ -433,14 +433,14 @@ mod test { let mut writer = MemWriter::new(); for i in ints.iter() { - writer.write_be_i32(*i).unwrap(); + writer.write_be_i32(*i).assert(); } let mut reader = MemReader::new(writer.unwrap()); for i in ints.iter() { // this tests that the sign extension is working // (comparing the values as i32 would not test this) - assert!(reader.read_be_int_n(4).unwrap() == *i as i64); + assert!(reader.read_be_int_n(4).assert() == *i as i64); } } @@ -450,10 +450,10 @@ mod test { let buf = vec![0x41, 0x02, 0x00, 0x00]; let mut writer = MemWriter::new(); - writer.write(buf.as_slice()).unwrap(); + writer.write(buf.as_slice()).assert(); let mut reader = MemReader::new(writer.unwrap()); - let f = reader.read_be_f32().unwrap(); + let f = reader.read_be_f32().assert(); assert!(f == 8.1250); } @@ -462,12 +462,12 @@ mod test { let f:f32 = 8.1250; let mut writer = MemWriter::new(); - writer.write_be_f32(f).unwrap(); - writer.write_le_f32(f).unwrap(); + writer.write_be_f32(f).assert(); + writer.write_le_f32(f).assert(); let mut reader = MemReader::new(writer.unwrap()); - assert!(reader.read_be_f32().unwrap() == 8.1250); - assert!(reader.read_le_f32().unwrap() == 8.1250); + assert!(reader.read_be_f32().assert() == 8.1250); + assert!(reader.read_le_f32().assert() == 8.1250); } #[test] diff --git a/src/libstd/io/fs.rs b/src/libstd/io/fs.rs index 7335511ed857e..fa97fb47a70bb 100644 --- a/src/libstd/io/fs.rs +++ b/src/libstd/io/fs.rs @@ -44,7 +44,7 @@ file.write(b"foobar"); let mut file = File::open(&path); file.read_to_end(); -println!("{}", path.stat().unwrap().size); +println!("{}", path.stat().assert().size); # drop(file); fs::unlink(&path); ``` @@ -645,7 +645,7 @@ pub fn rmdir(path: &Path) -> IoResult<()> { /// at a non-directory file pub fn readdir(path: &Path) -> IoResult<Vec<Path>> { let err = LocalIo::maybe_raise(|io| { - Ok(try!(io.fs_readdir(&path.to_c_str(), 0)).move_iter().map(|a| { + Ok(try!(io.fs_readdir(&path.to_c_str(), 0)).iter_owned().map(|a| { Path::new(a) }).collect()) }).map_err(IoError::from_rtio_error); @@ -750,14 +750,14 @@ pub fn rmdir_recursive(path: &Path) -> IoResult<()> { } while !rm_stack.is_empty() { - let children = try!(readdir(rm_stack.last().unwrap()) + let children = try!(readdir(rm_stack.last().assert()) .update_detail(|e| rmdir_failed(e, path))); let mut has_child_dir = false; // delete all regular files in the way and push subdirs // on the stack - for child in children.move_iter() { + for child in children.iter_owned() { // FIXME(#12795) we should use lstat in all cases let child_type = match cfg!(windows) { true => try!(update_err(stat(&child), path)), @@ -780,7 +780,7 @@ pub fn rmdir_recursive(path: &Path) -> IoResult<()> { // if no subdir was found, let's pop and delete if !has_child_dir { - let result = update_err(rmdir(&rm_stack.pop().unwrap()), path); + let result = update_err(rmdir(&rm_stack.pop().assert()), path); match result { Ok(()) => (), Err(ref e) if e.kind == io::FileNotFound => (), @@ -999,7 +999,7 @@ mod test { let mut read_buf = [0, .. 1028]; let read_str = match check!(read_stream.read(read_buf)) { -1|0 => fail!("shouldn't happen"), - n => str::from_utf8(read_buf.slice_to(n)).unwrap().to_string() + n => str::from_utf8(read_buf.slice_to(n)).assert().to_string() }; assert_eq!(read_str.as_slice(), message); } @@ -1043,16 +1043,16 @@ mod test { { let mut read_stream = File::open_mode(filename, Open, Read); { - let read_buf = read_mem.mut_slice(0, 4); + let read_buf = read_mem.slice_mut(0, 4); check!(read_stream.read(read_buf)); } { - let read_buf = read_mem.mut_slice(4, 8); + let read_buf = read_mem.slice_mut(4, 8); check!(read_stream.read(read_buf)); } } check!(unlink(filename)); - let read_str = str::from_utf8(read_mem).unwrap(); + let read_str = str::from_utf8(read_mem).assert(); assert_eq!(read_str, message); }) @@ -1076,7 +1076,7 @@ mod test { tell_pos_post_read = check!(read_stream.tell()); } check!(unlink(filename)); - let read_str = str::from_utf8(read_mem).unwrap(); + let read_str = str::from_utf8(read_mem).assert(); assert_eq!(read_str, message.slice(4, 8)); assert_eq!(tell_pos_pre_read, set_cursor); assert_eq!(tell_pos_post_read, message.len() as u64); @@ -1101,7 +1101,7 @@ mod test { check!(read_stream.read(read_mem)); } check!(unlink(filename)); - let read_str = str::from_utf8(read_mem).unwrap(); + let read_str = str::from_utf8(read_mem).assert(); assert!(read_str.as_slice() == final_msg.as_slice()); }) @@ -1123,15 +1123,15 @@ mod test { check!(read_stream.seek(-4, SeekEnd)); check!(read_stream.read(read_mem)); - assert_eq!(str::from_utf8(read_mem).unwrap(), chunk_three); + assert_eq!(str::from_utf8(read_mem).assert(), chunk_three); check!(read_stream.seek(-9, SeekCur)); check!(read_stream.read(read_mem)); - assert_eq!(str::from_utf8(read_mem).unwrap(), chunk_two); + assert_eq!(str::from_utf8(read_mem).assert(), chunk_two); check!(read_stream.seek(0, SeekSet)); check!(read_stream.read(read_mem)); - assert_eq!(str::from_utf8(read_mem).unwrap(), chunk_one); + assert_eq!(str::from_utf8(read_mem).assert(), chunk_one); } check!(unlink(filename)); }) @@ -1142,7 +1142,7 @@ mod test { { let mut fs = check!(File::open_mode(filename, Open, ReadWrite)); let msg = "hw"; - fs.write(msg.as_bytes()).unwrap(); + fs.write(msg.as_bytes()).assert(); let fstat_res = check!(fs.stat()); assert_eq!(fstat_res.kind, io::TypeFile); @@ -1212,7 +1212,7 @@ mod test { { let n = f.filestem_str(); check!(File::open(f).read(mem)); - let read_str = str::from_utf8(mem).unwrap(); + let read_str = str::from_utf8(mem).assert(); let expected = match n { None|Some("") => fail!("really shouldn't happen.."), Some(n) => format!("{}{}", prefix, n), @@ -1240,7 +1240,7 @@ mod test { let mut files = check!(walk_dir(dir)); let mut cur = [0u8, .. 2]; for f in files { - let stem = f.filestem_str().unwrap(); + let stem = f.filestem_str().assert(); let root = stem.as_bytes()[0] - b'0'; let name = stem.as_bytes()[1] - b'0'; assert!(cur[root as uint] < name); @@ -1612,7 +1612,7 @@ mod test { use rand::{StdRng, Rng}; let mut bytes = [0, ..1024]; - StdRng::new().ok().unwrap().fill_bytes(bytes); + StdRng::new().ok().assert().fill_bytes(bytes); let tmpdir = tmpdir(); diff --git a/src/libstd/io/mem.rs b/src/libstd/io/mem.rs index 8879f7e25063c..13e18c6d408b2 100644 --- a/src/libstd/io/mem.rs +++ b/src/libstd/io/mem.rs @@ -102,7 +102,7 @@ impl Writer for MemWriter { /// /// let mut r = MemReader::new(vec!(0, 1, 2)); /// -/// assert_eq!(r.read_to_end().unwrap(), vec!(0, 1, 2)); +/// assert_eq!(r.read_to_end().assert(), vec!(0, 1, 2)); /// ``` pub struct MemReader { buf: Vec<u8>, @@ -147,7 +147,7 @@ impl Reader for MemReader { let write_len = min(buf.len(), self.buf.len() - self.pos); { let input = self.buf.slice(self.pos, self.pos + write_len); - let output = buf.mut_slice(0, write_len); + let output = buf.slice_mut(0, write_len); assert_eq!(input.len(), output.len()); slice::bytes::copy_memory(output, input); } @@ -232,7 +232,7 @@ impl<'a> Writer for BufWriter<'a> { }) } - slice::bytes::copy_memory(self.buf.mut_slice_from(self.pos), buf); + slice::bytes::copy_memory(self.buf.slice_from_mut(self.pos), buf); self.pos += buf.len(); Ok(()) } @@ -261,7 +261,7 @@ impl<'a> Seek for BufWriter<'a> { /// let mut buf = [0, 1, 2, 3]; /// let mut r = BufReader::new(buf); /// -/// assert_eq!(r.read_to_end().unwrap(), vec!(0, 1, 2, 3)); +/// assert_eq!(r.read_to_end().assert(), vec!(0, 1, 2, 3)); /// ``` pub struct BufReader<'a> { buf: &'a [u8], @@ -293,7 +293,7 @@ impl<'a> Reader for BufReader<'a> { let write_len = min(buf.len(), self.buf.len() - self.pos); { let input = self.buf.slice(self.pos, self.pos + write_len); - let output = buf.mut_slice(0, write_len); + let output = buf.slice_mut(0, write_len); assert_eq!(input.len(), output.len()); slice::bytes::copy_memory(output, input); } @@ -343,9 +343,9 @@ mod test { #[test] fn test_mem_writer() { let mut writer = MemWriter::new(); - writer.write([0]).unwrap(); - writer.write([1, 2, 3]).unwrap(); - writer.write([4, 5, 6, 7]).unwrap(); + writer.write([0]).assert(); + writer.write([1, 2, 3]).assert(); + writer.write([4, 5, 6, 7]).assert(); assert_eq!(writer.get_ref(), &[0, 1, 2, 3, 4, 5, 6, 7]); } @@ -355,12 +355,12 @@ mod test { { let mut writer = BufWriter::new(buf); assert_eq!(writer.tell(), Ok(0)); - writer.write([0]).unwrap(); + writer.write([0]).assert(); assert_eq!(writer.tell(), Ok(1)); - writer.write([1, 2, 3]).unwrap(); - writer.write([4, 5, 6, 7]).unwrap(); + writer.write([1, 2, 3]).assert(); + writer.write([4, 5, 6, 7]).assert(); assert_eq!(writer.tell(), Ok(8)); - writer.write([]).unwrap(); + writer.write([]).assert(); assert_eq!(writer.tell(), Ok(8)); } assert_eq!(buf.as_slice(), &[0, 1, 2, 3, 4, 5, 6, 7]); @@ -372,22 +372,22 @@ mod test { { let mut writer = BufWriter::new(buf); assert_eq!(writer.tell(), Ok(0)); - writer.write([1]).unwrap(); + writer.write([1]).assert(); assert_eq!(writer.tell(), Ok(1)); - writer.seek(2, SeekSet).unwrap(); + writer.seek(2, SeekSet).assert(); assert_eq!(writer.tell(), Ok(2)); - writer.write([2]).unwrap(); + writer.write([2]).assert(); assert_eq!(writer.tell(), Ok(3)); - writer.seek(-2, SeekCur).unwrap(); + writer.seek(-2, SeekCur).assert(); assert_eq!(writer.tell(), Ok(1)); - writer.write([3]).unwrap(); + writer.write([3]).assert(); assert_eq!(writer.tell(), Ok(2)); - writer.seek(-1, SeekEnd).unwrap(); + writer.seek(-1, SeekEnd).assert(); assert_eq!(writer.tell(), Ok(7)); - writer.write([4]).unwrap(); + writer.write([4]).assert(); assert_eq!(writer.tell(), Ok(8)); } @@ -398,7 +398,7 @@ mod test { fn test_buf_writer_error() { let mut buf = [0 as u8, ..2]; let mut writer = BufWriter::new(buf); - writer.write([0]).unwrap(); + writer.write([0]).assert(); match writer.write([0, 0]) { Ok(..) => fail!(), @@ -424,8 +424,8 @@ mod test { assert_eq!(buf.slice(0, 3), &[5, 6, 7]); assert!(reader.read(buf).is_err()); let mut reader = MemReader::new(vec!(0, 1, 2, 3, 4, 5, 6, 7)); - assert_eq!(reader.read_until(3).unwrap(), vec!(0, 1, 2, 3)); - assert_eq!(reader.read_until(3).unwrap(), vec!(4, 5, 6, 7)); + assert_eq!(reader.read_until(3).assert(), vec!(0, 1, 2, 3)); + assert_eq!(reader.read_until(3).assert(), vec!(4, 5, 6, 7)); assert!(reader.read(buf).is_err()); } @@ -448,8 +448,8 @@ mod test { assert_eq!(buf.slice(0, 3), &[5, 6, 7]); assert!(reader.read(buf).is_err()); let mut reader = BufReader::new(in_buf.as_slice()); - assert_eq!(reader.read_until(3).unwrap(), vec!(0, 1, 2, 3)); - assert_eq!(reader.read_until(3).unwrap(), vec!(4, 5, 6, 7)); + assert_eq!(reader.read_until(3).assert(), vec!(0, 1, 2, 3)); + assert_eq!(reader.read_until(3).assert(), vec!(4, 5, 6, 7)); assert!(reader.read(buf).is_err()); } @@ -474,21 +474,21 @@ mod test { #[test] fn test_write_strings() { let mut writer = MemWriter::new(); - writer.write_str("testing").unwrap(); - writer.write_line("testing").unwrap(); - writer.write_str("testing").unwrap(); + writer.write_str("testing").assert(); + writer.write_line("testing").assert(); + writer.write_str("testing").assert(); let mut r = BufReader::new(writer.get_ref()); - assert_eq!(r.read_to_string().unwrap(), "testingtesting\ntesting".to_string()); + assert_eq!(r.read_to_string().assert(), "testingtesting\ntesting".to_string()); } #[test] fn test_write_char() { let mut writer = MemWriter::new(); - writer.write_char('a').unwrap(); - writer.write_char('\n').unwrap(); - writer.write_char('ệ').unwrap(); + writer.write_char('a').assert(); + writer.write_char('\n').assert(); + writer.write_char('ệ').assert(); let mut r = BufReader::new(writer.get_ref()); - assert_eq!(r.read_to_string().unwrap(), "a\nệ".to_string()); + assert_eq!(r.read_to_string().assert(), "a\nệ".to_string()); } #[test] @@ -505,16 +505,16 @@ mod test { fn seek_past_end() { let buf = [0xff]; let mut r = BufReader::new(buf); - r.seek(10, SeekSet).unwrap(); + r.seek(10, SeekSet).assert(); assert!(r.read(&mut []).is_err()); let mut r = MemReader::new(vec!(10)); - r.seek(10, SeekSet).unwrap(); + r.seek(10, SeekSet).assert(); assert!(r.read(&mut []).is_err()); let mut buf = [0]; let mut r = BufWriter::new(buf); - r.seek(10, SeekSet).unwrap(); + r.seek(10, SeekSet).assert(); assert!(r.write([3]).is_err()); } @@ -538,7 +538,7 @@ mod test { let mut buf = [0, ..3]; assert!(r.read_at_least(buf.len(), buf).is_ok()); assert_eq!(buf.as_slice(), &[1, 2, 3]); - assert!(r.read_at_least(0, buf.mut_slice_to(0)).is_ok()); + assert!(r.read_at_least(0, buf.slice_to_mut(0)).is_ok()); assert_eq!(buf.as_slice(), &[1, 2, 3]); assert!(r.read_at_least(buf.len(), buf).is_ok()); assert_eq!(buf.as_slice(), &[4, 5, 6]); @@ -553,7 +553,7 @@ mod test { b.iter(|| { let mut wr = MemWriter::new(); for _ in range(0, times) { - wr.write(src.as_slice()).unwrap(); + wr.write(src.as_slice()).assert(); } let v = wr.unwrap(); @@ -610,7 +610,7 @@ mod test { let mut rdr = MemReader::new(buf); for _i in range(0u, 10) { let mut buf = [0 as u8, .. 10]; - rdr.read(buf).unwrap(); + rdr.read(buf).assert(); assert_eq!(buf.as_slice(), [5, .. 10].as_slice()); } } @@ -624,7 +624,7 @@ mod test { { let mut wr = BufWriter::new(buf); for _i in range(0u, 10) { - wr.write([5, .. 10]).unwrap(); + wr.write([5, .. 10]).assert(); } } assert_eq!(buf.as_slice(), [5, .. 100].as_slice()); @@ -639,7 +639,7 @@ mod test { let mut rdr = BufReader::new(buf); for _i in range(0u, 10) { let mut buf = [0 as u8, .. 10]; - rdr.read(buf).unwrap(); + rdr.read(buf).assert(); assert_eq!(buf.as_slice(), [5, .. 10].as_slice()); } } diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs index d098f9a647914..8aa93dd432a25 100644 --- a/src/libstd/io/mod.rs +++ b/src/libstd/io/mod.rs @@ -33,7 +33,7 @@ Some examples of obvious things you might want to do use std::io; for line in io::stdin().lines() { - print!("{}", line.unwrap()); + print!("{}", line.assert()); } ``` @@ -66,7 +66,7 @@ Some examples of obvious things you might want to do let path = Path::new("message.txt"); let mut file = BufferedReader::new(File::open(&path)); for line in file.lines() { - print!("{}", line.unwrap()); + print!("{}", line.assert()); } ``` @@ -78,7 +78,7 @@ Some examples of obvious things you might want to do let path = Path::new("message.txt"); let mut file = BufferedReader::new(File::open(&path)); - let lines: Vec<String> = file.lines().map(|x| x.unwrap()).collect(); + let lines: Vec<String> = file.lines().map(|x| x.assert()).collect(); ``` * Make a simple TCP client connection and request @@ -91,7 +91,7 @@ Some examples of obvious things you might want to do # // locally, we still want to be type checking this code, so lets # // just stop it running (#11576) # if false { - let mut socket = TcpStream::connect("127.0.0.1", 8080).unwrap(); + let mut socket = TcpStream::connect("127.0.0.1", 8080).assert(); socket.write(b"GET / HTTP/1.0\n\n"); let response = socket.read_to_end(); # } @@ -578,7 +578,7 @@ pub trait Reader { while read < min { let mut zeroes = 0; loop { - match self.read(buf.mut_slice_from(read)) { + match self.read(buf.slice_from_mut(read)) { Ok(0) => { zeroes += 1; if zeroes >= NO_PROGRESS_LIMIT { @@ -1523,7 +1523,7 @@ pub trait Buffer: Reader { { let mut start = 1; while start < width { - match try!(self.read(buf.mut_slice(start, width))) { + match try!(self.read(buf.slice_mut(start, width))) { n if n == width - start => break, n if n < width - start => { start += n; } _ => return Err(standard_error(InvalidInput)), @@ -1888,27 +1888,27 @@ mod tests { let mut r = BadReader::new(MemReader::new(Vec::from_slice(b"hello, world!")), Vec::from_slice([GoodBehavior(uint::MAX)])); let mut buf = [0u8, ..5]; - assert!(r.read_at_least(1, buf).unwrap() >= 1); - assert!(r.read_exact(5).unwrap().len() == 5); // read_exact uses read_at_least + assert!(r.read_at_least(1, buf).assert() >= 1); + assert!(r.read_exact(5).assert().len() == 5); // read_exact uses read_at_least assert!(r.read_at_least(0, buf).is_ok()); let mut r = BadReader::new(MemReader::new(Vec::from_slice(b"hello, world!")), Vec::from_slice([BadBehavior(50), GoodBehavior(uint::MAX)])); - assert!(r.read_at_least(1, buf).unwrap() >= 1); + assert!(r.read_at_least(1, buf).assert() >= 1); let mut r = BadReader::new(MemReader::new(Vec::from_slice(b"hello, world!")), Vec::from_slice([BadBehavior(1), GoodBehavior(1), BadBehavior(50), GoodBehavior(uint::MAX)])); - assert!(r.read_at_least(1, buf).unwrap() >= 1); - assert!(r.read_at_least(1, buf).unwrap() >= 1); + assert!(r.read_at_least(1, buf).assert() >= 1); + assert!(r.read_at_least(1, buf).assert() >= 1); let mut r = BadReader::new(MemReader::new(Vec::from_slice(b"hello, world!")), Vec::from_slice([BadBehavior(uint::MAX)])); - assert_eq!(r.read_at_least(1, buf).unwrap_err().kind, NoProgress); + assert_eq!(r.read_at_least(1, buf).assert_err().kind, NoProgress); let mut r = MemReader::new(Vec::from_slice(b"hello, world!")); - assert_eq!(r.read_at_least(5, buf).unwrap(), 5); - assert_eq!(r.read_at_least(6, buf).unwrap_err().kind, InvalidInput); + assert_eq!(r.read_at_least(5, buf).assert(), 5); + assert_eq!(r.read_at_least(6, buf).assert_err().kind, InvalidInput); } #[test] @@ -1916,24 +1916,24 @@ mod tests { let mut r = BadReader::new(MemReader::new(Vec::from_slice(b"hello, world!")), Vec::from_slice([GoodBehavior(uint::MAX)])); let mut buf = Vec::new(); - assert!(r.push_at_least(1, 5, &mut buf).unwrap() >= 1); + assert!(r.push_at_least(1, 5, &mut buf).assert() >= 1); assert!(r.push_at_least(0, 5, &mut buf).is_ok()); let mut r = BadReader::new(MemReader::new(Vec::from_slice(b"hello, world!")), Vec::from_slice([BadBehavior(50), GoodBehavior(uint::MAX)])); - assert!(r.push_at_least(1, 5, &mut buf).unwrap() >= 1); + assert!(r.push_at_least(1, 5, &mut buf).assert() >= 1); let mut r = BadReader::new(MemReader::new(Vec::from_slice(b"hello, world!")), Vec::from_slice([BadBehavior(1), GoodBehavior(1), BadBehavior(50), GoodBehavior(uint::MAX)])); - assert!(r.push_at_least(1, 5, &mut buf).unwrap() >= 1); - assert!(r.push_at_least(1, 5, &mut buf).unwrap() >= 1); + assert!(r.push_at_least(1, 5, &mut buf).assert() >= 1); + assert!(r.push_at_least(1, 5, &mut buf).assert() >= 1); let mut r = BadReader::new(MemReader::new(Vec::from_slice(b"hello, world!")), Vec::from_slice([BadBehavior(uint::MAX)])); - assert_eq!(r.push_at_least(1, 5, &mut buf).unwrap_err().kind, NoProgress); + assert_eq!(r.push_at_least(1, 5, &mut buf).assert_err().kind, NoProgress); let mut r = MemReader::new(Vec::from_slice(b"hello, world!")); - assert_eq!(r.push_at_least(5, 1, &mut buf).unwrap_err().kind, InvalidInput); + assert_eq!(r.push_at_least(5, 1, &mut buf).assert_err().kind, InvalidInput); } } diff --git a/src/libstd/io/net/addrinfo.rs b/src/libstd/io/net/addrinfo.rs index 771eb9e13e836..05a4a9b380479 100644 --- a/src/libstd/io/net/addrinfo.rs +++ b/src/libstd/io/net/addrinfo.rs @@ -76,7 +76,7 @@ pub struct Info { /// Easy name resolution. Given a hostname, returns the list of IP addresses for /// that hostname. pub fn get_host_addresses(host: &str) -> IoResult<Vec<IpAddr>> { - lookup(Some(host), None, None).map(|a| a.move_iter().map(|i| i.address.ip).collect()) + lookup(Some(host), None, None).map(|a| a.iter_owned().map(|i| i.address.ip).collect()) } /// Full-fledged resolution. This function will perform a synchronous call to @@ -105,7 +105,7 @@ fn lookup(hostname: Option<&str>, servname: Option<&str>, hint: Option<Hint>) match LocalIo::maybe_raise(|io| { io.get_host_addresses(hostname, servname, hint) }) { - Ok(v) => Ok(v.move_iter().map(|info| { + Ok(v) => Ok(v.iter_owned().map(|info| { Info { address: SocketAddr { ip: super::from_rtio(info.address.ip), @@ -126,7 +126,7 @@ fn lookup(hostname: Option<&str>, servname: Option<&str>, hint: Option<Hint>) #[cfg(test, not(target_os = "android"))] mod test { iotest!(fn dns_smoke_test() { - let ipaddrs = get_host_addresses("localhost").unwrap(); + let ipaddrs = get_host_addresses("localhost").assert(); let mut found_local = false; let local_addr = &Ipv4Addr(127, 0, 0, 1); for addr in ipaddrs.iter() { @@ -138,6 +138,6 @@ mod test { iotest!(fn issue_10663() { // Something should happen here, but this certainly shouldn't cause // everything to die. The actual outcome we don't care too much about. - get_host_addresses("example.com").unwrap(); + get_host_addresses("example.com").assert(); } #[ignore]) } diff --git a/src/libstd/io/net/ip.rs b/src/libstd/io/net/ip.rs index 0f864c7be5e27..e96f3193ae97e 100644 --- a/src/libstd/io/net/ip.rs +++ b/src/libstd/io/net/ip.rs @@ -109,7 +109,7 @@ impl<'a> Parser<'a> { // Return result of first successful parser fn read_or<T>(&mut self, parsers: &mut [|&mut Parser| -> Option<T>]) -> Option<T> { - for pf in parsers.mut_iter() { + for pf in parsers.iter_mut() { match self.read_atomically(|p: &mut Parser| (*pf)(p)) { Some(r) => return Some(r), None => {} @@ -233,7 +233,7 @@ impl<'a> Parser<'a> { assert!(head.len() + tail.len() <= 8); let mut gs = [0u16, ..8]; gs.copy_from(head); - gs.mut_slice(8 - tail.len(), 8).copy_from(tail); + gs.slice_mut(8 - tail.len(), 8).copy_from(tail); Ipv6Addr(gs[0], gs[1], gs[2], gs[3], gs[4], gs[5], gs[6], gs[7]) } diff --git a/src/libstd/io/net/tcp.rs b/src/libstd/io/net/tcp.rs index 0b0c22ed88799..1ba998b28a46f 100644 --- a/src/libstd/io/net/tcp.rs +++ b/src/libstd/io/net/tcp.rs @@ -165,7 +165,7 @@ impl TcpStream { /// use std::io::timer; /// use std::io::TcpStream; /// - /// let mut stream = TcpStream::connect("127.0.0.1", 34254).unwrap(); + /// let mut stream = TcpStream::connect("127.0.0.1", 34254).assert(); /// let stream2 = stream.clone(); /// /// spawn(proc() { @@ -410,7 +410,7 @@ impl TcpAcceptor { /// use std::io::TcpListener; /// use std::io::{Listener, Acceptor, TimedOut}; /// - /// let mut a = TcpListener::bind("127.0.0.1", 8482).listen().unwrap(); + /// let mut a = TcpListener::bind("127.0.0.1", 8482).listen().assert(); /// /// // After 100ms have passed, all accepts will fail /// a.set_timeout(Some(100)); @@ -475,12 +475,12 @@ mod test { spawn(proc() { let mut stream = TcpStream::connect("localhost", port); - stream.write([144]).unwrap(); + stream.write([144]).assert(); }); let mut stream = acceptor.accept(); let mut buf = [0]; - stream.read(buf).unwrap(); + stream.read(buf).assert(); assert!(buf[0] == 144); }) @@ -492,12 +492,12 @@ mod test { spawn(proc() { let mut stream = TcpStream::connect("localhost", addr.port); - stream.write([64]).unwrap(); + stream.write([64]).assert(); }); let mut stream = acceptor.accept(); let mut buf = [0]; - stream.read(buf).unwrap(); + stream.read(buf).assert(); assert!(buf[0] == 64); }) @@ -509,12 +509,12 @@ mod test { spawn(proc() { let mut stream = TcpStream::connect("127.0.0.1", addr.port); - stream.write([44]).unwrap(); + stream.write([44]).assert(); }); let mut stream = acceptor.accept(); let mut buf = [0]; - stream.read(buf).unwrap(); + stream.read(buf).assert(); assert!(buf[0] == 44); }) @@ -526,12 +526,12 @@ mod test { spawn(proc() { let mut stream = TcpStream::connect("::1", addr.port); - stream.write([66]).unwrap(); + stream.write([66]).assert(); }); let mut stream = acceptor.accept(); let mut buf = [0]; - stream.read(buf).unwrap(); + stream.read(buf).assert(); assert!(buf[0] == 66); }) @@ -543,12 +543,12 @@ mod test { spawn(proc() { let mut stream = TcpStream::connect(ip_str.as_slice(), port); - stream.write([99]).unwrap(); + stream.write([99]).assert(); }); let mut stream = acceptor.accept(); let mut buf = [0]; - stream.read(buf).unwrap(); + stream.read(buf).assert(); assert!(buf[0] == 99); }) @@ -560,12 +560,12 @@ mod test { spawn(proc() { let mut stream = TcpStream::connect(ip_str.as_slice(), port); - stream.write([99]).unwrap(); + stream.write([99]).assert(); }); let mut stream = acceptor.accept(); let mut buf = [0]; - stream.read(buf).unwrap(); + stream.read(buf).assert(); assert!(buf[0] == 99); }) @@ -717,13 +717,13 @@ mod test { spawn(proc() { for _ in range(0, max) { let mut stream = TcpStream::connect(ip_str.as_slice(), port); - stream.write([99]).unwrap(); + stream.write([99]).assert(); } }); for ref mut stream in acceptor.incoming().take(max) { let mut buf = [0]; - stream.read(buf).unwrap(); + stream.read(buf).assert(); assert_eq!(buf[0], 99); } }) @@ -738,13 +738,13 @@ mod test { spawn(proc() { for _ in range(0, max) { let mut stream = TcpStream::connect(ip_str.as_slice(), port); - stream.write([99]).unwrap(); + stream.write([99]).assert(); } }); for ref mut stream in acceptor.incoming().take(max) { let mut buf = [0]; - stream.read(buf).unwrap(); + stream.read(buf).assert(); assert_eq!(buf[0], 99); } }) @@ -763,7 +763,7 @@ mod test { spawn(proc() { let mut stream = stream; let mut buf = [0]; - stream.read(buf).unwrap(); + stream.read(buf).assert(); assert!(buf[0] == i as u8); debug!("read"); }); @@ -783,7 +783,7 @@ mod test { // Connect again before writing connect(i + 1, addr); debug!("writing"); - stream.write([i as u8]).unwrap(); + stream.write([i as u8]).assert(); }); } }) @@ -802,7 +802,7 @@ mod test { spawn(proc() { let mut stream = stream; let mut buf = [0]; - stream.read(buf).unwrap(); + stream.read(buf).assert(); assert!(buf[0] == i as u8); debug!("read"); }); @@ -822,7 +822,7 @@ mod test { // Connect again before writing connect(i + 1, addr); debug!("writing"); - stream.write([i as u8]).unwrap(); + stream.write([i as u8]).assert(); }); } }) @@ -841,7 +841,7 @@ mod test { spawn(proc() { let mut stream = stream; let mut buf = [0]; - stream.read(buf).unwrap(); + stream.read(buf).assert(); assert!(buf[0] == 99); debug!("read"); }); @@ -861,7 +861,7 @@ mod test { // Connect again before writing connect(i + 1, addr); debug!("writing"); - stream.write([99]).unwrap(); + stream.write([99]).assert(); }); } }) @@ -880,7 +880,7 @@ mod test { spawn(proc() { let mut stream = stream; let mut buf = [0]; - stream.read(buf).unwrap(); + stream.read(buf).assert(); assert!(buf[0] == 99); debug!("read"); }); @@ -900,7 +900,7 @@ mod test { // Connect again before writing connect(i + 1, addr); debug!("writing"); - stream.write([99]).unwrap(); + stream.write([99]).assert(); }); } }) @@ -908,13 +908,13 @@ mod test { pub fn socket_name(addr: SocketAddr) { let ip_str = addr.ip.to_string(); let port = addr.port; - let mut listener = TcpListener::bind(ip_str.as_slice(), port).unwrap(); + let mut listener = TcpListener::bind(ip_str.as_slice(), port).assert(); // Make sure socket_name gives // us the socket we binded to. let so_name = listener.socket_name(); assert!(so_name.is_ok()); - assert_eq!(addr, so_name.unwrap()); + assert_eq!(addr, so_name.assert()); } pub fn peer_name(addr: SocketAddr) { @@ -923,20 +923,20 @@ mod test { let acceptor = TcpListener::bind(ip_str.as_slice(), port).listen(); spawn(proc() { let mut acceptor = acceptor; - acceptor.accept().unwrap(); + acceptor.accept().assert(); }); let stream = TcpStream::connect(ip_str.as_slice(), port); assert!(stream.is_ok()); - let mut stream = stream.unwrap(); + let mut stream = stream.assert(); // Make sure peer_name gives us the // address/port of the peer we've // connected to. let peer_name = stream.peer_name(); assert!(peer_name.is_ok()); - assert_eq!(addr, peer_name.unwrap()); + assert_eq!(addr, peer_name.assert()); } iotest!(fn socket_and_peer_name_ip4() { @@ -956,21 +956,21 @@ mod test { let (tx, rx) = channel(); spawn(proc() { let ip_str = addr.ip.to_string(); - let mut srv = TcpListener::bind(ip_str.as_slice(), port).listen().unwrap(); + let mut srv = TcpListener::bind(ip_str.as_slice(), port).listen().assert(); tx.send(()); - let mut cl = srv.accept().unwrap(); - cl.write([10]).unwrap(); + let mut cl = srv.accept().assert(); + cl.write([10]).assert(); let mut b = [0]; - cl.read(b).unwrap(); + cl.read(b).assert(); tx.send(()); }); rx.recv(); let ip_str = addr.ip.to_string(); - let mut c = TcpStream::connect(ip_str.as_slice(), port).unwrap(); + let mut c = TcpStream::connect(ip_str.as_slice(), port).assert(); let mut b = [0, ..10]; assert_eq!(c.read(b), Ok(1)); - c.write([1]).unwrap(); + c.write([1]).assert(); rx.recv(); }) @@ -978,7 +978,7 @@ mod test { let addr = next_test_ip4(); let ip_str = addr.ip.to_string(); let port = addr.port; - let listener = TcpListener::bind(ip_str.as_slice(), port).unwrap().listen(); + let listener = TcpListener::bind(ip_str.as_slice(), port).assert().listen(); assert!(listener.is_ok()); match TcpListener::bind(ip_str.as_slice(), port).listen() { Ok(..) => fail!(), @@ -997,7 +997,7 @@ mod test { spawn(proc() { let ip_str = addr.ip.to_string(); rx.recv(); - let _stream = TcpStream::connect(ip_str.as_slice(), port).unwrap(); + let _stream = TcpStream::connect(ip_str.as_slice(), port).assert(); // Close rx.recv(); }); @@ -1007,7 +1007,7 @@ mod test { let mut acceptor = TcpListener::bind(ip_str.as_slice(), port).listen(); tx.send(()); { - let _stream = acceptor.accept().unwrap(); + let _stream = acceptor.accept().assert(); // Close client tx.send(()); } @@ -1027,10 +1027,10 @@ mod test { let mut buf = [0, 0]; assert_eq!(s.read(buf), Ok(1)); assert_eq!(buf[0], 1); - s.write([2]).unwrap(); + s.write([2]).assert(); }); - let mut s1 = acceptor.accept().unwrap(); + let mut s1 = acceptor.accept().assert(); let s2 = s1.clone(); let (tx1, rx1) = channel(); @@ -1038,7 +1038,7 @@ mod test { spawn(proc() { let mut s2 = s2; rx1.recv(); - s2.write([1]).unwrap(); + s2.write([1]).assert(); tx2.send(()); }); tx1.send(()); @@ -1057,25 +1057,25 @@ mod test { spawn(proc() { let mut s = TcpStream::connect(ip_str.as_slice(), port); - s.write([1]).unwrap(); + s.write([1]).assert(); rx.recv(); - s.write([2]).unwrap(); + s.write([2]).assert(); rx.recv(); }); - let mut s1 = acceptor.accept().unwrap(); + let mut s1 = acceptor.accept().assert(); let s2 = s1.clone(); let (done, rx) = channel(); spawn(proc() { let mut s2 = s2; let mut buf = [0, 0]; - s2.read(buf).unwrap(); + s2.read(buf).assert(); tx2.send(()); done.send(()); }); let mut buf = [0, 0]; - s1.read(buf).unwrap(); + s1.read(buf).assert(); tx1.send(()); rx.recv(); @@ -1090,20 +1090,20 @@ mod test { spawn(proc() { let mut s = TcpStream::connect(ip_str.as_slice(), port); let mut buf = [0, 1]; - s.read(buf).unwrap(); - s.read(buf).unwrap(); + s.read(buf).assert(); + s.read(buf).assert(); }); - let mut s1 = acceptor.accept().unwrap(); + let mut s1 = acceptor.accept().assert(); let s2 = s1.clone(); let (done, rx) = channel(); spawn(proc() { let mut s2 = s2; - s2.write([1]).unwrap(); + s2.write([1]).assert(); done.send(()); }); - s1.write([2]).unwrap(); + s1.write([2]).assert(); rx.recv(); }) @@ -1114,15 +1114,15 @@ mod test { let addr = next_test_ip4(); let ip_str = addr.ip.to_string(); let port = addr.port; - let a = TcpListener::bind(ip_str.as_slice(), port).unwrap().listen(); + let a = TcpListener::bind(ip_str.as_slice(), port).assert().listen(); spawn(proc() { let mut a = a; - let mut c = a.accept().unwrap(); + let mut c = a.accept().assert(); assert_eq!(c.read_to_end(), Ok(vec!())); - c.write([1]).unwrap(); + c.write([1]).assert(); }); - let mut s = TcpStream::connect(ip_str.as_slice(), port).unwrap(); + let mut s = TcpStream::connect(ip_str.as_slice(), port).assert(); assert!(s.obj.close_write().is_ok()); assert!(s.write([1]).is_err()); assert_eq!(s.read_to_end(), Ok(vec!(1))); @@ -1132,14 +1132,14 @@ mod test { let addr = next_test_ip4(); let ip_str = addr.ip.to_string(); let port = addr.port; - let mut a = TcpListener::bind(ip_str.as_slice(), port).unwrap().listen().unwrap(); + let mut a = TcpListener::bind(ip_str.as_slice(), port).assert().listen().assert(); a.set_timeout(Some(10)); // Make sure we time out once and future invocations also time out - let err = a.accept().err().unwrap(); + let err = a.accept().err().assert(); assert_eq!(err.kind, TimedOut); - let err = a.accept().err().unwrap(); + let err = a.accept().err().assert(); assert_eq!(err.kind, TimedOut); // Also make sure that even though the timeout is expired that we will @@ -1152,7 +1152,7 @@ mod test { let (tx, rx) = channel(); spawn(proc() { tx.send(TcpStream::connect(addr.ip.to_string().as_slice(), - port).unwrap()); + port).assert()); }); let _l = rx.recv(); for i in range(0i, 1001) { @@ -1170,31 +1170,31 @@ mod test { a.set_timeout(None); spawn(proc() { drop(TcpStream::connect(addr.ip.to_string().as_slice(), - port).unwrap()); + port).assert()); }); - a.accept().unwrap(); + a.accept().assert(); }) iotest!(fn close_readwrite_smoke() { let addr = next_test_ip4(); let ip_str = addr.ip.to_string(); let port = addr.port; - let a = TcpListener::bind(ip_str.as_slice(), port).listen().unwrap(); + let a = TcpListener::bind(ip_str.as_slice(), port).listen().assert(); let (_tx, rx) = channel::<()>(); spawn(proc() { let mut a = a; - let _s = a.accept().unwrap(); + let _s = a.accept().assert(); let _ = rx.recv_opt(); }); let mut b = [0]; - let mut s = TcpStream::connect(ip_str.as_slice(), port).unwrap(); + let mut s = TcpStream::connect(ip_str.as_slice(), port).assert(); let mut s2 = s.clone(); // closing should prevent reads/writes - s.close_write().unwrap(); + s.close_write().assert(); assert!(s.write([0]).is_err()); - s.close_read().unwrap(); + s.close_read().assert(); assert!(s.read(b).is_err()); // closing should affect previous handles @@ -1217,15 +1217,15 @@ mod test { let addr = next_test_ip4(); let ip_str = addr.ip.to_string(); let port = addr.port; - let a = TcpListener::bind(ip_str.as_slice(), port).listen().unwrap(); + let a = TcpListener::bind(ip_str.as_slice(), port).listen().assert(); let (_tx, rx) = channel::<()>(); spawn(proc() { let mut a = a; - let _s = a.accept().unwrap(); + let _s = a.accept().assert(); let _ = rx.recv_opt(); }); - let mut s = TcpStream::connect(ip_str.as_slice(), port).unwrap(); + let mut s = TcpStream::connect(ip_str.as_slice(), port).assert(); let s2 = s.clone(); let (tx, rx) = channel(); spawn(proc() { @@ -1234,7 +1234,7 @@ mod test { tx.send(()); }); // this should wake up the child task - s.close_read().unwrap(); + s.close_read().assert(); // this test will never finish if the child doesn't wake up rx.recv(); @@ -1244,19 +1244,19 @@ mod test { let addr = next_test_ip6(); let ip_str = addr.ip.to_string(); let port = addr.port; - let mut a = TcpListener::bind(ip_str.as_slice(), port).listen().unwrap(); + let mut a = TcpListener::bind(ip_str.as_slice(), port).listen().assert(); let (tx, rx) = channel::<()>(); spawn(proc() { - let mut s = TcpStream::connect(ip_str.as_slice(), port).unwrap(); + let mut s = TcpStream::connect(ip_str.as_slice(), port).assert(); rx.recv(); assert!(s.write([0]).is_ok()); let _ = rx.recv_opt(); }); - let mut s = a.accept().unwrap(); + let mut s = a.accept().assert(); s.set_timeout(Some(20)); - assert_eq!(s.read([0]).err().unwrap().kind, TimedOut); - assert_eq!(s.read([0]).err().unwrap().kind, TimedOut); + assert_eq!(s.read([0]).err().assert().kind, TimedOut); + assert_eq!(s.read([0]).err().assert().kind, TimedOut); s.set_timeout(Some(20)); for i in range(0i, 1001) { @@ -1267,7 +1267,7 @@ mod test { } if i == 1000 { fail!("should have filled up?!"); } } - assert_eq!(s.write([0]).err().unwrap().kind, TimedOut); + assert_eq!(s.write([0]).err().assert().kind, TimedOut); tx.send(()); s.set_timeout(None); @@ -1278,10 +1278,10 @@ mod test { let addr = next_test_ip6(); let ip_str = addr.ip.to_string(); let port = addr.port; - let mut a = TcpListener::bind(ip_str.as_slice(), port).listen().unwrap(); + let mut a = TcpListener::bind(ip_str.as_slice(), port).listen().assert(); let (tx, rx) = channel::<()>(); spawn(proc() { - let mut s = TcpStream::connect(ip_str.as_slice(), port).unwrap(); + let mut s = TcpStream::connect(ip_str.as_slice(), port).assert(); rx.recv(); let mut amt = 0; while amt < 100 * 128 * 1024 { @@ -1293,10 +1293,10 @@ mod test { let _ = rx.recv_opt(); }); - let mut s = a.accept().unwrap(); + let mut s = a.accept().assert(); s.set_read_timeout(Some(20)); - assert_eq!(s.read([0]).err().unwrap().kind, TimedOut); - assert_eq!(s.read([0]).err().unwrap().kind, TimedOut); + assert_eq!(s.read([0]).err().assert().kind, TimedOut); + assert_eq!(s.read([0]).err().assert().kind, TimedOut); tx.send(()); for _ in range(0i, 100) { @@ -1308,16 +1308,16 @@ mod test { let addr = next_test_ip6(); let ip_str = addr.ip.to_string(); let port = addr.port; - let mut a = TcpListener::bind(ip_str.as_slice(), port).listen().unwrap(); + let mut a = TcpListener::bind(ip_str.as_slice(), port).listen().assert(); let (tx, rx) = channel::<()>(); spawn(proc() { - let mut s = TcpStream::connect(ip_str.as_slice(), port).unwrap(); + let mut s = TcpStream::connect(ip_str.as_slice(), port).assert(); rx.recv(); assert!(s.write([0]).is_ok()); let _ = rx.recv_opt(); }); - let mut s = a.accept().unwrap(); + let mut s = a.accept().assert(); s.set_write_timeout(Some(20)); for i in range(0i, 1001) { match s.write([0, .. 128 * 1024]) { @@ -1327,7 +1327,7 @@ mod test { } if i == 1000 { fail!("should have filled up?!"); } } - assert_eq!(s.write([0]).err().unwrap().kind, TimedOut); + assert_eq!(s.write([0]).err().assert().kind, TimedOut); tx.send(()); assert!(s.read([0]).is_ok()); @@ -1337,16 +1337,16 @@ mod test { let addr = next_test_ip6(); let ip_str = addr.ip.to_string(); let port = addr.port; - let mut a = TcpListener::bind(ip_str.as_slice(), port).listen().unwrap(); + let mut a = TcpListener::bind(ip_str.as_slice(), port).listen().assert(); let (tx, rx) = channel::<()>(); spawn(proc() { - let mut s = TcpStream::connect(ip_str.as_slice(), port).unwrap(); + let mut s = TcpStream::connect(ip_str.as_slice(), port).assert(); rx.recv(); assert_eq!(s.write([0]), Ok(())); let _ = rx.recv_opt(); }); - let mut s = a.accept().unwrap(); + let mut s = a.accept().assert(); let s2 = s.clone(); let (tx2, rx2) = channel(); spawn(proc() { @@ -1356,7 +1356,7 @@ mod test { }); s.set_read_timeout(Some(20)); - assert_eq!(s.read([0]).err().unwrap().kind, TimedOut); + assert_eq!(s.read([0]).err().assert().kind, TimedOut); tx.send(()); rx2.recv(); @@ -1365,7 +1365,7 @@ mod test { iotest!(fn clone_while_reading() { let addr = next_test_ip6(); let listen = TcpListener::bind(addr.ip.to_string().as_slice(), addr.port); - let mut accept = listen.listen().unwrap(); + let mut accept = listen.listen().assert(); // Enqueue a task to write to a socket let (tx, rx) = channel(); @@ -1373,19 +1373,19 @@ mod test { let txdone2 = txdone.clone(); spawn(proc() { let mut tcp = TcpStream::connect(addr.ip.to_string().as_slice(), - addr.port).unwrap(); + addr.port).assert(); rx.recv(); - tcp.write_u8(0).unwrap(); + tcp.write_u8(0).assert(); txdone2.send(()); }); // Spawn off a reading clone - let tcp = accept.accept().unwrap(); + let tcp = accept.accept().assert(); let tcp2 = tcp.clone(); let txdone3 = txdone.clone(); spawn(proc() { let mut tcp2 = tcp2; - tcp2.read_u8().unwrap(); + tcp2.read_u8().assert(); txdone3.send(()); }); diff --git a/src/libstd/io/net/udp.rs b/src/libstd/io/net/udp.rs index 5f7563e7467ba..cd24b76c62ffa 100644 --- a/src/libstd/io/net/udp.rs +++ b/src/libstd/io/net/udp.rs @@ -48,7 +48,7 @@ use rt::rtio; /// match socket.recv_from(buf) { /// Ok((amt, src)) => { /// // Send a reply to the socket we received data from -/// let buf = buf.mut_slice_to(amt); +/// let buf = buf.slice_to_mut(amt); /// buf.reverse(); /// socket.send_to(buf, src); /// } @@ -285,7 +285,7 @@ mod test { match UdpSocket::bind(client_ip) { Ok(ref mut client) => { rx1.recv(); - client.send_to([99], server_ip).unwrap() + client.send_to([99], server_ip).assert() } Err(..) => fail!() } @@ -319,7 +319,7 @@ mod test { match UdpSocket::bind(client_ip) { Ok(ref mut client) => { rx.recv(); - client.send_to([99], server_ip).unwrap() + client.send_to([99], server_ip).assert() } Err(..) => fail!() } @@ -354,7 +354,7 @@ mod test { let client = box client; let mut stream = client.connect(server_ip); rx1.recv(); - stream.write([99]).unwrap(); + stream.write([99]).assert(); } Err(..) => fail!() } @@ -392,7 +392,7 @@ mod test { let client = box client; let mut stream = client.connect(server_ip); rx1.recv(); - stream.write([99]).unwrap(); + stream.write([99]).assert(); } Err(..) => fail!() } @@ -422,13 +422,13 @@ mod test { let server = UdpSocket::bind(addr); assert!(server.is_ok()); - let mut server = server.unwrap(); + let mut server = server.assert(); // Make sure socket_name gives // us the socket we binded to. let so_name = server.socket_name(); assert!(so_name.is_ok()); - assert_eq!(addr, so_name.unwrap()); + assert_eq!(addr, so_name.assert()); } iotest!(fn socket_name_ip4() { @@ -442,15 +442,15 @@ mod test { iotest!(fn udp_clone_smoke() { let addr1 = next_test_ip4(); let addr2 = next_test_ip4(); - let mut sock1 = UdpSocket::bind(addr1).unwrap(); - let sock2 = UdpSocket::bind(addr2).unwrap(); + let mut sock1 = UdpSocket::bind(addr1).assert(); + let sock2 = UdpSocket::bind(addr2).assert(); spawn(proc() { let mut sock2 = sock2; let mut buf = [0, 0]; assert_eq!(sock2.recv_from(buf), Ok((1, addr1))); assert_eq!(buf[0], 1); - sock2.send_to([2], addr1).unwrap(); + sock2.send_to([2], addr1).assert(); }); let sock3 = sock1.clone(); @@ -460,7 +460,7 @@ mod test { spawn(proc() { let mut sock3 = sock3; rx1.recv(); - sock3.send_to([1], addr2).unwrap(); + sock3.send_to([1], addr2).assert(); tx2.send(()); }); tx1.send(()); @@ -472,16 +472,16 @@ mod test { iotest!(fn udp_clone_two_read() { let addr1 = next_test_ip4(); let addr2 = next_test_ip4(); - let mut sock1 = UdpSocket::bind(addr1).unwrap(); - let sock2 = UdpSocket::bind(addr2).unwrap(); + let mut sock1 = UdpSocket::bind(addr1).assert(); + let sock2 = UdpSocket::bind(addr2).assert(); let (tx1, rx) = channel(); let tx2 = tx1.clone(); spawn(proc() { let mut sock2 = sock2; - sock2.send_to([1], addr1).unwrap(); + sock2.send_to([1], addr1).assert(); rx.recv(); - sock2.send_to([2], addr1).unwrap(); + sock2.send_to([2], addr1).assert(); rx.recv(); }); @@ -491,12 +491,12 @@ mod test { spawn(proc() { let mut sock3 = sock3; let mut buf = [0, 0]; - sock3.recv_from(buf).unwrap(); + sock3.recv_from(buf).assert(); tx2.send(()); done.send(()); }); let mut buf = [0, 0]; - sock1.recv_from(buf).unwrap(); + sock1.recv_from(buf).assert(); tx1.send(()); rx.recv(); @@ -505,8 +505,8 @@ mod test { iotest!(fn udp_clone_two_write() { let addr1 = next_test_ip4(); let addr2 = next_test_ip4(); - let mut sock1 = UdpSocket::bind(addr1).unwrap(); - let sock2 = UdpSocket::bind(addr2).unwrap(); + let mut sock1 = UdpSocket::bind(addr1).assert(); + let sock2 = UdpSocket::bind(addr2).assert(); let (tx, rx) = channel(); let (serv_tx, serv_rx) = channel(); @@ -548,12 +548,12 @@ mod test { iotest!(fn recv_from_timeout() { let addr1 = next_test_ip4(); let addr2 = next_test_ip4(); - let mut a = UdpSocket::bind(addr1).unwrap(); + let mut a = UdpSocket::bind(addr1).assert(); let (tx, rx) = channel(); let (tx2, rx2) = channel(); spawn(proc() { - let mut a = UdpSocket::bind(addr2).unwrap(); + let mut a = UdpSocket::bind(addr2).assert(); assert_eq!(a.recv_from([0]), Ok((1, addr1))); assert_eq!(a.send_to([0], addr1), Ok(())); rx.recv(); @@ -564,8 +564,8 @@ mod test { // Make sure that reads time out, but writes can continue a.set_read_timeout(Some(20)); - assert_eq!(a.recv_from([0]).err().unwrap().kind, TimedOut); - assert_eq!(a.recv_from([0]).err().unwrap().kind, TimedOut); + assert_eq!(a.recv_from([0]).err().assert().kind, TimedOut); + assert_eq!(a.recv_from([0]).err().assert().kind, TimedOut); assert_eq!(a.send_to([0], addr2), Ok(())); // Cloned handles should be able to block @@ -584,8 +584,8 @@ mod test { iotest!(fn send_to_timeout() { let addr1 = next_test_ip4(); let addr2 = next_test_ip4(); - let mut a = UdpSocket::bind(addr1).unwrap(); - let _b = UdpSocket::bind(addr2).unwrap(); + let mut a = UdpSocket::bind(addr1).assert(); + let _b = UdpSocket::bind(addr2).assert(); a.set_write_timeout(Some(1000)); for _ in range(0u, 100) { diff --git a/src/libstd/io/net/unix.rs b/src/libstd/io/net/unix.rs index 5e7c421497772..0ce0e6daf453f 100644 --- a/src/libstd/io/net/unix.rs +++ b/src/libstd/io/net/unix.rs @@ -273,10 +273,10 @@ mod tests { iotest!(fn smoke() { smalltest(proc(mut server) { let mut buf = [0]; - server.read(buf).unwrap(); + server.read(buf).assert(); assert!(buf[0] == 99); }, proc(mut client) { - client.write([99]).unwrap(); + client.write([99]).assert(); }) }) @@ -359,11 +359,11 @@ mod tests { assert_eq!(s.read(buf), Ok(1)); assert_eq!(buf[0], 1); debug!("client writing"); - s.write([2]).unwrap(); + s.write([2]).assert(); debug!("client dropping"); }); - let mut s1 = acceptor.accept().unwrap(); + let mut s1 = acceptor.accept().assert(); let s2 = s1.clone(); let (tx1, rx1) = channel(); @@ -372,7 +372,7 @@ mod tests { let mut s2 = s2; rx1.recv(); debug!("writer writing"); - s2.write([1]).unwrap(); + s2.write([1]).assert(); debug!("writer done"); tx2.send(()); }); @@ -392,25 +392,25 @@ mod tests { spawn(proc() { let mut s = UnixStream::connect(&addr); - s.write([1]).unwrap(); + s.write([1]).assert(); rx.recv(); - s.write([2]).unwrap(); + s.write([2]).assert(); rx.recv(); }); - let mut s1 = acceptor.accept().unwrap(); + let mut s1 = acceptor.accept().assert(); let s2 = s1.clone(); let (done, rx) = channel(); spawn(proc() { let mut s2 = s2; let mut buf = [0, 0]; - s2.read(buf).unwrap(); + s2.read(buf).assert(); tx2.send(()); done.send(()); }); let mut buf = [0, 0]; - s1.read(buf).unwrap(); + s1.read(buf).assert(); tx1.send(()); rx.recv(); @@ -423,27 +423,27 @@ mod tests { spawn(proc() { let mut s = UnixStream::connect(&addr); let mut buf = [0, 1]; - s.read(buf).unwrap(); - s.read(buf).unwrap(); + s.read(buf).assert(); + s.read(buf).assert(); }); - let mut s1 = acceptor.accept().unwrap(); + let mut s1 = acceptor.accept().assert(); let s2 = s1.clone(); let (tx, rx) = channel(); spawn(proc() { let mut s2 = s2; - s2.write([1]).unwrap(); + s2.write([1]).assert(); tx.send(()); }); - s1.write([2]).unwrap(); + s1.write([2]).assert(); rx.recv(); }) iotest!(fn drop_removes_listener_path() { let path = next_test_unix(); - let l = UnixListener::bind(&path).unwrap(); + let l = UnixListener::bind(&path).assert(); assert!(path.exists()); drop(l); assert!(!path.exists()); @@ -451,22 +451,22 @@ mod tests { iotest!(fn drop_removes_acceptor_path() { let path = next_test_unix(); - let l = UnixListener::bind(&path).unwrap(); + let l = UnixListener::bind(&path).assert(); assert!(path.exists()); - drop(l.listen().unwrap()); + drop(l.listen().assert()); assert!(!path.exists()); } #[cfg(not(windows))]) iotest!(fn accept_timeout() { let addr = next_test_unix(); - let mut a = UnixListener::bind(&addr).unwrap().listen().unwrap(); + let mut a = UnixListener::bind(&addr).assert().listen().assert(); a.set_timeout(Some(10)); // Make sure we time out once and future invocations also time out - let err = a.accept().err().unwrap(); + let err = a.accept().err().assert(); assert_eq!(err.kind, TimedOut); - let err = a.accept().err().unwrap(); + let err = a.accept().err().assert(); assert_eq!(err.kind, TimedOut); // Also make sure that even though the timeout is expired that we will @@ -474,7 +474,7 @@ mod tests { let (tx, rx) = channel(); let addr2 = addr.clone(); spawn(proc() { - tx.send(UnixStream::connect(&addr2).unwrap()); + tx.send(UnixStream::connect(&addr2).assert()); }); let l = rx.recv(); for i in range(0u, 1001) { @@ -492,9 +492,9 @@ mod tests { a.set_timeout(None); let addr2 = addr.clone(); spawn(proc() { - drop(UnixStream::connect(&addr2).unwrap()); + drop(UnixStream::connect(&addr2).assert()); }); - a.accept().unwrap(); + a.accept().assert(); }) iotest!(fn connect_timeout_error() { @@ -504,28 +504,28 @@ mod tests { iotest!(fn connect_timeout_success() { let addr = next_test_unix(); - let _a = UnixListener::bind(&addr).unwrap().listen().unwrap(); + let _a = UnixListener::bind(&addr).assert().listen().assert(); assert!(UnixStream::connect_timeout(&addr, 100).is_ok()); }) iotest!(fn close_readwrite_smoke() { let addr = next_test_unix(); - let a = UnixListener::bind(&addr).listen().unwrap(); + let a = UnixListener::bind(&addr).listen().assert(); let (_tx, rx) = channel::<()>(); spawn(proc() { let mut a = a; - let _s = a.accept().unwrap(); + let _s = a.accept().assert(); let _ = rx.recv_opt(); }); let mut b = [0]; - let mut s = UnixStream::connect(&addr).unwrap(); + let mut s = UnixStream::connect(&addr).assert(); let mut s2 = s.clone(); // closing should prevent reads/writes - s.close_write().unwrap(); + s.close_write().assert(); assert!(s.write([0]).is_err()); - s.close_read().unwrap(); + s.close_read().assert(); assert!(s.read(b).is_err()); // closing should affect previous handles @@ -546,15 +546,15 @@ mod tests { iotest!(fn close_read_wakes_up() { let addr = next_test_unix(); - let a = UnixListener::bind(&addr).listen().unwrap(); + let a = UnixListener::bind(&addr).listen().assert(); let (_tx, rx) = channel::<()>(); spawn(proc() { let mut a = a; - let _s = a.accept().unwrap(); + let _s = a.accept().assert(); let _ = rx.recv_opt(); }); - let mut s = UnixStream::connect(&addr).unwrap(); + let mut s = UnixStream::connect(&addr).assert(); let s2 = s.clone(); let (tx, rx) = channel(); spawn(proc() { @@ -563,7 +563,7 @@ mod tests { tx.send(()); }); // this should wake up the child task - s.close_read().unwrap(); + s.close_read().assert(); // this test will never finish if the child doesn't wake up rx.recv(); @@ -571,19 +571,19 @@ mod tests { iotest!(fn readwrite_timeouts() { let addr = next_test_unix(); - let mut a = UnixListener::bind(&addr).listen().unwrap(); + let mut a = UnixListener::bind(&addr).listen().assert(); let (tx, rx) = channel::<()>(); spawn(proc() { - let mut s = UnixStream::connect(&addr).unwrap(); + let mut s = UnixStream::connect(&addr).assert(); rx.recv(); assert!(s.write([0]).is_ok()); let _ = rx.recv_opt(); }); - let mut s = a.accept().unwrap(); + let mut s = a.accept().assert(); s.set_timeout(Some(20)); - assert_eq!(s.read([0]).err().unwrap().kind, TimedOut); - assert_eq!(s.read([0]).err().unwrap().kind, TimedOut); + assert_eq!(s.read([0]).err().assert().kind, TimedOut); + assert_eq!(s.read([0]).err().assert().kind, TimedOut); s.set_timeout(Some(20)); for i in range(0u, 1001) { @@ -598,7 +598,7 @@ mod tests { // I'm not sure as to why, but apparently the write on windows always // succeeds after the previous timeout. Who knows? if !cfg!(windows) { - assert_eq!(s.write([0]).err().unwrap().kind, TimedOut); + assert_eq!(s.write([0]).err().assert().kind, TimedOut); } tx.send(()); @@ -608,10 +608,10 @@ mod tests { iotest!(fn read_timeouts() { let addr = next_test_unix(); - let mut a = UnixListener::bind(&addr).listen().unwrap(); + let mut a = UnixListener::bind(&addr).listen().assert(); let (tx, rx) = channel::<()>(); spawn(proc() { - let mut s = UnixStream::connect(&addr).unwrap(); + let mut s = UnixStream::connect(&addr).assert(); rx.recv(); let mut amt = 0; while amt < 100 * 128 * 1024 { @@ -623,10 +623,10 @@ mod tests { let _ = rx.recv_opt(); }); - let mut s = a.accept().unwrap(); + let mut s = a.accept().assert(); s.set_read_timeout(Some(20)); - assert_eq!(s.read([0]).err().unwrap().kind, TimedOut); - assert_eq!(s.read([0]).err().unwrap().kind, TimedOut); + assert_eq!(s.read([0]).err().assert().kind, TimedOut); + assert_eq!(s.read([0]).err().assert().kind, TimedOut); tx.send(()); for _ in range(0u, 100) { @@ -636,16 +636,16 @@ mod tests { iotest!(fn write_timeouts() { let addr = next_test_unix(); - let mut a = UnixListener::bind(&addr).listen().unwrap(); + let mut a = UnixListener::bind(&addr).listen().assert(); let (tx, rx) = channel::<()>(); spawn(proc() { - let mut s = UnixStream::connect(&addr).unwrap(); + let mut s = UnixStream::connect(&addr).assert(); rx.recv(); assert!(s.write([0]).is_ok()); let _ = rx.recv_opt(); }); - let mut s = a.accept().unwrap(); + let mut s = a.accept().assert(); s.set_write_timeout(Some(20)); for i in range(0u, 1001) { match s.write([0, .. 128 * 1024]) { @@ -662,16 +662,16 @@ mod tests { iotest!(fn timeout_concurrent_read() { let addr = next_test_unix(); - let mut a = UnixListener::bind(&addr).listen().unwrap(); + let mut a = UnixListener::bind(&addr).listen().assert(); let (tx, rx) = channel::<()>(); spawn(proc() { - let mut s = UnixStream::connect(&addr).unwrap(); + let mut s = UnixStream::connect(&addr).assert(); rx.recv(); assert!(s.write([0]).is_ok()); let _ = rx.recv_opt(); }); - let mut s = a.accept().unwrap(); + let mut s = a.accept().assert(); let s2 = s.clone(); let (tx2, rx2) = channel(); spawn(proc() { @@ -681,7 +681,7 @@ mod tests { }); s.set_read_timeout(Some(20)); - assert_eq!(s.read([0]).err().unwrap().kind, TimedOut); + assert_eq!(s.read([0]).err().assert().kind, TimedOut); tx.send(()); rx2.recv(); diff --git a/src/libstd/io/pipe.rs b/src/libstd/io/pipe.rs index c476a99fee9dc..3b053c32e83ec 100644 --- a/src/libstd/io/pipe.rs +++ b/src/libstd/io/pipe.rs @@ -123,18 +123,18 @@ mod test { use os; use io::pipe::PipeStream; - let os::Pipe { reader, writer } = unsafe { os::pipe().unwrap() }; + let os::Pipe { reader, writer } = unsafe { os::pipe().assert() }; let out = PipeStream::open(writer); let mut input = PipeStream::open(reader); let (tx, rx) = channel(); spawn(proc() { let mut out = out; - out.write([10]).unwrap(); + out.write([10]).assert(); rx.recv(); // don't close the pipe until the other read has finished }); let mut buf = [0, ..10]; - input.read(buf).unwrap(); + input.read(buf).assert(); tx.send(()); }) } diff --git a/src/libstd/io/process.rs b/src/libstd/io/process.rs index 1eee69834948f..9b0a3578e152c 100644 --- a/src/libstd/io/process.rs +++ b/src/libstd/io/process.rs @@ -55,8 +55,8 @@ use collections::HashMap; /// Err(e) => fail!("failed to execute child: {}", e), /// }; /// -/// let contents = child.stdout.get_mut_ref().read_to_end(); -/// assert!(child.wait().unwrap().success()); +/// let contents = child.stdout.as_mut().assert().read_to_end(); +/// assert!(child.wait().assert().success()); /// ``` pub struct Process { handle: Box<RtioProcess + Send>, @@ -96,7 +96,7 @@ pub type EnvMap = HashMap<CString, CString>; /// Err(e) => fail!("failed to execute process: {}", e), /// }; /// -/// let output = process.stdout.get_mut_ref().read_to_end(); +/// let output = process.stdout.as_mut().assert().read_to_end(); /// ``` #[deriving(Clone)] pub struct Command { @@ -168,11 +168,11 @@ impl Command { None => { // if the env is currently just inheriting from the parent's, // materialize the parent's env into a hashtable. - self.env = Some(os::env_as_bytes().move_iter() + self.env = Some(os::env_as_bytes().iter_owned() .map(|(k, v)| (k.as_slice().to_c_str(), v.as_slice().to_c_str())) .collect()); - self.env.as_mut().unwrap() + self.env.as_mut().assert() } } } @@ -290,15 +290,15 @@ impl Command { detach: self.detach, }; io.spawn(cfg).map(|(p, io)| { - let mut io = io.move_iter().map(|p| { + let mut io = io.iter_owned().map(|p| { p.map(|p| io::PipeStream::new(p)) }); Process { handle: p, forget: false, - stdin: io.next().unwrap(), - stdout: io.next().unwrap(), - stderr: io.next().unwrap(), + stdin: io.next().assert(), + stdout: io.next().assert(), + stderr: io.next().assert(), extra_io: io.collect(), } }) @@ -599,7 +599,7 @@ impl Drop for Process { drop(mem::replace(&mut self.extra_io, Vec::new())); self.set_timeout(None); - let _ = self.wait().unwrap(); + let _ = self.wait().assert(); } } @@ -614,8 +614,8 @@ mod tests { iotest!(fn smoke() { let p = Command::new("true").spawn(); assert!(p.is_ok()); - let mut p = p.unwrap(); - assert!(p.wait().unwrap().success()); + let mut p = p.assert(); + assert!(p.wait().assert().success()); }) #[cfg(not(target_os="android"))] @@ -630,8 +630,8 @@ mod tests { iotest!(fn exit_reported_right() { let p = Command::new("false").spawn(); assert!(p.is_ok()); - let mut p = p.unwrap(); - assert!(p.wait().unwrap().matches_exit_status(1)); + let mut p = p.assert(); + assert!(p.wait().assert().matches_exit_status(1)); drop(p.wait().clone()); }) @@ -639,24 +639,24 @@ mod tests { iotest!(fn signal_reported_right() { let p = Command::new("/bin/sh").arg("-c").arg("kill -1 $$").spawn(); assert!(p.is_ok()); - let mut p = p.unwrap(); - match p.wait().unwrap() { + let mut p = p.assert(); + match p.wait().assert() { process::ExitSignal(1) => {}, result => fail!("not terminated by signal 1 (instead, {})", result), } }) pub fn read_all(input: &mut Reader) -> String { - input.read_to_string().unwrap() + input.read_to_string().assert() } pub fn run_output(cmd: Command) -> String { let p = cmd.spawn(); assert!(p.is_ok()); - let mut p = p.unwrap(); + let mut p = p.assert(); assert!(p.stdout.is_some()); - let ret = read_all(p.stdout.get_mut_ref() as &mut Reader); - assert!(p.wait().unwrap().success()); + let ret = read_all(p.stdout.as_mut().assert() as &mut Reader); + assert!(p.wait().assert().success()); return ret; } @@ -682,18 +682,18 @@ mod tests { .arg("-c").arg("read line; echo $line") .stdin(CreatePipe(true, false)) .stdout(CreatePipe(false, true)) - .spawn().unwrap(); - p.stdin.get_mut_ref().write("foobar".as_bytes()).unwrap(); + .spawn().assert(); + p.stdin.as_mut().assert().write("foobar".as_bytes()).assert(); drop(p.stdin.take()); - let out = read_all(p.stdout.get_mut_ref() as &mut Reader); - assert!(p.wait().unwrap().success()); + let out = read_all(p.stdout.as_mut().assert() as &mut Reader); + assert!(p.wait().assert().success()); assert_eq!(out, "foobar\n".to_string()); }) #[cfg(not(target_os="android"))] iotest!(fn detach_works() { - let mut p = Command::new("true").detached().spawn().unwrap(); - assert!(p.wait().unwrap().success()); + let mut p = Command::new("true").detached().spawn().assert(); + assert!(p.wait().assert().success()); }) #[cfg(windows)] @@ -708,8 +708,8 @@ mod tests { .arg("-c").arg("true") .uid(unsafe { libc::getuid() as uint }) .gid(unsafe { libc::getgid() as uint }) - .spawn().unwrap(); - assert!(p.wait().unwrap().success()); + .spawn().assert(); + assert!(p.wait().assert().success()); }) #[cfg(unix, not(target_os="android"))] @@ -724,10 +724,10 @@ mod tests { #[cfg(not(target_os="android"))] iotest!(fn test_process_status() { - let mut status = Command::new("false").status().unwrap(); + let mut status = Command::new("false").status().assert(); assert!(status.matches_exit_status(1)); - status = Command::new("true").status().unwrap(); + status = Command::new("true").status().assert(); assert!(status.success()); }) @@ -741,8 +741,8 @@ mod tests { #[cfg(not(target_os="android"))] iotest!(fn test_process_output_output() { let ProcessOutput {status, output, error} - = Command::new("echo").arg("hello").output().unwrap(); - let output_str = str::from_utf8(output.as_slice()).unwrap(); + = Command::new("echo").arg("hello").output().assert(); + let output_str = str::from_utf8(output.as_slice()).assert(); assert!(status.success()); assert_eq!(output_str.trim().to_string(), "hello".to_string()); @@ -755,7 +755,7 @@ mod tests { #[cfg(not(target_os="android"))] iotest!(fn test_process_output_error() { let ProcessOutput {status, output, error} - = Command::new("mkdir").arg(".").output().unwrap(); + = Command::new("mkdir").arg(".").output().assert(); assert!(status.matches_exit_status(1)); assert_eq!(output, Vec::new()); @@ -764,22 +764,22 @@ mod tests { #[cfg(not(target_os="android"))] iotest!(fn test_finish_once() { - let mut prog = Command::new("false").spawn().unwrap(); - assert!(prog.wait().unwrap().matches_exit_status(1)); + let mut prog = Command::new("false").spawn().assert(); + assert!(prog.wait().assert().matches_exit_status(1)); }) #[cfg(not(target_os="android"))] iotest!(fn test_finish_twice() { - let mut prog = Command::new("false").spawn().unwrap(); - assert!(prog.wait().unwrap().matches_exit_status(1)); - assert!(prog.wait().unwrap().matches_exit_status(1)); + let mut prog = Command::new("false").spawn().assert(); + assert!(prog.wait().assert().matches_exit_status(1)); + assert!(prog.wait().assert().matches_exit_status(1)); }) #[cfg(not(target_os="android"))] iotest!(fn test_wait_with_output_once() { - let prog = Command::new("echo").arg("hello").spawn().unwrap(); - let ProcessOutput {status, output, error} = prog.wait_with_output().unwrap(); - let output_str = str::from_utf8(output.as_slice()).unwrap(); + let prog = Command::new("echo").arg("hello").spawn().assert(); + let ProcessOutput {status, output, error} = prog.wait_with_output().assert(); + let output_str = str::from_utf8(output.as_slice()).assert(); assert!(status.success()); assert_eq!(output_str.trim().to_string(), "hello".to_string()); @@ -809,14 +809,14 @@ mod tests { iotest!(fn test_keep_current_working_dir() { use os; - let prog = pwd_cmd().spawn().unwrap(); + let prog = pwd_cmd().spawn().assert(); - let output = String::from_utf8(prog.wait_with_output().unwrap().output).unwrap(); + let output = String::from_utf8(prog.wait_with_output().assert().output).assert(); let parent_dir = os::getcwd(); let child_dir = Path::new(output.as_slice().trim()); - let parent_stat = parent_dir.stat().unwrap(); - let child_stat = child_dir.stat().unwrap(); + let parent_stat = parent_dir.stat().assert(); + let child_stat = child_dir.stat().assert(); assert_eq!(parent_stat.unstable.device, child_stat.unstable.device); assert_eq!(parent_stat.unstable.inode, child_stat.unstable.inode); @@ -827,13 +827,13 @@ mod tests { // test changing to the parent of os::getcwd() because we know // the path exists (and os::getcwd() is not expected to be root) let parent_dir = os::getcwd().dir_path(); - let prog = pwd_cmd().cwd(&parent_dir).spawn().unwrap(); + let prog = pwd_cmd().cwd(&parent_dir).spawn().assert(); - let output = String::from_utf8(prog.wait_with_output().unwrap().output).unwrap(); + let output = String::from_utf8(prog.wait_with_output().assert().output).assert(); let child_dir = Path::new(output.as_slice().trim().into_string()); - let parent_stat = parent_dir.stat().unwrap(); - let child_stat = child_dir.stat().unwrap(); + let parent_stat = parent_dir.stat().assert(); + let child_stat = child_dir.stat().assert(); assert_eq!(parent_stat.unstable.device, child_stat.unstable.device); assert_eq!(parent_stat.unstable.inode, child_stat.unstable.inode); @@ -862,8 +862,8 @@ mod tests { use os; if running_on_valgrind() { return; } - let prog = env_cmd().spawn().unwrap(); - let output = String::from_utf8(prog.wait_with_output().unwrap().output).unwrap(); + let prog = env_cmd().spawn().assert(); + let output = String::from_utf8(prog.wait_with_output().assert().output).assert(); let r = os::env(); for &(ref k, ref v) in r.iter() { @@ -878,8 +878,8 @@ mod tests { use os; if running_on_valgrind() { return; } - let mut prog = env_cmd().spawn().unwrap(); - let output = String::from_utf8(prog.wait_with_output().unwrap().output).unwrap(); + let mut prog = env_cmd().spawn().assert(); + let output = String::from_utf8(prog.wait_with_output().assert().output).assert(); let r = os::env(); for &(ref k, ref v) in r.iter() { @@ -899,8 +899,8 @@ mod tests { iotest!(fn test_override_env() { let new_env = vec![("RUN_TEST_NEW_ENV", "123")]; - let prog = env_cmd().env_set_all(new_env.as_slice()).spawn().unwrap(); - let result = prog.wait_with_output().unwrap(); + let prog = env_cmd().env_set_all(new_env.as_slice()).spawn().assert(); + let result = prog.wait_with_output().assert(); let output = String::from_utf8_lossy(result.output.as_slice()).into_string(); assert!(output.as_slice().contains("RUN_TEST_NEW_ENV=123"), @@ -908,8 +908,8 @@ mod tests { }) iotest!(fn test_add_to_env() { - let prog = env_cmd().env("RUN_TEST_NEW_ENV", "123").spawn().unwrap(); - let result = prog.wait_with_output().unwrap(); + let prog = env_cmd().env("RUN_TEST_NEW_ENV", "123").spawn().assert(); + let result = prog.wait_with_output().assert(); let output = str::from_utf8_lossy(result.output.as_slice()).into_string(); assert!(output.as_slice().contains("RUN_TEST_NEW_ENV=123"), @@ -923,8 +923,8 @@ mod tests { let old_env = os::getenv("RUN_TEST_NEW_ENV"); os::setenv("RUN_TEST_NEW_ENV", "123"); - let prog = env_cmd().env_remove("RUN_TEST_NEW_ENV").spawn().unwrap(); - let result = prog.wait_with_output().unwrap(); + let prog = env_cmd().env_remove("RUN_TEST_NEW_ENV").spawn().assert(); + let result = prog.wait_with_output().assert(); let output = str::from_utf8_lossy(result.output.as_slice()).into_string(); // restore original environment @@ -943,35 +943,35 @@ mod tests { #[cfg(unix)] pub fn sleeper() -> Process { - Command::new("sleep").arg("1000").spawn().unwrap() + Command::new("sleep").arg("1000").spawn().assert() } #[cfg(windows)] pub fn sleeper() -> Process { // There's a `timeout` command on windows, but it doesn't like having // its output piped, so instead just ping ourselves a few times with // gaps in between so we're sure this process is alive for awhile - Command::new("ping").arg("127.0.0.1").arg("-n").arg("1000").spawn().unwrap() + Command::new("ping").arg("127.0.0.1").arg("-n").arg("1000").spawn().assert() } iotest!(fn test_kill() { let mut p = sleeper(); - Process::kill(p.id(), PleaseExitSignal).unwrap(); - assert!(!p.wait().unwrap().success()); + Process::kill(p.id(), PleaseExitSignal).assert(); + assert!(!p.wait().assert().success()); }) iotest!(fn test_exists() { let mut p = sleeper(); assert!(Process::kill(p.id(), 0).is_ok()); - p.signal_kill().unwrap(); - assert!(!p.wait().unwrap().success()); + p.signal_kill().assert(); + assert!(!p.wait().assert().success()); }) iotest!(fn test_zero() { let mut p = sleeper(); - p.signal_kill().unwrap(); + p.signal_kill().assert(); for _ in range(0i, 20) { if p.signal(0).is_err() { - assert!(!p.wait().unwrap().success()); + assert!(!p.wait().assert().success()); return } timer::sleep(100); @@ -982,9 +982,9 @@ mod tests { iotest!(fn wait_timeout() { let mut p = sleeper(); p.set_timeout(Some(10)); - assert_eq!(p.wait().err().unwrap().kind, TimedOut); - assert_eq!(p.wait().err().unwrap().kind, TimedOut); - p.signal_kill().unwrap(); + assert_eq!(p.wait().err().assert().kind, TimedOut); + assert_eq!(p.wait().err().assert().kind, TimedOut); + p.signal_kill().assert(); p.set_timeout(None); assert!(p.wait().is_ok()); }) @@ -995,15 +995,15 @@ mod tests { spawn(proc() { let mut p = sleeper(); p.set_timeout(Some(10)); - assert_eq!(p.wait().err().unwrap().kind, TimedOut); - p.signal_kill().unwrap(); + assert_eq!(p.wait().err().assert().kind, TimedOut); + p.signal_kill().assert(); tx.send(()); }); spawn(proc() { let mut p = sleeper(); p.set_timeout(Some(10)); - assert_eq!(p.wait().err().unwrap().kind, TimedOut); - p.signal_kill().unwrap(); + assert_eq!(p.wait().err().assert().kind, TimedOut); + p.signal_kill().assert(); tx2.send(()); }); rx.recv(); diff --git a/src/libstd/io/result.rs b/src/libstd/io/result.rs index a69f6c10abf8e..bded16ed4353e 100644 --- a/src/libstd/io/result.rs +++ b/src/libstd/io/result.rs @@ -85,9 +85,9 @@ mod test { #[test] fn test_option_writer() { let mut writer: io::IoResult<MemWriter> = Ok(MemWriter::new()); - writer.write([0, 1, 2]).unwrap(); - writer.flush().unwrap(); - assert_eq!(writer.unwrap().unwrap(), vec!(0, 1, 2)); + writer.write([0, 1, 2]).assert(); + writer.flush().assert(); + assert_eq!(writer.assert().unwrap(), vec!(0, 1, 2)); } #[test] @@ -110,7 +110,7 @@ mod test { let mut reader: io::IoResult<MemReader> = Ok(MemReader::new(vec!(0, 1, 2, 3))); let mut buf = [0, 0]; - reader.read(buf).unwrap(); + reader.read(buf).assert(); assert_eq!(buf.as_slice(), &[0, 1]); } diff --git a/src/libstd/io/signal.rs b/src/libstd/io/signal.rs index c126866e7159a..dd71318740660 100644 --- a/src/libstd/io/signal.rs +++ b/src/libstd/io/signal.rs @@ -177,7 +177,7 @@ mod test_unix { #[test] #[cfg(not(target_os="android"))] // FIXME(#10378) fn test_io_signal_smoketest() { let mut signal = Listener::new(); - signal.register(Interrupt).unwrap(); + signal.register(Interrupt).assert(); sigint(); timer::sleep(10); match signal.rx.recv() { @@ -190,8 +190,8 @@ mod test_unix { fn test_io_signal_two_signal_one_signum() { let mut s1 = Listener::new(); let mut s2 = Listener::new(); - s1.register(Interrupt).unwrap(); - s2.register(Interrupt).unwrap(); + s1.register(Interrupt).assert(); + s2.register(Interrupt).assert(); sigint(); timer::sleep(10); match s1.rx.recv() { @@ -208,8 +208,8 @@ mod test_unix { fn test_io_signal_unregister() { let mut s1 = Listener::new(); let mut s2 = Listener::new(); - s1.register(Interrupt).unwrap(); - s2.register(Interrupt).unwrap(); + s1.register(Interrupt).assert(); + s2.register(Interrupt).assert(); s2.unregister(Interrupt); sigint(); timer::sleep(10); diff --git a/src/libstd/io/stdio.rs b/src/libstd/io/stdio.rs index 5b33c3671b488..23df569f96174 100644 --- a/src/libstd/io/stdio.rs +++ b/src/libstd/io/stdio.rs @@ -84,7 +84,7 @@ fn src<T>(fd: libc::c_int, readable: bool, f: |StdSource| -> T) -> T { Ok(tty) => f(TTY(tty)), Err(_) => f(File(io.fs_from_raw_fd(fd, DontClose))), }) - }).map_err(IoError::from_rtio_error).unwrap() + }).map_err(IoError::from_rtio_error).assert() } local_data_key!(local_stdout: Box<Writer + Send>) @@ -391,7 +391,7 @@ mod tests { set_stdout(box w); println!("hello!"); }); - assert_eq!(r.read_to_string().unwrap(), "hello!\n".to_string()); + assert_eq!(r.read_to_string().assert(), "hello!\n".to_string()); }) iotest!(fn capture_stderr() { @@ -404,7 +404,7 @@ mod tests { ::realstd::io::stdio::set_stderr(box w); fail!("my special message"); }); - let s = r.read_to_string().unwrap(); + let s = r.read_to_string().assert(); assert!(s.as_slice().contains("my special message")); }) } diff --git a/src/libstd/io/tempfile.rs b/src/libstd/io/tempfile.rs index 2faa23a6aa0a5..f79f84df97dba 100644 --- a/src/libstd/io/tempfile.rs +++ b/src/libstd/io/tempfile.rs @@ -70,12 +70,12 @@ impl TempDir { /// temporary directory is prevented. pub fn unwrap(self) -> Path { let mut tmpdir = self; - tmpdir.path.take_unwrap() + tmpdir.path.take().assert() } /// Access the wrapped `std::path::Path` to the temporary directory. pub fn path<'a>(&'a self) -> &'a Path { - self.path.get_ref() + self.path.as_ref().assert() } /// Close and remove the temporary directory diff --git a/src/libstd/io/test.rs b/src/libstd/io/test.rs index 331cfa1a59ef9..74d7a92d2f767 100644 --- a/src/libstd/io/test.rs +++ b/src/libstd/io/test.rs @@ -113,7 +113,7 @@ fn base_port() -> u16 { // FIXME (#9639): This needs to handle non-utf8 paths let path = os::getcwd(); - let path_s = path.as_str().unwrap(); + let path_s = path.as_str().assert(); let mut final_base = base; @@ -164,7 +164,7 @@ mod darwin_fd_limit { pub unsafe fn raise_fd_limit() { // The strategy here is to fetch the current resource limits, read the kern.maxfilesperproc // sysctl value, and bump the soft resource limit for maxfiles up to the sysctl value. - use ptr::mut_null; + use ptr::null_mut; use mem::size_of_val; use os::last_os_error; @@ -173,7 +173,7 @@ mod darwin_fd_limit { let mut maxfiles: libc::c_int = 0; let mut size: libc::size_t = size_of_val(&maxfiles) as libc::size_t; if sysctl(&mut mib[0], 2, &mut maxfiles as *mut libc::c_int as *mut libc::c_void, &mut size, - mut_null(), 0) != 0 { + null_mut(), 0) != 0 { let err = last_os_error(); fail!("raise_fd_limit: error calling sysctl: {}", err); } diff --git a/src/libstd/io/timer.rs b/src/libstd/io/timer.rs index 1c9e428dcad82..74d03cae966a1 100644 --- a/src/libstd/io/timer.rs +++ b/src/libstd/io/timer.rs @@ -36,7 +36,7 @@ use rt::rtio::{IoFactory, LocalIo, RtioTimer, Callback}; /// # fn foo() { /// use std::io::Timer; /// -/// let mut timer = Timer::new().unwrap(); +/// let mut timer = Timer::new().assert(); /// timer.sleep(10); // block the task for awhile /// /// let timeout = timer.oneshot(10); @@ -112,7 +112,7 @@ impl Timer { /// ```rust /// use std::io::Timer; /// - /// let mut timer = Timer::new().unwrap(); + /// let mut timer = Timer::new().assert(); /// let ten_milliseconds = timer.oneshot(10); /// /// for _ in range(0u, 100) { /* do work */ } @@ -125,7 +125,7 @@ impl Timer { /// use std::io::Timer; /// /// // Incorrect, method chaining-style: - /// let mut five_ms = Timer::new().unwrap().oneshot(5); + /// let mut five_ms = Timer::new().assert().oneshot(5); /// // The timer object was destroyed, so this will always fail: /// // five_ms.recv() /// ``` @@ -154,7 +154,7 @@ impl Timer { /// ```rust /// use std::io::Timer; /// - /// let mut timer = Timer::new().unwrap(); + /// let mut timer = Timer::new().assert(); /// let ten_milliseconds = timer.periodic(10); /// /// for _ in range(0u, 100) { /* do work */ } @@ -173,7 +173,7 @@ impl Timer { /// use std::io::Timer; /// /// // Incorrect, method chaining-style. - /// let mut five_ms = Timer::new().unwrap().periodic(5); + /// let mut five_ms = Timer::new().assert().periodic(5); /// // The timer object was destroyed, so this will always fail: /// // five_ms.recv() /// ``` @@ -193,22 +193,22 @@ impl Callback for TimerCallback { #[cfg(test)] mod test { iotest!(fn test_io_timer_sleep_simple() { - let mut timer = Timer::new().unwrap(); + let mut timer = Timer::new().assert(); timer.sleep(1); }) iotest!(fn test_io_timer_sleep_oneshot() { - let mut timer = Timer::new().unwrap(); + let mut timer = Timer::new().assert(); timer.oneshot(1).recv(); }) iotest!(fn test_io_timer_sleep_oneshot_forget() { - let mut timer = Timer::new().unwrap(); + let mut timer = Timer::new().assert(); timer.oneshot(100000000000); }) iotest!(fn oneshot_twice() { - let mut timer = Timer::new().unwrap(); + let mut timer = Timer::new().assert(); let rx1 = timer.oneshot(10000); let rx = timer.oneshot(1); rx.recv(); @@ -216,7 +216,7 @@ mod test { }) iotest!(fn test_io_timer_oneshot_then_sleep() { - let mut timer = Timer::new().unwrap(); + let mut timer = Timer::new().assert(); let rx = timer.oneshot(100000000000); timer.sleep(1); // this should invalidate rx @@ -224,7 +224,7 @@ mod test { }) iotest!(fn test_io_timer_sleep_periodic() { - let mut timer = Timer::new().unwrap(); + let mut timer = Timer::new().assert(); let rx = timer.periodic(1); rx.recv(); rx.recv(); @@ -232,7 +232,7 @@ mod test { }) iotest!(fn test_io_timer_sleep_periodic_forget() { - let mut timer = Timer::new().unwrap(); + let mut timer = Timer::new().assert(); timer.periodic(100000000000); }) @@ -241,7 +241,7 @@ mod test { }) iotest!(fn oneshot() { - let mut timer = Timer::new().unwrap(); + let mut timer = Timer::new().assert(); let rx = timer.oneshot(1); rx.recv(); @@ -253,7 +253,7 @@ mod test { }) iotest!(fn override() { - let mut timer = Timer::new().unwrap(); + let mut timer = Timer::new().assert(); let orx = timer.oneshot(100); let prx = timer.periodic(100); timer.sleep(1); @@ -263,7 +263,7 @@ mod test { }) iotest!(fn period() { - let mut timer = Timer::new().unwrap(); + let mut timer = Timer::new().assert(); let rx = timer.periodic(1); rx.recv(); rx.recv(); @@ -273,31 +273,31 @@ mod test { }) iotest!(fn sleep() { - let mut timer = Timer::new().unwrap(); + let mut timer = Timer::new().assert(); timer.sleep(1); timer.sleep(1); }) iotest!(fn oneshot_fail() { - let mut timer = Timer::new().unwrap(); + let mut timer = Timer::new().assert(); let _rx = timer.oneshot(1); fail!(); } #[should_fail]) iotest!(fn period_fail() { - let mut timer = Timer::new().unwrap(); + let mut timer = Timer::new().assert(); let _rx = timer.periodic(1); fail!(); } #[should_fail]) iotest!(fn normal_fail() { - let _timer = Timer::new().unwrap(); + let _timer = Timer::new().assert(); fail!(); } #[should_fail]) iotest!(fn closing_channel_during_drop_doesnt_kill_everything() { // see issue #10375 - let mut timer = Timer::new().unwrap(); + let mut timer = Timer::new().assert(); let timer_rx = timer.periodic(1000); spawn(proc() { @@ -310,7 +310,7 @@ mod test { iotest!(fn reset_doesnt_switch_tasks() { // similar test to the one above. - let mut timer = Timer::new().unwrap(); + let mut timer = Timer::new().assert(); let timer_rx = timer.periodic(1000); spawn(proc() { @@ -322,7 +322,7 @@ mod test { iotest!(fn reset_doesnt_switch_tasks2() { // similar test to the one above. - let mut timer = Timer::new().unwrap(); + let mut timer = Timer::new().assert(); let timer_rx = timer.periodic(1000); spawn(proc() { @@ -334,7 +334,7 @@ mod test { iotest!(fn sender_goes_away_oneshot() { let rx = { - let mut timer = Timer::new().unwrap(); + let mut timer = Timer::new().assert(); timer.oneshot(1000) }; assert_eq!(rx.recv_opt(), Err(())); @@ -342,25 +342,25 @@ mod test { iotest!(fn sender_goes_away_period() { let rx = { - let mut timer = Timer::new().unwrap(); + let mut timer = Timer::new().assert(); timer.periodic(1000) }; assert_eq!(rx.recv_opt(), Err(())); }) iotest!(fn receiver_goes_away_oneshot() { - let mut timer1 = Timer::new().unwrap(); + let mut timer1 = Timer::new().assert(); timer1.oneshot(1); - let mut timer2 = Timer::new().unwrap(); + let mut timer2 = Timer::new().assert(); // while sleeping, the previous timer should fire and not have its // callback do something terrible. timer2.sleep(2); }) iotest!(fn receiver_goes_away_period() { - let mut timer1 = Timer::new().unwrap(); + let mut timer1 = Timer::new().assert(); timer1.periodic(1); - let mut timer2 = Timer::new().unwrap(); + let mut timer2 = Timer::new().assert(); // while sleeping, the previous timer should fire and not have its // callback do something terrible. timer2.sleep(2); diff --git a/src/libstd/io/util.rs b/src/libstd/io/util.rs index e928323030c4f..7b26c52f34ba7 100644 --- a/src/libstd/io/util.rs +++ b/src/libstd/io/util.rs @@ -48,7 +48,7 @@ impl<R: Reader> Reader for LimitReader<R> { } let len = cmp::min(self.limit, buf.len()); - self.inner.read(buf.mut_slice_to(len)).map(|len| { + self.inner.read(buf.slice_to_mut(len)).map(|len| { self.limit -= len; len }) @@ -133,7 +133,7 @@ impl Writer for MultiWriter { #[inline] fn write(&mut self, buf: &[u8]) -> io::IoResult<()> { let mut ret = Ok(()); - for writer in self.writers.mut_iter() { + for writer in self.writers.iter_mut() { ret = ret.and(writer.write(buf)); } return ret; @@ -142,7 +142,7 @@ impl Writer for MultiWriter { #[inline] fn flush(&mut self) -> io::IoResult<()> { let mut ret = Ok(()); - for writer in self.writers.mut_iter() { + for writer in self.writers.iter_mut() { ret = ret.and(writer.flush()); } return ret; @@ -247,7 +247,7 @@ impl<T: Iterator<u8>> Reader for IterReader<T> { #[inline] fn read(&mut self, buf: &mut [u8]) -> io::IoResult<uint> { let mut len = 0; - for (slot, elt) in buf.mut_iter().zip(self.iter.by_ref()) { + for (slot, elt) in buf.iter_mut().zip(self.iter.by_ref()) { *slot = elt; len += 1; } @@ -272,7 +272,7 @@ mod test { let mut r = MemReader::new(vec!(0, 1, 2)); { let mut r = LimitReader::new(r.by_ref(), 4); - assert_eq!(vec!(0, 1, 2), r.read_to_end().unwrap()); + assert_eq!(vec!(0, 1, 2), r.read_to_end().assert()); } } @@ -281,9 +281,9 @@ mod test { let mut r = MemReader::new(vec!(0, 1, 2)); { let mut r = LimitReader::new(r.by_ref(), 2); - assert_eq!(vec!(0, 1), r.read_to_end().unwrap()); + assert_eq!(vec!(0, 1), r.read_to_end().assert()); } - assert_eq!(vec!(2), r.read_to_end().unwrap()); + assert_eq!(vec!(2), r.read_to_end().assert()); } #[test] @@ -291,9 +291,9 @@ mod test { let r = MemReader::new(vec!(0, 1, 2)); let mut r = LimitReader::new(r, 3); assert_eq!(3, r.limit()); - assert_eq!(0, r.read_byte().unwrap()); + assert_eq!(0, r.read_byte().assert()); assert_eq!(2, r.limit()); - assert_eq!(vec!(1, 2), r.read_to_end().unwrap()); + assert_eq!(vec!(1, 2), r.read_to_end().assert()); assert_eq!(0, r.limit()); } @@ -301,8 +301,8 @@ mod test { fn test_null_writer() { let mut s = NullWriter; let buf = vec![0, 0, 0]; - s.write(buf.as_slice()).unwrap(); - s.flush().unwrap(); + s.write(buf.as_slice()).assert(); + s.flush().assert(); } #[test] @@ -340,10 +340,10 @@ mod test { let mut multi = MultiWriter::new(vec!(box TestWriter as Box<Writer>, box TestWriter as Box<Writer>)); - multi.write([1, 2, 3]).unwrap(); + multi.write([1, 2, 3]).assert(); assert_eq!(2, unsafe { writes }); assert_eq!(0, unsafe { flushes }); - multi.flush().unwrap(); + multi.flush().assert(); assert_eq!(2, unsafe { writes }); assert_eq!(2, unsafe { flushes }); } @@ -352,15 +352,15 @@ mod test { fn test_chained_reader() { let rs = vec!(MemReader::new(vec!(0, 1)), MemReader::new(vec!()), MemReader::new(vec!(2, 3))); - let mut r = ChainedReader::new(rs.move_iter()); - assert_eq!(vec!(0, 1, 2, 3), r.read_to_end().unwrap()); + let mut r = ChainedReader::new(rs.iter_owned()); + assert_eq!(vec!(0, 1, 2, 3), r.read_to_end().assert()); } #[test] fn test_tee_reader() { let mut r = TeeReader::new(MemReader::new(vec!(0, 1, 2)), MemWriter::new()); - assert_eq!(vec!(0, 1, 2), r.read_to_end().unwrap()); + assert_eq!(vec!(0, 1, 2), r.read_to_end().assert()); let (_, w) = r.unwrap(); assert_eq!(vec!(0, 1, 2), w.unwrap()); } @@ -369,7 +369,7 @@ mod test { fn test_copy() { let mut r = MemReader::new(vec!(0, 1, 2, 3, 4)); let mut w = MemWriter::new(); - copy(&mut r, &mut w).unwrap(); + copy(&mut r, &mut w).assert(); assert_eq!(vec!(0, 1, 2, 3, 4), w.unwrap()); } @@ -381,7 +381,7 @@ mod test { let mut r = LimitReader::new(r.by_ref(), 3); assert_eq!(r.read_line(), Ok("012".to_string())); assert_eq!(r.limit(), 0); - assert_eq!(r.read_line().err().unwrap().kind, io::EndOfFile); + assert_eq!(r.read_line().err().assert().kind, io::EndOfFile); } { let mut r = LimitReader::new(r.by_ref(), 9); @@ -401,18 +401,18 @@ mod test { fn test_iter_reader() { let mut r = IterReader::new(range(0u8, 8)); let mut buf = [0, 0, 0]; - let len = r.read(buf).unwrap(); + let len = r.read(buf).assert(); assert_eq!(len, 3); assert!(buf == [0, 1, 2]); - let len = r.read(buf).unwrap(); + let len = r.read(buf).assert(); assert_eq!(len, 3); assert!(buf == [3, 4, 5]); - let len = r.read(buf).unwrap(); + let len = r.read(buf).assert(); assert_eq!(len, 2); assert!(buf == [6, 7, 5]); - assert_eq!(r.read(buf).unwrap_err().kind, io::EndOfFile); + assert_eq!(r.read(buf).assert_err().kind, io::EndOfFile); } } diff --git a/src/libstd/num/f32.rs b/src/libstd/num/f32.rs index 680620f5a752f..a5fc2d16f7ebd 100644 --- a/src/libstd/num/f32.rs +++ b/src/libstd/num/f32.rs @@ -734,8 +734,8 @@ mod tests { fn test_ldexp() { // We have to use from_str until base-2 exponents // are supported in floating-point literals - let f1: f32 = from_str_hex("1p-123").unwrap(); - let f2: f32 = from_str_hex("1p-111").unwrap(); + let f1: f32 = from_str_hex("1p-123").assert(); + let f2: f32 = from_str_hex("1p-111").assert(); assert_eq!(FloatMath::ldexp(1f32, -123), f1); assert_eq!(FloatMath::ldexp(1f32, -111), f2); @@ -754,8 +754,8 @@ mod tests { fn test_frexp() { // We have to use from_str until base-2 exponents // are supported in floating-point literals - let f1: f32 = from_str_hex("1p-123").unwrap(); - let f2: f32 = from_str_hex("1p-111").unwrap(); + let f1: f32 = from_str_hex("1p-123").assert(); + let f2: f32 = from_str_hex("1p-111").assert(); let (x1, exp1) = f1.frexp(); let (x2, exp2) = f2.frexp(); assert_eq!((x1, exp1), (0.5f32, -122)); diff --git a/src/libstd/num/f64.rs b/src/libstd/num/f64.rs index 3180ee28c6fee..6ff315be26367 100644 --- a/src/libstd/num/f64.rs +++ b/src/libstd/num/f64.rs @@ -736,8 +736,8 @@ mod tests { fn test_ldexp() { // We have to use from_str until base-2 exponents // are supported in floating-point literals - let f1: f64 = from_str_hex("1p-123").unwrap(); - let f2: f64 = from_str_hex("1p-111").unwrap(); + let f1: f64 = from_str_hex("1p-123").assert(); + let f2: f64 = from_str_hex("1p-111").assert(); assert_eq!(FloatMath::ldexp(1f64, -123), f1); assert_eq!(FloatMath::ldexp(1f64, -111), f2); @@ -756,8 +756,8 @@ mod tests { fn test_frexp() { // We have to use from_str until base-2 exponents // are supported in floating-point literals - let f1: f64 = from_str_hex("1p-123").unwrap(); - let f2: f64 = from_str_hex("1p-111").unwrap(); + let f1: f64 = from_str_hex("1p-123").assert(); + let f2: f64 = from_str_hex("1p-111").assert(); let (x1, exp1) = f1.frexp(); let (x2, exp2) = f2.frexp(); assert_eq!((x1, exp1), (0.5f64, -122)); diff --git a/src/libstd/num/int_macros.rs b/src/libstd/num/int_macros.rs index 3c01edf233925..b708bd1dd5409 100644 --- a/src/libstd/num/int_macros.rs +++ b/src/libstd/num/int_macros.rs @@ -75,8 +75,8 @@ pub fn to_str_bytes<U>(n: $T, radix: uint, f: |v: &[u8]| -> U) -> U { let mut buf = [0u8, ..65]; let amt = { let mut wr = ::io::BufWriter::new(buf); - (write!(&mut wr, "{}", ::fmt::radix(n, radix as u8))).unwrap(); - wr.tell().unwrap() as uint + (write!(&mut wr, "{}", ::fmt::radix(n, radix as u8))).assert(); + wr.tell().assert() as uint }; f(buf.slice(0, amt)) } diff --git a/src/libstd/num/mod.rs b/src/libstd/num/mod.rs index 27ee1e3ce3bb3..cbc690df7b955 100644 --- a/src/libstd/num/mod.rs +++ b/src/libstd/num/mod.rs @@ -132,11 +132,11 @@ pub fn from_str_radix<T: FromStrRadix>(str: &str, radix: uint) -> Option<T> { /// Helper function for testing numeric operations #[cfg(test)] pub fn test_num<T:Num + NumCast + Show>(ten: T, two: T) { - assert_eq!(ten.add(&two), cast(12i).unwrap()); - assert_eq!(ten.sub(&two), cast(8i).unwrap()); - assert_eq!(ten.mul(&two), cast(20i).unwrap()); - assert_eq!(ten.div(&two), cast(5i).unwrap()); - assert_eq!(ten.rem(&two), cast(0i).unwrap()); + assert_eq!(ten.add(&two), cast(12i).assert()); + assert_eq!(ten.sub(&two), cast(8i).assert()); + assert_eq!(ten.mul(&two), cast(20i).assert()); + assert_eq!(ten.div(&two), cast(5i).assert()); + assert_eq!(ten.rem(&two), cast(0i).assert()); assert_eq!(ten.add(&two), ten + two); assert_eq!(ten.sub(&two), ten - two); @@ -164,44 +164,44 @@ mod tests { ($_20:expr) => ({ let _20 = $_20; - assert_eq!(20u, _20.to_uint().unwrap()); - assert_eq!(20u8, _20.to_u8().unwrap()); - assert_eq!(20u16, _20.to_u16().unwrap()); - assert_eq!(20u32, _20.to_u32().unwrap()); - assert_eq!(20u64, _20.to_u64().unwrap()); - assert_eq!(20i, _20.to_int().unwrap()); - assert_eq!(20i8, _20.to_i8().unwrap()); - assert_eq!(20i16, _20.to_i16().unwrap()); - assert_eq!(20i32, _20.to_i32().unwrap()); - assert_eq!(20i64, _20.to_i64().unwrap()); - assert_eq!(20f32, _20.to_f32().unwrap()); - assert_eq!(20f64, _20.to_f64().unwrap()); - - assert_eq!(_20, NumCast::from(20u).unwrap()); - assert_eq!(_20, NumCast::from(20u8).unwrap()); - assert_eq!(_20, NumCast::from(20u16).unwrap()); - assert_eq!(_20, NumCast::from(20u32).unwrap()); - assert_eq!(_20, NumCast::from(20u64).unwrap()); - assert_eq!(_20, NumCast::from(20i).unwrap()); - assert_eq!(_20, NumCast::from(20i8).unwrap()); - assert_eq!(_20, NumCast::from(20i16).unwrap()); - assert_eq!(_20, NumCast::from(20i32).unwrap()); - assert_eq!(_20, NumCast::from(20i64).unwrap()); - assert_eq!(_20, NumCast::from(20f32).unwrap()); - assert_eq!(_20, NumCast::from(20f64).unwrap()); - - assert_eq!(_20, cast(20u).unwrap()); - assert_eq!(_20, cast(20u8).unwrap()); - assert_eq!(_20, cast(20u16).unwrap()); - assert_eq!(_20, cast(20u32).unwrap()); - assert_eq!(_20, cast(20u64).unwrap()); - assert_eq!(_20, cast(20i).unwrap()); - assert_eq!(_20, cast(20i8).unwrap()); - assert_eq!(_20, cast(20i16).unwrap()); - assert_eq!(_20, cast(20i32).unwrap()); - assert_eq!(_20, cast(20i64).unwrap()); - assert_eq!(_20, cast(20f32).unwrap()); - assert_eq!(_20, cast(20f64).unwrap()); + assert_eq!(20u, _20.to_uint().assert()); + assert_eq!(20u8, _20.to_u8().assert()); + assert_eq!(20u16, _20.to_u16().assert()); + assert_eq!(20u32, _20.to_u32().assert()); + assert_eq!(20u64, _20.to_u64().assert()); + assert_eq!(20i, _20.to_int().assert()); + assert_eq!(20i8, _20.to_i8().assert()); + assert_eq!(20i16, _20.to_i16().assert()); + assert_eq!(20i32, _20.to_i32().assert()); + assert_eq!(20i64, _20.to_i64().assert()); + assert_eq!(20f32, _20.to_f32().assert()); + assert_eq!(20f64, _20.to_f64().assert()); + + assert_eq!(_20, NumCast::from(20u).assert()); + assert_eq!(_20, NumCast::from(20u8).assert()); + assert_eq!(_20, NumCast::from(20u16).assert()); + assert_eq!(_20, NumCast::from(20u32).assert()); + assert_eq!(_20, NumCast::from(20u64).assert()); + assert_eq!(_20, NumCast::from(20i).assert()); + assert_eq!(_20, NumCast::from(20i8).assert()); + assert_eq!(_20, NumCast::from(20i16).assert()); + assert_eq!(_20, NumCast::from(20i32).assert()); + assert_eq!(_20, NumCast::from(20i64).assert()); + assert_eq!(_20, NumCast::from(20f32).assert()); + assert_eq!(_20, NumCast::from(20f64).assert()); + + assert_eq!(_20, cast(20u).assert()); + assert_eq!(_20, cast(20u8).assert()); + assert_eq!(_20, cast(20u16).assert()); + assert_eq!(_20, cast(20u32).assert()); + assert_eq!(_20, cast(20u64).assert()); + assert_eq!(_20, cast(20i).assert()); + assert_eq!(_20, cast(20i8).assert()); + assert_eq!(_20, cast(20i16).assert()); + assert_eq!(_20, cast(20i32).assert()); + assert_eq!(_20, cast(20i64).assert()); + assert_eq!(_20, cast(20f32).assert()); + assert_eq!(_20, cast(20f64).assert()); }) ) diff --git a/src/libstd/num/strconv.rs b/src/libstd/num/strconv.rs index 37378518dc8e1..1085db0301c63 100644 --- a/src/libstd/num/strconv.rs +++ b/src/libstd/num/strconv.rs @@ -175,7 +175,7 @@ pub fn int_to_str_bytes_common<T: Int>(num: T, radix: uint, sign: SignFormat, f: let _0: T = Zero::zero(); let neg = num < _0; - let radix_gen: T = cast(radix).unwrap(); + let radix_gen: T = cast(radix).assert(); let mut deccum = num; // This is just for integral types, the largest of which is a u64. The @@ -198,7 +198,7 @@ pub fn int_to_str_bytes_common<T: Int>(num: T, radix: uint, sign: SignFormat, f: } else { current_digit_signed }; - buf[cur] = match current_digit.to_u8().unwrap() { + buf[cur] = match current_digit.to_u8().assert() { i @ 0..9 => b'0' + i, i => b'a' + (i - 10), }; @@ -296,7 +296,7 @@ pub fn float_to_str_bytes_common<T:NumCast+Zero+One+PartialEq+PartialOrd+Float+ let neg = num < _0 || (negative_zero && _1 / num == Float::neg_infinity()); let mut buf = Vec::new(); - let radix_gen: T = cast(radix as int).unwrap(); + let radix_gen: T = cast(radix as int).assert(); let (num, exp) = match exp_format { ExpNone => (num, 0i32), @@ -305,12 +305,12 @@ pub fn float_to_str_bytes_common<T:NumCast+Zero+One+PartialEq+PartialOrd+Float+ (num, 0i32) } else { let (exp, exp_base) = match exp_format { - ExpDec => (num.abs().log10().floor(), cast::<f64, T>(10.0f64).unwrap()), - ExpBin => (num.abs().log2().floor(), cast::<f64, T>(2.0f64).unwrap()), + ExpDec => (num.abs().log10().floor(), cast::<f64, T>(10.0f64).assert()), + ExpBin => (num.abs().log2().floor(), cast::<f64, T>(2.0f64).assert()), ExpNone => unreachable!() }; - (num / exp_base.powf(exp), cast::<T, i32>(exp).unwrap()) + (num / exp_base.powf(exp), cast::<T, i32>(exp).assert()) } } }; @@ -331,8 +331,8 @@ pub fn float_to_str_bytes_common<T:NumCast+Zero+One+PartialEq+PartialOrd+Float+ deccum = deccum / radix_gen; deccum = deccum.trunc(); - buf.push(char::from_digit(current_digit.to_int().unwrap() as uint, radix) - .unwrap() as u8); + buf.push(char::from_digit(current_digit.to_int().assert() as uint, radix) + .assert() as u8); // No more digits to calculate for the non-fractional part -> break if deccum == _0 { break; } @@ -388,7 +388,7 @@ pub fn float_to_str_bytes_common<T:NumCast+Zero+One+PartialEq+PartialOrd+Float+ let current_digit = deccum.trunc().abs(); buf.push(char::from_digit( - current_digit.to_int().unwrap() as uint, radix).unwrap() as u8); + current_digit.to_int().assert() as uint, radix).assert() as u8); // Decrease the deccumulator one fractional digit at a time deccum = deccum.fract(); @@ -400,13 +400,13 @@ pub fn float_to_str_bytes_common<T:NumCast+Zero+One+PartialEq+PartialOrd+Float+ // round the remaining ones. if limit_digits && dig == digit_count { let ascii2value = |chr: u8| { - char::to_digit(chr as char, radix).unwrap() + char::to_digit(chr as char, radix).assert() }; let value2ascii = |val: uint| { - char::from_digit(val, radix).unwrap() as u8 + char::from_digit(val, radix).assert() as u8 }; - let extra_digit = ascii2value(buf.pop().unwrap()); + let extra_digit = ascii2value(buf.pop().assert()); if extra_digit >= radix / 2 { // -> need to round let mut i: int = buf.len() as int - 1; loop { @@ -498,7 +498,7 @@ pub fn float_to_str_common<T:NumCast+Zero+One+PartialEq+PartialOrd+NumStrConv+Fl ) -> (String, bool) { let (bytes, special) = float_to_str_bytes_common(num, radix, negative_zero, sign, digits, exp_format, exp_capital); - (String::from_utf8(bytes).unwrap(), special) + (String::from_utf8(bytes).assert(), special) } // Some constants for from_str_bytes_common's input validation, @@ -574,7 +574,7 @@ pub fn from_str_bytes_common<T:NumCast+Zero+One+PartialEq+PartialOrd+Div<T,T>+ let _0: T = Zero::zero(); let _1: T = One::one(); - let radix_gen: T = cast(radix as int).unwrap(); + let radix_gen: T = cast(radix as int).assert(); let len = buf.len(); @@ -625,9 +625,9 @@ pub fn from_str_bytes_common<T:NumCast+Zero+One+PartialEq+PartialOrd+Div<T,T>+ // add/subtract current digit depending on sign if accum_positive { - accum = accum + cast(digit as int).unwrap(); + accum = accum + cast(digit as int).assert(); } else { - accum = accum - cast(digit as int).unwrap(); + accum = accum - cast(digit as int).assert(); } // Detect overflow by comparing to last value, except @@ -638,11 +638,11 @@ pub fn from_str_bytes_common<T:NumCast+Zero+One+PartialEq+PartialOrd+Div<T,T>+ // Detect overflow by reversing the shift-and-add process if accum_positive && - (last_accum != ((accum - cast(digit as int).unwrap())/radix_gen.clone())) { + (last_accum != ((accum - cast(digit as int).assert())/radix_gen.clone())) { return NumStrConv::inf(); } if !accum_positive && - (last_accum != ((accum + cast(digit as int).unwrap())/radix_gen.clone())) { + (last_accum != ((accum + cast(digit as int).assert())/radix_gen.clone())) { return NumStrConv::neg_inf(); } } @@ -678,7 +678,7 @@ pub fn from_str_bytes_common<T:NumCast+Zero+One+PartialEq+PartialOrd+Div<T,T>+ // Decrease power one order of magnitude power = power / radix_gen; - let digit_t: T = cast(digit).unwrap(); + let digit_t: T = cast(digit).assert(); // add/subtract current digit depending on sign if accum_positive { @@ -722,8 +722,8 @@ pub fn from_str_bytes_common<T:NumCast+Zero+One+PartialEq+PartialOrd+Div<T,T>+ let c = buf[i] as char; let base: T = match (c, exponent) { // c is never _ so don't need to handle specially - ('e', ExpDec) | ('E', ExpDec) => cast(10u).unwrap(), - ('p', ExpBin) | ('P', ExpBin) => cast(2u).unwrap(), + ('e', ExpDec) | ('E', ExpDec) => cast(10u).assert(), + ('p', ExpBin) | ('P', ExpBin) => cast(2u).assert(), _ => return None // char doesn't fit given exponent format }; @@ -736,9 +736,9 @@ pub fn from_str_bytes_common<T:NumCast+Zero+One+PartialEq+PartialOrd+Div<T,T>+ match exp { Some(exp_pow) => { multiplier = if exp_pow < 0 { - _1 / num::pow(base, (-exp_pow.to_int().unwrap()) as uint) + _1 / num::pow(base, (-exp_pow.to_int().assert()) as uint) } else { - num::pow(base, exp_pow.to_int().unwrap() as uint) + num::pow(base, exp_pow.to_int().assert() as uint) } } None => return None // invalid exponent -> invalid number diff --git a/src/libstd/num/uint_macros.rs b/src/libstd/num/uint_macros.rs index cfcaf0fa8daa3..605447777eb87 100644 --- a/src/libstd/num/uint_macros.rs +++ b/src/libstd/num/uint_macros.rs @@ -76,8 +76,8 @@ pub fn to_str_bytes<U>(n: $T, radix: uint, f: |v: &[u8]| -> U) -> U { let mut buf = [0u8, ..65]; let amt = { let mut wr = ::io::BufWriter::new(buf); - (write!(&mut wr, "{}", ::fmt::radix(n, radix as u8))).unwrap(); - wr.tell().unwrap() as uint + (write!(&mut wr, "{}", ::fmt::radix(n, radix as u8))).assert(); + wr.tell().assert() as uint }; f(buf.slice(0, amt)) } diff --git a/src/libstd/os.rs b/src/libstd/os.rs index 85445e4913935..0be34233d0468 100644 --- a/src/libstd/os.rs +++ b/src/libstd/os.rs @@ -218,7 +218,7 @@ fn with_env_lock<T>(f: || -> T) -> T { /// } /// ``` pub fn env() -> Vec<(String,String)> { - env_as_bytes().move_iter().map(|(k,v)| { + env_as_bytes().iter_owned().map(|(k,v)| { let k = String::from_utf8_lossy(k.as_slice()).into_string(); let v = String::from_utf8_lossy(v.as_slice()).into_string(); (k,v) @@ -294,7 +294,7 @@ pub fn env_as_bytes() -> Vec<(Vec<u8>,Vec<u8>)> { let mut pairs = Vec::new(); for p in input.iter() { let mut it = p.as_slice().splitn(1, |b| *b == b'='); - let key = Vec::from_slice(it.next().unwrap()); + let key = Vec::from_slice(it.next().assert()); let val = Vec::from_slice(it.next().unwrap_or(&[])); pairs.push((key, val)); } @@ -412,7 +412,7 @@ pub fn setenv<T: BytesContainer>(n: &str, v: T) { fn _setenv(n: &str, v: &[u8]) { let n: Vec<u16> = n.utf16_units().collect(); let n = n.append_one(0); - let v: Vec<u16> = ::str::from_utf8(v).unwrap().utf16_units().collect(); + let v: Vec<u16> = ::str::from_utf8(v).assert().utf16_units().collect(); let v = v.append_one(0); unsafe { @@ -536,7 +536,7 @@ pub fn split_paths<T: BytesContainer>(unparsed: T) -> Vec<Path> { /// let key = "PATH"; /// let mut paths = os::getenv_as_bytes(key).map_or(Vec::new(), os::split_paths); /// paths.push(Path::new("/home/xyz/bin")); -/// os::setenv(key, os::join_paths(paths.as_slice()).unwrap()); +/// os::setenv(key, os::join_paths(paths.as_slice()).assert()); /// ``` pub fn join_paths<T: BytesContainer>(paths: &[T]) -> Result<Vec<u8>, &'static str> { #[cfg(windows)] @@ -662,14 +662,14 @@ pub fn self_exe_name() -> Option<Path> { -1 as c_int]; let mut sz: libc::size_t = 0; let err = sysctl(mib.as_mut_ptr(), mib.len() as ::libc::c_uint, - ptr::mut_null(), &mut sz, ptr::mut_null(), + ptr::null_mut(), &mut sz, ptr::null_mut(), 0u as libc::size_t); if err != 0 { return None; } if sz == 0 { return None; } let mut v: Vec<u8> = Vec::with_capacity(sz as uint); let err = sysctl(mib.as_mut_ptr(), mib.len() as ::libc::c_uint, v.as_mut_ptr() as *mut c_void, &mut sz, - ptr::mut_null(), 0u as libc::size_t); + ptr::null_mut(), 0u as libc::size_t); if err != 0 { return None; } if sz == 0 { return None; } v.set_len(sz as uint - 1); // chop off trailing NUL @@ -694,7 +694,7 @@ pub fn self_exe_name() -> Option<Path> { unsafe { use libc::funcs::extra::_NSGetExecutablePath; let mut sz: u32 = 0; - _NSGetExecutablePath(ptr::mut_null(), &mut sz); + _NSGetExecutablePath(ptr::null_mut(), &mut sz); if sz == 0 { return None; } let mut v: Vec<u8> = Vec::with_capacity(sz as uint); let err = _NSGetExecutablePath(v.as_mut_ptr() as *mut i8, &mut sz); @@ -1044,7 +1044,7 @@ pub fn error_string(errnum: uint) -> String { unsafe { let res = FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, - ptr::mut_null(), + ptr::null_mut(), errnum as DWORD, langId, buf.as_mut_ptr(), @@ -1191,7 +1191,7 @@ fn real_args_as_bytes() -> Vec<Vec<u8>> { #[cfg(not(windows))] fn real_args() -> Vec<String> { - real_args_as_bytes().move_iter() + real_args_as_bytes().iter_owned() .map(|v| { String::from_utf8_lossy(v.as_slice()).into_string() }).collect() @@ -1228,7 +1228,7 @@ fn real_args() -> Vec<String> { #[cfg(windows)] fn real_args_as_bytes() -> Vec<Vec<u8>> { - real_args().move_iter().map(|s| s.into_bytes()).collect() + real_args().iter_owned().map(|s| s.into_bytes()).collect() } type LPCWSTR = *const u16; @@ -1528,7 +1528,7 @@ impl MemoryMap { pub fn new(min_len: uint, options: &[MapOption]) -> Result<MemoryMap, MapError> { use libc::types::os::arch::extra::{LPVOID, DWORD, SIZE_T, HANDLE}; - let mut lpAddress: LPVOID = ptr::mut_null(); + let mut lpAddress: LPVOID = ptr::null_mut(); let mut readable = false; let mut writable = false; let mut executable = false; @@ -1588,12 +1588,12 @@ impl MemoryMap { unsafe { let hFile = libc::get_osfhandle(fd) as HANDLE; let mapping = libc::CreateFileMappingW(hFile, - ptr::mut_null(), + ptr::null_mut(), flProtect, 0, 0, ptr::null()); - if mapping == ptr::mut_null() { + if mapping == ptr::null_mut() { return Err(ErrCreateFileMappingW(errno())); } if errno() as c_int == libc::ERROR_ALREADY_EXISTS { @@ -1974,7 +1974,7 @@ mod tests { fn test_self_exe_name() { let path = os::self_exe_name(); assert!(path.is_some()); - let path = path.unwrap(); + let path = path.assert(); debug!("{:?}", path.clone()); // Hard to test this function @@ -1985,7 +1985,7 @@ mod tests { fn test_self_exe_path() { let path = os::self_exe_path(); assert!(path.is_some()); - let path = path.unwrap(); + let path = path.assert(); debug!("{:?}", path.clone()); // Hard to test this function @@ -2158,7 +2158,7 @@ mod tests { } drop(chunk); - fs::unlink(&path).unwrap(); + fs::unlink(&path).assert(); } #[test] @@ -2200,7 +2200,7 @@ mod tests { #[cfg(unix)] fn join_paths_unix() { fn test_eq(input: &[&str], output: &str) -> bool { - join_paths(input).unwrap().as_slice() == output.as_bytes() + join_paths(input).assert().as_slice() == output.as_bytes() } assert!(test_eq([], "")); @@ -2215,7 +2215,7 @@ mod tests { #[cfg(windows)] fn join_paths_windows() { fn test_eq(input: &[&str], output: &str) -> bool { - join_paths(input).unwrap().as_slice() == output.as_bytes() + join_paths(input).assert().as_slice() == output.as_bytes() } assert!(test_eq([], "")); diff --git a/src/libstd/path/mod.rs b/src/libstd/path/mod.rs index d290a5f8c63c7..20ac9c6713f6f 100644 --- a/src/libstd/path/mod.rs +++ b/src/libstd/path/mod.rs @@ -628,7 +628,7 @@ pub trait GenericPath: Clone + GenericPathUnsafe { let t: Option<T> = None; if BytesContainer::is_str(t) { for p in paths.iter() { - self.push(p.container_as_str().unwrap()) + self.push(p.container_as_str().assert()) } } else { for p in paths.iter() { @@ -938,6 +938,6 @@ mod tests { let input = r"\foo\bar\baz"; let path: WindowsPath = WindowsPath::new(input.to_c_str()); - assert_eq!(path.as_str().unwrap(), input.as_slice()); + assert_eq!(path.as_str().assert(), input.as_slice()); } } diff --git a/src/libstd/path/posix.rs b/src/libstd/path/posix.rs index 9a4bc11f5c03a..112e8ef49e218 100644 --- a/src/libstd/path/posix.rs +++ b/src/libstd/path/posix.rs @@ -382,7 +382,7 @@ impl Path { let n = if is_abs { comps.len() } else { comps.len() - 1} + comps.iter().map(|v| v.len()).sum(); let mut v = Vec::with_capacity(n); - let mut it = comps.move_iter(); + let mut it = comps.iter_owned(); if !is_abs { match it.next() { None => (), @@ -441,7 +441,7 @@ fn normalize_helper<'a>(v: &'a [u8], is_abs: bool) -> Option<Vec<&'a [u8]>> { else if comp == b".." { if is_abs && comps.is_empty() { changed = true } else if comps.len() == n_up { comps.push(dot_dot_static); n_up += 1 } - else { comps.pop().unwrap(); changed = true } + else { comps.pop().assert(); changed = true } } else { comps.push(comp) } } if changed { @@ -527,9 +527,9 @@ mod tests { #[test] fn test_opt_paths() { assert!(Path::new_opt(b"foo/bar\0") == None); - t!(v: Path::new_opt(b"foo/bar").unwrap(), b"foo/bar"); + t!(v: Path::new_opt(b"foo/bar").assert(), b"foo/bar"); assert!(Path::new_opt("foo/bar\0") == None); - t!(s: Path::new_opt("foo/bar").unwrap(), "foo/bar"); + t!(s: Path::new_opt("foo/bar").assert(), "foo/bar"); } #[test] @@ -628,7 +628,7 @@ mod tests { (s: $path:expr, $op:ident, $exp:expr, opt) => ( { let path = Path::new($path); - let left = path.$op().map(|x| str::from_utf8(x).unwrap()); + let left = path.$op().map(|x| str::from_utf8(x).assert()); assert!(left == $exp); } ); @@ -978,19 +978,19 @@ mod tests { let filename = $filename; assert!(path.filename_str() == filename, "{}.filename_str(): Expected `{:?}`, found {:?}", - path.as_str().unwrap(), filename, path.filename_str()); + path.as_str().assert(), filename, path.filename_str()); let dirname = $dirname; assert!(path.dirname_str() == dirname, "`{}`.dirname_str(): Expected `{:?}`, found `{:?}`", - path.as_str().unwrap(), dirname, path.dirname_str()); + path.as_str().assert(), dirname, path.dirname_str()); let filestem = $filestem; assert!(path.filestem_str() == filestem, "`{}`.filestem_str(): Expected `{:?}`, found `{:?}`", - path.as_str().unwrap(), filestem, path.filestem_str()); + path.as_str().assert(), filestem, path.filestem_str()); let ext = $ext; assert!(path.extension_str() == ext, "`{}`.extension_str(): Expected `{:?}`, found `{:?}`", - path.as_str().unwrap(), ext, path.extension_str()); + path.as_str().assert(), ext, path.extension_str()); } ); (v: $path:expr, $filename:expr, $dirname:expr, $filestem:expr, $ext:expr) => ( @@ -1190,7 +1190,7 @@ mod tests { assert!(comps == exps, "components: Expected {:?}, found {:?}", comps, exps); let comps = path.components().rev().collect::<Vec<&[u8]>>(); - let exps = exps.move_iter().rev().collect::<Vec<&[u8]>>(); + let exps = exps.iter_owned().rev().collect::<Vec<&[u8]>>(); assert!(comps == exps, "rev_components: Expected {:?}, found {:?}", comps, exps); } diff --git a/src/libstd/path/windows.rs b/src/libstd/path/windows.rs index c3a217bf940f3..2c753985bd0ce 100644 --- a/src/libstd/path/windows.rs +++ b/src/libstd/path/windows.rs @@ -194,7 +194,7 @@ impl GenericPathUnsafe for Path { /// Fails if not valid UTF-8. #[inline] unsafe fn new_unchecked<T: BytesContainer>(path: T) -> Path { - let (prefix, path) = Path::normalize_(path.container_as_str().unwrap()); + let (prefix, path) = Path::normalize_(path.container_as_str().assert()); assert!(!path.is_empty()); let mut ret = Path{ repr: path, prefix: prefix, sepidx: None }; ret.update_sepidx(); @@ -207,7 +207,7 @@ impl GenericPathUnsafe for Path { /// /// Fails if not valid UTF-8. unsafe fn set_filename_unchecked<T: BytesContainer>(&mut self, filename: T) { - let filename = filename.container_as_str().unwrap(); + let filename = filename.container_as_str().assert(); match self.sepidx_or_prefix_len() { None if ".." == self.repr.as_slice() => { let mut s = String::with_capacity(3 + filename.len()); @@ -253,7 +253,7 @@ impl GenericPathUnsafe for Path { /// the new path is relative to. Otherwise, the new path will be treated /// as if it were absolute and will replace the receiver outright. unsafe fn push_unchecked<T: BytesContainer>(&mut self, path: T) { - let path = path.container_as_str().unwrap(); + let path = path.container_as_str().assert(); fn is_vol_abs(path: &str, prefix: Option<PathPrefix>) -> bool { // assume prefix is Some(DiskPrefix) let rest = path.slice_from(prefix_len(prefix)); @@ -376,7 +376,7 @@ impl GenericPath for Path { #[inline] fn dirname<'a>(&'a self) -> &'a [u8] { - self.dirname_str().unwrap().as_bytes() + self.dirname_str().assert().as_bytes() } /// See `GenericPath::dirname_str` for info. @@ -436,7 +436,7 @@ impl GenericPath for Path { } fn dir_path(&self) -> Path { - unsafe { GenericPathUnsafe::new_unchecked(self.dirname_str().unwrap()) } + unsafe { GenericPathUnsafe::new_unchecked(self.dirname_str().assert()) } } #[inline] @@ -516,8 +516,8 @@ impl GenericPath for Path { is_vol_relative(self) != is_vol_relative(other) { false } else { - let mut ita = self.str_components().map(|x|x.unwrap()); - let mut itb = other.str_components().map(|x|x.unwrap()); + let mut ita = self.str_components().map(|x|x.assert()); + let mut itb = other.str_components().map(|x|x.assert()); if "." == self.repr.as_slice() { return itb.next() != Some(".."); } @@ -564,8 +564,8 @@ impl GenericPath for Path { None } } else { - let mut ita = self.str_components().map(|x|x.unwrap()); - let mut itb = base.str_components().map(|x|x.unwrap()); + let mut ita = self.str_components().map(|x|x.assert()); + let mut itb = base.str_components().map(|x|x.assert()); let mut comps = vec![]; let a_verb = is_verbatim(self); @@ -673,7 +673,7 @@ impl Path { pub fn components<'a>(&'a self) -> Components<'a> { fn convert<'a>(x: Option<&'a str>) -> &'a [u8] { #![inline] - x.unwrap().as_bytes() + x.assert().as_bytes() } self.str_components().map(convert) } @@ -752,7 +752,7 @@ impl Path { None => None, Some(comps) => { if prefix.is_some() && comps.is_empty() { - match prefix.unwrap() { + match prefix.assert() { DiskPrefix => { let len = prefix_len(prefix) + is_abs as uint; let mut s = String::from_str(s.slice_to(len)); @@ -814,7 +814,7 @@ impl Path { Some(_) => s.push_str(prefix_), None => () } - let mut it = comps.move_iter(); + let mut it = comps.iter_owned(); if !is_abs { match it.next() { None => (), @@ -1082,7 +1082,7 @@ fn normalize_helper<'a>(s: &'a str, prefix: Option<PathPrefix>) -> (bool, Option }; if (is_abs || has_abs_prefix) && comps.is_empty() { changed = true } else if comps.len() == n_up { comps.push(".."); n_up += 1 } - else { comps.pop().unwrap(); changed = true } + else { comps.pop().assert(); changed = true } } else { comps.push(comp) } } if !changed && !prefix_is_verbatim(prefix) { @@ -1296,9 +1296,9 @@ mod tests { fn test_opt_paths() { assert!(Path::new_opt(b"foo\\bar\0") == None); assert!(Path::new_opt(b"foo\\bar\x80") == None); - t!(v: Path::new_opt(b"foo\\bar").unwrap(), b"foo\\bar"); + t!(v: Path::new_opt(b"foo\\bar").assert(), b"foo\\bar"); assert!(Path::new_opt("foo\\bar\0") == None); - t!(s: Path::new_opt("foo\\bar").unwrap(), "foo\\bar"); + t!(s: Path::new_opt("foo\\bar").assert(), "foo\\bar"); } #[test] @@ -1610,7 +1610,7 @@ mod tests { let left = $left; assert!(p.as_str() == Some(left), "`{}`.pop() failed; expected remainder `{}`, found `{}`", - pstr, left, p.as_str().unwrap()); + pstr, left, p.as_str().assert()); assert!(result == $right); } ); @@ -1751,7 +1751,7 @@ mod tests { let exp = $res; assert!(res.as_str() == Some(exp), "`{}`.{}(\"{}\"): Expected `{}`, found `{}`", - pstr, stringify!($op), arg, exp, res.as_str().unwrap()); + pstr, stringify!($op), arg, exp, res.as_str().assert()); } ) ) @@ -1878,19 +1878,19 @@ mod tests { let filename = $filename; assert!(path.filename_str() == filename, "`{}`.filename_str(): Expected `{:?}`, found `{:?}`", - path.as_str().unwrap(), filename, path.filename_str()); + path.as_str().assert(), filename, path.filename_str()); let dirname = $dirname; assert!(path.dirname_str() == dirname, "`{}`.dirname_str(): Expected `{:?}`, found `{:?}`", - path.as_str().unwrap(), dirname, path.dirname_str()); + path.as_str().assert(), dirname, path.dirname_str()); let filestem = $filestem; assert!(path.filestem_str() == filestem, "`{}`.filestem_str(): Expected `{:?}`, found `{:?}`", - path.as_str().unwrap(), filestem, path.filestem_str()); + path.as_str().assert(), filestem, path.filestem_str()); let ext = $ext; assert!(path.extension_str() == ext, "`{}`.extension_str(): Expected `{:?}`, found `{:?}`", - path.as_str().unwrap(), ext, path.extension_str()); + path.as_str().assert(), ext, path.extension_str()); } ); (v: $path:expr, $filename:expr, $dirname:expr, $filestem:expr, $ext:expr) => ( @@ -1944,16 +1944,16 @@ mod tests { let (abs, vol, cwd, rel) = ($abs, $vol, $cwd, $rel); let b = path.is_absolute(); assert!(b == abs, "Path '{}'.is_absolute(): expected {:?}, found {:?}", - path.as_str().unwrap(), abs, b); + path.as_str().assert(), abs, b); let b = is_vol_relative(&path); assert!(b == vol, "is_vol_relative('{}'): expected {:?}, found {:?}", - path.as_str().unwrap(), vol, b); + path.as_str().assert(), vol, b); let b = is_cwd_relative(&path); assert!(b == cwd, "is_cwd_relative('{}'): expected {:?}, found {:?}", - path.as_str().unwrap(), cwd, b); + path.as_str().assert(), cwd, b); let b = path.is_relative(); assert!(b == rel, "Path '{}'.is_relativf(): expected {:?}, found {:?}", - path.as_str().unwrap(), rel, b); + path.as_str().assert(), rel, b); } ) ) @@ -1986,7 +1986,7 @@ mod tests { let res = path.is_ancestor_of(&dest); assert!(res == exp, "`{}`.is_ancestor_of(`{}`): Expected {:?}, found {:?}", - path.as_str().unwrap(), dest.as_str().unwrap(), exp, res); + path.as_str().assert(), dest.as_str().assert(), exp, res); } ) ) @@ -2121,7 +2121,7 @@ mod tests { let exp = $exp; assert!(res.as_ref().and_then(|x| x.as_str()) == exp, "`{}`.path_relative_from(`{}`): Expected {:?}, got {:?}", - path.as_str().unwrap(), other.as_str().unwrap(), exp, + path.as_str().assert(), other.as_str().assert(), exp, res.as_ref().and_then(|x| x.as_str())); } ) @@ -2250,11 +2250,11 @@ mod tests { (s: $path:expr, $exp:expr) => ( { let path = Path::new($path); - let comps = path.str_components().map(|x|x.unwrap()) + let comps = path.str_components().map(|x|x.assert()) .collect::<Vec<&str>>(); let exp: &[&str] = $exp; assert_eq!(comps.as_slice(), exp); - let comps = path.str_components().rev().map(|x|x.unwrap()) + let comps = path.str_components().rev().map(|x|x.assert()) .collect::<Vec<&str>>(); let exp = exp.iter().rev().map(|&x|x).collect::<Vec<&str>>(); assert_eq!(comps, exp); diff --git a/src/libstd/rand/mod.rs b/src/libstd/rand/mod.rs index 40d8f80171c4e..64115667855b4 100644 --- a/src/libstd/rand/mod.rs +++ b/src/libstd/rand/mod.rs @@ -119,7 +119,7 @@ //! // where the car is. The game host will never open the door with the car. //! fn game_host_open<R: Rng>(car: uint, choice: uint, rng: &mut R) -> uint { //! let choices = free_doors(&[car, choice]); -//! rand::sample(rng, choices.move_iter(), 1)[0] +//! rand::sample(rng, choices.iter_owned(), 1)[0] //! } //! //! // Returns the door we switch to, given our current choice and @@ -578,7 +578,7 @@ mod bench { #[bench] fn rand_xorshift(b: &mut Bencher) { - let mut rng: XorShiftRng = OsRng::new().unwrap().gen(); + let mut rng: XorShiftRng = OsRng::new().assert().gen(); b.iter(|| { for _ in range(0, RAND_BENCH_N) { rng.gen::<uint>(); @@ -589,7 +589,7 @@ mod bench { #[bench] fn rand_isaac(b: &mut Bencher) { - let mut rng: IsaacRng = OsRng::new().unwrap().gen(); + let mut rng: IsaacRng = OsRng::new().assert().gen(); b.iter(|| { for _ in range(0, RAND_BENCH_N) { rng.gen::<uint>(); @@ -600,7 +600,7 @@ mod bench { #[bench] fn rand_isaac64(b: &mut Bencher) { - let mut rng: Isaac64Rng = OsRng::new().unwrap().gen(); + let mut rng: Isaac64Rng = OsRng::new().assert().gen(); b.iter(|| { for _ in range(0, RAND_BENCH_N) { rng.gen::<uint>(); @@ -611,7 +611,7 @@ mod bench { #[bench] fn rand_std(b: &mut Bencher) { - let mut rng = StdRng::new().unwrap(); + let mut rng = StdRng::new().assert(); b.iter(|| { for _ in range(0, RAND_BENCH_N) { rng.gen::<uint>(); diff --git a/src/libstd/rand/os.rs b/src/libstd/rand/os.rs index ffe8e539ffba1..dfcc7242f9004 100644 --- a/src/libstd/rand/os.rs +++ b/src/libstd/rand/os.rs @@ -271,7 +271,7 @@ mod test { #[test] fn test_os_rng() { - let mut r = OsRng::new().unwrap(); + let mut r = OsRng::new().assert(); r.next_u32(); r.next_u64(); @@ -293,7 +293,7 @@ mod test { // deschedule to attempt to interleave things as much // as possible (XXX: is this a good test?) - let mut r = OsRng::new().unwrap(); + let mut r = OsRng::new().assert(); task::deschedule(); let mut v = [0u8, .. 1000]; diff --git a/src/libstd/rand/reader.rs b/src/libstd/rand/reader.rs index fe5d8fc068c91..f84bd67aec0d0 100644 --- a/src/libstd/rand/reader.rs +++ b/src/libstd/rand/reader.rs @@ -48,17 +48,17 @@ impl<R: Reader> Rng for ReaderRng<R> { // platform just involves blitting the bytes into the memory // of the u32, similarly for BE on BE; avoiding byteswapping. if cfg!(target_endian="little") { - self.reader.read_le_u32().unwrap() + self.reader.read_le_u32().assert() } else { - self.reader.read_be_u32().unwrap() + self.reader.read_be_u32().assert() } } fn next_u64(&mut self) -> u64 { // see above for explanation. if cfg!(target_endian="little") { - self.reader.read_le_u64().unwrap() + self.reader.read_le_u64().assert() } else { - self.reader.read_be_u64().unwrap() + self.reader.read_be_u64().assert() } } fn fill_bytes(&mut self, v: &mut [u8]) { diff --git a/src/libstd/rt/backtrace.rs b/src/libstd/rt/backtrace.rs index b86937e421301..0f39f4ea69d7d 100644 --- a/src/libstd/rt/backtrace.rs +++ b/src/libstd/rt/backtrace.rs @@ -108,7 +108,7 @@ fn demangle(writer: &mut Writer, s: &str) -> IoResult<()> { while rest.char_at(0).is_digit() { rest = rest.slice_from(1); } - let i: uint = from_str(s.slice_to(s.len() - rest.len())).unwrap(); + let i: uint = from_str(s.slice_to(s.len() - rest.len())).assert(); s = rest.slice_from(i); rest = rest.slice_to(i); while rest.len() > 0 { @@ -485,7 +485,7 @@ mod imp { let bytes = path.as_vec(); if bytes.len() < LAST_FILENAME.len() { let i = bytes.iter(); - for (slot, val) in LAST_FILENAME.mut_iter().zip(i) { + for (slot, val) in LAST_FILENAME.iter_mut().zip(i) { *slot = *val as libc::c_char; } LAST_FILENAME.as_ptr() @@ -496,7 +496,7 @@ mod imp { None => ptr::null(), }; STATE = backtrace_create_state(filename, 0, error_cb, - ptr::mut_null()); + ptr::null_mut()); return STATE } @@ -1002,8 +1002,8 @@ mod test { macro_rules! t( ($a:expr, $b:expr) => ({ let mut m = MemWriter::new(); - super::demangle(&mut m, $a).unwrap(); - assert_eq!(String::from_utf8(m.unwrap()).unwrap(), $b.to_string()); + super::demangle(&mut m, $a).assert(); + assert_eq!(String::from_utf8(m.unwrap()).assert(), $b.to_string()); }) ) #[test] diff --git a/src/libstd/sync/task_pool.rs b/src/libstd/sync/task_pool.rs index da0c3daefe705..23ba582ec0aa7 100644 --- a/src/libstd/sync/task_pool.rs +++ b/src/libstd/sync/task_pool.rs @@ -31,7 +31,7 @@ pub struct TaskPool<T> { #[unsafe_destructor] impl<T> Drop for TaskPool<T> { fn drop(&mut self) { - for channel in self.channels.mut_iter() { + for channel in self.channels.iter_mut() { channel.send(Quit); } } diff --git a/src/libstd/task.rs b/src/libstd/task.rs index 19ad81a04834d..977f192986ede 100644 --- a/src/libstd/task.rs +++ b/src/libstd/task.rs @@ -413,28 +413,28 @@ mod test { fn test_unnamed_task() { try(proc() { assert!(name().is_none()); - }).map_err(|_| ()).unwrap(); + }).map_err(|_| ()).assert(); } #[test] fn test_owned_named_task() { TaskBuilder::new().named("ada lovelace".to_string()).try(proc() { - assert!(name().unwrap() == "ada lovelace".to_string()); - }).map_err(|_| ()).unwrap(); + assert!(name().assert() == "ada lovelace".to_string()); + }).map_err(|_| ()).assert(); } #[test] fn test_static_named_task() { TaskBuilder::new().named("ada lovelace").try(proc() { - assert!(name().unwrap() == "ada lovelace".to_string()); - }).map_err(|_| ()).unwrap(); + assert!(name().assert() == "ada lovelace".to_string()); + }).map_err(|_| ()).assert(); } #[test] fn test_send_named_task() { TaskBuilder::new().named("ada lovelace".into_maybe_owned()).try(proc() { - assert!(name().unwrap() == "ada lovelace".to_string()); - }).map_err(|_| ()).unwrap(); + assert!(name().assert() == "ada lovelace".to_string()); + }).map_err(|_| ()).assert(); } #[test] @@ -593,7 +593,7 @@ mod test { Err(e) => { type T = &'static str; assert!(e.is::<T>()); - assert_eq!(*e.downcast::<T>().unwrap(), "static string"); + assert_eq!(*e.downcast::<T>().assert(), "static string"); } Ok(()) => fail!() } @@ -607,7 +607,7 @@ mod test { Err(e) => { type T = String; assert!(e.is::<T>()); - assert_eq!(*e.downcast::<T>().unwrap(), "owned string".to_string()); + assert_eq!(*e.downcast::<T>().assert(), "owned string".to_string()); } Ok(()) => fail!() } @@ -621,9 +621,9 @@ mod test { Err(e) => { type T = Box<Any + Send>; assert!(e.is::<T>()); - let any = e.downcast::<T>().unwrap(); + let any = e.downcast::<T>().assert(); assert!(any.is::<u16>()); - assert_eq!(*any.downcast::<u16>().unwrap(), 413u16); + assert_eq!(*any.downcast::<u16>().assert(), 413u16); } Ok(()) => fail!() } @@ -653,7 +653,7 @@ mod test { }); assert!(r.is_ok()); - let output = reader.read_to_string().unwrap(); + let output = reader.read_to_string().assert(); assert_eq!(output, "Hello, world!".to_string()); } diff --git a/src/libsync/comm/mod.rs b/src/libsync/comm/mod.rs index 45016b97566ce..e59f44e6a61b9 100644 --- a/src/libsync/comm/mod.rs +++ b/src/libsync/comm/mod.rs @@ -130,7 +130,7 @@ //! use std::io::timer::Timer; //! //! let (tx, rx) = channel::<int>(); -//! let mut timer = Timer::new().unwrap(); +//! let mut timer = Timer::new().assert(); //! let timeout = timer.oneshot(10000); //! //! loop { @@ -152,7 +152,7 @@ //! use std::io::timer::Timer; //! //! let (tx, rx) = channel::<int>(); -//! let mut timer = Timer::new().unwrap(); +//! let mut timer = Timer::new().assert(); //! //! loop { //! let timeout = timer.oneshot(5000); @@ -445,7 +445,7 @@ enum Flavor<T> { #[doc(hidden)] trait UnsafeFlavor<T> { fn inner_unsafe<'a>(&'a self) -> &'a UnsafeCell<Flavor<T>>; - unsafe fn mut_inner<'a>(&'a self) -> &'a mut Flavor<T> { + unsafe fn inner_mut<'a>(&'a self) -> &'a mut Flavor<T> { &mut *self.inner_unsafe().get() } unsafe fn inner<'a>(&'a self) -> &'a Flavor<T> { @@ -633,7 +633,7 @@ impl<T: Send> Sender<T> { // This send cannot fail because the task is // asleep (we're looking at it), so the receiver // can't go away. - (*a.get()).send(t).ok().unwrap(); + (*a.get()).send(t).ok().assert(); task.wake().map(|t| t.reawaken()); (a, Ok(())) } @@ -648,7 +648,7 @@ impl<T: Send> Sender<T> { unsafe { let tmp = Sender::new(Stream(new_inner)); - mem::swap(self.mut_inner(), tmp.mut_inner()); + mem::swap(self.inner_mut(), tmp.inner_mut()); } return ret; } @@ -689,7 +689,7 @@ impl<T: Send> Clone for Sender<T> { (*packet.get()).inherit_blocker(sleeper); let tmp = Sender::new(Shared(packet.clone())); - mem::swap(self.mut_inner(), tmp.mut_inner()); + mem::swap(self.inner_mut(), tmp.inner_mut()); } Sender::new(Shared(packet)) } @@ -698,7 +698,7 @@ impl<T: Send> Clone for Sender<T> { #[unsafe_destructor] impl<T: Send> Drop for Sender<T> { fn drop(&mut self) { - match *unsafe { self.mut_inner() } { + match *unsafe { self.inner_mut() } { Oneshot(ref mut p) => unsafe { (*p.get()).drop_chan(); }, Stream(ref mut p) => unsafe { (*p.get()).drop_chan(); }, Shared(ref mut p) => unsafe { (*p.get()).drop_chan(); }, @@ -889,8 +889,8 @@ impl<T: Send> Receiver<T> { } }; unsafe { - mem::swap(self.mut_inner(), - new_port.mut_inner()); + mem::swap(self.inner_mut(), + new_port.inner_mut()); } } } @@ -937,7 +937,7 @@ impl<T: Send> Receiver<T> { Sync(ref p) => return unsafe { (*p.get()).recv() } }; unsafe { - mem::swap(self.mut_inner(), new_port.mut_inner()); + mem::swap(self.inner_mut(), new_port.inner_mut()); } } } @@ -974,8 +974,8 @@ impl<T: Send> select::Packet for Receiver<T> { } }; unsafe { - mem::swap(self.mut_inner(), - new_port.mut_inner()); + mem::swap(self.inner_mut(), + new_port.inner_mut()); } } } @@ -1006,8 +1006,8 @@ impl<T: Send> select::Packet for Receiver<T> { }; task = t; unsafe { - mem::swap(self.mut_inner(), - new_port.mut_inner()); + mem::swap(self.inner_mut(), + new_port.inner_mut()); } } } @@ -1030,8 +1030,8 @@ impl<T: Send> select::Packet for Receiver<T> { let new_port = match result { Ok(b) => return b, Err(p) => p }; was_upgrade = true; unsafe { - mem::swap(self.mut_inner(), - new_port.mut_inner()); + mem::swap(self.inner_mut(), + new_port.inner_mut()); } } } @@ -1045,7 +1045,7 @@ impl<'a, T: Send> Iterator<T> for Messages<'a, T> { #[unsafe_destructor] impl<T: Send> Drop for Receiver<T> { fn drop(&mut self) { - match *unsafe { self.mut_inner() } { + match *unsafe { self.inner_mut() } { Oneshot(ref mut p) => unsafe { (*p.get()).drop_port(); }, Stream(ref mut p) => unsafe { (*p.get()).drop_port(); }, Shared(ref mut p) => unsafe { (*p.get()).drop_port(); }, @@ -1064,7 +1064,7 @@ mod test { pub fn stress_factor() -> uint { match os::getenv("RUST_TEST_STRESS") { - Some(val) => from_str::<uint>(val.as_slice()).unwrap(), + Some(val) => from_str::<uint>(val.as_slice()).assert(), None => 1, } } @@ -1597,7 +1597,7 @@ mod sync_tests { pub fn stress_factor() -> uint { match os::getenv("RUST_TEST_STRESS") { - Some(val) => from_str::<uint>(val.as_slice()).unwrap(), + Some(val) => from_str::<uint>(val.as_slice()).assert(), None => 1, } } @@ -2110,10 +2110,10 @@ mod sync_tests { spawn(proc() { rx1.recv(); - tx2.try_send(()).unwrap(); + tx2.try_send(()).assert(); }); - tx1.try_send(()).unwrap(); + tx1.try_send(()).assert(); rx2.recv(); } diff --git a/src/libsync/comm/oneshot.rs b/src/libsync/comm/oneshot.rs index 188bea83ac80f..5e60775d95259 100644 --- a/src/libsync/comm/oneshot.rs +++ b/src/libsync/comm/oneshot.rs @@ -107,7 +107,7 @@ impl<T: Send> Packet<T> { // Couldn't send the data, the port hung up first. Return the data // back up the stack. DISCONNECTED => { - Err(self.data.take_unwrap()) + Err(self.data.take().assert()) } // Not possible, these are one-use channels @@ -244,7 +244,7 @@ impl<T: Send> Packet<T> { // There's data on the channel, so make sure we destroy it promptly. // This is why not using an arc is a little difficult (need the box // to stay valid while we take the data). - DATA => { self.data.take_unwrap(); } + DATA => { self.data.take().assert(); } // We're the only ones that can block on this port _ => unreachable!() diff --git a/src/libsync/comm/select.rs b/src/libsync/comm/select.rs index 737a4bfe29916..31043b88c157a 100644 --- a/src/libsync/comm/select.rs +++ b/src/libsync/comm/select.rs @@ -184,7 +184,7 @@ impl Select { let task: Box<Task> = Local::take(); task.deschedule(amt, |task| { // Prepare for the block - let (i, handle) = iter.next().unwrap(); + let (i, handle) = iter.next().assert(); match (*handle).packet.start_selection(task) { Ok(()) => Ok(()), Err(task) => { diff --git a/src/libsync/comm/sync.rs b/src/libsync/comm/sync.rs index aef02f654c102..9aead6d9c6008 100644 --- a/src/libsync/comm/sync.rs +++ b/src/libsync/comm/sync.rs @@ -348,7 +348,7 @@ impl<T: Send> Packet<T> { let waiter = match mem::replace(&mut state.blocker, NoneBlocked) { NoneBlocked => None, BlockedSender(task) => { - *state.canceled.take_unwrap() = true; + *state.canceled.take().assert() = true; Some(task) } BlockedReceiver(..) => unreachable!(), @@ -435,7 +435,7 @@ impl<T> Buffer<T> { let start = self.start; self.size -= 1; self.start = (self.start + 1) % self.buf.len(); - self.buf.get_mut(start).take_unwrap() + self.buf.get_mut(start).take().assert() } fn size(&self) -> uint { self.size } @@ -482,7 +482,7 @@ impl Queue { } unsafe { (*node).next = 0 as *mut Node; - Some((*node).task.take_unwrap()) + Some((*node).task.take().assert()) } } } diff --git a/src/libsync/deque.rs b/src/libsync/deque.rs index e70a730dc3a13..1417bde35badc 100644 --- a/src/libsync/deque.rs +++ b/src/libsync/deque.rs @@ -161,7 +161,7 @@ impl<T: Send> BufferPool<T> { unsafe { let mut pool = self.pool.lock(); match pool.iter().position(|x| x.size() >= (1 << bits)) { - Some(i) => pool.remove(i).unwrap(), + Some(i) => pool.remove(i).assert(), None => box Buffer::new(bits) } } @@ -513,7 +513,7 @@ mod tests { } } - for thread in threads.move_iter() { + for thread in threads.iter_owned() { thread.join(); } } @@ -536,7 +536,7 @@ mod tests { }) }).collect::<Vec<Thread<()>>>(); - for thread in threads.move_iter() { + for thread in threads.iter_owned() { thread.join(); } } @@ -592,7 +592,7 @@ mod tests { DONE.store(true, SeqCst); } - for thread in threads.move_iter() { + for thread in threads.iter_owned() { thread.join(); } @@ -657,7 +657,7 @@ mod tests { unsafe { DONE.store(true, SeqCst); } - for thread in threads.move_iter() { + for thread in threads.iter_owned() { thread.join(); } } diff --git a/src/libsync/lock.rs b/src/libsync/lock.rs index b07d06ca18e54..e9529f5a8f986 100644 --- a/src/libsync/lock.rs +++ b/src/libsync/lock.rs @@ -636,8 +636,8 @@ mod tests { } // Wait for children to pass their asserts - for r in children.mut_iter() { - assert!(r.get_ref().is_ok()); + for r in children.iter_mut() { + assert!(r.as_ref().assert().is_ok()); } // Wait for writer to finish @@ -722,12 +722,12 @@ mod tests { assert_eq!(*lock, 42); *lock = 31337; // send to other readers - for &(ref mut rc, _) in reader_convos.mut_iter() { + for &(ref mut rc, _) in reader_convos.iter_mut() { rc.send(()) } let lock = lock.downgrade(); // complete handshake with other readers - for &(_, ref mut rp) in reader_convos.mut_iter() { + for &(_, ref mut rp) in reader_convos.iter_mut() { rp.recv() } tx1.send(()); // tell writer to try again diff --git a/src/libsync/mpmc_bounded_queue.rs b/src/libsync/mpmc_bounded_queue.rs index 949ef3bc34c25..fa29bb6088ae1 100644 --- a/src/libsync/mpmc_bounded_queue.rs +++ b/src/libsync/mpmc_bounded_queue.rs @@ -210,7 +210,7 @@ mod tests { }); } - for rx in completion_rxs.mut_iter() { + for rx in completion_rxs.iter_mut() { assert_eq!(nmsgs, rx.recv()); } for _ in range(0, nthreads) { diff --git a/src/libsync/mpsc_queue.rs b/src/libsync/mpsc_queue.rs index 012574808f3c6..9fe60265eef7c 100644 --- a/src/libsync/mpsc_queue.rs +++ b/src/libsync/mpsc_queue.rs @@ -122,7 +122,7 @@ impl<T: Send> Queue<T> { *self.tail.get() = next; assert!((*tail).value.is_none()); assert!((*next).value.is_some()); - let ret = (*next).value.take_unwrap(); + let ret = (*next).value.take().assert(); let _: Box<Node<T>> = mem::transmute(tail); return Data(ret); } diff --git a/src/libsync/raw.rs b/src/libsync/raw.rs index c42d567fc18ce..4c971611cb703 100644 --- a/src/libsync/raw.rs +++ b/src/libsync/raw.rs @@ -143,7 +143,7 @@ impl<Q: Send> Sem<Q> { /* for _ in range(0u, 1000) { task::deschedule(); } */ // Need to wait outside the exclusive. if waiter_nobe.is_some() { - let _ = waiter_nobe.unwrap().recv(); + let _ = waiter_nobe.assert().recv(); } } } @@ -259,7 +259,7 @@ impl<'a> Condvar<'a> { // signaller already sent -- I mean 'unconditionally' in contrast // with acquire().) (|| { - let _ = wait_end.take_unwrap().recv(); + let _ = wait_end.take().assert().recv(); }).finally(|| { // Reacquire the condvar. match self.order { @@ -318,7 +318,7 @@ impl<'a> Condvar<'a> { condvar_id, "cond.signal_on()", || { - queue.take_unwrap().broadcast() + queue.take().assert().broadcast() }) } } @@ -804,14 +804,14 @@ mod tests { } // wait until all children get in the mutex - for rx in rxs.mut_iter() { rx.recv(); } + for rx in rxs.iter_mut() { rx.recv(); } { let lock = m.lock(); let num_woken = lock.cond.broadcast(); assert_eq!(num_woken, num_waiters); } // wait until all children wake up - for rx in rxs.mut_iter() { rx.recv(); } + for rx in rxs.iter_mut() { rx.recv(); } } #[test] fn test_mutex_cond_broadcast() { @@ -1058,13 +1058,13 @@ mod tests { } // wait until all children get in the mutex - for rx in rxs.mut_iter() { let _ = rx.recv(); } + for rx in rxs.iter_mut() { let _ = rx.recv(); } lock_cond(&x, |cond| { let num_woken = cond.broadcast(); assert_eq!(num_woken, num_waiters); }); // wait until all children wake up - for rx in rxs.mut_iter() { let _ = rx.recv(); } + for rx in rxs.iter_mut() { let _ = rx.recv(); } } #[test] fn test_rwlock_cond_broadcast() { diff --git a/src/libsync/spsc_queue.rs b/src/libsync/spsc_queue.rs index 578e518cb8ff5..cfe118d6f6e04 100644 --- a/src/libsync/spsc_queue.rs +++ b/src/libsync/spsc_queue.rs @@ -321,7 +321,7 @@ mod test { let q = unsafe { Queue::new(0) }; q.push(vec![1i]); q.push(vec![2]); - let peeked = q.peek().unwrap(); + let peeked = q.peek().assert(); assert_eq!(*peeked, vec![1]); assert_eq!(q.pop(), Some(vec![1])); diff --git a/src/libsyntax/abi.rs b/src/libsyntax/abi.rs index c50a5661973f5..89d16d2cf1efc 100644 --- a/src/libsyntax/abi.rs +++ b/src/libsyntax/abi.rs @@ -161,13 +161,13 @@ impl fmt::Show for Os { #[test] fn lookup_Rust() { let abi = lookup("Rust"); - assert!(abi.is_some() && abi.unwrap().data().name == "Rust"); + assert!(abi.is_some() && abi.assert().data().name == "Rust"); } #[test] fn lookup_cdecl() { let abi = lookup("cdecl"); - assert!(abi.is_some() && abi.unwrap().data().name == "cdecl"); + assert!(abi.is_some() && abi.assert().data().name == "cdecl"); } #[test] diff --git a/src/libsyntax/ast_map/mod.rs b/src/libsyntax/ast_map/mod.rs index 881ee4fd8d13e..a3a7aa6d7ee43 100644 --- a/src/libsyntax/ast_map/mod.rs +++ b/src/libsyntax/ast_map/mod.rs @@ -352,7 +352,7 @@ impl Map { fn path_to_str_with_ident(&self, id: NodeId, i: Ident) -> String { self.with_path(id, |path| { - path_to_string(path.chain(Some(PathName(i.name)).move_iter())) + path_to_string(path.chain(Some(PathName(i.name)).iter_owned())) }) } @@ -419,7 +419,7 @@ impl Map { /// any other such items it can find in the map. pub fn nodes_matching_suffix<'a, S:Str>(&'a self, parts: &'a [S]) -> NodesMatchingSuffix<'a,S> { NodesMatchingSuffix { map: self, - item_name: parts.last().unwrap(), + item_name: parts.last().assert(), where: parts.slice_to(parts.len() - 1), idx: 0 } } diff --git a/src/libsyntax/attr.rs b/src/libsyntax/attr.rs index 21252619d11ae..4e2ec8c828ee2 100644 --- a/src/libsyntax/attr.rs +++ b/src/libsyntax/attr.rs @@ -125,7 +125,7 @@ impl AttributeMethods for Attribute { /// non-sugared doc attributes.) fn desugar_doc(&self) -> Attribute { if self.node.is_sugared_doc { - let comment = self.value_str().unwrap(); + let comment = self.value_str().assert(); let meta = mk_name_value_item_str( InternedString::new("doc"), token::intern_and_get_ident(strip_doc_comment_decoration( @@ -254,7 +254,7 @@ pub fn sort_meta_items(items: &[Gc<MetaItem>]) -> Vec<Gc<MetaItem>> { v.sort_by(|&(ref a, _), &(ref b, _)| a.cmp(b)); // There doesn't seem to be a more optimal way to do this - v.move_iter().map(|(_, m)| { + v.iter_owned().map(|(_, m)| { match m.node { MetaList(ref n, ref mis) => { box(GC) Spanned { diff --git a/src/libsyntax/diagnostics/plugin.rs b/src/libsyntax/diagnostics/plugin.rs index 209296989fa0d..d92103115e75b 100644 --- a/src/libsyntax/diagnostics/plugin.rs +++ b/src/libsyntax/diagnostics/plugin.rs @@ -98,7 +98,7 @@ pub fn expand_register_diagnostic(ecx: &mut ExtCtxt, span: Span, let sym = Ident::new(token::gensym(( "__register_diagnostic_".to_string() + token::get_ident(*code).get() ).as_slice())); - MacItem::new(quote_item!(ecx, mod $sym {}).unwrap()) + MacItem::new(quote_item!(ecx, mod $sym {}).assert()) } pub fn expand_build_diagnostic_array(ecx: &mut ExtCtxt, span: Span, @@ -129,5 +129,5 @@ pub fn expand_build_diagnostic_array(ecx: &mut ExtCtxt, span: Span, }); MacItem::new(quote_item!(ecx, pub static $name: [(&'static str, &'static str), ..$count] = $expr; - ).unwrap()) + ).assert()) } diff --git a/src/libsyntax/ext/asm.rs b/src/libsyntax/ext/asm.rs index 13738e658e9f9..5e97d7c874c8a 100644 --- a/src/libsyntax/ext/asm.rs +++ b/src/libsyntax/ext/asm.rs @@ -213,7 +213,7 @@ pub fn expand_asm(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) id: ast::DUMMY_NODE_ID, node: ast::ExprInlineAsm(ast::InlineAsm { asm: token::intern_and_get_ident(asm.get()), - asm_str_style: asm_str_style.unwrap(), + asm_str_style: asm_str_style.assert(), clobbers: token::intern_and_get_ident(cons.as_slice()), inputs: inputs, outputs: outputs, diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs index 01d3920a25463..8cb3bc5f178cc 100644 --- a/src/libsyntax/ext/base.rs +++ b/src/libsyntax/ext/base.rs @@ -483,7 +483,7 @@ impl<'a> ExtCtxt<'a> { pub fn print_backtrace(&self) { } pub fn backtrace(&self) -> Option<Gc<ExpnInfo>> { self.backtrace } pub fn mod_push(&mut self, i: ast::Ident) { self.mod_path.push(i); } - pub fn mod_pop(&mut self) { self.mod_path.pop().unwrap(); } + pub fn mod_pop(&mut self) { self.mod_path.pop().assert(); } pub fn mod_path(&self) -> Vec<ast::Ident> { let mut v = Vec::new(); v.push(token::str_to_ident(self.ecfg.crate_name.as_slice())); @@ -686,7 +686,7 @@ impl SyntaxEnv { } fn find_escape_frame<'a>(&'a mut self) -> &'a mut MapChainFrame { - for (i, frame) in self.chain.mut_iter().enumerate().rev() { + for (i, frame) in self.chain.iter_mut().enumerate().rev() { if !frame.info.macros_escape || i == 0 { return frame } diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs index 0e687c02c1daf..703f912110f98 100644 --- a/src/libsyntax/ext/build.rs +++ b/src/libsyntax/ext/build.rs @@ -312,8 +312,8 @@ impl<'a> AstBuilder for ExtCtxt<'a> { lifetimes: Vec<ast::Lifetime>, types: Vec<P<ast::Ty>> ) -> ast::Path { - let last_identifier = idents.pop().unwrap(); - let mut segments: Vec<ast::PathSegment> = idents.move_iter() + let last_identifier = idents.pop().assert(); + let mut segments: Vec<ast::PathSegment> = idents.iter_owned() .map(|ident| { ast::PathSegment { identifier: ident, @@ -985,7 +985,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> { } fn variant(&self, span: Span, name: Ident, tys: Vec<P<ast::Ty>> ) -> ast::Variant { - let args = tys.move_iter().map(|ty| { + let args = tys.iter_owned().map(|ty| { ast::VariantArg { ty: ty, id: ast::DUMMY_NODE_ID } }).collect(); @@ -1100,7 +1100,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> { } fn view_use_simple(&self, sp: Span, vis: ast::Visibility, path: ast::Path) -> ast::ViewItem { - let last = path.segments.last().unwrap().identifier; + let last = path.segments.last().assert().identifier; self.view_use_simple_(sp, vis, last, path) } diff --git a/src/libsyntax/ext/concat.rs b/src/libsyntax/ext/concat.rs index dd1153bf66667..c20cc2b3be21d 100644 --- a/src/libsyntax/ext/concat.rs +++ b/src/libsyntax/ext/concat.rs @@ -25,7 +25,7 @@ pub fn expand_syntax_ext(cx: &mut base::ExtCtxt, None => return base::DummyResult::expr(sp) }; let mut accumulator = String::new(); - for e in es.move_iter() { + for e in es.iter_owned() { match e.node { ast::ExprLit(lit) => { match lit.node { diff --git a/src/libsyntax/ext/deriving/cmp/totaleq.rs b/src/libsyntax/ext/deriving/cmp/totaleq.rs index 42365936c9d4f..c548e456502ca 100644 --- a/src/libsyntax/ext/deriving/cmp/totaleq.rs +++ b/src/libsyntax/ext/deriving/cmp/totaleq.rs @@ -28,7 +28,7 @@ pub fn expand_deriving_totaleq(cx: &mut ExtCtxt, cs_same_method(|cx, span, exprs| { // create `a.<method>(); b.<method>(); c.<method>(); ...` // (where method is `assert_receiver_is_total_eq`) - let stmts = exprs.move_iter().map(|e| cx.stmt_expr(e)).collect(); + let stmts = exprs.iter_owned().map(|e| cx.stmt_expr(e)).collect(); let block = cx.block(span, stmts, None); cx.expr_block(block) }, diff --git a/src/libsyntax/ext/deriving/generic/mod.rs b/src/libsyntax/ext/deriving/generic/mod.rs index 5842ca4a0d54d..d53db059456d0 100644 --- a/src/libsyntax/ext/deriving/generic/mod.rs +++ b/src/libsyntax/ext/deriving/generic/mod.rs @@ -650,10 +650,10 @@ impl<'a> MethodDef<'a> { _ => Some(ast::Arg::new_self(trait_.span, ast::MutImmutable, special_idents::self_)) }; let args = { - let args = arg_types.move_iter().map(|(name, ty)| { + let args = arg_types.iter_owned().map(|(name, ty)| { cx.arg(trait_.span, name, ty) }); - self_arg.move_iter().chain(args).collect() + self_arg.iter_owned().chain(args).collect() }; let ret_type = self.get_ret_ty(cx, trait_, generics, type_ident); @@ -1253,7 +1253,7 @@ impl<'a> TraitDef<'a> { let pattern = if struct_type == Record { let field_pats = subpats.iter().zip(ident_expr.iter()).map(|(&pat, &(_, id, _))| { // id is guaranteed to be Some - ast::FieldPat { ident: id.unwrap(), pat: pat } + ast::FieldPat { ident: id.assert(), pat: pat } }).collect(); cx.pat_struct(self.span, matching_path, field_pats) } else { diff --git a/src/libsyntax/ext/deriving/show.rs b/src/libsyntax/ext/deriving/show.rs index e0dfbb232f554..c98f7d10fc284 100644 --- a/src/libsyntax/ext/deriving/show.rs +++ b/src/libsyntax/ext/deriving/show.rs @@ -103,7 +103,7 @@ fn show_substructure(cx: &mut ExtCtxt, span: Span, for (i, field) in fields.iter().enumerate() { if i != 0 { format_string.push_str(","); } - let name = token::get_ident(field.name.unwrap()); + let name = token::get_ident(field.name.assert()); format_string.push_str(" "); format_string.push_str(name.get()); format_string.push_str(": {}"); diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs index 808532d55bb2e..a3eef9bce4bc4 100644 --- a/src/libsyntax/ext/expand.rs +++ b/src/libsyntax/ext/expand.rs @@ -252,8 +252,8 @@ fn expand_item(it: Gc<ast::Item>, fld: &mut MacroExpander) let mut items: SmallVector<Gc<ast::Item>> = SmallVector::zero(); dec_fn(fld.cx, attr.span, attr.node.value, it, |item| items.push(item)); - decorator_items.extend(items.move_iter() - .flat_map(|item| expand_item(item, fld).move_iter())); + decorator_items.extend(items.iter_owned() + .flat_map(|item| expand_item(item, fld).iter_owned())); fld.cx.bt_pop(); } @@ -463,9 +463,9 @@ fn expand_item_mac(it: Gc<ast::Item>, fld: &mut MacroExpander) None => { match expanded.make_items() { Some(items) => { - items.move_iter() + items.iter_owned() .map(|i| mark_item(i, fm)) - .flat_map(|i| fld.fold_item(i).move_iter()) + .flat_map(|i| fld.fold_item(i).iter_owned()) .collect() } None => { @@ -505,11 +505,11 @@ fn expand_stmt(s: &Stmt, fld: &mut MacroExpander) -> SmallVector<Gc<Stmt>> { // Keep going, outside-in. let fully_expanded = fld.fold_stmt(&*expanded_stmt); fld.cx.bt_pop(); - let fully_expanded: SmallVector<Gc<Stmt>> = fully_expanded.move_iter() + let fully_expanded: SmallVector<Gc<Stmt>> = fully_expanded.iter_owned() .map(|s| box(GC) Spanned { span: s.span, node: s.node.clone() }) .collect(); - fully_expanded.move_iter().map(|s| { + fully_expanded.iter_owned().map(|s| { match s.node { StmtExpr(e, stmt_id) if semi => { box(GC) Spanned { @@ -681,7 +681,7 @@ fn expand_block_elts(b: &Block, fld: &mut MacroExpander) -> P<Block> { rename_fld.fold_stmt(&**x).expect_one("rename_fold didn't return one value") }; // expand macros in the statement - fld.fold_stmt(&*renamed_stmt).move_iter() + fld.fold_stmt(&*renamed_stmt).iter_owned() }).collect(); let new_expr = b.expr.map(|x| { let expr = { @@ -864,7 +864,7 @@ fn expand_method(m: &ast::Method, fld: &mut MacroExpander) -> SmallVector<Gc<ast expand_mac_invoc(mac, &m.span, |r|{r.make_methods()}, |meths,mark|{ - meths.move_iter().map(|m|{mark_method(m,mark)}) + meths.iter_owned().map(|m|{mark_method(m,mark)}) .collect()}, fld); @@ -874,7 +874,7 @@ fn expand_method(m: &ast::Method, fld: &mut MacroExpander) -> SmallVector<Gc<ast }; // expand again if necessary - new_methods.move_iter().flat_map(|m| fld.fold_method(m).move_iter()).collect() + new_methods.iter_owned().flat_map(|m| fld.fold_method(m).iter_owned()).collect() } } } @@ -971,11 +971,11 @@ pub fn expand_crate(parse_sess: &parse::ParseSess, cx: &mut cx, }; - for ExportedMacros { crate_name, macros } in imported_macros.move_iter() { + for ExportedMacros { crate_name, macros } in imported_macros.iter_owned() { let name = format!("<{} macros>", token::get_ident(crate_name)) .into_string(); - for source in macros.move_iter() { + for source in macros.iter_owned() { let item = parse::parse_item_from_source_str(name.clone(), source, expander.cx.cfg(), @@ -985,7 +985,7 @@ pub fn expand_crate(parse_sess: &parse::ParseSess, } } - for (name, extension) in user_exts.move_iter() { + for (name, extension) in user_exts.iter_owned() { expander.cx.syntax_env.insert(name, extension); } @@ -1063,7 +1063,7 @@ fn mark_method(expr: Gc<ast::Method>, m: Mrk) -> Gc<ast::Method> { fn original_span(cx: &ExtCtxt) -> Gc<codemap::ExpnInfo> { let mut relevant_info = cx.backtrace(); - let mut einfo = relevant_info.unwrap(); + let mut einfo = relevant_info.assert(); loop { match relevant_info { None => { break } @@ -1480,7 +1480,7 @@ mod test { let binding_marks = mtwt::marksof(bindings.get(binding_idx).ctxt, invalid_name); // shouldmatch can't name varrefs that don't exist: assert!((shouldmatch.len() == 0) || - (varrefs.len() > *shouldmatch.iter().max().unwrap())); + (varrefs.len() > *shouldmatch.iter().max().assert())); for (idx,varref) in varrefs.iter().enumerate() { let print_hygiene_debug_info = || { // good lord, you can't make a path with 0 segments, can you? diff --git a/src/libsyntax/ext/format.rs b/src/libsyntax/ext/format.rs index b00924c159016..eacc9b6c80362 100644 --- a/src/libsyntax/ext/format.rs +++ b/src/libsyntax/ext/format.rs @@ -535,8 +535,8 @@ impl<'a, 'b> Context<'a, 'b> { // Now create a vector containing all the arguments let slicename = self.ecx.ident_of("__args_vec"); { - let args = names.move_iter().map(|a| a.unwrap()); - let mut args = locals.move_iter().chain(args); + let args = names.iter_owned().map(|a| a.assert()); + let mut args = locals.iter_owned().chain(args); let args = self.ecx.expr_vec_slice(self.fmtsp, args.collect()); lets.push(self.ecx.stmt_let(self.fmtsp, false, slicename, args)); } @@ -612,7 +612,7 @@ impl<'a, 'b> Context<'a, 'b> { fn format_arg(&self, sp: Span, argno: Position, arg: Gc<ast::Expr>) -> Gc<ast::Expr> { let ty = match argno { - Exact(ref i) => self.arg_types.get(*i).get_ref(), + Exact(ref i) => self.arg_types.get(*i).as_ref().assert(), Named(ref s) => self.name_types.get(s) }; diff --git a/src/libsyntax/ext/mtwt.rs b/src/libsyntax/ext/mtwt.rs index 2c94db5296750..48af74fb04c2b 100644 --- a/src/libsyntax/ext/mtwt.rs +++ b/src/libsyntax/ext/mtwt.rs @@ -267,8 +267,8 @@ pub fn outer_mark(ctxt: SyntaxContext) -> Mrk { /// Push a name... unless it matches the one on top, in which /// case pop and discard (so two of the same marks cancel) fn xor_push(marks: &mut Vec<Mrk>, mark: Mrk) { - if (marks.len() > 0) && (*marks.last().unwrap() == mark) { - marks.pop().unwrap(); + if (marks.len() > 0) && (*marks.last().assert() == mark) { + marks.pop().assert(); } else { marks.push(mark); } diff --git a/src/libsyntax/ext/quote.rs b/src/libsyntax/ext/quote.rs index cc07b5312589f..920585ccdca87 100644 --- a/src/libsyntax/ext/quote.rs +++ b/src/libsyntax/ext/quote.rs @@ -56,7 +56,7 @@ pub mod rt { impl<T: ToTokens> ToTokens for Vec<T> { fn to_tokens(&self, cx: &ExtCtxt) -> Vec<TokenTree> { - let a = self.iter().flat_map(|t| t.to_tokens(cx).move_iter()); + let a = self.iter().flat_map(|t| t.to_tokens(cx).iter_owned()); FromIterator::from_iter(a) } } diff --git a/src/libsyntax/ext/source_util.rs b/src/libsyntax/ext/source_util.rs index 703adcbd33552..41bab763a082f 100644 --- a/src/libsyntax/ext/source_util.rs +++ b/src/libsyntax/ext/source_util.rs @@ -32,7 +32,7 @@ pub fn expand_line(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) -> Box<base::MacResult> { base::check_zero_tts(cx, sp, tts, "line!"); - let topmost = topmost_expn_info(cx.backtrace().unwrap()); + let topmost = topmost_expn_info(cx.backtrace().assert()); let loc = cx.codemap().lookup_char_pos(topmost.call_site.lo); base::MacExpr::new(cx.expr_uint(topmost.call_site, loc.line)) @@ -43,7 +43,7 @@ pub fn expand_col(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) -> Box<base::MacResult> { base::check_zero_tts(cx, sp, tts, "col!"); - let topmost = topmost_expn_info(cx.backtrace().unwrap()); + let topmost = topmost_expn_info(cx.backtrace().assert()); let loc = cx.codemap().lookup_char_pos(topmost.call_site.lo); base::MacExpr::new(cx.expr_uint(topmost.call_site, loc.col.to_uint())) } @@ -55,7 +55,7 @@ pub fn expand_file(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) -> Box<base::MacResult> { base::check_zero_tts(cx, sp, tts, "file!"); - let topmost = topmost_expn_info(cx.backtrace().unwrap()); + let topmost = topmost_expn_info(cx.backtrace().assert()); let loc = cx.codemap().lookup_char_pos(topmost.call_site.lo); let filename = token::intern_and_get_ident(loc.file.name.as_slice()); base::MacExpr::new(cx.expr_str(topmost.call_site, filename)) diff --git a/src/libsyntax/ext/tt/macro_parser.rs b/src/libsyntax/ext/tt/macro_parser.rs index 509d5bd442182..1735c8fcfbf40 100644 --- a/src/libsyntax/ext/tt/macro_parser.rs +++ b/src/libsyntax/ext/tt/macro_parser.rs @@ -275,7 +275,7 @@ pub fn parse(sess: &ParseSess, if idx == len { // pop from the matcher position - let mut new_pos = ei.up.clone().unwrap(); + let mut new_pos = ei.up.clone().assert(); // update matches (the MBE "parse tree") by appending // each tree as a subtree. @@ -366,8 +366,8 @@ pub fn parse(sess: &ParseSess, if token_name_eq(&tok, &EOF) { if eof_eis.len() == 1u { let mut v = Vec::new(); - for dv in eof_eis.get_mut(0).matches.mut_iter() { - v.push(dv.pop().unwrap()); + for dv in eof_eis.get_mut(0).matches.iter_mut() { + v.push(dv.pop().assert()); } return Success(nameize(sess, ms, v.as_slice())); } else if eof_eis.len() > 1u { @@ -397,13 +397,13 @@ pub fn parse(sess: &ParseSess, } else if next_eis.len() > 0u { /* Now process the next token */ while next_eis.len() > 0u { - cur_eis.push(next_eis.pop().unwrap()); + cur_eis.push(next_eis.pop().assert()); } rdr.next_token(); } else /* bb_eis.len() == 1 */ { let mut rust_parser = Parser::new(sess, cfg.clone(), box rdr.clone()); - let mut ei = bb_eis.pop().unwrap(); + let mut ei = bb_eis.pop().assert(); match ei.elts.get(ei.idx).node { MatchNonterminal(_, name, idx) => { let name_string = token::get_ident(name); diff --git a/src/libsyntax/ext/tt/transcribe.rs b/src/libsyntax/ext/tt/transcribe.rs index 726a7315f6991..f30e39232588b 100644 --- a/src/libsyntax/ext/tt/transcribe.rs +++ b/src/libsyntax/ext/tt/transcribe.rs @@ -157,14 +157,14 @@ pub fn tt_next_token(r: &mut TtReader) -> TokenAndSpan { break; } !frame.dotdotdoted || - *r.repeat_idx.last().unwrap() == *r.repeat_len.last().unwrap() - 1 + *r.repeat_idx.last().assert() == *r.repeat_len.last().assert() - 1 } }; /* done with this set; pop or repeat? */ if should_pop { - let prev = r.stack.pop().unwrap(); - match r.stack.mut_last() { + let prev = r.stack.pop().assert(); + match r.stack.last_mut() { None => { r.cur_tok = EOF; return ret_val; @@ -178,9 +178,9 @@ pub fn tt_next_token(r: &mut TtReader) -> TokenAndSpan { r.repeat_len.pop(); } } else { /* repeat */ - *r.repeat_idx.mut_last().unwrap() += 1u; - r.stack.mut_last().unwrap().idx = 0; - match r.stack.last().unwrap().sep.clone() { + *r.repeat_idx.last_mut().assert() += 1u; + r.stack.last_mut().assert().idx = 0; + match r.stack.last().assert().sep.clone() { Some(tk) => { r.cur_tok = tk; /* repeat same span, I guess */ return ret_val; @@ -192,7 +192,7 @@ pub fn tt_next_token(r: &mut TtReader) -> TokenAndSpan { loop { /* because it's easiest, this handles `TTDelim` not starting with a `TTTok`, even though it won't happen */ let t = { - let frame = r.stack.last().unwrap(); + let frame = r.stack.last().assert(); // FIXME(pcwalton): Bad copy. (*frame.forest.get(frame.idx)).clone() }; @@ -209,7 +209,7 @@ pub fn tt_next_token(r: &mut TtReader) -> TokenAndSpan { TTTok(sp, tok) => { r.cur_span = sp; r.cur_tok = tok; - r.stack.mut_last().unwrap().idx += 1; + r.stack.last_mut().assert().idx += 1; return ret_val; } TTSeq(sp, tts, sep, zerok) => { @@ -234,7 +234,7 @@ pub fn tt_next_token(r: &mut TtReader) -> TokenAndSpan { "this must repeat at least once"); } - r.stack.mut_last().unwrap().idx += 1; + r.stack.last_mut().assert().idx += 1; return tt_next_token(r); } r.repeat_len.push(len); @@ -250,7 +250,7 @@ pub fn tt_next_token(r: &mut TtReader) -> TokenAndSpan { } // FIXME #2887: think about span stuff here TTNonterminal(sp, ident) => { - r.stack.mut_last().unwrap().idx += 1; + r.stack.last_mut().assert().idx += 1; match *lookup_cur_matched(r, ident) { /* sidestep the interpolation tricks for ident because (a) idents can be in lots of places, so it'd be a pain diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs index 80325c64349e8..7bb049fa1808e 100644 --- a/src/libsyntax/fold.rs +++ b/src/libsyntax/fold.rs @@ -316,11 +316,11 @@ pub fn noop_fold_decl<T: Folder>(d: Gc<Decl>, fld: &mut T) -> SmallVector<Gc<Dec let node = match d.node { DeclLocal(ref l) => SmallVector::one(DeclLocal(fld.fold_local(*l))), DeclItem(it) => { - fld.fold_item(it).move_iter().map(|i| DeclItem(i)).collect() + fld.fold_item(it).iter_owned().map(|i| DeclItem(i)).collect() } }; - node.move_iter().map(|node| { + node.iter_owned().map(|node| { box(GC) Spanned { node: node, span: fld.new_span(d.span), @@ -789,7 +789,7 @@ pub fn noop_fold_view_item<T: Folder>(vi: &ViewItem, folder: &mut T) pub fn noop_fold_block<T: Folder>(b: P<Block>, folder: &mut T) -> P<Block> { let id = folder.new_id(b.id); // Needs to be first, for ast_map. let view_items = b.view_items.iter().map(|x| folder.fold_view_item(x)).collect(); - let stmts = b.stmts.iter().flat_map(|s| folder.fold_stmt(&**s).move_iter()).collect(); + let stmts = b.stmts.iter().flat_map(|s| folder.fold_stmt(&**s).iter_owned()).collect(); P(Block { id: id, view_items: view_items, @@ -836,23 +836,23 @@ pub fn noop_fold_item_underscore<T: Folder>(i: &Item_, folder: &mut T) -> Item_ ItemImpl(folder.fold_generics(generics), ifce.as_ref().map(|p| folder.fold_trait_ref(p)), folder.fold_ty(ty), - methods.iter().flat_map(|x| folder.fold_method(*x).move_iter()).collect() + methods.iter().flat_map(|x| folder.fold_method(*x).iter_owned()).collect() ) } ItemTrait(ref generics, ref unbound, ref traits, ref methods) => { let methods = methods.iter().flat_map(|method| { let r = match *method { Required(ref m) => - SmallVector::one(Required(folder.fold_type_method(m))).move_iter(), + SmallVector::one(Required(folder.fold_type_method(m))).iter_owned(), Provided(method) => { // the awkward collect/iter idiom here is because // even though an iter and a map satisfy the same trait bound, // they're not actually the same type, so the method arms // don't unify. let methods : SmallVector<ast::TraitMethod> = - folder.fold_method(method).move_iter() + folder.fold_method(method).iter_owned() .map(|m| Provided(m)).collect(); - methods.move_iter() + methods.iter_owned() } }; r @@ -888,7 +888,7 @@ pub fn noop_fold_mod<T: Folder>(m: &Mod, folder: &mut T) -> Mod { view_items: m.view_items .iter() .map(|x| folder.fold_view_item(x)).collect(), - items: m.items.iter().flat_map(|x| folder.fold_item(*x).move_iter()).collect(), + items: m.items.iter().flat_map(|x| folder.fold_item(*x).iter_owned()).collect(), } } @@ -1161,7 +1161,7 @@ pub fn noop_fold_stmt<T: Folder>(s: &Stmt, let nodes = match s.node { StmtDecl(d, id) => { let id = folder.new_id(id); - folder.fold_decl(d).move_iter() + folder.fold_decl(d).iter_owned() .map(|d| StmtDecl(d, id)) .collect() } @@ -1176,7 +1176,7 @@ pub fn noop_fold_stmt<T: Folder>(s: &Stmt, StmtMac(ref mac, semi) => SmallVector::one(StmtMac(folder.fold_mac(mac), semi)) }; - nodes.move_iter().map(|node| box(GC) Spanned { + nodes.iter_owned().map(|node| box(GC) Spanned { node: node, span: folder.new_span(s.span), }).collect() diff --git a/src/libsyntax/owned_slice.rs b/src/libsyntax/owned_slice.rs index 7eb6709919aaf..95a48604aab46 100644 --- a/src/libsyntax/owned_slice.rs +++ b/src/libsyntax/owned_slice.rs @@ -48,7 +48,7 @@ impl<T> Drop for OwnedSlice<T> { impl<T> OwnedSlice<T> { pub fn empty() -> OwnedSlice<T> { - OwnedSlice { data: ptr::mut_null(), len: 0 } + OwnedSlice { data: ptr::null_mut(), len: 0 } } #[inline(never)] diff --git a/src/libsyntax/parse/lexer/comments.rs b/src/libsyntax/parse/lexer/comments.rs index c53638ed07d13..4e73496a25c9e 100644 --- a/src/libsyntax/parse/lexer/comments.rs +++ b/src/libsyntax/parse/lexer/comments.rs @@ -252,7 +252,7 @@ fn read_block_comment(rdr: &mut StringReader, // doc-comments are not really comments, they are attributes if (rdr.curr_is('*') && !rdr.nextch_is('*')) || rdr.curr_is('!') { while !(rdr.curr_is('*') && rdr.nextch_is('/')) && !rdr.is_eof() { - curr_line.push_char(rdr.curr.unwrap()); + curr_line.push_char(rdr.curr.assert()); rdr.bump(); } if !rdr.is_eof() { @@ -279,7 +279,7 @@ fn read_block_comment(rdr: &mut StringReader, curr_line = String::new(); rdr.bump(); } else { - curr_line.push_char(rdr.curr.unwrap()); + curr_line.push_char(rdr.curr.assert()); if rdr.curr_is('/') && rdr.nextch_is('*') { rdr.bump(); rdr.bump(); @@ -338,8 +338,8 @@ pub fn gather_comments_and_literals(span_diagnostic: &diagnostic::SpanHandler, path: String, srdr: &mut io::Reader) -> (Vec<Comment>, Vec<Literal>) { - let src = srdr.read_to_end().unwrap(); - let src = String::from_utf8(src).unwrap(); + let src = srdr.read_to_end().assert(); + let src = String::from_utf8(src).assert(); let cm = CodeMap::new(); let filemap = cm.new_filemap(path, src); let mut rdr = lexer::StringReader::new_raw(span_diagnostic, filemap); diff --git a/src/libsyntax/parse/lexer/mod.rs b/src/libsyntax/parse/lexer/mod.rs index 625c03ec13db9..bae01a8fc2d79 100644 --- a/src/libsyntax/parse/lexer/mod.rs +++ b/src/libsyntax/parse/lexer/mod.rs @@ -286,7 +286,7 @@ impl<'a> StringReader<'a> { let current_byte_offset = self.byte_offset(self.pos).to_uint(); if current_byte_offset < self.filemap.src.len() { assert!(self.curr.is_some()); - let last_char = self.curr.unwrap(); + let last_char = self.curr.assert(); let next = self.filemap .src .as_slice() @@ -359,7 +359,7 @@ impl<'a> StringReader<'a> { if self.curr_is('/') || self.curr_is('!') { let start_bpos = self.pos - BytePos(3); while !self.is_eof() { - match self.curr.unwrap() { + match self.curr.assert() { '\n' => break, '\r' => { if self.nextch_is('\n') { @@ -475,7 +475,7 @@ impl<'a> StringReader<'a> { let last_bpos = self.last_pos; self.fatal_span_(start_bpos, last_bpos, msg); } - let n = self.curr.unwrap(); + let n = self.curr.assert(); match n { '/' if self.nextch_is('*') => { level += 1; @@ -809,7 +809,7 @@ impl<'a> StringReader<'a> { /// token, and updates the interner fn next_token_inner(&mut self) -> token::Token { let c = self.curr; - if ident_start(c) && match (c.unwrap(), self.nextch(), self.nextnextch()) { + if ident_start(c) && match (c.assert(), self.nextch(), self.nextnextch()) { // Note: r as in r" or r#" is part of a raw string literal, // b as in b' is part of a byte literal. // They are not identifiers, and are handled further down. @@ -836,7 +836,7 @@ impl<'a> StringReader<'a> { } if is_dec_digit(c) { - return self.scan_number(c.unwrap()); + return self.scan_number(c.assert()); } match c.expect("next_token_inner called at EOF") { @@ -1005,7 +1005,7 @@ impl<'a> StringReader<'a> { } let ch_start = self.last_pos; - let ch = self.curr.unwrap(); + let ch = self.curr.assert(); self.bump(); valid &= self.scan_char_or_byte(ch_start, ch, /* ascii_only = */ false, '"'); } @@ -1029,7 +1029,7 @@ impl<'a> StringReader<'a> { self.fatal_span_(start_bpos, last_bpos, "unterminated raw string"); } else if !self.curr_is('"') { let last_bpos = self.last_pos; - let curr_char = self.curr.unwrap(); + let curr_char = self.curr.assert(); self.fatal_span_char(start_bpos, last_bpos, "only `#` is allowed in raw string delimitation; \ found illegal character", @@ -1050,7 +1050,7 @@ impl<'a> StringReader<'a> { //self.bump(); //if !self.curr_is('#') { //continue 'outer; - let c = self.curr.unwrap(); + let c = self.curr.assert(); match c { '"' => { content_end_bpos = self.last_pos; @@ -1122,7 +1122,7 @@ impl<'a> StringReader<'a> { fn read_to_eol(&mut self) -> String { let mut val = String::new(); while !self.curr_is('\n') && !self.is_eof() { - val.push_char(self.curr.unwrap()); + val.push_char(self.curr.assert()); self.bump(); } if self.curr_is('\n') { self.bump(); } @@ -1186,7 +1186,7 @@ impl<'a> StringReader<'a> { } let ch_start = self.last_pos; - let ch = self.curr.unwrap(); + let ch = self.curr.assert(); self.bump(); valid &= self.scan_char_or_byte(ch_start, ch, /* ascii_only = */ true, '"'); } @@ -1209,7 +1209,7 @@ impl<'a> StringReader<'a> { self.fatal_span_(start_bpos, last_pos, "unterminated raw string"); } else if !self.curr_is('"') { let last_pos = self.last_pos; - let ch = self.curr.unwrap(); + let ch = self.curr.assert(); self.fatal_span_char(start_bpos, last_pos, "only `#` is allowed in raw string delimitation; \ found illegal character", diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs index 5b70ed609d98f..d45a5cdc4fcbe 100644 --- a/src/libsyntax/parse/mod.rs +++ b/src/libsyntax/parse/mod.rs @@ -232,7 +232,7 @@ pub fn file_to_filemap(sess: &ParseSess, path: &Path, spanopt: Option<Span>) match str::from_utf8(bytes.as_slice()) { Some(s) => { return string_to_filemap(sess, s.to_string(), - path.as_str().unwrap().to_string()) + path.as_str().assert().to_string()) } None => { err(format!("{} is not UTF-8 encoded", path.display()).as_slice()) @@ -394,7 +394,7 @@ pub fn raw_str_lit(lit: &str) -> String { match chars.next() { Some(c) => { if c == '\r' { - if *chars.peek().unwrap() != '\n' { + if *chars.peek().assert() != '\n' { fail!("lexer accepted bare CR"); } chars.next(); @@ -535,7 +535,7 @@ pub fn integer_lit(s: &str, sd: &SpanHandler, sp: Span) -> ast::Lit_ { debug!("parse_integer_lit: {}", s); if s.len() == 1 { - let n = (s.char_at(0)).to_digit(10).unwrap(); + let n = (s.char_at(0)).to_digit(10).assert(); return ast::LitInt(n as u64, ast::UnsuffixedIntLit(ast::Sign::new(n))); } @@ -1045,19 +1045,19 @@ mod test { let name = "<source>".to_string(); let source = "/// doc comment\r\nfn foo() {}".to_string(); - let item = parse_item_from_source_str(name.clone(), source, Vec::new(), &sess).unwrap(); - let doc = attr::first_attr_value_str_by_name(item.attrs.as_slice(), "doc").unwrap(); + let item = parse_item_from_source_str(name.clone(), source, Vec::new(), &sess).assert(); + let doc = attr::first_attr_value_str_by_name(item.attrs.as_slice(), "doc").assert(); assert_eq!(doc.get(), "/// doc comment"); let source = "/// doc comment\r\n/// line 2\r\nfn foo() {}".to_string(); - let item = parse_item_from_source_str(name.clone(), source, Vec::new(), &sess).unwrap(); + let item = parse_item_from_source_str(name.clone(), source, Vec::new(), &sess).assert(); let docs = item.attrs.iter().filter(|a| a.name().get() == "doc") - .map(|a| a.value_str().unwrap().get().to_string()).collect::<Vec<_>>(); + .map(|a| a.value_str().assert().get().to_string()).collect::<Vec<_>>(); assert_eq!(docs.as_slice(), &["/// doc comment".to_string(), "/// line 2".to_string()]); let source = "/** doc comment\r\n * with CRLF */\r\nfn foo() {}".to_string(); - let item = parse_item_from_source_str(name, source, Vec::new(), &sess).unwrap(); - let doc = attr::first_attr_value_str_by_name(item.attrs.as_slice(), "doc").unwrap(); + let item = parse_item_from_source_str(name, source, Vec::new(), &sess).assert(); + let doc = attr::first_attr_value_str_by_name(item.attrs.as_slice(), "doc").assert(); assert_eq!(doc.get(), "/** doc comment\n * with CRLF */"); } } diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 7ea000d3aac41..1ce764fc003ac 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -1957,19 +1957,19 @@ impl<'a> Parser<'a> { return self.mk_expr(lo, hi, ExprLit(lit)); } let mut es = vec!(self.parse_expr()); - self.commit_expr(*es.last().unwrap(), &[], &[token::COMMA, token::RPAREN]); + self.commit_expr(*es.last().assert(), &[], &[token::COMMA, token::RPAREN]); while self.token == token::COMMA { self.bump(); if self.token != token::RPAREN { es.push(self.parse_expr()); - self.commit_expr(*es.last().unwrap(), &[], &[token::COMMA, token::RPAREN]); + self.commit_expr(*es.last().assert(), &[], &[token::COMMA, token::RPAREN]); } else { trailing_comma = true; } } hi = self.span.hi; - self.commit_expr_expecting(*es.last().unwrap(), token::RPAREN); + self.commit_expr_expecting(*es.last().assert(), token::RPAREN); return if es.len() == 1 && !trailing_comma { self.mk_expr(lo, hi, ExprParen(*es.get(0))) @@ -2158,7 +2158,7 @@ impl<'a> Parser<'a> { } fields.push(self.parse_field()); - self.commit_expr(fields.last().unwrap().expr, + self.commit_expr(fields.last().assert().expr, &[token::COMMA], &[token::RBRACE]); } @@ -2395,7 +2395,7 @@ impl<'a> Parser<'a> { // Parse the close delimiter. result.push(parse_any_tt_tok(self)); - self.open_braces.pop().unwrap(); + self.open_braces.pop().assert(); TTDelim(Rc::new(result)) } @@ -3781,7 +3781,7 @@ impl<'a> Parser<'a> { "variadic function must be declared with at least one named argument"); } - let args = args.move_iter().map(|x| x.unwrap()).collect(); + let args = args.iter_owned().map(|x| x.assert()).collect(); (args, variadic) } @@ -4515,7 +4515,7 @@ impl<'a> Parser<'a> { } fn pop_mod_path(&mut self) { - self.mod_path_stack.pop().unwrap(); + self.mod_path_stack.pop().assert(); } /// Read a module from a source file. @@ -4546,7 +4546,7 @@ impl<'a> Parser<'a> { "cannot declare a new module at this location"); let this_module = match self.mod_path_stack.last() { Some(name) => name.get().to_string(), - None => self.root_module_name.get_ref().clone(), + None => self.root_module_name.as_ref().assert().clone(), }; self.span_note(id_sp, format!("maybe move this module `{0}` \ @@ -4835,7 +4835,7 @@ impl<'a> Parser<'a> { seq_sep_trailing_disallowed(token::COMMA), |p| p.parse_ty(true) ); - for ty in arg_tys.move_iter() { + for ty in arg_tys.iter_owned() { args.push(ast::VariantArg { ty: ty, id: ast::DUMMY_NODE_ID, @@ -5277,7 +5277,7 @@ impl<'a> Parser<'a> { let path = ast::Path { span: mk_sp(path_lo, self.span.hi), global: false, - segments: path.move_iter().map(|identifier| { + segments: path.iter_owned().map(|identifier| { ast::PathSegment { identifier: identifier, lifetimes: Vec::new(), @@ -5312,7 +5312,7 @@ impl<'a> Parser<'a> { let path = ast::Path { span: mk_sp(lo, self.span.hi), global: false, - segments: path.move_iter().map(|identifier| { + segments: path.iter_owned().map(|identifier| { ast::PathSegment { identifier: identifier, lifetimes: Vec::new(), @@ -5330,7 +5330,7 @@ impl<'a> Parser<'a> { let path = ast::Path { span: mk_sp(lo, self.span.hi), global: false, - segments: path.move_iter().map(|identifier| { + segments: path.iter_owned().map(|identifier| { ast::PathSegment { identifier: identifier, lifetimes: Vec::new(), @@ -5352,7 +5352,7 @@ impl<'a> Parser<'a> { let path = ast::Path { span: mk_sp(lo, self.span.hi), global: false, - segments: path.move_iter().map(|identifier| { + segments: path.iter_owned().map(|identifier| { ast::PathSegment { identifier: identifier, lifetimes: Vec::new(), diff --git a/src/libsyntax/print/pp.rs b/src/libsyntax/print/pp.rs index f28e6829b00d8..f4a5f5b4c1471 100644 --- a/src/libsyntax/print/pp.rs +++ b/src/libsyntax/print/pp.rs @@ -556,7 +556,7 @@ impl Printer { debug!("print End -> pop End"); let print_stack = &mut self.print_stack; assert!((print_stack.len() != 0u)); - print_stack.pop().unwrap(); + print_stack.pop().assert(); Ok(()) } Break(b) => { diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index 9d4b7343c8a15..c5828eb81f36e 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -155,15 +155,15 @@ impl<'a> State<'a> { pub fn to_string(f: |&mut State| -> IoResult<()>) -> String { let mut s = rust_printer(box MemWriter::new()); - f(&mut s).unwrap(); - eof(&mut s.s).unwrap(); + f(&mut s).assert(); + eof(&mut s.s).assert(); unsafe { // FIXME(pcwalton): A nasty function to extract the string from an `io::Writer` // that we "know" to be a `MemWriter` that works around the lack of checked // downcasts. let (_, wr): (uint, Box<MemWriter>) = mem::transmute_copy(&s.s.out); let result = - String::from_utf8(Vec::from_slice(wr.get_ref().as_slice())).unwrap(); + String::from_utf8(Vec::from_slice(wr.get_ref().as_slice())).assert(); mem::forget(wr); result.to_string() } @@ -302,7 +302,7 @@ impl<'a> State<'a> { } pub fn end(&mut self) -> IoResult<()> { - self.boxes.pop().unwrap(); + self.boxes.pop().assert(); pp::end(&mut self.s) } @@ -1107,7 +1107,7 @@ impl<'a> State<'a> { try!(self.hardbreak_if_not_bol()); try!(self.maybe_print_comment(attr.span.lo)); if attr.node.is_sugared_doc { - word(&mut self.s, attr.value_str().unwrap().get()) + word(&mut self.s, attr.value_str().assert().get()) } else { match attr.node.style { ast::AttrInner => try!(word(&mut self.s, "#![")), @@ -1451,13 +1451,13 @@ impl<'a> State<'a> { try!(self.print_block_unclosed(&**body)); } else { // we extract the block, so as not to create another set of boxes - match body.expr.unwrap().node { + match body.expr.assert().node { ast::ExprBlock(blk) => { try!(self.print_block_unclosed(&*blk)); } _ => { // this is a bare expression - try!(self.print_expr(&*body.expr.unwrap())); + try!(self.print_expr(&*body.expr.assert())); try!(self.end()); // need to close a box } } @@ -1481,13 +1481,13 @@ impl<'a> State<'a> { try!(self.print_block_unclosed(&**body)); } else { // we extract the block, so as not to create another set of boxes - match body.expr.unwrap().node { + match body.expr.assert().node { ast::ExprBlock(ref blk) => { try!(self.print_block_unclosed(&**blk)); } _ => { // this is a bare expression - try!(self.print_expr(&*body.expr.unwrap())); + try!(self.print_expr(&*body.expr.assert())); try!(self.end()); // need to close a box } } @@ -1509,13 +1509,13 @@ impl<'a> State<'a> { assert!(body.stmts.is_empty()); assert!(body.expr.is_some()); // we extract the block, so as not to create another set of boxes - match body.expr.unwrap().node { + match body.expr.assert().node { ast::ExprBlock(ref blk) => { try!(self.print_block_unclosed(&**blk)); } _ => { // this is a bare expression - try!(self.print_expr(&*body.expr.unwrap())); + try!(self.print_expr(&*body.expr.assert())); try!(self.end()); // need to close a box } } @@ -2204,7 +2204,7 @@ impl<'a> State<'a> { match vp.node { ast::ViewPathSimple(ident, ref path, _) => { // FIXME(#6993) can't compare identifiers directly here - if path.segments.last().unwrap().identifier.name != ident.name { + if path.segments.last().assert().identifier.name != ident.name { try!(self.print_ident(ident)); try!(space(&mut self.s)); try!(self.word_space("=")); diff --git a/src/libsyntax/util/small_vector.rs b/src/libsyntax/util/small_vector.rs index 43367611ab2b9..10c9e15d87229 100644 --- a/src/libsyntax/util/small_vector.rs +++ b/src/libsyntax/util/small_vector.rs @@ -85,7 +85,7 @@ impl<T> SmallVector<T> { } pub fn push_all(&mut self, other: SmallVector<T>) { - for v in other.move_iter() { + for v in other.iter_owned() { self.push(v); } } @@ -103,7 +103,7 @@ impl<T> SmallVector<T> { One(v) => v, Many(v) => { if v.len() == 1 { - v.move_iter().next().unwrap() + v.iter_owned().next().assert() } else { fail!(err) } @@ -112,27 +112,37 @@ impl<T> SmallVector<T> { } } - pub fn move_iter(self) -> MoveItems<T> { + /// Deprecated: renamed to `iter_owned`. + #[deprecated = "renamed to iter_owned"] + pub fn move_iter(self) -> ItemsOwned<T> { + self.iter_owned() + } + + pub fn iter_owned(self) -> ItemsOwned<T> { let repr = match self.repr { Zero => ZeroIterator, One(v) => OneIterator(v), - Many(vs) => ManyIterator(vs.move_iter()) + Many(vs) => ManyIterator(vs.iter_owned()) }; - MoveItems { repr: repr } + ItemsOwned { repr: repr } } } -pub struct MoveItems<T> { - repr: MoveItemsRepr<T>, +pub struct ItemsOwned<T> { + repr: ItemsOwnedRepr<T>, } -enum MoveItemsRepr<T> { +/// Deprecated: renamed to `ItemsOwned`. +#[deprecated = "renamed to ItemsOwned"] +pub type MoveItems<T> = ItemsOwned<T>; + +enum ItemsOwnedRepr<T> { ZeroIterator, OneIterator(T), - ManyIterator(vec::MoveItems<T>), + ManyIterator(vec::ItemsOwned<T>), } -impl<T> Iterator<T> for MoveItems<T> { +impl<T> Iterator<T> for ItemsOwned<T> { fn next(&mut self) -> Option<T> { match self.repr { ZeroIterator => None, @@ -186,7 +196,7 @@ mod test { #[test] fn test_from_iter() { - let v: SmallVector<int> = (vec!(1i, 2, 3)).move_iter().collect(); + let v: SmallVector<int> = (vec!(1i, 2, 3)).iter_owned().collect(); assert_eq!(3, v.len()); assert_eq!(&1, v.get(0)); assert_eq!(&2, v.get(1)); @@ -196,14 +206,14 @@ mod test { #[test] fn test_move_iter() { let v = SmallVector::zero(); - let v: Vec<int> = v.move_iter().collect(); + let v: Vec<int> = v.iter_owned().collect(); assert_eq!(Vec::new(), v); let v = SmallVector::one(1i); - assert_eq!(vec!(1i), v.move_iter().collect()); + assert_eq!(vec!(1i), v.iter_owned().collect()); let v = SmallVector::many(vec!(1i, 2i, 3i)); - assert_eq!(vec!(1i, 2i, 3i), v.move_iter().collect()); + assert_eq!(vec!(1i, 2i, 3i), v.iter_owned().collect()); } #[test] diff --git a/src/libterm/lib.rs b/src/libterm/lib.rs index 3fc631422d5f3..4ff9926d5a0bd 100644 --- a/src/libterm/lib.rs +++ b/src/libterm/lib.rs @@ -22,15 +22,15 @@ //! extern crate term; //! //! fn main() { -//! let mut t = term::stdout().unwrap(); +//! let mut t = term::stdout().assert(); //! -//! t.fg(term::color::GREEN).unwrap(); -//! (write!(t, "hello, ")).unwrap(); +//! t.fg(term::color::GREEN).assert(); +//! (write!(t, "hello, ")).assert(); //! -//! t.fg(term::color::RED).unwrap(); -//! (writeln!(t, "world!")).unwrap(); +//! t.fg(term::color::RED).assert(); +//! (writeln!(t, "world!")).assert(); //! -//! t.reset().unwrap(); +//! t.reset().assert(); //! } //! ``` //! @@ -244,9 +244,21 @@ pub trait Terminal<T: Writer>: Writer { /// Returns the contained stream, destroying the `Terminal` fn unwrap(self) -> T; + /// Deprecated. Use `as_inner` instead. + /// + /// Gets an immutable reference to the stream inside + #[deprecated = "use as_inner instead"] + fn get_ref(&self) -> &T { self.as_inner() } + + /// /// Deprecated. Use `as_inner_mut` instead. + /// + /// Gets a mutable reference to the stream inside + #[deprecated = "use as_inner_mut instead"] + fn get_mut(&mut self) -> &mut T { self.as_inner_mut() } + /// Gets an immutable reference to the stream inside - fn get_ref<'a>(&'a self) -> &'a T; + fn as_inner(&self) -> &T; /// Gets a mutable reference to the stream inside - fn get_mut<'a>(&'a mut self) -> &'a mut T; + fn as_inner_mut(&mut self) -> &mut T; } diff --git a/src/libterm/terminfo/mod.rs b/src/libterm/terminfo/mod.rs index 36883c8fcf4f2..881aa7742f210 100644 --- a/src/libterm/terminfo/mod.rs +++ b/src/libterm/terminfo/mod.rs @@ -89,18 +89,18 @@ impl<T: Writer> Terminal<T> for TerminfoTerminal<T> { // msys terminal return Some(TerminfoTerminal {out: out, ti: msys_terminfo(), num_colors: 8}); } - debug!("error finding terminfo entry: {}", entry.err().unwrap()); + debug!("error finding terminfo entry: {}", entry.err().assert()); return None; } - let mut file = entry.unwrap(); + let mut file = entry.assert(); let ti = parse(&mut file, false); if ti.is_err() { - debug!("error parsing terminfo entry: {}", ti.unwrap_err()); + debug!("error parsing terminfo entry: {}", ti.assert_err()); return None; } - let inf = ti.unwrap(); + let inf = ti.assert(); let nc = if inf.strings.find_equiv(&("setaf")).is_some() && inf.strings.find_equiv(&("setab")).is_some() { inf.numbers.find_equiv(&("colors")).map_or(0, |&n| n) @@ -115,11 +115,11 @@ impl<T: Writer> Terminal<T> for TerminfoTerminal<T> { let s = expand(self.ti .strings .find_equiv(&("setaf")) - .unwrap() + .assert() .as_slice(), [Number(color as int)], &mut Variables::new()); if s.is_ok() { - try!(self.out.write(s.unwrap().as_slice())); + try!(self.out.write(s.assert().as_slice())); return Ok(true) } } @@ -132,11 +132,11 @@ impl<T: Writer> Terminal<T> for TerminfoTerminal<T> { let s = expand(self.ti .strings .find_equiv(&("setab")) - .unwrap() + .assert() .as_slice(), [Number(color as int)], &mut Variables::new()); if s.is_ok() { - try!(self.out.write(s.unwrap().as_slice())); + try!(self.out.write(s.assert().as_slice())); return Ok(true) } } @@ -151,11 +151,11 @@ impl<T: Writer> Terminal<T> for TerminfoTerminal<T> { let cap = cap_for_attr(attr); let parm = self.ti.strings.find_equiv(&cap); if parm.is_some() { - let s = expand(parm.unwrap().as_slice(), + let s = expand(parm.assert().as_slice(), [], &mut Variables::new()); if s.is_ok() { - try!(self.out.write(s.unwrap().as_slice())); + try!(self.out.write(s.assert().as_slice())); return Ok(true) } } @@ -190,16 +190,16 @@ impl<T: Writer> Terminal<T> for TerminfoTerminal<T> { expand(op.as_slice(), [], &mut Variables::new()) }); if s.is_ok() { - return self.out.write(s.unwrap().as_slice()) + return self.out.write(s.assert().as_slice()) } Ok(()) } fn unwrap(self) -> T { self.out } - fn get_ref<'a>(&'a self) -> &'a T { &self.out } + fn as_inner(&self) -> &T { &self.out } - fn get_mut<'a>(&'a mut self) -> &'a mut T { &mut self.out } + fn as_inner_mut(&mut self) -> &mut T { &mut self.out } } impl<T: Writer> TerminfoTerminal<T> { @@ -220,4 +220,3 @@ impl<T: Writer> Writer for TerminfoTerminal<T> { self.out.flush() } } - diff --git a/src/libterm/terminfo/parm.rs b/src/libterm/terminfo/parm.rs index fdbe6eeadfd8a..a11b2b3bca1e4 100644 --- a/src/libterm/terminfo/parm.rs +++ b/src/libterm/terminfo/parm.rs @@ -102,7 +102,7 @@ pub fn expand(cap: &[u8], params: &[Param], vars: &mut Variables) Number(0), Number(0), Number(0), Number(0), Number(0), Number(0), Number(0), Number(0), Number(0), ]; - for (dst, src) in mparams.mut_iter().zip(params.iter()) { + for (dst, src) in mparams.iter_mut().zip(params.iter()) { *dst = (*src).clone(); } @@ -121,7 +121,7 @@ pub fn expand(cap: &[u8], params: &[Param], vars: &mut Variables) match cur { '%' => { output.push(c); state = Nothing }, 'c' => if stack.len() > 0 { - match stack.pop().unwrap() { + match stack.pop().assert() { // if c is 0, use 0200 (128) for ncurses compatibility Number(c) => { output.push(if c == 0 { @@ -139,82 +139,82 @@ pub fn expand(cap: &[u8], params: &[Param], vars: &mut Variables) '\'' => state = CharConstant, '{' => state = IntConstant(0), 'l' => if stack.len() > 0 { - match stack.pop().unwrap() { + match stack.pop().assert() { String(s) => stack.push(Number(s.len() as int)), _ => return Err("a non-str was used with %l".to_string()) } } else { return Err("stack is empty".to_string()) }, '+' => if stack.len() > 1 { - match (stack.pop().unwrap(), stack.pop().unwrap()) { + match (stack.pop().assert(), stack.pop().assert()) { (Number(y), Number(x)) => stack.push(Number(x + y)), _ => return Err("non-numbers on stack with +".to_string()) } } else { return Err("stack is empty".to_string()) }, '-' => if stack.len() > 1 { - match (stack.pop().unwrap(), stack.pop().unwrap()) { + match (stack.pop().assert(), stack.pop().assert()) { (Number(y), Number(x)) => stack.push(Number(x - y)), _ => return Err("non-numbers on stack with -".to_string()) } } else { return Err("stack is empty".to_string()) }, '*' => if stack.len() > 1 { - match (stack.pop().unwrap(), stack.pop().unwrap()) { + match (stack.pop().assert(), stack.pop().assert()) { (Number(y), Number(x)) => stack.push(Number(x * y)), _ => return Err("non-numbers on stack with *".to_string()) } } else { return Err("stack is empty".to_string()) }, '/' => if stack.len() > 1 { - match (stack.pop().unwrap(), stack.pop().unwrap()) { + match (stack.pop().assert(), stack.pop().assert()) { (Number(y), Number(x)) => stack.push(Number(x / y)), _ => return Err("non-numbers on stack with /".to_string()) } } else { return Err("stack is empty".to_string()) }, 'm' => if stack.len() > 1 { - match (stack.pop().unwrap(), stack.pop().unwrap()) { + match (stack.pop().assert(), stack.pop().assert()) { (Number(y), Number(x)) => stack.push(Number(x % y)), _ => return Err("non-numbers on stack with %".to_string()) } } else { return Err("stack is empty".to_string()) }, '&' => if stack.len() > 1 { - match (stack.pop().unwrap(), stack.pop().unwrap()) { + match (stack.pop().assert(), stack.pop().assert()) { (Number(y), Number(x)) => stack.push(Number(x & y)), _ => return Err("non-numbers on stack with &".to_string()) } } else { return Err("stack is empty".to_string()) }, '|' => if stack.len() > 1 { - match (stack.pop().unwrap(), stack.pop().unwrap()) { + match (stack.pop().assert(), stack.pop().assert()) { (Number(y), Number(x)) => stack.push(Number(x | y)), _ => return Err("non-numbers on stack with |".to_string()) } } else { return Err("stack is empty".to_string()) }, '^' => if stack.len() > 1 { - match (stack.pop().unwrap(), stack.pop().unwrap()) { + match (stack.pop().assert(), stack.pop().assert()) { (Number(y), Number(x)) => stack.push(Number(x ^ y)), _ => return Err("non-numbers on stack with ^".to_string()) } } else { return Err("stack is empty".to_string()) }, '=' => if stack.len() > 1 { - match (stack.pop().unwrap(), stack.pop().unwrap()) { + match (stack.pop().assert(), stack.pop().assert()) { (Number(y), Number(x)) => stack.push(Number(if x == y { 1 } else { 0 })), _ => return Err("non-numbers on stack with =".to_string()) } } else { return Err("stack is empty".to_string()) }, '>' => if stack.len() > 1 { - match (stack.pop().unwrap(), stack.pop().unwrap()) { + match (stack.pop().assert(), stack.pop().assert()) { (Number(y), Number(x)) => stack.push(Number(if x > y { 1 } else { 0 })), _ => return Err("non-numbers on stack with >".to_string()) } } else { return Err("stack is empty".to_string()) }, '<' => if stack.len() > 1 { - match (stack.pop().unwrap(), stack.pop().unwrap()) { + match (stack.pop().assert(), stack.pop().assert()) { (Number(y), Number(x)) => stack.push(Number(if x < y { 1 } else { 0 })), _ => return Err("non-numbers on stack with <".to_string()) } } else { return Err("stack is empty".to_string()) }, 'A' => if stack.len() > 1 { - match (stack.pop().unwrap(), stack.pop().unwrap()) { + match (stack.pop().assert(), stack.pop().assert()) { (Number(0), Number(_)) => stack.push(Number(0)), (Number(_), Number(0)) => stack.push(Number(0)), (Number(_), Number(_)) => stack.push(Number(1)), @@ -222,21 +222,21 @@ pub fn expand(cap: &[u8], params: &[Param], vars: &mut Variables) } } else { return Err("stack is empty".to_string()) }, 'O' => if stack.len() > 1 { - match (stack.pop().unwrap(), stack.pop().unwrap()) { + match (stack.pop().assert(), stack.pop().assert()) { (Number(0), Number(0)) => stack.push(Number(0)), (Number(_), Number(_)) => stack.push(Number(1)), _ => return Err("non-numbers on stack with logical or".to_string()) } } else { return Err("stack is empty".to_string()) }, '!' => if stack.len() > 0 { - match stack.pop().unwrap() { + match stack.pop().assert() { Number(0) => stack.push(Number(1)), Number(_) => stack.push(Number(0)), _ => return Err("non-number on stack with logical not".to_string()) } } else { return Err("stack is empty".to_string()) }, '~' => if stack.len() > 0 { - match stack.pop().unwrap() { + match stack.pop().assert() { Number(x) => stack.push(Number(!x)), _ => return Err("non-number on stack with %~".to_string()) } @@ -252,9 +252,9 @@ pub fn expand(cap: &[u8], params: &[Param], vars: &mut Variables) // printf-style support for %doxXs 'd'|'o'|'x'|'X'|'s' => if stack.len() > 0 { let flags = Flags::new(); - let res = format(stack.pop().unwrap(), FormatOp::from_char(cur), flags); + let res = format(stack.pop().assert(), FormatOp::from_char(cur), flags); if res.is_err() { return res } - output.push_all(res.unwrap().as_slice()) + output.push_all(res.assert().as_slice()) } else { return Err("stack is empty".to_string()) }, ':'|'#'|' '|'.'|'0'..'9' => { let mut flags = Flags::new(); @@ -276,7 +276,7 @@ pub fn expand(cap: &[u8], params: &[Param], vars: &mut Variables) // conditionals '?' => (), 't' => if stack.len() > 0 { - match stack.pop().unwrap() { + match stack.pop().assert() { Number(0) => state = SeekIfElse(0), Number(_) => (), _ => return Err("non-number on stack \ @@ -302,12 +302,12 @@ pub fn expand(cap: &[u8], params: &[Param], vars: &mut Variables) if cur >= 'A' && cur <= 'Z' { if stack.len() > 0 { let idx = (cur as u8) - b'A'; - vars.sta[idx as uint] = stack.pop().unwrap(); + vars.sta[idx as uint] = stack.pop().assert(); } else { return Err("stack is empty".to_string()) } } else if cur >= 'a' && cur <= 'z' { if stack.len() > 0 { let idx = (cur as u8) - b'a'; - vars.dyn[idx as uint] = stack.pop().unwrap(); + vars.dyn[idx as uint] = stack.pop().assert(); } else { return Err("stack is empty".to_string()) } } else { return Err("bad variable name in %P".to_string()); @@ -350,9 +350,9 @@ pub fn expand(cap: &[u8], params: &[Param], vars: &mut Variables) old_state = Nothing; match (*fstate, cur) { (_,'d')|(_,'o')|(_,'x')|(_,'X')|(_,'s') => if stack.len() > 0 { - let res = format(stack.pop().unwrap(), FormatOp::from_char(cur), *flags); + let res = format(stack.pop().assert(), FormatOp::from_char(cur), *flags); if res.is_err() { return res } - output.push_all(res.unwrap().as_slice()); + output.push_all(res.assert().as_slice()); // will cause state to go to Nothing old_state = FormatPattern(*flags, *fstate); } else { return Err("stack is empty".to_string()) }, @@ -501,7 +501,7 @@ fn format(val: Param, op: FormatOp, flags: Flags) -> Result<Vec<u8> ,String> { return Err("non-number on stack with %s".to_string()) } }; - let mut s: Vec<u8> = s.move_iter().collect(); + let mut s: Vec<u8> = s.iter_owned().collect(); if flags.precision > s.len() { let mut s_ = Vec::with_capacity(flags.precision); let n = flags.precision - s.len(); @@ -532,7 +532,7 @@ fn format(val: Param, op: FormatOp, flags: Flags) -> Result<Vec<u8> ,String> { .to_ascii() .to_upper() .into_bytes() - .move_iter() + .iter_owned() .collect(); if flags.alternate { let s_ = replace(&mut s, vec!(b'0', b'X')); @@ -581,13 +581,13 @@ mod test { #[test] fn test_basic_setabf() { let s = b"\\E[48;5;%p1%dm"; - assert_eq!(expand(s, [Number(1)], &mut Variables::new()).unwrap(), + assert_eq!(expand(s, [Number(1)], &mut Variables::new()).assert(), "\\E[48;5;1m".bytes().collect()); } #[test] fn test_multiple_int_constants() { - assert_eq!(expand(b"%{1}%{2}%d%d", [], &mut Variables::new()).unwrap(), + assert_eq!(expand(b"%{1}%{2}%d%d", [], &mut Variables::new()).assert(), "21".bytes().collect()); } @@ -620,7 +620,7 @@ mod test { [p], vars); assert!(res.is_ok(), - "Op {} failed with 1 stack entry: {}", *cap, res.unwrap_err()); + "Op {} failed with 1 stack entry: {}", *cap, res.assert_err()); } let caps = ["%+", "%-", "%*", "%/", "%m", "%&", "%|", "%A", "%O"]; for cap in caps.iter() { @@ -638,7 +638,7 @@ mod test { [], vars); assert!(res.is_ok(), - "Binop {} failed with 2 stack entries: {}", *cap, res.unwrap_err()); + "Binop {} failed with 2 stack entries: {}", *cap, res.assert_err()); } } @@ -653,16 +653,16 @@ mod test { for &(op, bs) in v.iter() { 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(), vec!(b'0' + bs[0])); + assert!(res.is_ok(), res.assert_err()); + assert_eq!(res.assert(), vec!(b'0' + 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(), vec!(b'0' + bs[1])); + assert!(res.is_ok(), res.assert_err()); + assert_eq!(res.assert(), vec!(b'0' + 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(), vec!(b'0' + bs[2])); + assert!(res.is_ok(), res.assert_err()); + assert_eq!(res.assert(), vec!(b'0' + bs[2])); } } @@ -671,16 +671,16 @@ mod test { let mut vars = Variables::new(); let s = b"\\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(), + assert!(res.is_ok(), res.assert_err()); + assert_eq!(res.assert(), "\\E[31m".bytes().collect()); let res = expand(s, [Number(8)], &mut vars); - assert!(res.is_ok(), res.unwrap_err()); - assert_eq!(res.unwrap(), + assert!(res.is_ok(), res.assert_err()); + assert_eq!(res.assert(), "\\E[90m".bytes().collect()); let res = expand(s, [Number(42)], &mut vars); - assert!(res.is_ok(), res.unwrap_err()); - assert_eq!(res.unwrap(), + assert!(res.is_ok(), res.assert_err()); + assert_eq!(res.assert(), "\\E[38;5;42m".bytes().collect()); } diff --git a/src/libterm/terminfo/parser/compiled.rs b/src/libterm/terminfo/parser/compiled.rs index 94ed7fbbf306e..653037002cd2e 100644 --- a/src/libterm/terminfo/parser/compiled.rs +++ b/src/libterm/terminfo/parser/compiled.rs @@ -342,6 +342,6 @@ mod test { #[ignore(reason = "no ncurses on buildbots, needs a bundled terminfo file to test against")] fn test_parse() { // FIXME #6870: Distribute a compiled file in src/tests and test there - // parse(io::fs_reader(&p("/usr/share/terminfo/r/rxvt-256color")).unwrap(), false); + // parse(io::fs_reader(&p("/usr/share/terminfo/r/rxvt-256color")).assert(), false); } } diff --git a/src/libterm/terminfo/searcher.rs b/src/libterm/terminfo/searcher.rs index ebec59924e8f3..07e5f367c916d 100644 --- a/src/libterm/terminfo/searcher.rs +++ b/src/libterm/terminfo/searcher.rs @@ -33,7 +33,7 @@ pub fn get_dbpath_for_term(term: &str) -> Option<Box<Path>> { None => { if homedir.is_some() { // ncurses compatibility; - dirs_to_search.push(homedir.unwrap().join(".terminfo")) + dirs_to_search.push(homedir.assert().join(".terminfo")) } match getenv("TERMINFO_DIRS") { Some(dirs) => for i in dirs.as_slice().split(':') { @@ -99,7 +99,7 @@ fn test_get_dbpath_for_term() { // FIXME (#9639): This needs to handle non-utf8 paths fn x(t: &str) -> String { let p = get_dbpath_for_term(t).expect("no terminfo entry found"); - p.as_str().unwrap().to_string() + p.as_str().assert().to_string() }; assert!(x("screen") == "/usr/share/terminfo/s/screen".to_string()); assert!(get_dbpath_for_term("") == None); @@ -111,7 +111,7 @@ fn test_get_dbpath_for_term() { #[test] #[ignore(reason = "see test_get_dbpath_for_term")] fn test_open() { - open("screen").unwrap(); + open("screen").assert(); let t = open("nonexistent terminal that hopefully does not exist"); assert!(t.is_err()); } diff --git a/src/libtest/lib.rs b/src/libtest/lib.rs index 46e2ca03ef6ed..1d978d9300ea5 100644 --- a/src/libtest/lib.rs +++ b/src/libtest/lib.rs @@ -396,7 +396,7 @@ pub fn parse_opts(args: &[String]) -> Option<OptRes> { let ratchet_noise_percent = matches.opt_str("ratchet-noise-percent"); let ratchet_noise_percent = - ratchet_noise_percent.map(|s| from_str::<f64>(s.as_slice()).unwrap()); + ratchet_noise_percent.map(|s| from_str::<f64>(s.as_slice()).assert()); let save_metrics = matches.opt_str("save-metrics"); let save_metrics = save_metrics.map(|s| Path::new(s)); @@ -869,14 +869,14 @@ fn should_sort_failures_before_printing_them() { failures: vec!((test_b, Vec::new()), (test_a, Vec::new())) }; - st.write_failures().unwrap(); + st.write_failures().assert(); let s = match st.out { - Raw(ref m) => String::from_utf8_lossy(m.get_ref()), + Raw(ref m) => String::from_utf8_lossy(m.as_ref().assert()), Pretty(_) => unreachable!() }; - let apos = s.as_slice().find_str("a").unwrap(); - let bpos = s.as_slice().find_str("b").unwrap(); + let apos = s.as_slice().find_str("a").assert(); + let bpos = s.as_slice().find_str("b").assert(); assert!(apos < bpos); } @@ -927,7 +927,7 @@ fn run_tests(opts: &TestOpts, while pending > 0 || !remaining.is_empty() { while pending < concurrency && !remaining.is_empty() { - let test = remaining.pop().unwrap(); + let test = remaining.pop().assert(); if concurrency == 1 { // We are doing one test at a time so we can print the name // of the test before we run it. Useful for debugging tests @@ -948,7 +948,7 @@ fn run_tests(opts: &TestOpts, // All benchmarks run at the end, in serial. // (this includes metric fns) - for b in filtered_benchs_and_metrics.move_iter() { + for b in filtered_benchs_and_metrics.iter_owned() { try!(callback(TeWait(b.desc.clone(), b.testfn.padding()))); run_test(opts, !opts.run_benchmarks, b, tx.clone()); let (test, result, stdout) = rx.recv(); @@ -980,7 +980,7 @@ pub fn filter_tests(opts: &TestOpts, tests: Vec<TestDescAndFn>) -> Vec<TestDescA filtered = match opts.filter { None => filtered, Some(ref re) => { - filtered.move_iter() + filtered.iter_owned() .filter(|test| re.is_match(test.desc.name.as_slice())).collect() } }; @@ -1000,7 +1000,7 @@ pub fn filter_tests(opts: &TestOpts, tests: Vec<TestDescAndFn>) -> Vec<TestDescA None } }; - filtered.move_iter().filter_map(|x| filter(x)).collect() + filtered.iter_owned().filter_map(|x| filter(x)).collect() }; // Sort the tests alphabetically @@ -1010,7 +1010,7 @@ pub fn filter_tests(opts: &TestOpts, tests: Vec<TestDescAndFn>) -> Vec<TestDescA match opts.test_shard { None => filtered, Some((a,b)) => { - filtered.move_iter().enumerate() + filtered.iter_owned().enumerate() // note: using a - 1 so that the valid shards, for example, are // 1.2 and 2.2 instead of 0.2 and 1.2 .filter(|&(i,_)| i % b == (a - 1)) @@ -1053,7 +1053,7 @@ pub fn run_test(opts: &TestOpts, } let result_future = task.try_future(testfn); - let stdout = reader.read_to_end().unwrap().move_iter().collect(); + let stdout = reader.read_to_end().assert().iter_owned().collect(); let task_result = result_future.unwrap(); let test_result = calc_result(&desc, task_result.is_ok()); monitor_ch.send((desc.clone(), test_result, stdout)); @@ -1124,8 +1124,8 @@ impl MetricMap { /// contain a valid metric map. pub fn load(p: &Path) -> MetricMap { assert!(p.exists()); - let mut f = File::open(p).unwrap(); - let value = json::from_reader(&mut f as &mut io::Reader).unwrap(); + let mut f = File::open(p).assert(); + let value = json::from_reader(&mut f as &mut io::Reader).assert(); let mut decoder = json::Decoder::new(value); MetricMap(match Decodable::decode(&mut decoder) { Ok(t) => t, @@ -1248,7 +1248,7 @@ impl MetricMap { }); if ok { - self.save(p).unwrap(); + self.save(p).assert(); } return (diff, ok) } @@ -1327,7 +1327,7 @@ impl Bencher { loop { let loop_start = precise_time_ns(); - for p in samples.mut_iter() { + for p in samples.iter_mut() { self.bench_n(n, |x| f(x)); *p = self.ns_per_iter() as f64; }; @@ -1335,7 +1335,7 @@ impl Bencher { stats::winsorize(samples, 5.0); let summ = stats::Summary::new(samples); - for p in samples.mut_iter() { + for p in samples.iter_mut() { self.bench_n(5 * n, |x| f(x)); *p = self.ns_per_iter() as f64; }; @@ -1576,7 +1576,7 @@ mod tests { #[test] pub fn filter_tests_regex() { let mut opts = TestOpts::new(); - opts.filter = Some(::regex::Regex::new("a.*b.+c").unwrap()); + opts.filter = Some(::regex::Regex::new("a.*b.+c").assert()); let mut names = ["yes::abXc", "yes::aXXXbXXXXc", "no::XYZ", "no::abc"]; @@ -1628,31 +1628,31 @@ mod tests { let diff1 = m2.compare_to_old(&m1, None); - assert_eq!(*(diff1.find(&"in-both-noise".to_string()).unwrap()), LikelyNoise); - assert_eq!(*(diff1.find(&"in-first-noise".to_string()).unwrap()), MetricRemoved); - assert_eq!(*(diff1.find(&"in-second-noise".to_string()).unwrap()), MetricAdded); - assert_eq!(*(diff1.find(&"in-both-want-downwards-but-regressed".to_string()).unwrap()), + assert_eq!(*(diff1.find(&"in-both-noise".to_string()).assert()), LikelyNoise); + assert_eq!(*(diff1.find(&"in-first-noise".to_string()).assert()), MetricRemoved); + assert_eq!(*(diff1.find(&"in-second-noise".to_string()).assert()), MetricAdded); + assert_eq!(*(diff1.find(&"in-both-want-downwards-but-regressed".to_string()).assert()), Regression(100.0)); - assert_eq!(*(diff1.find(&"in-both-want-downwards-and-improved".to_string()).unwrap()), + assert_eq!(*(diff1.find(&"in-both-want-downwards-and-improved".to_string()).assert()), Improvement(50.0)); - assert_eq!(*(diff1.find(&"in-both-want-upwards-but-regressed".to_string()).unwrap()), + assert_eq!(*(diff1.find(&"in-both-want-upwards-but-regressed".to_string()).assert()), Regression(50.0)); - assert_eq!(*(diff1.find(&"in-both-want-upwards-and-improved".to_string()).unwrap()), + assert_eq!(*(diff1.find(&"in-both-want-upwards-and-improved".to_string()).assert()), Improvement(100.0)); assert_eq!(diff1.len(), 7); let diff2 = m2.compare_to_old(&m1, Some(200.0)); - assert_eq!(*(diff2.find(&"in-both-noise".to_string()).unwrap()), LikelyNoise); - assert_eq!(*(diff2.find(&"in-first-noise".to_string()).unwrap()), MetricRemoved); - assert_eq!(*(diff2.find(&"in-second-noise".to_string()).unwrap()), MetricAdded); - assert_eq!(*(diff2.find(&"in-both-want-downwards-but-regressed".to_string()).unwrap()), + assert_eq!(*(diff2.find(&"in-both-noise".to_string()).assert()), LikelyNoise); + assert_eq!(*(diff2.find(&"in-first-noise".to_string()).assert()), MetricRemoved); + assert_eq!(*(diff2.find(&"in-second-noise".to_string()).assert()), MetricAdded); + assert_eq!(*(diff2.find(&"in-both-want-downwards-but-regressed".to_string()).assert()), LikelyNoise); - assert_eq!(*(diff2.find(&"in-both-want-downwards-and-improved".to_string()).unwrap()), + assert_eq!(*(diff2.find(&"in-both-want-downwards-and-improved".to_string()).assert()), LikelyNoise); - assert_eq!(*(diff2.find(&"in-both-want-upwards-but-regressed".to_string()).unwrap()), + assert_eq!(*(diff2.find(&"in-both-want-upwards-but-regressed".to_string()).assert()), LikelyNoise); - assert_eq!(*(diff2.find(&"in-both-want-upwards-and-improved".to_string()).unwrap()), + assert_eq!(*(diff2.find(&"in-both-want-upwards-and-improved".to_string()).assert()), LikelyNoise); assert_eq!(diff2.len(), 7); } @@ -1671,35 +1671,35 @@ mod tests { m2.insert_metric("runtime", 1100.0, 2.0); m2.insert_metric("throughput", 50.0, 2.0); - m1.save(&pth).unwrap(); + m1.save(&pth).assert(); // Ask for a ratchet that should fail to advance. let (diff1, ok1) = m2.ratchet(&pth, None); assert_eq!(ok1, false); assert_eq!(diff1.len(), 2); - assert_eq!(*(diff1.find(&"runtime".to_string()).unwrap()), Regression(10.0)); - assert_eq!(*(diff1.find(&"throughput".to_string()).unwrap()), LikelyNoise); + assert_eq!(*(diff1.find(&"runtime".to_string()).assert()), Regression(10.0)); + assert_eq!(*(diff1.find(&"throughput".to_string()).assert()), LikelyNoise); // Check that it was not rewritten. let m3 = MetricMap::load(&pth); let MetricMap(m3) = m3; assert_eq!(m3.len(), 2); - assert_eq!(*(m3.find(&"runtime".to_string()).unwrap()), Metric::new(1000.0, 2.0)); - assert_eq!(*(m3.find(&"throughput".to_string()).unwrap()), Metric::new(50.0, 2.0)); + assert_eq!(*(m3.find(&"runtime".to_string()).assert()), Metric::new(1000.0, 2.0)); + assert_eq!(*(m3.find(&"throughput".to_string()).assert()), Metric::new(50.0, 2.0)); // Ask for a ratchet with an explicit noise-percentage override, // that should advance. let (diff2, ok2) = m2.ratchet(&pth, Some(10.0)); assert_eq!(ok2, true); assert_eq!(diff2.len(), 2); - assert_eq!(*(diff2.find(&"runtime".to_string()).unwrap()), LikelyNoise); - assert_eq!(*(diff2.find(&"throughput".to_string()).unwrap()), LikelyNoise); + assert_eq!(*(diff2.find(&"runtime".to_string()).assert()), LikelyNoise); + assert_eq!(*(diff2.find(&"throughput".to_string()).assert()), LikelyNoise); // Check that it was rewritten. let m4 = MetricMap::load(&pth); let MetricMap(m4) = m4; assert_eq!(m4.len(), 2); - assert_eq!(*(m4.find(&"runtime".to_string()).unwrap()), Metric::new(1100.0, 2.0)); - assert_eq!(*(m4.find(&"throughput".to_string()).unwrap()), Metric::new(50.0, 2.0)); + assert_eq!(*(m4.find(&"runtime".to_string()).assert()), Metric::new(1100.0, 2.0)); + assert_eq!(*(m4.find(&"throughput".to_string()).assert()), Metric::new(50.0, 2.0)); } } diff --git a/src/libtest/stats.rs b/src/libtest/stats.rs index 9af28e771e1fb..844f7652082e9 100644 --- a/src/libtest/stats.rs +++ b/src/libtest/stats.rs @@ -212,11 +212,11 @@ impl<'a, T: FloatMath + FromPrimitive> Stats<T> for &'a [T] { fn mean(self) -> T { assert!(self.len() != 0); - self.sum() / FromPrimitive::from_uint(self.len()).unwrap() + self.sum() / FromPrimitive::from_uint(self.len()).assert() } fn median(self) -> T { - self.percentile(FromPrimitive::from_uint(50).unwrap()) + self.percentile(FromPrimitive::from_uint(50).assert()) } fn var(self) -> T { @@ -232,7 +232,7 @@ impl<'a, T: FloatMath + FromPrimitive> Stats<T> for &'a [T] { // NB: this is _supposed to be_ len-1, not len. If you // change it back to len, you will be calculating a // population variance, not a sample variance. - let denom = FromPrimitive::from_uint(self.len()-1).unwrap(); + let denom = FromPrimitive::from_uint(self.len()-1).assert(); v/denom } } @@ -242,7 +242,7 @@ impl<'a, T: FloatMath + FromPrimitive> Stats<T> for &'a [T] { } fn std_dev_pct(self) -> T { - let hundred = FromPrimitive::from_uint(100).unwrap(); + let hundred = FromPrimitive::from_uint(100).assert(); (self.std_dev() / self.mean()) * hundred } @@ -251,12 +251,12 @@ impl<'a, T: FloatMath + FromPrimitive> Stats<T> for &'a [T] { let abs_devs: Vec<T> = self.iter().map(|&v| num::abs(med - v)).collect(); // This constant is derived by smarter statistics brains than me, but it is // consistent with how R and other packages treat the MAD. - let number = FromPrimitive::from_f64(1.4826).unwrap(); + let number = FromPrimitive::from_f64(1.4826).assert(); abs_devs.as_slice().median() * number } fn median_abs_dev_pct(self) -> T { - let hundred = FromPrimitive::from_uint(100).unwrap(); + let hundred = FromPrimitive::from_uint(100).assert(); (self.median_abs_dev() / self.median()) * hundred } @@ -269,11 +269,11 @@ impl<'a, T: FloatMath + FromPrimitive> Stats<T> for &'a [T] { fn quartiles(self) -> (T,T,T) { let mut tmp = Vec::from_slice(self); local_sort(tmp.as_mut_slice()); - let first = FromPrimitive::from_uint(25).unwrap(); + let first = FromPrimitive::from_uint(25).assert(); let a = percentile_of_sorted(tmp.as_slice(), first); - let secound = FromPrimitive::from_uint(50).unwrap(); + let secound = FromPrimitive::from_uint(50).assert(); let b = percentile_of_sorted(tmp.as_slice(), secound); - let third = FromPrimitive::from_uint(75).unwrap(); + let third = FromPrimitive::from_uint(75).assert(); let c = percentile_of_sorted(tmp.as_slice(), third); (a,b,c) } @@ -295,16 +295,16 @@ fn percentile_of_sorted<T: Float + FromPrimitive>(sorted_samples: &[T], } let zero: T = Zero::zero(); assert!(zero <= pct); - let hundred = FromPrimitive::from_uint(100).unwrap(); + let hundred = FromPrimitive::from_uint(100).assert(); assert!(pct <= hundred); if pct == hundred { return sorted_samples[sorted_samples.len() - 1]; } - let length = FromPrimitive::from_uint(sorted_samples.len() - 1).unwrap(); + let length = FromPrimitive::from_uint(sorted_samples.len() - 1).assert(); let rank = (pct / hundred) * length; let lrank = rank.floor(); let d = rank - lrank; - let n = lrank.to_uint().unwrap(); + let n = lrank.to_uint().assert(); let lo = sorted_samples[n]; let hi = sorted_samples[n+1]; lo + (hi - lo) * d @@ -321,9 +321,9 @@ pub fn winsorize<T: Float + FromPrimitive>(samples: &mut [T], pct: T) { let mut tmp = Vec::from_slice(samples); local_sort(tmp.as_mut_slice()); let lo = percentile_of_sorted(tmp.as_slice(), pct); - let hundred: T = FromPrimitive::from_uint(100).unwrap(); + let hundred: T = FromPrimitive::from_uint(100).assert(); let hi = percentile_of_sorted(tmp.as_slice(), hundred-pct); - for samp in samples.mut_iter() { + for samp in samples.iter_mut() { if *samp > hi { *samp = hi } else if *samp < lo { @@ -365,7 +365,7 @@ pub fn write_boxplot<T: Float + Show + FromPrimitive>( let (q1,q2,q3) = s.quartiles; // the .abs() handles the case where numbers are negative - let ten: T = FromPrimitive::from_uint(10).unwrap(); + let ten: T = FromPrimitive::from_uint(10).assert(); let lomag = ten.powf(s.min.abs().log10().floor()); let himag = ten.powf(s.max.abs().log10().floor()); @@ -390,7 +390,7 @@ pub fn write_boxplot<T: Float + Show + FromPrimitive>( let overhead_width = lostr.len() + histr.len() + 4; let range_width = width_hint - overhead_width; - let range_float = FromPrimitive::from_uint(range_width).unwrap(); + let range_float = FromPrimitive::from_uint(range_width).assert(); let char_step = range / range_float; try!(write!(w, "{} |", lostr)); @@ -473,11 +473,11 @@ mod tests { let mut w = io::stdout(); let w = &mut w as &mut io::Writer; - (write!(w, "\n")).unwrap(); - write_5_number_summary(w, &summ2).unwrap(); - (write!(w, "\n")).unwrap(); - write_boxplot(w, &summ2, 50).unwrap(); - (write!(w, "\n")).unwrap(); + (write!(w, "\n")).assert(); + write_5_number_summary(w, &summ2).assert(); + (write!(w, "\n")).assert(); + write_boxplot(w, &summ2, 50).assert(); + (write!(w, "\n")).assert(); assert_eq!(summ.sum, summ2.sum); assert_eq!(summ.min, summ2.min); @@ -1028,8 +1028,8 @@ mod tests { fn t(s: &Summary<f64>, expected: String) { use std::io::MemWriter; let mut m = MemWriter::new(); - write_boxplot(&mut m as &mut io::Writer, s, 30).unwrap(); - let out = String::from_utf8(m.unwrap()).unwrap(); + write_boxplot(&mut m as &mut io::Writer, s, 30).assert(); + let out = String::from_utf8(m.assert()).assert(); assert_eq!(out, expected); } diff --git a/src/libtime/lib.rs b/src/libtime/lib.rs index 56a22bb2addeb..2e3060003d024 100644 --- a/src/libtime/lib.rs +++ b/src/libtime/lib.rs @@ -126,7 +126,7 @@ pub fn get_time() -> Timespec { unsafe fn os_get_time() -> (i64, i32) { use std::ptr; let mut tv = libc::timeval { tv_sec: 0, tv_usec: 0 }; - imp::gettimeofday(&mut tv, ptr::mut_null()); + imp::gettimeofday(&mut tv, ptr::null_mut()); (tv.tv_sec as i64, tv.tv_usec * 1000) } @@ -823,7 +823,7 @@ pub fn strptime(s: &str, format: &str) -> Result<Tm, String> { } } - if pos == len && rdr.tell().unwrap() == format.len() as u64 { + if pos == len && rdr.tell().assert() == format.len() as u64 { Ok(Tm { tm_sec: tm.tm_sec, tm_min: tm.tm_min, @@ -1061,7 +1061,7 @@ pub fn strftime(format: &str, tm: &Tm) -> String { }; match ch as char { '%' => { - rdr.read(b).unwrap(); + rdr.read(b).assert(); let s = parse_type(b[0] as char, tm); buf.push_all(s.as_bytes()); } @@ -1069,7 +1069,7 @@ pub fn strftime(format: &str, tm: &Tm) -> String { } } - String::from_utf8(buf).unwrap() + String::from_utf8(buf).assert() } #[cfg(test)] @@ -1359,9 +1359,9 @@ mod tests { assert!(test("6", "%w")); assert!(test("2009", "%Y")); assert!(test("09", "%y")); - assert!(strptime("-0000", "%z").unwrap().tm_gmtoff == + assert!(strptime("-0000", "%z").assert().tm_gmtoff == 0); - assert!(strptime("-0800", "%z").unwrap().tm_gmtoff == + assert!(strptime("-0800", "%z").assert().tm_gmtoff == 0); assert!(test("%", "%%")); diff --git a/src/libunicode/u_str.rs b/src/libunicode/u_str.rs index 2e656a5a420d3..a3b2f7b539564 100644 --- a/src/libunicode/u_str.rs +++ b/src/libunicode/u_str.rs @@ -242,7 +242,7 @@ impl<'a> Iterator<&'a str> for Graphemes<'a> { // looking up each character twice. cat = match self.cat { None => gr::grapheme_category(ch), - _ => self.cat.take_unwrap() + _ => self.cat.take().assert() }; if match cat { @@ -342,7 +342,7 @@ impl<'a> DoubleEndedIterator<&'a str> for Graphemes<'a> { // cached category, if any cat = match self.catb { None => gr::grapheme_category(ch), - _ => self.catb.take_unwrap() + _ => self.catb.take().assert() }; // a matching state machine that runs *backwards* across an input string diff --git a/src/liburl/lib.rs b/src/liburl/lib.rs index 0221b95b40434..87396fb480882 100644 --- a/src/liburl/lib.rs +++ b/src/liburl/lib.rs @@ -273,7 +273,7 @@ fn decode_inner<T: BytesContainer>(c: T, full_url: bool) -> DecodeResult<String> }; // Only decode some characters if full_url: - match uint::parse_bytes(bytes, 16u).unwrap() as u8 as char { + match uint::parse_bytes(bytes, 16u).assert() as u8 as char { // gen-delims: ':' | '/' | '?' | '#' | '[' | ']' | '@' | @@ -373,7 +373,7 @@ pub fn decode_form_urlencoded(s: &[u8]) '%' without two trailing bytes")) }; - uint::parse_bytes(bytes, 16u).unwrap() as u8 as char + uint::parse_bytes(bytes, 16u).assert() as u8 as char } '+' => ' ', ch => ch @@ -794,20 +794,20 @@ fn test_split_char_first() { #[test] fn test_get_authority() { let (u, h, p, r) = get_authority( - "//user:pass@rust-lang.org/something").unwrap(); + "//user:pass@rust-lang.org/something").assert(); assert_eq!(u, Some(UserInfo::new("user".to_string(), Some("pass".to_string())))); assert_eq!(h, "rust-lang.org"); assert!(p.is_none()); assert_eq!(r, "/something"); let (u, h, p, r) = get_authority( - "//rust-lang.org:8000?something").unwrap(); + "//rust-lang.org:8000?something").assert(); assert!(u.is_none()); assert_eq!(h, "rust-lang.org"); assert_eq!(p, Some(8000)); assert_eq!(r, "?something"); - let (u, h, p, r) = get_authority("//rust-lang.org#blah").unwrap(); + let (u, h, p, r) = get_authority("//rust-lang.org#blah").assert(); assert!(u.is_none()); assert_eq!(h, "rust-lang.org"); assert!(p.is_none()); @@ -815,17 +815,17 @@ fn test_get_authority() { // ipv6 tests let (_, h, _, _) = get_authority( - "//2001:0db8:85a3:0042:0000:8a2e:0370:7334#blah").unwrap(); + "//2001:0db8:85a3:0042:0000:8a2e:0370:7334#blah").assert(); assert_eq!(h, "2001:0db8:85a3:0042:0000:8a2e:0370:7334"); let (_, h, p, _) = get_authority( - "//2001:0db8:85a3:0042:0000:8a2e:0370:7334:8000#blah").unwrap(); + "//2001:0db8:85a3:0042:0000:8a2e:0370:7334:8000#blah").assert(); assert_eq!(h, "2001:0db8:85a3:0042:0000:8a2e:0370:7334"); assert_eq!(p, Some(8000)); let (u, h, p, _) = get_authority( "//us:p@2001:0db8:85a3:0042:0000:8a2e:0370:7334:8000#blah" - ).unwrap(); + ).assert(); assert_eq!(u, Some(UserInfo::new("us".to_string(), Some("p".to_string())))); assert_eq!(h, "2001:0db8:85a3:0042:0000:8a2e:0370:7334"); assert_eq!(p, Some(8000)); @@ -841,21 +841,21 @@ fn test_get_authority() { assert!(get_authority("//user:pass@rust-lang:65536").is_err()); // these parse as empty, because they don't start with '//' - let (_, h, _, _) = get_authority("user:pass@rust-lang").unwrap(); + let (_, h, _, _) = get_authority("user:pass@rust-lang").assert(); assert_eq!(h, ""); - let (_, h, _, _) = get_authority("rust-lang.org").unwrap(); + let (_, h, _, _) = get_authority("rust-lang.org").assert(); assert_eq!(h, ""); } #[test] fn test_get_path() { - let (p, r) = get_path("/something+%20orother", true).unwrap(); + let (p, r) = get_path("/something+%20orother", true).assert(); assert_eq!(p, "/something+ orother".to_string()); assert_eq!(r, ""); - let (p, r) = get_path("test@email.com#fragment", false).unwrap(); + let (p, r) = get_path("test@email.com#fragment", false).assert(); assert_eq!(p, "test@email.com".to_string()); assert_eq!(r, "#fragment"); - let (p, r) = get_path("/gen/:addr=?q=v", false).unwrap(); + let (p, r) = get_path("/gen/:addr=?q=v", false).assert(); assert_eq!(p, "/gen/:addr=".to_string()); assert_eq!(r, "?q=v"); @@ -874,7 +874,7 @@ mod tests { #[test] fn test_url_parse() { let url = "http://user:pass@rust-lang.org:8080/doc/~u?s=v#something"; - let u = from_str::<Url>(url).unwrap(); + let u = from_str::<Url>(url).assert(); assert_eq!(u.scheme, "http".to_string()); assert_eq!(u.user, Some(UserInfo::new("user".to_string(), Some("pass".to_string())))); @@ -888,7 +888,7 @@ mod tests { #[test] fn test_path_parse() { let path = "/doc/~u?s=v#something"; - let u = from_str::<Path>(path).unwrap(); + let u = from_str::<Path>(path).assert(); assert_eq!(u.path, "/doc/~u".to_string()); assert_eq!(u.query, vec!(("s".to_string(), "v".to_string()))); @@ -898,7 +898,7 @@ mod tests { #[test] fn test_url_parse_host_slash() { let urlstr = "http://0.42.42.42/"; - let url = from_str::<Url>(urlstr).unwrap(); + let url = from_str::<Url>(urlstr).assert(); assert_eq!(url.host, "0.42.42.42".to_string()); assert_eq!(url.path.path, "/".to_string()); } @@ -906,14 +906,14 @@ mod tests { #[test] fn test_path_parse_host_slash() { let pathstr = "/"; - let path = from_str::<Path>(pathstr).unwrap(); + let path = from_str::<Path>(pathstr).assert(); assert_eq!(path.path, "/".to_string()); } #[test] fn test_url_host_with_port() { let urlstr = "scheme://host:1234"; - let url = from_str::<Url>(urlstr).unwrap(); + let url = from_str::<Url>(urlstr).assert(); assert_eq!(url.scheme, "scheme".to_string()); assert_eq!(url.host, "host".to_string()); assert_eq!(url.port, Some(1234)); @@ -921,7 +921,7 @@ mod tests { assert_eq!(url.path.path, "".to_string()); let urlstr = "scheme://host:1234/"; - let url = from_str::<Url>(urlstr).unwrap(); + let url = from_str::<Url>(urlstr).assert(); assert_eq!(url.scheme, "scheme".to_string()); assert_eq!(url.host, "host".to_string()); assert_eq!(url.port, Some(1234)); @@ -931,28 +931,28 @@ mod tests { #[test] fn test_url_with_underscores() { let urlstr = "http://dotcom.com/file_name.html"; - let url = from_str::<Url>(urlstr).unwrap(); + let url = from_str::<Url>(urlstr).assert(); assert_eq!(url.path.path, "/file_name.html".to_string()); } #[test] fn test_path_with_underscores() { let pathstr = "/file_name.html"; - let path = from_str::<Path>(pathstr).unwrap(); + let path = from_str::<Path>(pathstr).assert(); assert_eq!(path.path, "/file_name.html".to_string()); } #[test] fn test_url_with_dashes() { let urlstr = "http://dotcom.com/file-name.html"; - let url = from_str::<Url>(urlstr).unwrap(); + let url = from_str::<Url>(urlstr).assert(); assert_eq!(url.path.path, "/file-name.html".to_string()); } #[test] fn test_path_with_dashes() { let pathstr = "/file-name.html"; - let path = from_str::<Path>(pathstr).unwrap(); + let path = from_str::<Path>(pathstr).assert(); assert_eq!(path.path, "/file-name.html".to_string()); } @@ -970,21 +970,21 @@ mod tests { #[test] fn test_full_url_parse_and_format() { let url = "http://user:pass@rust-lang.org/doc?s=v#something"; - let u = from_str::<Url>(url).unwrap(); + let u = from_str::<Url>(url).assert(); assert_eq!(format!("{}", u).as_slice(), url); } #[test] fn test_userless_url_parse_and_format() { let url = "http://rust-lang.org/doc?s=v#something"; - let u = from_str::<Url>(url).unwrap(); + let u = from_str::<Url>(url).assert(); assert_eq!(format!("{}", u).as_slice(), url); } #[test] fn test_queryless_url_parse_and_format() { let url = "http://user:pass@rust-lang.org/doc#something"; - let u = from_str::<Url>(url).unwrap(); + let u = from_str::<Url>(url).assert(); assert_eq!(format!("{}", u).as_slice(), url); } @@ -992,56 +992,56 @@ mod tests { fn test_empty_query_url_parse_and_format() { let url = "http://user:pass@rust-lang.org/doc?#something"; let should_be = "http://user:pass@rust-lang.org/doc#something"; - let u = from_str::<Url>(url).unwrap(); + let u = from_str::<Url>(url).assert(); assert_eq!(format!("{}", u).as_slice(), should_be); } #[test] fn test_fragmentless_url_parse_and_format() { let url = "http://user:pass@rust-lang.org/doc?q=v"; - let u = from_str::<Url>(url).unwrap(); + let u = from_str::<Url>(url).assert(); assert_eq!(format!("{}", u).as_slice(), url); } #[test] fn test_minimal_url_parse_and_format() { let url = "http://rust-lang.org/doc"; - let u = from_str::<Url>(url).unwrap(); + let u = from_str::<Url>(url).assert(); assert_eq!(format!("{}", u).as_slice(), url); } #[test] fn test_url_with_port_parse_and_format() { let url = "http://rust-lang.org:80/doc"; - let u = from_str::<Url>(url).unwrap(); + let u = from_str::<Url>(url).assert(); assert_eq!(format!("{}", u).as_slice(), url); } #[test] fn test_scheme_host_only_url_parse_and_format() { let url = "http://rust-lang.org"; - let u = from_str::<Url>(url).unwrap(); + let u = from_str::<Url>(url).assert(); assert_eq!(format!("{}", u).as_slice(), url); } #[test] fn test_pathless_url_parse_and_format() { let url = "http://user:pass@rust-lang.org?q=v#something"; - let u = from_str::<Url>(url).unwrap(); + let u = from_str::<Url>(url).assert(); assert_eq!(format!("{}", u).as_slice(), url); } #[test] fn test_scheme_host_fragment_only_url_parse_and_format() { let url = "http://rust-lang.org#something"; - let u = from_str::<Url>(url).unwrap(); + let u = from_str::<Url>(url).assert(); assert_eq!(format!("{}", u).as_slice(), url); } #[test] fn test_url_component_encoding() { let url = "http://rust-lang.org/doc%20uments?ba%25d%20=%23%26%2B"; - let u = from_str::<Url>(url).unwrap(); + let u = from_str::<Url>(url).assert(); assert!(u.path.path == "/doc uments".to_string()); assert!(u.path.query == vec!(("ba%d ".to_string(), "#&+".to_string()))); } @@ -1049,7 +1049,7 @@ mod tests { #[test] fn test_path_component_encoding() { let path = "/doc%20uments?ba%25d%20=%23%26%2B"; - let p = from_str::<Path>(path).unwrap(); + let p = from_str::<Path>(path).assert(); assert!(p.path == "/doc uments".to_string()); assert!(p.query == vec!(("ba%d ".to_string(), "#&+".to_string()))); } @@ -1057,7 +1057,7 @@ mod tests { #[test] fn test_url_without_authority() { let url = "mailto:test@email.com"; - let u = from_str::<Url>(url).unwrap(); + let u = from_str::<Url>(url).assert(); assert_eq!(format!("{}", u).as_slice(), url); } @@ -1225,10 +1225,10 @@ mod tests { #[test] fn test_decode_form_urlencoded() { - assert_eq!(decode_form_urlencoded([]).unwrap().len(), 0); + assert_eq!(decode_form_urlencoded([]).assert().len(), 0); let s = "a=1&foo+bar=abc&foo+bar=12+%3D+34".as_bytes(); - let form = decode_form_urlencoded(s).unwrap(); + let form = decode_form_urlencoded(s).assert(); assert_eq!(form.len(), 2); assert_eq!(form.get(&"a".to_string()), &vec!("1".to_string())); assert_eq!(form.get(&"foo bar".to_string()), diff --git a/src/libuuid/lib.rs b/src/libuuid/lib.rs index d922dde6f8537..747dd18a3a935 100644 --- a/src/libuuid/lib.rs +++ b/src/libuuid/lib.rs @@ -329,7 +329,7 @@ impl Uuid { *s.get_mut(i*2+0) = digit.as_bytes()[0]; *s.get_mut(i*2+1) = digit.as_bytes()[1]; } - String::from_utf8(s).unwrap() + String::from_utf8(s).assert() } /// Returns a string of hexadecimal digits, separated into groups with a hyphen. @@ -434,10 +434,10 @@ impl Uuid { for i in range(0u, 16u) { ub[i] = FromStrRadix::from_str_radix(vs.as_slice() .slice(i*2, (i+1)*2), - 16).unwrap(); + 16).assert(); } - Ok(Uuid::from_bytes(ub).unwrap()) + Ok(Uuid::from_bytes(ub).assert()) } /// Tests if the UUID is nil @@ -541,11 +541,11 @@ mod test { #[test] fn test_new() { // Supported - let uuid1 = Uuid::new(Version4Random).unwrap(); + let uuid1 = Uuid::new(Version4Random).assert(); let s = uuid1.to_simple_str(); assert!(s.len() == 32); - assert!(uuid1.get_version().unwrap() == Version4Random); + assert!(uuid1.get_version().assert() == Version4Random); // Test unsupported versions assert!(Uuid::new(Version1Mac) == None); @@ -558,33 +558,33 @@ mod test { fn test_new_v4() { let uuid1 = Uuid::new_v4(); - assert!(uuid1.get_version().unwrap() == Version4Random); - assert!(uuid1.get_variant().unwrap() == VariantRFC4122); + assert!(uuid1.get_version().assert() == Version4Random); + assert!(uuid1.get_variant().assert() == VariantRFC4122); } #[test] fn test_get_version() { let uuid1 = Uuid::new_v4(); - assert!(uuid1.get_version().unwrap() == Version4Random); + assert!(uuid1.get_version().assert() == Version4Random); assert!(uuid1.get_version_num() == 4); } #[test] fn test_get_variant() { let uuid1 = Uuid::new_v4(); - let uuid2 = Uuid::parse_string("550e8400-e29b-41d4-a716-446655440000").unwrap(); - let uuid3 = Uuid::parse_string("67e55044-10b1-426f-9247-bb680e5fe0c8").unwrap(); - let uuid4 = Uuid::parse_string("936DA01F9ABD4d9dC0C702AF85C822A8").unwrap(); - let uuid5 = Uuid::parse_string("F9168C5E-CEB2-4faa-D6BF-329BF39FA1E4").unwrap(); - let uuid6 = Uuid::parse_string("f81d4fae-7dec-11d0-7765-00a0c91e6bf6").unwrap(); + let uuid2 = Uuid::parse_string("550e8400-e29b-41d4-a716-446655440000").assert(); + let uuid3 = Uuid::parse_string("67e55044-10b1-426f-9247-bb680e5fe0c8").assert(); + let uuid4 = Uuid::parse_string("936DA01F9ABD4d9dC0C702AF85C822A8").assert(); + let uuid5 = Uuid::parse_string("F9168C5E-CEB2-4faa-D6BF-329BF39FA1E4").assert(); + let uuid6 = Uuid::parse_string("f81d4fae-7dec-11d0-7765-00a0c91e6bf6").assert(); - assert!(uuid1.get_variant().unwrap() == VariantRFC4122); - assert!(uuid2.get_variant().unwrap() == VariantRFC4122); - assert!(uuid3.get_variant().unwrap() == VariantRFC4122); - assert!(uuid4.get_variant().unwrap() == VariantMicrosoft); - assert!(uuid5.get_variant().unwrap() == VariantMicrosoft); - assert!(uuid6.get_variant().unwrap() == VariantNCS); + assert!(uuid1.get_variant().assert() == VariantRFC4122); + assert!(uuid2.get_variant().assert() == VariantRFC4122); + assert!(uuid3.get_variant().assert() == VariantRFC4122); + assert!(uuid4.get_variant().assert() == VariantMicrosoft); + assert!(uuid5.get_variant().assert() == VariantMicrosoft); + assert!(uuid6.get_variant().assert() == VariantNCS); } #[test] @@ -619,26 +619,26 @@ mod test { // Nil let nil = Uuid::nil(); - assert!(Uuid::parse_string("00000000000000000000000000000000").unwrap() == nil); - assert!(Uuid::parse_string("00000000-0000-0000-0000-000000000000").unwrap() == nil); + assert!(Uuid::parse_string("00000000000000000000000000000000").assert() == nil); + assert!(Uuid::parse_string("00000000-0000-0000-0000-000000000000").assert() == nil); // Round-trip let uuid_orig = Uuid::new_v4(); let orig_str = uuid_orig.to_string(); - let uuid_out = Uuid::parse_string(orig_str.as_slice()).unwrap(); + let uuid_out = Uuid::parse_string(orig_str.as_slice()).assert(); assert!(uuid_orig == uuid_out); // Test error reporting - let e = Uuid::parse_string("67e5504410b1426f9247bb680e5fe0c").unwrap_err(); + let e = Uuid::parse_string("67e5504410b1426f9247bb680e5fe0c").assert_err(); assert!(match e { ErrorInvalidLength(n) => n==31, _ => false }); - let e = Uuid::parse_string("67e550X410b1426f9247bb680e5fe0cd").unwrap_err(); + let e = Uuid::parse_string("67e550X410b1426f9247bb680e5fe0cd").assert_err(); assert!(match e { ErrorInvalidCharacter(c, n) => c=='X' && n==6, _ => false }); - let e = Uuid::parse_string("67e550-4105b1426f9247bb680e5fe0c").unwrap_err(); + let e = Uuid::parse_string("67e550-4105b1426f9247bb680e5fe0c").assert_err(); assert!(match e { ErrorInvalidGroups(n) => n==2, _ => false }); - let e = Uuid::parse_string("F9168C5E-CEB2-4faa-B6BF1-02BF39FA1E4").unwrap_err(); + let e = Uuid::parse_string("F9168C5E-CEB2-4faa-B6BF1-02BF39FA1E4").assert_err(); assert!(match e { ErrorInvalidGroupLength(g, n, e) => g==3 && n==5 && e==4, _ => false }); } @@ -703,11 +703,11 @@ mod test { let uuid = Uuid::new_v4(); let hs = uuid.to_hyphenated_str(); - let uuid_hs = Uuid::parse_string(hs.as_slice()).unwrap(); + let uuid_hs = Uuid::parse_string(hs.as_slice()).assert(); assert!(uuid_hs == uuid); let ss = uuid.to_string(); - let uuid_ss = Uuid::parse_string(ss.as_slice()).unwrap(); + let uuid_ss = Uuid::parse_string(ss.as_slice()).assert(); assert!(uuid_ss == uuid); } @@ -741,7 +741,7 @@ mod test { 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.as_slice()).unwrap(); + let u = Uuid::from_bytes(b.as_slice()).assert(); let expected = "a1a2a3a4b1b2c1c2d1d2d3d4d5d6d7d8".to_string(); assert!(u.to_simple_str() == expected); @@ -761,7 +761,7 @@ mod test { let b_in: [u8, ..16] = [ 0xa1, 0xa2, 0xa3, 0xa4, 0xb1, 0xb2, 0xc1, 0xc2, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8 ]; - let u = Uuid::from_bytes(b_in.clone()).unwrap(); + let u = Uuid::from_bytes(b_in.clone()).assert(); let b_out = u.as_bytes(); @@ -801,7 +801,7 @@ mod test { let u = Uuid::new_v4(); let s = json::encode(&u); - let u2 = json::decode(s.as_slice()).unwrap(); + let u2 = json::decode(s.as_slice()).assert(); assert_eq!(u, u2); } @@ -859,7 +859,7 @@ mod bench { pub fn parse_str(b: &mut Bencher) { let s = "urn:uuid:F9168C5E-CEB2-4faa-B6BF-329BF39FA1E4"; b.iter(|| { - Uuid::parse_string(s).unwrap(); + Uuid::parse_string(s).assert(); }) } } diff --git a/src/test/auxiliary/linkage-visibility.rs b/src/test/auxiliary/linkage-visibility.rs index 0b4bea49fa249..2c017accb3a95 100644 --- a/src/test/auxiliary/linkage-visibility.rs +++ b/src/test/auxiliary/linkage-visibility.rs @@ -28,7 +28,7 @@ fn baz() { } pub fn test() { let none: Option<Path> = None; // appease the typechecker - let lib = DynamicLibrary::open(none).unwrap(); + let lib = DynamicLibrary::open(none).assert(); unsafe { assert!(lib.symbol::<int>("foo").is_ok()); assert!(lib.symbol::<int>("baz").is_err()); diff --git a/src/test/auxiliary/macro_crate_test.rs b/src/test/auxiliary/macro_crate_test.rs index 4936bff5768c9..00c3900dad1db 100644 --- a/src/test/auxiliary/macro_crate_test.rs +++ b/src/test/auxiliary/macro_crate_test.rs @@ -48,7 +48,7 @@ fn expand_into_foo(cx: &mut ExtCtxt, sp: Span, attr: Gc<MetaItem>, it: Gc<Item>) -> Gc<Item> { box(GC) Item { attrs: it.attrs.clone(), - ..(*quote_item!(cx, enum Foo { Bar, Baz }).unwrap()).clone() + ..(*quote_item!(cx, enum Foo { Bar, Baz }).assert()).clone() } } diff --git a/src/test/auxiliary/overloaded_autoderef_xc.rs b/src/test/auxiliary/overloaded_autoderef_xc.rs index 26d61e166f26b..deb1cc75fa76d 100644 --- a/src/test/auxiliary/overloaded_autoderef_xc.rs +++ b/src/test/auxiliary/overloaded_autoderef_xc.rs @@ -20,7 +20,7 @@ trait Helper<T> { impl<T> Helper<T> for Option<T> { fn helper_borrow(&self) -> &T { - self.as_ref().unwrap() + self.as_ref().assert() } } diff --git a/src/test/bench/core-map.rs b/src/test/bench/core-map.rs index 5044d82a6eabb..b4aaf984693f8 100644 --- a/src/test/bench/core-map.rs +++ b/src/test/bench/core-map.rs @@ -33,7 +33,7 @@ fn ascending<M: MutableMap<uint, uint>>(map: &mut M, n_keys: uint) { timed("search", || { for i in range(0u, n_keys) { - assert_eq!(map.find(&i).unwrap(), &(i + 1)); + assert_eq!(map.find(&i).assert(), &(i + 1)); } }); @@ -55,7 +55,7 @@ fn descending<M: MutableMap<uint, uint>>(map: &mut M, n_keys: uint) { timed("search", || { for i in range(0, n_keys).rev() { - assert_eq!(map.find(&i).unwrap(), &(i + 1)); + assert_eq!(map.find(&i).assert(), &(i + 1)); } }); @@ -75,7 +75,7 @@ fn vector<M: MutableMap<uint, uint>>(map: &mut M, n_keys: uint, dist: &[uint]) { timed("search", || { for i in range(0u, n_keys) { - assert_eq!(map.find(&dist[i]).unwrap(), &(i + 1)); + assert_eq!(map.find(&dist[i]).assert(), &(i + 1)); } }); @@ -91,7 +91,7 @@ fn main() { let args = args.as_slice(); let n_keys = { if args.len() == 2 { - from_str::<uint>(args[1].as_slice()).unwrap() + from_str::<uint>(args[1].as_slice()).assert() } else { 1000000 } diff --git a/src/test/bench/core-set.rs b/src/test/bench/core-set.rs index 1d2d02d7d5926..b755b05d36cc5 100644 --- a/src/test/bench/core-set.rs +++ b/src/test/bench/core-set.rs @@ -158,7 +158,7 @@ fn main() { let args = args.as_slice(); let num_keys = { if args.len() == 2 { - from_str::<uint>(args[1].as_slice()).unwrap() + from_str::<uint>(args[1].as_slice()).assert() } else { 100 // woefully inadequate for any real measurement } diff --git a/src/test/bench/core-std.rs b/src/test/bench/core-std.rs index 9af3c0c6c8c1a..f9eb9d46cc68a 100644 --- a/src/test/bench/core-std.rs +++ b/src/test/bench/core-std.rs @@ -68,7 +68,7 @@ fn shift_push() { let mut v2 = Vec::new(); while v1.len() > 0 { - v2.push(v1.shift().unwrap()); + v2.push(v1.shift().assert()); } } @@ -79,7 +79,7 @@ fn read_line() { path.push("src/test/bench/shootout-k-nucleotide.data"); for _ in range(0u, 3) { - let mut reader = BufferedReader::new(File::open(&path).unwrap()); + let mut reader = BufferedReader::new(File::open(&path).assert()); for _line in reader.lines() { } } diff --git a/src/test/bench/core-uint-to-str.rs b/src/test/bench/core-uint-to-str.rs index f385175156609..bd27284cc5bb3 100644 --- a/src/test/bench/core-uint-to-str.rs +++ b/src/test/bench/core-uint-to-str.rs @@ -18,10 +18,10 @@ fn main() { } else if args.len() <= 1u { vec!("".to_string(), "100000".to_string()) } else { - args.move_iter().collect() + args.iter_owned().collect() }; - let n = from_str::<uint>(args.get(1).as_slice()).unwrap(); + let n = from_str::<uint>(args.get(1).as_slice()).assert(); for i in range(0u, n) { let x = i.to_string(); diff --git a/src/test/bench/msgsend-pipes-shared.rs b/src/test/bench/msgsend-pipes-shared.rs index 14155d54d73cc..d581e3c8512ee 100644 --- a/src/test/bench/msgsend-pipes-shared.rs +++ b/src/test/bench/msgsend-pipes-shared.rs @@ -56,8 +56,8 @@ fn run(args: &[String]) { let (to_parent, from_child) = channel(); let (to_child, from_parent) = channel(); - let size = from_str::<uint>(args[1].as_slice()).unwrap(); - let workers = from_str::<uint>(args[2].as_slice()).unwrap(); + let size = from_str::<uint>(args[1].as_slice()).assert(); + let workers = from_str::<uint>(args[2].as_slice()).assert(); let num_bytes = 100; let start = time::precise_time_s(); let mut worker_results = Vec::new(); @@ -75,8 +75,8 @@ fn run(args: &[String]) { server(&from_parent, &to_parent); }); - for r in worker_results.move_iter() { - r.unwrap(); + for r in worker_results.iter_owned() { + r.assert(); } //println!("sending stop message"); @@ -99,7 +99,7 @@ fn main() { } else if args.len() <= 1u { vec!("".to_string(), "10000".to_string(), "4".to_string()) } else { - args.move_iter().map(|x| x.to_string()).collect() + args.iter_owned().map(|x| x.to_string()).collect() }; println!("{}", args); diff --git a/src/test/bench/msgsend-pipes.rs b/src/test/bench/msgsend-pipes.rs index 7ec2796b230a7..8b9f4da5a929a 100644 --- a/src/test/bench/msgsend-pipes.rs +++ b/src/test/bench/msgsend-pipes.rs @@ -50,8 +50,8 @@ fn server(requests: &Receiver<request>, responses: &Sender<uint>) { fn run(args: &[String]) { let (to_parent, from_child) = channel(); - let size = from_str::<uint>(args[1].as_slice()).unwrap(); - let workers = from_str::<uint>(args[2].as_slice()).unwrap(); + let size = from_str::<uint>(args[1].as_slice()).assert(); + let workers = from_str::<uint>(args[2].as_slice()).assert(); let num_bytes = 100; let start = time::precise_time_s(); let mut worker_results = Vec::new(); @@ -83,8 +83,8 @@ fn run(args: &[String]) { server(&from_parent, &to_parent); }); - for r in worker_results.move_iter() { - r.unwrap(); + for r in worker_results.iter_owned() { + r.assert(); } //println!("sending stop message"); @@ -107,7 +107,7 @@ fn main() { } else if args.len() <= 1u { vec!("".to_string(), "10000".to_string(), "4".to_string()) } else { - args.clone().move_iter().map(|x| x.to_string()).collect() + args.clone().iter_owned().map(|x| x.to_string()).collect() }; println!("{:?}", args); diff --git a/src/test/bench/msgsend-ring-mutex-arcs.rs b/src/test/bench/msgsend-ring-mutex-arcs.rs index a0ff7736b5c7f..25b4c724388a0 100644 --- a/src/test/bench/msgsend-ring-mutex-arcs.rs +++ b/src/test/bench/msgsend-ring-mutex-arcs.rs @@ -37,7 +37,7 @@ fn recv(p: &pipe) -> uint { while arr.is_empty() { arr.cond.wait(); } - arr.pop().unwrap() + arr.pop().assert() } fn init() -> (pipe,pipe) { @@ -52,8 +52,8 @@ fn thread_ring(i: uint, count: uint, num_chan: pipe, num_port: pipe) { // Send/Receive lots of messages. for j in range(0u, count) { //println!("task %?, iter %?", i, j); - let num_chan2 = num_chan.take_unwrap(); - let num_port2 = num_port.take_unwrap(); + let num_chan2 = num_chan.take().assert(); + let num_port2 = num_port.take().assert(); send(&num_chan2, i * j); num_chan = Some(num_chan2); let _n = recv(&num_port2); @@ -69,11 +69,11 @@ fn main() { } else if args.len() <= 1u { vec!("".to_string(), "10".to_string(), "100".to_string()) } else { - args.clone().move_iter().collect() + args.clone().iter_owned().collect() }; - let num_tasks = from_str::<uint>(args.get(1).as_slice()).unwrap(); - let msg_per_task = from_str::<uint>(args.get(2).as_slice()).unwrap(); + let num_tasks = from_str::<uint>(args.get(1).as_slice()).assert(); + let msg_per_task = from_str::<uint>(args.get(2).as_slice()).assert(); let (mut num_chan, num_port) = init(); @@ -97,7 +97,7 @@ fn main() { thread_ring(0, msg_per_task, num_chan, num_port); // synchronize - for f in futures.mut_iter() { + for f in futures.iter_mut() { f.get() } diff --git a/src/test/bench/msgsend-ring-rw-arcs.rs b/src/test/bench/msgsend-ring-rw-arcs.rs index 6512ecfb3e260..56cfdaaa30bad 100644 --- a/src/test/bench/msgsend-ring-rw-arcs.rs +++ b/src/test/bench/msgsend-ring-rw-arcs.rs @@ -37,7 +37,7 @@ fn recv(p: &pipe) -> uint { while arr.is_empty() { arr.cond.wait(); } - arr.pop().unwrap() + arr.pop().assert() } fn init() -> (pipe,pipe) { @@ -52,8 +52,8 @@ fn thread_ring(i: uint, count: uint, num_chan: pipe, num_port: pipe) { // Send/Receive lots of messages. for j in range(0u, count) { //println!("task %?, iter %?", i, j); - let num_chan2 = num_chan.take_unwrap(); - let num_port2 = num_port.take_unwrap(); + let num_chan2 = num_chan.take().assert(); + let num_port2 = num_port.take().assert(); send(&num_chan2, i * j); num_chan = Some(num_chan2); let _n = recv(&num_port2); @@ -69,11 +69,11 @@ fn main() { } else if args.len() <= 1u { vec!("".to_string(), "10".to_string(), "100".to_string()) } else { - args.clone().move_iter().collect() + args.clone().iter_owned().collect() }; - let num_tasks = from_str::<uint>(args.get(1).as_slice()).unwrap(); - let msg_per_task = from_str::<uint>(args.get(2).as_slice()).unwrap(); + let num_tasks = from_str::<uint>(args.get(1).as_slice()).assert(); + let msg_per_task = from_str::<uint>(args.get(2).as_slice()).assert(); let (mut num_chan, num_port) = init(); @@ -97,7 +97,7 @@ fn main() { thread_ring(0, msg_per_task, num_chan, num_port); // synchronize - for f in futures.mut_iter() { + for f in futures.iter_mut() { let _ = f.get(); } diff --git a/src/test/bench/noise.rs b/src/test/bench/noise.rs index bdca03490369a..c8bfdbf9fb8d1 100644 --- a/src/test/bench/noise.rs +++ b/src/test/bench/noise.rs @@ -40,15 +40,15 @@ struct Noise2DContext { impl Noise2DContext { fn new() -> Noise2DContext { - let mut rng = StdRng::new().unwrap(); + let mut rng = StdRng::new().assert(); let mut rgradients = [Vec2 { x: 0.0, y: 0.0 }, ..256]; - for x in rgradients.mut_iter() { + for x in rgradients.iter_mut() { *x = random_gradient(&mut rng); } let mut permutations = [0i32, ..256]; - for (i, x) in permutations.mut_iter().enumerate() { + for (i, x) in permutations.iter_mut().enumerate() { *x = i as i32; } rng.shuffle(permutations); diff --git a/src/test/bench/rt-messaging-ping-pong.rs b/src/test/bench/rt-messaging-ping-pong.rs index b00adf4bdb1d4..34b5c6249f780 100644 --- a/src/test/bench/rt-messaging-ping-pong.rs +++ b/src/test/bench/rt-messaging-ping-pong.rs @@ -63,13 +63,13 @@ fn main() { let args = os::args(); let args = args.as_slice(); let n = if args.len() == 3 { - from_str::<uint>(args[1].as_slice()).unwrap() + from_str::<uint>(args[1].as_slice()).assert() } else { 10000 }; let m = if args.len() == 3 { - from_str::<uint>(args[2].as_slice()).unwrap() + from_str::<uint>(args[2].as_slice()).assert() } else { 4 }; diff --git a/src/test/bench/rt-parfib.rs b/src/test/bench/rt-parfib.rs index 4072dc0064afb..4065e78457cdf 100644 --- a/src/test/bench/rt-parfib.rs +++ b/src/test/bench/rt-parfib.rs @@ -33,7 +33,7 @@ fn main() { let args = os::args(); let args = args.as_slice(); let n = if args.len() == 2 { - from_str::<uint>(args[1].as_slice()).unwrap() + from_str::<uint>(args[1].as_slice()).assert() } else { 10 }; diff --git a/src/test/bench/rt-spawn-rate.rs b/src/test/bench/rt-spawn-rate.rs index 2737c6df533fe..2cc18311d94ab 100644 --- a/src/test/bench/rt-spawn-rate.rs +++ b/src/test/bench/rt-spawn-rate.rs @@ -30,7 +30,7 @@ fn main() { let args = os::args(); let args = args.as_slice(); let n = if args.len() == 2 { - from_str::<uint>(args[1].as_slice()).unwrap() + from_str::<uint>(args[1].as_slice()).assert() } else { 100000 }; diff --git a/src/test/bench/shootout-ackermann.rs b/src/test/bench/shootout-ackermann.rs index d8eceec6321df..44645ce6ae0ee 100644 --- a/src/test/bench/shootout-ackermann.rs +++ b/src/test/bench/shootout-ackermann.rs @@ -29,8 +29,8 @@ fn main() { } else if args.len() <= 1u { vec!("".to_string(), "8".to_string()) } else { - args.move_iter().collect() + args.iter_owned().collect() }; - let n = from_str::<int>(args.get(1).as_slice()).unwrap(); + let n = from_str::<int>(args.get(1).as_slice()).assert(); println!("Ack(3,{}): {}\n", n, ack(3, n)); } diff --git a/src/test/bench/shootout-binarytrees.rs b/src/test/bench/shootout-binarytrees.rs index 822565ec1279b..16e3d6b37c076 100644 --- a/src/test/bench/shootout-binarytrees.rs +++ b/src/test/bench/shootout-binarytrees.rs @@ -75,7 +75,7 @@ fn main() { } else if args.len() <= 1u { 8 } else { - from_str(args[1].as_slice()).unwrap() + from_str(args[1].as_slice()).assert() }; let min_depth = 4; let max_depth = if min_depth + 2 > n {min_depth + 2} else {n}; @@ -108,8 +108,8 @@ fn main() { }) }).collect::<Vec<Future<String>>>(); - for message in messages.mut_iter() { - println!("{}", *message.get_ref()); + for message in messages.iter_mut() { + println!("{}", *message.as_ref().assert()); } println!("long lived tree of depth {}\t check: {}", diff --git a/src/test/bench/shootout-fannkuch-redux.rs b/src/test/bench/shootout-fannkuch-redux.rs index 91686d00fc39f..f48b7c7897d7c 100644 --- a/src/test/bench/shootout-fannkuch-redux.rs +++ b/src/test/bench/shootout-fannkuch-redux.rs @@ -73,7 +73,7 @@ fn fannkuch(n: uint, i: uint) -> (int, int) { loop { let k = *tperm.get(0); if k == 1 { break; } - tperm.mut_slice_to(k as uint).reverse(); + tperm.slice_to_mut(k as uint).reverse(); flips_count += 1; } perm_count = max(perm_count, flips_count); diff --git a/src/test/bench/shootout-fasta-redux.rs b/src/test/bench/shootout-fasta-redux.rs index adec9d31afecb..e7cf2844af396 100644 --- a/src/test/bench/shootout-fasta-redux.rs +++ b/src/test/bench/shootout-fasta-redux.rs @@ -94,7 +94,7 @@ impl<'a, W: Writer> RepeatFasta<'a, W> { copy_memory(buf.as_mut_slice(), alu); let buf_len = buf.len(); - copy_memory(buf.mut_slice(alu_len, buf_len), + copy_memory(buf.slice_mut(alu_len, buf_len), alu.slice_to(LINE_LEN)); let mut pos = 0; @@ -117,7 +117,7 @@ impl<'a, W: Writer> RepeatFasta<'a, W> { fn make_lookup(a: &[AminoAcid]) -> [AminoAcid, ..LOOKUP_SIZE] { let mut lookup = [ NULL_AMINO_ACID, ..LOOKUP_SIZE ]; let mut j = 0; - for (i, slot) in lookup.mut_iter().enumerate() { + for (i, slot) in lookup.iter_mut().enumerate() { while a[j].p < (i as f32) { j += 1; } @@ -179,28 +179,28 @@ fn main() { let args = os::args(); let args = args.as_slice(); let n = if args.len() > 1 { - from_str::<uint>(args[1].as_slice()).unwrap() + from_str::<uint>(args[1].as_slice()).assert() } else { 5 }; let mut out = stdout(); - out.write_line(">ONE Homo sapiens alu").unwrap(); + out.write_line(">ONE Homo sapiens alu").assert(); { let mut repeat = RepeatFasta::new(ALU, &mut out); - repeat.make(n * 2).unwrap(); + repeat.make(n * 2).assert(); } - out.write_line(">TWO IUB ambiguity codes").unwrap(); + out.write_line(">TWO IUB ambiguity codes").assert(); let iub = sum_and_scale(IUB); let mut random = RandomFasta::new(&mut out, iub.as_slice()); - random.make(n * 3).unwrap(); + random.make(n * 3).assert(); - random.out.write_line(">THREE Homo sapiens frequency").unwrap(); + random.out.write_line(">THREE Homo sapiens frequency").assert(); let homo_sapiens = sum_and_scale(HOMO_SAPIENS); random.lookup = make_lookup(homo_sapiens.as_slice()); - random.make(n * 5).unwrap(); + random.make(n * 5).assert(); - random.out.write_str("\n").unwrap(); + random.out.write_str("\n").assert(); } diff --git a/src/test/bench/shootout-fasta.rs b/src/test/bench/shootout-fasta.rs index 4126fda00bcce..ce72194a62514 100644 --- a/src/test/bench/shootout-fasta.rs +++ b/src/test/bench/shootout-fasta.rs @@ -64,7 +64,7 @@ fn make_fasta<W: Writer, I: Iterator<u8>>( while n > 0 { let nb = min(LINE_LENGTH, n); for i in range(0, nb) { - line[i] = it.next().unwrap(); + line[i] = it.next().assert(); } n -= nb; line[nb] = '\n' as u8; @@ -80,7 +80,7 @@ fn run<W: Writer>(writer: &mut W) { } else if args.len() <= 1u { 1000 } else { - from_str(args[1].as_slice()).unwrap() + from_str(args[1].as_slice()).assert() }; let rng = &mut MyRandom::new(); diff --git a/src/test/bench/shootout-fibo.rs b/src/test/bench/shootout-fibo.rs index 83db926ad6cfa..68c5e5108e573 100644 --- a/src/test/bench/shootout-fibo.rs +++ b/src/test/bench/shootout-fibo.rs @@ -25,8 +25,8 @@ fn main() { } else if args.len() <= 1u { vec!("".to_string(), "30".to_string()) } else { - args.move_iter().collect() + args.iter_owned().collect() }; - let n = from_str::<int>(args.get(1).as_slice()).unwrap(); + let n = from_str::<int>(args.get(1).as_slice()).assert(); println!("{}\n", fib(n)); } diff --git a/src/test/bench/shootout-k-nucleotide-pipes.rs b/src/test/bench/shootout-k-nucleotide-pipes.rs index 143175e558b6d..82296c1384086 100644 --- a/src/test/bench/shootout-k-nucleotide-pipes.rs +++ b/src/test/bench/shootout-k-nucleotide-pipes.rs @@ -157,10 +157,10 @@ fn main() { let sizes = vec!(1u,2,3,4,6,12,18); let mut streams = Vec::from_fn(sizes.len(), |_| Some(channel::<String>())); let mut from_child = Vec::new(); - let to_child = sizes.iter().zip(streams.mut_iter()).map(|(sz, stream_ref)| { + let to_child = sizes.iter().zip(streams.iter_mut()).map(|(sz, stream_ref)| { let sz = *sz; let stream = replace(stream_ref, None); - let (to_parent_, from_child_) = stream.unwrap(); + let (to_parent_, from_child_) = stream.assert(); from_child.push(from_child_); @@ -179,7 +179,7 @@ fn main() { let mut proc_mode = false; for line in rdr.lines() { - let line = line.unwrap().as_slice().trim().to_string(); + let line = line.assert().as_slice().trim().to_string(); if line.len() == 0u { continue; } diff --git a/src/test/bench/shootout-k-nucleotide.rs b/src/test/bench/shootout-k-nucleotide.rs index 59cbc6bc0043e..c31d4b77c7859 100644 --- a/src/test/bench/shootout-k-nucleotide.rs +++ b/src/test/bench/shootout-k-nucleotide.rs @@ -87,7 +87,7 @@ impl Code { } result.reverse(); - String::from_utf8(result).unwrap() + String::from_utf8(result).assert() } } @@ -176,7 +176,7 @@ impl Table { } { - let entry = &mut *self.items.get_mut(index as uint).get_mut_ref(); + let entry = &mut *self.items.get_mut(index as uint).as_mut().assert(); if entry.code == key { c.f(&mut **entry); return; @@ -278,12 +278,12 @@ fn print_occurrences(frequencies: &mut Table, occurrence: &'static str) { fn get_sequence<R: Buffer>(r: &mut R, key: &str) -> Vec<u8> { let mut res = Vec::new(); - for l in r.lines().map(|l| l.ok().unwrap()) + for l in r.lines().map(|l| l.ok().assert()) .skip_while(|l| key != l.as_slice().slice_to(key.len())).skip(1) { res.push_all(l.as_slice().trim().as_bytes()); } - for b in res.mut_iter() { + for b in res.iter_mut() { *b = b.to_ascii().to_upper().to_byte(); } res @@ -307,10 +307,10 @@ fn main() { Future::spawn(proc() generate_frequencies(input.as_slice(), occ.len())) }).collect(); - for (i, freq) in nb_freqs.move_iter() { - print_frequencies(&freq.unwrap(), i); + for (i, freq) in nb_freqs.iter_owned() { + print_frequencies(&freq.assert(), i); } - for (&occ, freq) in OCCURRENCES.iter().zip(occ_freqs.move_iter()) { - print_occurrences(&mut freq.unwrap(), occ); + for (&occ, freq) in OCCURRENCES.iter().zip(occ_freqs.iter_owned()) { + print_occurrences(&mut freq.assert(), occ); } } diff --git a/src/test/bench/shootout-mandelbrot.rs b/src/test/bench/shootout-mandelbrot.rs index b0e23983192f2..3348132298493 100644 --- a/src/test/bench/shootout-mandelbrot.rs +++ b/src/test/bench/shootout-mandelbrot.rs @@ -107,8 +107,8 @@ fn mandelbrot<W: io::Writer>(w: uint, mut out: W) -> io::IoResult<()> { }) }); - for res in precalc_futures.move_iter() { - let (rs, is) = res.unwrap(); + for res in precalc_futures.iter_owned() { + let (rs, is) = res.assert(); precalc_r.push_all_move(rs); precalc_i.push_all_move(is); } @@ -135,8 +135,8 @@ fn mandelbrot<W: io::Writer>(w: uint, mut out: W) -> io::IoResult<()> { }); try!(writeln!(&mut out as &mut Writer, "P4\n{} {}", w, h)); - for res in data.move_iter() { - try!(out.write(res.unwrap().as_slice())); + for res in data.iter_owned() { + try!(out.write(res.assert().as_slice())); } out.flush() } @@ -197,7 +197,7 @@ fn main() { which interferes with the test runner."); mandelbrot(1000, io::util::NullWriter) } else { - mandelbrot(from_str(args[1].as_slice()).unwrap(), io::stdout()) + mandelbrot(from_str(args[1].as_slice()).assert(), io::stdout()) }; - res.unwrap(); + res.assert(); } diff --git a/src/test/bench/shootout-meteor.rs b/src/test/bench/shootout-meteor.rs index 9be111f55ae09..96d933c20f78c 100644 --- a/src/test/bench/shootout-meteor.rs +++ b/src/test/bench/shootout-meteor.rs @@ -114,9 +114,9 @@ fn transform(piece: Vec<(int, int)> , all: bool) -> Vec<Vec<(int, int)>> { }).collect(); // translating to (0, 0) as minimum coordinates. - for cur_piece in res.mut_iter() { - let (dy, dx) = *cur_piece.iter().min_by(|e| *e).unwrap(); - for &(ref mut y, ref mut x) in cur_piece.mut_iter() { + for cur_piece in res.iter_mut() { + let (dy, dx) = *cur_piece.iter().min_by(|e| *e).assert(); + for &(ref mut y, ref mut x) in cur_piece.iter_mut() { *y -= dy; *x -= dx; } } @@ -163,7 +163,7 @@ fn make_masks() -> Vec<Vec<Vec<u64> > > { // transformation must be taken except for one piece (piece 3 // here). let transforms: Vec<Vec<Vec<(int, int)>>> = - pieces.move_iter().enumerate() + pieces.iter_owned().enumerate() .map(|(id, p)| transform(p, id != 3)) .collect(); diff --git a/src/test/bench/shootout-nbody.rs b/src/test/bench/shootout-nbody.rs index 5a077b377475c..9b68239204102 100644 --- a/src/test/bench/shootout-nbody.rs +++ b/src/test/bench/shootout-nbody.rs @@ -72,11 +72,11 @@ fn advance(bodies: &mut [Planet, ..N_BODIES], dt: f64, steps: int) { for _ in range(0, steps) { let mut b_slice = bodies.as_mut_slice(); loop { - let bi = match b_slice.mut_shift_ref() { + let bi = match b_slice.shift_mut() { Some(bi) => bi, None => break }; - for bj in b_slice.mut_iter() { + for bj in b_slice.iter_mut() { let dx = bi.x - bj.x; let dy = bi.y - bj.y; let dz = bi.z - bj.z; diff --git a/src/test/bench/shootout-pfib.rs b/src/test/bench/shootout-pfib.rs index 0e0b0b518d587..25dbdee82b934 100644 --- a/src/test/bench/shootout-pfib.rs +++ b/src/test/bench/shootout-pfib.rs @@ -82,8 +82,8 @@ fn stress(num_tasks: int) { stress_task(i); })); } - for r in results.move_iter() { - r.unwrap(); + for r in results.iter_owned() { + r.assert(); } } @@ -94,7 +94,7 @@ fn main() { } else if args.len() <= 1u { vec!("".to_string(), "8".to_string()) } else { - args.move_iter().map(|x| x.to_string()).collect() + args.iter_owned().map(|x| x.to_string()).collect() }; let opts = parse_opts(args.clone()); @@ -102,7 +102,7 @@ fn main() { if opts.stress { stress(2); } else { - let max = uint::parse_bytes(args.get(1).as_bytes(), 10u).unwrap() as + let max = uint::parse_bytes(args.get(1).as_bytes(), 10u).assert() as int; let num_trials = 10; diff --git a/src/test/bench/shootout-pidigits.rs b/src/test/bench/shootout-pidigits.rs index d22633b341289..d322fd2427cd7 100644 --- a/src/test/bench/shootout-pidigits.rs +++ b/src/test/bench/shootout-pidigits.rs @@ -63,7 +63,7 @@ impl Context { } fn from_int(i: int) -> BigInt { - FromPrimitive::from_int(i).unwrap() + FromPrimitive::from_int(i).assert() } fn extract_digit(&self) -> int { @@ -72,7 +72,7 @@ impl Context { (self.numer * Context::from_int(3) + self.accum) .div_rem(&self.denom); if r + self.numer >= self.denom {return -1;} - q.to_int().unwrap() + q.to_int().assert() } fn next_term(&mut self, k: int) { @@ -122,7 +122,7 @@ fn main() { let n = if args.len() < 2 { 512 } else { - FromStr::from_str(args[1].as_slice()).unwrap() + FromStr::from_str(args[1].as_slice()).assert() }; pidigits(n); } diff --git a/src/test/bench/shootout-regex-dna.rs b/src/test/bench/shootout-regex-dna.rs index 8908b5b87ed3c..fbb0462390601 100644 --- a/src/test/bench/shootout-regex-dna.rs +++ b/src/test/bench/shootout-regex-dna.rs @@ -67,7 +67,7 @@ fn main() { } else { box io::stdin() as Box<io::Reader> }; - let mut seq = rdr.read_to_string().unwrap(); + let mut seq = rdr.read_to_string().assert(); let ilen = seq.len(); seq = regex!(">[^\n]*\n|\n").replace_all(seq.as_slice(), NoExpand("")); @@ -89,7 +89,7 @@ fn main() { (regex!("Y"), "(c|t)"), ]; let mut seq = seq; - for (re, replacement) in substs.move_iter() { + for (re, replacement) in substs.iter_owned() { seq = re.replace_all(seq.as_slice(), NoExpand(replacement)); } seq.len() @@ -107,7 +107,7 @@ fn main() { regex!("agggtaa[cgt]|[acg]ttaccct"), ]; let (mut variant_strs, mut counts) = (vec!(), vec!()); - for variant in variants.move_iter() { + for variant in variants.iter_owned() { let seq_arc_copy = seq_arc.clone(); variant_strs.push(variant.to_string()); counts.push(Future::spawn(proc() { diff --git a/src/test/bench/shootout-reverse-complement.rs b/src/test/bench/shootout-reverse-complement.rs index fdd711d22c760..499125a753a9e 100644 --- a/src/test/bench/shootout-reverse-complement.rs +++ b/src/test/bench/shootout-reverse-complement.rs @@ -24,7 +24,7 @@ fn make_complements() -> [u8, ..256] { ('H', 'D'), ('D', 'H'), ('B', 'V'), ('N', 'N'), ('\n', '\n')]; let mut complements: [u8, ..256] = [0, ..256]; - for (i, c) in complements.mut_iter().enumerate() { + for (i, c) in complements.iter_mut().enumerate() { *c = i as u8; } let lower = 'A' as u8 - 'a' as u8; @@ -42,16 +42,16 @@ fn main() { } else { stdin().read_to_end() }; - let mut data = data.unwrap(); + let mut data = data.assert(); - for seq in data.as_mut_slice().mut_split(|c| *c == '>' as u8) { + for seq in data.as_mut_slice().split_mut(|c| *c == '>' as u8) { // skip header and last \n let begin = match seq.iter().position(|c| *c == '\n' as u8) { None => continue, Some(c) => c }; let len = seq.len(); - let seq = seq.mut_slice(begin + 1, len - 1); + let seq = seq.slice_mut(begin + 1, len - 1); // arrange line breaks let len = seq.len(); @@ -64,9 +64,9 @@ fn main() { } // reverse complement, as - // seq.reverse(); for c in seq.mut_iter() {*c = complements[*c]} + // seq.reverse(); for c in seq.iter_mut() {*c = complements[*c]} // but faster: - let mut it = seq.mut_iter(); + let mut it = seq.iter_mut(); loop { match (it.next(), it.next_back()) { (Some(front), Some(back)) => { @@ -80,5 +80,5 @@ fn main() { } } - stdout().write(data.as_slice()).unwrap(); + stdout().write(data.as_slice()).assert(); } diff --git a/src/test/bench/shootout-spectralnorm.rs b/src/test/bench/shootout-spectralnorm.rs index 2cbbfdb23fe02..0874e825f29bb 100644 --- a/src/test/bench/shootout-spectralnorm.rs +++ b/src/test/bench/shootout-spectralnorm.rs @@ -102,7 +102,7 @@ fn main() { } else if args.len() < 2 { 2000 } else { - FromStr::from_str(args[1].as_slice()).unwrap() + FromStr::from_str(args[1].as_slice()).assert() }; let u = Arc::new(RWLock::new(Vec::from_elem(n, 1f64))); let v = Arc::new(RWLock::new(Vec::from_elem(n, 1f64))); diff --git a/src/test/bench/std-smallintmap.rs b/src/test/bench/std-smallintmap.rs index ae05466eb9cb8..184d4564b9252 100644 --- a/src/test/bench/std-smallintmap.rs +++ b/src/test/bench/std-smallintmap.rs @@ -37,10 +37,10 @@ fn main() { } else if args.len() <= 1u { vec!("".to_string(), "10000".to_string(), "50".to_string()) } else { - args.move_iter().collect() + args.iter_owned().collect() }; - let max = from_str::<uint>(args.get(1).as_slice()).unwrap(); - let rep = from_str::<uint>(args.get(2).as_slice()).unwrap(); + let max = from_str::<uint>(args.get(1).as_slice()).assert(); + let rep = from_str::<uint>(args.get(2).as_slice()).assert(); let mut checkf = 0.0; let mut appendf = 0.0; diff --git a/src/test/bench/sudoku.rs b/src/test/bench/sudoku.rs index 7129d4993b74f..371d2ed640480 100644 --- a/src/test/bench/sudoku.rs +++ b/src/test/bench/sudoku.rs @@ -66,21 +66,21 @@ impl Sudoku { pub fn read(mut reader: BufferedReader<StdReader>) -> Sudoku { /* assert first line is exactly "9,9" */ - assert!(reader.read_line().unwrap() == "9,9".to_string()); + assert!(reader.read_line().assert() == "9,9".to_string()); let mut g = Vec::from_fn(10u, { |_i| vec!(0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8) }); for line in reader.lines() { - let line = line.unwrap(); + let line = line.assert(); let comps: Vec<&str> = line.as_slice() .trim() .split(',') .collect(); if comps.len() == 3u { - let row = from_str::<uint>(*comps.get(0)).unwrap() as u8; - let col = from_str::<uint>(*comps.get(1)).unwrap() as u8; + let row = from_str::<uint>(*comps.get(0)).assert() as u8; + let col = from_str::<uint>(*comps.get(1)).assert() as u8; *g.get_mut(row as uint).get_mut(col as uint) = - from_str::<uint>(*comps.get(2)).unwrap() as u8; + from_str::<uint>(*comps.get(2)).assert() as u8; } else { fail!("Invalid sudoku file"); diff --git a/src/test/bench/task-perf-alloc-unwind.rs b/src/test/bench/task-perf-alloc-unwind.rs index 93b22edbf03e6..7e96c417bb137 100644 --- a/src/test/bench/task-perf-alloc-unwind.rs +++ b/src/test/bench/task-perf-alloc-unwind.rs @@ -99,7 +99,7 @@ fn recurse_or_fail(depth: int, st: Option<State>) { tuple: (box(GC) Cons((), st.tuple.ref0().clone()), box Cons((), box(GC) *st.tuple.ref1().clone())), vec: st.vec.clone().append( - &[box(GC) Cons((), *st.vec.last().unwrap())]), + &[box(GC) Cons((), *st.vec.last().assert())]), res: r(box(GC) Cons((), st.res._l)) } } diff --git a/src/test/bench/task-perf-jargon-metal-smoke.rs b/src/test/bench/task-perf-jargon-metal-smoke.rs index c631e3e04f2ef..a2d810c9eb1b9 100644 --- a/src/test/bench/task-perf-jargon-metal-smoke.rs +++ b/src/test/bench/task-perf-jargon-metal-smoke.rs @@ -45,11 +45,11 @@ fn main() { } else if args.len() <= 1 { vec!("".to_string(), "100".to_string()) } else { - args.clone().move_iter().collect() + args.clone().iter_owned().collect() }; let (tx, rx) = channel(); - child_generation(from_str::<uint>(args.get(1).as_slice()).unwrap(), tx); + child_generation(from_str::<uint>(args.get(1).as_slice()).assert(), tx); if rx.recv_opt().is_err() { fail!("it happened when we slumbered"); } diff --git a/src/test/bench/task-perf-one-million.rs b/src/test/bench/task-perf-one-million.rs index c980d531bb5eb..54614a6036ad6 100644 --- a/src/test/bench/task-perf-one-million.rs +++ b/src/test/bench/task-perf-one-million.rs @@ -28,20 +28,20 @@ fn calc(children: uint, parent_wait_chan: &Sender<Sender<Sender<int>>>) { }); let child_start_chans: Vec<Sender<Sender<int>>> = - wait_ports.move_iter().map(|port| port.recv()).collect(); + wait_ports.iter_owned().map(|port| port.recv()).collect(); let (start_port, start_chan) = stream::<Sender<int>>(); parent_wait_chan.send(start_chan); let parent_result_chan: Sender<int> = start_port.recv(); let child_sum_ports: Vec<Reciever<int>> = - child_start_chans.move_iter().map(|child_start_chan| { + child_start_chans.iter_owned().map(|child_start_chan| { let (child_sum_port, child_sum_chan) = stream::<int>(); child_start_chan.send(child_sum_chan); child_sum_port }).collect(); - let sum = child_sum_ports.move_iter().fold(0, |sum, sum_port| sum + sum_port.recv() ); + let sum = child_sum_ports.iter_owned().fold(0, |sum, sum_port| sum + sum_port.recv() ); parent_result_chan.send(sum + 1); } @@ -56,7 +56,7 @@ fn main() { args }; - let children = from_str::<uint>(args[1]).unwrap(); + let children = from_str::<uint>(args[1]).assert(); let (wait_port, wait_chan) = stream(); task::spawn(proc() { calc(children, &wait_chan); diff --git a/src/test/bench/task-perf-spawnalot.rs b/src/test/bench/task-perf-spawnalot.rs index 8b090d6d7fb79..f8c849e38f944 100644 --- a/src/test/bench/task-perf-spawnalot.rs +++ b/src/test/bench/task-perf-spawnalot.rs @@ -29,9 +29,9 @@ fn main() { } else if args.len() <= 1u { vec!("".to_string(), "10".to_string()) } else { - args.move_iter().collect() + args.iter_owned().collect() }; - let n = from_str::<uint>(args.get(1).as_slice()).unwrap(); + let n = from_str::<uint>(args.get(1).as_slice()).assert(); let mut i = 0u; while i < n { task::spawn(proc() f(n) ); i += 1u; } } diff --git a/src/test/compile-fail/borrowck-move-out-of-overloaded-auto-deref.rs b/src/test/compile-fail/borrowck-move-out-of-overloaded-auto-deref.rs index 7962617916346..ef143262371de 100644 --- a/src/test/compile-fail/borrowck-move-out-of-overloaded-auto-deref.rs +++ b/src/test/compile-fail/borrowck-move-out-of-overloaded-auto-deref.rs @@ -11,6 +11,6 @@ use std::rc::Rc; pub fn main() { - let _x = Rc::new(vec!(1i, 2)).move_iter(); + let _x = Rc::new(vec!(1i, 2)).iter_owned(); //~^ ERROR cannot move out of dereference of `&`-pointer } diff --git a/src/test/compile-fail/lub-if.rs b/src/test/compile-fail/lub-if.rs index 82938d63ce54c..72196cc224720 100644 --- a/src/test/compile-fail/lub-if.rs +++ b/src/test/compile-fail/lub-if.rs @@ -16,14 +16,14 @@ pub fn opt_str0<'a>(maybestr: &'a Option<String>) -> &'a str { if maybestr.is_none() { "(none)" } else { - let s: &'a str = maybestr.get_ref().as_slice(); + let s: &'a str = maybestr.as_ref().assert().as_slice(); s } } pub fn opt_str1<'a>(maybestr: &'a Option<String>) -> &'a str { if maybestr.is_some() { - let s: &'a str = maybestr.get_ref().as_slice(); + let s: &'a str = maybestr.as_ref().assert().as_slice(); s } else { "(none)" @@ -34,14 +34,14 @@ pub fn opt_str2<'a>(maybestr: &'a Option<String>) -> &'static str { if maybestr.is_none() { //~ ERROR mismatched types "(none)" } else { - let s: &'a str = maybestr.get_ref().as_slice(); + let s: &'a str = maybestr.as_ref().assert().as_slice(); s } } pub fn opt_str3<'a>(maybestr: &'a Option<String>) -> &'static str { if maybestr.is_some() { //~ ERROR mismatched types - let s: &'a str = maybestr.get_ref().as_slice(); + let s: &'a str = maybestr.as_ref().assert().as_slice(); s } else { "(none)" diff --git a/src/test/compile-fail/moves-based-on-type-access-to-field.rs b/src/test/compile-fail/moves-based-on-type-access-to-field.rs index f09e80974bd42..fbddbd43afe75 100644 --- a/src/test/compile-fail/moves-based-on-type-access-to-field.rs +++ b/src/test/compile-fail/moves-based-on-type-access-to-field.rs @@ -19,7 +19,7 @@ fn touch<A>(_a: &A) {} fn f20() { let x = vec!("hi".to_string()); - consume(x.move_iter().next().unwrap()); + consume(x.iter_owned().next().assert()); touch(x.get(0)); //~ ERROR use of moved value: `x` } diff --git a/src/test/compile-fail/moves-based-on-type-exprs.rs b/src/test/compile-fail/moves-based-on-type-exprs.rs index a6f7fb2433188..efbac0685ebf3 100644 --- a/src/test/compile-fail/moves-based-on-type-exprs.rs +++ b/src/test/compile-fail/moves-based-on-type-exprs.rs @@ -83,13 +83,13 @@ fn f80() { fn f100() { let x = vec!("hi".to_string()); - let _y = x.move_iter().next().unwrap(); + let _y = x.iter_owned().next().assert(); touch(&x); //~ ERROR use of moved value: `x` } fn f110() { let x = vec!("hi".to_string()); - let _y = [x.move_iter().next().unwrap(), ..1]; + let _y = [x.iter_owned().next().assert(), ..1]; touch(&x); //~ ERROR use of moved value: `x` } diff --git a/src/test/compile-fail/std-uncopyable-atomics.rs b/src/test/compile-fail/std-uncopyable-atomics.rs index fa2cf6bda33d7..0e8c2f38afbed 100644 --- a/src/test/compile-fail/std-uncopyable-atomics.rs +++ b/src/test/compile-fail/std-uncopyable-atomics.rs @@ -22,7 +22,7 @@ fn main() { let x = *&x; //~ ERROR: cannot move out of dereference let x = INIT_ATOMIC_UINT; //~ ERROR cannot move out of static item let x = *&x; //~ ERROR: cannot move out of dereference - let x: AtomicPtr<uint> = AtomicPtr::new(ptr::mut_null()); + let x: AtomicPtr<uint> = AtomicPtr::new(ptr::null_mut()); let x = *&x; //~ ERROR: cannot move out of dereference let x: AtomicOption<uint> = AtomicOption::empty(); let x = *&x; //~ ERROR: cannot move out of dereference diff --git a/src/test/compile-fail/vec-mut-iter-borrow.rs b/src/test/compile-fail/vec-mut-iter-borrow.rs index 9060ed7495ee5..c03956c42cb30 100644 --- a/src/test/compile-fail/vec-mut-iter-borrow.rs +++ b/src/test/compile-fail/vec-mut-iter-borrow.rs @@ -11,7 +11,7 @@ fn main() { let mut xs: Vec<int> = vec!(); - for x in xs.mut_iter() { + for x in xs.iter_mut() { xs.push(1i) //~ ERROR cannot borrow `xs` } } diff --git a/src/test/debuginfo/issue12886.rs b/src/test/debuginfo/issue12886.rs index 3b152cd3c1a8c..fd61617317f1e 100644 --- a/src/test/debuginfo/issue12886.rs +++ b/src/test/debuginfo/issue12886.rs @@ -26,7 +26,7 @@ // unwrap(). (The testing framework doesn't allow for checking that some text is *not* contained in // the output, which is why we have to make the test in this kind of roundabout way) fn bar() -> int { - let s = Some(5).unwrap(); + let s = Some(5).assert(); s } diff --git a/src/test/debuginfo/type-names.rs b/src/test/debuginfo/type-names.rs index ac5fe83027527..2ea9ff7a2dd72 100644 --- a/src/test/debuginfo/type-names.rs +++ b/src/test/debuginfo/type-names.rs @@ -269,9 +269,9 @@ fn main() { let mut_ref2 = (&mut mut_generic_struct, 0i32); // Raw Pointers - let mut_ptr1: (*mut Struct1, int) = (ptr::mut_null(), 0); - let mut_ptr2: (*mut int, int) = (ptr::mut_null(), 0); - let mut_ptr3: (*mut Mod1::Mod2::Enum3<Struct1>, int) = (ptr::mut_null(), 0); + let mut_ptr1: (*mut Struct1, int) = (ptr::null_mut(), 0); + let mut_ptr2: (*mut int, int) = (ptr::null_mut(), 0); + let mut_ptr3: (*mut Mod1::Mod2::Enum3<Struct1>, int) = (ptr::null_mut(), 0); let const_ptr1: (*const Struct1, int) = (ptr::null(), 0); let const_ptr2: (*const int, int) = (ptr::null(), 0); diff --git a/src/test/run-fail/result-get-fail.rs b/src/test/run-fail/result-get-fail.rs index 216cf7211f674..e33bb992e7ba2 100644 --- a/src/test/run-fail/result-get-fail.rs +++ b/src/test/run-fail/result-get-fail.rs @@ -8,12 +8,12 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// error-pattern:called `Result::unwrap()` on an `Err` value +// error-pattern:called `Result::assert()` on an `Err` value extern crate debug; use std::result; fn main() { - println!("{:?}", result::Err::<int,String>("kitty".to_string()).unwrap()); + println!("{:?}", result::Err::<int,String>("kitty".to_string()).assert()); } diff --git a/src/test/run-make/extern-fn-reachable/main.rs b/src/test/run-make/extern-fn-reachable/main.rs index 0f759efb02539..74f374858de31 100644 --- a/src/test/run-make/extern-fn-reachable/main.rs +++ b/src/test/run-make/extern-fn-reachable/main.rs @@ -14,7 +14,7 @@ use std::os; pub fn main() { unsafe { let path = Path::new("libdylib.so"); - let a = DynamicLibrary::open(Some(&path)).unwrap(); + let a = DynamicLibrary::open(Some(&path)).assert(); assert!(a.symbol::<int>("fun1").is_ok()); assert!(a.symbol::<int>("fun2").is_err()); assert!(a.symbol::<int>("fun3").is_err()); diff --git a/src/test/run-make/unicode-input/multiple_files.rs b/src/test/run-make/unicode-input/multiple_files.rs index 295af0964b41c..9b60ea55661e3 100644 --- a/src/test/run-make/unicode-input/multiple_files.rs +++ b/src/test/run-make/unicode-input/multiple_files.rs @@ -29,7 +29,7 @@ fn random_char() -> char { _ => (0x10400, 0x1044f) }; - char::from_u32(rng.gen_range(lo, hi + 1)).unwrap() + char::from_u32(rng.gen_range(lo, hi + 1)).assert() } fn main() { @@ -39,14 +39,14 @@ fn main() { let main_file = tmpdir.join("unicode_input_multiple_files_main.rs"); { - let _ = File::create(&main_file).unwrap() + let _ = File::create(&main_file).assert() .write_str("mod unicode_input_multiple_files_chars;"); } for _ in range(0u, 100) { { let randoms = tmpdir.join("unicode_input_multiple_files_chars.rs"); - let mut w = File::create(&randoms).unwrap(); + let mut w = File::create(&randoms).assert(); for _ in range(0u, 30) { let _ = w.write_char(random_char()); } @@ -59,8 +59,8 @@ fn main() { .arg(format!("{} {}", rustc, main_file.as_str() - .unwrap()).as_slice()) - .output().unwrap(); + .assert()).as_slice()) + .output().assert(); let err = String::from_utf8_lossy(result.error.as_slice()); // positive test so that this test will be updated when the diff --git a/src/test/run-make/unicode-input/span_length.rs b/src/test/run-make/unicode-input/span_length.rs index 913f1318ebf84..808458cb3c331 100644 --- a/src/test/run-make/unicode-input/span_length.rs +++ b/src/test/run-make/unicode-input/span_length.rs @@ -28,7 +28,7 @@ fn random_char() -> char { _ => (0x10400, 0x1044f) }; - char::from_u32(rng.gen_range(lo, hi + 1)).unwrap() + char::from_u32(rng.gen_range(lo, hi + 1)).assert() } fn main() { @@ -41,7 +41,7 @@ fn main() { let n = task_rng().gen_range(3u, 20); { - let _ = write!(&mut File::create(&main_file).unwrap(), + let _ = write!(&mut File::create(&main_file).assert(), "#![feature(non_ascii_idents)] fn main() {{ {} }}", // random string of length n range(0, n).map(|_| random_char()).collect::<String>()); @@ -54,8 +54,8 @@ fn main() { .arg(format!("{} {}", rustc, main_file.as_str() - .unwrap()).as_slice()) - .output().unwrap(); + .assert()).as_slice()) + .output().assert(); let err = String::from_utf8_lossy(result.error.as_slice()); diff --git a/src/test/run-pass/auto-encode.rs b/src/test/run-pass/auto-encode.rs index b03feb8fc224b..57870a9b36757 100644 --- a/src/test/run-pass/auto-encode.rs +++ b/src/test/run-pass/auto-encode.rs @@ -34,7 +34,7 @@ fn test_rbml<'a, 'b, A: let mut wr = std::io::MemWriter::new(); let mut rbml_w = EBwriter::Encoder::new(&mut wr); a1.encode(&mut rbml_w); - let bytes = wr.get_ref(); + let bytes = wr.as_ref().assert(); let d: serialize::rbml::Doc<'a> = EBDoc::new(bytes); let mut decoder: EBReader::Decoder<'a> = EBreader::Decoder::new(d); diff --git a/src/test/run-pass/autobind.rs b/src/test/run-pass/autobind.rs index 5d1a502490140..a06915b98000f 100644 --- a/src/test/run-pass/autobind.rs +++ b/src/test/run-pass/autobind.rs @@ -9,7 +9,7 @@ // except according to those terms. -fn f<T>(x: Vec<T>) -> T { return x.move_iter().next().unwrap(); } +fn f<T>(x: Vec<T>) -> T { return x.iter_owned().next().assert(); } fn g(act: |Vec<int> | -> int) -> int { return act(vec!(1, 2, 3)); } diff --git a/src/test/run-pass/backtrace.rs b/src/test/run-pass/backtrace.rs index 0e4be12aa456d..beec844fff49d 100644 --- a/src/test/run-pass/backtrace.rs +++ b/src/test/run-pass/backtrace.rs @@ -44,38 +44,38 @@ fn runtest(me: &str) { template.env("IS_TEST", "1"); // Make sure that the stack trace is printed - let p = template.clone().arg("fail").env("RUST_BACKTRACE", "1").spawn().unwrap(); - let out = p.wait_with_output().unwrap(); + let p = template.clone().arg("fail").env("RUST_BACKTRACE", "1").spawn().assert(); + let out = p.wait_with_output().assert(); assert!(!out.status.success()); - let s = str::from_utf8(out.error.as_slice()).unwrap(); + let s = str::from_utf8(out.error.as_slice()).assert(); assert!(s.contains("stack backtrace") && s.contains("foo::h"), "bad output: {}", s); // Make sure the stack trace is *not* printed - let p = template.clone().arg("fail").spawn().unwrap(); - let out = p.wait_with_output().unwrap(); + let p = template.clone().arg("fail").spawn().assert(); + let out = p.wait_with_output().assert(); assert!(!out.status.success()); - let s = str::from_utf8(out.error.as_slice()).unwrap(); + let s = str::from_utf8(out.error.as_slice()).assert(); assert!(!s.contains("stack backtrace") && !s.contains("foo::h"), "bad output2: {}", s); // Make sure a stack trace is printed - let p = template.clone().arg("double-fail").spawn().unwrap(); - let out = p.wait_with_output().unwrap(); + let p = template.clone().arg("double-fail").spawn().assert(); + let out = p.wait_with_output().assert(); assert!(!out.status.success()); - let s = str::from_utf8(out.error.as_slice()).unwrap(); + let s = str::from_utf8(out.error.as_slice()).assert(); assert!(s.contains("stack backtrace") && s.contains("double::h"), "bad output3: {}", s); // Make sure a stack trace isn't printed too many times let p = template.clone().arg("double-fail") - .env("RUST_BACKTRACE", "1").spawn().unwrap(); - let out = p.wait_with_output().unwrap(); + .env("RUST_BACKTRACE", "1").spawn().assert(); + let out = p.wait_with_output().assert(); assert!(!out.status.success()); - let s = str::from_utf8(out.error.as_slice()).unwrap(); + let s = str::from_utf8(out.error.as_slice()).assert(); let mut i = 0; for _ in range(0i, 2) { - i += s.slice_from(i + 10).find_str("stack backtrace").unwrap() + 10; + i += s.slice_from(i + 10).find_str("stack backtrace").assert() + 10; } assert!(s.slice_from(i + 10).find_str("stack backtrace").is_none(), "bad output4: {}", s); diff --git a/src/test/run-pass/borrowed-ptr-pattern-option.rs b/src/test/run-pass/borrowed-ptr-pattern-option.rs index 9f17b9d7f95b5..f7f989662c8a7 100644 --- a/src/test/run-pass/borrowed-ptr-pattern-option.rs +++ b/src/test/run-pass/borrowed-ptr-pattern-option.rs @@ -19,5 +19,5 @@ fn select<'r>(x: &'r Option<int>, y: &'r Option<int>) -> &'r Option<int> { pub fn main() { let x = None; let y = Some(3); - assert_eq!(select(&x, &y).unwrap(), 3); + assert_eq!(select(&x, &y).assert(), 3); } diff --git a/src/test/run-pass/capturing-logging.rs b/src/test/run-pass/capturing-logging.rs index 33ee2ffd3592c..3e52300cda744 100644 --- a/src/test/run-pass/capturing-logging.rs +++ b/src/test/run-pass/capturing-logging.rs @@ -45,7 +45,7 @@ fn main() { debug!("debug"); info!("info"); }); - let s = r.read_to_string().unwrap(); + let s = r.read_to_string().assert(); assert!(s.as_slice().contains("info")); assert!(!s.as_slice().contains("debug")); } diff --git a/src/test/run-pass/class-impl-very-parameterized-trait.rs b/src/test/run-pass/class-impl-very-parameterized-trait.rs index dd3a7b86bea83..9e57f13c9f449 100644 --- a/src/test/run-pass/class-impl-very-parameterized-trait.rs +++ b/src/test/run-pass/class-impl-very-parameterized-trait.rs @@ -116,7 +116,7 @@ impl<T> cat<T> { pub fn main() { let mut nyan: cat<String> = cat::new(0, 2, "nyan".to_string()); for _ in range(1u, 5) { nyan.speak(); } - assert!(*nyan.find(&1).unwrap() == "nyan".to_string()); + assert!(*nyan.find(&1).assert() == "nyan".to_string()); assert_eq!(nyan.find(&10), None); let mut spotty: cat<cat_type> = cat::new(2, 57, tuxedo); for _ in range(0u, 6) { spotty.speak(); } diff --git a/src/test/run-pass/const-vec-of-fns.rs b/src/test/run-pass/const-vec-of-fns.rs index 202354b1326dd..86cac14b4439d 100644 --- a/src/test/run-pass/const-vec-of-fns.rs +++ b/src/test/run-pass/const-vec-of-fns.rs @@ -23,7 +23,7 @@ static mut closures: &'static mut [S<'static>] = &mut [S(f), S(f)]; pub fn main() { unsafe { for &bare_fn in bare_fns.iter() { bare_fn() } - for closure in closures.mut_iter() { + for closure in closures.iter_mut() { let S(ref mut closure) = *closure; (*closure)() } diff --git a/src/test/run-pass/core-run-destroy.rs b/src/test/run-pass/core-run-destroy.rs index 34f1e681608a3..bc95359e056cc 100644 --- a/src/test/run-pass/core-run-destroy.rs +++ b/src/test/run-pass/core-run-destroy.rs @@ -70,14 +70,14 @@ iotest!(fn test_destroy_once() { #[cfg(unix)] pub fn sleeper() -> Process { - Command::new("sleep").arg("1000").spawn().unwrap() + Command::new("sleep").arg("1000").spawn().assert() } #[cfg(windows)] pub fn sleeper() -> Process { // There's a `timeout` command on windows, but it doesn't like having // its output piped, so instead just ping ourselves a few times with // gaps in between so we're sure this process is alive for awhile - Command::new("ping").arg("127.0.0.1").arg("-n").arg("1000").spawn().unwrap() + Command::new("ping").arg("127.0.0.1").arg("-n").arg("1000").spawn().assert() } iotest!(fn test_destroy_twice() { @@ -102,19 +102,19 @@ pub fn test_destroy_actually_kills(force: bool) { static BLOCK_COMMAND: &'static str = "cmd"; // this process will stay alive indefinitely trying to read from stdin - let mut p = Command::new(BLOCK_COMMAND).spawn().unwrap(); + let mut p = Command::new(BLOCK_COMMAND).spawn().assert(); assert!(p.signal(0).is_ok()); if force { - p.signal_kill().unwrap(); + p.signal_kill().assert(); } else { - p.signal_exit().unwrap(); + p.signal_exit().assert(); } // Don't let this test time out, this should be quick let (tx, rx1) = channel(); - let mut t = timer::Timer::new().unwrap(); + let mut t = timer::Timer::new().assert(); let rx2 = t.oneshot(1000); spawn(proc() { select! { @@ -122,7 +122,7 @@ pub fn test_destroy_actually_kills(force: bool) { () = rx1.recv() => {} } }); - match p.wait().unwrap() { + match p.wait().assert() { ExitStatus(..) => fail!("expected a signal"), ExitSignal(..) => tx.send(()), } diff --git a/src/test/run-pass/deriving-encodable-decodable-cell-refcell.rs b/src/test/run-pass/deriving-encodable-decodable-cell-refcell.rs index 7164547b6b827..7831215550a11 100644 --- a/src/test/run-pass/deriving-encodable-decodable-cell-refcell.rs +++ b/src/test/run-pass/deriving-encodable-decodable-cell-refcell.rs @@ -35,7 +35,7 @@ fn main() { bar: RefCell::new( A { baz: 2 } ) }; let s = json::encode(&obj); - let obj2: B = json::decode(s.as_slice()).unwrap(); + let obj2: B = json::decode(s.as_slice()).assert(); assert!(obj.foo.get() == obj2.foo.get()); assert!(obj.bar.borrow().baz == obj2.bar.borrow().baz); } diff --git a/src/test/run-pass/deriving-encodable-decodable.rs b/src/test/run-pass/deriving-encodable-decodable.rs index 573b57fb44a46..e03e836e5f834 100644 --- a/src/test/run-pass/deriving-encodable-decodable.rs +++ b/src/test/run-pass/deriving-encodable-decodable.rs @@ -62,7 +62,7 @@ fn roundtrip<'a, T: Rand + Eq + Encodable<Encoder<'a>> + let mut w = MemWriter::new(); let mut e = Encoder::new(&mut w); obj.encode(&mut e); - let doc = rbml::Doc::new(@w.get_ref()); + let doc = rbml::Doc::new(@w.as_ref().assert()); let mut dec = Decoder::new(doc); let obj2 = Decodable::decode(&mut dec); assert!(obj == obj2); diff --git a/src/test/run-pass/glob-std.rs b/src/test/run-pass/glob-std.rs index 26b575c4b07ff..d3931ae530d67 100644 --- a/src/test/run-pass/glob-std.rs +++ b/src/test/run-pass/glob-std.rs @@ -28,9 +28,9 @@ macro_rules! assert_eq ( ($e1:expr, $e2:expr) => ( pub fn main() { fn mk_file(path: &str, directory: bool) { if directory { - io::fs::mkdir(&Path::new(path), io::UserRWX).unwrap(); + io::fs::mkdir(&Path::new(path), io::UserRWX).assert(); } else { - io::File::create(&Path::new(path)).unwrap(); + io::File::create(&Path::new(path)).assert(); } } @@ -132,7 +132,7 @@ pub fn main() { assert_eq!(glob_vec("./aaa"), vec!(abs_path("aaa"))); assert_eq!(glob_vec("./*"), glob_vec("*")); - assert_eq!(glob_vec("*/..").pop().unwrap(), abs_path(".")); + assert_eq!(glob_vec("*/..").pop().assert(), abs_path(".")); assert_eq!(glob_vec("aaa/../bbb"), vec!(abs_path("bbb"))); assert_eq!(glob_vec("nonexistent/../bbb"), Vec::new()); assert_eq!(glob_vec("aaa/tomato/tomato.txt/.."), Vec::new()); diff --git a/src/test/run-pass/hashmap-memory.rs b/src/test/run-pass/hashmap-memory.rs index f733fc1eb8f1a..f7821c6d526b0 100644 --- a/src/test/run-pass/hashmap-memory.rs +++ b/src/test/run-pass/hashmap-memory.rs @@ -85,7 +85,7 @@ mod map_reduce { find_reducer(k, cc) => { let mut c; match reducers.find(&str::from_utf8( - k.as_slice()).unwrap().to_string()) { + k.as_slice()).assert().to_string()) { Some(&_c) => { c = _c; } None => { c = 0; } } diff --git a/src/test/run-pass/ifmt.rs b/src/test/run-pass/ifmt.rs index 2a3bce18eba5e..5f9789db9723a 100644 --- a/src/test/run-pass/ifmt.rs +++ b/src/test/run-pass/ifmt.rs @@ -167,7 +167,7 @@ fn test_write() { writeln!(w, "{foo}", foo="bar"); } - let s = str::from_utf8(buf.unwrap().as_slice()).unwrap().to_string(); + let s = str::from_utf8(buf.unwrap().as_slice()).assert().to_string(); t!(s, "34helloline\nbar\n"); } @@ -191,7 +191,7 @@ fn test_format_args() { format_args!(|args| { write!(w, "{}", args); }, "test"); format_args!(|args| { write!(w, "{}", args); }, "{test}", test=3i); } - let s = str::from_utf8(buf.unwrap().as_slice()).unwrap().to_string(); + let s = str::from_utf8(buf.unwrap().as_slice()).assert().to_string(); t!(s, "1test3"); let s = format_args!(fmt::format, "hello {}", "world"); diff --git a/src/test/run-pass/issue-10626.rs b/src/test/run-pass/issue-10626.rs index 8a6e300bd15b6..86e0abd25180c 100644 --- a/src/test/run-pass/issue-10626.rs +++ b/src/test/run-pass/issue-10626.rs @@ -30,5 +30,5 @@ pub fn main () { let mut p = process::Command::new(args[0].as_slice()); p.arg("child").stdout(process::Ignored).stderr(process::Ignored); - println!("{}", p.spawn().unwrap().wait()); + println!("{}", p.spawn().assert().wait()); } diff --git a/src/test/run-pass/issue-12684.rs b/src/test/run-pass/issue-12684.rs index 37e675b52ebd8..6340ba868c851 100644 --- a/src/test/run-pass/issue-12684.rs +++ b/src/test/run-pass/issue-12684.rs @@ -23,7 +23,7 @@ fn main() { } fn customtask() { - let mut timer = std::io::timer::Timer::new().unwrap(); + let mut timer = std::io::timer::Timer::new().assert(); let periodic = timer.periodic(10); periodic.recv(); } diff --git a/src/test/run-pass/issue-12860.rs b/src/test/run-pass/issue-12860.rs index 4496a921e2448..bb4026ac67632 100644 --- a/src/test/run-pass/issue-12860.rs +++ b/src/test/run-pass/issue-12860.rs @@ -28,7 +28,7 @@ fn main() { border.insert(middle); while border.len() > 0 && connected.len() < 10000 { - let choice = *(border.iter().next().unwrap()); + let choice = *(border.iter().next().assert()); border.remove(&choice); connected.insert(choice); diff --git a/src/test/run-pass/issue-13304.rs b/src/test/run-pass/issue-13304.rs index 6ca605742efa9..ad6c4d5848754 100644 --- a/src/test/run-pass/issue-13304.rs +++ b/src/test/run-pass/issue-13304.rs @@ -51,16 +51,16 @@ fn parent(flavor: String) { let args = os::args(); let args = args.as_slice(); let mut p = io::process::Command::new(args[0].as_slice()) - .arg("child").arg(flavor).spawn().unwrap(); - p.stdin.get_mut_ref().write_str("test1\ntest2\ntest3").unwrap(); - let out = p.wait_with_output().unwrap(); + .arg("child").arg(flavor).spawn().assert(); + p.stdin.as_mut().assert().write_str("test1\ntest2\ntest3").assert(); + let out = p.wait_with_output().assert(); assert!(out.status.success()); - let s = str::from_utf8(out.output.as_slice()).unwrap(); + let s = str::from_utf8(out.output.as_slice()).assert(); assert_eq!(s, "test1\n\ntest2\n\ntest3\n"); } fn child() { for line in io::stdin().lines() { - println!("{}", line.unwrap()); + println!("{}", line.assert()); } } diff --git a/src/test/run-pass/issue-14021.rs b/src/test/run-pass/issue-14021.rs index f25a1fcdab6f2..f982416f17a71 100644 --- a/src/test/run-pass/issue-14021.rs +++ b/src/test/run-pass/issue-14021.rs @@ -22,8 +22,8 @@ pub fn main() { let json_str: String = json::Encoder::str_encode(&obj); let json_object = json::from_str(json_str.as_slice()); - let mut decoder = json::Decoder::new(json_object.unwrap()); - let mut decoded_obj: UnitLikeStruct = Decodable::decode(&mut decoder).unwrap(); + let mut decoder = json::Decoder::new(json_object.assert()); + let mut decoded_obj: UnitLikeStruct = Decodable::decode(&mut decoder).assert(); assert_eq!(obj, decoded_obj); } diff --git a/src/test/run-pass/issue-14456.rs b/src/test/run-pass/issue-14456.rs index 96290386ccc11..7ff33a94785db 100644 --- a/src/test/run-pass/issue-14456.rs +++ b/src/test/run-pass/issue-14456.rs @@ -38,9 +38,9 @@ fn main() { } fn child() { - io::stdout().write_line("foo").unwrap(); - io::stderr().write_line("bar").unwrap(); - assert_eq!(io::stdin().read_line().err().unwrap().kind, io::EndOfFile); + io::stdout().write_line("foo").assert(); + io::stderr().write_line("bar").assert(); + assert_eq!(io::stdin().read_line().err().assert().kind, io::EndOfFile); } fn test() { @@ -49,7 +49,7 @@ fn test() { .stdin(process::Ignored) .stdout(process::Ignored) .stderr(process::Ignored) - .spawn().unwrap(); - assert!(p.wait().unwrap().success()); + .spawn().assert(); + assert!(p.wait().assert().success()); } diff --git a/src/test/run-pass/issue-14940.rs b/src/test/run-pass/issue-14940.rs index e0a63331e9717..faef1325d1fb6 100644 --- a/src/test/run-pass/issue-14940.rs +++ b/src/test/run-pass/issue-14940.rs @@ -15,10 +15,10 @@ fn main() { let args = os::args(); if args.len() > 1 { let mut out = stdio::stdout(); - out.write(['a' as u8, ..128 * 1024]).unwrap(); + out.write(['a' as u8, ..128 * 1024]).assert(); } else { let out = Command::new(args.get(0).as_slice()).arg("child").output(); - let out = out.unwrap(); + let out = out.assert(); assert!(out.status.success()); } } diff --git a/src/test/run-pass/issue-14959.rs b/src/test/run-pass/issue-14959.rs index af0bc78094e5f..06bd64798ddf2 100644 --- a/src/test/run-pass/issue-14959.rs +++ b/src/test/run-pass/issue-14959.rs @@ -39,7 +39,7 @@ impl<'a, 'b> Fn<(&'b mut Response,),()> for SendFile<'a> { impl<Rq: Request, Rs: Response> Ingot<Rq, Rs> for HelloWorld { fn enter(&mut self, _req: &mut Rq, res: &mut Rs, alloy: &mut Alloy) -> Status { - let send_file = alloy.find::<SendFile>().unwrap(); + let send_file = alloy.find::<SendFile>().assert(); send_file(res); Continue } diff --git a/src/test/run-pass/issue-15149.rs b/src/test/run-pass/issue-15149.rs index cb4410cc1aad9..0ac3dd74af704 100644 --- a/src/test/run-pass/issue-15149.rs +++ b/src/test/run-pass/issue-15149.rs @@ -38,17 +38,17 @@ fn main() { fn test() { // If we're the parent, copy our own binary to a tempr directory, and then // make it executable. - let dir = TempDir::new("mytest").unwrap(); - let me = os::self_exe_name().unwrap(); + let dir = TempDir::new("mytest").assert(); + let me = os::self_exe_name().assert(); let dest = dir.path().join(format!("mytest{}", os::consts::EXE_SUFFIX)); - fs::copy(&me, &dest).unwrap(); + fs::copy(&me, &dest).assert(); // Append the temp directory to our own PATH. let mut path = os::split_paths(os::getenv("PATH").unwrap_or(String::new())); path.push(dir.path().clone()); - let path = os::join_paths(path.as_slice()).unwrap(); + let path = os::join_paths(path.as_slice()).assert(); Command::new("mytest").env("PATH", path.as_slice()) .arg("child") - .spawn().unwrap(); + .spawn().assert(); } diff --git a/src/test/run-pass/issue-15571.rs b/src/test/run-pass/issue-15571.rs index 0ef0fc83c9456..ee4229a277c03 100644 --- a/src/test/run-pass/issue-15571.rs +++ b/src/test/run-pass/issue-15571.rs @@ -16,7 +16,7 @@ fn match_on_local() { foo = Some(x); } } - println!("'{}'", foo.unwrap()); + println!("'{}'", foo.assert()); } fn match_on_arg(mut foo: Option<Box<int>>) { @@ -26,7 +26,7 @@ fn match_on_arg(mut foo: Option<Box<int>>) { foo = Some(x); } } - println!("'{}'", foo.unwrap()); + println!("'{}'", foo.assert()); } fn match_on_binding() { @@ -38,7 +38,7 @@ fn match_on_binding() { foo = Some(x); } } - println!("'{}'", foo.unwrap()); + println!("'{}'", foo.assert()); } } } @@ -52,7 +52,7 @@ fn match_on_upvar() { foo = Some(x); } } - println!("'{}'", foo.unwrap()); + println!("'{}'", foo.assert()); })(); } diff --git a/src/test/run-pass/issue-16151.rs b/src/test/run-pass/issue-16151.rs index 9cc571c7819cd..f55ff829adae0 100644 --- a/src/test/run-pass/issue-16151.rs +++ b/src/test/run-pass/issue-16151.rs @@ -26,7 +26,7 @@ fn main() { { let mut fragments = vec![Fragment, Fragment, Fragment]; let _new_fragments: Vec<Fragment> = mem::replace(&mut fragments, vec![]) - .move_iter() + .iter_owned() .skip_while(|_fragment| { true }).collect(); diff --git a/src/test/run-pass/issue-2718.rs b/src/test/run-pass/issue-2718.rs index c52dd5ce5e4e3..5767af00076ed 100644 --- a/src/test/run-pass/issue-2718.rs +++ b/src/test/run-pass/issue-2718.rs @@ -1,4 +1,3 @@ - // Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. @@ -115,7 +114,7 @@ pub mod pipes { empty | blocked => { task::deschedule(); } full => { let payload = replace(&mut p.payload, None); - return Some(payload.unwrap()) + return Some(payload.assert()) } terminated => { assert_eq!(old_state, terminated); @@ -171,7 +170,7 @@ pub mod pipes { let self_p: &mut Option<*const packet<T>> = mem::transmute(&self.p); let p = replace(self_p, None); - sender_terminate(p.unwrap()) + sender_terminate(p.assert()) } } } @@ -179,7 +178,7 @@ pub mod pipes { impl<T:Send> send_packet<T> { pub fn unwrap(&mut self) -> *const packet<T> { - replace(&mut self.p, None).unwrap() + replace(&mut self.p, None).assert() } } @@ -201,7 +200,7 @@ pub mod pipes { let self_p: &mut Option<*const packet<T>> = mem::transmute(&self.p); let p = replace(self_p, None); - receiver_terminate(p.unwrap()) + receiver_terminate(p.assert()) } } } @@ -209,7 +208,7 @@ pub mod pipes { impl<T:Send> recv_packet<T> { pub fn unwrap(&mut self) -> *const packet<T> { - replace(&mut self.p, None).unwrap() + replace(&mut self.p, None).assert() } } @@ -271,7 +270,7 @@ pub mod pingpong { if packet.is_none() { fail!("sender closed the connection") } - (pingpong::liberate_pong(packet.unwrap()), ()) + (pingpong::liberate_pong(packet.assert()), ()) } } @@ -286,7 +285,7 @@ pub mod pingpong { if packet.is_none() { fail!("sender closed the connection") } - (pingpong::liberate_ping(packet.unwrap()), ()) + (pingpong::liberate_ping(packet.assert()), ()) } pub fn do_pong(c: pong) -> ping { diff --git a/src/test/run-pass/issue-4016.rs b/src/test/run-pass/issue-4016.rs index 20b818f47d477..2256438ed9077 100644 --- a/src/test/run-pass/issue-4016.rs +++ b/src/test/run-pass/issue-4016.rs @@ -16,9 +16,9 @@ use serialize::{json, Decodable}; trait JD : Decodable<json::Decoder, json::DecoderError> { } fn exec<T: JD>() { - let doc = json::from_str("").unwrap(); + let doc = json::from_str("").assert(); let mut decoder = json::Decoder::new(doc); - let _v: T = Decodable::decode(&mut decoder).unwrap(); + let _v: T = Decodable::decode(&mut decoder).assert(); fail!() } diff --git a/src/test/run-pass/issue-4036.rs b/src/test/run-pass/issue-4036.rs index 48e32922ce708..ead93a09574a1 100644 --- a/src/test/run-pass/issue-4036.rs +++ b/src/test/run-pass/issue-4036.rs @@ -17,7 +17,7 @@ extern crate serialize; use serialize::{json, Decodable}; pub fn main() { - let json = json::from_str("[1]").unwrap(); + let json = json::from_str("[1]").assert(); let mut decoder = json::Decoder::new(json); - let _x: Vec<int> = Decodable::decode(&mut decoder).unwrap(); + let _x: Vec<int> = Decodable::decode(&mut decoder).assert(); } diff --git a/src/test/run-pass/issue-8398.rs b/src/test/run-pass/issue-8398.rs index 0884db633264e..d12475f6b7640 100644 --- a/src/test/run-pass/issue-8398.rs +++ b/src/test/run-pass/issue-8398.rs @@ -11,7 +11,7 @@ use std::io; fn foo(a: &mut io::Writer) { - a.write([]).unwrap(); + a.write([]).assert(); } pub fn main(){} diff --git a/src/test/run-pass/issue-9259.rs b/src/test/run-pass/issue-9259.rs index 35f51efe135ca..bd664c5bc69d1 100644 --- a/src/test/run-pass/issue-9259.rs +++ b/src/test/run-pass/issue-9259.rs @@ -19,5 +19,5 @@ pub fn main() { a: &["test".to_string()], b: Some(b), }; - assert_eq!(a.b.get_ref()[0].as_slice(), "foo"); + assert_eq!(a.b.as_ref().assert()[0].as_slice(), "foo"); } diff --git a/src/test/run-pass/issue-9396.rs b/src/test/run-pass/issue-9396.rs index 9f08f1db41057..dc22aa6f2d61a 100644 --- a/src/test/run-pass/issue-9396.rs +++ b/src/test/run-pass/issue-9396.rs @@ -14,7 +14,7 @@ use std::io::timer::Timer; pub fn main() { let (tx, rx) = channel(); spawn(proc (){ - let mut timer = Timer::new().unwrap(); + let mut timer = Timer::new().assert(); timer.sleep(10); tx.send(()); }); diff --git a/src/test/run-pass/logging-separate-lines.rs b/src/test/run-pass/logging-separate-lines.rs index ad7ba02970f05..67c19860749e9 100644 --- a/src/test/run-pass/logging-separate-lines.rs +++ b/src/test/run-pass/logging-separate-lines.rs @@ -32,9 +32,9 @@ fn main() { let p = Command::new(args[0].as_slice()) .arg("child") - .spawn().unwrap().wait_with_output().unwrap(); + .spawn().assert().wait_with_output().assert(); assert!(p.status.success()); - let mut lines = str::from_utf8(p.error.as_slice()).unwrap().lines(); - assert!(lines.next().unwrap().contains("foo")); - assert!(lines.next().unwrap().contains("bar")); + let mut lines = str::from_utf8(p.error.as_slice()).assert().lines(); + assert!(lines.next().assert().contains("foo")); + assert!(lines.next().assert().contains("bar")); } diff --git a/src/test/run-pass/macro-local-data-key.rs b/src/test/run-pass/macro-local-data-key.rs index 730b0b08d451a..a7459a63aaa24 100644 --- a/src/test/run-pass/macro-local-data-key.rs +++ b/src/test/run-pass/macro-local-data-key.rs @@ -21,6 +21,6 @@ pub fn main() { foo.replace(Some(3)); bar::baz.replace(Some(-10.0)); - assert_eq!(*foo.get().unwrap(), 3); - assert_eq!(*bar::baz.get().unwrap(), -10.0); + assert_eq!(*foo.get().assert(), 3); + assert_eq!(*bar::baz.get().assert(), -10.0); } diff --git a/src/test/run-pass/mutability-inherits-through-fixed-length-vec.rs b/src/test/run-pass/mutability-inherits-through-fixed-length-vec.rs index ffab06e2203e8..ef0bc75c32661 100644 --- a/src/test/run-pass/mutability-inherits-through-fixed-length-vec.rs +++ b/src/test/run-pass/mutability-inherits-through-fixed-length-vec.rs @@ -16,7 +16,7 @@ fn test1() { fn test2() { let mut ints = [0i, ..32]; - for i in ints.mut_iter() { *i += 22; } + for i in ints.iter_mut() { *i += 22; } for i in ints.iter() { assert!(*i == 22); } } diff --git a/src/test/run-pass/newtype-polymorphic.rs b/src/test/run-pass/newtype-polymorphic.rs index 4d15e4fe21593..d61114546ac94 100644 --- a/src/test/run-pass/newtype-polymorphic.rs +++ b/src/test/run-pass/newtype-polymorphic.rs @@ -19,7 +19,7 @@ fn myvec_deref<X:Clone>(mv: myvec<X>) -> Vec<X> { fn myvec_elt<X>(mv: myvec<X>) -> X { let myvec(v) = mv; - return v.move_iter().next().unwrap(); + return v.iter_owned().next().assert(); } pub fn main() { diff --git a/src/test/run-pass/nullable-pointer-iotareduction.rs b/src/test/run-pass/nullable-pointer-iotareduction.rs index a7d52b87e551a..a230131a3ada2 100644 --- a/src/test/run-pass/nullable-pointer-iotareduction.rs +++ b/src/test/run-pass/nullable-pointer-iotareduction.rs @@ -45,7 +45,7 @@ macro_rules! check_option { assert!(option::None::<$T>.is_none()); let e = $e; let s_ = option::Some::<$T>(e); - let $v = s_.get_ref(); + let $v = s_.as_ref().assert(); $chk }} } @@ -60,7 +60,7 @@ macro_rules! check_fancy { let t_ = Thing::<$T>(23, e); match t_.get_ref() { (23, $v) => { $chk } - _ => fail!("Thing::<{}>(23, {}).get_ref() != (23, _)", + _ => fail!("Thing::<{}>(23, {}).as_ref().assert() != (23, _)", stringify!($T), stringify!($e)) } }} diff --git a/src/test/run-pass/numeric-method-autoexport.rs b/src/test/run-pass/numeric-method-autoexport.rs index 585ade71fc603..b29e294515927 100644 --- a/src/test/run-pass/numeric-method-autoexport.rs +++ b/src/test/run-pass/numeric-method-autoexport.rs @@ -34,6 +34,6 @@ pub fn main() { // floats // num - assert_eq!(10f32.to_int().unwrap(), 10); - assert_eq!(10f64.to_int().unwrap(), 10); + assert_eq!(10f32.to_int().assert(), 10); + assert_eq!(10f64.to_int().assert(), 10); } diff --git a/src/test/run-pass/out-of-stack.rs b/src/test/run-pass/out-of-stack.rs index 7f2f9f9ece83d..13462bccc7fa3 100644 --- a/src/test/run-pass/out-of-stack.rs +++ b/src/test/run-pass/out-of-stack.rs @@ -39,12 +39,12 @@ fn main() { } else if args.len() > 1 && args[1].as_slice() == "loud" { loud_recurse(); } else { - let silent = Command::new(args[0].as_slice()).arg("silent").output().unwrap(); + let silent = Command::new(args[0].as_slice()).arg("silent").output().assert(); assert!(!silent.status.success()); let error = String::from_utf8_lossy(silent.error.as_slice()); assert!(error.as_slice().contains("has overflowed its stack")); - let loud = Command::new(args[0].as_slice()).arg("loud").output().unwrap(); + let loud = Command::new(args[0].as_slice()).arg("loud").output().assert(); assert!(!loud.status.success()); let error = String::from_utf8_lossy(silent.error.as_slice()); assert!(error.as_slice().contains("has overflowed its stack")); diff --git a/src/test/run-pass/overloaded-autoderef-vtable.rs b/src/test/run-pass/overloaded-autoderef-vtable.rs index f71afb9650743..d75d72c5a513c 100644 --- a/src/test/run-pass/overloaded-autoderef-vtable.rs +++ b/src/test/run-pass/overloaded-autoderef-vtable.rs @@ -20,7 +20,7 @@ trait Helper<T> { impl<T> Helper<T> for Option<T> { fn helper_borrow(&self) -> &T { - self.as_ref().unwrap() + self.as_ref().assert() } } diff --git a/src/test/run-pass/process-detach.rs b/src/test/run-pass/process-detach.rs index 69ff9fca6ceb9..8627425f4306b 100644 --- a/src/test/run-pass/process-detach.rs +++ b/src/test/run-pass/process-detach.rs @@ -37,10 +37,10 @@ fn main() { // we shouldn't die because of an interrupt let mut l = Listener::new(); - l.register(Interrupt).unwrap(); + l.register(Interrupt).assert(); // spawn the child - let mut p = Command::new("/bin/sh").arg("-c").arg("read a").detached().spawn().unwrap(); + let mut p = Command::new("/bin/sh").arg("-c").arg("read a").detached().spawn().assert(); // send an interrupt to everyone in our process group unsafe { libc::funcs::posix88::signal::kill(0, libc::SIGINT); } @@ -48,7 +48,7 @@ fn main() { // Wait for the child process to die (terminate it's stdin and the read // should fail). drop(p.stdin.take()); - match p.wait().unwrap() { + match p.wait().assert() { process::ExitStatus(..) => {} process::ExitSignal(..) => fail!() } diff --git a/src/test/run-pass/process-spawn-with-unicode-params.rs b/src/test/run-pass/process-spawn-with-unicode-params.rs index de86ca179b7d7..115c4db5dfc92 100644 --- a/src/test/run-pass/process-spawn-with-unicode-params.rs +++ b/src/test/run-pass/process-spawn-with-unicode-params.rs @@ -28,7 +28,7 @@ fn main() { let my_args = os::args(); let my_cwd = os::getcwd(); let my_env = os::env(); - let my_path = Path::new(os::self_exe_name().unwrap()); + let my_path = Path::new(os::self_exe_name().assert()); let my_dir = my_path.dir_path(); let my_ext = my_path.extension_str().unwrap_or(""); @@ -59,7 +59,7 @@ fn main() { .arg(arg) .cwd(&cwd) .env_set_all(my_env.append_one(env).as_slice()) - .spawn().unwrap().wait_with_output().unwrap(); + .spawn().assert().wait_with_output().assert(); // display the output assert!(io::stdout().write(p.output.as_slice()).is_ok()); diff --git a/src/test/run-pass/reflect-visit-type.rs b/src/test/run-pass/reflect-visit-type.rs index 596e56b424a30..5de7edb24e579 100644 --- a/src/test/run-pass/reflect-visit-type.rs +++ b/src/test/run-pass/reflect-visit-type.rs @@ -144,7 +144,7 @@ pub fn main() { println!("type: {}", (*s).clone()); } - let vec_types: Vec<String> = v.types.clone().move_iter().collect(); + let vec_types: Vec<String> = v.types.clone().iter_owned().collect(); assert_eq!(vec_types, vec!("bool".to_string(), "int".to_string(), "i8".to_string(), "i16".to_string())); } diff --git a/src/test/run-pass/regions-dependent-addr-of.rs b/src/test/run-pass/regions-dependent-addr-of.rs index 252c0b5578ac6..16e5c4e582aa0 100644 --- a/src/test/run-pass/regions-dependent-addr-of.rs +++ b/src/test/run-pass/regions-dependent-addr-of.rs @@ -106,13 +106,13 @@ pub fn main() { assert_eq!(*p, a.value.v5.f); let p = get_v6_a(&a, 1); - assert_eq!(*p, a.value.v6.unwrap().f); + assert_eq!(*p, a.value.v6.assert().f); let p = get_v6_b(&a, 1); - assert_eq!(*p, a.value.v6.unwrap().f); + assert_eq!(*p, a.value.v6.assert().f); let p = get_v6_c(&a, 1); - assert_eq!(*p, a.value.v6.unwrap().f); + assert_eq!(*p, a.value.v6.assert().f); let p = get_v5_ref(&a, 1); assert_eq!(*p, a.value.v5.f); diff --git a/src/test/run-pass/running-with-no-runtime.rs b/src/test/run-pass/running-with-no-runtime.rs index 44435dc2398dc..dba96d4f77566 100644 --- a/src/test/run-pass/running-with-no-runtime.rs +++ b/src/test/run-pass/running-with-no-runtime.rs @@ -43,14 +43,14 @@ fn main() { let args = os::args(); let me = args.get(0).as_slice(); - pass(Command::new(me).arg(&[1u8]).output().unwrap()); - pass(Command::new(me).arg(&[2u8]).output().unwrap()); - pass(Command::new(me).arg(&[3u8]).output().unwrap()); - pass(Command::new(me).arg(&[4u8]).output().unwrap()); - pass(Command::new(me).arg(&[5u8]).output().unwrap()); - pass(Command::new(me).arg(&[6u8]).output().unwrap()); - pass(Command::new(me).arg(&[7u8]).output().unwrap()); - pass(Command::new(me).arg(&[8u8]).output().unwrap()); + pass(Command::new(me).arg(&[1u8]).output().assert()); + pass(Command::new(me).arg(&[2u8]).output().assert()); + pass(Command::new(me).arg(&[3u8]).output().assert()); + pass(Command::new(me).arg(&[4u8]).output().assert()); + pass(Command::new(me).arg(&[5u8]).output().assert()); + pass(Command::new(me).arg(&[6u8]).output().assert()); + pass(Command::new(me).arg(&[7u8]).output().assert()); + pass(Command::new(me).arg(&[8u8]).output().assert()); } fn pass(output: ProcessOutput) { diff --git a/src/test/run-pass/send_str_treemap.rs b/src/test/run-pass/send_str_treemap.rs index e51c94428dae3..d10d5c74f0577 100644 --- a/src/test/run-pass/send_str_treemap.rs +++ b/src/test/run-pass/send_str_treemap.rs @@ -61,7 +61,7 @@ pub fn main() { assert_eq!(map.find(&Owned("def".to_string())), Some(&d)); assert!(map.pop(&Slice("foo")).is_some()); - assert_eq!(map.move_iter().map(|(k, v)| format!("{}{}", k, v)) + assert_eq!(map.iter_owned().map(|(k, v)| format!("{}{}", k, v)) .collect::<Vec<String>>() .concat(), "abc50bcd51cde52def53".to_string()); diff --git a/src/test/run-pass/signal-exit-status.rs b/src/test/run-pass/signal-exit-status.rs index c28e128dd0527..734407368fef5 100644 --- a/src/test/run-pass/signal-exit-status.rs +++ b/src/test/run-pass/signal-exit-status.rs @@ -22,7 +22,7 @@ pub fn main() { // Raise a segfault. unsafe { *(0 as *mut int) = 0; } } else { - let status = Command::new(args[0].as_slice()).arg("signal").status().unwrap(); + let status = Command::new(args[0].as_slice()).arg("signal").status().assert(); // Windows does not have signal, so we get exit status 0xC0000028 (STATUS_BAD_STACK). match status { ExitSignal(_) if cfg!(unix) => {}, diff --git a/src/test/run-pass/sigpipe-should-be-ignored.rs b/src/test/run-pass/sigpipe-should-be-ignored.rs index 8c68ef173a5e7..70b6f8ff57a44 100644 --- a/src/test/run-pass/sigpipe-should-be-ignored.rs +++ b/src/test/run-pass/sigpipe-should-be-ignored.rs @@ -16,7 +16,7 @@ use std::io::PipeStream; use std::io::Command; fn test() { - let os::Pipe { reader, writer } = unsafe { os::pipe().unwrap() }; + let os::Pipe { reader, writer } = unsafe { os::pipe().assert() }; let reader = PipeStream::open(reader); let mut writer = PipeStream::open(writer); drop(reader); @@ -32,6 +32,6 @@ fn main() { } let mut p = Command::new(args[0].as_slice()) - .arg("test").spawn().unwrap(); - assert!(p.wait().unwrap().success()); + .arg("test").spawn().assert(); + assert!(p.wait().assert().success()); } diff --git a/src/test/run-pass/stat.rs b/src/test/run-pass/stat.rs index d9eae02670f38..e03e3287d4ede 100644 --- a/src/test/run-pass/stat.rs +++ b/src/test/run-pass/stat.rs @@ -12,7 +12,7 @@ use std::io::{File, TempDir}; pub fn main() { - let dir = TempDir::new_in(&Path::new("."), "").unwrap(); + let dir = TempDir::new_in(&Path::new("."), "").assert(); let path = dir.path().join("file"); { @@ -28,5 +28,5 @@ pub fn main() { } assert!(path.exists()); - assert_eq!(path.stat().unwrap().size, 1000); + assert_eq!(path.stat().assert().size, 1000); } diff --git a/src/test/run-pass/task-comm-3.rs b/src/test/run-pass/task-comm-3.rs index afeb9125fe64a..eb0449efa6a28 100644 --- a/src/test/run-pass/task-comm-3.rs +++ b/src/test/run-pass/task-comm-3.rs @@ -62,7 +62,7 @@ fn test00() { } // Join spawned tasks... - for r in results.mut_iter() { r.get_ref(); } + for r in results.iter_mut() { r.get_ref(); } println!("Completed: Final number is: "); println!("{:?}", sum); diff --git a/src/test/run-pass/task-stderr.rs b/src/test/run-pass/task-stderr.rs index ceffd1e363667..1b36d3f1d418e 100644 --- a/src/test/run-pass/task-stderr.rs +++ b/src/test/run-pass/task-stderr.rs @@ -21,6 +21,6 @@ fn main() { }); assert!(res.is_err()); - let output = reader.read_to_string().unwrap(); + let output = reader.read_to_string().assert(); assert!(output.as_slice().contains("Hello, world!")); } diff --git a/src/test/run-pass/tcp-connect-timeouts.rs b/src/test/run-pass/tcp-connect-timeouts.rs index 6f6fff15814d5..cef96f9ab4e36 100644 --- a/src/test/run-pass/tcp-connect-timeouts.rs +++ b/src/test/run-pass/tcp-connect-timeouts.rs @@ -64,7 +64,7 @@ iotest!(fn eventual_timeout() { let (tx1, rx1) = channel(); let (_tx2, rx2) = channel::<()>(); native::task::spawn(proc() { - let _l = TcpListener::bind(host.as_slice(), port).unwrap().listen(); + let _l = TcpListener::bind(host.as_slice(), port).assert().listen(); tx1.send(()); let _ = rx2.recv_opt(); }); @@ -85,7 +85,7 @@ iotest!(fn timeout_success() { let addr = next_test_ip4(); let host = addr.ip.to_string(); let port = addr.port; - let _l = TcpListener::bind(host.as_slice(), port).unwrap().listen(); + let _l = TcpListener::bind(host.as_slice(), port).assert().listen(); assert!(TcpStream::connect_timeout(addr, 1000).is_ok()); }) diff --git a/src/test/run-pass/tcp-stress.rs b/src/test/run-pass/tcp-stress.rs index f52a3455e4157..305ff7ab7da3c 100644 --- a/src/test/run-pass/tcp-stress.rs +++ b/src/test/run-pass/tcp-stress.rs @@ -40,8 +40,8 @@ fn main() { let (tx, rx) = channel(); spawn(proc() { - let mut listener = TcpListener::bind("127.0.0.1", 0).unwrap(); - tx.send(listener.socket_name().unwrap()); + let mut listener = TcpListener::bind("127.0.0.1", 0).assert(); + tx.send(listener.socket_name().assert()); let mut acceptor = listener.listen(); loop { let mut stream = match acceptor.accept() { diff --git a/src/test/run-pass/tempfile.rs b/src/test/run-pass/tempfile.rs index 4355bf4127fc4..93f5de91beb67 100644 --- a/src/test/run-pass/tempfile.rs +++ b/src/test/run-pass/tempfile.rs @@ -27,7 +27,7 @@ use std::task; fn test_tempdir() { let path = { - let p = TempDir::new_in(&Path::new("."), "foobar").unwrap(); + let p = TempDir::new_in(&Path::new("."), "foobar").assert(); let p = p.path(); assert!(p.as_vec().ends_with(b"foobar")); p.clone() @@ -38,7 +38,7 @@ fn test_tempdir() { fn test_rm_tempdir() { let (tx, rx) = channel(); let f: proc():Send = proc() { - let tmp = TempDir::new("test_rm_tempdir").unwrap(); + let tmp = TempDir::new("test_rm_tempdir").assert(); tx.send(tmp.path().clone()); fail!("fail to unwind past `tmp`"); }; @@ -46,7 +46,7 @@ fn test_rm_tempdir() { let path = rx.recv(); assert!(!path.exists()); - let tmp = TempDir::new("test_rm_tempdir").unwrap(); + let tmp = TempDir::new("test_rm_tempdir").assert(); let path = tmp.path().clone(); let f: proc():Send = proc() { let _tmp = tmp; @@ -58,7 +58,7 @@ fn test_rm_tempdir() { let path; { let f = proc() { - TempDir::new("test_rm_tempdir").unwrap() + TempDir::new("test_rm_tempdir").assert() }; let tmp = task::try(f).ok().expect("test_rm_tmdir"); path = tmp.path().clone(); @@ -68,7 +68,7 @@ fn test_rm_tempdir() { let path; { - let tmp = TempDir::new("test_rm_tempdir").unwrap(); + let tmp = TempDir::new("test_rm_tempdir").assert(); path = tmp.unwrap(); } assert!(path.exists()); @@ -79,7 +79,7 @@ fn test_rm_tempdir() { fn test_rm_tempdir_close() { let (tx, rx) = channel(); let f: proc():Send = proc() { - let tmp = TempDir::new("test_rm_tempdir").unwrap(); + let tmp = TempDir::new("test_rm_tempdir").assert(); tx.send(tmp.path().clone()); tmp.close(); fail!("fail to unwind past `tmp`"); @@ -88,7 +88,7 @@ fn test_rm_tempdir_close() { let path = rx.recv(); assert!(!path.exists()); - let tmp = TempDir::new("test_rm_tempdir").unwrap(); + let tmp = TempDir::new("test_rm_tempdir").assert(); let path = tmp.path().clone(); let f: proc():Send = proc() { let tmp = tmp; @@ -101,7 +101,7 @@ fn test_rm_tempdir_close() { let path; { let f = proc() { - TempDir::new("test_rm_tempdir").unwrap() + TempDir::new("test_rm_tempdir").assert() }; let tmp = task::try(f).ok().expect("test_rm_tmdir"); path = tmp.path().clone(); @@ -112,7 +112,7 @@ fn test_rm_tempdir_close() { let path; { - let tmp = TempDir::new("test_rm_tempdir").unwrap(); + let tmp = TempDir::new("test_rm_tempdir").assert(); path = tmp.unwrap(); } assert!(path.exists()); @@ -178,7 +178,7 @@ pub fn test_rmdir_recursive_ok() { pub fn dont_double_fail() { let r: Result<(), _> = task::try(proc() { - let tmpdir = TempDir::new("test").unwrap(); + let tmpdir = TempDir::new("test").assert(); // Remove the temporary directory so that TempDir sees // an error on drop fs::rmdir(tmpdir.path()); diff --git a/src/test/run-pass/trait-inheritance-num.rs b/src/test/run-pass/trait-inheritance-num.rs index 3b61a85995f63..ec53aa2c9e108 100644 --- a/src/test/run-pass/trait-inheritance-num.rs +++ b/src/test/run-pass/trait-inheritance-num.rs @@ -16,7 +16,7 @@ pub trait NumExt: Num + NumCast + PartialEq + PartialOrd {} pub trait FloatExt: NumExt {} -fn greater_than_one<T:NumExt>(n: &T) -> bool { *n > NumCast::from(1i).unwrap() } -fn greater_than_one_float<T:FloatExt>(n: &T) -> bool { *n > NumCast::from(1i).unwrap() } +fn greater_than_one<T:NumExt>(n: &T) -> bool { *n > NumCast::from(1i).assert() } +fn greater_than_one_float<T:FloatExt>(n: &T) -> bool { *n > NumCast::from(1i).assert() } pub fn main() {} diff --git a/src/test/run-pass/trait-inheritance-num0.rs b/src/test/run-pass/trait-inheritance-num0.rs index 58709ab4c850e..953b16f39e1e6 100644 --- a/src/test/run-pass/trait-inheritance-num0.rs +++ b/src/test/run-pass/trait-inheritance-num0.rs @@ -21,7 +21,7 @@ trait Num { pub trait NumExt: Num + NumCast { } fn greater_than_one<T:NumExt>(n: &T) -> bool { - n.gt(&NumCast::from(1i).unwrap()) + n.gt(&NumCast::from(1i).assert()) } pub fn main() {} diff --git a/src/test/run-pass/trait-inheritance-num1.rs b/src/test/run-pass/trait-inheritance-num1.rs index 5a2e88631a6e7..381115407997f 100644 --- a/src/test/run-pass/trait-inheritance-num1.rs +++ b/src/test/run-pass/trait-inheritance-num1.rs @@ -14,7 +14,7 @@ use std::num::NumCast; pub trait NumExt: Num + NumCast + PartialOrd { } fn greater_than_one<T:NumExt>(n: &T) -> bool { - *n > NumCast::from(1i).unwrap() + *n > NumCast::from(1i).assert() } pub fn main() {} diff --git a/src/test/run-pass/trait-inheritance-num3.rs b/src/test/run-pass/trait-inheritance-num3.rs index 415d0a04c8b9c..455185dc4cb2c 100644 --- a/src/test/run-pass/trait-inheritance-num3.rs +++ b/src/test/run-pass/trait-inheritance-num3.rs @@ -16,7 +16,7 @@ pub trait NumExt: PartialEq + PartialOrd + Num + NumCast {} impl NumExt for f32 {} fn num_eq_one<T:NumExt>(n: T) { - println!("{}", n == NumCast::from(1i).unwrap()) + println!("{}", n == NumCast::from(1i).assert()) } pub fn main() { diff --git a/src/test/run-pass/trait-inheritance-num5.rs b/src/test/run-pass/trait-inheritance-num5.rs index e3d631013c0fb..9155f460ec34f 100644 --- a/src/test/run-pass/trait-inheritance-num5.rs +++ b/src/test/run-pass/trait-inheritance-num5.rs @@ -17,7 +17,7 @@ impl NumExt for f32 {} impl NumExt for int {} fn num_eq_one<T:NumExt>() -> T { - NumCast::from(1i).unwrap() + NumCast::from(1i).assert() } pub fn main() { diff --git a/src/test/run-pass/trait-with-bounds-default.rs b/src/test/run-pass/trait-with-bounds-default.rs index ec9f666eb198d..298951fdfb765 100644 --- a/src/test/run-pass/trait-with-bounds-default.rs +++ b/src/test/run-pass/trait-with-bounds-default.rs @@ -32,7 +32,7 @@ impl Getter<int> for int { } impl<T: Clone> Getter<T> for Option<T> { - fn do_get(&self) -> T { self.get_ref().clone() } + fn do_get(&self) -> T { self.as_ref().assert().clone() } } diff --git a/src/test/run-pass/unit-like-struct-drop-run.rs b/src/test/run-pass/unit-like-struct-drop-run.rs index 3a1cc0331a3e6..8df3b3a5350ae 100644 --- a/src/test/run-pass/unit-like-struct-drop-run.rs +++ b/src/test/run-pass/unit-like-struct-drop-run.rs @@ -26,6 +26,6 @@ pub fn main() { let _b = Foo; }); - let s = x.unwrap_err().downcast::<&'static str>().unwrap(); + let s = x.assert_err().downcast::<&'static str>().assert(); assert_eq!(s.as_slice(), "This failure should happen."); } diff --git a/src/test/run-pass/variadic-ffi.rs b/src/test/run-pass/variadic-ffi.rs index 570b881650ae8..a4c829a7ca844 100644 --- a/src/test/run-pass/variadic-ffi.rs +++ b/src/test/run-pass/variadic-ffi.rs @@ -22,7 +22,7 @@ unsafe fn check<T>(expected: &str, f: |*mut c_char| -> T) { let mut x = [0i8, ..50]; f(&mut x[0] as *mut c_char); let res = CString::new(&x[0], false); - assert_eq!(expected, res.as_str().unwrap()); + assert_eq!(expected, res.as_str().assert()); } pub fn main() {