diff options
| author | Huon Wilson <dbau.pp+github@gmail.com> | 2013-06-13 03:02:55 +1000 |
|---|---|---|
| committer | Huon Wilson <dbau.pp+github@gmail.com> | 2013-06-13 10:20:52 +1000 |
| commit | 096f6f56a8178bd7f4b69a2ea909838e782766fb (patch) | |
| tree | 37513f0d39fdfb4d5a702a72abd7423c93c51cdf /src/libsyntax | |
| parent | 641910dc1340b7786fd758282bac88639a58ddcd (diff) | |
| download | rust-096f6f56a8178bd7f4b69a2ea909838e782766fb.tar.gz rust-096f6f56a8178bd7f4b69a2ea909838e782766fb.zip | |
Use @str instead of @~str in libsyntax and librustc. Fixes #5048.
This almost removes the StringRef wrapper, since all strings are Equiv-alent now. Removes a lot of `/* bad */ copy *`'s, and converts several things to be &'static str (the lint table and the intrinsics table). There are many instances of .to_managed(), unfortunately.
Diffstat (limited to 'src/libsyntax')
38 files changed, 432 insertions, 451 deletions
diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index f27ae3b828c..e3182916723 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -84,7 +84,7 @@ pub type Mrk = uint; impl<S:Encoder> Encodable<S> for ident { fn encode(&self, s: &mut S) { - s.emit_str(*interner_get(self.name)); + s.emit_str(interner_get(self.name)); } } @@ -228,9 +228,9 @@ pub type meta_item = spanned<meta_item_>; #[deriving(Eq, Encodable, Decodable)] pub enum meta_item_ { - meta_word(@~str), - meta_list(@~str, ~[@meta_item]), - meta_name_value(@~str, lit), + meta_word(@str), + meta_list(@str, ~[@meta_item]), + meta_name_value(@str, lit), } pub type blk = spanned<blk_>; @@ -634,12 +634,12 @@ pub type lit = spanned<lit_>; #[deriving(Eq, Encodable, Decodable)] pub enum lit_ { - lit_str(@~str), + lit_str(@str), lit_int(i64, int_ty), lit_uint(u64, uint_ty), lit_int_unsuffixed(i64), - lit_float(@~str, float_ty), - lit_float_unsuffixed(@~str), + lit_float(@str, float_ty), + lit_float_unsuffixed(@str), lit_nil, lit_bool(bool), } @@ -819,10 +819,10 @@ pub enum asm_dialect { #[deriving(Eq, Encodable, Decodable)] pub struct inline_asm { - asm: @~str, - clobbers: @~str, - inputs: ~[(@~str, @expr)], - outputs: ~[(@~str, @expr)], + asm: @str, + clobbers: @str, + inputs: ~[(@str, @expr)], + outputs: ~[(@str, @expr)], volatile: bool, alignstack: bool, dialect: asm_dialect diff --git a/src/libsyntax/ast_map.rs b/src/libsyntax/ast_map.rs index 430567e3e2f..ca91d3a4f8c 100644 --- a/src/libsyntax/ast_map.rs +++ b/src/libsyntax/ast_map.rs @@ -58,8 +58,8 @@ pub fn path_to_str_with_sep(p: &[path_elt], sep: &str, itr: @ident_interner) -> ~str { let strs = do p.map |e| { match *e { - path_mod(s) => copy *itr.get(s.name), - path_name(s) => copy *itr.get(s.name) + path_mod(s) => itr.get(s.name), + path_name(s) => itr.get(s.name) } }; strs.connect(sep) @@ -68,9 +68,9 @@ pub fn path_to_str_with_sep(p: &[path_elt], sep: &str, itr: @ident_interner) pub fn path_ident_to_str(p: &path, i: ident, itr: @ident_interner) -> ~str { if p.is_empty() { //FIXME /* FIXME (#2543) */ copy *i - copy *itr.get(i.name) + itr.get(i.name).to_owned() } else { - fmt!("%s::%s", path_to_str(*p, itr), *itr.get(i.name)) + fmt!("%s::%s", path_to_str(*p, itr), itr.get(i.name)) } } @@ -80,8 +80,8 @@ pub fn path_to_str(p: &[path_elt], itr: @ident_interner) -> ~str { pub fn path_elt_to_str(pe: path_elt, itr: @ident_interner) -> ~str { match pe { - path_mod(s) => copy *itr.get(s.name), - path_name(s) => copy *itr.get(s.name) + path_mod(s) => itr.get(s.name).to_owned(), + path_name(s) => itr.get(s.name).to_owned() } } @@ -359,16 +359,16 @@ pub fn node_id_to_str(map: map, id: node_id, itr: @ident_interner) -> ~str { } Some(&node_method(m, _, path)) => { fmt!("method %s in %s (id=%?)", - *itr.get(m.ident.name), path_to_str(*path, itr), id) + itr.get(m.ident.name), path_to_str(*path, itr), id) } Some(&node_trait_method(ref tm, _, path)) => { let m = ast_util::trait_method_to_ty_method(&**tm); fmt!("method %s in %s (id=%?)", - *itr.get(m.ident.name), path_to_str(*path, itr), id) + itr.get(m.ident.name), path_to_str(*path, itr), id) } Some(&node_variant(ref variant, _, path)) => { fmt!("variant %s in %s (id=%?)", - *itr.get(variant.node.name.name), path_to_str(*path, itr), id) + itr.get(variant.node.name.name), path_to_str(*path, itr), id) } Some(&node_expr(expr)) => { fmt!("expr %s (id=%?)", pprust::expr_to_str(expr, itr), id) @@ -384,7 +384,7 @@ pub fn node_id_to_str(map: map, id: node_id, itr: @ident_interner) -> ~str { fmt!("arg (id=%?)", id) } Some(&node_local(ident)) => { - fmt!("local (id=%?, name=%s)", id, *itr.get(ident.name)) + fmt!("local (id=%?, name=%s)", id, itr.get(ident.name)) } Some(&node_block(_)) => { fmt!("block") diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs index 904f35bce5a..d4aa9229319 100644 --- a/src/libsyntax/ast_util.rs +++ b/src/libsyntax/ast_util.rs @@ -28,7 +28,7 @@ use core::iterator::IteratorUtil; pub fn path_name_i(idents: &[ident]) -> ~str { // FIXME: Bad copies (#2543 -- same for everything else that says "bad") - idents.map(|i| copy *token::interner_get(i.name)).connect("::") + idents.map(|i| token::interner_get(i.name)).connect("::") } pub fn path_to_ident(p: @Path) -> ident { copy *p.idents.last() } @@ -815,7 +815,7 @@ mod test { assert_eq!(copy s,~[14]); } - // convert a list of uints to an @~[ident] + // convert a list of uints to an @[ident] // (ignores the interner completely) fn uints_to_idents (uints: &~[uint]) -> @~[ident] { @uints.map(|u|{ ident {name:*u, ctxt: empty_ctxt} }) diff --git a/src/libsyntax/attr.rs b/src/libsyntax/attr.rs index da5874f7b05..1bf21c18886 100644 --- a/src/libsyntax/attr.rs +++ b/src/libsyntax/attr.rs @@ -26,23 +26,23 @@ use extra; /* Constructors */ -pub fn mk_name_value_item_str(name: @~str, value: @~str) +pub fn mk_name_value_item_str(name: @str, value: @str) -> @ast::meta_item { let value_lit = dummy_spanned(ast::lit_str(value)); mk_name_value_item(name, value_lit) } -pub fn mk_name_value_item(name: @~str, value: ast::lit) +pub fn mk_name_value_item(name: @str, value: ast::lit) -> @ast::meta_item { @dummy_spanned(ast::meta_name_value(name, value)) } -pub fn mk_list_item(name: @~str, items: ~[@ast::meta_item]) -> +pub fn mk_list_item(name: @str, items: ~[@ast::meta_item]) -> @ast::meta_item { @dummy_spanned(ast::meta_list(name, items)) } -pub fn mk_word_item(name: @~str) -> @ast::meta_item { +pub fn mk_word_item(name: @str) -> @ast::meta_item { @dummy_spanned(ast::meta_word(name)) } @@ -52,13 +52,13 @@ pub fn mk_attr(item: @ast::meta_item) -> ast::attribute { is_sugared_doc: false }) } -pub fn mk_sugared_doc_attr(text: ~str, +pub fn mk_sugared_doc_attr(text: @str, lo: BytePos, hi: BytePos) -> ast::attribute { let style = doc_comment_style(text); - let lit = spanned(lo, hi, ast::lit_str(@text)); + let lit = spanned(lo, hi, ast::lit_str(text)); let attr = ast::attribute_ { style: style, - value: @spanned(lo, hi, ast::meta_name_value(@~"doc", lit)), + value: @spanned(lo, hi, ast::meta_name_value(@"doc", lit)), is_sugared_doc: true }; spanned(lo, hi, attr) @@ -78,8 +78,8 @@ pub fn attr_metas(attrs: &[ast::attribute]) -> ~[@ast::meta_item] { pub fn desugar_doc_attr(attr: &ast::attribute) -> ast::attribute { if attr.node.is_sugared_doc { let comment = get_meta_item_value_str(attr.node.value).get(); - let meta = mk_name_value_item_str(@~"doc", - @strip_doc_comment_decoration(*comment)); + let meta = mk_name_value_item_str(@"doc", + strip_doc_comment_decoration(comment).to_managed()); mk_attr(meta) } else { *attr @@ -88,11 +88,11 @@ pub fn desugar_doc_attr(attr: &ast::attribute) -> ast::attribute { /* Accessors */ -pub fn get_attr_name(attr: &ast::attribute) -> @~str { +pub fn get_attr_name(attr: &ast::attribute) -> @str { get_meta_item_name(attr.node.value) } -pub fn get_meta_item_name(meta: @ast::meta_item) -> @~str { +pub fn get_meta_item_name(meta: @ast::meta_item) -> @str { match meta.node { ast::meta_word(n) => n, ast::meta_name_value(n, _) => n, @@ -104,7 +104,7 @@ pub fn get_meta_item_name(meta: @ast::meta_item) -> @~str { * Gets the string value if the meta_item is a meta_name_value variant * containing a string, otherwise none */ -pub fn get_meta_item_value_str(meta: @ast::meta_item) -> Option<@~str> { +pub fn get_meta_item_value_str(meta: @ast::meta_item) -> Option<@str> { match meta.node { ast::meta_name_value(_, v) => { match v.node { @@ -130,7 +130,7 @@ pub fn get_meta_item_list(meta: @ast::meta_item) * a tuple containing the name and string value, otherwise `none` */ pub fn get_name_value_str_pair(item: @ast::meta_item) - -> Option<(@~str, @~str)> { + -> Option<(@str, @str)> { match attr::get_meta_item_value_str(item) { Some(value) => { let name = attr::get_meta_item_name(item); @@ -147,7 +147,7 @@ pub fn get_name_value_str_pair(item: @ast::meta_item) pub fn find_attrs_by_name(attrs: &[ast::attribute], name: &str) -> ~[ast::attribute] { do vec::filter_mapped(attrs) |a| { - if name == *get_attr_name(a) { + if name == get_attr_name(a) { Some(*a) } else { None @@ -160,7 +160,7 @@ pub fn find_meta_items_by_name(metas: &[@ast::meta_item], name: &str) -> ~[@ast::meta_item] { let mut rs = ~[]; for metas.each |mi| { - if name == *get_meta_item_name(*mi) { + if name == get_meta_item_name(*mi) { rs.push(*mi) } } @@ -214,7 +214,7 @@ pub fn attrs_contains_name(attrs: &[ast::attribute], name: &str) -> bool { } pub fn first_attr_value_str_by_name(attrs: &[ast::attribute], name: &str) - -> Option<@~str> { + -> Option<@str> { let mattrs = find_attrs_by_name(attrs, name); if mattrs.len() > 0 { @@ -232,7 +232,7 @@ fn last_meta_item_by_name(items: &[@ast::meta_item], name: &str) } pub fn last_meta_item_value_str_by_name(items: &[@ast::meta_item], name: &str) - -> Option<@~str> { + -> Option<@str> { match last_meta_item_by_name(items, name) { Some(item) => { @@ -282,7 +282,7 @@ pub fn remove_meta_items_by_name(items: ~[@ast::meta_item], name: &str) -> ~[@ast::meta_item] { return vec::filter_mapped(items, |item| { - if name != *get_meta_item_name(*item) { + if name != get_meta_item_name(*item) { Some(*item) } else { None @@ -316,8 +316,8 @@ pub fn find_inline_attr(attrs: &[ast::attribute]) -> inline_attr { // FIXME (#2809)---validate the usage of #[inline] and #[inline(always)] do attrs.iter().fold(ia_none) |ia,attr| { match attr.node.value.node { - ast::meta_word(@~"inline") => ia_hint, - ast::meta_list(@~"inline", ref items) => { + ast::meta_word(s) if "inline" == s => ia_hint, + ast::meta_list(s, ref items) if "inline" == s => { if !find_meta_items_by_name(*items, "always").is_empty() { ia_always } else if !find_meta_items_by_name(*items, "never").is_empty() { @@ -341,7 +341,7 @@ pub fn require_unique_names(diagnostic: @span_handler, // FIXME: How do I silence the warnings? --pcw (#2619) if !set.insert(name) { diagnostic.span_fatal(meta.span, - fmt!("duplicate meta item `%s`", *name)); + fmt!("duplicate meta item `%s`", name)); } } } diff --git a/src/libsyntax/codemap.rs b/src/libsyntax/codemap.rs index 68403b2c608..0c09a001d48 100644 --- a/src/libsyntax/codemap.rs +++ b/src/libsyntax/codemap.rs @@ -184,7 +184,7 @@ pub struct Loc { // Actually, *none* of the clients use the filename *or* file field; // perhaps they should just be removed. pub struct LocWithOpt { - filename: ~str, + filename: FileName, line: uint, col: CharPos, file: Option<@FileMap>, @@ -193,7 +193,7 @@ pub struct LocWithOpt { // used to be structural records. Better names, anyone? pub struct FileMapAndLine {fm: @FileMap, line: uint} pub struct FileMapAndBytePos {fm: @FileMap, pos: BytePos} -pub struct NameAndSpan {name: ~str, span: Option<span>} +pub struct NameAndSpan {name: @str, span: Option<span>} impl to_bytes::IterBytes for NameAndSpan { fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool { @@ -227,7 +227,7 @@ impl to_bytes::IterBytes for ExpnInfo { } } -pub type FileName = ~str; +pub type FileName = @str; pub struct FileLines { @@ -261,7 +261,7 @@ pub struct FileMap { /// Extra information used by qquote substr: FileSubstr, /// The complete source code - src: @~str, + src: @str, /// The start position of this source in the CodeMap start_pos: BytePos, /// Locations of lines beginnings in the source code @@ -316,14 +316,14 @@ impl CodeMap { } /// Add a new FileMap to the CodeMap and return it - pub fn new_filemap(&self, filename: FileName, src: @~str) -> @FileMap { + pub fn new_filemap(&self, filename: FileName, src: @str) -> @FileMap { return self.new_filemap_w_substr(filename, FssNone, src); } pub fn new_filemap_w_substr(&self, filename: FileName, substr: FileSubstr, - src: @~str) + src: @str) -> @FileMap { let files = &mut *self.files; let start_pos = if files.len() == 0 { @@ -362,7 +362,7 @@ impl CodeMap { match (loc.file.substr) { FssNone => LocWithOpt { - filename: /* FIXME (#2543) */ copy loc.file.name, + filename: loc.file.name, line: loc.line, col: loc.col, file: Some(loc.file)}, @@ -421,8 +421,8 @@ impl CodeMap { begin.pos.to_uint(), end.pos.to_uint()).to_owned(); } - pub fn get_filemap(&self, filename: ~str) -> @FileMap { - for self.files.each |fm| { if fm.name == filename { return *fm; } } + pub fn get_filemap(&self, filename: &str) -> @FileMap { + for self.files.each |fm| { if filename == fm.name { return *fm; } } //XXjdm the following triggers a mismatched type bug // (or expected function, found _|_) fail!(); // ("asking for " + filename + " which we don't know about"); @@ -532,7 +532,7 @@ mod test { #[test] fn t1 () { let cm = CodeMap::new(); - let fm = cm.new_filemap(~"blork.rs",@~"first line.\nsecond line"); + let fm = cm.new_filemap(@"blork.rs",@"first line.\nsecond line"); fm.next_line(BytePos(0)); assert_eq!(&fm.get_line(0),&~"first line."); // TESTING BROKEN BEHAVIOR: @@ -544,7 +544,7 @@ mod test { #[should_fail] fn t2 () { let cm = CodeMap::new(); - let fm = cm.new_filemap(~"blork.rs",@~"first line.\nsecond line"); + let fm = cm.new_filemap(@"blork.rs",@"first line.\nsecond line"); // TESTING *REALLY* BROKEN BEHAVIOR: fm.next_line(BytePos(0)); fm.next_line(BytePos(10)); diff --git a/src/libsyntax/diagnostic.rs b/src/libsyntax/diagnostic.rs index 1a2569ef787..36100e3f52f 100644 --- a/src/libsyntax/diagnostic.rs +++ b/src/libsyntax/diagnostic.rs @@ -306,8 +306,8 @@ fn highlight_lines(cm: @codemap::CodeMap, fn print_macro_backtrace(cm: @codemap::CodeMap, sp: span) { for sp.expn_info.iter().advance |ei| { - let ss = ei.callee.span.map_default(@~"", |span| @cm.span_to_str(*span)); - print_diagnostic(*ss, note, + let ss = ei.callee.span.map_default(~"", |span| cm.span_to_str(*span)); + print_diagnostic(ss, note, fmt!("in expansion of %s!", ei.callee.name)); let ss = cm.span_to_str(ei.call_site); print_diagnostic(ss, note, "expansion site"); diff --git a/src/libsyntax/ext/asm.rs b/src/libsyntax/ext/asm.rs index f9f9f7216a4..0394ccb3efb 100644 --- a/src/libsyntax/ext/asm.rs +++ b/src/libsyntax/ext/asm.rs @@ -45,7 +45,7 @@ pub fn expand_asm(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree]) cx.cfg(), tts.to_owned()); - let mut asm = ~""; + let mut asm = @""; let mut outputs = ~[]; let mut inputs = ~[]; let mut cons = ~""; @@ -113,7 +113,7 @@ pub fn expand_asm(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree]) p.eat(&token::COMMA); } - let clob = ~"~{" + *p.parse_str() + "}"; + let clob = fmt!("~{%s}", p.parse_str()); clobs.push(clob); } @@ -122,11 +122,11 @@ pub fn expand_asm(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree]) Options => { let option = p.parse_str(); - if "volatile" == *option { + if "volatile" == option { volatile = true; - } else if "alignstack" == *option { + } else if "alignstack" == option { alignstack = true; - } else if "intel" == *option { + } else if "intel" == option { dialect = ast::asm_intel; } @@ -176,8 +176,8 @@ pub fn expand_asm(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree]) MRExpr(@ast::expr { id: cx.next_id(), node: ast::expr_inline_asm(ast::inline_asm { - asm: @asm, - clobbers: @cons, + asm: asm, + clobbers: cons.to_managed(), inputs: inputs, outputs: outputs, volatile: volatile, diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs index 73f68735bcd..8e30a5880d5 100644 --- a/src/libsyntax/ext/base.rs +++ b/src/libsyntax/ext/base.rs @@ -33,7 +33,7 @@ use core::hashmap::HashMap; // ast::mac_invoc_tt. pub struct MacroDef { - name: ~str, + name: @str, ext: SyntaxExtension } @@ -308,18 +308,18 @@ impl ExtCtxt { pub fn set_trace_macros(&self, x: bool) { *self.trace_mac = x } - pub fn str_of(&self, id: ast::ident) -> ~str { - copy *ident_to_str(&id) + pub fn str_of(&self, id: ast::ident) -> @str { + ident_to_str(&id) } pub fn ident_of(&self, st: &str) -> ast::ident { str_to_ident(st) } } -pub fn expr_to_str(cx: @ExtCtxt, expr: @ast::expr, err_msg: ~str) -> ~str { +pub fn expr_to_str(cx: @ExtCtxt, expr: @ast::expr, err_msg: ~str) -> @str { match expr.node { ast::expr_lit(l) => match l.node { - ast::lit_str(s) => copy *s, + ast::lit_str(s) => s, _ => cx.span_fatal(l.span, err_msg) }, _ => cx.span_fatal(expr.span, err_msg) @@ -350,7 +350,7 @@ pub fn check_zero_tts(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree], pub fn get_single_str_from_tts(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree], - name: &str) -> ~str { + name: &str) -> @str { if tts.len() != 1 { cx.span_fatal(sp, fmt!("%s takes 1 argument.", name)); } @@ -538,25 +538,25 @@ mod test { #[test] fn testenv () { let mut a = HashMap::new(); - a.insert (@~"abc",@15); + a.insert (@"abc",@15); let m = MapChain::new(~a); - 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); + 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); let n = m.push_frame(); // old bindings are still present: - assert_eq!(*(n.find(&@~"abc").get()),15); - assert_eq!(*(n.find(&@~"def").get()),16); - n.insert (@~"def",@17); + assert_eq!(*(n.find(&@"abc").get()),15); + assert_eq!(*(n.find(&@"def").get()),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").get()),15); + assert_eq!(*(n.find(&@"def").get()),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); + // 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); } } diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs index 324b909fbb0..dc31a248065 100644 --- a/src/libsyntax/ext/build.rs +++ b/src/libsyntax/ext/build.rs @@ -126,8 +126,8 @@ pub trait AstBuilder { fn expr_vec(&self, sp: span, exprs: ~[@ast::expr]) -> @ast::expr; fn expr_vec_uniq(&self, sp: span, exprs: ~[@ast::expr]) -> @ast::expr; fn expr_vec_slice(&self, sp: span, exprs: ~[@ast::expr]) -> @ast::expr; - fn expr_str(&self, sp: span, s: ~str) -> @ast::expr; - fn expr_str_uniq(&self, sp: span, s: ~str) -> @ast::expr; + fn expr_str(&self, sp: span, s: @str) -> @ast::expr; + fn expr_str_uniq(&self, sp: span, s: @str) -> @ast::expr; fn expr_unreachable(&self, span: span) -> @ast::expr; @@ -215,9 +215,9 @@ pub trait AstBuilder { fn attribute(&self, sp: span, mi: @ast::meta_item) -> ast::attribute; - fn meta_word(&self, sp: span, w: ~str) -> @ast::meta_item; - fn meta_list(&self, sp: span, name: ~str, mis: ~[@ast::meta_item]) -> @ast::meta_item; - fn meta_name_value(&self, sp: span, name: ~str, value: ast::lit_) -> @ast::meta_item; + fn meta_word(&self, sp: span, w: @str) -> @ast::meta_item; + fn meta_list(&self, sp: span, name: @str, mis: ~[@ast::meta_item]) -> @ast::meta_item; + fn meta_name_value(&self, sp: span, name: @str, value: ast::lit_) -> @ast::meta_item; fn view_use(&self, sp: span, vis: ast::visibility, vp: ~[@ast::view_path]) -> @ast::view_item; @@ -521,10 +521,10 @@ impl AstBuilder for @ExtCtxt { fn expr_vec_slice(&self, sp: span, exprs: ~[@ast::expr]) -> @ast::expr { self.expr_vstore(sp, self.expr_vec(sp, exprs), ast::expr_vstore_slice) } - fn expr_str(&self, sp: span, s: ~str) -> @ast::expr { - self.expr_lit(sp, ast::lit_str(@s)) + fn expr_str(&self, sp: span, s: @str) -> @ast::expr { + self.expr_lit(sp, ast::lit_str(s)) } - fn expr_str_uniq(&self, sp: span, s: ~str) -> @ast::expr { + fn expr_str_uniq(&self, sp: span, s: @str) -> @ast::expr { self.expr_vstore(sp, self.expr_str(sp, s), ast::expr_vstore_uniq) } @@ -540,8 +540,8 @@ impl AstBuilder for @ExtCtxt { self.ident_of("fail_with"), ], ~[ - self.expr_str(span, ~"internal error: entered unreachable code"), - self.expr_str(span, copy loc.file.name), + self.expr_str(span, @"internal error: entered unreachable code"), + self.expr_str(span, loc.file.name), self.expr_uint(span, loc.line), ]) } @@ -791,14 +791,14 @@ impl AstBuilder for @ExtCtxt { }) } - fn meta_word(&self, sp: span, w: ~str) -> @ast::meta_item { - @respan(sp, ast::meta_word(@w)) + fn meta_word(&self, sp: span, w: @str) -> @ast::meta_item { + @respan(sp, ast::meta_word(w)) } - fn meta_list(&self, sp: span, name: ~str, mis: ~[@ast::meta_item]) -> @ast::meta_item { - @respan(sp, ast::meta_list(@name, mis)) + fn meta_list(&self, sp: span, name: @str, mis: ~[@ast::meta_item]) -> @ast::meta_item { + @respan(sp, ast::meta_list(name, mis)) } - fn meta_name_value(&self, sp: span, name: ~str, value: ast::lit_) -> @ast::meta_item { - @respan(sp, ast::meta_name_value(@name, respan(sp, value))) + fn meta_name_value(&self, sp: span, name: @str, value: ast::lit_) -> @ast::meta_item { + @respan(sp, ast::meta_name_value(name, respan(sp, value))) } fn view_use(&self, sp: span, diff --git a/src/libsyntax/ext/deriving/decodable.rs b/src/libsyntax/ext/deriving/decodable.rs index 2081f262825..abea7912fc8 100644 --- a/src/libsyntax/ext/deriving/decodable.rs +++ b/src/libsyntax/ext/deriving/decodable.rs @@ -72,7 +72,7 @@ fn decodable_substructure(cx: @ExtCtxt, span: span, }; let read_struct_field = cx.ident_of("read_struct_field"); - let getarg = |name: ~str, field: uint| { + let getarg = |name: @str, field: uint| { cx.expr_method_call(span, blkdecoder, read_struct_field, ~[cx.expr_str(span, name), cx.expr_uint(span, field), @@ -86,7 +86,7 @@ fn decodable_substructure(cx: @ExtCtxt, span: span, } else { let mut fields = vec::with_capacity(n); for uint::range(0, n) |i| { - fields.push(getarg(fmt!("_field%u", i), i)); + fields.push(getarg(fmt!("_field%u", i).to_managed(), i)); } cx.expr_call_ident(span, substr.type_ident, fields) } diff --git a/src/libsyntax/ext/deriving/encodable.rs b/src/libsyntax/ext/deriving/encodable.rs index 2d24de553d6..d7e64caa5c8 100644 --- a/src/libsyntax/ext/deriving/encodable.rs +++ b/src/libsyntax/ext/deriving/encodable.rs @@ -127,7 +127,7 @@ fn encodable_substructure(cx: @ExtCtxt, span: span, for fields.eachi |i, f| { let (name, val) = match *f { (Some(id), e, _) => (cx.str_of(id), e), - (None, e, _) => (fmt!("_field%u", i), e) + (None, e, _) => (fmt!("_field%u", i).to_managed(), e) }; let enc = cx.expr_method_call(span, val, encode, ~[blkencoder]); let lambda = cx.lambda_expr_1(span, enc, blkarg); diff --git a/src/libsyntax/ext/deriving/generic.rs b/src/libsyntax/ext/deriving/generic.rs index 078fd4231ca..5d07171bbb1 100644 --- a/src/libsyntax/ext/deriving/generic.rs +++ b/src/libsyntax/ext/deriving/generic.rs @@ -364,7 +364,7 @@ impl<'self> TraitDef<'self> { let doc_attr = cx.attribute( span, cx.meta_name_value(span, - ~"doc", ast::lit_str(@~"Automatically derived."))); + @"doc", ast::lit_str(@"Automatically derived."))); cx.item( span, ::parse::token::special_idents::clownshoes_extensions, diff --git a/src/libsyntax/ext/deriving/mod.rs b/src/libsyntax/ext/deriving/mod.rs index c091ab8b617..606e372a25d 100644 --- a/src/libsyntax/ext/deriving/mod.rs +++ b/src/libsyntax/ext/deriving/mod.rs @@ -82,23 +82,23 @@ pub fn expand_meta_deriving(cx: @ExtCtxt, meta_word(tname) => { macro_rules! expand(($func:path) => ($func(cx, titem.span, titem, in_items))); - match *tname { - ~"Clone" => expand!(clone::expand_deriving_clone), - ~"DeepClone" => expand!(clone::expand_deriving_deep_clone), + match tname.as_slice() { + "Clone" => expand!(clone::expand_deriving_clone), + "DeepClone" => expand!(clone::expand_deriving_deep_clone), - ~"IterBytes" => expand!(iter_bytes::expand_deriving_iter_bytes), + "IterBytes" => expand!(iter_bytes::expand_deriving_iter_bytes), - ~"Encodable" => expand!(encodable::expand_deriving_encodable), - ~"Decodable" => expand!(decodable::expand_deriving_decodable), + "Encodable" => expand!(encodable::expand_deriving_encodable), + "Decodable" => expand!(decodable::expand_deriving_decodable), - ~"Eq" => expand!(eq::expand_deriving_eq), - ~"TotalEq" => expand!(totaleq::expand_deriving_totaleq), - ~"Ord" => expand!(ord::expand_deriving_ord), - ~"TotalOrd" => expand!(totalord::expand_deriving_totalord), + "Eq" => expand!(eq::expand_deriving_eq), + "TotalEq" => expand!(totaleq::expand_deriving_totaleq), + "Ord" => expand!(ord::expand_deriving_ord), + "TotalOrd" => expand!(totalord::expand_deriving_totalord), - ~"Rand" => expand!(rand::expand_deriving_rand), + "Rand" => expand!(rand::expand_deriving_rand), - ~"ToStr" => expand!(to_str::expand_deriving_to_str), + "ToStr" => expand!(to_str::expand_deriving_to_str), ref tname => { cx.span_err(titem.span, fmt!("unknown \ diff --git a/src/libsyntax/ext/env.rs b/src/libsyntax/ext/env.rs index 4d074b4d0e6..34be6fc8143 100644 --- a/src/libsyntax/ext/env.rs +++ b/src/libsyntax/ext/env.rs @@ -33,8 +33,8 @@ pub fn expand_syntax_ext(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree]) // Option<str> rather than just an maybe-empty string. let e = match os::getenv(var) { - None => cx.expr_str(sp, ~""), - Some(ref s) => cx.expr_str(sp, copy *s) + None => cx.expr_str(sp, @""), + Some(s) => cx.expr_str(sp, s.to_managed()) }; MRExpr(e) } diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs index fe751d279d2..7ca8ab911de 100644 --- a/src/libsyntax/ext/expand.rs +++ b/src/libsyntax/ext/expand.rs @@ -57,7 +57,7 @@ pub fn expand_expr(extsbox: @mut SyntaxEnv, None => { cx.span_fatal( pth.span, - fmt!("macro undefined: '%s'", *extnamestr)) + fmt!("macro undefined: '%s'", extnamestr)) } Some(@SE(NormalTT(SyntaxExpanderTT{ expander: exp, @@ -66,7 +66,7 @@ pub fn expand_expr(extsbox: @mut SyntaxEnv, cx.bt_push(ExpandedFrom(CallInfo { call_site: s, callee: NameAndSpan { - name: copy *extnamestr, + name: extnamestr, span: exp_sp, }, })); @@ -79,7 +79,7 @@ pub fn expand_expr(extsbox: @mut SyntaxEnv, pth.span, fmt!( "non-expr macro in expr pos: %s", - *extnamestr + extnamestr ) ) } @@ -95,7 +95,7 @@ pub fn expand_expr(extsbox: @mut SyntaxEnv, _ => { cx.span_fatal( pth.span, - fmt!("'%s' is not a tt-style macro", *extnamestr) + fmt!("'%s' is not a tt-style macro", extnamestr) ) } } @@ -132,12 +132,12 @@ pub fn expand_mod_items(extsbox: @mut SyntaxEnv, do item.attrs.rev_iter().fold(~[*item]) |items, attr| { let mname = attr::get_attr_name(attr); - match (*extsbox).find(&intern(*mname)) { + match (*extsbox).find(&intern(mname)) { Some(@SE(ItemDecorator(dec_fn))) => { cx.bt_push(ExpandedFrom(CallInfo { call_site: attr.span, callee: NameAndSpan { - name: /*bad*/ copy *mname, + name: mname, span: None } })); @@ -201,7 +201,7 @@ pub fn expand_item(extsbox: @mut SyntaxEnv, // does this attribute list contain "macro_escape" ? pub fn contains_macro_escape (attrs: &[ast::attribute]) -> bool { - attrs.any(|attr| "macro_escape" == *attr::get_attr_name(attr)) + attrs.any(|attr| "macro_escape" == attr::get_attr_name(attr)) } // Support for item-position macro invocations, exactly the same @@ -221,19 +221,19 @@ pub fn expand_item_mac(extsbox: @mut SyntaxEnv, let extnamestr = ident_to_str(extname); let expanded = match (*extsbox).find(&extname.name) { None => cx.span_fatal(pth.span, - fmt!("macro undefined: '%s!'", *extnamestr)), + fmt!("macro undefined: '%s!'", extnamestr)), Some(@SE(NormalTT(ref expand))) => { if it.ident != parse::token::special_idents::invalid { cx.span_fatal(pth.span, fmt!("macro %s! expects no ident argument, \ - given '%s'", *extnamestr, - *ident_to_str(&it.ident))); + given '%s'", extnamestr, + ident_to_str(&it.ident))); } cx.bt_push(ExpandedFrom(CallInfo { call_site: it.span, callee: NameAndSpan { - name: copy *extnamestr, + name: extnamestr, span: expand.span } })); @@ -243,26 +243,25 @@ pub fn expand_item_mac(extsbox: @mut SyntaxEnv, if it.ident == parse::token::special_idents::invalid { cx.span_fatal(pth.span, fmt!("macro %s! expects an ident argument", - *extnamestr)); + extnamestr)); } cx.bt_push(ExpandedFrom(CallInfo { call_site: it.span, callee: NameAndSpan { - name: copy *extnamestr, + name: extnamestr, span: expand.span } })); ((*expand).expander)(cx, it.span, it.ident, tts) } _ => cx.span_fatal( - it.span, fmt!("%s! is not legal in item position", *extnamestr)) + it.span, fmt!("%s! is not legal in item position", extnamestr)) }; let maybe_it = match expanded { MRItem(it) => fld.fold_item(it), MRExpr(_) => cx.span_fatal(pth.span, - ~"expr macro in item position: " - + *extnamestr), + fmt!("expr macro in item position: %s", extnamestr)), MRAny(_, item_maker, _) => item_maker().chain(|i| {fld.fold_item(i)}), MRDef(ref mdef) => { insert_macro(*extsbox,intern(mdef.name), @SE((*mdef).ext)); @@ -319,13 +318,13 @@ pub fn expand_stmt(extsbox: @mut SyntaxEnv, let extnamestr = ident_to_str(extname); let (fully_expanded, sp) = match (*extsbox).find(&extname.name) { None => - cx.span_fatal(pth.span, fmt!("macro undefined: '%s'", *extnamestr)), + cx.span_fatal(pth.span, fmt!("macro undefined: '%s'", extnamestr)), Some(@SE(NormalTT( SyntaxExpanderTT{expander: exp, span: exp_sp}))) => { cx.bt_push(ExpandedFrom(CallInfo { call_site: sp, - callee: NameAndSpan { name: copy *extnamestr, span: exp_sp } + callee: NameAndSpan { name: extnamestr, span: exp_sp } })); let expanded = match exp(cx, mac.span, tts) { MRExpr(e) => @@ -334,7 +333,7 @@ pub fn expand_stmt(extsbox: @mut SyntaxEnv, MRAny(_,_,stmt_mkr) => stmt_mkr(), _ => cx.span_fatal( pth.span, - fmt!("non-stmt macro in stmt pos: %s", *extnamestr)) + fmt!("non-stmt macro in stmt pos: %s", extnamestr)) }; //keep going, outside-in @@ -355,7 +354,7 @@ pub fn expand_stmt(extsbox: @mut SyntaxEnv, _ => { cx.span_fatal(pth.span, - fmt!("'%s' is not a tt-style macro", *extnamestr)) + fmt!("'%s' is not a tt-style macro", extnamestr)) } }; @@ -414,7 +413,7 @@ fn get_block_info(exts : SyntaxEnv) -> BlockInfo { match exts.find_in_topmost_frame(&intern(special_block_name)) { Some(@BlockInfo(bi)) => bi, _ => fail!(fmt!("special identifier %? was bound to a non-BlockInfo", - @~" block")) + @" block")) } } @@ -456,9 +455,9 @@ pub fn new_span(cx: @ExtCtxt, sp: span) -> span { // the default compilation environment. It would be much nicer to use // a mechanism like syntax_quote to ensure hygiene. -pub fn core_macros() -> ~str { +pub fn core_macros() -> @str { return -~"pub mod macros { +@"pub mod macros { macro_rules! ignore (($($x:tt)*) => (())) macro_rules! error ( @@ -679,7 +678,7 @@ pub fn expand_crate(parse_sess: @mut parse::ParseSess, node: attribute_ { style: attr_outer, value: @spanned { - node: meta_word(@~"macro_escape"), + node: meta_word(@"macro_escape"), span: codemap::dummy_sp(), }, is_sugared_doc: false, @@ -687,8 +686,8 @@ pub fn expand_crate(parse_sess: @mut parse::ParseSess, } ]; - let cm = match parse_item_from_source_str(~"<core-macros>", - @core_macros(), + let cm = match parse_item_from_source_str(@"<core-macros>", + core_macros(), copy cfg, attrs, parse_sess) { @@ -764,11 +763,11 @@ mod test { // make sure that fail! is present #[test] fn fail_exists_test () { - let src = ~"fn main() { fail!(\"something appropriately gloomy\");}"; + let src = @"fn main() { fail!(\"something appropriately gloomy\");}"; let sess = parse::new_parse_sess(None); let crate_ast = parse::parse_crate_from_source_str( - ~"<test>", - @src, + @"<test>", + src, ~[],sess); expand_crate(sess,~[],crate_ast); } @@ -779,12 +778,12 @@ mod test { // make sure that macros can leave scope #[should_fail] #[test] fn macros_cant_escape_fns_test () { - let src = ~"fn bogus() {macro_rules! z (() => (3+4))}\ + let src = @"fn bogus() {macro_rules! z (() => (3+4))}\ fn inty() -> int { z!() }"; let sess = parse::new_parse_sess(None); let crate_ast = parse::parse_crate_from_source_str( - ~"<test>", - @src, + @"<test>", + src, ~[],sess); // should fail: expand_crate(sess,~[],crate_ast); @@ -793,12 +792,12 @@ mod test { // make sure that macros can leave scope for modules #[should_fail] #[test] fn macros_cant_escape_mods_test () { - let src = ~"mod foo {macro_rules! z (() => (3+4))}\ + let src = @"mod foo {macro_rules! z (() => (3+4))}\ fn inty() -> int { z!() }"; let sess = parse::new_parse_sess(None); let crate_ast = parse::parse_crate_from_source_str( - ~"<test>", - @src, + @"<test>", + src, ~[],sess); // should fail: expand_crate(sess,~[],crate_ast); @@ -806,19 +805,19 @@ mod test { // macro_escape modules shouldn't cause macros to leave scope #[test] fn macros_can_escape_flattened_mods_test () { - let src = ~"#[macro_escape] mod foo {macro_rules! z (() => (3+4))}\ + let src = @"#[macro_escape] mod foo {macro_rules! z (() => (3+4))}\ fn inty() -> int { z!() }"; let sess = parse::new_parse_sess(None); let crate_ast = parse::parse_crate_from_source_str( - ~"<test>", - @src, + @"<test>", + src, ~[], sess); // should fail: expand_crate(sess,~[],crate_ast); } #[test] fn core_macros_must_parse () { - let src = ~" + let src = @" pub mod macros { macro_rules! ignore (($($x:tt)*) => (())) @@ -828,9 +827,9 @@ mod test { let sess = parse::new_parse_sess(None); let cfg = ~[]; let item_ast = parse::parse_item_from_source_str( - ~"<test>", - @src, - cfg,~[make_dummy_attr (@~"macro_escape")],sess); + @"<test>", + src, + cfg,~[make_dummy_attr (@"macro_escape")],sess); match item_ast { Some(_) => (), // success None => fail!("expected this to parse") @@ -838,9 +837,9 @@ mod test { } #[test] fn test_contains_flatten (){ - let attr1 = make_dummy_attr (@~"foo"); - let attr2 = make_dummy_attr (@~"bar"); - let escape_attr = make_dummy_attr (@~"macro_escape"); + let attr1 = make_dummy_attr (@"foo"); + let attr2 = make_dummy_attr (@"bar"); + let escape_attr = make_dummy_attr (@"macro_escape"); let attrs1 = ~[attr1, escape_attr, attr2]; assert_eq!(contains_macro_escape (attrs1),true); let attrs2 = ~[attr1,attr2]; @@ -848,7 +847,7 @@ mod test { } // make a "meta_word" outer attribute with the given name - fn make_dummy_attr(s: @~str) -> ast::attribute { + fn make_dummy_attr(s: @str) -> ast::attribute { spanned { span:codemap::dummy_sp(), node: attribute_ { @@ -864,7 +863,7 @@ mod test { #[test] fn renaming () { - let maybe_item_ast = string_to_item(@~"fn a() -> int { let b = 13; b }"); + let maybe_item_ast = string_to_item(@"fn a() -> int { let b = 13; b }"); let item_ast = match maybe_item_ast { Some(x) => x, None => fail!("test case fail") @@ -887,7 +886,7 @@ mod test { #[test] fn pat_idents(){ - let pat = string_to_pat(@~"(a,Foo{x:c @ (b,9),y:Bar(4,d)})"); + let pat = string_to_pat(@"(a,Foo{x:c @ (b,9),y:Bar(4,d)})"); let pat_idents = new_name_finder(); let idents = @mut ~[]; ((*pat_idents).visit_pat)(pat, (idents, mk_vt(pat_idents))); diff --git a/src/libsyntax/ext/fmt.rs b/src/libsyntax/ext/fmt.rs index b2ec3684b70..74496ac5359 100644 --- a/src/libsyntax/ext/fmt.rs +++ b/src/libsyntax/ext/fmt.rs @@ -274,12 +274,13 @@ fn pieces_to_expr(cx: @ExtCtxt, sp: span, then there's no need for it to be mutable */ if i == 0 { stms.push(cx.stmt_let(fmt_sp, npieces > 1, - ident, cx.expr_str_uniq(fmt_sp, s))); + ident, cx.expr_str_uniq(fmt_sp, s.to_managed()))); } else { // we call the push_str function because the // bootstrap doesnt't seem to work if we call the // method. - let args = ~[cx.expr_mut_addr_of(fmt_sp, buf()), cx.expr_str(fmt_sp, s)]; + let args = ~[cx.expr_mut_addr_of(fmt_sp, buf()), + cx.expr_str(fmt_sp, s.to_managed())]; let call = cx.expr_call_global(fmt_sp, ~[core_ident, str_ident, @@ -303,7 +304,7 @@ fn pieces_to_expr(cx: @ExtCtxt, sp: span, must be initialized as an empty string */ if i == 0 { stms.push(cx.stmt_let(fmt_sp, true, ident, - cx.expr_str_uniq(fmt_sp, ~""))); + cx.expr_str_uniq(fmt_sp, @""))); } stms.push(cx.stmt_expr(make_new_conv(cx, fmt_sp, conv, args[n], buf()))); diff --git a/src/libsyntax/ext/pipes/check.rs b/src/libsyntax/ext/pipes/check.rs index 694a7c1cf84..c1b9b051ec9 100644 --- a/src/libsyntax/ext/pipes/check.rs +++ b/src/libsyntax/ext/pipes/check.rs @@ -51,7 +51,7 @@ impl proto::visitor<(), (), ()> for @ExtCtxt { } } - fn visit_message(&self, name: ~str, _span: span, _tys: &[@ast::Ty], + fn visit_message(&self, name: @str, _span: span, _tys: &[@ast::Ty], this: state, next: Option<next_state>) { match next { Some(ref next_state) => { diff --git a/src/libsyntax/ext/pipes/parse_proto.rs b/src/libsyntax/ext/pipes/parse_proto.rs index a89fd26df4c..11db1a5da29 100644 --- a/src/libsyntax/ext/pipes/parse_proto.rs +++ b/src/libsyntax/ext/pipes/parse_proto.rs @@ -20,13 +20,13 @@ use parse::token; use parse::token::{interner_get}; pub trait proto_parser { - fn parse_proto(&self, id: ~str) -> protocol; + fn parse_proto(&self, id: @str) -> protocol; fn parse_state(&self, proto: protocol); fn parse_message(&self, state: state); } impl proto_parser for parser::Parser { - fn parse_proto(&self, id: ~str) -> protocol { + fn parse_proto(&self, id: @str) -> protocol { let proto = protocol(id, *self.span); self.parse_seq_to_before_end( @@ -43,7 +43,7 @@ impl proto_parser for parser::Parser { fn parse_state(&self, proto: protocol) { let id = self.parse_ident(); - let name = copy *interner_get(id.name); + let name = interner_get(id.name); self.expect(&token::COLON); let dir = match copy *self.token { @@ -51,9 +51,9 @@ impl proto_parser for parser::Parser { _ => fail!() }; self.bump(); - let dir = match dir { - @~"send" => send, - @~"recv" => recv, + let dir = match dir.as_slice() { + "send" => send, + "recv" => recv, _ => fail!() }; @@ -78,7 +78,7 @@ impl proto_parser for parser::Parser { } fn parse_message(&self, state: state) { - let mname = copy *interner_get(self.parse_ident().name); + let mname = interner_get(self.parse_ident().name); let args = if *self.token == token::LPAREN { self.parse_unspanned_seq( @@ -97,7 +97,7 @@ impl proto_parser for parser::Parser { let next = match *self.token { token::IDENT(_, _) => { - let name = copy *interner_get(self.parse_ident().name); + let name = interner_get(self.parse_ident().name); let ntys = if *self.token == token::LT { self.parse_unspanned_seq( &token::LT, diff --git a/src/libsyntax/ext/pipes/pipec.rs b/src/libsyntax/ext/pipes/pipec.rs index 304c496bbf4..b00f5057dac 100644 --- a/src/libsyntax/ext/pipes/pipec.rs +++ b/src/libsyntax/ext/pipes/pipec.rs @@ -101,7 +101,7 @@ impl gen_send for message { name, vec::append_one( arg_names.map(|x| cx.str_of(*x)), - ~"s").connect(", ")); + @"s").connect(", ")); if !try { body += fmt!("::std::pipes::send(pipe, message);\n"); @@ -114,7 +114,7 @@ impl gen_send for message { } else { ::std::pipes::rt::make_none() } }"); } - let body = cx.parse_expr(body); + let body = cx.parse_expr(body.to_managed()); let mut rty = cx.ty_path(path(~[next.data_name()], span) @@ -123,7 +123,7 @@ impl gen_send for message { rty = cx.ty_option(rty); } - let name = cx.ident_of(if try { ~"try_" + name } else { name } ); + let name = if try {cx.ident_of(~"try_" + name)} else {cx.ident_of(name)}; cx.item_fn_poly(dummy_sp(), name, @@ -173,12 +173,12 @@ impl gen_send for message { } }"); } - let body = cx.parse_expr(body); + let body = cx.parse_expr(body.to_managed()); - let name = if try { ~"try_" + name } else { name }; + let name = if try {cx.ident_of(~"try_" + name)} else {cx.ident_of(name)}; cx.item_fn_poly(dummy_sp(), - cx.ident_of(name), + name, args_ast, if try { cx.ty_option(cx.ty_nil()) @@ -326,7 +326,7 @@ impl gen_init for protocol { start_state.generics.to_source(), start_state.to_ty(cx).to_source(), start_state.to_ty(cx).to_source(), - body.to_source())) + body.to_source()).to_managed()) } fn gen_buffer_init(&self, ext_cx: @ExtCtxt) -> @ast::expr { @@ -358,10 +358,10 @@ impl gen_init for protocol { self.states.map_to_vec( |s| ext_cx.parse_stmt( fmt!("data.%s.set_buffer(buffer)", - s.name))), + s.name).to_managed())), Some(ext_cx.parse_expr(fmt!( "::std::ptr::to_mut_unsafe_ptr(&mut (data.%s))", - self.states[0].name))))); + self.states[0].name).to_managed())))); quote_expr!({ let buffer = $buffer; @@ -459,9 +459,9 @@ impl gen_init for protocol { let allows = cx.attribute( copy self.span, cx.meta_list(copy self.span, - ~"allow", - ~[cx.meta_word(copy self.span, ~"non_camel_case_types"), - cx.meta_word(copy self.span, ~"unused_mut")])); + @"allow", + ~[cx.meta_word(copy self.span, @"non_camel_case_types"), + cx.meta_word(copy self.span, @"unused_mut")])); cx.item_mod(copy self.span, cx.ident_of(copy self.name), ~[allows], ~[], items) } diff --git a/src/libsyntax/ext/pipes/proto.rs b/src/libsyntax/ext/pipes/proto.rs index 0eb0f5c6159..32714f37272 100644 --- a/src/libsyntax/ext/pipes/proto.rs +++ b/src/libsyntax/ext/pipes/proto.rs @@ -38,17 +38,17 @@ impl direction { } pub struct next_state { - state: ~str, + state: @str, tys: ~[@ast::Ty], } // name, span, data, current state, next state -pub struct message(~str, span, ~[@ast::Ty], state, Option<next_state>); +pub struct message(@str, span, ~[@ast::Ty], state, Option<next_state>); impl message { - pub fn name(&mut self) -> ~str { + pub fn name(&mut self) -> @str { match *self { - message(ref id, _, _, _, _) => copy *id + message(id, _, _, _, _) => id } } @@ -70,7 +70,7 @@ pub type state = @state_; pub struct state_ { id: uint, - name: ~str, + name: @str, ident: ast::ident, span: span, dir: direction, @@ -81,7 +81,7 @@ pub struct state_ { impl state_ { pub fn add_message(@self, - name: ~str, + name: @str, span: span, data: ~[@ast::Ty], next: Option<next_state>) { @@ -122,11 +122,11 @@ impl state_ { pub type protocol = @mut protocol_; -pub fn protocol(name: ~str, span: span) -> protocol { +pub fn protocol(name: @str, span: span) -> protocol { @mut protocol_(name, span) } -pub fn protocol_(name: ~str, span: span) -> protocol_ { +pub fn protocol_(name: @str, span: span) -> protocol_ { protocol_ { name: name, span: span, @@ -136,7 +136,7 @@ pub fn protocol_(name: ~str, span: span) -> protocol_ { } pub struct protocol_ { - name: ~str, + name: @str, span: span, states: @mut ~[state], @@ -181,7 +181,7 @@ impl protocol_ { impl protocol_ { pub fn add_state_poly(@mut self, - name: ~str, + name: @str, ident: ast::ident, dir: direction, generics: ast::Generics) @@ -208,7 +208,7 @@ impl protocol_ { pub trait visitor<Tproto, Tstate, Tmessage> { fn visit_proto(&self, proto: protocol, st: &[Tstate]) -> Tproto; fn visit_state(&self, state: state, m: &[Tmessage]) -> Tstate; - fn visit_message(&self, name: ~str, spane: span, tys: &[@ast::Ty], + fn visit_message(&self, name: @str, spane: span, tys: &[@ast::Ty], this: state, next: Option<next_state>) -> Tmessage; } diff --git a/src/libsyntax/ext/quote.rs b/src/libsyntax/ext/quote.rs index 92727c73977..5e47862a1f0 100644 --- a/src/libsyntax/ext/quote.rs +++ b/src/libsyntax/ext/quote.rs @@ -43,8 +43,6 @@ pub mod rt { pub use parse::new_parser_from_tts; pub use codemap::{BytePos, span, dummy_spanned}; - use print::pprust::{item_to_str, ty_to_str}; - pub trait ToTokens { pub fn to_tokens(&self, _cx: @ExtCtxt) -> ~[token_tree]; } @@ -71,132 +69,132 @@ pub mod rt { pub trait ToSource { // Takes a thing and generates a string containing rust code for it. - pub fn to_source(&self) -> ~str; + pub fn to_source(&self) -> @str; } impl ToSource for ast::ident { - fn to_source(&self) -> ~str { - copy *ident_to_str(self) + fn to_source(&self) -> @str { + ident_to_str(self) } } impl ToSource for @ast::item { - fn to_source(&self) -> ~str { - item_to_str(*self, get_ident_interner()) + fn to_source(&self) -> @str { + pprust::item_to_str(*self, get_ident_interner()).to_managed() } } impl<'self> ToSource for &'self [@ast::item] { - fn to_source(&self) -> ~str { - self.map(|i| i.to_source()).connect("\n\n") + fn to_source(&self) -> @str { + self.map(|i| i.to_source()).connect("\n\n").to_managed() } } impl ToSource for @ast::Ty { - fn to_source(&self) -> ~str { - ty_to_str(*self, get_ident_interner()) + fn to_source(&self) -> @str { + pprust::ty_to_str(*self, get_ident_interner()).to_managed() } } impl<'self> ToSource for &'self [@ast::Ty] { - fn to_source(&self) -> ~str { - self.map(|i| i.to_source()).connect(", ") + fn to_source(&self) -> @str { + self.map(|i| i.to_source()).connect(", ").to_managed() } } impl ToSource for Generics { - fn to_source(&self) -> ~str { - pprust::generics_to_str(self, get_ident_interner()) + fn to_source(&self) -> @str { + pprust::generics_to_str(self, get_ident_interner()).to_managed() } } impl ToSource for @ast::expr { - fn to_source(&self) -> ~str { - pprust::expr_to_str(*self, get_ident_interner()) + fn to_source(&self) -> @str { + pprust::expr_to_str(*self, get_ident_interner()).to_managed() } } impl ToSource for ast::blk { - fn to_source(&self) -> ~str { - pprust::block_to_str(self, get_ident_interner()) + fn to_source(&self) -> @str { + pprust::block_to_str(self, get_ident_interner()).to_managed() } } impl<'self> ToSource for &'self str { - fn to_source(&self) -> ~str { - let lit = dummy_spanned(ast::lit_str(@self.to_owned())); - pprust::lit_to_str(@lit) + fn to_source(&self) -> @str { + let lit = dummy_spanned(ast::lit_str(self.to_managed())); + pprust::lit_to_str(@lit).to_managed() } } impl ToSource for int { - fn to_source(&self) -> ~str { + fn to_source(&self) -> @str { let lit = dummy_spanned(ast::lit_int(*self as i64, ast::ty_i)); - pprust::lit_to_str(@lit) + pprust::lit_to_str(@lit).to_managed() } } impl ToSource for i8 { - fn to_source(&self) -> ~str { + fn to_source(&self) -> @str { let lit = dummy_spanned(ast::lit_int(*self as i64, ast::ty_i8)); - pprust::lit_to_str(@lit) + pprust::lit_to_str(@lit).to_managed() } } impl ToSource for i16 { - fn to_source(&self) -> ~str { + fn to_source(&self) -> @str { let lit = dummy_spanned(ast::lit_int(*self as i64, ast::ty_i16)); - pprust::lit_to_str(@lit) + pprust::lit_to_str(@lit).to_managed() } } impl ToSource for i32 { - fn to_source(&self) -> ~str { + fn to_source(&self) -> @str { let lit = dummy_spanned(ast::lit_int(*self as i64, ast::ty_i32)); - pprust::lit_to_str(@lit) + pprust::lit_to_str(@lit).to_managed() } } impl ToSource for i64 { - fn to_source(&self) -> ~str { + fn to_source(&self) -> @str { let lit = dummy_spanned(ast::lit_int(*self as i64, ast::ty_i64)); - pprust::lit_to_str(@lit) + pprust::lit_to_str(@lit).to_managed() } } impl ToSource for uint { - fn to_source(&self) -> ~str { + fn to_source(&self) -> @str { let lit = dummy_spanned(ast::lit_uint(*self as u64, ast::ty_u)); - pprust::lit_to_str(@lit) + pprust::lit_to_str(@lit).to_managed() } } impl ToSource for u8 { - fn to_source(&self) -> ~str { + fn to_source(&self) -> @str { let lit = dummy_spanned(ast::lit_uint(*self as u64, ast::ty_u8)); - pprust::lit_to_str(@lit) + pprust::lit_to_str(@lit).to_managed() } } impl ToSource for u16 { - fn to_source(&self) -> ~str { + fn to_source(&self) -> @str { let lit = dummy_spanned(ast::lit_uint(*self as u64, ast::ty_u16)); - pprust::lit_to_str(@lit) + pprust::lit_to_str(@lit).to_managed() } } impl ToSource for u32 { - fn to_source(&self) -> ~str { + fn to_source(&self) -> @str { let lit = dummy_spanned(ast::lit_uint(*self as u64, ast::ty_u32)); - pprust::lit_to_str(@lit) + pprust::lit_to_str(@lit).to_managed() } } impl ToSource for u64 { - fn to_source(&self) -> ~str { + fn to_source(&self) -> @str { let lit = dummy_spanned(ast::lit_uint(*self as u64, ast::ty_u64)); - pprust::lit_to_str(@lit) + pprust::lit_to_str(@lit).to_managed() } } @@ -317,18 +315,18 @@ pub mod rt { } pub trait ExtParseUtils { - fn parse_item(&self, s: ~str) -> @ast::item; - fn parse_expr(&self, s: ~str) -> @ast::expr; - fn parse_stmt(&self, s: ~str) -> @ast::stmt; - fn parse_tts(&self, s: ~str) -> ~[ast::token_tree]; + fn parse_item(&self, s: @str) -> @ast::item; + fn parse_expr(&self, s: @str) -> @ast::expr; + fn parse_stmt(&self, s: @str) -> @ast::stmt; + fn parse_tts(&self, s: @str) -> ~[ast::token_tree]; } impl ExtParseUtils for ExtCtxt { - fn parse_item(&self, s: ~str) -> @ast::item { + fn parse_item(&self, s: @str) -> @ast::item { let res = parse::parse_item_from_source_str( - ~"<quote expansion>", - @(copy s), + @"<quote expansion>", + s, self.cfg(), ~[], self.parse_sess()); @@ -341,27 +339,27 @@ pub mod rt { } } - fn parse_stmt(&self, s: ~str) -> @ast::stmt { + fn parse_stmt(&self, s: @str) -> @ast::stmt { parse::parse_stmt_from_source_str( - ~"<quote expansion>", - @(copy s), + @"<quote expansion>", + s, self.cfg(), ~[], self.parse_sess()) } - fn parse_expr(&self, s: ~str) -> @ast::expr { + fn parse_expr(&self, s: @str) -> @ast::expr { parse::parse_expr_from_source_str( - ~"<quote expansion>", - @(copy s), + @"<quote expansion>", + s, self.cfg(), self.parse_sess()) } - fn parse_tts(&self, s: ~str) -> ~[ast::token_tree] { + fn parse_tts(&self, s: @str) -> ~[ast::token_tree] { parse::parse_tts_from_source_str( - ~"<quote expansion>", - @(copy s), + @"<quote expansion>", + s, self.cfg(), self.parse_sess()) } diff --git a/src/libsyntax/ext/source_util.rs b/src/libsyntax/ext/source_util.rs index 79018ebd1ea..d92f4e8458b 100644 --- a/src/libsyntax/ext/source_util.rs +++ b/src/libsyntax/ext/source_util.rs @@ -59,21 +59,21 @@ pub fn expand_file(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree]) let topmost = topmost_expn_info(cx.backtrace().get()); let loc = cx.codemap().lookup_char_pos(topmost.call_site.lo); - let filename = copy loc.file.name; + let filename = loc.file.name; base::MRExpr(cx.expr_str(topmost.call_site, filename)) } pub fn expand_stringify(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree]) -> base::MacResult { let s = pprust::tts_to_str(tts, get_ident_interner()); - base::MRExpr(cx.expr_str(sp, s)) + base::MRExpr(cx.expr_str(sp, s.to_managed())) } pub fn expand_mod(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree]) -> base::MacResult { base::check_zero_tts(cx, sp, tts, "module_path!"); base::MRExpr(cx.expr_str(sp, - cx.mod_path().map(|x| cx.str_of(*x)).connect("::"))) + cx.mod_path().map(|x| cx.str_of(*x)).connect("::").to_managed())) } // include! : parse the given file as an expr @@ -94,13 +94,13 @@ pub fn expand_include_str(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree]) let file = get_single_str_from_tts(cx, sp, tts, "include_str!"); let res = io::read_whole_file_str(&res_rel_file(cx, sp, &Path(file))); match res { - result::Ok(_) => { /* Continue. */ } - result::Err(ref e) => { - cx.parse_sess().span_diagnostic.handler().fatal((*e)); + result::Ok(res) => { + base::MRExpr(cx.expr_str(sp, res.to_managed())) + } + result::Err(e) => { + cx.span_fatal(sp, e); } } - - base::MRExpr(cx.expr_str(sp, result::unwrap(res))) } pub fn expand_include_bin(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree]) @@ -131,7 +131,7 @@ fn topmost_expn_info(expn_info: @codemap::ExpnInfo) -> @codemap::ExpnInfo { _ }) => { // Don't recurse into file using "include!" - if *name == ~"include" { + if "include" == *name { expn_info } else { topmost_expn_info(next_expn_info) diff --git a/src/libsyntax/ext/tt/macro_parser.rs b/src/libsyntax/ext/tt/macro_parser.rs index e5a77cc21fb..dd155869526 100644 --- a/src/libsyntax/ext/tt/macro_parser.rs +++ b/src/libsyntax/ext/tt/macro_parser.rs @@ -205,7 +205,7 @@ pub fn nameize(p_s: @mut ParseSess, ms: &[matcher], res: &[@named_match]) } => { if ret_val.contains_key(bind_name) { p_s.span_diagnostic.span_fatal(sp, ~"Duplicated bind name: "+ - *ident_to_str(bind_name)) + ident_to_str(bind_name)) } ret_val.insert(*bind_name, res[idx]); } @@ -373,8 +373,8 @@ pub fn parse( let nts = bb_eis.map(|ei| { match ei.elts[ei.idx].node { match_nonterminal(ref bind,ref name,_) => { - fmt!("%s ('%s')", *ident_to_str(name), - *ident_to_str(bind)) + fmt!("%s ('%s')", ident_to_str(name), + ident_to_str(bind)) } _ => fail!() } }).connect(" or "); @@ -398,7 +398,7 @@ pub fn parse( match ei.elts[ei.idx].node { match_nonterminal(_, ref name, idx) => { ei.matches[idx].push(@matched_nonterminal( - parse_nt(&rust_parser, *ident_to_str(name)))); + parse_nt(&rust_parser, ident_to_str(name)))); ei.idx += 1u; } _ => fail!() diff --git a/src/libsyntax/ext/tt/macro_rules.rs b/src/libsyntax/ext/tt/macro_rules.rs index 7805e736467..491989c77c4 100644 --- a/src/libsyntax/ext/tt/macro_rules.rs +++ b/src/libsyntax/ext/tt/macro_rules.rs @@ -148,7 +148,7 @@ pub fn add_new_extension(cx: @ExtCtxt, |cx, sp, arg| generic_extension(cx, sp, name, arg, *lhses, *rhses); return MRDef(MacroDef{ - name: copy *ident_to_str(&name), + name: ident_to_str(&name), ext: NormalTT(base::SyntaxExpanderTT{expander: exp, span: Some(sp)}) }); } diff --git a/src/libsyntax/ext/tt/transcribe.rs b/src/libsyntax/ext/tt/transcribe.rs index f3bd2d4b8d1..e44c3e67212 100644 --- a/src/libsyntax/ext/tt/transcribe.rs +++ b/src/libsyntax/ext/tt/transcribe.rs @@ -121,7 +121,7 @@ fn lookup_cur_matched(r: &mut TtReader, name: ident) -> @named_match { Some(s) => lookup_cur_matched_by_matched(r, s), None => { r.sp_diag.span_fatal(r.cur_span, fmt!("unknown macro variable `%s`", - *ident_to_str(&name))); + ident_to_str(&name))); } } } @@ -139,8 +139,8 @@ fn lockstep_iter_size(t: &token_tree, r: &mut TtReader) -> lis { lis_contradiction(_) => copy rhs, lis_constraint(r_len, _) if l_len == r_len => copy lhs, lis_constraint(r_len, ref r_id) => { - let l_n = copy *ident_to_str(l_id); - let r_n = copy *ident_to_str(r_id); + let l_n = ident_to_str(l_id); + let r_n = ident_to_str(r_id); lis_contradiction(fmt!("Inconsistent lockstep iteration: \ '%s' has %u items, but '%s' has %u", l_n, l_len, r_n, r_len)) @@ -290,7 +290,7 @@ pub fn tt_next_token(r: &mut TtReader) -> TokenAndSpan { r.sp_diag.span_fatal( copy r.cur_span, /* blame the macro writer */ fmt!("variable '%s' is still repeating at this depth", - *ident_to_str(&ident))); + ident_to_str(&ident))); } } } diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs index 9796fcd8bac..035675e523e 100644 --- a/src/libsyntax/fold.rs +++ b/src/libsyntax/fold.rs @@ -990,7 +990,7 @@ mod test { // make sure idents get transformed everywhere #[test] fn ident_transformation () { let zz_fold = fun_to_ident_folder(to_zz()); - let ast = string_to_crate(@~"#[a] mod b {fn c (d : e, f : g) {h!(i,j,k);l;m}}"); + let ast = string_to_crate(@"#[a] mod b {fn c (d : e, f : g) {h!(i,j,k);l;m}}"); assert_pred!(matches_codepattern, "matches_codepattern", pprust::to_str(zz_fold.fold_crate(ast),fake_print_crate, @@ -1001,7 +1001,7 @@ mod test { // even inside macro defs.... #[test] fn ident_transformation_in_defs () { let zz_fold = fun_to_ident_folder(to_zz()); - let ast = string_to_crate(@~"macro_rules! a {(b $c:expr $(d $e:token)f+ + let ast = string_to_crate(@"macro_rules! a {(b $c:expr $(d $e:token)f+ => (g $(d $d $e)+))} "); assert_pred!(matches_codepattern, "matches_codepattern", diff --git a/src/libsyntax/parse/attr.rs b/src/libsyntax/parse/attr.rs index ed9a83d6b1e..ddcad5c3e8f 100644 --- a/src/libsyntax/parse/attr.rs +++ b/src/libsyntax/parse/attr.rs @@ -46,7 +46,7 @@ impl parser_attr for Parser { } token::DOC_COMMENT(s) => { let attr = ::attr::mk_sugared_doc_attr( - copy *self.id_to_str(s), + self.id_to_str(s), self.span.lo, self.span.hi ); @@ -119,7 +119,7 @@ impl parser_attr for Parser { } token::DOC_COMMENT(s) => { let attr = ::attr::mk_sugared_doc_attr( - copy *self.id_to_str(s), + self.id_to_str(s), self.span.lo, self.span.hi ); diff --git a/src/libsyntax/parse/comments.rs b/src/libsyntax/parse/comments.rs index a6933c16483..5c56ea6c446 100644 --- a/src/libsyntax/parse/comments.rs +++ b/src/libsyntax/parse/comments.rs @@ -320,10 +320,10 @@ pub struct lit { // probably not a good thing. pub fn gather_comments_and_literals(span_diagnostic: @diagnostic::span_handler, - path: ~str, + path: @str, srdr: @io::Reader) -> (~[cmnt], ~[lit]) { - let src = @str::from_bytes(srdr.read_whole_stream()); + let src = str::from_bytes(srdr.read_whole_stream()).to_managed(); let cm = CodeMap::new(); let filemap = cm.new_filemap(path, src); let rdr = lexer::new_low_level_string_reader(span_diagnostic, filemap); diff --git a/src/libsyntax/parse/common.rs b/src/libsyntax/parse/common.rs index 6027d3b07f2..0956fa7225f 100644 --- a/src/libsyntax/parse/common.rs +++ b/src/libsyntax/parse/common.rs @@ -158,7 +158,7 @@ impl Parser { self.fatal( fmt!( "expected `%s`, found `%s`", - *self.id_to_str(kw.to_ident()), + self.id_to_str(kw.to_ident()), self.this_token_to_str() ) ); diff --git a/src/libsyntax/parse/lexer.rs b/src/libsyntax/parse/lexer.rs index 474e93ed11a..d71e2763b5c 100644 --- a/src/libsyntax/parse/lexer.rs +++ b/src/libsyntax/parse/lexer.rs @@ -40,7 +40,7 @@ pub struct TokenAndSpan {tok: token::Token, sp: span} pub struct StringReader { span_diagnostic: @span_handler, - src: @~str, + src: @str, // The absolute offset within the codemap of the next character to read pos: BytePos, // The absolute offset within the codemap of the last character read(curr) @@ -176,7 +176,7 @@ pub fn with_str_from<T>(rdr: @mut StringReader, start: BytePos, f: &fn(s: &str) pub fn bump(rdr: &mut StringReader) { rdr.last_pos = rdr.pos; let current_byte_offset = byte_offset(rdr, rdr.pos).to_uint(); - if current_byte_offset < (*rdr.src).len() { + if current_byte_offset < (rdr.src).len() { assert!(rdr.curr != -1 as char); let last_char = rdr.curr; let next = rdr.src.char_range_at(current_byte_offset); @@ -202,7 +202,7 @@ pub fn is_eof(rdr: @mut StringReader) -> bool { } pub fn nextch(rdr: @mut StringReader) -> char { let offset = byte_offset(rdr, rdr.pos).to_uint(); - if offset < (*rdr.src).len() { + if offset < (rdr.src).len() { return rdr.src.char_at(offset); } else { return -1 as char; } } @@ -801,9 +801,9 @@ mod test { } // open a string reader for the given string - fn setup(teststr: ~str) -> Env { + fn setup(teststr: @str) -> Env { let cm = CodeMap::new(); - let fm = cm.new_filemap(~"zebra.rs", @teststr); + let fm = cm.new_filemap(@"zebra.rs", teststr); let span_handler = diagnostic::mk_span_handler(diagnostic::mk_handler(None),@cm); Env { @@ -813,7 +813,7 @@ mod test { #[test] fn t1 () { let Env {string_reader} = - setup(~"/* my source file */ \ + setup(@"/* my source file */ \ fn main() { io::println(~\"zebra\"); }\n"); let id = str_to_ident("fn"); let tok1 = string_reader.next_token(); @@ -849,14 +849,14 @@ mod test { } #[test] fn doublecolonparsing () { - let env = setup (~"a b"); + let env = setup (@"a b"); check_tokenization (env, ~[mk_ident("a",false), mk_ident("b",false)]); } #[test] fn dcparsing_2 () { - let env = setup (~"a::b"); + let env = setup (@"a::b"); check_tokenization (env, ~[mk_ident("a",true), token::MOD_SEP, @@ -864,7 +864,7 @@ mod test { } #[test] fn dcparsing_3 () { - let env = setup (~"a ::b"); + let env = setup (@"a ::b"); check_tokenization (env, ~[mk_ident("a",false), token::MOD_SEP, @@ -872,7 +872,7 @@ mod test { } #[test] fn dcparsing_4 () { - let env = setup (~"a:: b"); + let env = setup (@"a:: b"); check_tokenization (env, ~[mk_ident("a",true), token::MOD_SEP, @@ -880,28 +880,28 @@ mod test { } #[test] fn character_a() { - let env = setup(~"'a'"); + let env = setup(@"'a'"); let TokenAndSpan {tok, sp: _} = env.string_reader.next_token(); assert_eq!(tok,token::LIT_INT('a' as i64, ast::ty_char)); } #[test] fn character_space() { - let env = setup(~"' '"); + let env = setup(@"' '"); let TokenAndSpan {tok, sp: _} = env.string_reader.next_token(); assert_eq!(tok, token::LIT_INT(' ' as i64, ast::ty_char)); } #[test] fn character_escaped() { - let env = setup(~"'\n'"); + let env = setup(@"'\n'"); let TokenAndSpan {tok, sp: _} = env.string_reader.next_token(); assert_eq!(tok, token::LIT_INT('\n' as i64, ast::ty_char)); } #[test] fn lifetime_name() { - let env = setup(~"'abc"); + let env = setup(@"'abc"); let TokenAndSpan {tok, sp: _} = env.string_reader.next_token(); let id = token::str_to_ident("abc"); diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs index 559bca34f21..5edd2ec4d47 100644 --- a/src/libsyntax/parse/mod.rs +++ b/src/libsyntax/parse/mod.rs @@ -82,38 +82,38 @@ pub fn parse_crate_from_file( } pub fn parse_crate_from_source_str( - name: ~str, - source: @~str, + name: @str, + source: @str, cfg: ast::crate_cfg, sess: @mut ParseSess ) -> @ast::crate { let p = new_parser_from_source_str( sess, /*bad*/ copy cfg, - /*bad*/ copy name, + name, source ); maybe_aborted(p.parse_crate_mod(),p) } pub fn parse_expr_from_source_str( - name: ~str, - source: @~str, + name: @str, + source: @str, cfg: ast::crate_cfg, sess: @mut ParseSess ) -> @ast::expr { let p = new_parser_from_source_str( sess, cfg, - /*bad*/ copy name, + name, source ); maybe_aborted(p.parse_expr(), p) } pub fn parse_item_from_source_str( - name: ~str, - source: @~str, + name: @str, + source: @str, cfg: ast::crate_cfg, attrs: ~[ast::attribute], sess: @mut ParseSess @@ -121,30 +121,30 @@ pub fn parse_item_from_source_str( let p = new_parser_from_source_str( sess, cfg, - /*bad*/ copy name, + name, source ); maybe_aborted(p.parse_item(attrs),p) } pub fn parse_meta_from_source_str( - name: ~str, - source: @~str, + name: @str, + source: @str, cfg: ast::crate_cfg, sess: @mut ParseSess ) -> @ast::meta_item { let p = new_parser_from_source_str( sess, cfg, - /*bad*/ copy name, + name, source ); maybe_aborted(p.parse_meta_item(),p) } pub fn parse_stmt_from_source_str( - name: ~str, - source: @~str, + name: @str, + source: @str, cfg: ast::crate_cfg, attrs: ~[ast::attribute], sess: @mut ParseSess @@ -152,22 +152,22 @@ pub fn parse_stmt_from_source_str( let p = new_parser_from_source_str( sess, cfg, - /*bad*/ copy name, + name, source ); maybe_aborted(p.parse_stmt(attrs),p) } pub fn parse_tts_from_source_str( - name: ~str, - source: @~str, + name: @str, + source: @str, cfg: ast::crate_cfg, sess: @mut ParseSess ) -> ~[ast::token_tree] { let p = new_parser_from_source_str( sess, cfg, - /*bad*/ copy name, + name, source ); *p.quote_depth += 1u; @@ -182,8 +182,8 @@ pub fn parse_tts_from_source_str( // result. pub fn parse_from_source_str<T>( f: &fn(&Parser) -> T, - name: ~str, ss: codemap::FileSubstr, - source: @~str, + name: @str, ss: codemap::FileSubstr, + source: @str, cfg: ast::crate_cfg, sess: @mut ParseSess ) -> T { @@ -213,8 +213,8 @@ pub fn next_node_id(sess: @mut ParseSess) -> node_id { // Create a new parser from a source string pub fn new_parser_from_source_str(sess: @mut ParseSess, cfg: ast::crate_cfg, - name: ~str, - source: @~str) + name: @str, + source: @str) -> Parser { filemap_to_parser(sess,string_to_filemap(sess,source,name),cfg) } @@ -223,9 +223,9 @@ pub fn new_parser_from_source_str(sess: @mut ParseSess, // is specified as a substring of another file. pub fn new_parser_from_source_substr(sess: @mut ParseSess, cfg: ast::crate_cfg, - name: ~str, + name: @str, ss: codemap::FileSubstr, - source: @~str) + source: @str) -> Parser { filemap_to_parser(sess,substring_to_filemap(sess,source,name,ss),cfg) } @@ -275,7 +275,7 @@ pub fn new_parser_from_tts(sess: @mut ParseSess, pub fn file_to_filemap(sess: @mut ParseSess, path: &Path, spanopt: Option<span>) -> @FileMap { match io::read_whole_file_str(path) { - Ok(src) => string_to_filemap(sess, @src, path.to_str()), + Ok(src) => string_to_filemap(sess, src.to_managed(), path.to_str().to_managed()), Err(e) => { match spanopt { Some(span) => sess.span_diagnostic.span_fatal(span, e), @@ -287,14 +287,14 @@ pub fn file_to_filemap(sess: @mut ParseSess, path: &Path, spanopt: Option<span>) // given a session and a string, add the string to // the session's codemap and return the new filemap -pub fn string_to_filemap(sess: @mut ParseSess, source: @~str, path: ~str) +pub fn string_to_filemap(sess: @mut ParseSess, source: @str, path: @str) -> @FileMap { sess.cm.new_filemap(path, source) } // given a session and a string and a path and a FileSubStr, add // the string to the CodeMap and return the new FileMap -pub fn substring_to_filemap(sess: @mut ParseSess, source: @~str, path: ~str, +pub fn substring_to_filemap(sess: @mut ParseSess, source: @str, path: @str, filesubstr: FileSubstr) -> @FileMap { sess.cm.new_filemap_w_substr(path,filesubstr,source) } @@ -349,7 +349,7 @@ mod test { use util::parser_testing::{string_to_stmt, strs_to_idents}; // map a string to tts, return the tt without its parsesess - fn string_to_tts_only(source_str : @~str) -> ~[ast::token_tree] { + fn string_to_tts_only(source_str : @str) -> ~[ast::token_tree] { let (tts,_ps) = string_to_tts_and_sess(source_str); tts } @@ -368,7 +368,7 @@ mod test { } #[test] fn path_exprs_1 () { - assert_eq!(string_to_expr(@~"a"), + assert_eq!(string_to_expr(@"a"), @ast::expr{id:1, node:ast::expr_path(@ast::Path {span:sp(0,1), global:false, @@ -379,7 +379,7 @@ mod test { } #[test] fn path_exprs_2 () { - assert_eq!(string_to_expr(@~"::a::b"), + assert_eq!(string_to_expr(@"::a::b"), @ast::expr{id:1, node:ast::expr_path( @ast::Path {span:sp(0,6), @@ -394,11 +394,11 @@ mod test { // marked as `#[should_fail]`. /*#[should_fail] #[test] fn bad_path_expr_1() { - string_to_expr(@~"::abc::def::return"); + string_to_expr(@"::abc::def::return"); }*/ #[test] fn string_to_tts_1 () { - let (tts,_ps) = string_to_tts_and_sess(@~"fn a (b : int) { b; }"); + let (tts,_ps) = string_to_tts_and_sess(@"fn a (b : int) { b; }"); assert_eq!(to_json_str(@tts), ~"[\ [\"tt_tok\",null,[\"IDENT\",\"fn\",false]],\ @@ -427,7 +427,7 @@ mod test { } #[test] fn ret_expr() { - assert_eq!(string_to_expr(@~"return d"), + assert_eq!(string_to_expr(@"return d"), @ast::expr{id:2, node:ast::expr_ret( Some(@ast::expr{id:1, @@ -443,7 +443,7 @@ mod test { } #[test] fn parse_stmt_1 () { - assert_eq!(string_to_stmt(@~"b;"), + assert_eq!(string_to_stmt(@"b;"), @spanned{ node: ast::stmt_expr(@ast::expr{ id: 1, @@ -465,7 +465,7 @@ mod test { } #[test] fn parse_ident_pat () { - let parser = string_to_parser(@~"b"); + let parser = string_to_parser(@"b"); assert_eq!(parser.parse_pat(), @ast::pat{id:1, // fixme node: ast::pat_ident(ast::bind_infer, @@ -482,7 +482,7 @@ mod test { } #[test] fn parse_arg () { - let parser = string_to_parser(@~"b : int"); + let parser = string_to_parser(@"b : int"); assert_eq!(parser.parse_arg_general(true), ast::arg{ is_mutbl: false, @@ -515,7 +515,7 @@ mod test { #[test] fn parse_fundecl () { // this test depends on the intern order of "fn" and "int", and on the // assignment order of the node_ids. - assert_eq!(string_to_item(@~"fn a (b : int) { b; }"), + assert_eq!(string_to_item(@"fn a (b : int) { b; }"), Some( @ast::item{ident:str_to_ident("a"), attrs:~[], @@ -585,12 +585,12 @@ mod test { #[test] fn parse_exprs () { // just make sure that they parse.... - string_to_expr(@~"3 + 4"); - string_to_expr(@~"a::z.froob(b,@(987+3))"); + string_to_expr(@"3 + 4"); + string_to_expr(@"a::z.froob(b,@(987+3))"); } #[test] fn attrs_fix_bug () { - string_to_item(@~"pub fn mk_file_writer(path: &Path, flags: &[FileFlag]) + string_to_item(@"pub fn mk_file_writer(path: &Path, flags: &[FileFlag]) -> Result<@Writer, ~str> { #[cfg(windows)] fn wb() -> c_int { diff --git a/src/libsyntax/parse/obsolete.rs b/src/libsyntax/parse/obsolete.rs index 61b7f1403e6..cc7b7fab07e 100644 --- a/src/libsyntax/parse/obsolete.rs +++ b/src/libsyntax/parse/obsolete.rs @@ -259,7 +259,7 @@ impl Parser { -> bool { match *token { token::IDENT(sid, _) => { - str::eq_slice(*self.id_to_str(sid), ident) + str::eq_slice(self.id_to_str(sid), ident) } _ => false } diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 8dd80be4f9c..47c0827eb23 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -96,7 +96,6 @@ use core::iterator::IteratorUtil; use core::either::Either; use core::either; use core::hashmap::HashSet; -use core::str; use core::vec; #[deriving(Eq)] @@ -263,7 +262,7 @@ pub struct Parser { /// extra detail when the same error is seen twice obsolete_set: @mut HashSet<ObsoleteSyntax>, /// Used to determine the path to externally loaded source files - mod_path_stack: @mut ~[~str], + mod_path_stack: @mut ~[@str], } @@ -333,7 +332,7 @@ impl Parser { } pub fn get_id(&self) -> node_id { next_node_id(self.sess) } - pub fn id_to_str(&self, id: ident) -> @~str { + pub fn id_to_str(&self, id: ident) -> @str { get_ident_interner().get(id.name) } @@ -2886,7 +2885,7 @@ impl Parser { loop { match *self.token { token::LIFETIME(lifetime) => { - if str::eq_slice(*self.id_to_str(lifetime), "static") { + if "static" == self.id_to_str(lifetime) { result.push(RegionTyParamBound); } else { self.span_err(*self.span, @@ -2898,11 +2897,11 @@ impl Parser { let obsolete_bound = match *self.token { token::MOD_SEP => false, token::IDENT(sid, _) => { - match *self.id_to_str(sid) { - ~"send" | - ~"copy" | - ~"const" | - ~"owned" => { + match self.id_to_str(sid).as_slice() { + "send" | + "copy" | + "const" | + "owned" => { self.obsolete( *self.span, ObsoleteLowerCaseKindBounds); @@ -3364,7 +3363,7 @@ impl Parser { } if fields.len() == 0 { self.fatal(fmt!("Unit-like struct should be written as `struct %s;`", - *get_ident_interner().get(class_name.name))); + get_ident_interner().get(class_name.name))); } self.bump(); } else if *self.token == token::LPAREN { @@ -3580,8 +3579,8 @@ impl Parser { let file_path = match ::attr::first_attr_value_str_by_name( attrs, "path") { - Some(d) => copy *d, - None => copy *default_path + Some(d) => d, + None => default_path }; self.mod_path_stack.push(file_path) } @@ -3599,13 +3598,13 @@ impl Parser { let prefix = prefix.dir_path(); let mod_path_stack = &*self.mod_path_stack; let mod_path = Path(".").push_many(*mod_path_stack); - let default_path = *token::interner_get(id.name) + ".rs"; + let default_path = token::interner_get(id.name).to_owned() + ".rs"; let file_path = match ::attr::first_attr_value_str_by_name( outer_attrs, "path") { Some(d) => { - let path = Path(copy *d); + let path = Path(d); if !path.is_absolute { - mod_path.push(copy *d) + mod_path.push(d) } else { path } @@ -3637,9 +3636,9 @@ impl Parser { let m0 = p0.parse_mod_items(token::EOF, first_item_outer_attrs); return (ast::item_mod(m0), mod_attrs); - fn cdir_path_opt(default: ~str, attrs: ~[ast::attribute]) -> ~str { + fn cdir_path_opt(default: @str, attrs: ~[ast::attribute]) -> @str { match ::attr::first_attr_value_str_by_name(attrs, "path") { - Some(d) => copy *d, + Some(d) => d, None => default } } @@ -4263,7 +4262,7 @@ impl Parser { let first_ident = self.parse_ident(); let mut path = ~[first_ident]; - debug!("parsed view_path: %s", *self.id_to_str(first_ident)); + debug!("parsed view_path: %s", self.id_to_str(first_ident)); match *self.token { token::EQ => { // x = foo::bar @@ -4528,7 +4527,7 @@ impl Parser { config: copy self.cfg }) } - pub fn parse_str(&self) -> @~str { + pub fn parse_str(&self) -> @str { match *self.token { token::LIT_STR(s) => { self.bump(); diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs index 91605db77b5..e7bc67340f0 100644 --- a/src/libsyntax/parse/token.rs +++ b/src/libsyntax/parse/token.rs @@ -21,10 +21,8 @@ use core::cast; use core::char; use core::cmp::Equiv; use core::local_data; -use core::str; use core::rand; use core::rand::RngUtil; -use core::to_bytes; #[deriving(Encodable, Decodable, Eq)] pub enum binop { @@ -180,28 +178,28 @@ pub fn to_str(in: @ident_interner, t: &Token) -> ~str { } LIT_INT_UNSUFFIXED(i) => { i.to_str() } LIT_FLOAT(ref s, t) => { - let mut body = copy *ident_to_str(s); + let mut body = ident_to_str(s).to_owned(); if body.ends_with(".") { body += "0"; // `10.f` is not a float literal } body + ast_util::float_ty_to_str(t) } LIT_FLOAT_UNSUFFIXED(ref s) => { - let mut body = copy *ident_to_str(s); + let mut body = ident_to_str(s).to_owned(); if body.ends_with(".") { body += "0"; // `10.f` is not a float literal } body } - LIT_STR(ref s) => { ~"\"" + ident_to_str(s).escape_default() + "\"" } + LIT_STR(ref s) => { fmt!("\"%s\"", ident_to_str(s).escape_default()) } /* Name components */ - IDENT(s, _) => copy *in.get(s.name), - LIFETIME(s) => fmt!("'%s", *in.get(s.name)), + IDENT(s, _) => in.get(s.name).to_owned(), + LIFETIME(s) => fmt!("'%s", in.get(s.name)), UNDERSCORE => ~"_", /* Other */ - DOC_COMMENT(ref s) => copy *ident_to_str(s), + DOC_COMMENT(ref s) => ident_to_str(s).to_owned(), EOF => ~"<eof>", INTERPOLATED(ref nt) => { match nt { @@ -350,20 +348,6 @@ pub mod special_idents { pub static type_self: ident = ident { name: 34, ctxt: 0}; // `Self` } -pub struct StringRef<'self>(&'self str); - -impl<'self> Equiv<@~str> for StringRef<'self> { - #[inline(always)] - fn equiv(&self, other: &@~str) -> bool { str::eq_slice(**self, **other) } -} - -impl<'self> to_bytes::IterBytes for StringRef<'self> { - #[inline(always)] - fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool { - (**self).iter_bytes(lsb0, f) - } -} - /** * Maps a token to a record specifying the corresponding binary * operator @@ -403,14 +387,14 @@ impl ident_interner { pub fn gensym(&self, val: &str) -> Name { self.interner.gensym(val) } - pub fn get(&self, idx: Name) -> @~str { + pub fn get(&self, idx: Name) -> @str { self.interner.get(idx) } // is this really something that should be exposed? pub fn len(&self) -> uint { self.interner.len() } - pub fn find_equiv<Q:Hash + IterBytes + Equiv<@~str>>(&self, val: &Q) + pub fn find_equiv<Q:Hash + IterBytes + Equiv<@str>>(&self, val: &Q) -> Option<Name> { self.interner.find_equiv(val) } @@ -542,12 +526,12 @@ pub fn gensym(str : &str) -> Name { } // map an interned representation back to a string -pub fn interner_get(name : Name) -> @~str { +pub fn interner_get(name : Name) -> @str { get_ident_interner().get(name) } // maps an identifier to the string that it corresponds to -pub fn ident_to_str(id : &ast::ident) -> @~str { +pub fn ident_to_str(id : &ast::ident) -> @str { interner_get(id.name) } @@ -715,6 +699,6 @@ mod test { #[test] fn t1() { let a = fresh_name("ghi"); io::println(fmt!("interned name: %u,\ntextual name: %s\n", - a,*interner_get(a))); + a,interner_get(a))); } } diff --git a/src/libsyntax/print/pp.rs b/src/libsyntax/print/pp.rs index f6059980697..7853e7e312d 100644 --- a/src/libsyntax/print/pp.rs +++ b/src/libsyntax/print/pp.rs @@ -80,7 +80,7 @@ pub struct begin_t { } pub enum token { - STRING(@~str, int), + STRING(@str, int), BREAK(break_t), BEGIN(begin_t), END, @@ -107,7 +107,7 @@ impl token { pub fn tok_str(t: token) -> ~str { match t { - STRING(s, len) => return fmt!("STR(%s,%d)", *s, len), + STRING(s, len) => return fmt!("STR(%s,%d)", s, len), BREAK(_) => return ~"BREAK", BEGIN(_) => return ~"BEGIN", END => return ~"END", @@ -335,11 +335,11 @@ impl Printer { STRING(s, len) => { if self.scan_stack_empty { debug!("pp STRING('%s')/print ~[%u,%u]", - *s, self.left, self.right); + s, self.left, self.right); self.print(t, len); } else { debug!("pp STRING('%s')/buffer ~[%u,%u]", - *s, self.left, self.right); + s, self.left, self.right); self.advance_right(); self.token[self.right] = t; self.size[self.right] = len; @@ -534,11 +534,11 @@ impl Printer { } } STRING(s, len) => { - debug!("print STRING(%s)", *s); + debug!("print STRING(%s)", s); assert_eq!(L, len); // assert!(L <= space); self.space -= len; - self.print_str(*s); + self.print_str(s); } EOF => { // EOF should never get here. @@ -572,15 +572,15 @@ pub fn end(p: @mut Printer) { p.pretty_print(END); } pub fn eof(p: @mut Printer) { p.pretty_print(EOF); } pub fn word(p: @mut Printer, wrd: &str) { - p.pretty_print(STRING(@/*bad*/ wrd.to_owned(), wrd.len() as int)); + p.pretty_print(STRING(/* bad */ wrd.to_managed(), wrd.len() as int)); } pub fn huge_word(p: @mut Printer, wrd: &str) { - p.pretty_print(STRING(@/*bad*/ wrd.to_owned(), size_infinity)); + p.pretty_print(STRING(/* bad */ wrd.to_managed(), size_infinity)); } pub fn zero_word(p: @mut Printer, wrd: &str) { - p.pretty_print(STRING(@/*bad*/ wrd.to_owned(), 0)); + p.pretty_print(STRING(/* bad */ wrd.to_managed(), 0)); } pub fn spaces(p: @mut Printer, n: uint) { break_offset(p, n, 0); } diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index ea33c04dbb5..c2a537dd10d 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -111,14 +111,14 @@ pub fn print_crate(cm: @CodeMap, intr: @ident_interner, span_diagnostic: @diagnostic::span_handler, crate: @ast::crate, - filename: ~str, + filename: @str, in: @io::Reader, out: @io::Writer, ann: pp_ann, is_expanded: bool) { let (cmnts, lits) = comments::gather_comments_and_literals( span_diagnostic, - copy filename, + filename, in ); let s = @ps { @@ -860,7 +860,7 @@ pub fn print_attribute(s: @ps, attr: ast::attribute) { if attr.node.is_sugared_doc { let meta = attr::attr_meta(attr); let comment = attr::get_meta_item_value_str(meta).get(); - word(s.s, *comment); + word(s.s, comment); } else { word(s.s, "#["); print_meta_item(s, attr.node.value); @@ -1400,10 +1400,10 @@ pub fn print_expr(s: @ps, expr: @ast::expr) { word(s.s, "asm!"); } popen(s); - print_string(s, *a.asm); + print_string(s, a.asm); word_space(s, ":"); for a.outputs.each |&(co, o)| { - print_string(s, *co); + print_string(s, co); popen(s); print_expr(s, o); pclose(s); @@ -1411,14 +1411,14 @@ pub fn print_expr(s: @ps, expr: @ast::expr) { } word_space(s, ":"); for a.inputs.each |&(co, o)| { - print_string(s, *co); + print_string(s, co); popen(s); print_expr(s, o); pclose(s); word_space(s, ","); } word_space(s, ":"); - print_string(s, *a.clobbers); + print_string(s, a.clobbers); pclose(s); } ast::expr_mac(ref m) => print_mac(s, m), @@ -1474,7 +1474,7 @@ pub fn print_decl(s: @ps, decl: @ast::decl) { } pub fn print_ident(s: @ps, ident: ast::ident) { - word(s.s, *ident_to_str(&ident)); + word(s.s, ident_to_str(&ident)); } pub fn print_for_decl(s: @ps, loc: @ast::local, coll: @ast::expr) { @@ -1776,14 +1776,14 @@ pub fn print_generics(s: @ps, generics: &ast::Generics) { pub fn print_meta_item(s: @ps, item: @ast::meta_item) { ibox(s, indent_unit); match item.node { - ast::meta_word(name) => word(s.s, *name), + ast::meta_word(name) => word(s.s, name), ast::meta_name_value(name, value) => { - word_space(s, *name); + word_space(s, name); word_space(s, "="); print_literal(s, @value); } ast::meta_list(name, ref items) => { - word(s.s, *name); + word(s.s, name); popen(s); commasep( s, @@ -1995,7 +1995,7 @@ pub fn print_literal(s: @ps, lit: @ast::lit) { _ => () } match lit.node { - ast::lit_str(st) => print_string(s, *st), + ast::lit_str(st) => print_string(s, st), ast::lit_int(ch, ast::ty_char) => { word(s.s, ~"'" + char::escape_default(ch as char) + "'"); } @@ -2023,9 +2023,9 @@ pub fn print_literal(s: @ps, lit: @ast::lit) { } } ast::lit_float(f, t) => { - word(s.s, *f + ast_util::float_ty_to_str(t)); + word(s.s, f.to_owned() + ast_util::float_ty_to_str(t)); } - ast::lit_float_unsuffixed(f) => word(s.s, *f), + ast::lit_float_unsuffixed(f) => word(s.s, f), ast::lit_nil => word(s.s, "()"), ast::lit_bool(val) => { if val { word(s.s, "true"); } else { word(s.s, "false"); } @@ -2101,7 +2101,7 @@ pub fn print_comment(s: @ps, cmnt: &comments::cmnt) { // We need to do at least one, possibly two hardbreaks. let is_semi = match s.s.last_token() { - pp::STRING(s, _) => *s == ~";", + pp::STRING(s, _) => ";" == s, _ => false }; if is_semi || is_begin(s) || is_end(s) { hardbreak(s.s); } diff --git a/src/libsyntax/util/interner.rs b/src/libsyntax/util/interner.rs index b55050184fe..d4f183ada7b 100644 --- a/src/libsyntax/util/interner.rs +++ b/src/libsyntax/util/interner.rs @@ -19,7 +19,6 @@ use core::prelude::*; use core::cmp::Equiv; use core::hashmap::HashMap; -use syntax::parse::token::StringRef; pub struct Interner<T> { priv map: @mut HashMap<T, uint>, @@ -80,8 +79,8 @@ impl<T:Eq + IterBytes + Hash + Const + Copy> Interner<T> { // A StrInterner differs from Interner<String> in that it accepts // borrowed pointers rather than @ ones, resulting in less allocation. pub struct StrInterner { - priv map: @mut HashMap<@~str, uint>, - priv vect: @mut ~[@~str], + priv map: @mut HashMap<@str, uint>, + priv vect: @mut ~[@str], } // when traits can extend traits, we should extend index<uint,T> to get [] @@ -95,37 +94,38 @@ impl StrInterner { pub fn prefill(init: &[&str]) -> StrInterner { let rv = StrInterner::new(); - for init.each() |v| { rv.intern(*v); } + for init.each |&v| { rv.intern(v); } rv } pub fn intern(&self, val: &str) -> uint { - match self.map.find_equiv(&StringRef(val)) { + match self.map.find_equiv(&val) { Some(&idx) => return idx, None => (), } let new_idx = self.len(); - self.map.insert(@val.to_owned(), new_idx); - self.vect.push(@val.to_owned()); + let val = val.to_managed(); + self.map.insert(val, new_idx); + self.vect.push(val); new_idx } pub fn gensym(&self, val: &str) -> uint { let new_idx = self.len(); // leave out of .map to avoid colliding - self.vect.push(@val.to_owned()); + self.vect.push(val.to_managed()); new_idx } // this isn't "pure" in the traditional sense, because it can go from // failing to returning a value as items are interned. But for typestate, // where we first check a pred and then rely on it, ceasing to fail is ok. - pub fn get(&self, idx: uint) -> @~str { self.vect[idx] } + pub fn get(&self, idx: uint) -> @str { self.vect[idx] } pub fn len(&self) -> uint { let vect = &*self.vect; vect.len() } - pub fn find_equiv<Q:Hash + IterBytes + Equiv<@~str>>(&self, val: &Q) + pub fn find_equiv<Q:Hash + IterBytes + Equiv<@str>>(&self, val: &Q) -> Option<uint> { match self.map.find_equiv(val) { Some(v) => Some(*v), @@ -140,41 +140,41 @@ mod tests { #[test] #[should_fail] fn i1 () { - let i : Interner<@~str> = Interner::new(); + let i : Interner<@str> = Interner::new(); i.get(13); } #[test] fn i2 () { - let i : Interner<@~str> = Interner::new(); + let i : Interner<@str> = Interner::new(); // first one is zero: - assert_eq!(i.intern (@~"dog"), 0); + assert_eq!(i.intern (@"dog"), 0); // re-use gets the same entry: - assert_eq!(i.intern (@~"dog"), 0); + assert_eq!(i.intern (@"dog"), 0); // different string gets a different #: - assert_eq!(i.intern (@~"cat"), 1); - assert_eq!(i.intern (@~"cat"), 1); + assert_eq!(i.intern (@"cat"), 1); + assert_eq!(i.intern (@"cat"), 1); // dog is still at zero - assert_eq!(i.intern (@~"dog"), 0); + assert_eq!(i.intern (@"dog"), 0); // gensym gets 3 - assert_eq!(i.gensym (@~"zebra" ), 2); + assert_eq!(i.gensym (@"zebra" ), 2); // gensym of same string gets new number : - assert_eq!(i.gensym (@~"zebra" ), 3); + assert_eq!(i.gensym (@"zebra" ), 3); // gensym of *existing* string gets new number: - assert_eq!(i.gensym (@~"dog"), 4); - assert_eq!(i.get(0), @~"dog"); - assert_eq!(i.get(1), @~"cat"); - assert_eq!(i.get(2), @~"zebra"); - assert_eq!(i.get(3), @~"zebra"); - assert_eq!(i.get(4), @~"dog"); + assert_eq!(i.gensym (@"dog"), 4); + assert_eq!(i.get(0), @"dog"); + assert_eq!(i.get(1), @"cat"); + assert_eq!(i.get(2), @"zebra"); + assert_eq!(i.get(3), @"zebra"); + assert_eq!(i.get(4), @"dog"); } #[test] fn i3 () { - let i : Interner<@~str> = Interner::prefill([@~"Alan",@~"Bob",@~"Carol"]); - assert_eq!(i.get(0), @~"Alan"); - assert_eq!(i.get(1), @~"Bob"); - assert_eq!(i.get(2), @~"Carol"); - assert_eq!(i.intern(@~"Bob"), 1); + let i : Interner<@str> = Interner::prefill([@"Alan",@"Bob",@"Carol"]); + assert_eq!(i.get(0), @"Alan"); + assert_eq!(i.get(1), @"Bob"); + assert_eq!(i.get(2), @"Carol"); + assert_eq!(i.intern(@"Bob"), 1); } } diff --git a/src/libsyntax/util/parser_testing.rs b/src/libsyntax/util/parser_testing.rs index 76055ca7914..d0961ddbc70 100644 --- a/src/libsyntax/util/parser_testing.rs +++ b/src/libsyntax/util/parser_testing.rs @@ -18,50 +18,50 @@ use parse::token; // map a string to tts, using a made-up filename: return both the token_trees // and the ParseSess -pub fn string_to_tts_and_sess (source_str : @~str) -> (~[ast::token_tree],@mut ParseSess) { +pub fn string_to_tts_and_sess (source_str : @str) -> (~[ast::token_tree],@mut ParseSess) { let ps = new_parse_sess(None); - (filemap_to_tts(ps,string_to_filemap(ps,source_str,~"bogofile")),ps) + (filemap_to_tts(ps,string_to_filemap(ps,source_str,@"bogofile")),ps) } -pub fn string_to_parser_and_sess(source_str: @~str) -> (Parser,@mut ParseSess) { +pub fn string_to_parser_and_sess(source_str: @str) -> (Parser,@mut ParseSess) { let ps = new_parse_sess(None); - (new_parser_from_source_str(ps,~[],~"bogofile",source_str),ps) + (new_parser_from_source_str(ps,~[],@"bogofile",source_str),ps) } // map string to parser (via tts) -pub fn string_to_parser(source_str: @~str) -> Parser { +pub fn string_to_parser(source_str: @str) -> Parser { let (p,_) = string_to_parser_and_sess(source_str); p } -pub fn string_to_crate (source_str : @~str) -> @ast::crate { +pub fn string_to_crate (source_str : @str) -> @ast::crate { string_to_parser(source_str).parse_crate_mod() } // parse a string, return an expr -pub fn string_to_expr (source_str : @~str) -> @ast::expr { +pub fn string_to_expr (source_str : @str) -> @ast::expr { string_to_parser(source_str).parse_expr() } // parse a string, return an item -pub fn string_to_item (source_str : @~str) -> Option<@ast::item> { +pub fn string_to_item (source_str : @str) -> Option<@ast::item> { string_to_parser(source_str).parse_item(~[]) } // parse a string, return an item and the ParseSess -pub fn string_to_item_and_sess (source_str : @~str) -> (Option<@ast::item>,@mut ParseSess) { +pub fn string_to_item_and_sess (source_str : @str) -> (Option<@ast::item>,@mut ParseSess) { let (p,ps) = string_to_parser_and_sess(source_str); (p.parse_item(~[]),ps) } // parse a string, return a stmt -pub fn string_to_stmt(source_str : @~str) -> @ast::stmt { +pub fn string_to_stmt(source_str : @str) -> @ast::stmt { string_to_parser(source_str).parse_stmt(~[]) } // parse a string, return a pat. Uses "irrefutable"... which doesn't // (currently) affect parsing. -pub fn string_to_pat(source_str : @~str) -> @ast::pat { +pub fn string_to_pat(source_str : @str) -> @ast::pat { string_to_parser(source_str).parse_pat() } |