From 1fb08f11b75259ad4f208e25fab6c7acc1bccd89 Mon Sep 17 00:00:00 2001 From: Patrick Walton Date: Wed, 14 May 2014 21:39:11 -0700 Subject: [PATCH] libgetopts: Remove all uses of `~str` from `libgetopts` --- src/compiletest/compiletest.rs | 13 +- src/libgetopts/lib.rs | 431 +++++++++++++++++--------------- src/librustc/driver/config.rs | 15 +- src/librustc/driver/mod.rs | 25 +- src/librustc/lib.rs | 5 +- src/librustdoc/lib.rs | 23 +- src/libtest/lib.rs | 9 +- src/test/bench/shootout-pfib.rs | 2 +- 8 files changed, 275 insertions(+), 248 deletions(-) diff --git a/src/compiletest/compiletest.rs b/src/compiletest/compiletest.rs index feae84e7d87..3fb354a7867 100644 --- a/src/compiletest/compiletest.rs +++ b/src/compiletest/compiletest.rs @@ -101,11 +101,7 @@ pub fn parse_config(args: Vec ) -> Config { } let matches = - &match getopts::getopts(args_.iter() - .map(|x| x.to_owned()) - .collect::>() - .as_slice(), - groups.as_slice()) { + &match getopts::getopts(args_.as_slice(), groups.as_slice()) { Ok(m) => m, Err(f) => fail!("{}", f.to_err_msg()) }; @@ -146,7 +142,9 @@ pub fn parse_config(args: Vec ) -> Config { build_base: opt_path(matches, "build-base"), aux_base: opt_path(matches, "aux-base"), stage_id: matches.opt_str("stage-id").unwrap().to_strbuf(), - mode: FromStr::from_str(matches.opt_str("mode").unwrap()).expect("invalid mode"), + mode: FromStr::from_str(matches.opt_str("mode") + .unwrap() + .as_slice()).expect("invalid mode"), run_ignored: matches.opt_present("ignored"), filter: filter, logfile: matches.opt_str("logfile").map(|s| Path::new(s)), @@ -154,7 +152,8 @@ pub fn parse_config(args: Vec ) -> Config { ratchet_metrics: matches.opt_str("ratchet-metrics").map(|s| Path::new(s)), ratchet_noise_percent: - matches.opt_str("ratchet-noise-percent").and_then(|s| from_str::(s)), + matches.opt_str("ratchet-noise-percent") + .and_then(|s| from_str::(s.as_slice())), runtool: matches.opt_str("runtool").map(|x| x.to_strbuf()), host_rustcflags: matches.opt_str("host-rustcflags") .map(|x| x.to_strbuf()), diff --git a/src/libgetopts/lib.rs b/src/libgetopts/lib.rs index 3ac01681be1..ba30e1a2e98 100644 --- a/src/libgetopts/lib.rs +++ b/src/libgetopts/lib.rs @@ -34,7 +34,7 @@ //! use getopts::{optopt,optflag,getopts,OptGroup}; //! use std::os; //! -//! fn do_work(inp: &str, out: Option<~str>) { +//! fn do_work(inp: &str, out: Option) { //! println!("{}", inp); //! match out { //! Some(x) => println!("{}", x), @@ -49,7 +49,9 @@ //! } //! //! fn main() { -//! let args = os::args(); +//! let args: Vec = os::args().iter() +//! .map(|x| x.to_strbuf()) +//! .collect(); //! //! let program = args.get(0).clone(); //! @@ -62,17 +64,17 @@ //! Err(f) => { fail!(f.to_err_msg()) } //! }; //! if matches.opt_present("h") { -//! print_usage(program, opts); +//! print_usage(program.as_slice(), opts); //! return; //! } //! let output = matches.opt_str("o"); -//! let input: &str = if !matches.free.is_empty() { +//! let input = if !matches.free.is_empty() { //! (*matches.free.get(0)).clone() //! } else { -//! print_usage(program, opts); +//! print_usage(program.as_slice(), opts); //! return; //! }; -//! do_work(input, output); +//! do_work(input.as_slice(), output); //! } //! ~~~ @@ -99,7 +101,7 @@ use std::strbuf::StrBuf; pub enum Name { /// A string representing the long name of an option. /// For example: "help" - Long(~str), + Long(StrBuf), /// A char representing the short name of an option. /// For example: 'h' Short(char), @@ -145,13 +147,13 @@ pub struct Opt { #[deriving(Clone, Eq)] pub struct OptGroup { /// Short Name of the `OptGroup` - pub short_name: ~str, + pub short_name: StrBuf, /// Long Name of the `OptGroup` - pub long_name: ~str, + pub long_name: StrBuf, /// Hint - pub hint: ~str, + pub hint: StrBuf, /// Description - pub desc: ~str, + pub desc: StrBuf, /// Whether it has an argument pub hasarg: HasArg, /// How often it can occur @@ -161,7 +163,7 @@ pub struct OptGroup { /// Describes wether an option is given at all or has a value. #[deriving(Clone, Eq)] enum Optval { - Val(~str), + Val(StrBuf), Given, } @@ -174,7 +176,7 @@ pub struct Matches { /// Values of the Options that matched vals: Vec > , /// Free string fragments - pub free: Vec<~str>, + pub free: Vec, } /// The type returned when the command line does not conform to the @@ -183,15 +185,15 @@ pub struct Matches { #[deriving(Clone, Eq, Show)] pub enum Fail_ { /// The option requires an argument but none was passed. - ArgumentMissing(~str), + ArgumentMissing(StrBuf), /// The passed option is not declared among the possible options. - UnrecognizedOption(~str), + UnrecognizedOption(StrBuf), /// A required option is not present. - OptionMissing(~str), + OptionMissing(StrBuf), /// A single occurence option is being used multiple times. - OptionDuplicated(~str), + OptionDuplicated(StrBuf), /// There's an argument being passed to a non-argument option. - UnexpectedArgument(~str), + UnexpectedArgument(StrBuf), } /// The type of failure that occurred. @@ -213,14 +215,14 @@ impl Name { if nm.len() == 1u { Short(nm.char_at(0u)) } else { - Long(nm.to_owned()) + Long(nm.to_strbuf()) } } - fn to_str(&self) -> ~str { + fn to_str(&self) -> StrBuf { match *self { - Short(ch) => ch.to_str(), - Long(ref s) => s.to_owned() + Short(ch) => ch.to_str().to_strbuf(), + Long(ref s) => s.to_strbuf() } } } @@ -246,7 +248,7 @@ impl OptGroup { aliases: Vec::new() }, (1,0) => Opt { - name: Short(short_name.char_at(0)), + name: Short(short_name.as_slice().char_at(0)), hasarg: hasarg, occur: occur, aliases: Vec::new() @@ -257,7 +259,7 @@ impl OptGroup { occur: occur, aliases: vec!( Opt { - name: Short(short_name.char_at(0)), + name: Short(short_name.as_slice().char_at(0)), hasarg: hasarg, occur: occur, aliases: Vec::new() @@ -297,9 +299,10 @@ impl Matches { } /// Returns true if any of several options were matched. - pub fn opts_present(&self, names: &[~str]) -> bool { + pub fn opts_present(&self, names: &[StrBuf]) -> bool { for nm in names.iter() { - match find_opt(self.opts.as_slice(), Name::from_str(*nm)) { + match find_opt(self.opts.as_slice(), + Name::from_str(nm.as_slice())) { Some(id) if !self.vals.get(id).is_empty() => return true, _ => (), }; @@ -308,9 +311,9 @@ impl Matches { } /// Returns the string argument supplied to one of several matching options or `None`. - pub fn opts_str(&self, names: &[~str]) -> Option<~str> { + pub fn opts_str(&self, names: &[StrBuf]) -> Option { for nm in names.iter() { - match self.opt_val(*nm) { + match self.opt_val(nm.as_slice()) { Some(Val(ref s)) => return Some(s.clone()), _ => () } @@ -322,8 +325,8 @@ impl Matches { /// option. /// /// Used when an option accepts multiple values. - pub fn opt_strs(&self, nm: &str) -> Vec<~str> { - let mut acc: Vec<~str> = Vec::new(); + pub fn opt_strs(&self, nm: &str) -> Vec { + let mut acc: Vec = Vec::new(); let r = self.opt_vals(nm); for v in r.iter() { match *v { @@ -335,10 +338,10 @@ impl Matches { } /// Returns the string argument supplied to a matching option or `None`. - pub fn opt_str(&self, nm: &str) -> Option<~str> { + pub fn opt_str(&self, nm: &str) -> Option { let vals = self.opt_vals(nm); if vals.is_empty() { - return None::<~str>; + return None::; } match vals.get(0) { &Val(ref s) => Some((*s).clone()), @@ -352,12 +355,14 @@ impl Matches { /// Returns none if the option was not present, `def` if the option was /// present but no argument was provided, and the argument if the option was /// present and an argument was provided. - pub fn opt_default(&self, nm: &str, def: &str) -> Option<~str> { + pub fn opt_default(&self, nm: &str, def: &str) -> Option { let vals = self.opt_vals(nm); - if vals.is_empty() { return None; } + if vals.is_empty() { + return None; + } match vals.get(0) { &Val(ref s) => Some((*s).clone()), - _ => Some(def.to_owned()) + _ => Some(def.to_strbuf()) } } @@ -389,10 +394,10 @@ pub fn reqopt(short_name: &str, long_name: &str, desc: &str, hint: &str) -> OptG let len = short_name.len(); assert!(len == 1 || len == 0); OptGroup { - short_name: short_name.to_owned(), - long_name: long_name.to_owned(), - hint: hint.to_owned(), - desc: desc.to_owned(), + short_name: short_name.to_strbuf(), + long_name: long_name.to_strbuf(), + hint: hint.to_strbuf(), + desc: desc.to_strbuf(), hasarg: Yes, occur: Req } @@ -403,10 +408,10 @@ pub fn optopt(short_name: &str, long_name: &str, desc: &str, hint: &str) -> OptG let len = short_name.len(); assert!(len == 1 || len == 0); OptGroup { - short_name: short_name.to_owned(), - long_name: long_name.to_owned(), - hint: hint.to_owned(), - desc: desc.to_owned(), + short_name: short_name.to_strbuf(), + long_name: long_name.to_strbuf(), + hint: hint.to_strbuf(), + desc: desc.to_strbuf(), hasarg: Yes, occur: Optional } @@ -417,10 +422,10 @@ pub fn optflag(short_name: &str, long_name: &str, desc: &str) -> OptGroup { let len = short_name.len(); assert!(len == 1 || len == 0); OptGroup { - short_name: short_name.to_owned(), - long_name: long_name.to_owned(), - hint: "".to_owned(), - desc: desc.to_owned(), + short_name: short_name.to_strbuf(), + long_name: long_name.to_strbuf(), + hint: "".to_strbuf(), + desc: desc.to_strbuf(), hasarg: No, occur: Optional } @@ -432,10 +437,10 @@ pub fn optflagmulti(short_name: &str, long_name: &str, desc: &str) -> OptGroup { let len = short_name.len(); assert!(len == 1 || len == 0); OptGroup { - short_name: short_name.to_owned(), - long_name: long_name.to_owned(), - hint: "".to_owned(), - desc: desc.to_owned(), + short_name: short_name.to_strbuf(), + long_name: long_name.to_strbuf(), + hint: "".to_strbuf(), + desc: desc.to_strbuf(), hasarg: No, occur: Multi } @@ -446,10 +451,10 @@ pub fn optflagopt(short_name: &str, long_name: &str, desc: &str, hint: &str) -> let len = short_name.len(); assert!(len == 1 || len == 0); OptGroup { - short_name: short_name.to_owned(), - long_name: long_name.to_owned(), - hint: hint.to_owned(), - desc: desc.to_owned(), + short_name: short_name.to_strbuf(), + long_name: long_name.to_strbuf(), + hint: hint.to_strbuf(), + desc: desc.to_strbuf(), hasarg: Maybe, occur: Optional } @@ -461,10 +466,10 @@ pub fn optmulti(short_name: &str, long_name: &str, desc: &str, hint: &str) -> Op let len = short_name.len(); assert!(len == 1 || len == 0); OptGroup { - short_name: short_name.to_owned(), - long_name: long_name.to_owned(), - hint: hint.to_owned(), - desc: desc.to_owned(), + short_name: short_name.to_strbuf(), + long_name: long_name.to_strbuf(), + hint: hint.to_strbuf(), + desc: desc.to_strbuf(), hasarg: Yes, occur: Multi } @@ -480,10 +485,10 @@ pub fn opt(short_name: &str, let len = short_name.len(); assert!(len == 1 || len == 0); OptGroup { - short_name: short_name.to_owned(), - long_name: long_name.to_owned(), - hint: hint.to_owned(), - desc: desc.to_owned(), + short_name: short_name.to_strbuf(), + long_name: long_name.to_strbuf(), + hint: hint.to_strbuf(), + desc: desc.to_strbuf(), hasarg: hasarg, occur: occur } @@ -491,22 +496,22 @@ pub fn opt(short_name: &str, impl Fail_ { /// Convert a `Fail_` enum into an error string. - pub fn to_err_msg(self) -> ~str { + pub fn to_err_msg(self) -> StrBuf { match self { ArgumentMissing(ref nm) => { - format!("Argument to option '{}' missing.", *nm) + format_strbuf!("Argument to option '{}' missing.", *nm) } UnrecognizedOption(ref nm) => { - format!("Unrecognized option: '{}'.", *nm) + format_strbuf!("Unrecognized option: '{}'.", *nm) } OptionMissing(ref nm) => { - format!("Required option '{}' missing.", *nm) + format_strbuf!("Required option '{}' missing.", *nm) } OptionDuplicated(ref nm) => { - format!("Option '{}' given more than once.", *nm) + format_strbuf!("Option '{}' given more than once.", *nm) } UnexpectedArgument(ref nm) => { - format!("Option '{}' does not take an argument.", *nm) + format_strbuf!("Option '{}' does not take an argument.", *nm) } } } @@ -517,44 +522,44 @@ impl Fail_ { /// On success returns `Ok(Opt)`. Use methods such as `opt_present` /// `opt_str`, etc. to interrogate results. Returns `Err(Fail_)` on failure. /// Use `to_err_msg` to get an error message. -pub fn getopts(args: &[~str], optgrps: &[OptGroup]) -> Result { +pub fn getopts(args: &[StrBuf], optgrps: &[OptGroup]) -> Result { let opts: Vec = optgrps.iter().map(|x| x.long_to_short()).collect(); let n_opts = opts.len(); fn f(_x: uint) -> Vec { return Vec::new(); } let mut vals = Vec::from_fn(n_opts, f); - let mut free: Vec<~str> = Vec::new(); + let mut free: Vec = Vec::new(); let l = args.len(); let mut i = 0; while i < l { let cur = args[i].clone(); let curlen = cur.len(); - if !is_arg(cur) { + if !is_arg(cur.as_slice()) { free.push(cur); - } else if cur == "--".to_owned() { + } else if cur.as_slice() == "--" { let mut j = i + 1; while j < l { free.push(args[j].clone()); j += 1; } break; } else { let mut names; let mut i_arg = None; - if cur[1] == '-' as u8 { - let tail = cur.slice(2, curlen); + if cur.as_slice()[1] == '-' as u8 { + let tail = cur.as_slice().slice(2, curlen); let tail_eq: Vec<&str> = tail.split('=').collect(); if tail_eq.len() <= 1 { - names = vec!(Long(tail.to_owned())); + names = vec!(Long(tail.to_strbuf())); } else { names = - vec!(Long((*tail_eq.get(0)).to_owned())); - i_arg = Some((*tail_eq.get(1)).to_owned()); + vec!(Long((*tail_eq.get(0)).to_strbuf())); + i_arg = Some((*tail_eq.get(1)).to_strbuf()); } } else { let mut j = 1; let mut last_valid_opt_id = None; names = Vec::new(); while j < curlen { - let range = cur.char_range_at(j); + let range = cur.as_slice().char_range_at(j); let opt = Short(range.ch); /* In a series of potential options (eg. -aheJ), if we @@ -576,7 +581,8 @@ pub fn getopts(args: &[~str], optgrps: &[OptGroup]) -> Result { No => false }; if arg_follows && j < curlen { - i_arg = Some(cur.slice(j, curlen).to_owned()); + i_arg = Some(cur.as_slice() + .slice(j, curlen).to_strbuf()); break; } else { last_valid_opt_id = None; @@ -606,8 +612,8 @@ pub fn getopts(args: &[~str], optgrps: &[OptGroup]) -> Result { vals.get_mut(optid) .push(Val((i_arg.clone()) .unwrap())); - } else if name_pos < names.len() || - i + 1 == l || is_arg(args[i + 1]) { + } else if name_pos < names.len() || i + 1 == l || + is_arg(args[i + 1].as_slice()) { vals.get_mut(optid).push(Given); } else { i += 1; @@ -653,7 +659,7 @@ pub fn getopts(args: &[~str], optgrps: &[OptGroup]) -> Result { } /// Derive a usage message from a set of long options. -pub fn usage(brief: &str, opts: &[OptGroup]) -> ~str { +pub fn usage(brief: &str, opts: &[OptGroup]) -> StrBuf { let desc_sep = "\n" + " ".repeat(24); @@ -672,7 +678,7 @@ pub fn usage(brief: &str, opts: &[OptGroup]) -> ~str { 0 => {} 1 => { row.push_char('-'); - row.push_str(short_name); + row.push_str(short_name.as_slice()); row.push_char(' '); } _ => fail!("the short name should only be 1 ascii char long"), @@ -683,7 +689,7 @@ pub fn usage(brief: &str, opts: &[OptGroup]) -> ~str { 0 => {} _ => { row.push_str("--"); - row.push_str(long_name); + row.push_str(long_name.as_slice()); row.push_char(' '); } } @@ -691,10 +697,10 @@ pub fn usage(brief: &str, opts: &[OptGroup]) -> ~str { // arg match hasarg { No => {} - Yes => row.push_str(hint), + Yes => row.push_str(hint.as_slice()), Maybe => { row.push_char('['); - row.push_str(hint); + row.push_str(hint.as_slice()); row.push_char(']'); } } @@ -712,7 +718,7 @@ pub fn usage(brief: &str, opts: &[OptGroup]) -> ~str { // Normalize desc to contain words separated by one space character let mut desc_normalized_whitespace = StrBuf::new(); - for word in desc.words() { + for word in desc.as_slice().words() { desc_normalized_whitespace.push_str(word); desc_normalized_whitespace.push_char(' '); } @@ -730,13 +736,15 @@ pub fn usage(brief: &str, opts: &[OptGroup]) -> ~str { // wrapped description row.push_str(desc_rows.connect(desc_sep)); - row.into_owned() + row }); - format!("{}\n\nOptions:\n{}\n", brief, rows.collect:: >().connect("\n")) + format_strbuf!("{}\n\nOptions:\n{}\n", + brief, + rows.collect::>().connect("\n")) } -fn format_option(opt: &OptGroup) -> ~str { +fn format_option(opt: &OptGroup) -> StrBuf { let mut line = StrBuf::new(); if opt.occur != Req { @@ -746,10 +754,10 @@ fn format_option(opt: &OptGroup) -> ~str { // Use short_name is possible, but fallback to long_name. if opt.short_name.len() > 0 { line.push_char('-'); - line.push_str(opt.short_name); + line.push_str(opt.short_name.as_slice()); } else { line.push_str("--"); - line.push_str(opt.long_name); + line.push_str(opt.long_name.as_slice()); } if opt.hasarg != No { @@ -757,7 +765,7 @@ fn format_option(opt: &OptGroup) -> ~str { if opt.hasarg == Maybe { line.push_char('['); } - line.push_str(opt.hint); + line.push_str(opt.hint.as_slice()); if opt.hasarg == Maybe { line.push_char(']'); } @@ -770,14 +778,14 @@ fn format_option(opt: &OptGroup) -> ~str { line.push_str(".."); } - line.into_owned() + line } /// Derive a short one-line usage summary from a set of long options. -pub fn short_usage(program_name: &str, opts: &[OptGroup]) -> ~str { - let mut line = StrBuf::from_str("Usage: " + program_name + " "); - line.push_str(opts.iter().map(format_option).collect::>().connect(" ")); - line.into_owned() +pub fn short_usage(program_name: &str, opts: &[OptGroup]) -> StrBuf { + let mut line = format_strbuf!("Usage: {} ", program_name); + line.push_str(opts.iter().map(format_option).collect::>().connect(" ")); + line } @@ -886,18 +894,21 @@ fn each_split_within<'a>(ss: &'a str, lim: uint, it: |&'a str| -> bool) #[test] fn test_split_within() { - fn t(s: &str, i: uint, u: &[~str]) { + fn t(s: &str, i: uint, u: &[StrBuf]) { let mut v = Vec::new(); - each_split_within(s, i, |s| { v.push(s.to_owned()); true }); + each_split_within(s, i, |s| { v.push(s.to_strbuf()); true }); assert!(v.iter().zip(u.iter()).all(|(a,b)| a == b)); } t("", 0, []); t("", 15, []); - t("hello", 15, ["hello".to_owned()]); - t("\nMary had a little lamb\nLittle lamb\n", 15, - ["Mary had a".to_owned(), "little lamb".to_owned(), "Little lamb".to_owned()]); + t("hello", 15, ["hello".to_strbuf()]); + t("\nMary had a little lamb\nLittle lamb\n", 15, [ + "Mary had a".to_strbuf(), + "little lamb".to_strbuf(), + "Little lamb".to_strbuf() + ]); t("\nMary had a little lamb\nLittle lamb\n", ::std::uint::MAX, - ["Mary had a little lamb\nLittle lamb".to_owned()]); + ["Mary had a little lamb\nLittle lamb".to_strbuf()]); } #[cfg(test)] @@ -920,25 +931,25 @@ mod tests { // Tests for reqopt #[test] fn test_reqopt() { - let long_args = vec!("--test=20".to_owned()); + let long_args = vec!("--test=20".to_strbuf()); let opts = vec!(reqopt("t", "test", "testing", "TEST")); let rs = getopts(long_args.as_slice(), opts.as_slice()); match rs { Ok(ref m) => { assert!(m.opt_present("test")); - assert_eq!(m.opt_str("test").unwrap(), "20".to_owned()); + assert_eq!(m.opt_str("test").unwrap(), "20".to_strbuf()); assert!(m.opt_present("t")); - assert_eq!(m.opt_str("t").unwrap(), "20".to_owned()); + assert_eq!(m.opt_str("t").unwrap(), "20".to_strbuf()); } _ => { fail!("test_reqopt failed (long arg)"); } } - let short_args = vec!("-t".to_owned(), "20".to_owned()); + let short_args = vec!("-t".to_strbuf(), "20".to_strbuf()); match getopts(short_args.as_slice(), opts.as_slice()) { Ok(ref m) => { assert!((m.opt_present("test"))); - assert_eq!(m.opt_str("test").unwrap(), "20".to_owned()); + assert_eq!(m.opt_str("test").unwrap(), "20".to_strbuf()); assert!((m.opt_present("t"))); - assert_eq!(m.opt_str("t").unwrap(), "20".to_owned()); + assert_eq!(m.opt_str("t").unwrap(), "20".to_strbuf()); } _ => { fail!("test_reqopt failed (short arg)"); } } @@ -946,7 +957,7 @@ mod tests { #[test] fn test_reqopt_missing() { - let args = vec!("blah".to_owned()); + let args = vec!("blah".to_strbuf()); let opts = vec!(reqopt("t", "test", "testing", "TEST")); let rs = getopts(args.as_slice(), opts.as_slice()); match rs { @@ -957,14 +968,14 @@ mod tests { #[test] fn test_reqopt_no_arg() { - let long_args = vec!("--test".to_owned()); + let long_args = vec!("--test".to_strbuf()); let opts = vec!(reqopt("t", "test", "testing", "TEST")); let rs = getopts(long_args.as_slice(), opts.as_slice()); match rs { Err(f) => check_fail_type(f, ArgumentMissing_), _ => fail!() } - let short_args = vec!("-t".to_owned()); + let short_args = vec!("-t".to_strbuf()); match getopts(short_args.as_slice(), opts.as_slice()) { Err(f) => check_fail_type(f, ArgumentMissing_), _ => fail!() @@ -973,7 +984,7 @@ mod tests { #[test] fn test_reqopt_multi() { - let args = vec!("--test=20".to_owned(), "-t".to_owned(), "30".to_owned()); + let args = vec!("--test=20".to_strbuf(), "-t".to_strbuf(), "30".to_strbuf()); let opts = vec!(reqopt("t", "test", "testing", "TEST")); let rs = getopts(args.as_slice(), opts.as_slice()); match rs { @@ -985,25 +996,25 @@ mod tests { // Tests for optopt #[test] fn test_optopt() { - let long_args = vec!("--test=20".to_owned()); + let long_args = vec!("--test=20".to_strbuf()); let opts = vec!(optopt("t", "test", "testing", "TEST")); let rs = getopts(long_args.as_slice(), opts.as_slice()); match rs { Ok(ref m) => { assert!(m.opt_present("test")); - assert_eq!(m.opt_str("test").unwrap(), "20".to_owned()); + assert_eq!(m.opt_str("test").unwrap(), "20".to_strbuf()); assert!((m.opt_present("t"))); - assert_eq!(m.opt_str("t").unwrap(), "20".to_owned()); + assert_eq!(m.opt_str("t").unwrap(), "20".to_strbuf()); } _ => fail!() } - let short_args = vec!("-t".to_owned(), "20".to_owned()); + let short_args = vec!("-t".to_strbuf(), "20".to_strbuf()); match getopts(short_args.as_slice(), opts.as_slice()) { Ok(ref m) => { assert!((m.opt_present("test"))); - assert_eq!(m.opt_str("test").unwrap(), "20".to_owned()); + assert_eq!(m.opt_str("test").unwrap(), "20".to_strbuf()); assert!((m.opt_present("t"))); - assert_eq!(m.opt_str("t").unwrap(), "20".to_owned()); + assert_eq!(m.opt_str("t").unwrap(), "20".to_strbuf()); } _ => fail!() } @@ -1011,7 +1022,7 @@ mod tests { #[test] fn test_optopt_missing() { - let args = vec!("blah".to_owned()); + let args = vec!("blah".to_strbuf()); let opts = vec!(optopt("t", "test", "testing", "TEST")); let rs = getopts(args.as_slice(), opts.as_slice()); match rs { @@ -1025,14 +1036,14 @@ mod tests { #[test] fn test_optopt_no_arg() { - let long_args = vec!("--test".to_owned()); + let long_args = vec!("--test".to_strbuf()); let opts = vec!(optopt("t", "test", "testing", "TEST")); let rs = getopts(long_args.as_slice(), opts.as_slice()); match rs { Err(f) => check_fail_type(f, ArgumentMissing_), _ => fail!() } - let short_args = vec!("-t".to_owned()); + let short_args = vec!("-t".to_strbuf()); match getopts(short_args.as_slice(), opts.as_slice()) { Err(f) => check_fail_type(f, ArgumentMissing_), _ => fail!() @@ -1041,7 +1052,7 @@ mod tests { #[test] fn test_optopt_multi() { - let args = vec!("--test=20".to_owned(), "-t".to_owned(), "30".to_owned()); + let args = vec!("--test=20".to_strbuf(), "-t".to_strbuf(), "30".to_strbuf()); let opts = vec!(optopt("t", "test", "testing", "TEST")); let rs = getopts(args.as_slice(), opts.as_slice()); match rs { @@ -1053,7 +1064,7 @@ mod tests { // Tests for optflag #[test] fn test_optflag() { - let long_args = vec!("--test".to_owned()); + let long_args = vec!("--test".to_strbuf()); let opts = vec!(optflag("t", "test", "testing")); let rs = getopts(long_args.as_slice(), opts.as_slice()); match rs { @@ -1063,7 +1074,7 @@ mod tests { } _ => fail!() } - let short_args = vec!("-t".to_owned()); + let short_args = vec!("-t".to_strbuf()); match getopts(short_args.as_slice(), opts.as_slice()) { Ok(ref m) => { assert!(m.opt_present("test")); @@ -1075,7 +1086,7 @@ mod tests { #[test] fn test_optflag_missing() { - let args = vec!("blah".to_owned()); + let args = vec!("blah".to_strbuf()); let opts = vec!(optflag("t", "test", "testing")); let rs = getopts(args.as_slice(), opts.as_slice()); match rs { @@ -1089,7 +1100,7 @@ mod tests { #[test] fn test_optflag_long_arg() { - let args = vec!("--test=20".to_owned()); + let args = vec!("--test=20".to_strbuf()); let opts = vec!(optflag("t", "test", "testing")); let rs = getopts(args.as_slice(), opts.as_slice()); match rs { @@ -1103,7 +1114,7 @@ mod tests { #[test] fn test_optflag_multi() { - let args = vec!("--test".to_owned(), "-t".to_owned()); + let args = vec!("--test".to_strbuf(), "-t".to_strbuf()); let opts = vec!(optflag("t", "test", "testing")); let rs = getopts(args.as_slice(), opts.as_slice()); match rs { @@ -1114,14 +1125,14 @@ mod tests { #[test] fn test_optflag_short_arg() { - let args = vec!("-t".to_owned(), "20".to_owned()); + let args = vec!("-t".to_strbuf(), "20".to_strbuf()); let opts = vec!(optflag("t", "test", "testing")); let rs = getopts(args.as_slice(), opts.as_slice()); match rs { Ok(ref m) => { // The next variable after the flag is just a free argument - assert!(*m.free.get(0) == "20".to_owned()); + assert!(*m.free.get(0) == "20".to_strbuf()); } _ => fail!() } @@ -1130,7 +1141,7 @@ mod tests { // Tests for optflagmulti #[test] fn test_optflagmulti_short1() { - let args = vec!("-v".to_owned()); + let args = vec!("-v".to_strbuf()); let opts = vec!(optflagmulti("v", "verbose", "verbosity")); let rs = getopts(args.as_slice(), opts.as_slice()); match rs { @@ -1143,7 +1154,7 @@ mod tests { #[test] fn test_optflagmulti_short2a() { - let args = vec!("-v".to_owned(), "-v".to_owned()); + let args = vec!("-v".to_strbuf(), "-v".to_strbuf()); let opts = vec!(optflagmulti("v", "verbose", "verbosity")); let rs = getopts(args.as_slice(), opts.as_slice()); match rs { @@ -1156,7 +1167,7 @@ mod tests { #[test] fn test_optflagmulti_short2b() { - let args = vec!("-vv".to_owned()); + let args = vec!("-vv".to_strbuf()); let opts = vec!(optflagmulti("v", "verbose", "verbosity")); let rs = getopts(args.as_slice(), opts.as_slice()); match rs { @@ -1169,7 +1180,7 @@ mod tests { #[test] fn test_optflagmulti_long1() { - let args = vec!("--verbose".to_owned()); + let args = vec!("--verbose".to_strbuf()); let opts = vec!(optflagmulti("v", "verbose", "verbosity")); let rs = getopts(args.as_slice(), opts.as_slice()); match rs { @@ -1182,7 +1193,7 @@ mod tests { #[test] fn test_optflagmulti_long2() { - let args = vec!("--verbose".to_owned(), "--verbose".to_owned()); + let args = vec!("--verbose".to_strbuf(), "--verbose".to_strbuf()); let opts = vec!(optflagmulti("v", "verbose", "verbosity")); let rs = getopts(args.as_slice(), opts.as_slice()); match rs { @@ -1195,8 +1206,8 @@ mod tests { #[test] fn test_optflagmulti_mix() { - let args = vec!("--verbose".to_owned(), "-v".to_owned(), - "-vv".to_owned(), "verbose".to_owned()); + let args = vec!("--verbose".to_strbuf(), "-v".to_strbuf(), + "-vv".to_strbuf(), "verbose".to_strbuf()); let opts = vec!(optflagmulti("v", "verbose", "verbosity")); let rs = getopts(args.as_slice(), opts.as_slice()); match rs { @@ -1211,25 +1222,25 @@ mod tests { // Tests for optmulti #[test] fn test_optmulti() { - let long_args = vec!("--test=20".to_owned()); + let long_args = vec!("--test=20".to_strbuf()); let opts = vec!(optmulti("t", "test", "testing", "TEST")); let rs = getopts(long_args.as_slice(), opts.as_slice()); match rs { Ok(ref m) => { assert!((m.opt_present("test"))); - assert_eq!(m.opt_str("test").unwrap(), "20".to_owned()); + assert_eq!(m.opt_str("test").unwrap(), "20".to_strbuf()); assert!((m.opt_present("t"))); - assert_eq!(m.opt_str("t").unwrap(), "20".to_owned()); + assert_eq!(m.opt_str("t").unwrap(), "20".to_strbuf()); } _ => fail!() } - let short_args = vec!("-t".to_owned(), "20".to_owned()); + let short_args = vec!("-t".to_strbuf(), "20".to_strbuf()); match getopts(short_args.as_slice(), opts.as_slice()) { Ok(ref m) => { assert!((m.opt_present("test"))); - assert_eq!(m.opt_str("test").unwrap(), "20".to_owned()); + assert_eq!(m.opt_str("test").unwrap(), "20".to_strbuf()); assert!((m.opt_present("t"))); - assert_eq!(m.opt_str("t").unwrap(), "20".to_owned()); + assert_eq!(m.opt_str("t").unwrap(), "20".to_strbuf()); } _ => fail!() } @@ -1237,7 +1248,7 @@ mod tests { #[test] fn test_optmulti_missing() { - let args = vec!("blah".to_owned()); + let args = vec!("blah".to_strbuf()); let opts = vec!(optmulti("t", "test", "testing", "TEST")); let rs = getopts(args.as_slice(), opts.as_slice()); match rs { @@ -1251,14 +1262,14 @@ mod tests { #[test] fn test_optmulti_no_arg() { - let long_args = vec!("--test".to_owned()); + let long_args = vec!("--test".to_strbuf()); let opts = vec!(optmulti("t", "test", "testing", "TEST")); let rs = getopts(long_args.as_slice(), opts.as_slice()); match rs { Err(f) => check_fail_type(f, ArgumentMissing_), _ => fail!() } - let short_args = vec!("-t".to_owned()); + let short_args = vec!("-t".to_strbuf()); match getopts(short_args.as_slice(), opts.as_slice()) { Err(f) => check_fail_type(f, ArgumentMissing_), _ => fail!() @@ -1267,18 +1278,18 @@ mod tests { #[test] fn test_optmulti_multi() { - let args = vec!("--test=20".to_owned(), "-t".to_owned(), "30".to_owned()); + let args = vec!("--test=20".to_strbuf(), "-t".to_strbuf(), "30".to_strbuf()); let opts = vec!(optmulti("t", "test", "testing", "TEST")); let rs = getopts(args.as_slice(), opts.as_slice()); match rs { Ok(ref m) => { assert!(m.opt_present("test")); - assert_eq!(m.opt_str("test").unwrap(), "20".to_owned()); + assert_eq!(m.opt_str("test").unwrap(), "20".to_strbuf()); assert!(m.opt_present("t")); - assert_eq!(m.opt_str("t").unwrap(), "20".to_owned()); + assert_eq!(m.opt_str("t").unwrap(), "20".to_strbuf()); let pair = m.opt_strs("test"); - assert!(*pair.get(0) == "20".to_owned()); - assert!(*pair.get(1) == "30".to_owned()); + assert!(*pair.get(0) == "20".to_strbuf()); + assert!(*pair.get(1) == "30".to_strbuf()); } _ => fail!() } @@ -1286,14 +1297,14 @@ mod tests { #[test] fn test_unrecognized_option() { - let long_args = vec!("--untest".to_owned()); + let long_args = vec!("--untest".to_strbuf()); let opts = vec!(optmulti("t", "test", "testing", "TEST")); let rs = getopts(long_args.as_slice(), opts.as_slice()); match rs { Err(f) => check_fail_type(f, UnrecognizedOption_), _ => fail!() } - let short_args = vec!("-u".to_owned()); + let short_args = vec!("-u".to_strbuf()); match getopts(short_args.as_slice(), opts.as_slice()) { Err(f) => check_fail_type(f, UnrecognizedOption_), _ => fail!() @@ -1303,10 +1314,22 @@ mod tests { #[test] fn test_combined() { let args = - vec!("prog".to_owned(), "free1".to_owned(), "-s".to_owned(), "20".to_owned(), - "free2".to_owned(), "--flag".to_owned(), "--long=30".to_owned(), "-f".to_owned(), - "-m".to_owned(), "40".to_owned(), "-m".to_owned(), "50".to_owned(), "-n".to_owned(), - "-A B".to_owned(), "-n".to_owned(), "-60 70".to_owned()); + vec!("prog".to_strbuf(), + "free1".to_strbuf(), + "-s".to_strbuf(), + "20".to_strbuf(), + "free2".to_strbuf(), + "--flag".to_strbuf(), + "--long=30".to_strbuf(), + "-f".to_strbuf(), + "-m".to_strbuf(), + "40".to_strbuf(), + "-m".to_strbuf(), + "50".to_strbuf(), + "-n".to_strbuf(), + "-A B".to_strbuf(), + "-n".to_strbuf(), + "-60 70".to_strbuf()); let opts = vec!(optopt("s", "something", "something", "SOMETHING"), optflag("", "flag", "a flag"), @@ -1318,19 +1341,19 @@ mod tests { let rs = getopts(args.as_slice(), opts.as_slice()); match rs { Ok(ref m) => { - assert!(*m.free.get(0) == "prog".to_owned()); - assert!(*m.free.get(1) == "free1".to_owned()); - assert_eq!(m.opt_str("s").unwrap(), "20".to_owned()); - assert!(*m.free.get(2) == "free2".to_owned()); + assert!(*m.free.get(0) == "prog".to_strbuf()); + assert!(*m.free.get(1) == "free1".to_strbuf()); + assert_eq!(m.opt_str("s").unwrap(), "20".to_strbuf()); + assert!(*m.free.get(2) == "free2".to_strbuf()); assert!((m.opt_present("flag"))); - assert_eq!(m.opt_str("long").unwrap(), "30".to_owned()); + assert_eq!(m.opt_str("long").unwrap(), "30".to_strbuf()); assert!((m.opt_present("f"))); let pair = m.opt_strs("m"); - assert!(*pair.get(0) == "40".to_owned()); - assert!(*pair.get(1) == "50".to_owned()); + assert!(*pair.get(0) == "40".to_strbuf()); + assert!(*pair.get(1) == "50".to_strbuf()); let pair = m.opt_strs("n"); - assert!(*pair.get(0) == "-A B".to_owned()); - assert!(*pair.get(1) == "-60 70".to_owned()); + assert!(*pair.get(0) == "-A B".to_strbuf()); + assert!(*pair.get(1) == "-60 70".to_strbuf()); assert!((!m.opt_present("notpresent"))); } _ => fail!() @@ -1343,68 +1366,68 @@ mod tests { optopt("", "encrypt", "encrypt", "ENCRYPT"), optopt("f", "", "flag", "FLAG")); - let args_single = vec!("-e".to_owned(), "foo".to_owned()); + let args_single = vec!("-e".to_strbuf(), "foo".to_strbuf()); let matches_single = &match getopts(args_single.as_slice(), opts.as_slice()) { result::Ok(m) => m, result::Err(_) => fail!() }; - assert!(matches_single.opts_present(["e".to_owned()])); - assert!(matches_single.opts_present(["encrypt".to_owned(), "e".to_owned()])); - assert!(matches_single.opts_present(["e".to_owned(), "encrypt".to_owned()])); - assert!(!matches_single.opts_present(["encrypt".to_owned()])); - assert!(!matches_single.opts_present(["thing".to_owned()])); + assert!(matches_single.opts_present(["e".to_strbuf()])); + assert!(matches_single.opts_present(["encrypt".to_strbuf(), "e".to_strbuf()])); + assert!(matches_single.opts_present(["e".to_strbuf(), "encrypt".to_strbuf()])); + assert!(!matches_single.opts_present(["encrypt".to_strbuf()])); + assert!(!matches_single.opts_present(["thing".to_strbuf()])); assert!(!matches_single.opts_present([])); - assert_eq!(matches_single.opts_str(["e".to_owned()]).unwrap(), "foo".to_owned()); - assert_eq!(matches_single.opts_str(["e".to_owned(), "encrypt".to_owned()]).unwrap(), - "foo".to_owned()); - assert_eq!(matches_single.opts_str(["encrypt".to_owned(), "e".to_owned()]).unwrap(), - "foo".to_owned()); + assert_eq!(matches_single.opts_str(["e".to_strbuf()]).unwrap(), "foo".to_strbuf()); + assert_eq!(matches_single.opts_str(["e".to_strbuf(), "encrypt".to_strbuf()]).unwrap(), + "foo".to_strbuf()); + assert_eq!(matches_single.opts_str(["encrypt".to_strbuf(), "e".to_strbuf()]).unwrap(), + "foo".to_strbuf()); - let args_both = vec!("-e".to_owned(), "foo".to_owned(), "--encrypt".to_owned(), - "foo".to_owned()); + let args_both = vec!("-e".to_strbuf(), "foo".to_strbuf(), "--encrypt".to_strbuf(), + "foo".to_strbuf()); let matches_both = &match getopts(args_both.as_slice(), opts.as_slice()) { result::Ok(m) => m, result::Err(_) => fail!() }; - assert!(matches_both.opts_present(["e".to_owned()])); - assert!(matches_both.opts_present(["encrypt".to_owned()])); - assert!(matches_both.opts_present(["encrypt".to_owned(), "e".to_owned()])); - assert!(matches_both.opts_present(["e".to_owned(), "encrypt".to_owned()])); - assert!(!matches_both.opts_present(["f".to_owned()])); - assert!(!matches_both.opts_present(["thing".to_owned()])); + assert!(matches_both.opts_present(["e".to_strbuf()])); + assert!(matches_both.opts_present(["encrypt".to_strbuf()])); + assert!(matches_both.opts_present(["encrypt".to_strbuf(), "e".to_strbuf()])); + assert!(matches_both.opts_present(["e".to_strbuf(), "encrypt".to_strbuf()])); + assert!(!matches_both.opts_present(["f".to_strbuf()])); + assert!(!matches_both.opts_present(["thing".to_strbuf()])); assert!(!matches_both.opts_present([])); - assert_eq!(matches_both.opts_str(["e".to_owned()]).unwrap(), "foo".to_owned()); - assert_eq!(matches_both.opts_str(["encrypt".to_owned()]).unwrap(), "foo".to_owned()); - assert_eq!(matches_both.opts_str(["e".to_owned(), "encrypt".to_owned()]).unwrap(), - "foo".to_owned()); - assert_eq!(matches_both.opts_str(["encrypt".to_owned(), "e".to_owned()]).unwrap(), - "foo".to_owned()); + assert_eq!(matches_both.opts_str(["e".to_strbuf()]).unwrap(), "foo".to_strbuf()); + assert_eq!(matches_both.opts_str(["encrypt".to_strbuf()]).unwrap(), "foo".to_strbuf()); + assert_eq!(matches_both.opts_str(["e".to_strbuf(), "encrypt".to_strbuf()]).unwrap(), + "foo".to_strbuf()); + assert_eq!(matches_both.opts_str(["encrypt".to_strbuf(), "e".to_strbuf()]).unwrap(), + "foo".to_strbuf()); } #[test] fn test_nospace() { - let args = vec!("-Lfoo".to_owned(), "-M.".to_owned()); + let args = vec!("-Lfoo".to_strbuf(), "-M.".to_strbuf()); let opts = vec!(optmulti("L", "", "library directory", "LIB"), optmulti("M", "", "something", "MMMM")); let matches = &match getopts(args.as_slice(), opts.as_slice()) { result::Ok(m) => m, result::Err(_) => fail!() }; - assert!(matches.opts_present(["L".to_owned()])); - assert_eq!(matches.opts_str(["L".to_owned()]).unwrap(), "foo".to_owned()); - assert!(matches.opts_present(["M".to_owned()])); - assert_eq!(matches.opts_str(["M".to_owned()]).unwrap(), ".".to_owned()); + assert!(matches.opts_present(["L".to_strbuf()])); + assert_eq!(matches.opts_str(["L".to_strbuf()]).unwrap(), "foo".to_strbuf()); + assert!(matches.opts_present(["M".to_strbuf()])); + assert_eq!(matches.opts_str(["M".to_strbuf()]).unwrap(), ".".to_strbuf()); } #[test] fn test_long_to_short() { let mut short = Opt { - name: Long("banana".to_owned()), + name: Long("banana".to_strbuf()), hasarg: Yes, occur: Req, aliases: Vec::new(), @@ -1423,7 +1446,7 @@ mod tests { let opts = vec!( optflagmulti("a", "apple", "Desc")); - let args = vec!("-a".to_owned(), "--apple".to_owned(), "-a".to_owned()); + let args = vec!("-a".to_strbuf(), "--apple".to_strbuf(), "-a".to_strbuf()); let matches = getopts(args.as_slice(), opts.as_slice()).unwrap(); assert_eq!(3, matches.opt_count("a")); @@ -1450,7 +1473,7 @@ Options: -k --kiwi Desc -p [VAL] Desc -l VAL Desc -".to_owned(); +".to_strbuf(); let generated_usage = usage("Usage: fruits", optgroups.as_slice()); @@ -1477,7 +1500,7 @@ Options: -k --kiwi This is a long description which won't be wrapped..+.. -a --apple This is a long description which _will_ be wrapped..+.. -".to_owned(); +".to_strbuf(); let usage = usage("Usage: fruits", optgroups.as_slice()); @@ -1503,7 +1526,7 @@ Options: -a --apple This “description” has some characters that could confuse the line wrapping; an apple costs 0.51€ in some parts of Europe. -".to_owned(); +".to_strbuf(); let usage = usage("Usage: fruits", optgroups.as_slice()); @@ -1522,7 +1545,7 @@ Options: optflagopt("p", "", "Desc", "VAL"), optmulti("l", "", "Desc", "VAL")); - let expected = "Usage: fruits -b VAL [-a VAL] [-k] [-p [VAL]] [-l VAL]..".to_owned(); + let expected = "Usage: fruits -b VAL [-a VAL] [-k] [-p [VAL]] [-l VAL]..".to_strbuf(); let generated_usage = short_usage("fruits", optgroups.as_slice()); debug!("expected: <<{}>>", expected); diff --git a/src/librustc/driver/config.rs b/src/librustc/driver/config.rs index da573a014d0..02f937af90d 100644 --- a/src/librustc/driver/config.rs +++ b/src/librustc/driver/config.rs @@ -319,7 +319,7 @@ pub fn build_codegen_options(matches: &getopts::Matches) -> CodegenOptions { let mut cg = basic_codegen_options(); for option in matches.opt_strs("C").move_iter() { - let mut iter = option.splitn('=', 1); + let mut iter = option.as_slice().splitn('=', 1); let key = iter.next().unwrap(); let value = iter.next(); let option_to_lookup = key.replace("-", "_"); @@ -563,7 +563,7 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options { let mut crate_types: Vec = Vec::new(); let unparsed_crate_types = matches.opt_strs("crate-type"); for unparsed_crate_type in unparsed_crate_types.iter() { - for part in unparsed_crate_type.split(',') { + for part in unparsed_crate_type.as_slice().split(',') { let new_part = match part { "lib" => default_lib_output(), "rlib" => CrateTypeRlib, @@ -612,7 +612,10 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options { let mut this_bit = 0; for tuple in debug_map.iter() { let (name, bit) = match *tuple { (ref a, _, b) => (a, b) }; - if *name == *debug_flag { this_bit = bit; break; } + if *name == debug_flag.as_slice() { + this_bit = bit; + break; + } } if this_bit == 0 { early_error(format!("unknown debug flag: {}", *debug_flag)) @@ -628,7 +631,7 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options { if !parse_only && !no_trans { let unparsed_output_types = matches.opt_strs("emit"); for unparsed_output_type in unparsed_output_types.iter() { - for part in unparsed_output_type.split(',') { + for part in unparsed_output_type.as_slice().split(',') { let output_type = match part.as_slice() { "asm" => link::OutputTypeAssembly, "ir" => link::OutputTypeLlvmAssembly, @@ -765,7 +768,7 @@ mod test { #[test] fn test_switch_implies_cfg_test() { let matches = - &match getopts(["--test".to_owned()], optgroups().as_slice()) { + &match getopts(["--test".to_strbuf()], optgroups().as_slice()) { Ok(m) => m, Err(f) => fail!("test_switch_implies_cfg_test: {}", f.to_err_msg()) }; @@ -780,7 +783,7 @@ mod test { #[test] fn test_switch_implies_cfg_test_unless_cfg_test() { let matches = - &match getopts(["--test".to_owned(), "--cfg=test".to_owned()], + &match getopts(["--test".to_strbuf(), "--cfg=test".to_strbuf()], optgroups().as_slice()) { Ok(m) => m, Err(f) => { diff --git a/src/librustc/driver/mod.rs b/src/librustc/driver/mod.rs index f32a8ec7cd7..c4c145f5bd6 100644 --- a/src/librustc/driver/mod.rs +++ b/src/librustc/driver/mod.rs @@ -35,7 +35,7 @@ pub mod session; pub mod config; -pub fn main_args(args: &[~str]) -> int { +pub fn main_args(args: &[StrBuf]) -> int { let owned_args = args.to_owned(); monitor(proc() run_compiler(owned_args)); 0 @@ -44,7 +44,7 @@ pub fn main_args(args: &[~str]) -> int { static BUG_REPORT_URL: &'static str = "http://static.rust-lang.org/doc/master/complement-bugreport.html"; -fn run_compiler(args: &[~str]) { +fn run_compiler(args: &[StrBuf]) { let matches = match handle_options(Vec::from_slice(args)) { Some(matches) => matches, None => return @@ -73,7 +73,7 @@ fn run_compiler(args: &[~str]) { let ofile = matches.opt_str("o").map(|o| Path::new(o)); let pretty = matches.opt_default("pretty", "normal").map(|a| { - parse_pretty(&sess, a) + parse_pretty(&sess, a.as_slice()) }); match pretty { Some::(ppm) => { @@ -84,7 +84,7 @@ fn run_compiler(args: &[~str]) { } let r = matches.opt_strs("Z"); - if r.contains(&("ls".to_owned())) { + if r.contains(&("ls".to_strbuf())) { match input { FileInput(ref ifile) => { let mut stdout = io::stdout(); @@ -191,17 +191,20 @@ fn describe_codegen_flags() { /// Process command line options. Emits messages as appropirate.If compilation /// should continue, returns a getopts::Matches object parsed from args, otherwise /// returns None. -pub fn handle_options(mut args: Vec<~str>) -> Option { +pub fn handle_options(mut args: Vec) -> Option { // Throw away the first argument, the name of the binary let _binary = args.shift().unwrap(); - if args.is_empty() { usage(); return None; } + if args.is_empty() { + usage(); + return None; + } let matches = match getopts::getopts(args.as_slice(), config::optgroups().as_slice()) { Ok(m) => m, Err(f) => { - early_error(f.to_err_msg()); + early_error(f.to_err_msg().as_slice()); } }; @@ -212,24 +215,24 @@ pub fn handle_options(mut args: Vec<~str>) -> Option { let lint_flags = matches.opt_strs("W").move_iter().collect::>().append( matches.opt_strs("warn").as_slice()); - if lint_flags.iter().any(|x| x == &"help".to_owned()) { + if lint_flags.iter().any(|x| x.as_slice() == "help") { describe_warnings(); return None; } let r = matches.opt_strs("Z"); - if r.iter().any(|x| x == &"help".to_owned()) { + if r.iter().any(|x| x.as_slice() == "help") { describe_debug_flags(); return None; } let cg_flags = matches.opt_strs("C"); - if cg_flags.iter().any(|x| x == &"help".to_owned()) { + if cg_flags.iter().any(|x| x.as_slice() == "help") { describe_codegen_flags(); return None; } - if cg_flags.contains(&"passes=list".to_owned()) { + if cg_flags.contains(&"passes=list".to_strbuf()) { unsafe { ::lib::llvm::llvm::LLVMRustPrintPasses(); } return None; } diff --git a/src/librustc/lib.rs b/src/librustc/lib.rs index 18c59a955b5..678d525ddcb 100644 --- a/src/librustc/lib.rs +++ b/src/librustc/lib.rs @@ -121,5 +121,8 @@ pub mod lib { } pub fn main() { - std::os::set_exit_status(driver::main_args(std::os::args().as_slice())); + let args = std::os::args().iter() + .map(|x| x.to_strbuf()) + .collect::>(); + std::os::set_exit_status(driver::main_args(args.as_slice())); } diff --git a/src/librustdoc/lib.rs b/src/librustdoc/lib.rs index 238d6ae3d6d..2a7808fdf77 100644 --- a/src/librustdoc/lib.rs +++ b/src/librustdoc/lib.rs @@ -137,12 +137,7 @@ pub fn usage(argv0: &str) { } pub fn main_args(args: &[StrBuf]) -> int { - let matches = match getopts::getopts(args.tail() - .iter() - .map(|x| (*x).to_owned()) - .collect::>() - .as_slice(), - opts().as_slice()) { + let matches = match getopts::getopts(args.tail(), opts().as_slice()) { Ok(m) => m, Err(err) => { println!("{}", err.to_err_msg()); @@ -170,7 +165,7 @@ pub fn main_args(args: &[StrBuf]) -> int { let test_args = matches.opt_strs("test-args"); let test_args: Vec = test_args.iter() - .flat_map(|s| s.words()) + .flat_map(|s| s.as_slice().words()) .map(|s| s.to_strbuf()) .collect(); @@ -199,7 +194,7 @@ pub fn main_args(args: &[StrBuf]) -> int { (false, false) => {} } - if matches.opt_strs("passes").as_slice() == &["list".to_owned()] { + if matches.opt_strs("passes").as_slice() == &["list".to_strbuf()] { println!("Available passes for running rustdoc:"); for &(name, _, description) in PASSES.iter() { println!("{:>20s} - {}", name, description); @@ -306,7 +301,7 @@ fn rust_input(cratefile: &str, matches: &getopts::Matches) -> Output { clean::NameValue(ref x, ref value) if "passes" == x.as_slice() => { for pass in value.as_slice().words() { - passes.push(pass.to_owned()); + passes.push(pass.to_strbuf()); } } clean::NameValue(ref x, ref value) @@ -323,15 +318,19 @@ fn rust_input(cratefile: &str, matches: &getopts::Matches) -> Output { } if default_passes { for name in DEFAULT_PASSES.iter().rev() { - passes.unshift(name.to_owned()); + passes.unshift(name.to_strbuf()); } } // Load all plugins/passes into a PluginManager - let path = matches.opt_str("plugin-path").unwrap_or("/tmp/rustdoc/plugins".to_owned()); + let path = matches.opt_str("plugin-path") + .unwrap_or("/tmp/rustdoc/plugins".to_strbuf()); let mut pm = plugins::PluginManager::new(Path::new(path)); for pass in passes.iter() { - let plugin = match PASSES.iter().position(|&(p, _, _)| p == *pass) { + let plugin = match PASSES.iter() + .position(|&(p, _, _)| { + p == pass.as_slice() + }) { Some(i) => PASSES[i].val1(), None => { error!("unknown pass {}, skipping", *pass); diff --git a/src/libtest/lib.rs b/src/libtest/lib.rs index ebdef9f73ae..462c378617b 100644 --- a/src/libtest/lib.rs +++ b/src/libtest/lib.rs @@ -354,11 +354,7 @@ Test Attributes: pub fn parse_opts(args: &[StrBuf]) -> Option { let args_ = args.tail(); let matches = - match getopts::getopts(args_.iter() - .map(|x| x.to_owned()) - .collect::>() - .as_slice(), - optgroups().as_slice()) { + match getopts::getopts(args_.as_slice(), optgroups().as_slice()) { Ok(m) => m, Err(f) => return Some(Err(f.to_err_msg().to_strbuf())) }; @@ -388,7 +384,8 @@ pub fn parse_opts(args: &[StrBuf]) -> Option { let ratchet_metrics = ratchet_metrics.map(|s| Path::new(s)); let ratchet_noise_percent = matches.opt_str("ratchet-noise-percent"); - let ratchet_noise_percent = ratchet_noise_percent.map(|s| from_str::(s).unwrap()); + let ratchet_noise_percent = + ratchet_noise_percent.map(|s| from_str::(s.as_slice()).unwrap()); let save_metrics = matches.opt_str("save-metrics"); let save_metrics = save_metrics.map(|s| Path::new(s)); diff --git a/src/test/bench/shootout-pfib.rs b/src/test/bench/shootout-pfib.rs index a6e579689ed..313671448f8 100644 --- a/src/test/bench/shootout-pfib.rs +++ b/src/test/bench/shootout-pfib.rs @@ -55,7 +55,7 @@ struct Config { fn parse_opts(argv: Vec ) -> Config { let opts = vec!(getopts::optflag("", "stress", "")); - let argv = argv.iter().map(|x| x.to_str()).collect::>(); + let argv = argv.iter().map(|x| x.to_strbuf()).collect::>(); let opt_args = argv.slice(1, argv.len()); match getopts::getopts(opt_args, opts.as_slice()) {