From 0ac7a219f043d3b1c8c239089d9dd6e6c9fa830b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Marvin=20L=C3=B6bel?= Date: Sun, 4 Aug 2013 01:59:24 +0200 Subject: [PATCH] Updated std::Option, std::Either and std::Result - Made naming schemes consistent between Option, Result and Either - Changed Options Add implementation to work like the maybe monad (return None if any of the inputs is None) - Removed duplicate Option::get and renamed all related functions to use the term `unwrap` instead --- src/compiletest/compiletest.rs | 6 +- src/compiletest/runtest.rs | 12 +- src/libextra/base64.rs | 20 +- src/libextra/fileinput.rs | 4 +- src/libextra/getopts.rs | 8 +- src/libextra/num/bigint.rs | 12 +- src/libextra/ringbuf.rs | 12 +- src/libextra/semver.rs | 4 +- src/libextra/smallintmap.rs | 6 +- src/libextra/test.rs | 57 ++- src/libextra/url.rs | 4 +- src/librustc/back/link.rs | 4 +- src/librustc/back/passes.rs | 6 +- src/librustc/driver/driver.rs | 2 +- src/librustc/front/test.rs | 4 +- src/librustc/middle/astencode.rs | 10 +- src/librustc/middle/borrowck/check_loans.rs | 2 +- src/librustc/middle/check_match.rs | 12 +- src/librustc/middle/const_eval.rs | 4 +- src/librustc/middle/privacy.rs | 2 +- src/librustc/middle/resolve.rs | 4 +- src/librustc/middle/trans/_match.rs | 8 +- src/librustc/middle/trans/adt.rs | 2 +- src/librustc/middle/trans/base.rs | 22 +- src/librustc/middle/trans/build.rs | 4 +- src/librustc/middle/trans/cabi.rs | 2 +- src/librustc/middle/trans/closure.rs | 4 +- src/librustc/middle/trans/common.rs | 4 +- src/librustc/middle/trans/controlflow.rs | 4 +- src/librustc/middle/trans/debuginfo.rs | 4 +- src/librustc/middle/trans/foreign.rs | 20 +- src/librustc/middle/trans/glue.rs | 4 +- src/librustc/middle/trans/monomorphize.rs | 4 +- src/librustc/middle/trans/reflect.rs | 4 +- src/librustc/middle/trans/type_of.rs | 2 +- src/librustc/middle/ty.rs | 32 +- src/librustc/middle/typeck/astconv.rs | 6 +- src/librustc/middle/typeck/check/_match.rs | 4 +- src/librustc/middle/typeck/check/method.rs | 6 +- src/librustc/middle/typeck/check/mod.rs | 4 +- src/librustc/middle/typeck/infer/glb.rs | 2 +- src/librustc/middle/typeck/mod.rs | 2 +- src/librustc/middle/typeck/rscope.rs | 1 + src/librustc/util/enum_set.rs | 2 +- src/librustdoc/attr_pass.rs | 4 +- src/librustdoc/config.rs | 30 +- src/librustdoc/desc_to_brief_pass.rs | 2 +- src/librustdoc/doc.rs | 2 +- src/librustdoc/markdown_index_pass.rs | 12 +- src/librustdoc/markdown_pass.rs | 8 +- src/librustdoc/sectionalize_pass.rs | 4 +- src/librustdoc/tystr_pass.rs | 6 +- src/librusti/rusti.rs | 10 +- src/librustpkg/rustpkg.rs | 4 +- src/librustpkg/util.rs | 2 +- src/libstd/at_vec.rs | 6 +- src/libstd/either.rs | 366 +++++++++--------- src/libstd/local_data.rs | 14 +- src/libstd/num/strconv.rs | 2 +- src/libstd/option.rs | 212 +++++----- src/libstd/os.rs | 6 +- src/libstd/rand.rs | 4 +- src/libstd/result.rs | 327 +++++++--------- src/libstd/rt/io/flate.rs | 2 +- src/libstd/rt/io/mod.rs | 36 +- src/libstd/rt/mod.rs | 2 +- src/libstd/rt/task.rs | 4 +- src/libstd/rt/test.rs | 4 +- src/libstd/rt/util.rs | 4 +- src/libstd/rt/uv/net.rs | 6 +- src/libstd/rt/uv/uvio.rs | 2 +- src/libstd/str.rs | 4 +- src/libstd/task/mod.rs | 2 +- src/libstd/vec.rs | 6 +- src/libsyntax/abi.rs | 4 +- src/libsyntax/ast.rs | 4 +- src/libsyntax/attr.rs | 2 +- src/libsyntax/ext/base.rs | 16 +- src/libsyntax/ext/deriving/generic.rs | 2 +- src/libsyntax/ext/expand.rs | 4 +- src/libsyntax/ext/source_util.rs | 6 +- src/libsyntax/parse/parser.rs | 8 +- src/libsyntax/print/pprust.rs | 10 +- src/test/bench/core-map.rs | 2 +- src/test/bench/core-set.rs | 2 +- src/test/bench/core-uint-to-str.rs | 2 +- src/test/bench/graph500-bfs.rs | 4 +- src/test/bench/msgsend-pipes-shared.rs | 4 +- src/test/bench/msgsend-pipes.rs | 4 +- src/test/bench/msgsend-ring-mutex-arcs.rs | 4 +- src/test/bench/msgsend-ring-rw-arcs.rs | 4 +- src/test/bench/shootout-ackermann.rs | 2 +- src/test/bench/shootout-binarytrees.rs | 2 +- src/test/bench/shootout-chameneos-redux.rs | 2 +- src/test/bench/shootout-fannkuch-redux.rs | 2 +- src/test/bench/shootout-fasta-redux.rs | 2 +- src/test/bench/shootout-fasta.rs | 2 +- src/test/bench/shootout-fibo.rs | 2 +- src/test/bench/shootout-mandelbrot.rs | 2 +- src/test/bench/shootout-nbody.rs | 2 +- src/test/bench/shootout-pfib.rs | 2 +- src/test/bench/shootout-spectralnorm.rs | 2 +- src/test/bench/shootout-threadring.rs | 4 +- src/test/bench/std-smallintmap.rs | 4 +- src/test/bench/sudoku.rs | 6 +- .../bench/task-perf-jargon-metal-smoke.rs | 2 +- src/test/bench/task-perf-linked-failure.rs | 2 +- src/test/bench/task-perf-spawnalot.rs | 2 +- .../arc-rw-read-mode-shouldnt-escape.rs | 2 +- .../arc-rw-write-mode-shouldnt-escape.rs | 2 +- src/test/run-fail/result-get-fail.rs | 4 +- .../run-pass/borrowck-wg-borrow-mut-to-imm.rs | 2 +- .../run-pass/borrowed-ptr-pattern-option.rs | 2 +- src/test/run-pass/option_addition.rs | 32 +- src/test/run-pass/region-dependent-addr-of.rs | 6 +- 115 files changed, 792 insertions(+), 817 deletions(-) diff --git a/src/compiletest/compiletest.rs b/src/compiletest/compiletest.rs index b01de242590d0..094d176980b81 100644 --- a/src/compiletest/compiletest.rs +++ b/src/compiletest/compiletest.rs @@ -131,7 +131,7 @@ pub fn parse_config(args: ~[~str]) -> config { ratchet_noise_percent: getopts::opt_maybe_str(matches, "ratchet-noise-percent").map(|s| - f64::from_str(*s).get()), + f64::from_str(*s).unwrap()), runtool: getopts::opt_maybe_str(matches, "runtool"), rustcflags: getopts::opt_maybe_str(matches, "rustcflags"), jit: getopts::opt_present(matches, "jit"), @@ -267,7 +267,7 @@ pub fn is_test(config: &config, testfile: &Path) -> bool { _ => ~[~".rc", ~".rs"] }; let invalid_prefixes = ~[~".", ~"#", ~"~"]; - let name = testfile.filename().get(); + let name = testfile.filename().unwrap(); let mut valid = false; @@ -300,7 +300,7 @@ pub fn make_test_name(config: &config, testfile: &Path) -> test::TestName { fn shorten(path: &Path) -> ~str { let filename = path.filename(); let dir = path.pop().filename(); - fmt!("%s/%s", dir.get_or_default(~""), filename.get_or_default(~"")) + fmt!("%s/%s", dir.unwrap_or_default(~""), filename.unwrap_or_default(~"")) } test::DynTestName(fmt!("[%s] %s", diff --git a/src/compiletest/runtest.rs b/src/compiletest/runtest.rs index 74b4a1de5e0d1..5c1cc78d678f3 100644 --- a/src/compiletest/runtest.rs +++ b/src/compiletest/runtest.rs @@ -145,7 +145,7 @@ fn run_pretty_test(config: &config, props: &TestProps, testfile: &Path) { let rounds = match props.pp_exact { Some(_) => 1, None => 2 }; - let mut srcs = ~[io::read_whole_file_str(testfile).get()]; + let mut srcs = ~[io::read_whole_file_str(testfile).unwrap()]; let mut round = 0; while round < rounds { @@ -166,7 +166,7 @@ fn run_pretty_test(config: &config, props: &TestProps, testfile: &Path) { match props.pp_exact { Some(ref file) => { let filepath = testfile.dir_path().push_rel(file); - io::read_whole_file_str(&filepath).get() + io::read_whole_file_str(&filepath).unwrap() } None => { srcs[srcs.len() - 2u].clone() } }; @@ -448,7 +448,7 @@ fn scan_until_char(haystack: &str, needle: char, idx: &mut uint) -> bool { if opt.is_none() { return false; } - *idx = opt.get(); + *idx = opt.unwrap(); return true; } @@ -709,7 +709,7 @@ fn aux_output_dir_name(config: &config, testfile: &Path) -> Path { } fn output_testname(testfile: &Path) -> Path { - Path(testfile.filestem().get()) + Path(testfile.filestem().unwrap()) } fn output_base_name(config: &config, testfile: &Path) -> Path { @@ -878,7 +878,7 @@ fn append_suffix_to_stem(p: &Path, suffix: &str) -> Path { if suffix.len() == 0 { (*p).clone() } else { - let stem = p.filestem().get(); + let stem = p.filestem().unwrap(); p.with_filestem(stem + "-" + suffix) } } @@ -938,7 +938,7 @@ fn disassemble_extract(config: &config, _props: &TestProps, fn count_extracted_lines(p: &Path) -> uint { - let x = io::read_whole_file_str(&p.with_filetype("ll")).get(); + let x = io::read_whole_file_str(&p.with_filetype("ll")).unwrap(); x.line_iter().len_() } diff --git a/src/libextra/base64.rs b/src/libextra/base64.rs index f2cbcf86935e7..550b891a4db16 100644 --- a/src/libextra/base64.rs +++ b/src/libextra/base64.rs @@ -322,24 +322,24 @@ mod test { #[test] fn test_from_base64_basic() { - assert_eq!("".from_base64().get(), "".as_bytes().to_owned()); - assert_eq!("Zg==".from_base64().get(), "f".as_bytes().to_owned()); - assert_eq!("Zm8=".from_base64().get(), "fo".as_bytes().to_owned()); - assert_eq!("Zm9v".from_base64().get(), "foo".as_bytes().to_owned()); - assert_eq!("Zm9vYg==".from_base64().get(), "foob".as_bytes().to_owned()); - assert_eq!("Zm9vYmE=".from_base64().get(), "fooba".as_bytes().to_owned()); - assert_eq!("Zm9vYmFy".from_base64().get(), "foobar".as_bytes().to_owned()); + assert_eq!("".from_base64().unwrap(), "".as_bytes().to_owned()); + assert_eq!("Zg==".from_base64().unwrap(), "f".as_bytes().to_owned()); + assert_eq!("Zm8=".from_base64().unwrap(), "fo".as_bytes().to_owned()); + assert_eq!("Zm9v".from_base64().unwrap(), "foo".as_bytes().to_owned()); + assert_eq!("Zm9vYg==".from_base64().unwrap(), "foob".as_bytes().to_owned()); + assert_eq!("Zm9vYmE=".from_base64().unwrap(), "fooba".as_bytes().to_owned()); + assert_eq!("Zm9vYmFy".from_base64().unwrap(), "foobar".as_bytes().to_owned()); } #[test] fn test_from_base64_newlines() { - assert_eq!("Zm9v\r\nYmFy".from_base64().get(), + assert_eq!("Zm9v\r\nYmFy".from_base64().unwrap(), "foobar".as_bytes().to_owned()); } #[test] fn test_from_base64_urlsafe() { - assert_eq!("-_8".from_base64().get(), "+/8=".from_base64().get()); + assert_eq!("-_8".from_base64().unwrap(), "+/8=".from_base64().unwrap()); } #[test] @@ -364,7 +364,7 @@ mod test { push(random()); } }; - assert_eq!(v.to_base64(STANDARD).from_base64().get(), v); + assert_eq!(v.to_base64(STANDARD).from_base64().unwrap(), v); } } diff --git a/src/libextra/fileinput.rs b/src/libextra/fileinput.rs index a161989c37516..7a36b25eac57a 100644 --- a/src/libextra/fileinput.rs +++ b/src/libextra/fileinput.rs @@ -526,8 +526,8 @@ mod test { do input_vec_state(filenames) |line, state| { let nums: ~[&str] = line.split_iter(' ').collect(); - let file_num = uint::from_str(nums[0]).get(); - let line_num = uint::from_str(nums[1]).get(); + let file_num = uint::from_str(nums[0]).unwrap(); + let line_num = uint::from_str(nums[1]).unwrap(); assert_eq!(line_num, state.line_num_file); assert_eq!(file_num * 3 + line_num, state.line_num); true diff --git a/src/libextra/getopts.rs b/src/libextra/getopts.rs index b9ee38317f321..15aac8ef47c9e 100644 --- a/src/libextra/getopts.rs +++ b/src/libextra/getopts.rs @@ -196,7 +196,7 @@ fn find_opt(opts: &[Opt], nm: Name) -> Option { * The type returned when the command line does not conform to the * expected format. Pass this value to to get an error message. */ -#[deriving(Clone, Eq)] +#[deriving(Clone, Eq, ToStr)] pub enum Fail_ { ArgumentMissing(~str), UnrecognizedOption(~str), @@ -288,7 +288,7 @@ pub fn getopts(args: &[~str], opts: &[Opt]) -> Result { None => { let arg_follows = last_valid_opt_id.is_some() && - match opts[last_valid_opt_id.get()] + match opts[last_valid_opt_id.unwrap()] .hasarg { Yes | Maybe => true, @@ -322,7 +322,7 @@ pub fn getopts(args: &[~str], opts: &[Opt]) -> Result { } Maybe => { if !i_arg.is_none() { - vals[optid].push(Val((i_arg.clone()).get())); + vals[optid].push(Val((i_arg.clone()).unwrap())); } else if name_pos < names.len() || i + 1 == l || is_arg(args[i + 1]) { vals[optid].push(Given); @@ -330,7 +330,7 @@ pub fn getopts(args: &[~str], opts: &[Opt]) -> Result { } Yes => { if !i_arg.is_none() { - vals[optid].push(Val(i_arg.clone().get())); + vals[optid].push(Val(i_arg.clone().unwrap())); } else if i + 1 == l { return Err(ArgumentMissing(name_str(nm))); } else { i += 1; vals[optid].push(Val(args[i].clone())); } diff --git a/src/libextra/num/bigint.rs b/src/libextra/num/bigint.rs index ab843fe65464b..bced00902c95f 100644 --- a/src/libextra/num/bigint.rs +++ b/src/libextra/num/bigint.rs @@ -1510,11 +1510,11 @@ mod biguint_tests { #[test] fn test_is_even() { - assert!(FromStr::from_str::("1").get().is_odd()); - assert!(FromStr::from_str::("2").get().is_even()); - assert!(FromStr::from_str::("1000").get().is_even()); - assert!(FromStr::from_str::("1000000000000000000000").get().is_even()); - assert!(FromStr::from_str::("1000000000000000000001").get().is_odd()); + assert!(FromStr::from_str::("1").unwrap().is_odd()); + assert!(FromStr::from_str::("2").unwrap().is_even()); + assert!(FromStr::from_str::("1000").unwrap().is_even()); + assert!(FromStr::from_str::("1000000000000000000000").unwrap().is_even()); + assert!(FromStr::from_str::("1000000000000000000001").unwrap().is_odd()); assert!((BigUint::from_uint(1) << 64).is_even()); assert!(((BigUint::from_uint(1) << 64) + BigUint::from_uint(1)).is_odd()); } @@ -1595,7 +1595,7 @@ mod biguint_tests { let &(ref n, ref rs) = num_pair; for str_pair in rs.iter() { let &(ref radix, ref str) = str_pair; - assert_eq!(n, &FromStrRadix::from_str_radix(*str, *radix).get()); + assert_eq!(n, &FromStrRadix::from_str_radix(*str, *radix).unwrap()); } } diff --git a/src/libextra/ringbuf.rs b/src/libextra/ringbuf.rs index 89d23191a7634..9833bd5d1cbf2 100644 --- a/src/libextra/ringbuf.rs +++ b/src/libextra/ringbuf.rs @@ -437,12 +437,12 @@ mod tests { assert_eq!(deq.len(), 3); deq.push_back(d.clone()); assert_eq!(deq.len(), 4); - assert_eq!((*deq.front().get()).clone(), b.clone()); - assert_eq!((*deq.back().get()).clone(), d.clone()); - assert_eq!(deq.pop_front().get(), b.clone()); - assert_eq!(deq.pop_back().get(), d.clone()); - assert_eq!(deq.pop_back().get(), c.clone()); - assert_eq!(deq.pop_back().get(), a.clone()); + 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.len(), 0); deq.push_back(c.clone()); assert_eq!(deq.len(), 1); diff --git a/src/libextra/semver.rs b/src/libextra/semver.rs index 8c298a7373d96..b0f89e219d8d8 100644 --- a/src/libextra/semver.rs +++ b/src/libextra/semver.rs @@ -386,8 +386,8 @@ fn test_spec_order() { "1.0.0"]; let mut i = 1; while i < vs.len() { - let a = parse(vs[i-1]).get(); - let b = parse(vs[i]).get(); + let a = parse(vs[i-1]).unwrap(); + let b = parse(vs[i]).unwrap(); assert!(a < b); i += 1; } diff --git a/src/libextra/smallintmap.rs b/src/libextra/smallintmap.rs index 52e6c1fcc1c90..3f62317eb8908 100644 --- a/src/libextra/smallintmap.rs +++ b/src/libextra/smallintmap.rs @@ -366,9 +366,9 @@ mod test_map { map.update_with_key(3, 2, addMoreToCount); // check the total counts - assert_eq!(map.find(&3).get(), &10); - assert_eq!(map.find(&5).get(), &3); - assert_eq!(map.find(&9).get(), &1); + assert_eq!(map.find(&3).unwrap(), &10); + assert_eq!(map.find(&5).unwrap(), &3); + assert_eq!(map.find(&9).unwrap(), &1); // sadly, no sevens were counted assert!(map.find(&7).is_none()); diff --git a/src/libextra/test.rs b/src/libextra/test.rs index 02481693eb971..e87be14622674 100644 --- a/src/libextra/test.rs +++ b/src/libextra/test.rs @@ -247,9 +247,8 @@ pub fn parse_opts(args: &[~str]) -> OptRes { let ratchet_metrics = getopts::opt_maybe_str(&matches, "ratchet-metrics"); let ratchet_metrics = ratchet_metrics.map(|s| Path(*s)); - let ratchet_noise_percent = - getopts::opt_maybe_str(&matches, "ratchet-noise-percent"); - let ratchet_noise_percent = ratchet_noise_percent.map(|s| f64::from_str(*s).get()); + let ratchet_noise_percent = getopts::opt_maybe_str(&matches, "ratchet-noise-percent"); + let ratchet_noise_percent = ratchet_noise_percent.map(|s| f64::from_str(*s).unwrap()); let save_metrics = getopts::opt_maybe_str(&matches, "save-metrics"); let save_metrics = save_metrics.map(|s| Path(*s)); @@ -631,8 +630,8 @@ fn should_sort_failures_before_printing_them() { st.write_failures(); }; - let apos = s.find_str("a").get(); - let bpos = s.find_str("b").get(); + let apos = s.find_str("a").unwrap(); + let bpos = s.find_str("b").unwrap(); assert!(apos < bpos); } @@ -868,7 +867,7 @@ impl MetricMap { pub fn load(p: &Path) -> MetricMap { assert!(os::path_exists(p)); let f = io::file_reader(p).unwrap(); - let mut decoder = json::Decoder(json::from_reader(f).get()); + let mut decoder = json::Decoder(json::from_reader(f).unwrap()); MetricMap(Decodable::decode(&mut decoder)) } @@ -1207,7 +1206,7 @@ mod tests { either::Left(o) => o, _ => fail!("Malformed arg in first_free_arg_should_be_a_filter") }; - assert!("filter" == opts.filter.clone().get()); + assert!("filter" == opts.filter.clone().unwrap()); } #[test] @@ -1346,28 +1345,28 @@ mod tests { let diff1 = m2.compare_to_old(&m1, None); - assert_eq!(*(diff1.find(&~"in-both-noise").get()), LikelyNoise); - assert_eq!(*(diff1.find(&~"in-first-noise").get()), MetricRemoved); - assert_eq!(*(diff1.find(&~"in-second-noise").get()), MetricAdded); - assert_eq!(*(diff1.find(&~"in-both-want-downwards-but-regressed").get()), + assert_eq!(*(diff1.find(&~"in-both-noise").unwrap()), LikelyNoise); + assert_eq!(*(diff1.find(&~"in-first-noise").unwrap()), MetricRemoved); + assert_eq!(*(diff1.find(&~"in-second-noise").unwrap()), MetricAdded); + assert_eq!(*(diff1.find(&~"in-both-want-downwards-but-regressed").unwrap()), Regression(100.0)); - assert_eq!(*(diff1.find(&~"in-both-want-downwards-and-improved").get()), + assert_eq!(*(diff1.find(&~"in-both-want-downwards-and-improved").unwrap()), Improvement(50.0)); - assert_eq!(*(diff1.find(&~"in-both-want-upwards-but-regressed").get()), + assert_eq!(*(diff1.find(&~"in-both-want-upwards-but-regressed").unwrap()), Regression(50.0)); - assert_eq!(*(diff1.find(&~"in-both-want-upwards-and-improved").get()), + assert_eq!(*(diff1.find(&~"in-both-want-upwards-and-improved").unwrap()), 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").get()), LikelyNoise); - assert_eq!(*(diff2.find(&~"in-first-noise").get()), MetricRemoved); - assert_eq!(*(diff2.find(&~"in-second-noise").get()), MetricAdded); - assert_eq!(*(diff2.find(&~"in-both-want-downwards-but-regressed").get()), LikelyNoise); - assert_eq!(*(diff2.find(&~"in-both-want-downwards-and-improved").get()), LikelyNoise); - assert_eq!(*(diff2.find(&~"in-both-want-upwards-but-regressed").get()), LikelyNoise); - assert_eq!(*(diff2.find(&~"in-both-want-upwards-and-improved").get()), LikelyNoise); + assert_eq!(*(diff2.find(&~"in-both-noise").unwrap()), LikelyNoise); + assert_eq!(*(diff2.find(&~"in-first-noise").unwrap()), MetricRemoved); + assert_eq!(*(diff2.find(&~"in-second-noise").unwrap()), MetricAdded); + assert_eq!(*(diff2.find(&~"in-both-want-downwards-but-regressed").unwrap()), LikelyNoise); + assert_eq!(*(diff2.find(&~"in-both-want-downwards-and-improved").unwrap()), LikelyNoise); + assert_eq!(*(diff2.find(&~"in-both-want-upwards-but-regressed").unwrap()), LikelyNoise); + assert_eq!(*(diff2.find(&~"in-both-want-upwards-and-improved").unwrap()), LikelyNoise); assert_eq!(diff2.len(), 7); } @@ -1391,28 +1390,28 @@ mod tests { let (diff1, ok1) = m2.ratchet(&pth, None); assert_eq!(ok1, false); assert_eq!(diff1.len(), 2); - assert_eq!(*(diff1.find(&~"runtime").get()), Regression(10.0)); - assert_eq!(*(diff1.find(&~"throughput").get()), LikelyNoise); + assert_eq!(*(diff1.find(&~"runtime").unwrap()), Regression(10.0)); + assert_eq!(*(diff1.find(&~"throughput").unwrap()), LikelyNoise); // Check that it was not rewritten. let m3 = MetricMap::load(&pth); assert_eq!(m3.len(), 2); - assert_eq!(*(m3.find(&~"runtime").get()), Metric { value: 1000.0, noise: 2.0 }); - assert_eq!(*(m3.find(&~"throughput").get()), Metric { value: 50.0, noise: 2.0 }); + assert_eq!(*(m3.find(&~"runtime").unwrap()), Metric { value: 1000.0, noise: 2.0 }); + assert_eq!(*(m3.find(&~"throughput").unwrap()), Metric { value: 50.0, noise: 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").get()), LikelyNoise); - assert_eq!(*(diff2.find(&~"throughput").get()), LikelyNoise); + assert_eq!(*(diff2.find(&~"runtime").unwrap()), LikelyNoise); + assert_eq!(*(diff2.find(&~"throughput").unwrap()), LikelyNoise); // Check that it was rewritten. let m4 = MetricMap::load(&pth); assert_eq!(m4.len(), 2); - assert_eq!(*(m4.find(&~"runtime").get()), Metric { value: 1100.0, noise: 2.0 }); - assert_eq!(*(m4.find(&~"throughput").get()), Metric { value: 50.0, noise: 2.0 }); + assert_eq!(*(m4.find(&~"runtime").unwrap()), Metric { value: 1100.0, noise: 2.0 }); + assert_eq!(*(m4.find(&~"throughput").unwrap()), Metric { value: 50.0, noise: 2.0 }); os::remove_dir_recursive(&dpth); } diff --git a/src/libextra/url.rs b/src/libextra/url.rs index 523c3521f8665..581bdf2a294db 100644 --- a/src/libextra/url.rs +++ b/src/libextra/url.rs @@ -134,7 +134,7 @@ fn decode_inner(s: &str, full_url: bool) -> ~str { match rdr.read_char() { '%' => { let bytes = rdr.read_bytes(2u); - let ch = uint::parse_bytes(bytes, 16u).get() as char; + let ch = uint::parse_bytes(bytes, 16u).unwrap() as char; if full_url { // Only decode some characters: @@ -257,7 +257,7 @@ pub fn decode_form_urlencoded(s: &[u8]) -> HashMap<~str, ~[~str]> { let ch = match ch { '%' => { let bytes = rdr.read_bytes(2u); - uint::parse_bytes(bytes, 16u).get() as char + uint::parse_bytes(bytes, 16u).unwrap() as char } '+' => ' ', ch => ch diff --git a/src/librustc/back/link.rs b/src/librustc/back/link.rs index f066ede65f976..637ea159d79d0 100644 --- a/src/librustc/back/link.rs +++ b/src/librustc/back/link.rs @@ -912,7 +912,7 @@ pub fn link_args(sess: Session, } let dir = cratepath.dirname(); if dir != ~"" { args.push(~"-L" + dir); } - let libarg = unlib(sess.targ_cfg, cratepath.filestem().get()); + let libarg = unlib(sess.targ_cfg, cratepath.filestem().unwrap()); args.push(~"-l" + libarg); } @@ -950,7 +950,7 @@ pub fn link_args(sess: Session, // be rpathed if sess.targ_cfg.os == session::os_macos { args.push(~"-Wl,-install_name,@rpath/" - + output.filename().get()); + + output.filename().unwrap()); } } diff --git a/src/librustc/back/passes.rs b/src/librustc/back/passes.rs index b77ed10c21ba4..35d070baa9bac 100644 --- a/src/librustc/back/passes.rs +++ b/src/librustc/back/passes.rs @@ -319,7 +319,7 @@ fn passes_exist() { if !pass.is_some() { failed.push(name); } else { - unsafe { llvm::LLVMDestroyPass(pass.get()) } + unsafe { llvm::LLVMDestroyPass(pass.unwrap()) } } } for &(name,_) in transform_passes.iter() { @@ -327,7 +327,7 @@ fn passes_exist() { if !pass.is_some() { failed.push(name); } else { - unsafe { llvm::LLVMDestroyPass(pass.get()) } + unsafe { llvm::LLVMDestroyPass(pass.unwrap()) } } } for &(name,_) in utility_passes.iter() { @@ -335,7 +335,7 @@ fn passes_exist() { if !pass.is_some() { failed.push(name); } else { - unsafe { llvm::LLVMDestroyPass(pass.get()) } + unsafe { llvm::LLVMDestroyPass(pass.unwrap()) } } } diff --git a/src/librustc/driver/driver.rs b/src/librustc/driver/driver.rs index ea679d19f73b8..356820f8267fe 100644 --- a/src/librustc/driver/driver.rs +++ b/src/librustc/driver/driver.rs @@ -922,7 +922,7 @@ pub fn build_output_filenames(input: &input, }; let mut stem = match *input { - file_input(ref ifile) => (*ifile).filestem().get().to_managed(), + file_input(ref ifile) => (*ifile).filestem().unwrap().to_managed(), str_input(_) => @"rust_out" }; diff --git a/src/librustc/front/test.rs b/src/librustc/front/test.rs index 8ca68251cb891..d2d2a8b4be99d 100644 --- a/src/librustc/front/test.rs +++ b/src/librustc/front/test.rs @@ -308,7 +308,7 @@ fn mk_test_module(cx: &TestCtxt) -> @ast::item { #[main]; extra::test::test_main_static(::std::os::args(), TESTS); } - )).get(); + )).unwrap(); let testmod = ast::_mod { view_items: view_items, @@ -366,7 +366,7 @@ fn mk_tests(cx: &TestCtxt) -> @ast::item { pub static TESTS : &'static [self::extra::test::TestDescAndFn] = $test_descs ; - )).get() + )).unwrap() } fn is_extra(cx: &TestCtxt) -> bool { diff --git a/src/librustc/middle/astencode.rs b/src/librustc/middle/astencode.rs index 34f4425a871dd..b909f70440a82 100644 --- a/src/librustc/middle/astencode.rs +++ b/src/librustc/middle/astencode.rs @@ -328,7 +328,7 @@ fn simplify_ast(ii: &ast::inlined_item) -> ast::inlined_item { match *ii { //hack: we're not dropping items - ast::ii_item(i) => ast::ii_item(fld.fold_item(i).get()), + ast::ii_item(i) => ast::ii_item(fld.fold_item(i).unwrap()), ast::ii_method(d, is_provided, m) => ast::ii_method(d, is_provided, fld.fold_method(m)), ast::ii_foreign(i) => ast::ii_foreign(fld.fold_foreign_item(i)) @@ -350,7 +350,7 @@ fn renumber_ast(xcx: @ExtendedDecodeContext, ii: ast::inlined_item) }); match ii { - ast::ii_item(i) => ast::ii_item(fld.fold_item(i).get()), + ast::ii_item(i) => ast::ii_item(fld.fold_item(i).unwrap()), ast::ii_method(d, is_provided, m) => ast::ii_method(xcx.tr_def_id(d), is_provided, fld.fold_method(m)), ast::ii_foreign(i) => ast::ii_foreign(fld.fold_foreign_item(i)), @@ -1275,7 +1275,7 @@ fn mk_ctxt() -> @fake_ext_ctxt { fn roundtrip(in_item: Option<@ast::item>) { use std::io; - let in_item = in_item.get(); + let in_item = in_item.unwrap(); let bytes = do io::with_bytes_writer |wr| { let mut ebml_w = writer::Encoder(wr); encode_item_ast(&mut ebml_w, in_item); @@ -1321,13 +1321,13 @@ fn test_simplification() { fn eq_int(a: int, b: int) -> bool { a == b } return alist {eq_fn: eq_int, data: ~[]}; } - ).get()); + ).unwrap()); let item_out = simplify_ast(&item_in); let item_exp = ast::ii_item(quote_item!( fn new_int_alist() -> alist { return alist {eq_fn: eq_int, data: ~[]}; } - ).get()); + ).unwrap()); match (item_out, item_exp) { (ast::ii_item(item_out), ast::ii_item(item_exp)) => { assert!(pprust::item_to_str(item_out, diff --git a/src/librustc/middle/borrowck/check_loans.rs b/src/librustc/middle/borrowck/check_loans.rs index 646840f1e3063..c3bb2000447f7 100644 --- a/src/librustc/middle/borrowck/check_loans.rs +++ b/src/librustc/middle/borrowck/check_loans.rs @@ -307,7 +307,7 @@ impl<'self> CheckLoanCtxt<'self> { // if they cannot already have been assigned if self.is_local_variable(cmt) { assert!(cmt.mutbl.is_immutable()); // no "const" locals - let lp = opt_loan_path(cmt).get(); + let lp = opt_loan_path(cmt).unwrap(); do self.move_data.each_assignment_of(expr.id, lp) |assign| { self.bccx.report_reassigned_immutable_variable( expr.span, diff --git a/src/librustc/middle/check_match.rs b/src/librustc/middle/check_match.rs index 4de096428f26f..1b420b9c06a55 100644 --- a/src/librustc/middle/check_match.rs +++ b/src/librustc/middle/check_match.rs @@ -109,7 +109,7 @@ pub fn check_arms(cx: &MatchCheckCtxt, arms: &[arm]) { let pat_matches_nan: &fn(@pat) -> bool = |p| { match cx.tcx.def_map.find(&p.id) { Some(&def_static(did, false)) => { - let const_expr = lookup_const_by_id(cx.tcx, did).get(); + let const_expr = lookup_const_by_id(cx.tcx, did).unwrap(); match eval_const_expr(cx.tcx, const_expr) { const_float(f) if f.is_NaN() => true, _ => false @@ -304,7 +304,7 @@ pub fn is_useful_specialized(cx: &MatchCheckCtxt, -> useful { let ms = m.iter().filter_map(|r| specialize(cx, *r, &ctor, arity, lty)).collect::(); let could_be_useful = is_useful( - cx, &ms, specialize(cx, v, &ctor, arity, lty).get()); + cx, &ms, specialize(cx, v, &ctor, arity, lty).unwrap()); match could_be_useful { useful_ => useful(lty, ctor), ref u => *u, @@ -319,7 +319,7 @@ pub fn pat_ctor_id(cx: &MatchCheckCtxt, p: @pat) -> Option { match cx.tcx.def_map.find(&pat.id) { Some(&def_variant(_, id)) => Some(variant(id)), Some(&def_static(did, false)) => { - let const_expr = lookup_const_by_id(cx.tcx, did).get(); + let const_expr = lookup_const_by_id(cx.tcx, did).unwrap(); Some(val(eval_const_expr(cx.tcx, const_expr))) } _ => None @@ -515,7 +515,7 @@ pub fn specialize(cx: &MatchCheckCtxt, } Some(&def_static(did, _)) => { let const_expr = - lookup_const_by_id(cx.tcx, did).get(); + lookup_const_by_id(cx.tcx, did).unwrap(); let e_v = eval_const_expr(cx.tcx, const_expr); let match_ = match *ctor_id { val(ref v) => { @@ -565,7 +565,7 @@ pub fn specialize(cx: &MatchCheckCtxt, match cx.tcx.def_map.get_copy(&pat_id) { def_static(did, _) => { let const_expr = - lookup_const_by_id(cx.tcx, did).get(); + lookup_const_by_id(cx.tcx, did).unwrap(); let e_v = eval_const_expr(cx.tcx, const_expr); let match_ = match *ctor_id { val(ref v) => @@ -867,7 +867,7 @@ pub fn check_legality_of_move_bindings(cx: &MatchCheckCtxt, "cannot bind by-move and by-ref \ in the same pattern"); tcx.sess.span_note( - by_ref_span.get(), + by_ref_span.unwrap(), "by-ref binding occurs here"); } }; diff --git a/src/librustc/middle/const_eval.rs b/src/librustc/middle/const_eval.rs index 330e44893f04a..77e81709a03d7 100644 --- a/src/librustc/middle/const_eval.rs +++ b/src/librustc/middle/const_eval.rs @@ -466,9 +466,9 @@ pub fn lit_to_const(lit: &lit) -> const_val { lit_int(n, _) => const_int(n), lit_uint(n, _) => const_uint(n), lit_int_unsuffixed(n) => const_int(n), - lit_float(n, _) => const_float(float::from_str(n).get() as f64), + lit_float(n, _) => const_float(float::from_str(n).unwrap() as f64), lit_float_unsuffixed(n) => - const_float(float::from_str(n).get() as f64), + const_float(float::from_str(n).unwrap() as f64), lit_nil => const_int(0i64), lit_bool(b) => const_bool(b) } diff --git a/src/librustc/middle/privacy.rs b/src/librustc/middle/privacy.rs index 76d1d0b05ffbc..9ffeb99ac3559 100644 --- a/src/librustc/middle/privacy.rs +++ b/src/librustc/middle/privacy.rs @@ -225,7 +225,7 @@ pub fn check_crate<'mm>(tcx: ty::ctxt, // the default implementation. // Having to do this this is really unfortunate. let method_id = ty::method(tcx, method_id).provided_source - .get_or_default(method_id); + .unwrap_or_default(method_id); if method_id.crate == LOCAL_CRATE { let is_private = method_is_private(span, method_id.node); diff --git a/src/librustc/middle/resolve.rs b/src/librustc/middle/resolve.rs index 60ecff39d8554..5ca3a58b137a7 100644 --- a/src/librustc/middle/resolve.rs +++ b/src/librustc/middle/resolve.rs @@ -1726,7 +1726,7 @@ impl Resolver { let mut modules = HashMap::new(); // Create all the items reachable by paths. - do each_path(self.session.cstore, root.def_id.get().crate) + do each_path(self.session.cstore, root.def_id.unwrap().crate) |path_string, def_like, visibility| { debug!("(building reduced graph for external crate) found path \ @@ -2350,7 +2350,7 @@ impl Resolver { match type_result { BoundResult(target_module, name_bindings) => { debug!("(resolving single import) found type target: %?", - name_bindings.type_def.get().type_def); + name_bindings.type_def.unwrap().type_def); import_resolution.type_target = Some(Target(target_module, name_bindings)); import_resolution.type_id = directive.id; diff --git a/src/librustc/middle/trans/_match.rs b/src/librustc/middle/trans/_match.rs index 725beee6604e7..d77cebbf23e0b 100644 --- a/src/librustc/middle/trans/_match.rs +++ b/src/librustc/middle/trans/_match.rs @@ -210,7 +210,7 @@ pub fn opt_eq(tcx: ty::ctxt, a: &Opt, b: &Opt) -> bool { ExprLit(existing_a_expr) => a_expr = existing_a_expr, ConstLit(a_const) => { let e = const_eval::lookup_const_by_id(tcx, a_const); - a_expr = e.get(); + a_expr = e.unwrap(); } UnitLikeStructLit(_) => { fail!("UnitLikeStructLit should have been handled \ @@ -223,7 +223,7 @@ pub fn opt_eq(tcx: ty::ctxt, a: &Opt, b: &Opt) -> bool { ExprLit(existing_b_expr) => b_expr = existing_b_expr, ConstLit(b_const) => { let e = const_eval::lookup_const_by_id(tcx, b_const); - b_expr = e.get(); + b_expr = e.unwrap(); } UnitLikeStructLit(_) => { fail!("UnitLikeStructLit should have been handled \ @@ -922,7 +922,7 @@ pub fn extract_vec_elems(bcx: @mut Block, } }; if slice.is_some() { - let n = slice.get(); + let n = slice.unwrap(); let slice_offset = Mul(bcx, vt.llunit_size, C_int(bcx.ccx(), n as int) ); @@ -1280,7 +1280,7 @@ pub fn compile_submatch(bcx: @mut Block, let _icx = push_ctxt("match::compile_submatch"); let mut bcx = bcx; if m.len() == 0u { - Br(bcx, chk.get()()); + Br(bcx, chk.unwrap()()); return; } if m[0].pats.len() == 0u { diff --git a/src/librustc/middle/trans/adt.rs b/src/librustc/middle/trans/adt.rs index fad5b9ec73b0f..2eb9841c6c757 100644 --- a/src/librustc/middle/trans/adt.rs +++ b/src/librustc/middle/trans/adt.rs @@ -260,7 +260,7 @@ fn generic_fields_of(cx: &mut CrateContext, r: &Repr, sizing: bool) -> ~[Type] { most_aligned = Some(st); } } - let most_aligned = most_aligned.get(); + let most_aligned = most_aligned.unwrap(); let padding = largest_size - most_aligned.size; struct_llfields(cx, most_aligned, sizing) diff --git a/src/librustc/middle/trans/base.rs b/src/librustc/middle/trans/base.rs index 0a28da5f88a7c..3fc6dbca96475 100644 --- a/src/librustc/middle/trans/base.rs +++ b/src/librustc/middle/trans/base.rs @@ -1321,7 +1321,7 @@ pub fn cleanup_and_leave(bcx: @mut Block, } match leave { Some(target) => Br(bcx, target), - None => { Resume(bcx, Load(bcx, bcx.fcx.personality.get())); } + None => { Resume(bcx, Load(bcx, bcx.fcx.personality.unwrap())); } } } @@ -1529,7 +1529,7 @@ pub fn alloca_maybe_zeroed(cx: @mut Block, ty: Type, name: &str, zero: bool) -> let p = Alloca(cx, ty, name); if zero { let b = cx.fcx.ccx.builder(); - b.position_before(cx.fcx.alloca_insert_pt.get()); + b.position_before(cx.fcx.alloca_insert_pt.unwrap()); memzero(&b, p, ty); } p @@ -1575,7 +1575,7 @@ pub fn make_return_pointer(fcx: @mut FunctionContext, output_type: ty::t) -> Val llvm::LLVMGetParam(fcx.llfn, 0) } else { let lloutputtype = type_of::type_of(fcx.ccx, output_type); - let bcx = fcx.entry_bcx.get(); + let bcx = fcx.entry_bcx.unwrap(); Alloca(bcx, lloutputtype, "__make_return_pointer") } } @@ -1793,7 +1793,7 @@ pub fn finish_fn(fcx: @mut FunctionContext, last_bcx: @mut Block) { pub fn build_return_block(fcx: &FunctionContext, ret_cx: @mut Block) { // Return the value if this function immediate; otherwise, return void. if fcx.llretptr.is_some() && fcx.has_immediate_return_value { - Ret(ret_cx, Load(ret_cx, fcx.llretptr.get())) + Ret(ret_cx, Load(ret_cx, fcx.llretptr.unwrap())) } else { RetVoid(ret_cx) } @@ -1843,7 +1843,7 @@ pub fn trans_closure(ccx: @mut CrateContext, // Create the first basic block in the function and keep a handle on it to // pass to finish_fn later. - let bcx_top = fcx.entry_bcx.get(); + let bcx_top = fcx.entry_bcx.unwrap(); let mut bcx = bcx_top; let block_ty = node_id_type(bcx, body.id); @@ -1861,7 +1861,7 @@ pub fn trans_closure(ccx: @mut CrateContext, { bcx = controlflow::trans_block(bcx, body, expr::Ignore); } else { - let dest = expr::SaveIn(fcx.llretptr.get()); + let dest = expr::SaveIn(fcx.llretptr.unwrap()); bcx = controlflow::trans_block(bcx, body, dest); } @@ -2055,18 +2055,18 @@ pub fn trans_enum_variant_or_tuple_like_struct( let raw_llargs = create_llargs_for_fn_args(fcx, no_self, fn_args); - let bcx = fcx.entry_bcx.get(); + let bcx = fcx.entry_bcx.unwrap(); let arg_tys = ty::ty_fn_args(ctor_ty); insert_synthetic_type_entries(bcx, fn_args, arg_tys); let bcx = copy_args_to_allocas(fcx, bcx, fn_args, raw_llargs, arg_tys); let repr = adt::represent_type(ccx, result_ty); - adt::trans_start_init(bcx, repr, fcx.llretptr.get(), disr); + adt::trans_start_init(bcx, repr, fcx.llretptr.unwrap(), disr); for (i, fn_arg) in fn_args.iter().enumerate() { let lldestptr = adt::trans_field_ptr(bcx, repr, - fcx.llretptr.get(), + fcx.llretptr.unwrap(), disr, i); let llarg = fcx.llargs.get_copy(&fn_arg.pat.id); @@ -2293,7 +2293,7 @@ pub fn create_entry_wrapper(ccx: @mut CrateContext, // be updated if this assertion starts to fail. assert!(fcx.has_immediate_return_value); - let bcx = fcx.entry_bcx.get(); + let bcx = fcx.entry_bcx.unwrap(); // Call main. let llenvarg = unsafe { let env_arg = fcx.env_arg_pos(); @@ -2782,7 +2782,7 @@ pub fn create_module_map(ccx: &mut CrateContext) -> ValueRef { } for key in keys.iter() { - let val = *ccx.module_data.find_equiv(key).get(); + let val = *ccx.module_data.find_equiv(key).unwrap(); let s_const = C_cstr(ccx, *key); let s_ptr = p2i(ccx, s_const); let v_ptr = p2i(ccx, val); diff --git a/src/librustc/middle/trans/build.rs b/src/librustc/middle/trans/build.rs index 07b774105bbde..c8e2a17c3b5f1 100644 --- a/src/librustc/middle/trans/build.rs +++ b/src/librustc/middle/trans/build.rs @@ -319,7 +319,7 @@ pub fn Alloca(cx: @mut Block, Ty: Type, name: &str) -> ValueRef { unsafe { if cx.unreachable { return llvm::LLVMGetUndef(Ty.ptr_to().to_ref()); } let b = cx.fcx.ccx.builder(); - b.position_before(cx.fcx.alloca_insert_pt.get()); + b.position_before(cx.fcx.alloca_insert_pt.unwrap()); b.alloca(Ty, name) } } @@ -328,7 +328,7 @@ pub fn ArrayAlloca(cx: @mut Block, Ty: Type, Val: ValueRef) -> ValueRef { unsafe { if cx.unreachable { return llvm::LLVMGetUndef(Ty.ptr_to().to_ref()); } let b = cx.fcx.ccx.builder(); - b.position_before(cx.fcx.alloca_insert_pt.get()); + b.position_before(cx.fcx.alloca_insert_pt.unwrap()); b.array_alloca(Ty, Val) } } diff --git a/src/librustc/middle/trans/cabi.rs b/src/librustc/middle/trans/cabi.rs index 3a6577e28b7cc..895bea715c964 100644 --- a/src/librustc/middle/trans/cabi.rs +++ b/src/librustc/middle/trans/cabi.rs @@ -169,7 +169,7 @@ impl FnType { } else { Load(bcx, llretval) }; - let llretptr = BitCast(bcx, bcx.fcx.llretptr.get(), self.ret_ty.ty.ptr_to()); + let llretptr = BitCast(bcx, bcx.fcx.llretptr.unwrap(), self.ret_ty.ty.ptr_to()); Store(bcx, llretval, llretptr); } } diff --git a/src/librustc/middle/trans/closure.rs b/src/librustc/middle/trans/closure.rs index ae3b773af0b63..602d33a197e29 100644 --- a/src/librustc/middle/trans/closure.rs +++ b/src/librustc/middle/trans/closure.rs @@ -330,7 +330,7 @@ pub fn load_environment(fcx: @mut FunctionContext, return; } - let bcx = fcx.entry_bcx.get(); + let bcx = fcx.entry_bcx.unwrap(); // Load a pointer to the closure data, skipping over the box header: let llcdata = opaque_box_body(bcx, cdata_ty, fcx.llenv); @@ -443,7 +443,7 @@ pub fn trans_expr_fn(bcx: @mut Block, if is_loop_body.is_some() { Store(bcx, C_bool(true), - bcx.fcx.llretptr.get()); + bcx.fcx.llretptr.unwrap()); } }); rslt(bcx, llbox) diff --git a/src/librustc/middle/trans/common.rs b/src/librustc/middle/trans/common.rs index 527706be6c1f7..f303e7b827597 100644 --- a/src/librustc/middle/trans/common.rs +++ b/src/librustc/middle/trans/common.rs @@ -251,7 +251,7 @@ impl FunctionContext { pub fn cleanup(&mut self) { unsafe { - llvm::LLVMInstructionEraseFromParent(self.alloca_insert_pt.get()); + llvm::LLVMInstructionEraseFromParent(self.alloca_insert_pt.unwrap()); } // Remove the cycle between fcx and bcx, so memory can be freed self.entry_bcx = None; @@ -262,7 +262,7 @@ impl FunctionContext { self.llreturn = Some(base::mk_return_basic_block(self.llfn)); } - self.llreturn.get() + self.llreturn.unwrap() } } diff --git a/src/librustc/middle/trans/controlflow.rs b/src/librustc/middle/trans/controlflow.rs index 4fa64b4130aa9..823b1e0645cbc 100644 --- a/src/librustc/middle/trans/controlflow.rs +++ b/src/librustc/middle/trans/controlflow.rs @@ -314,7 +314,7 @@ pub fn trans_break_cont(bcx: @mut Block, Some(bcx) => bcx, // This is a return from a loop body block None => { - Store(bcx, C_bool(!to_end), bcx.fcx.llretptr.get()); + Store(bcx, C_bool(!to_end), bcx.fcx.llretptr.unwrap()); cleanup_and_leave(bcx, None, Some(bcx.fcx.get_llreturn())); Unreachable(bcx); return bcx; @@ -346,7 +346,7 @@ pub fn trans_ret(bcx: @mut Block, e: Option<@ast::expr>) -> @mut Block { // to false, return flag to true, and then store the value in the // parent's retptr. Store(bcx, C_bool(true), flagptr); - Store(bcx, C_bool(false), bcx.fcx.llretptr.get()); + Store(bcx, C_bool(false), bcx.fcx.llretptr.unwrap()); expr::SaveIn(match e { Some(x) => PointerCast(bcx, retptr, type_of(bcx.ccx(), expr_ty(bcx, x)).ptr_to()), diff --git a/src/librustc/middle/trans/debuginfo.rs b/src/librustc/middle/trans/debuginfo.rs index e31a27a4c6ca0..624704c2c686c 100644 --- a/src/librustc/middle/trans/debuginfo.rs +++ b/src/librustc/middle/trans/debuginfo.rs @@ -485,8 +485,8 @@ fn lexical_block_metadata(bcx: @mut Block) -> DILexicalBlock { } } - let span = bcx.node_info.get().span; - let id = bcx.node_info.get().id; + let span = bcx.node_info.unwrap().span; + let id = bcx.node_info.unwrap().id; // Check whether we already have a cache entry for this node id match dbg_cx(cx).created_blocks.find(&id) { diff --git a/src/librustc/middle/trans/foreign.rs b/src/librustc/middle/trans/foreign.rs index 20c8e69129d74..6d5934592ebcb 100644 --- a/src/librustc/middle/trans/foreign.rs +++ b/src/librustc/middle/trans/foreign.rs @@ -149,7 +149,7 @@ fn build_shim_fn_(ccx: @mut CrateContext, // Declare the body of the shim function: let fcx = new_fn_ctxt(ccx, ~[], llshimfn, tys.fn_sig.output, None); - let bcx = fcx.entry_bcx.get(); + let bcx = fcx.entry_bcx.unwrap(); let llargbundle = get_param(llshimfn, 0u); let llargvals = arg_builder(bcx, tys, llargbundle); @@ -190,7 +190,7 @@ fn build_wrap_fn_(ccx: @mut CrateContext, ret_builder: wrap_ret_builder) { let _icx = push_ctxt("foreign::build_wrap_fn_"); let fcx = new_fn_ctxt(ccx, ~[], llwrapfn, tys.fn_sig.output, None); - let bcx = fcx.entry_bcx.get(); + let bcx = fcx.entry_bcx.unwrap(); // Patch up the return type if it's not immediate and we're returning via // the C ABI. @@ -226,7 +226,7 @@ fn build_wrap_fn_(ccx: @mut CrateContext, } else { // Cast if we have to... // XXX: This is ugly. - let llretptr = BitCast(return_context, fcx.llretptr.get(), return_type.ptr_to()); + let llretptr = BitCast(return_context, fcx.llretptr.unwrap(), return_type.ptr_to()); Ret(return_context, Load(return_context, llretptr)); } fcx.cleanup(); @@ -421,7 +421,7 @@ pub fn trans_foreign_mod(ccx: @mut CrateContext, debug!("build_direct_fn(%s)", link_name(ccx, item)); let fcx = new_fn_ctxt(ccx, ~[], decl, tys.fn_sig.output, None); - let bcx = fcx.entry_bcx.get(); + let bcx = fcx.entry_bcx.unwrap(); let llbasefn = base_fn(ccx, link_name(ccx, item), tys, cc); let ty = ty::lookup_item_type(ccx.tcx, ast_util::local_def(item.id)).ty; @@ -431,7 +431,7 @@ pub fn trans_foreign_mod(ccx: @mut CrateContext, }); let retval = Call(bcx, llbasefn, args); if !ty::type_is_nil(ret_ty) && !ty::type_is_bot(ret_ty) { - Store(bcx, retval, fcx.llretptr.get()); + Store(bcx, retval, fcx.llretptr.unwrap()); } finish_fn(fcx, bcx); } @@ -446,7 +446,7 @@ pub fn trans_foreign_mod(ccx: @mut CrateContext, debug!("build_fast_ffi_fn(%s)", link_name(ccx, item)); let fcx = new_fn_ctxt(ccx, ~[], decl, tys.fn_sig.output, None); - let bcx = fcx.entry_bcx.get(); + let bcx = fcx.entry_bcx.unwrap(); let llbasefn = base_fn(ccx, link_name(ccx, item), tys, cc); set_no_inline(fcx.llfn); set_fixed_stack_segment(fcx.llfn); @@ -458,7 +458,7 @@ pub fn trans_foreign_mod(ccx: @mut CrateContext, }); let retval = Call(bcx, llbasefn, args); if !ty::type_is_nil(ret_ty) && !ty::type_is_bot(ret_ty) { - Store(bcx, retval, fcx.llretptr.get()); + Store(bcx, retval, fcx.llretptr.unwrap()); } finish_fn(fcx, bcx); } @@ -618,7 +618,7 @@ pub fn trans_intrinsic(ccx: @mut CrateContext, set_fixed_stack_segment(fcx.llfn); } - let mut bcx = fcx.entry_bcx.get(); + let mut bcx = fcx.entry_bcx.unwrap(); let first_real_arg = fcx.arg_pos(0u); let nm = ccx.sess.str_of(item.ident); @@ -775,7 +775,7 @@ pub fn trans_intrinsic(ccx: @mut CrateContext, let in_type_size = machine::llbitsize_of_real(ccx, llintype); let out_type_size = machine::llbitsize_of_real(ccx, llouttype); if in_type_size != out_type_size { - let sp = match ccx.tcx.items.get_copy(&ref_id.get()) { + let sp = match ccx.tcx.items.get_copy(&ref_id.unwrap()) { ast_map::node_expr(e) => e.span, _ => fail!("transmute has non-expr arg"), }; @@ -816,7 +816,7 @@ pub fn trans_intrinsic(ccx: @mut CrateContext, // NB: Do not use a Load and Store here. This causes massive // code bloat when `transmute` is used on large structural // types. - let lldestptr = fcx.llretptr.get(); + let lldestptr = fcx.llretptr.unwrap(); let lldestptr = PointerCast(bcx, lldestptr, Type::i8p()); let llsrcptr = PointerCast(bcx, llsrcval, Type::i8p()); diff --git a/src/librustc/middle/trans/glue.rs b/src/librustc/middle/trans/glue.rs index 659f56b355e79..948c9ceef8e61 100644 --- a/src/librustc/middle/trans/glue.rs +++ b/src/librustc/middle/trans/glue.rs @@ -311,7 +311,7 @@ pub fn call_tydesc_glue_full(bcx: @mut Block, let llrawptr = if static_ti.is_none() || static_glue_fn.is_none() { PointerCast(bcx, v, Type::i8p()) } else { - let ty = static_ti.get().ty; + let ty = static_ti.unwrap().ty; let simpl = simplified_glue_type(ccx.tcx, field, ty); if simpl != ty { PointerCast(bcx, v, type_of(ccx, simpl).ptr_to()) @@ -708,7 +708,7 @@ pub fn make_generic_glue_inner(ccx: @mut CrateContext, // llfn is expected be declared to take a parameter of the appropriate // type, so we don't need to explicitly cast the function parameter. - let bcx = fcx.entry_bcx.get(); + let bcx = fcx.entry_bcx.unwrap(); let rawptr0_arg = fcx.arg_pos(0u); let llrawptr0 = unsafe { llvm::LLVMGetParam(llfn, rawptr0_arg as c_uint) }; let bcx = helper(bcx, llrawptr0, t); diff --git a/src/librustc/middle/trans/monomorphize.rs b/src/librustc/middle/trans/monomorphize.rs index 6fd47436fd884..5f8837b538cdf 100644 --- a/src/librustc/middle/trans/monomorphize.rs +++ b/src/librustc/middle/trans/monomorphize.rs @@ -180,7 +180,7 @@ pub fn monomorphic_fn(ccx: @mut CrateContext, let idx = psubsts.tys.len() - num_method_ty_params; let substs = (psubsts.tys.slice(0, idx) + - &[psubsts.self_ty.get()] + + &[psubsts.self_ty.unwrap()] + psubsts.tys.tailn(idx)); debug!("static default: changed substitution to %s", substs.repr(ccx.tcx)); @@ -245,7 +245,7 @@ pub fn monomorphic_fn(ccx: @mut CrateContext, } ast_map::node_variant(ref v, enum_item, _) => { let tvs = ty::enum_variants(ccx.tcx, local_def(enum_item.id)); - let this_tv = *tvs.iter().find_(|tv| { tv.id.node == fn_id.node}).get(); + let this_tv = *tvs.iter().find_(|tv| { tv.id.node == fn_id.node}).unwrap(); let d = mk_lldecl(); 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 e4259c80720e6..609aad0bc201c 100644 --- a/src/librustc/middle/trans/reflect.rs +++ b/src/librustc/middle/trans/reflect.rs @@ -303,10 +303,10 @@ impl Reflector { // llvm::LLVMGetParam(llfdecl, fcx.arg_pos(0u) as c_uint) }; - let mut bcx = fcx.entry_bcx.get(); + let mut bcx = fcx.entry_bcx.unwrap(); let arg = BitCast(bcx, arg, llptrty); let ret = adt::trans_get_discr(bcx, repr, arg); - Store(bcx, ret, fcx.llretptr.get()); + Store(bcx, ret, fcx.llretptr.unwrap()); match fcx.llreturn { Some(llreturn) => cleanup_and_Br(bcx, bcx, llreturn), None => bcx = cleanup_block(bcx, Some(bcx.llbb)) diff --git a/src/librustc/middle/trans/type_of.rs b/src/librustc/middle/trans/type_of.rs index b743f2e940157..6a382cc1a5d1c 100644 --- a/src/librustc/middle/trans/type_of.rs +++ b/src/librustc/middle/trans/type_of.rs @@ -239,7 +239,7 @@ pub fn type_of(cx: &mut CrateContext, t: ty::t) -> Type { ty::ty_estr(ty::vstore_slice(_)) => { // This means we get a nicer name in the output - cx.tn.find_type("str_slice").get() + cx.tn.find_type("str_slice").unwrap() } ty::ty_estr(ty::vstore_fixed(n)) => { diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index 29b975cdf99f8..48a003ddaf157 100644 --- a/src/librustc/middle/ty.rs +++ b/src/librustc/middle/ty.rs @@ -33,6 +33,7 @@ use std::hashmap::{HashMap, HashSet}; use std::ops; use std::ptr::to_unsafe_ptr; use std::to_bytes; +use std::to_str::ToStr; use std::u32; use std::vec; use syntax::ast::*; @@ -116,7 +117,7 @@ pub struct mt { mutbl: ast::mutability, } -#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable, IterBytes, ToStr)] pub enum vstore { vstore_fixed(uint), vstore_uniq, @@ -124,7 +125,7 @@ pub enum vstore { vstore_slice(Region) } -#[deriving(Clone, Eq, IterBytes, Encodable, Decodable)] +#[deriving(Clone, Eq, IterBytes, Encodable, Decodable, ToStr)] pub enum TraitStore { BoxTraitStore, // @Trait UniqTraitStore, // ~Trait @@ -350,6 +351,12 @@ pub struct t_box_ { enum t_opaque {} pub type t = *t_opaque; +impl ToStr for t { + fn to_str(&self) -> ~str { + ~"*t_opaque" + } +} + pub fn get(t: t) -> t_box { unsafe { let t2: t_box = cast::transmute(t); @@ -410,7 +417,7 @@ pub struct param_ty { } /// Representation of regions: -#[deriving(Clone, Eq, IterBytes, Encodable, Decodable)] +#[deriving(Clone, Eq, IterBytes, Encodable, Decodable, ToStr)] pub enum Region { /// Bound regions are found (primarily) in function types. They indicate /// region parameters that have yet to be replaced with actual regions @@ -456,13 +463,13 @@ impl Region { } } -#[deriving(Clone, Eq, IterBytes, Encodable, Decodable)] +#[deriving(Clone, Eq, IterBytes, Encodable, Decodable, ToStr)] pub struct FreeRegion { scope_id: NodeId, bound_region: bound_region } -#[deriving(Clone, Eq, IterBytes, Encodable, Decodable)] +#[deriving(Clone, Eq, IterBytes, Encodable, Decodable, ToStr)] pub enum bound_region { /// The self region for structs, impls (&T in a type defn or &'self T) br_self, @@ -620,19 +627,22 @@ pub enum IntVarValue { UintType(ast::uint_ty), } -#[deriving(Clone)] +#[deriving(Clone, ToStr)] pub enum terr_vstore_kind { - terr_vec, terr_str, terr_fn, terr_trait + terr_vec, + terr_str, + terr_fn, + terr_trait } -#[deriving(Clone)] +#[deriving(Clone, ToStr)] pub struct expected_found { expected: T, found: T } // Data structures used in type unification -#[deriving(Clone)] +#[deriving(Clone, ToStr)] pub enum type_err { terr_mismatch, terr_purity_mismatch(expected_found), @@ -674,7 +684,7 @@ pub struct ParamBounds { pub type BuiltinBounds = EnumSet; -#[deriving(Clone, Eq, IterBytes)] +#[deriving(Clone, Eq, IterBytes, ToStr)] pub enum BuiltinBound { BoundStatic, BoundSend, @@ -725,7 +735,7 @@ pub enum InferTy { FloatVar(FloatVid) } -#[deriving(Clone, Encodable, Decodable, IterBytes)] +#[deriving(Clone, Encodable, Decodable, IterBytes, ToStr)] pub enum InferRegion { ReVar(RegionVid), ReSkolemized(uint, bound_region) diff --git a/src/librustc/middle/typeck/astconv.rs b/src/librustc/middle/typeck/astconv.rs index ebf9d0944c9fb..53853e4fe1a78 100644 --- a/src/librustc/middle/typeck/astconv.rs +++ b/src/librustc/middle/typeck/astconv.rs @@ -531,7 +531,7 @@ pub fn ty_of_arg) -> ty::t { match a.ty.node { - ast::ty_infer if expected_ty.is_some() => expected_ty.get(), + ast::ty_infer if expected_ty.is_some() => expected_ty.unwrap(), ast::ty_infer => this.ty_infer(a.ty.span), _ => ast_ty_to_ty(this, rscope, &a.ty), } @@ -587,7 +587,7 @@ pub fn ty_of_method( }; let (a, b) = ty_of_method_or_bare_fn( this, rscope, purity, AbiSet::Rust(), lifetimes, Some(&self_info), decl); - (a.get(), b) + (a.unwrap(), b) } pub fn ty_of_bare_fn( @@ -735,7 +735,7 @@ pub fn ty_of_closure( let expected_ret_ty = expected_sig.map(|e| e.output); let output_ty = match decl.output.node { - ast::ty_infer if expected_ret_ty.is_some() => expected_ret_ty.get(), + ast::ty_infer if expected_ret_ty.is_some() => expected_ret_ty.unwrap(), ast::ty_infer => 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 842bbff41e065..7caed39060159 100644 --- a/src/librustc/middle/typeck/check/_match.rs +++ b/src/librustc/middle/typeck/check/_match.rs @@ -166,7 +166,7 @@ pub fn check_pat_variant(pcx: &pat_ctxt, pat: @ast::pat, path: &ast::Path, fcx.write_error(pat.id); kind_name = "[error]"; arg_types = (*subpats).clone() - .get_or_default(~[]) + .unwrap_or_default(~[]) .map(|_| ty::mk_err()); } } @@ -209,7 +209,7 @@ pub fn check_pat_variant(pcx: &pat_ctxt, pat: @ast::pat, path: &ast::Path, fcx.write_error(pat.id); kind_name = "[error]"; arg_types = (*subpats).clone() - .get_or_default(~[]) + .unwrap_or_default(~[]) .map(|_| ty::mk_err()); } } diff --git a/src/librustc/middle/typeck/check/method.rs b/src/librustc/middle/typeck/check/method.rs index 209f636ddc238..e1e7d10db0abd 100644 --- a/src/librustc/middle/typeck/check/method.rs +++ b/src/librustc/middle/typeck/check/method.rs @@ -854,7 +854,7 @@ impl<'self> LookupContext<'self> { // like &'a Self. We then perform a // substitution which will replace Self with // @Trait. - let t = candidate.method_ty.transformed_self_ty.get(); + let t = candidate.method_ty.transformed_self_ty.unwrap(); ty::subst(tcx, &candidate.rcvr_substs, t) } _ => { @@ -863,7 +863,7 @@ impl<'self> LookupContext<'self> { } } _ => { - let t = candidate.method_ty.transformed_self_ty.get(); + let t = candidate.method_ty.transformed_self_ty.unwrap(); ty::subst(tcx, &candidate.rcvr_substs, t) } }; @@ -922,7 +922,7 @@ impl<'self> LookupContext<'self> { tcx, @Nil, Some(transformed_self_ty), &bare_fn_ty.sig, |br| self.fcx.infcx().next_region_var( infer::BoundRegionInFnCall(self.expr.span, br))); - let transformed_self_ty = opt_transformed_self_ty.get(); + let transformed_self_ty = opt_transformed_self_ty.unwrap(); let fty = ty::mk_bare_fn(tcx, ty::BareFnTy { sig: fn_sig, purity: bare_fn_ty.purity, diff --git a/src/librustc/middle/typeck/check/mod.rs b/src/librustc/middle/typeck/check/mod.rs index 7f486f77447cb..ea8a11fc7b382 100644 --- a/src/librustc/middle/typeck/check/mod.rs +++ b/src/librustc/middle/typeck/check/mod.rs @@ -365,7 +365,7 @@ pub fn check_fn(ccx: @mut CrateCtxt, bound_region: br})); let opt_self_info = opt_self_info.map( - |si| SelfInfo {self_ty: opt_self_ty.get(), ..*si}); + |si| SelfInfo {self_ty: opt_self_ty.unwrap(), ..*si}); (isr, opt_self_info, fn_sig) }; @@ -2449,7 +2449,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt, expected, |x| Some((*x).clone())); let inner_ty = match expected_sty { - Some(ty::ty_closure(_)) => expected.get(), + Some(ty::ty_closure(_)) => expected.unwrap(), _ => match expected { Some(expected_t) => { fcx.type_error_message(expr.span, |actual| { diff --git a/src/librustc/middle/typeck/infer/glb.rs b/src/librustc/middle/typeck/infer/glb.rs index b9a62acd0bd87..f05388344bc71 100644 --- a/src/librustc/middle/typeck/infer/glb.rs +++ b/src/librustc/middle/typeck/infer/glb.rs @@ -253,7 +253,7 @@ impl Combine for Glb { 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_isr, a_r.get()); + return rev_lookup(this, a_isr, a_r.unwrap()); } else if a_r.is_none() && b_r.is_none() { // Not related to bound variables from either fn: return r0; diff --git a/src/librustc/middle/typeck/mod.rs b/src/librustc/middle/typeck/mod.rs index e6c27fc8f836d..b1356ffb2d5e9 100644 --- a/src/librustc/middle/typeck/mod.rs +++ b/src/librustc/middle/typeck/mod.rs @@ -295,7 +295,7 @@ trait get_and_find_region { impl get_and_find_region for isr_alist { pub fn get(&self, br: ty::bound_region) -> ty::Region { - self.find(br).get() + self.find(br).unwrap() } pub fn find(&self, br: ty::bound_region) -> Option { diff --git a/src/librustc/middle/typeck/rscope.rs b/src/librustc/middle/typeck/rscope.rs index e2b25a67c3dde..bbcf42b1c5d32 100644 --- a/src/librustc/middle/typeck/rscope.rs +++ b/src/librustc/middle/typeck/rscope.rs @@ -18,6 +18,7 @@ use syntax::opt_vec::OptVec; use syntax::opt_vec; use syntax::parse::token::special_idents; +#[deriving(ToStr)] pub struct RegionError { msg: ~str, replacement: ty::Region diff --git a/src/librustc/util/enum_set.rs b/src/librustc/util/enum_set.rs index 2466c373f23b4..ced29f18f7f11 100644 --- a/src/librustc/util/enum_set.rs +++ b/src/librustc/util/enum_set.rs @@ -10,7 +10,7 @@ use std::iterator::Iterator; -#[deriving(Clone, Eq, IterBytes)] +#[deriving(Clone, Eq, IterBytes, ToStr)] pub struct EnumSet { // We must maintain the invariant that no bits are set // for which no variant exists diff --git a/src/librustdoc/attr_pass.rs b/src/librustdoc/attr_pass.rs index b189bd2bc2dcd..a1cb81f450357 100644 --- a/src/librustdoc/attr_pass.rs +++ b/src/librustdoc/attr_pass.rs @@ -68,7 +68,7 @@ fn fold_crate( doc::CrateDoc { topmod: doc::ModDoc { item: doc::ItemDoc { - name: attrs.name.clone().get_or_default(doc.topmod.name_()), + name: attrs.name.clone().unwrap_or_default(doc.topmod.name_()), .. doc.topmod.item.clone() }, .. doc.topmod.clone() @@ -135,7 +135,7 @@ fn fold_enum( let ast_variant = (*enum_definition.variants.iter().find_(|v| { to_str(v.node.name) == variant.name - }).get()).clone(); + }).unwrap()).clone(); attr_parser::parse_desc( ast_variant.node.attrs.clone()) diff --git a/src/librustdoc/config.rs b/src/librustdoc/config.rs index f287e17880bb3..d387bbea592d3 100644 --- a/src/librustdoc/config.rs +++ b/src/librustdoc/config.rs @@ -142,7 +142,7 @@ fn config_from_opts( let output_dir = getopts::opt_maybe_str(matches, opt_output_dir()); let output_dir = output_dir.map(|s| Path(*s)); result::Ok(Config { - output_dir: output_dir.get_or_default(config.output_dir.clone()), + output_dir: output_dir.unwrap_or_default(config.output_dir.clone()), .. config }) }; @@ -273,20 +273,20 @@ mod test { #[test] fn should_error_with_no_crates() { let config = parse_config([~"rustdoc"]); - assert!(config.get_err() == ~"no crates specified"); + assert!(config.unwrap_err() == ~"no crates specified"); } #[test] fn should_error_with_multiple_crates() { let config = parse_config([~"rustdoc", ~"crate1.rc", ~"crate2.rc"]); - assert!(config.get_err() == ~"multiple crates specified"); + assert!(config.unwrap_err() == ~"multiple crates specified"); } #[test] fn should_set_output_dir_to_cwd_if_not_provided() { let config = parse_config([~"rustdoc", ~"crate.rc"]); - assert!(config.get().output_dir == Path(".")); + assert!(config.unwrap().output_dir == Path(".")); } #[test] @@ -294,13 +294,13 @@ mod test { let config = parse_config([ ~"rustdoc", ~"crate.rc", ~"--output-dir", ~"snuggles" ]); - assert!(config.get().output_dir == Path("snuggles")); + assert!(config.unwrap().output_dir == Path("snuggles")); } #[test] fn should_set_output_format_to_pandoc_html_if_not_provided() { let config = parse_config([~"rustdoc", ~"crate.rc"]); - assert!(config.get().output_format == PandocHtml); + assert!(config.unwrap().output_format == PandocHtml); } #[test] @@ -308,7 +308,7 @@ mod test { let config = parse_config([ ~"rustdoc", ~"crate.rc", ~"--output-format", ~"markdown" ]); - assert!(config.get().output_format == Markdown); + assert!(config.unwrap().output_format == Markdown); } #[test] @@ -316,7 +316,7 @@ mod test { let config = parse_config([ ~"rustdoc", ~"crate.rc", ~"--output-format", ~"html" ]); - assert!(config.get().output_format == PandocHtml); + assert!(config.unwrap().output_format == PandocHtml); } #[test] @@ -324,13 +324,13 @@ mod test { let config = parse_config([ ~"rustdoc", ~"crate.rc", ~"--output-format", ~"bogus" ]); - assert!(config.get_err() == ~"unknown output format 'bogus'"); + assert!(config.unwrap_err() == ~"unknown output format 'bogus'"); } #[test] fn should_set_output_style_to_doc_per_mod_by_default() { let config = parse_config([~"rustdoc", ~"crate.rc"]); - assert!(config.get().output_style == DocPerMod); + assert!(config.unwrap().output_style == DocPerMod); } #[test] @@ -338,7 +338,7 @@ mod test { let config = parse_config([ ~"rustdoc", ~"crate.rc", ~"--output-style", ~"doc-per-crate" ]); - assert!(config.get().output_style == DocPerCrate); + assert!(config.unwrap().output_style == DocPerCrate); } #[test] @@ -346,7 +346,7 @@ mod test { let config = parse_config([ ~"rustdoc", ~"crate.rc", ~"--output-style", ~"doc-per-mod" ]); - assert!(config.get().output_style == DocPerMod); + assert!(config.unwrap().output_style == DocPerMod); } #[test] @@ -354,7 +354,7 @@ mod test { let config = parse_config([ ~"rustdoc", ~"crate.rc", ~"--output-style", ~"bogus" ]); - assert!(config.get_err() == ~"unknown output style 'bogus'"); + assert!(config.unwrap_err() == ~"unknown output style 'bogus'"); } #[test] @@ -362,12 +362,12 @@ mod test { let config = parse_config([ ~"rustdoc", ~"crate.rc", ~"--pandoc-cmd", ~"panda-bear-doc" ]); - assert!(config.get().pandoc_cmd == Some(~"panda-bear-doc")); + assert!(config.unwrap().pandoc_cmd == Some(~"panda-bear-doc")); } #[test] fn should_set_pandoc_command_when_using_pandoc() { let config = parse_config([~"rustdoc", ~"crate.rc"]); - assert!(config.get().pandoc_cmd == Some(~"pandoc")); + assert!(config.unwrap().pandoc_cmd == Some(~"pandoc")); } } diff --git a/src/librustdoc/desc_to_brief_pass.rs b/src/librustdoc/desc_to_brief_pass.rs index 9e1dffb989b00..9f8041712eaec 100644 --- a/src/librustdoc/desc_to_brief_pass.rs +++ b/src/librustdoc/desc_to_brief_pass.rs @@ -83,7 +83,7 @@ pub fn extract(desc: Option<~str>) -> Option<~str> { return None } - parse_desc(desc.clone().get()) + parse_desc(desc.clone().unwrap()) } fn parse_desc(desc: ~str) -> Option<~str> { diff --git a/src/librustdoc/doc.rs b/src/librustdoc/doc.rs index cca898feba2b2..d24fd1f5bfe54 100644 --- a/src/librustdoc/doc.rs +++ b/src/librustdoc/doc.rs @@ -176,7 +176,7 @@ impl Doc { doc::CratePage(doc) => Some(doc), _ => None } - }).get() + }).unwrap() } pub fn cratemod(&self) -> ModDoc { diff --git a/src/librustdoc/markdown_index_pass.rs b/src/librustdoc/markdown_index_pass.rs index 2c6312e01b205..90634770a501e 100644 --- a/src/librustdoc/markdown_index_pass.rs +++ b/src/librustdoc/markdown_index_pass.rs @@ -223,13 +223,13 @@ mod test { config::DocPerCrate, ~"mod a { } fn b() { }" ); - assert!(doc.cratemod().index.get().entries[0] == doc::IndexEntry { + assert!(doc.cratemod().index.unwrap().entries[0] == doc::IndexEntry { kind: ~"Module", name: ~"a", brief: None, link: ~"#module-a" }); - assert!(doc.cratemod().index.get().entries[1] == doc::IndexEntry { + assert!(doc.cratemod().index.unwrap().entries[1] == doc::IndexEntry { kind: ~"Function", name: ~"b", brief: None, @@ -243,13 +243,13 @@ mod test { config::DocPerMod, ~"mod a { } fn b() { }" ); - assert_eq!(doc.cratemod().index.get().entries[0], doc::IndexEntry { + assert_eq!(doc.cratemod().index.unwrap().entries[0], doc::IndexEntry { kind: ~"Module", name: ~"a", brief: None, link: ~"a.html" }); - assert_eq!(doc.cratemod().index.get().entries[1], doc::IndexEntry { + assert_eq!(doc.cratemod().index.unwrap().entries[1], doc::IndexEntry { kind: ~"Function", name: ~"b", brief: None, @@ -263,7 +263,7 @@ mod test { config::DocPerMod, ~"#[doc = \"test\"] mod a { }" ); - assert_eq!(doc.cratemod().index.get().entries[0].brief, Some(~"test")); + assert_eq!(doc.cratemod().index.unwrap().entries[0].brief, Some(~"test")); } #[test] @@ -273,7 +273,7 @@ mod test { ~"extern { fn b(); }" ); // hidden __std_macros module at the start. - assert_eq!(doc.cratemod().nmods()[0].index.get().entries[0], + assert_eq!(doc.cratemod().nmods()[0].index.unwrap().entries[0], doc::IndexEntry { kind: ~"Function", name: ~"b", diff --git a/src/librustdoc/markdown_pass.rs b/src/librustdoc/markdown_pass.rs index 0dbd29df48b63..85c360a9e0dfd 100644 --- a/src/librustdoc/markdown_pass.rs +++ b/src/librustdoc/markdown_pass.rs @@ -617,10 +617,10 @@ mod test { fn d() { }" ); - let idx_a = markdown.find_str("# Module `a`").get(); - let idx_b = markdown.find_str("## Function `b`").get(); - let idx_c = markdown.find_str("# Module `c`").get(); - let idx_d = markdown.find_str("## Function `d`").get(); + let idx_a = markdown.find_str("# Module `a`").unwrap(); + let idx_b = markdown.find_str("## Function `b`").unwrap(); + let idx_c = markdown.find_str("# Module `c`").unwrap(); + let idx_d = markdown.find_str("## Function `d`").unwrap(); assert!(idx_b < idx_d); assert!(idx_d < idx_a); diff --git a/src/librustdoc/sectionalize_pass.rs b/src/librustdoc/sectionalize_pass.rs index 4cd442bb95147..20f3ff3e98d48 100644 --- a/src/librustdoc/sectionalize_pass.rs +++ b/src/librustdoc/sectionalize_pass.rs @@ -218,8 +218,8 @@ mod test { Body\"]\ mod a { }"); - assert!(!doc.cratemod().mods()[0].desc().get().contains("Header")); - assert!(!doc.cratemod().mods()[0].desc().get().contains("Body")); + assert!(!doc.cratemod().mods()[0].desc().unwrap().contains("Header")); + assert!(!doc.cratemod().mods()[0].desc().unwrap().contains("Body")); } #[test] diff --git a/src/librustdoc/tystr_pass.rs b/src/librustdoc/tystr_pass.rs index abfc3517d60eb..684b4e9d198d4 100644 --- a/src/librustdoc/tystr_pass.rs +++ b/src/librustdoc/tystr_pass.rs @@ -135,7 +135,7 @@ fn fold_enum( let ast_variant = (*do enum_definition.variants.iter().find_ |v| { to_str(v.node.name) == variant.name - }.get()).clone(); + }.unwrap()).clone(); pprust::variant_to_str( &ast_variant, extract::interner()) @@ -443,7 +443,7 @@ mod test { #[test] fn should_add_struct_defs() { let doc = mk_doc(~"struct S { field: () }"); - assert!(doc.cratemod().structs()[0].sig.get().contains( + assert!(doc.cratemod().structs()[0].sig.unwrap().contains( "struct S {")); } @@ -451,6 +451,6 @@ mod test { fn should_not_serialize_struct_attrs() { // All we care about are the fields let doc = mk_doc(~"#[wut] struct S { field: () }"); - assert!(!doc.cratemod().structs()[0].sig.get().contains("wut")); + assert!(!doc.cratemod().structs()[0].sig.unwrap().contains("wut")); } } diff --git a/src/librusti/rusti.rs b/src/librusti/rusti.rs index 568a691290c88..5d5518997f68f 100644 --- a/src/librusti/rusti.rs +++ b/src/librusti/rusti.rs @@ -322,14 +322,14 @@ fn compile_crate(src_filename: ~str, binary: ~str) -> Option { // instead we guess which file is the library by matching // the prefix and suffix of out_filename to files in the // directory. - let file_str = file.filename().get(); - file_str.starts_with(outputs.out_filename.filestem().get()) - && file_str.ends_with(outputs.out_filename.filetype().get()) + let file_str = file.filename().unwrap(); + file_str.starts_with(outputs.out_filename.filestem().unwrap()) + && file_str.ends_with(outputs.out_filename.filetype().unwrap()) }; match maybe_lib_path { Some(lib_path) => { - let (src_mtime, _) = src_path.get_mtime().get(); - let (lib_mtime, _) = lib_path.get_mtime().get(); + let (src_mtime, _) = src_path.get_mtime().unwrap(); + let (lib_mtime, _) = lib_path.get_mtime().unwrap(); if lib_mtime >= src_mtime { should_compile = false; } diff --git a/src/librustpkg/rustpkg.rs b/src/librustpkg/rustpkg.rs index 4d6033de54de4..fa03a5bbfc2fb 100644 --- a/src/librustpkg/rustpkg.rs +++ b/src/librustpkg/rustpkg.rs @@ -102,7 +102,7 @@ impl<'self> PkgScript<'self> { debug!("pkgscript parse: %?", os::self_exe_path()); let options = @session::options { binary: binary, - maybe_sysroot: Some(@os::self_exe_path().get().pop()), + maybe_sysroot: Some(@os::self_exe_path().unwrap().pop()), crate_type: session::bin_crate, .. (*session::basic_options()).clone() }; @@ -535,7 +535,7 @@ pub fn main() { * in is the working directory. */ pub fn work_dir() -> Path { - os::self_exe_path().get() + os::self_exe_path().unwrap() } /** diff --git a/src/librustpkg/util.rs b/src/librustpkg/util.rs index 361981289d3ce..81b47d6a16c0a 100644 --- a/src/librustpkg/util.rs +++ b/src/librustpkg/util.rs @@ -195,7 +195,7 @@ pub fn compile_input(ctxt: &Ctx, } + flags + cfgs.flat_map(|c| { ~[~"--cfg", (*c).clone()] }), - driver::optgroups()).get(); + driver::optgroups()).unwrap(); let options = @session::options { crate_type: crate_type, optimize: if opt { session::Aggressive } else { session::No }, diff --git a/src/libstd/at_vec.rs b/src/libstd/at_vec.rs index 4ece53d0e7f52..a84f3137bbd5b 100644 --- a/src/libstd/at_vec.rs +++ b/src/libstd/at_vec.rs @@ -78,10 +78,8 @@ pub fn build(builder: &fn(push: &fn(v: A))) -> @[A] { * onto the vector being constructed. */ #[inline] -pub fn build_sized_opt(size: Option, - builder: &fn(push: &fn(v: A))) - -> @[A] { - build_sized(size.get_or_default(4), builder) +pub fn build_sized_opt(size: Option, builder: &fn(push: &fn(v: A))) -> @[A] { + build_sized(size.unwrap_or_default(4), builder) } // Appending diff --git a/src/libstd/either.rs b/src/libstd/either.rs index 6bdc45d72042a..cfaef550c6fa7 100644 --- a/src/libstd/either.rs +++ b/src/libstd/either.rs @@ -23,29 +23,102 @@ use str::StrSlice; use vec; use vec::{OwnedVector, ImmutableVector}; -/// The either type +/// `Either` is a type that represents one of two alternatives #[deriving(Clone, Eq)] -pub enum Either { - Left(T), - Right(U) +pub enum Either { + Left(L), + Right(R) } -/// Applies a function based on the given either value -/// -/// If `value` is left(T) then `f_left` is applied to its contents, if -/// `value` is right(U) then `f_right` is applied to its contents, and the -/// result is returned. -#[inline] -pub fn either(f_left: &fn(&T) -> V, - f_right: &fn(&U) -> V, value: &Either) -> V { - match *value { - Left(ref l) => f_left(l), - Right(ref r) => f_right(r) +impl Either { + /// Applies a function based on the given either value + /// + /// If `value` is `Left(L)` then `f_left` is applied to its contents, if + /// `value` is `Right(R)` then `f_right` is applied to its contents, and the + /// result is returned. + #[inline] + pub fn either(&self, f_left: &fn(&L) -> T, f_right: &fn(&R) -> T) -> T { + match *self { + Left(ref l) => f_left(l), + Right(ref r) => f_right(r) + } + } + + /// Flips between left and right of a given `Either` + #[inline] + pub fn flip(self) -> Either { + match self { + Right(r) => Left(r), + Left(l) => Right(l) + } + } + + /// Converts a `Either` to a `Result` + /// + /// Converts an `Either` type to a `Result` type, making the "right" choice + /// an `Ok` result, and the "left" choice a `Err` + #[inline] + pub fn to_result(self) -> Result { + match self { + Right(r) => result::Ok(r), + Left(l) => result::Err(l) + } + } + + /// Checks whether the given value is a `Left` + #[inline] + pub fn is_left(&self) -> bool { + match *self { + Left(_) => true, + _ => false + } + } + + /// Checks whether the given value is a `Right` + #[inline] + pub fn is_right(&self) -> bool { + match *self { + Right(_) => true, + _ => false + } + } + + /// Retrieves the value from a `Left`. + /// Fails with a specified reason if the `Either` is `Right`. + #[inline] + pub fn expect_left(self, reason: &str) -> L { + match self { + Left(x) => x, + Right(_) => fail!(reason.to_owned()) + } + } + + /// Retrieves the value from a `Left`. Fails if the `Either` is `Right`. + #[inline] + pub fn unwrap_left(self) -> L { + self.expect_left("called Either::unwrap_left()` on `Right` value") + } + + /// Retrieves the value from a `Right`. + /// Fails with a specified reason if the `Either` is `Left`. + #[inline] + pub fn expect_right(self, reason: &str) -> R { + match self { + Right(x) => x, + Left(_) => fail!(reason.to_owned()) + } + } + + /// Retrieves the value from a `Right`. Fails if the `Either` is `Left`. + #[inline] + pub fn unwrap_right(self) -> R { + self.expect_right("called Either::unwrap_right()` on `Left` value") } } +// FIXME: #8228 Replaceable by an external iterator? /// Extracts from a vector of either all the left values -pub fn lefts(eithers: &[Either]) -> ~[T] { +pub fn lefts(eithers: &[Either]) -> ~[L] { do vec::build_sized(eithers.len()) |push| { for elt in eithers.iter() { match *elt { @@ -56,8 +129,9 @@ pub fn lefts(eithers: &[Either]) -> ~[T] { } } +// FIXME: #8228 Replaceable by an external iterator? /// Extracts from a vector of either all the right values -pub fn rights(eithers: &[Either]) -> ~[U] { +pub fn rights(eithers: &[Either]) -> ~[R] { do vec::build_sized(eithers.len()) |push| { for elt in eithers.iter() { match *elt { @@ -68,13 +142,14 @@ pub fn rights(eithers: &[Either]) -> ~[U] { } } +// FIXME: #8228 Replaceable by an external iterator? /// Extracts from a vector of either all the left values and right values /// /// Returns a structure containing a vector of left values and a vector of /// right values. -pub fn partition(eithers: ~[Either]) -> (~[T], ~[U]) { - let mut lefts: ~[T] = ~[]; - let mut rights: ~[U] = ~[]; +pub fn partition(eithers: ~[Either]) -> (~[L], ~[R]) { + let mut lefts: ~[L] = ~[]; + let mut rights: ~[R] = ~[]; for elt in eithers.consume_iter() { match elt { Left(l) => lefts.push(l), @@ -84,196 +159,101 @@ pub fn partition(eithers: ~[Either]) -> (~[T], ~[U]) { return (lefts, rights); } -/// Flips between left and right of a given either -#[inline] -pub fn flip(eith: Either) -> Either { - match eith { - Right(r) => Left(r), - Left(l) => Right(l) - } -} +#[cfg(test)] +mod tests { + use super::*; -/// Converts either::t to a result::t -/// -/// Converts an `either` type to a `result` type, making the "right" choice -/// an ok result, and the "left" choice a fail -#[inline] -pub fn to_result(eith: Either) -> Result { - match eith { - Right(r) => result::Ok(r), - Left(l) => result::Err(l) + #[test] + fn test_either_left() { + let val = Left(10); + fn f_left(x: &int) -> bool { *x == 10 } + fn f_right(_x: &uint) -> bool { false } + assert!(val.either(f_left, f_right)); } -} -/// Checks whether the given value is a left -#[inline] -pub fn is_left(eith: &Either) -> bool { - match *eith { - Left(_) => true, - _ => false + #[test] + fn test_either_right() { + let val = Right(10u); + fn f_left(_x: &int) -> bool { false } + fn f_right(x: &uint) -> bool { *x == 10u } + assert!(val.either(f_left, f_right)); } -} -/// Checks whether the given value is a right -#[inline] -pub fn is_right(eith: &Either) -> bool { - match *eith { - Right(_) => true, - _ => false + #[test] + fn test_lefts() { + let input = ~[Left(10), Right(11), Left(12), Right(13), Left(14)]; + let result = lefts(input); + assert_eq!(result, ~[10, 12, 14]); } -} -/// Retrieves the value in the left branch. -/// Fails with a specified reason if the either is Right. -#[inline] -pub fn expect_left(eith: Either, reason: &str) -> T { - match eith { - Left(x) => x, - Right(_) => fail!(reason.to_owned()) + #[test] + fn test_lefts_none() { + let input: ~[Either] = ~[Right(10), Right(10)]; + let result = lefts(input); + assert_eq!(result.len(), 0u); } -} -/// Retrieves the value in the left branch. Fails if the either is Right. -#[inline] -pub fn unwrap_left(eith: Either) -> T { - expect_left(eith, "either::unwrap_left Right") -} - -/// Retrieves the value in the right branch. -/// Fails with a specified reason if the either is Left. -#[inline] -pub fn expect_right(eith: Either, reason: &str) -> U { - match eith { - Right(x) => x, - Left(_) => fail!(reason.to_owned()) + #[test] + fn test_lefts_empty() { + let input: ~[Either] = ~[]; + let result = lefts(input); + assert_eq!(result.len(), 0u); } -} -/// Retrieves the value in the right branch. Fails if the either is Left. -pub fn unwrap_right(eith: Either) -> U { - expect_right(eith, "either::unwrap_right Left") -} - -impl Either { - #[inline] - pub fn either(&self, f_left: &fn(&T) -> V, f_right: &fn(&U) -> V) -> V { - either(f_left, f_right, self) + #[test] + fn test_rights() { + let input = ~[Left(10), Right(11), Left(12), Right(13), Left(14)]; + let result = rights(input); + assert_eq!(result, ~[11, 13]); } - #[inline] - pub fn flip(self) -> Either { flip(self) } - - #[inline] - pub fn to_result(self) -> Result { to_result(self) } - - #[inline] - pub fn is_left(&self) -> bool { is_left(self) } - - #[inline] - pub fn is_right(&self) -> bool { is_right(self) } - - #[inline] - pub fn expect_left(self, reason: &str) -> T { expect_left(self, reason) } - - #[inline] - pub fn unwrap_left(self) -> T { unwrap_left(self) } - - #[inline] - pub fn expect_right(self, reason: &str) -> U { expect_right(self, reason) } - - #[inline] - pub fn unwrap_right(self) -> U { unwrap_right(self) } -} - -#[test] -fn test_either_left() { - let val = Left(10); - fn f_left(x: &int) -> bool { *x == 10 } - fn f_right(_x: &uint) -> bool { false } - assert!((either(f_left, f_right, &val))); -} - -#[test] -fn test_either_right() { - let val = Right(10u); - fn f_left(_x: &int) -> bool { false } - fn f_right(x: &uint) -> bool { *x == 10u } - assert!((either(f_left, f_right, &val))); -} - -#[test] -fn test_lefts() { - let input = ~[Left(10), Right(11), Left(12), Right(13), Left(14)]; - let result = lefts(input); - assert_eq!(result, ~[10, 12, 14]); -} - -#[test] -fn test_lefts_none() { - let input: ~[Either] = ~[Right(10), Right(10)]; - let result = lefts(input); - assert_eq!(result.len(), 0u); -} - -#[test] -fn test_lefts_empty() { - let input: ~[Either] = ~[]; - let result = lefts(input); - assert_eq!(result.len(), 0u); -} - -#[test] -fn test_rights() { - let input = ~[Left(10), Right(11), Left(12), Right(13), Left(14)]; - let result = rights(input); - assert_eq!(result, ~[11, 13]); -} + #[test] + fn test_rights_none() { + let input: ~[Either] = ~[Left(10), Left(10)]; + let result = rights(input); + assert_eq!(result.len(), 0u); + } -#[test] -fn test_rights_none() { - let input: ~[Either] = ~[Left(10), Left(10)]; - let result = rights(input); - assert_eq!(result.len(), 0u); -} + #[test] + fn test_rights_empty() { + let input: ~[Either] = ~[]; + let result = rights(input); + assert_eq!(result.len(), 0u); + } -#[test] -fn test_rights_empty() { - let input: ~[Either] = ~[]; - let result = rights(input); - assert_eq!(result.len(), 0u); -} + #[test] + fn test_partition() { + let input = ~[Left(10), Right(11), Left(12), Right(13), Left(14)]; + let (lefts, rights) = partition(input); + assert_eq!(lefts[0], 10); + assert_eq!(lefts[1], 12); + assert_eq!(lefts[2], 14); + assert_eq!(rights[0], 11); + assert_eq!(rights[1], 13); + } -#[test] -fn test_partition() { - let input = ~[Left(10), Right(11), Left(12), Right(13), Left(14)]; - let (lefts, rights) = partition(input); - assert_eq!(lefts[0], 10); - assert_eq!(lefts[1], 12); - assert_eq!(lefts[2], 14); - assert_eq!(rights[0], 11); - assert_eq!(rights[1], 13); -} + #[test] + fn test_partition_no_lefts() { + let input: ~[Either] = ~[Right(10), Right(11)]; + let (lefts, rights) = partition(input); + assert_eq!(lefts.len(), 0u); + assert_eq!(rights.len(), 2u); + } -#[test] -fn test_partition_no_lefts() { - let input: ~[Either] = ~[Right(10), Right(11)]; - let (lefts, rights) = partition(input); - assert_eq!(lefts.len(), 0u); - assert_eq!(rights.len(), 2u); -} + #[test] + fn test_partition_no_rights() { + let input: ~[Either] = ~[Left(10), Left(11)]; + let (lefts, rights) = partition(input); + assert_eq!(lefts.len(), 2u); + assert_eq!(rights.len(), 0u); + } -#[test] -fn test_partition_no_rights() { - let input: ~[Either] = ~[Left(10), Left(11)]; - let (lefts, rights) = partition(input); - assert_eq!(lefts.len(), 2u); - assert_eq!(rights.len(), 0u); -} + #[test] + fn test_partition_empty() { + let input: ~[Either] = ~[]; + let (lefts, rights) = partition(input); + assert_eq!(lefts.len(), 0u); + assert_eq!(rights.len(), 0u); + } -#[test] -fn test_partition_empty() { - let input: ~[Either] = ~[]; - let (lefts, rights) = partition(input); - assert_eq!(lefts.len(), 0u); - assert_eq!(rights.len(), 0u); } diff --git a/src/libstd/local_data.rs b/src/libstd/local_data.rs index 537289c8dd6c2..c2a60e1c0e9c0 100644 --- a/src/libstd/local_data.rs +++ b/src/libstd/local_data.rs @@ -112,14 +112,14 @@ fn test_tls_multitask() { // TLS shouldn't carry over. assert!(get(my_key, |k| k.map(|&k| *k)).is_none()); set(my_key, @~"child data"); - assert!(*(get(my_key, |k| k.map(|&k| *k)).get()) == + assert!(*(get(my_key, |k| k.map(|&k| *k)).unwrap()) == ~"child data"); // should be cleaned up for us } // Must work multiple times - assert!(*(get(my_key, |k| k.map(|&k| *k)).get()) == ~"parent data"); - assert!(*(get(my_key, |k| k.map(|&k| *k)).get()) == ~"parent data"); - assert!(*(get(my_key, |k| k.map(|&k| *k)).get()) == ~"parent data"); + assert!(*(get(my_key, |k| k.map(|&k| *k)).unwrap()) == ~"parent data"); + assert!(*(get(my_key, |k| k.map(|&k| *k)).unwrap()) == ~"parent data"); + assert!(*(get(my_key, |k| k.map(|&k| *k)).unwrap()) == ~"parent data"); } #[test] @@ -127,14 +127,14 @@ fn test_tls_overwrite() { static my_key: Key<@~str> = &Key; set(my_key, @~"first data"); set(my_key, @~"next data"); // Shouldn't leak. - assert!(*(get(my_key, |k| k.map(|&k| *k)).get()) == ~"next data"); + assert!(*(get(my_key, |k| k.map(|&k| *k)).unwrap()) == ~"next data"); } #[test] fn test_tls_pop() { static my_key: Key<@~str> = &Key; set(my_key, @~"weasel"); - assert!(*(pop(my_key).get()) == ~"weasel"); + assert!(*(pop(my_key).unwrap()) == ~"weasel"); // Pop must remove the data from the map. assert!(pop(my_key).is_none()); } @@ -155,7 +155,7 @@ fn test_tls_modify() { None => fail!("missing value") } }); - assert!(*(pop(my_key).get()) == ~"next data"); + assert!(*(pop(my_key).unwrap()) == ~"next data"); } #[test] diff --git a/src/libstd/num/strconv.rs b/src/libstd/num/strconv.rs index 722af828d5c11..7ab3c81b61f7a 100644 --- a/src/libstd/num/strconv.rs +++ b/src/libstd/num/strconv.rs @@ -726,4 +726,4 @@ mod bench { float::to_str(rng.gen()); } } -} \ No newline at end of file +} diff --git a/src/libstd/option.rs b/src/libstd/option.rs index 417251d3740e6..3a4a9220ee16c 100644 --- a/src/libstd/option.rs +++ b/src/libstd/option.rs @@ -47,7 +47,8 @@ use ops::Add; use util; use num::Zero; use iterator::Iterator; -use str::StrSlice; +use str::{StrSlice, OwnedStr}; +use to_str::ToStr; use clone::DeepClone; /// The option type @@ -85,18 +86,33 @@ impl Ord for Option { } } -impl> Add, Option> for Option { +impl> Add, Option> for Option { #[inline] fn add(&self, other: &Option) -> Option { match (&*self, &*other) { (&None, &None) => None, - (_, &None) => (*self).clone(), - (&None, _) => (*other).clone(), + (_, &None) => None, + (&None, _) => None, (&Some(ref lhs), &Some(ref rhs)) => Some(*lhs + *rhs) } } } +// FIXME: #8242 implementing manually because deriving doesn't work for some reason +impl ToStr for Option { + fn to_str(&self) -> ~str { + match *self { + Some(ref x) => { + let mut s = ~"Some("; + s.push_str(x.to_str()); + s.push_str(")"); + s + } + None => ~"None" + } + } +} + impl Option { /// Return an iterator over the possibly contained value #[inline] @@ -148,8 +164,7 @@ impl Option { /// Update an optional value by optionally running its content by reference /// through a function that returns an option. #[inline] - pub fn chain_ref<'a, U>(&'a self, f: &fn(x: &'a T) -> Option) - -> Option { + pub fn chain_ref<'a, U>(&'a self, f: &fn(x: &'a T) -> Option) -> Option { match *self { Some(ref x) => f(x), None => None @@ -159,8 +174,7 @@ impl Option { /// Update an optional value by optionally running its content by mut reference /// through a function that returns an option. #[inline] - pub fn chain_mut_ref<'a, U>(&'a mut self, f: &fn(x: &'a mut T) -> Option) - -> Option { + pub fn chain_mut_ref<'a, U>(&'a mut self, f: &fn(x: &'a mut T) -> Option) -> Option { match *self { Some(ref mut x) => f(x), None => None @@ -256,132 +270,105 @@ impl Option { } } - /** - Gets an immutable reference to the value inside an option. - - # Failure - - Fails if the value equals `None` - - # Safety note - - In general, because this function may fail, its use is discouraged - (calling `get` on `None` is akin to dereferencing a null pointer). - Instead, prefer to use pattern matching and handle the `None` - case explicitly. - */ + /// Gets an immutable reference to the value inside an option. + /// + /// # Failure + /// + /// Fails if the value equals `None` + /// + /// # Safety note + /// + /// In general, because this function may fail, its use is discouraged + /// (calling `get` on `None` is akin to dereferencing a null pointer). + /// Instead, prefer to use pattern matching and handle the `None` + /// case explicitly. #[inline] pub fn get_ref<'a>(&'a self) -> &'a T { match *self { - Some(ref x) => x, - None => fail!("option::get_ref `None`"), + Some(ref x) => x, + None => fail!("called `Option::get_ref()` on a `None` value"), } } - /** - Gets a mutable reference to the value inside an option. - - # Failure - - Fails if the value equals `None` - - # Safety note - - In general, because this function may fail, its use is discouraged - (calling `get` on `None` is akin to dereferencing a null pointer). - Instead, prefer to use pattern matching and handle the `None` - case explicitly. - */ + /// Gets a mutable reference to the value inside an option. + /// + /// # Failure + /// + /// Fails if the value equals `None` + /// + /// # Safety note + /// + /// In general, because this function may fail, its use is discouraged + /// (calling `get` on `None` is akin to dereferencing a null pointer). + /// Instead, prefer to use pattern matching and handle the `None` + /// case explicitly. #[inline] pub fn get_mut_ref<'a>(&'a mut self) -> &'a mut T { match *self { - Some(ref mut x) => x, - None => fail!("option::get_mut_ref `None`"), + Some(ref mut x) => x, + None => fail!("called `Option::get_mut_ref()` on a `None` value"), } } + /// Moves a value out of an option type and returns it. + /// + /// Useful primarily for getting strings, vectors and unique pointers out + /// of option types without copying them. + /// + /// # Failure + /// + /// Fails if the 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. #[inline] pub fn unwrap(self) -> T { - /*! - Moves a value out of an option type and returns it. - - Useful primarily for getting strings, vectors and unique pointers out - of option types without copying them. - - # Failure - - Fails if the 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. - */ match self { - Some(x) => x, - None => fail!("option::unwrap `None`"), + Some(x) => x, + None => fail!("called `Option::unwrap()` on a `None` value"), } } - /** - * The option dance. Moves a value out of an option type and returns it, - * replacing the original with `None`. - * - * # Failure - * - * Fails if the value equals `None`. - */ + /// The option dance. Moves a value out of an option type and returns it, + /// replacing the original with `None`. + /// + /// # Failure + /// + /// Fails if the value equals `None`. #[inline] pub fn take_unwrap(&mut self) -> T { - if self.is_none() { fail!("option::take_unwrap `None`") } + if self.is_none() { + fail!("called `Option::take_unwrap()` on a `None` value") + } self.take().unwrap() } - /** - * Gets the value out of an option, printing a specified message on - * failure - * - * # Failure - * - * Fails if the value equals `None` - */ + /// Gets the value out of an option, printing a specified message on + /// failure + /// + /// # Failure + /// + /// Fails if the value equals `None` #[inline] pub fn expect(self, reason: &str) -> T { match self { - Some(val) => val, - None => fail!(reason.to_owned()), + Some(val) => val, + None => fail!(reason.to_owned()), } } - /** - Gets the value out of an option - - # Failure - - Fails if the value equals `None` - - # Safety note - - In general, because this function may fail, its use is discouraged - (calling `get` on `None` is akin to dereferencing a null pointer). - Instead, prefer to use pattern matching and handle the `None` - case explicitly. - */ + /// Returns the contained value or a default #[inline] - pub fn get(self) -> T { + pub fn unwrap_or_default(self, def: T) -> T { match self { - Some(x) => return x, - None => fail!("option::get `None`") + Some(x) => x, + None => def } } - /// Returns the contained value or a default - #[inline] - pub fn get_or_default(self, def: T) -> T { - match self { Some(x) => x, None => def } - } - /// Applies a function zero or more times until the result is `None`. #[inline] pub fn while_some(self, blk: &fn(v: T) -> Option) { @@ -395,12 +382,21 @@ impl Option { impl Option { /// Returns the contained value or zero (for this type) #[inline] - pub fn get_or_zero(self) -> T { + pub fn unwrap_or_zero(self) -> T { match self { Some(x) => x, None => Zero::zero() } } + + /// Returns self or `Some(zero)` (for this type) + #[inline] + pub fn or_zero(self) -> Option { + match self { + None => Some(Zero::zero()), + x => x + } + } } impl Zero for Option { @@ -450,7 +446,7 @@ mod tests { use util; #[test] - fn test_unwrap_ptr() { + fn test_get_ptr() { unsafe { let x = ~0; let addr_x: *int = ::cast::transmute(&*x); @@ -462,7 +458,7 @@ mod tests { } #[test] - fn test_unwrap_str() { + fn test_get_str() { let x = ~"test"; let addr_x = x.as_imm_buf(|buf, _len| buf); let opt = Some(x); @@ -472,7 +468,7 @@ mod tests { } #[test] - fn test_unwrap_resource() { + fn test_get_resource() { struct R { i: @mut int, } @@ -530,18 +526,18 @@ mod tests { } #[test] - fn test_get_or_zero() { + fn test_unwrap_or_zero() { let some_stuff = Some(42); - assert_eq!(some_stuff.get_or_zero(), 42); + assert_eq!(some_stuff.unwrap_or_zero(), 42); let no_stuff: Option = None; - assert_eq!(no_stuff.get_or_zero(), 0); + assert_eq!(no_stuff.unwrap_or_zero(), 0); } #[test] fn test_filtered() { let some_stuff = Some(42); let modified_stuff = some_stuff.filtered(|&x| {x < 10}); - assert_eq!(some_stuff.get(), 42); + assert_eq!(some_stuff.unwrap(), 42); assert!(modified_stuff.is_none()); } diff --git a/src/libstd/os.rs b/src/libstd/os.rs index 2d0b7d4f849d7..b0e1f35b4a018 100644 --- a/src/libstd/os.rs +++ b/src/libstd/os.rs @@ -571,7 +571,7 @@ pub fn tmpdir() -> Path { #[cfg(unix)] fn lookup() -> Path { - getenv_nonempty("TMPDIR").get_or_default(Path("/tmp")) + getenv_nonempty("TMPDIR").unwrap_or_default(Path("/tmp")) } #[cfg(windows)] @@ -579,7 +579,7 @@ pub fn tmpdir() -> Path { getenv_nonempty("TMP").or( getenv_nonempty("TEMP").or( getenv_nonempty("USERPROFILE").or( - getenv_nonempty("WINDIR")))).get_or_default(Path("C:\\Windows")) + getenv_nonempty("WINDIR")))).unwrap_or_default(Path("C:\\Windows")) } } @@ -1782,7 +1782,7 @@ mod tests { fn test_self_exe_path() { let path = os::self_exe_path(); assert!(path.is_some()); - let path = path.get(); + let path = path.unwrap(); debug!(path.clone()); // Hard to test this function diff --git a/src/libstd/rand.rs b/src/libstd/rand.rs index b7d72c11ff7a8..4ef524d77152b 100644 --- a/src/libstd/rand.rs +++ b/src/libstd/rand.rs @@ -533,7 +533,7 @@ impl RngUtil for R { /// Choose an item randomly, failing if values is empty fn choose(&mut self, values: &[T]) -> T { - self.choose_option(values).get() + self.choose_option(values).unwrap() } /// Choose Some(item) randomly, returning None if values is empty @@ -549,7 +549,7 @@ impl RngUtil for R { * the weights is 0 */ fn choose_weighted(&mut self, v: &[Weighted]) -> T { - self.choose_weighted_option(v).get() + self.choose_weighted_option(v).unwrap() } /** diff --git a/src/libstd/result.rs b/src/libstd/result.rs index 7a578465841bb..181590e3929c5 100644 --- a/src/libstd/result.rs +++ b/src/libstd/result.rs @@ -20,23 +20,27 @@ use option::{None, Option, Some}; use vec; use vec::{OwnedVector, ImmutableVector}; use container::Container; - -/// The result type +use to_str::ToStr; +use str::StrSlice; + +/// `Result` is a type that represents either success (`Ok`) or failure (`Err`). +/// +/// In order to provide informative error messages, `E` is reqired to implement `ToStr`. +/// It is further recommended for `E` to be a descriptive error type, eg a `enum` for +/// all possible errors cases. #[deriving(Clone, Eq)] -pub enum Result { +pub enum Result { /// Contains the successful result value Ok(T), /// Contains the error value - Err(U) + Err(E) } -impl Result { - /** - * Convert to the `either` type - * - * `Ok` result variants are converted to `either::Right` variants, `Err` - * result variants are converted to `either::Left`. - */ +impl Result { + /// Convert to the `either` type + /// + /// `Ok` result variants are converted to `either::Right` variants, `Err` + /// result variants are converted to `either::Left`. #[inline] pub fn to_either(self)-> either::Either{ match self { @@ -45,18 +49,16 @@ impl Result { } } - /** - * Get a reference to the value out of a successful result - * - * # Failure - * - * If the result is an error - */ + /// Get a reference to the value out of a successful result + /// + /// # Failure + /// + /// If the result is an error #[inline] pub fn get_ref<'a>(&'a self) -> &'a T { match *self { Ok(ref t) => t, - Err(ref e) => fail!("get_ref called on `Err` result: %?", *e), + Err(ref e) => fail!("called `Result::get_ref()` on `Err` value: %s", e.to_str()), } } @@ -75,20 +77,18 @@ impl Result { !self.is_ok() } - /** - * Call a method based on a previous result - * - * If `self` is `Ok` then the value is extracted and passed to `op` - * whereupon `op`s result is returned. if `self` is `Err` then it is - * immediately returned. This function can be used to compose the results - * of two functions. - * - * Example: - * - * do read_file(file).iter |buf| { - * print_buf(buf) - * } - */ + /// Call a method based on a previous result + /// + /// If `self` is `Ok` then the value is extracted and passed to `op` + /// whereupon `op`s result is returned. if `self` is `Err` then it is + /// immediately returned. This function can be used to compose the results + /// of two functions. + /// + /// Example: + /// + /// do read_file(file).iter |buf| { + /// print_buf(buf) + /// } #[inline] pub fn iter(&self, f: &fn(&T)) { match *self { @@ -97,14 +97,12 @@ impl Result { } } - /** - * Call a method based on a previous result - * - * If `self` is `Err` then the value is extracted and passed to `op` - * whereupon `op`s result is returned. if `self` is `Ok` then it is - * immediately returned. This function can be used to pass through a - * successful result while handling an error. - */ + /// Call a method based on a previous result + /// + /// If `self` is `Err` then the value is extracted and passed to `op` + /// whereupon `op`s result is returned. if `self` is `Ok` then it is + /// immediately returned. This function can be used to pass through a + /// successful result while handling an error. #[inline] pub fn iter_err(&self, f: &fn(&E)) { match *self { @@ -113,38 +111,56 @@ impl Result { } } - /// Unwraps a result, assuming it is an `Ok(T)` + /// Unwraps a result, yielding the content of an `Ok`. + /// Fails if the value is a `Err` with an error message derived + /// from `E`'s `ToStr` implementation. #[inline] pub fn unwrap(self) -> T { match self { Ok(t) => t, - Err(_) => fail!("unwrap called on an `Err` result"), + Err(e) => fail!("called `Result::unwrap()` on `Err` value: %s", e.to_str()), } } - /// Unwraps a result, assuming it is an `Err(U)` + /// Unwraps a result, yielding the content of an `Err`. + /// Fails if the value is a `Ok`. #[inline] pub fn unwrap_err(self) -> E { + self.expect_err("called `Result::unwrap_err()` on `Ok` value") + } + + /// Unwraps a result, yielding the content of an `Ok`. + /// Fails if the value is a `Err` with a custom failure message. + #[inline] + pub fn expect(self, reason: &str) -> T { + match self { + Ok(t) => t, + Err(_) => fail!(reason.to_owned()), + } + } + + /// Unwraps a result, yielding the content of an `Err` + /// Fails if the value is a `Ok` with a custom failure message. + #[inline] + pub fn expect_err(self, reason: &str) -> E { match self { Err(e) => e, - Ok(_) => fail!("unwrap called on an `Ok` result"), + Ok(_) => fail!(reason.to_owned()), } } - /** - * Call a method based on a previous result - * - * If `self` is `Ok` then the value is extracted and passed to `op` - * whereupon `op`s result is returned. if `self` is `Err` then it is - * immediately returned. This function can be used to compose the results - * of two functions. - * - * Example: - * - * let res = do read_file(file) |buf| { - * Ok(parse_bytes(buf)) - * }; - */ + /// Call a method based on a previous result + /// + /// If `self` is `Ok` then the value is extracted and passed to `op` + /// whereupon `op`s result is returned. if `self` is `Err` then it is + /// immediately returned. This function can be used to compose the results + /// of two functions. + /// + /// Example: + /// + /// let res = do read_file(file) |buf| { + /// Ok(parse_bytes(buf)) + /// }; #[inline] pub fn chain(self, op: &fn(T) -> Result) -> Result { match self { @@ -153,14 +169,12 @@ impl Result { } } - /** - * Call a function based on a previous result - * - * If `self` is `Err` then the value is extracted and passed to `op` - * whereupon `op`s result is returned. if `self` is `Ok` then it is - * immediately returned. This function can be used to pass through a - * successful result while handling an error. - */ + /// Call a function based on a previous result + /// + /// If `self` is `Err` then the value is extracted and passed to `op` + /// whereupon `op`s result is returned. if `self` is `Ok` then it is + /// immediately returned. This function can be used to pass through a + /// successful result while handling an error. #[inline] pub fn chain_err(self, op: &fn(E) -> Result) -> Result { match self { @@ -170,32 +184,15 @@ impl Result { } } -impl Result { - /** - * Get the value out of a successful result - * - * # Failure - * - * If the result is an error - */ +impl Result { + /// Call a method based on a previous result + /// + /// If `self` is `Err` then the value is extracted and passed to `op` + /// whereupon `op`s result is wrapped in an `Err` and returned. if `self` is + /// `Ok` then it is immediately returned. This function can be used to pass + /// through a successful result while handling an error. #[inline] - pub fn get(&self) -> T { - match *self { - Ok(ref t) => t.clone(), - Err(ref e) => fail!("get called on `Err` result: %?", *e), - } - } - - /** - * Call a method based on a previous result - * - * If `self` is `Err` then the value is extracted and passed to `op` - * whereupon `op`s result is wrapped in an `Err` and returned. if `self` is - * `Ok` then it is immediately returned. This function can be used to pass - * through a successful result while handling an error. - */ - #[inline] - pub fn map_err(&self, op: &fn(&E) -> F) -> Result { + pub fn map_err(&self, op: &fn(&E) -> F) -> Result { match *self { Ok(ref t) => Ok(t.clone()), Err(ref e) => Err(op(e)) @@ -203,62 +200,57 @@ impl Result { } } -impl Result { - /** - * Get the value out of an error result - * - * # Failure - * - * If the result is not an error - */ +impl Result { + /// Call a method based on a previous result + /// + /// If `self` is `Ok` then the value is extracted and passed to `op` + /// whereupon `op`s result is wrapped in `Ok` and returned. if `self` is + /// `Err` then it is immediately returned. This function can be used to + /// compose the results of two functions. + /// + /// Example: + /// + /// let res = do read_file(file).map |buf| { + /// parse_bytes(buf) + /// }; #[inline] - pub fn get_err(&self) -> E { + pub fn map(&self, op: &fn(&T) -> U) -> Result { match *self { - Err(ref e) => e.clone(), - Ok(_) => fail!("get_err called on `Ok` result") + Ok(ref t) => Ok(op(t)), + Err(ref e) => Err(e.clone()) } } +} - /** - * Call a method based on a previous result - * - * If `self` is `Ok` then the value is extracted and passed to `op` - * whereupon `op`s result is wrapped in `Ok` and returned. if `self` is - * `Err` then it is immediately returned. This function can be used to - * compose the results of two functions. - * - * Example: - * - * let res = do read_file(file).map |buf| { - * parse_bytes(buf) - * }; - */ - #[inline] - pub fn map(&self, op: &fn(&T) -> U) -> Result { - match *self { - Ok(ref t) => Ok(op(t)), - Err(ref e) => Err(e.clone()) +#[inline] +#[allow(missing_doc)] +pub fn map_opt(o_t: &Option, + op: &fn(&T) -> Result) -> Result,U> { + match *o_t { + None => Ok(None), + Some(ref t) => match op(t) { + Ok(v) => Ok(Some(v)), + Err(e) => Err(e) } } } -/** - * Maps each element in the vector `ts` using the operation `op`. Should an - * error occur, no further mappings are performed and the error is returned. - * Should no error occur, a vector containing the result of each map is - * returned. - * - * Here is an example which increments every integer in a vector, - * checking for overflow: - * - * fn inc_conditionally(x: uint) -> result { - * if x == uint::max_value { return Err("overflow"); } - * else { return Ok(x+1u); } - * } - * map(~[1u, 2u, 3u], inc_conditionally).chain {|incd| - * assert!(incd == ~[2u, 3u, 4u]); - * } - */ +// FIXME: #8228 Replaceable by an external iterator? +/// Maps each element in the vector `ts` using the operation `op`. Should an +/// error occur, no further mappings are performed and the error is returned. +/// Should no error occur, a vector containing the result of each map is +/// returned. +/// +/// Here is an example which increments every integer in a vector, +/// checking for overflow: +/// +/// fn inc_conditionally(x: uint) -> result { +/// if x == uint::max_value { return Err("overflow"); } +/// else { return Ok(x+1u); } +/// } +/// map(~[1u, 2u, 3u], inc_conditionally).chain {|incd| +/// assert!(incd == ~[2u, 3u, 4u]); +/// } #[inline] pub fn map_vec(ts: &[T], op: &fn(&T) -> Result) -> Result<~[V],U> { @@ -272,36 +264,17 @@ pub fn map_vec(ts: &[T], op: &fn(&T) -> Result) return Ok(vs); } +// FIXME: #8228 Replaceable by an external iterator? +/// Same as map, but it operates over two parallel vectors. +/// +/// A precondition is used here to ensure that the vectors are the same +/// length. While we do not often use preconditions in the standard +/// library, a precondition is used here because result::t is generally +/// used in 'careful' code contexts where it is both appropriate and easy +/// to accommodate an error like the vectors being of different lengths. #[inline] -#[allow(missing_doc)] -pub fn map_opt( - o_t: &Option, - op: &fn(&T) -> Result) - -> Result,U> { - match *o_t { - None => Ok(None), - Some(ref t) => match op(t) { - Ok(v) => Ok(Some(v)), - Err(e) => Err(e) - } - } -} - -/** - * Same as map, but it operates over two parallel vectors. - * - * A precondition is used here to ensure that the vectors are the same - * length. While we do not often use preconditions in the standard - * library, a precondition is used here because result::t is generally - * used in 'careful' code contexts where it is both appropriate and easy - * to accommodate an error like the vectors being of different lengths. - */ -#[inline] -pub fn map_vec2(ss: &[S], ts: &[T], - op: &fn(&S,&T) -> Result) -> Result<~[V],U> { - +pub fn map_vec2(ss: &[S], ts: &[T], + op: &fn(&S,&T) -> Result) -> Result<~[V],U> { assert!(vec::same_length(ss, ts)); let n = ts.len(); let mut vs = vec::with_capacity(n); @@ -316,15 +289,13 @@ pub fn map_vec2(ss: &[S], ts: &[T], return Ok(vs); } -/** - * Applies op to the pairwise elements from `ss` and `ts`, aborting on - * error. This could be implemented using `map_zip()` but it is more efficient - * on its own as no result vector is built. - */ +// FIXME: #8228 Replaceable by an external iterator? +/// Applies op to the pairwise elements from `ss` and `ts`, aborting on +/// error. This could be implemented using `map_zip()` but it is more efficient +/// on its own as no result vector is built. #[inline] -pub fn iter_vec2(ss: &[S], ts: &[T], - op: &fn(&S,&T) -> Result<(),U>) -> Result<(),U> { - +pub fn iter_vec2(ss: &[S], ts: &[T], + op: &fn(&S,&T) -> Result<(),U>) -> Result<(),U> { assert!(vec::same_length(ss, ts)); let n = ts.len(); let mut i = 0u; @@ -353,12 +324,12 @@ mod tests { #[test] pub fn chain_success() { - assert_eq!(op1().chain(op2).get(), 667u); + assert_eq!(op1().chain(op2).unwrap(), 667u); } #[test] pub fn chain_failure() { - assert_eq!(op3().chain( op2).get_err(), ~"sadface"); + assert_eq!(op3().chain( op2).unwrap_err(), ~"sadface"); } #[test] diff --git a/src/libstd/rt/io/flate.rs b/src/libstd/rt/io/flate.rs index e57b80658eef2..bea62f7e28c19 100644 --- a/src/libstd/rt/io/flate.rs +++ b/src/libstd/rt/io/flate.rs @@ -115,7 +115,7 @@ mod test { let mem_reader = MemReader::new(buf); let mut inflate_reader = InflateReader::new(mem_reader); let mut out_bytes = [0, .. 100]; - let bytes_read = inflate_reader.read(out_bytes).get(); + let bytes_read = inflate_reader.read(out_bytes).unwrap(); assert_eq!(bytes_read, in_bytes.len()); let out_msg = str::from_bytes(out_bytes); assert!(in_msg == out_msg); diff --git a/src/libstd/rt/io/mod.rs b/src/libstd/rt/io/mod.rs index 838c2d86c9fa2..c980dc9d73efd 100644 --- a/src/libstd/rt/io/mod.rs +++ b/src/libstd/rt/io/mod.rs @@ -243,6 +243,8 @@ Out of scope */ use prelude::*; +use to_str::ToStr; +use str::{StrSlice, OwnedStr}; // Reexports pub use self::stdio::stdin; @@ -334,6 +336,20 @@ pub struct IoError { detail: Option<~str> } +// FIXME: #8242 implementing manually because deriving doesn't work for some reason +impl ToStr for IoError { + fn to_str(&self) -> ~str { + let mut s = ~"IoError { kind: "; + s.push_str(self.kind.to_str()); + s.push_str(", desc: "); + s.push_str(self.desc); + s.push_str(", detail: "); + s.push_str(self.detail.to_str()); + s.push_str(" }"); + s + } +} + #[deriving(Eq)] pub enum IoErrorKind { PreviousIoError, @@ -348,6 +364,24 @@ pub enum IoErrorKind { BrokenPipe } +// FIXME: #8242 implementing manually because deriving doesn't work for some reason +impl ToStr for IoErrorKind { + fn to_str(&self) -> ~str { + match *self { + PreviousIoError => ~"PreviousIoError", + OtherIoError => ~"OtherIoError", + EndOfFile => ~"EndOfFile", + FileNotFound => ~"FileNotFound", + PermissionDenied => ~"PermissionDenied", + ConnectionFailed => ~"ConnectionFailed", + Closed => ~"Closed", + ConnectionRefused => ~"ConnectionRefused", + ConnectionReset => ~"ConnectionReset", + BrokenPipe => ~"BrokenPipe" + } + } +} + // XXX: Can't put doc comments on macros // Raised by `I/O` operations on error. condition! { @@ -505,4 +539,4 @@ pub fn placeholder_error() -> IoError { desc: "Placeholder error. You shouldn't be seeing this", detail: None } -} \ No newline at end of file +} diff --git a/src/libstd/rt/mod.rs b/src/libstd/rt/mod.rs index 33e83fd904041..760ca8a9adadc 100644 --- a/src/libstd/rt/mod.rs +++ b/src/libstd/rt/mod.rs @@ -365,7 +365,7 @@ fn run_(main: ~fn(), use_main_sched: bool) -> int { rtdebug!("about to create the main scheduler task"); - let mut main_sched = main_sched.get(); + let mut main_sched = main_sched.unwrap(); let home = Sched(main_sched.make_handle()); let mut main_task = ~Task::new_root_homed(&mut main_sched.stack_pool, diff --git a/src/libstd/rt/task.rs b/src/libstd/rt/task.rs index cb949edd7bb4a..4c5e4bdc3c1d9 100644 --- a/src/libstd/rt/task.rs +++ b/src/libstd/rt/task.rs @@ -465,10 +465,10 @@ mod test { do run_in_newsched_task() { static key: local_data::Key<@~str> = &local_data::Key; local_data::set(key, @~"data"); - assert!(*local_data::get(key, |k| k.map(|&k| *k)).get() == ~"data"); + assert!(*local_data::get(key, |k| k.map(|&k| *k)).unwrap() == ~"data"); static key2: local_data::Key<@~str> = &local_data::Key; local_data::set(key2, @~"data"); - assert!(*local_data::get(key2, |k| k.map(|&k| *k)).get() == ~"data"); + assert!(*local_data::get(key2, |k| k.map(|&k| *k)).unwrap() == ~"data"); } } diff --git a/src/libstd/rt/test.rs b/src/libstd/rt/test.rs index 2427da01a0c1c..8b5215ae9694a 100644 --- a/src/libstd/rt/test.rs +++ b/src/libstd/rt/test.rs @@ -154,7 +154,7 @@ pub fn run_in_mt_newsched_task(f: ~fn()) { do run_in_bare_thread { let nthreads = match os::getenv("RUST_RT_TEST_THREADS") { - Some(nstr) => FromStr::from_str(nstr).get(), + Some(nstr) => FromStr::from_str(nstr).unwrap(), None => { // Using more threads than cores in test code // to force the OS to preempt them frequently. @@ -362,7 +362,7 @@ pub fn stress_factor() -> uint { use os::getenv; match getenv("RUST_RT_STRESS") { - Some(val) => uint::from_str(val).get(), + Some(val) => uint::from_str(val).unwrap(), None => 1 } } diff --git a/src/libstd/rt/util.rs b/src/libstd/rt/util.rs index a1169954688b0..40e5c8d4bf1a0 100644 --- a/src/libstd/rt/util.rs +++ b/src/libstd/rt/util.rs @@ -31,7 +31,7 @@ pub fn num_cpus() -> uint { /// either `RUST_THREADS` or `num_cpus`. pub fn default_sched_threads() -> uint { match os::getenv("RUST_THREADS") { - Some(nstr) => FromStr::from_str(nstr).get(), + Some(nstr) => FromStr::from_str(nstr).unwrap(), None => num_cpus() } } @@ -118,4 +118,4 @@ pub fn get_exit_status() -> int { extern { fn rust_get_exit_status_newrt() -> libc::uintptr_t; } -} \ No newline at end of file +} diff --git a/src/libstd/rt/uv/net.rs b/src/libstd/rt/uv/net.rs index 67d3bbef8a9c6..fd3042899f6bc 100644 --- a/src/libstd/rt/uv/net.rs +++ b/src/libstd/rt/uv/net.rs @@ -108,7 +108,7 @@ fn uv_socket_addr_as_socket_addr(addr: UvSocketAddr, f: &fn(SocketAddr) -> T) "" => ~[], // IPv4-Mapped/Compatible IPv6 Address? s if s.find('.').is_some() => { - let i = s.rfind(':').get_or_default(-1); + let i = s.rfind(':').unwrap_or_default(-1); let b = s.slice(i + 1, s.len()); // the ipv4 part @@ -614,7 +614,7 @@ mod test { do tcp_watcher.connect(addr) |stream_watcher, status| { rtdebug!("tcp_watcher.connect!"); assert!(status.is_some()); - assert_eq!(status.get().name(), ~"ECONNREFUSED"); + assert_eq!(status.unwrap().name(), ~"ECONNREFUSED"); stream_watcher.close(||()); } loop_.run(); @@ -632,7 +632,7 @@ mod test { do tcp_watcher.connect(addr) |stream_watcher, status| { rtdebug!("tcp_watcher.connect!"); assert!(status.is_some()); - assert_eq!(status.get().name(), ~"ECONNREFUSED"); + assert_eq!(status.unwrap().name(), ~"ECONNREFUSED"); stream_watcher.close(||()); } loop_.run(); diff --git a/src/libstd/rt/uv/uvio.rs b/src/libstd/rt/uv/uvio.rs index 85cf660a5f1aa..70a397199ab7c 100644 --- a/src/libstd/rt/uv/uvio.rs +++ b/src/libstd/rt/uv/uvio.rs @@ -278,7 +278,7 @@ impl IoFactory for UvIoFactory { rtdebug!("status is some"); let task_cell = Cell::new(task_cell.take()); do stream_watcher.close { - let res = Err(uv_error_to_io_error(status.get())); + let res = Err(uv_error_to_io_error(status.unwrap())); unsafe { (*result_cell_ptr).put_back(res); } let scheduler = Local::take::(); scheduler.resume_blocked_task_immediately(task_cell.take()); diff --git a/src/libstd/str.rs b/src/libstd/str.rs index 1a913fb4e996a..95a411a3f9673 100644 --- a/src/libstd/str.rs +++ b/src/libstd/str.rs @@ -58,7 +58,7 @@ pub fn from_bytes(vv: &[u8]) -> ~str { use str::not_utf8::cond; if !is_utf8(vv) { - let first_bad_byte = *vv.iter().find_(|&b| !is_utf8([*b])).get(); + let first_bad_byte = *vv.iter().find_(|&b| !is_utf8([*b])).unwrap(); cond.raise(fmt!("from_bytes: input is not UTF-8; first bad byte is %u", first_bad_byte as uint)) } else { @@ -75,7 +75,7 @@ pub fn from_bytes_owned(vv: ~[u8]) -> ~str { use str::not_utf8::cond; if !is_utf8(vv) { - let first_bad_byte = *vv.iter().find_(|&b| !is_utf8([*b])).get(); + let first_bad_byte = *vv.iter().find_(|&b| !is_utf8([*b])).unwrap(); cond.raise(fmt!("from_bytes: input is not UTF-8; first bad byte is %u", first_bad_byte as uint)) } else { diff --git a/src/libstd/task/mod.rs b/src/libstd/task/mod.rs index f7a943f8d2fdf..225a4b8cfd294 100644 --- a/src/libstd/task/mod.rs +++ b/src/libstd/task/mod.rs @@ -926,7 +926,7 @@ fn test_named_task() { t.name(~"ada lovelace"); do t.spawn { do with_task_name |name| { - assert!(name.get() == "ada lovelace"); + assert!(name.unwrap() == "ada lovelace"); } } } diff --git a/src/libstd/vec.rs b/src/libstd/vec.rs index f037aa2b7e789..4d4437cc963ea 100644 --- a/src/libstd/vec.rs +++ b/src/libstd/vec.rs @@ -195,10 +195,8 @@ pub fn build(builder: &fn(push: &fn(v: A))) -> ~[A] { * onto the vector being constructed. */ #[inline] -pub fn build_sized_opt(size: Option, - builder: &fn(push: &fn(v: A))) - -> ~[A] { - build_sized(size.get_or_default(4), builder) +pub fn build_sized_opt(size: Option, builder: &fn(push: &fn(v: A))) -> ~[A] { + build_sized(size.unwrap_or_default(4), builder) } /// An iterator over the slices of a vector separated by elements that diff --git a/src/libsyntax/abi.rs b/src/libsyntax/abi.rs index e6bbd45dae770..883020e637a1b 100644 --- a/src/libsyntax/abi.rs +++ b/src/libsyntax/abi.rs @@ -280,13 +280,13 @@ impl ToStr for AbiSet { #[test] fn lookup_Rust() { let abi = lookup("Rust"); - assert!(abi.is_some() && abi.get().data().name == "Rust"); + assert!(abi.is_some() && abi.unwrap().data().name == "Rust"); } #[test] fn lookup_cdecl() { let abi = lookup("cdecl"); - assert!(abi.is_some() && abi.get().data().name == "cdecl"); + assert!(abi.is_some() && abi.unwrap().data().name == "cdecl"); } #[test] diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index cf7a1e51798ac..435be3c71af6f 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -24,7 +24,7 @@ use extra::serialize::{Encodable, Decodable, Encoder, Decoder}; // table) and a SyntaxContext to track renaming and // macro expansion per Flatt et al., "Macros // That Work Together" -#[deriving(Clone, Eq, IterBytes)] +#[deriving(Clone, Eq, IterBytes, ToStr)] pub struct ident { name: Name, ctxt: SyntaxContext } /// Construct an identifier with the given name and an empty context: @@ -121,7 +121,7 @@ pub type CrateNum = int; pub type NodeId = int; -#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable, IterBytes, ToStr)] pub struct def_id { crate: CrateNum, node: NodeId, diff --git a/src/libsyntax/attr.rs b/src/libsyntax/attr.rs index d1ddebfc347af..d39cb2f507ca9 100644 --- a/src/libsyntax/attr.rs +++ b/src/libsyntax/attr.rs @@ -114,7 +114,7 @@ impl AttributeMethods for Attribute { /// non-sugared doc attributes.) pub fn desugar_doc(&self) -> Attribute { if self.node.is_sugared_doc { - let comment = self.value_str().get(); + let comment = self.value_str().unwrap(); let meta = mk_name_value_item_str(@"doc", strip_doc_comment_decoration(comment).to_managed()); mk_attr(meta) diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs index 1dda2493da20a..6ed5ca3e402a8 100644 --- a/src/libsyntax/ext/base.rs +++ b/src/libsyntax/ext/base.rs @@ -538,20 +538,20 @@ mod test { m.insert (@"def",@16); // FIXME: #4492 (ICE) assert_eq!(m.find(&@"abc"),Some(@15)); // .... assert_eq!(m.find(&@"def"),Some(@16)); - assert_eq!(*(m.find(&@"abc").get()),15); - assert_eq!(*(m.find(&@"def").get()),16); + assert_eq!(*(m.find(&@"abc").unwrap()),15); + assert_eq!(*(m.find(&@"def").unwrap()),16); let n = m.push_frame(); // old bindings are still present: - assert_eq!(*(n.find(&@"abc").get()),15); - assert_eq!(*(n.find(&@"def").get()),16); + assert_eq!(*(n.find(&@"abc").unwrap()),15); + assert_eq!(*(n.find(&@"def").unwrap()),16); n.insert (@"def",@17); // n shows the new binding - assert_eq!(*(n.find(&@"abc").get()),15); - assert_eq!(*(n.find(&@"def").get()),17); + assert_eq!(*(n.find(&@"abc").unwrap()),15); + assert_eq!(*(n.find(&@"def").unwrap()),17); // ... but m still has the old ones // FIXME: #4492: assert_eq!(m.find(&@"abc"),Some(@15)); // FIXME: #4492: assert_eq!(m.find(&@"def"),Some(@16)); - assert_eq!(*(m.find(&@"abc").get()),15); - assert_eq!(*(m.find(&@"def").get()),16); + assert_eq!(*(m.find(&@"abc").unwrap()),15); + assert_eq!(*(m.find(&@"def").unwrap()),16); } } diff --git a/src/libsyntax/ext/deriving/generic.rs b/src/libsyntax/ext/deriving/generic.rs index f5eb57c94b76f..fb1e6bf191384 100644 --- a/src/libsyntax/ext/deriving/generic.rs +++ b/src/libsyntax/ext/deriving/generic.rs @@ -961,7 +961,7 @@ fn create_struct_pattern(cx: @ExtCtxt, let field_pats = do vec::build |push| { for (&pat, &(id, _)) in subpats.iter().zip(ident_expr.iter()) { // id is guaranteed to be Some - push(ast::field_pat { ident: id.get(), pat: pat }) + push(ast::field_pat { ident: id.unwrap(), pat: pat }) } }; cx.pat_struct(span, matching_path, field_pats) diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs index a6c5526b5a9b4..c7020b990bf00 100644 --- a/src/libsyntax/ext/expand.rs +++ b/src/libsyntax/ext/expand.rs @@ -1182,9 +1182,9 @@ mod test { let a2_name = intern("a2"); let renamer = new_ident_renamer(ast::ident{name:a_name,ctxt:empty_ctxt}, a2_name); - let renamed_ast = fun_to_ident_folder(renamer).fold_item(item_ast).get(); + let renamed_ast = fun_to_ident_folder(renamer).fold_item(item_ast).unwrap(); let resolver = new_ident_resolver(); - let resolved_ast = fun_to_ident_folder(resolver).fold_item(renamed_ast).get(); + let resolved_ast = fun_to_ident_folder(resolver).fold_item(renamed_ast).unwrap(); let resolved_as_str = pprust::item_to_str(resolved_ast, get_ident_interner()); assert_eq!(resolved_as_str,~"fn a2() -> int { let b = 13; b }"); diff --git a/src/libsyntax/ext/source_util.rs b/src/libsyntax/ext/source_util.rs index 626a562b92c03..71903b9aa0204 100644 --- a/src/libsyntax/ext/source_util.rs +++ b/src/libsyntax/ext/source_util.rs @@ -31,7 +31,7 @@ pub fn expand_line(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree]) -> base::MacResult { base::check_zero_tts(cx, sp, tts, "line!"); - let topmost = topmost_expn_info(cx.backtrace().get()); + let topmost = topmost_expn_info(cx.backtrace().unwrap()); let loc = cx.codemap().lookup_char_pos(topmost.call_site.lo); base::MRExpr(cx.expr_uint(topmost.call_site, loc.line)) @@ -42,7 +42,7 @@ pub fn expand_col(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree]) -> base::MacResult { base::check_zero_tts(cx, sp, tts, "col!"); - let topmost = topmost_expn_info(cx.backtrace().get()); + let topmost = topmost_expn_info(cx.backtrace().unwrap()); let loc = cx.codemap().lookup_char_pos(topmost.call_site.lo); base::MRExpr(cx.expr_uint(topmost.call_site, loc.col.to_uint())) } @@ -54,7 +54,7 @@ pub fn expand_file(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree]) -> base::MacResult { base::check_zero_tts(cx, sp, tts, "file!"); - let topmost = topmost_expn_info(cx.backtrace().get()); + let topmost = topmost_expn_info(cx.backtrace().unwrap()); let loc = cx.codemap().lookup_char_pos(topmost.call_site.lo); let filename = loc.file.name; base::MRExpr(cx.expr_str(topmost.call_site, filename)) diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index afa2e7a5e42f5..a0932729930e3 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -691,7 +691,7 @@ impl Parser { */ let opt_abis = self.parse_opt_abis(); - let abis = opt_abis.get_or_default(AbiSet::Rust()); + let abis = opt_abis.unwrap_or_default(AbiSet::Rust()); let purity = self.parse_unsafety(); self.expect_keyword(keywords::Fn); let (decl, lifetimes) = self.parse_ty_fn_decl(); @@ -3326,7 +3326,7 @@ impl Parser { let ident = self.parse_ident(); let opt_bounds = self.parse_optional_ty_param_bounds(); // For typarams we don't care about the difference b/w "" and "". - let bounds = opt_bounds.get_or_default(opt_vec::Empty); + let bounds = opt_bounds.unwrap_or_default(opt_vec::Empty); ast::TyParam { ident: ident, id: self.get_id(), bounds: bounds } } @@ -4196,7 +4196,7 @@ impl Parser { self.obsolete(*self.last_span, ObsoleteExternVisibility); } - let abis = opt_abis.get_or_default(AbiSet::C()); + let abis = opt_abis.unwrap_or_default(AbiSet::C()); let (inner, next) = self.parse_inner_attrs_and_next(); let m = self.parse_foreign_mod_items(sort, abis, next); @@ -4463,7 +4463,7 @@ impl Parser { if self.eat_keyword(keywords::Fn) { // EXTERN FUNCTION ITEM - let abis = opt_abis.get_or_default(AbiSet::C()); + let abis = opt_abis.unwrap_or_default(AbiSet::C()); let (ident, item_, extra_attrs) = self.parse_item_fn(extern_fn, abis); return iovi_item(self.mk_item(lo, self.last_span.hi, ident, diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index 174b0f8e4517c..f517179f60366 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -874,7 +874,7 @@ pub fn print_attribute(s: @ps, attr: &ast::Attribute) { hardbreak_if_not_bol(s); maybe_print_comment(s, attr.span.lo); if attr.node.is_sugared_doc { - let comment = attr.value_str().get(); + let comment = attr.value_str().unwrap(); word(s.s, comment); } else { word(s.s, "#["); @@ -1085,7 +1085,7 @@ pub fn print_call_post(s: @ps, } if sugar != ast::NoSugar { nbsp(s); - match blk.get().node { + match blk.unwrap().node { // need to handle closures specifically ast::expr_do_body(e) => { end(s); // we close our head box; closure @@ -1095,7 +1095,7 @@ pub fn print_call_post(s: @ps, } _ => { // not sure if this can happen. - print_expr(s, blk.get()); + print_expr(s, blk.unwrap()); } } } @@ -1323,13 +1323,13 @@ pub fn print_expr(s: @ps, expr: &ast::expr) { 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.get().node { + match body.expr.unwrap().node { ast::expr_block(ref blk) => { print_block_unclosed(s, blk); } _ => { // this is a bare expression - print_expr(s, body.expr.get()); + print_expr(s, body.expr.unwrap()); end(s); // need to close a box } } diff --git a/src/test/bench/core-map.rs b/src/test/bench/core-map.rs index da1c3596ff6c9..cf160ca31c6f1 100644 --- a/src/test/bench/core-map.rs +++ b/src/test/bench/core-map.rs @@ -100,7 +100,7 @@ fn main() { let args = os::args(); let n_keys = { if args.len() == 2 { - uint::from_str(args[1]).get() + uint::from_str(args[1]).unwrap() } else { 1000000 } diff --git a/src/test/bench/core-set.rs b/src/test/bench/core-set.rs index 2c412e2eecd80..4fbe00622aa26 100644 --- a/src/test/bench/core-set.rs +++ b/src/test/bench/core-set.rs @@ -159,7 +159,7 @@ fn main() { let args = os::args(); let num_keys = { if args.len() == 2 { - uint::from_str(args[1]).get() + uint::from_str(args[1]).unwrap() } else { 100 // woefully inadequate for any real measurement } diff --git a/src/test/bench/core-uint-to-str.rs b/src/test/bench/core-uint-to-str.rs index 8924a9beb6e5e..4a32fda59d81a 100644 --- a/src/test/bench/core-uint-to-str.rs +++ b/src/test/bench/core-uint-to-str.rs @@ -21,7 +21,7 @@ fn main() { args }; - let n = uint::from_str(args[1]).get(); + let n = uint::from_str(args[1]).unwrap(); for i in range(0u, n) { let x = uint::to_str(i); diff --git a/src/test/bench/graph500-bfs.rs b/src/test/bench/graph500-bfs.rs index 2557680f7b507..2f4d763b84d77 100644 --- a/src/test/bench/graph500-bfs.rs +++ b/src/test/bench/graph500-bfs.rs @@ -418,8 +418,8 @@ fn main() { args }; - let scale = uint::from_str(args[1]).get(); - let num_keys = uint::from_str(args[2]).get(); + let scale = uint::from_str(args[1]).unwrap(); + let num_keys = uint::from_str(args[2]).unwrap(); let do_validate = false; let do_sequential = true; diff --git a/src/test/bench/msgsend-pipes-shared.rs b/src/test/bench/msgsend-pipes-shared.rs index 186923da43b8c..4e9656afb813d 100644 --- a/src/test/bench/msgsend-pipes-shared.rs +++ b/src/test/bench/msgsend-pipes-shared.rs @@ -59,8 +59,8 @@ fn run(args: &[~str]) { let to_child = SharedChan::new(to_child); - let size = uint::from_str(args[1]).get(); - let workers = uint::from_str(args[2]).get(); + let size = uint::from_str(args[1]).unwrap(); + let workers = uint::from_str(args[2]).unwrap(); let num_bytes = 100; let start = extra::time::precise_time_s(); let mut worker_results = ~[]; diff --git a/src/test/bench/msgsend-pipes.rs b/src/test/bench/msgsend-pipes.rs index 05ace5fd8e6c7..470e23d63a514 100644 --- a/src/test/bench/msgsend-pipes.rs +++ b/src/test/bench/msgsend-pipes.rs @@ -53,8 +53,8 @@ fn run(args: &[~str]) { let (from_parent, to_child) = stream(); let to_child = SharedChan::new(to_child); - let size = uint::from_str(args[1]).get(); - let workers = uint::from_str(args[2]).get(); + let size = uint::from_str(args[1]).unwrap(); + let workers = uint::from_str(args[2]).unwrap(); let num_bytes = 100; let start = extra::time::precise_time_s(); let mut worker_results = ~[]; diff --git a/src/test/bench/msgsend-ring-mutex-arcs.rs b/src/test/bench/msgsend-ring-mutex-arcs.rs index 649d029e60e8b..7de95f4d822c5 100644 --- a/src/test/bench/msgsend-ring-mutex-arcs.rs +++ b/src/test/bench/msgsend-ring-mutex-arcs.rs @@ -79,8 +79,8 @@ fn main() { args.clone() }; - let num_tasks = uint::from_str(args[1]).get(); - let msg_per_task = uint::from_str(args[2]).get(); + let num_tasks = uint::from_str(args[1]).unwrap(); + let msg_per_task = uint::from_str(args[2]).unwrap(); let (num_chan, num_port) = init(); let num_chan = Cell::new(num_chan); diff --git a/src/test/bench/msgsend-ring-rw-arcs.rs b/src/test/bench/msgsend-ring-rw-arcs.rs index 7f9d7aa588906..1299e863db6b3 100644 --- a/src/test/bench/msgsend-ring-rw-arcs.rs +++ b/src/test/bench/msgsend-ring-rw-arcs.rs @@ -75,8 +75,8 @@ fn main() { args.clone() }; - let num_tasks = uint::from_str(args[1]).get(); - let msg_per_task = uint::from_str(args[2]).get(); + let num_tasks = uint::from_str(args[1]).unwrap(); + let msg_per_task = uint::from_str(args[2]).unwrap(); let (num_chan, num_port) = init(); let num_chan = Cell::new(num_chan); diff --git a/src/test/bench/shootout-ackermann.rs b/src/test/bench/shootout-ackermann.rs index e06ff02a0b38f..e8659ba26d4bc 100644 --- a/src/test/bench/shootout-ackermann.rs +++ b/src/test/bench/shootout-ackermann.rs @@ -35,6 +35,6 @@ fn main() { } else { args }; - let n = int::from_str(args[1]).get(); + let n = int::from_str(args[1]).unwrap(); printfln!("Ack(3,%d): %d\n", n, ack(3, n)); } diff --git a/src/test/bench/shootout-binarytrees.rs b/src/test/bench/shootout-binarytrees.rs index 57bf33fb2fdac..8a2ae3e899520 100644 --- a/src/test/bench/shootout-binarytrees.rs +++ b/src/test/bench/shootout-binarytrees.rs @@ -48,7 +48,7 @@ fn main() { args }; - let n = int::from_str(args[1]).get(); + let n = int::from_str(args[1]).unwrap(); let min_depth = 4; let mut max_depth; if min_depth + 2 > n { diff --git a/src/test/bench/shootout-chameneos-redux.rs b/src/test/bench/shootout-chameneos-redux.rs index f48c15329463e..190ad62d6e17f 100644 --- a/src/test/bench/shootout-chameneos-redux.rs +++ b/src/test/bench/shootout-chameneos-redux.rs @@ -212,7 +212,7 @@ fn main() { args }; - let nn = uint::from_str(args[1]).get(); + let nn = uint::from_str(args[1]).unwrap(); print_complements(); io::println(""); diff --git a/src/test/bench/shootout-fannkuch-redux.rs b/src/test/bench/shootout-fannkuch-redux.rs index bf942cf61a38c..9d4d31b896920 100644 --- a/src/test/bench/shootout-fannkuch-redux.rs +++ b/src/test/bench/shootout-fannkuch-redux.rs @@ -91,6 +91,6 @@ fn fannkuch_redux(n: i32) -> i32 { #[fixed_stack_segment] fn main() { - let n: i32 = FromStr::from_str(os::args()[1]).get(); + let n: i32 = FromStr::from_str(os::args()[1]).unwrap(); printfln!("Pfannkuchen(%d) = %d", n as int, fannkuch_redux(n) as int); } diff --git a/src/test/bench/shootout-fasta-redux.rs b/src/test/bench/shootout-fasta-redux.rs index af96170c79c87..579b88a7e0e72 100644 --- a/src/test/bench/shootout-fasta-redux.rs +++ b/src/test/bench/shootout-fasta-redux.rs @@ -184,7 +184,7 @@ impl RandomFasta { #[fixed_stack_segment] fn main() { - let n: uint = FromStr::from_str(os::args()[1]).get(); + let n: uint = FromStr::from_str(os::args()[1]).unwrap(); unsafe { let mode = "w"; diff --git a/src/test/bench/shootout-fasta.rs b/src/test/bench/shootout-fasta.rs index 3a90c6647e08e..4e2ab8b0a498d 100644 --- a/src/test/bench/shootout-fasta.rs +++ b/src/test/bench/shootout-fasta.rs @@ -130,7 +130,7 @@ fn main() { io::stdout() }; - let n = int::from_str(args[1]).get(); + let n = int::from_str(args[1]).unwrap(); let iub: ~[AminoAcids] = make_cumulative(~[acid('a', 27u32), acid('c', 12u32), acid('g', 12u32), diff --git a/src/test/bench/shootout-fibo.rs b/src/test/bench/shootout-fibo.rs index 7b8bc31bf1c83..9c07df36eb3c1 100644 --- a/src/test/bench/shootout-fibo.rs +++ b/src/test/bench/shootout-fibo.rs @@ -31,6 +31,6 @@ fn main() { } else { args }; - let n = int::from_str(args[1]).get(); + let n = int::from_str(args[1]).unwrap(); printfln!("%d\n", fib(n)); } diff --git a/src/test/bench/shootout-mandelbrot.rs b/src/test/bench/shootout-mandelbrot.rs index 16936f6ed722d..cf43f470e7177 100644 --- a/src/test/bench/shootout-mandelbrot.rs +++ b/src/test/bench/shootout-mandelbrot.rs @@ -9,7 +9,7 @@ static LIMIT: f64 = 2.0; #[fixed_stack_segment] fn main() { unsafe { - let w: i32 = FromStr::from_str(os::args()[1]).get(); + let w: i32 = FromStr::from_str(os::args()[1]).unwrap(); let h = w; let mut byte_acc: i8 = 0; let mut bit_num: i32 = 0; diff --git a/src/test/bench/shootout-nbody.rs b/src/test/bench/shootout-nbody.rs index 99bd7c0f78672..115607d0a992c 100644 --- a/src/test/bench/shootout-nbody.rs +++ b/src/test/bench/shootout-nbody.rs @@ -137,7 +137,7 @@ fn offset_momentum(bodies: &mut [Planet, ..N_BODIES]) { } fn main() { - let n: i32 = FromStr::from_str(os::args()[1]).get(); + let n: i32 = FromStr::from_str(os::args()[1]).unwrap(); let mut bodies = BODIES; offset_momentum(&mut bodies); diff --git a/src/test/bench/shootout-pfib.rs b/src/test/bench/shootout-pfib.rs index 663ebcac3340a..611b11560e4ae 100644 --- a/src/test/bench/shootout-pfib.rs +++ b/src/test/bench/shootout-pfib.rs @@ -110,7 +110,7 @@ fn main() { if opts.stress { stress(2); } else { - let max = uint::parse_bytes(args[1].as_bytes(), 10u).get() as int; + let max = uint::parse_bytes(args[1].as_bytes(), 10u).unwrap() as int; let num_trials = 10; diff --git a/src/test/bench/shootout-spectralnorm.rs b/src/test/bench/shootout-spectralnorm.rs index e3c3c19c33bb3..aef22bc2b8426 100644 --- a/src/test/bench/shootout-spectralnorm.rs +++ b/src/test/bench/shootout-spectralnorm.rs @@ -52,7 +52,7 @@ fn mult_AtAv(v: &mut [f64], out: &mut [f64], tmp: &mut [f64]) { #[fixed_stack_segment] fn main() { - let n: uint = FromStr::from_str(os::args()[1]).get(); + let n: uint = FromStr::from_str(os::args()[1]).unwrap(); let mut u = vec::from_elem(n, 1f64); let mut v = u.clone(); let mut tmp = u.clone(); diff --git a/src/test/bench/shootout-threadring.rs b/src/test/bench/shootout-threadring.rs index 203b9c297fa6b..ace008c1f95d2 100644 --- a/src/test/bench/shootout-threadring.rs +++ b/src/test/bench/shootout-threadring.rs @@ -62,13 +62,13 @@ fn main() { os::args() }; let token = if args.len() > 1u { - FromStr::from_str(args[1]).get() + FromStr::from_str(args[1]).unwrap() } else { 1000 }; let n_tasks = if args.len() > 2u { - FromStr::from_str(args[2]).get() + FromStr::from_str(args[2]).unwrap() } else { 503 diff --git a/src/test/bench/std-smallintmap.rs b/src/test/bench/std-smallintmap.rs index 2c2073eafea62..a035041a662dc 100644 --- a/src/test/bench/std-smallintmap.rs +++ b/src/test/bench/std-smallintmap.rs @@ -39,8 +39,8 @@ fn main() { } else { args }; - let max = uint::from_str(args[1]).get(); - let rep = uint::from_str(args[2]).get(); + let max = uint::from_str(args[1]).unwrap(); + let rep = uint::from_str(args[2]).unwrap(); 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 49b2c32ed6867..6757354089534 100644 --- a/src/test/bench/sudoku.rs +++ b/src/test/bench/sudoku.rs @@ -75,9 +75,9 @@ impl Sudoku { let comps: ~[&str] = line.trim().split_iter(',').collect(); if comps.len() == 3u { - let row = uint::from_str(comps[0]).get() as u8; - let col = uint::from_str(comps[1]).get() as u8; - g[row][col] = uint::from_str(comps[2]).get() as u8; + let row = uint::from_str(comps[0]).unwrap() as u8; + let col = uint::from_str(comps[1]).unwrap() as u8; + g[row][col] = uint::from_str(comps[2]).unwrap() as u8; } else { fail!("Invalid sudoku file"); diff --git a/src/test/bench/task-perf-jargon-metal-smoke.rs b/src/test/bench/task-perf-jargon-metal-smoke.rs index 4e27841a74850..be7f9b5f43adf 100644 --- a/src/test/bench/task-perf-jargon-metal-smoke.rs +++ b/src/test/bench/task-perf-jargon-metal-smoke.rs @@ -52,7 +52,7 @@ fn main() { }; let (p,c) = comm::stream(); - child_generation(uint::from_str(args[1]).get(), c); + child_generation(uint::from_str(args[1]).unwrap(), c); if p.try_recv().is_none() { fail!("it happened when we slumbered"); } diff --git a/src/test/bench/task-perf-linked-failure.rs b/src/test/bench/task-perf-linked-failure.rs index 6ab83e5b3830b..95dd803af8183 100644 --- a/src/test/bench/task-perf-linked-failure.rs +++ b/src/test/bench/task-perf-linked-failure.rs @@ -71,7 +71,7 @@ fn main() { args.clone() }; - let num_tasks = uint::from_str(args[1]).get(); + let num_tasks = uint::from_str(args[1]).unwrap(); // Main group #0 waits for unsupervised group #1. // Grandparent group #1 waits for middle group #2, then fails, killing #3. diff --git a/src/test/bench/task-perf-spawnalot.rs b/src/test/bench/task-perf-spawnalot.rs index a152c30213318..83116ae3c87de 100644 --- a/src/test/bench/task-perf-spawnalot.rs +++ b/src/test/bench/task-perf-spawnalot.rs @@ -31,7 +31,7 @@ fn main() { } else { args }; - let n = uint::from_str(args[1]).get(); + let n = uint::from_str(args[1]).unwrap(); let mut i = 0u; while i < n { task::spawn(|| f(n) ); i += 1u; } } diff --git a/src/test/compile-fail/arc-rw-read-mode-shouldnt-escape.rs b/src/test/compile-fail/arc-rw-read-mode-shouldnt-escape.rs index 451616a074f11..cb6290686816d 100644 --- a/src/test/compile-fail/arc-rw-read-mode-shouldnt-escape.rs +++ b/src/test/compile-fail/arc-rw-read-mode-shouldnt-escape.rs @@ -17,7 +17,7 @@ fn main() { y = Some(x.downgrade(write_mode)); //~^ ERROR cannot infer an appropriate lifetime } - y.get(); + y.unwrap(); // Adding this line causes a method unification failure instead // do (&option::unwrap(y)).read |state| { assert!(*state == 1); } } diff --git a/src/test/compile-fail/arc-rw-write-mode-shouldnt-escape.rs b/src/test/compile-fail/arc-rw-write-mode-shouldnt-escape.rs index b6535b6189a04..75e1989aff01a 100644 --- a/src/test/compile-fail/arc-rw-write-mode-shouldnt-escape.rs +++ b/src/test/compile-fail/arc-rw-write-mode-shouldnt-escape.rs @@ -17,7 +17,7 @@ fn main() { do x.write_downgrade |write_mode| { y = Some(write_mode); } - y.get(); + y.unwrap(); // Adding this line causes a method unification failure instead // do (&option::unwrap(y)).write |state| { assert!(*state == 1); } } diff --git a/src/test/run-fail/result-get-fail.rs b/src/test/run-fail/result-get-fail.rs index 782ce61cab253..4f552bc8f4216 100644 --- a/src/test/run-fail/result-get-fail.rs +++ b/src/test/run-fail/result-get-fail.rs @@ -8,10 +8,10 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// error-pattern:get called on `Err` result: ~"kitty" +// error-pattern:called `Result::unwrap()` on `Err` value: kitty use std::result; fn main() { - error!(result::Err::(~"kitty").get()); + error!(result::Err::(~"kitty").unwrap()); } diff --git a/src/test/run-pass/borrowck-wg-borrow-mut-to-imm.rs b/src/test/run-pass/borrowck-wg-borrow-mut-to-imm.rs index 3b18a8649eeea..668f602b3d35c 100644 --- a/src/test/run-pass/borrowck-wg-borrow-mut-to-imm.rs +++ b/src/test/run-pass/borrowck-wg-borrow-mut-to-imm.rs @@ -1,5 +1,5 @@ fn g(x: &Option) { - println(x.get().to_str()); + println(x.unwrap().to_str()); } fn f(x: &mut Option) { diff --git a/src/test/run-pass/borrowed-ptr-pattern-option.rs b/src/test/run-pass/borrowed-ptr-pattern-option.rs index 4775e5fe0a80e..9f17b9d7f95b5 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, y: &'r Option) -> &'r Option { pub fn main() { let x = None; let y = Some(3); - assert_eq!(select(&x, &y).get(), 3); + assert_eq!(select(&x, &y).unwrap(), 3); } diff --git a/src/test/run-pass/option_addition.rs b/src/test/run-pass/option_addition.rs index fe39d1b11d3b8..8af173150a06d 100644 --- a/src/test/run-pass/option_addition.rs +++ b/src/test/run-pass/option_addition.rs @@ -9,29 +9,17 @@ // except according to those terms. pub fn main() { - let foo = 1; - let bar = 2; + let foo: int = 1; + let bar: int = 2; let foobar = foo + bar; - let nope = optint(0) + optint(0); - let somefoo = optint(foo) + optint(0); - let somebar = optint(bar) + optint(0); - let somefoobar = optint(foo) + optint(bar); + let nope = None:: + None::; + let somefoo = Some(foo) + None::; + let somebar = None:: + Some(bar); + let somefoobar = Some(foo) + Some(bar); - match nope { - None => (), - Some(foo) => fail!("expected None, but found %?", foo) - } - assert_eq!(foo, somefoo.get()); - assert_eq!(bar, somebar.get()); - assert_eq!(foobar, somefoobar.get()); -} - -fn optint(input: int) -> Option { - if input == 0 { - return None; - } - else { - return Some(input); - } + assert_eq!(nope, None::); + assert_eq!(somefoo, None::); + assert_eq!(somebar, None::); + assert_eq!(foobar, somefoobar.unwrap()); } diff --git a/src/test/run-pass/region-dependent-addr-of.rs b/src/test/run-pass/region-dependent-addr-of.rs index ac2fc2eda23cf..f5eb04dd83bfe 100644 --- a/src/test/run-pass/region-dependent-addr-of.rs +++ b/src/test/run-pass/region-dependent-addr-of.rs @@ -105,13 +105,13 @@ pub fn main() { assert_eq!(*p, a.value.v5.f); let p = get_v6_a(&a, 1); - assert_eq!(*p, a.value.v6.get().f); + assert_eq!(*p, a.value.v6.unwrap().f); let p = get_v6_b(&a, 1); - assert_eq!(*p, a.value.v6.get().f); + assert_eq!(*p, a.value.v6.unwrap().f); let p = get_v6_c(&a, 1); - assert_eq!(*p, a.value.v6.get().f); + assert_eq!(*p, a.value.v6.unwrap().f); let p = get_v5_ref(&a, 1); assert_eq!(*p, a.value.v5.f);