fn parse_expected(line_num: uint, line: &str, re: &Regex) -> Option<ExpectedError> {
re.captures(line).and_then(|caps| {
let adjusts = caps.name("adjusts").len();
- let kind = caps.name("kind").to_ascii().to_lower().into_str().to_string();
+ let kind = caps.name("kind").to_ascii().to_lower().into_str();
let msg = caps.name("msg").trim().to_string();
debug!("line={} kind={} msg={}", line_num, kind, msg);
Some(curr) => {
format!("{}{}{}", path, path_div(), curr)
}
- None => path.to_str().to_string()
+ None => path.to_str()
}
}
~~~
let x: int = 42;
-let y: String = x.to_str().to_string();
+let y: String = x.to_str();
~~~
**String to int**
let mut value: uint;
loop {
value = channel.recv();
- channel.send(value.to_str().to_string());
+ channel.send(value.to_str());
if value == 0 { break; }
}
}
# let mut value: uint;
# loop {
# value = channel.recv();
-# channel.send(value.to_str().to_string());
+# channel.send(value.to_str());
# if value == 0u { break; }
# }
# }
}
impl Printable for int {
- fn to_string(&self) -> String { self.to_str().to_string() }
+ fn to_string(&self) -> String { self.to_str() }
}
fn print(a: Box<Printable>) {
fn to_str(&self) -> String {
match *self {
- Short(ch) => ch.to_str().to_string(),
+ Short(ch) => ch.to_str(),
Long(ref s) => s.to_string()
}
}
#[test]
fn test_to_str() {
fn test(c : Complex64, s: String) {
- assert_eq!(c.to_str().to_string(), s);
+ assert_eq!(c.to_str(), s);
}
test(_0_0i, "0+0i".to_string());
test(_1_0i, "1+0i".to_string());
fn test_to_from_str() {
fn test(r: Rational, s: String) {
assert_eq!(FromStr::from_str(s.as_slice()), Some(r));
- assert_eq!(r.to_str().to_string(), s);
+ assert_eq!(r.to_str(), s);
}
test(_1, "1/1".to_string());
test(_0, "0/1".to_string());
let regex = match entry.node {
ast::ExprLit(lit) => {
match lit.node {
- ast::LitStr(ref s, _) => s.to_str().to_string(),
+ ast::LitStr(ref s, _) => s.to_str(),
_ => {
cx.span_err(entry.span, format!(
"expected string literal but got `{}`",
match node {
pprust::NodeItem(item) => {
try!(pp::space(&mut s.s));
- s.synth_comment(item.id.to_str().to_string())
+ s.synth_comment(item.id.to_str())
}
pprust::NodeBlock(blk) => {
try!(pp::space(&mut s.s));
}
pprust::NodeExpr(expr) => {
try!(pp::space(&mut s.s));
- try!(s.synth_comment(expr.id.to_str().to_string()));
+ try!(s.synth_comment(expr.id.to_str()));
s.pclose()
}
pprust::NodePat(pat) => {
fn variable_name(&self, var: Variable) -> String {
match self.var_kinds.get(var.get()) {
&Local(LocalInfo { ident: nm, .. }) | &Arg(_, nm) => {
- token::get_ident(nm).get().to_str().to_string()
+ token::get_ident(nm).get().to_str()
},
&ImplicitRet => "<implicit-ret>".to_string()
}
fn repr(&self, _tcx: &ty::ctxt) -> String {
match *self {
InteriorField(NamedField(fld)) => {
- token::get_name(fld).get().to_str().to_string()
+ token::get_name(fld).get().to_str()
}
InteriorField(PositionalField(i)) => format!("\\#{:?}", i),
InteriorElement(_) => "[]".to_string(),
_ => ccx.tcx.map.with_path(id, |mut path| {
if attr::contains_name(attrs, "no_mangle") {
// Don't mangle
- path.last().unwrap().to_str().to_string()
+ path.last().unwrap().to_str()
} else {
match weak_lang_items::link_name(attrs) {
Some(name) => name.get().to_string(),
impl InferStr for IntVarValue {
fn inf_str(&self, _cx: &InferCtxt) -> String {
- self.to_str().to_string()
+ self.to_str()
}
}
impl InferStr for ast::FloatTy {
fn inf_str(&self, _cx: &InferCtxt) -> String {
- self.to_str().to_string()
+ self.to_str()
}
}
ty_bare_fn(ref f) => {
bare_fn_to_str(cx, f.fn_style, f.abi, None, &f.sig)
}
- ty_infer(infer_ty) => infer_ty.to_str().to_string(),
+ ty_infer(infer_ty) => infer_ty.to_str(),
ty_err => "[type error]".to_string(),
ty_param(param_ty {idx: id, def_id: did}) => {
let ident = match cx.ty_param_defs.borrow().find(&did.node) {
impl Repr for ty::Variance {
fn repr(&self, _: &ctxt) -> String {
- self.to_str().to_string()
+ // The first `.to_str()` returns a &'static str (it is not an implementation
+ // of the ToStr trait). Because of that, we need to call `.to_str()` again
+ // if we want to have a `String`.
+ self.to_str().to_str()
}
}
impl Repr for abi::Abi {
fn repr(&self, _tcx: &ctxt) -> String {
- self.to_str().to_string()
+ self.to_str()
}
}
impl UserString for abi::Abi {
fn user_string(&self, _tcx: &ctxt) -> String {
- self.to_str().to_string()
+ self.to_str()
}
}
cx.inlined.borrow_mut().get_mut_ref().insert(did);
ret.push(clean::Item {
source: clean::Span::empty(),
- name: Some(fqn.last().unwrap().to_str().to_string()),
+ name: Some(fqn.last().unwrap().to_str()),
attrs: load_attrs(tcx, did),
inner: inner,
visibility: Some(ast::Public),
external_path("Share", &empty)),
};
let fqn = csearch::get_item_path(tcx, did);
- let fqn = fqn.move_iter().map(|i| i.to_str().to_string()).collect();
+ let fqn = fqn.move_iter().map(|i| i.to_str()).collect();
cx.external_paths.borrow_mut().get_mut_ref().insert(did,
(fqn, TypeTrait));
TraitBound(ResolvedPath {
core::NotTyped(_) => return RegionBound,
};
let fqn = csearch::get_item_path(tcx, self.def_id);
- let fqn = fqn.move_iter().map(|i| i.to_str().to_string())
+ let fqn = fqn.move_iter().map(|i| i.to_str())
.collect::<Vec<String>>();
let path = external_path(fqn.last().unwrap().as_slice(),
&self.substs);
};
let fqn = csearch::get_item_path(tcx, did);
let fqn: Vec<String> = fqn.move_iter().map(|i| {
- i.to_str().to_string()
+ i.to_str()
}).collect();
let kind = match ty::get(*self).sty {
ty::ty_struct(..) => TypeStruct,
type_params: Vec::new(),
},
decl: self.decl.clean(),
- abi: self.abi.to_str().to_string(),
+ abi: self.abi.to_str(),
}
}
}
ast::LitStr(ref st, _) => st.get().to_string(),
ast::LitBinary(ref data) => format!("{:?}", data.as_slice()),
ast::LitChar(c) => format!("'{}'", c),
- ast::LitInt(i, _t) => i.to_str().to_string(),
- ast::LitUint(u, _t) => u.to_str().to_string(),
- ast::LitIntUnsuffixed(i) => i.to_str().to_string(),
+ ast::LitInt(i, _t) => i.to_str(),
+ ast::LitUint(u, _t) => u.to_str(),
+ ast::LitIntUnsuffixed(i) => i.to_str(),
ast::LitFloat(ref f, _t) => f.get().to_string(),
ast::LitFloatUnsuffixed(ref f) => f.get().to_string(),
- ast::LitBool(b) => b.to_str().to_string(),
+ ast::LitBool(b) => b.to_str(),
ast::LitNil => "".to_string(),
}
}
} else {
let mut m = decl.bounds
.iter()
- .map(|s| s.to_str().to_string());
+ .map(|s| s.to_str());
format!(
": {}",
m.collect::<Vec<String>>().connect(" + "))
// Transform the contents of the header into a hyphenated string
let id = (s.as_slice().words().map(|s| {
match s.to_ascii_opt() {
- Some(s) => s.to_lower().into_str().to_string(),
+ Some(s) => s.to_lower().into_str(),
None => s.to_string()
}
}).collect::<Vec<String>>().connect("-")).to_string();
}
};
match json::from_reader(&mut input) {
- Err(s) => Err(s.to_str().to_string()),
+ Err(s) => Err(s.to_str()),
Ok(json::Object(obj)) => {
let mut obj = obj;
// Make sure the schema is what we expect
Some(src) => {
// Add this input file to the code map to make it available as
// dependency information
- let filename = file.display().to_str().to_string();
+ let filename = file.display().to_str();
let interned = token::intern_and_get_ident(src);
cx.codemap().new_filemap(filename, src.to_string());
box MacroRulesDefiner {
def: RefCell::new(Some(MacroDef {
- name: token::get_ident(name).to_str().to_string(),
+ name: token::get_ident(name).to_str(),
ext: NormalTT(exp, Some(sp))
}))
} as Box<MacResult>
ast_util::ForceSuffix),
LIT_UINT(u, t) => ast_util::uint_ty_to_str(t, Some(u),
ast_util::ForceSuffix),
- LIT_INT_UNSUFFIXED(i) => { (i as u64).to_str().to_string() }
+ LIT_INT_UNSUFFIXED(i) => { (i as u64).to_str() }
LIT_FLOAT(s, t) => {
let mut body = String::from_str(get_ident(s).get());
if body.as_slice().ends_with(".") {
let filtered = filter_tests(&opts, tests);
assert_eq!(filtered.len(), 1);
- assert_eq!(filtered.get(0).desc.name.to_str().to_string(),
+ assert_eq!(filtered.get(0).desc.name.to_str(),
"1".to_string());
assert!(filtered.get(0).desc.ignore == false);
}
"test::sort_tests".to_string());
for (a, b) in expected.iter().zip(filtered.iter()) {
- assert!(*a == b.desc.name.to_str().to_string());
+ assert!(*a == b.desc.name.to_str());
}
}
'U' => format!("{:02d}", (tm.tm_yday - tm.tm_wday + 7) / 7),
'u' => {
let i = tm.tm_wday as int;
- (if i == 0 { 7 } else { i }).to_str().to_string()
+ (if i == 0 { 7 } else { i }).to_str()
}
'V' => iso_week('V', tm),
'v' => {
format!("{:02d}",
(tm.tm_yday - (tm.tm_wday - 1 + 7) % 7 + 7) / 7)
}
- 'w' => (tm.tm_wday as int).to_str().to_string(),
- 'Y' => (tm.tm_year as int + 1900).to_str().to_string(),
+ 'w' => (tm.tm_wday as int).to_str(),
+ 'Y' => (tm.tm_year as int + 1900).to_str(),
'y' => format!("{:02d}", (tm.tm_year as int + 1900) % 100),
'Z' => "".to_string(), // FIXME(pcwalton): Implement this.
'z' => {
Result<(Option<UserInfo>, String, Option<String>, String), String> {
if !rawurl.starts_with("//") {
// there is no authority.
- return Ok((None, "".to_string(), None, rawurl.to_str().to_string()));
+ return Ok((None, "".to_string(), None, rawurl.to_str()));
}
enum State {
let mut set = f();
timed(&mut self.sequential_strings, || {
for i in range(0u, num_keys) {
- set.insert(i.to_str().to_string());
+ set.insert(i.to_str());
}
for i in range(0u, num_keys) {
- assert!(set.contains(&i.to_str().to_string()));
+ assert!(set.contains(&i.to_str()));
}
})
}
let mut set = f();
timed(&mut self.random_strings, || {
for _ in range(0, num_keys) {
- let s = rng.gen::<uint>().to_str().to_string();
+ let s = rng.gen::<uint>().to_str();
set.insert(s);
}
})
{
let mut set = f();
for i in range(0u, num_keys) {
- set.insert(i.to_str().to_string());
+ set.insert(i.to_str());
}
timed(&mut self.delete_strings, || {
for i in range(0u, num_keys) {
- assert!(set.remove(&i.to_str().to_string()));
+ assert!(set.remove(&i.to_str()));
}
})
}
}
fn transform(x: Option<int>) -> Option<String> {
- x.bind(|n| Some(*n + 1) ).bind(|n| Some(n.to_str().to_string()) )
+ x.bind(|n| Some(*n + 1) ).bind(|n| Some(n.to_str()) )
}
pub fn main() {
impl uint_utils for uint {
fn str(&self) -> String {
- self.to_str().to_string()
+ self.to_str()
}
fn multi(&self, f: |uint|) {
let mut c = 0u;
impl to_str for int {
fn to_str_(&self) -> String {
- self.to_str().to_string()
+ self.to_str()
}
}
}
impl to_str for int {
- fn to_string(&self) -> String { self.to_str().to_string() }
+ fn to_string(&self) -> String { self.to_str() }
}
impl<T:to_str> to_str for Vec<T> {
projects / rust.git / commitdiff