From 70c5a0fbf784d6a89b1c2c50f9fe83093bd21abc Mon Sep 17 00:00:00 2001 From: Patrick Walton Date: Wed, 8 Jan 2014 10:35:15 -0800 Subject: libsyntax: Introduce an `InternedString` type to reduce `@str` in the compiler and use it for attributes --- src/libsyntax/parse/attr.rs | 2 +- src/libsyntax/parse/parser.rs | 12 ++++-- src/libsyntax/parse/token.rs | 87 +++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 96 insertions(+), 5 deletions(-) (limited to 'src/libsyntax/parse') diff --git a/src/libsyntax/parse/attr.rs b/src/libsyntax/parse/attr.rs index e7630a66855..bc9f7e4b195 100644 --- a/src/libsyntax/parse/attr.rs +++ b/src/libsyntax/parse/attr.rs @@ -157,7 +157,7 @@ impl ParserAttr for Parser { fn parse_meta_item(&mut self) -> @ast::MetaItem { let lo = self.span.lo; let ident = self.parse_ident(); - let name = self.id_to_str(ident); + let name = self.id_to_interned_str(ident); match self.token { token::EQ => { self.bump(); diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 642624adfb2..93264f5a6c6 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -71,10 +71,10 @@ use parse::common::{seq_sep_trailing_disallowed, seq_sep_trailing_allowed}; use parse::lexer::Reader; use parse::lexer::TokenAndSpan; use parse::obsolete::*; -use parse::token::{can_begin_expr, get_ident_interner, ident_to_str, is_ident}; -use parse::token::{is_ident_or_path}; -use parse::token::{is_plain_ident, INTERPOLATED, keywords, special_idents}; -use parse::token::{token_to_binop}; +use parse::token::{INTERPOLATED, InternedString, can_begin_expr, get_ident}; +use parse::token::{get_ident_interner, ident_to_str, is_ident}; +use parse::token::{is_ident_or_path, is_plain_ident, keywords}; +use parse::token::{special_idents, token_to_binop}; use parse::token; use parse::{new_sub_parser_from_file, ParseSess}; use opt_vec; @@ -806,6 +806,10 @@ impl Parser { get_ident_interner().get(id.name) } + pub fn id_to_interned_str(&mut self, id: Ident) -> InternedString { + get_ident(id.name) + } + // Is the current token one of the keywords that signals a bare function // type? pub fn token_is_bare_fn_keyword(&mut self) -> bool { diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs index 68e2f44ebb1..97b9b4d53a4 100644 --- a/src/libsyntax/parse/token.rs +++ b/src/libsyntax/parse/token.rs @@ -15,8 +15,10 @@ use parse::token; use util::interner::StrInterner; use util::interner; +use extra::serialize::{Decodable, Decoder, Encodable, Encoder}; use std::cast; use std::char; +use std::fmt; use std::local_data; #[allow(non_camel_case_types)] @@ -525,6 +527,90 @@ pub fn get_ident_interner() -> @IdentInterner { } } +/// Represents a string stored in the task-local interner. Because the +/// interner lives for the life of the task, this can be safely treated as an +/// immortal string, as long as it never crosses between tasks. +/// +/// XXX(pcwalton): You must be careful about what you do in the destructors of +/// objects stored in TLS, because they may run after the interner is +/// destroyed. In particular, they must not access string contents. This can +/// be fixed in the future by just leaking all strings until task death +/// somehow. +#[no_send] +#[deriving(Clone, Eq, IterBytes, TotalEq, TotalOrd)] +pub struct InternedString { + priv string: @str, +} + +#[unsafe_destructor] +impl Drop for InternedString { + fn drop(&mut self) { + // No-op just to make this not implicitly copyable. + } +} + +impl InternedString { + #[inline] + pub fn new(string: &'static str) -> InternedString { + InternedString { + string: string.to_managed(), + } + } + + // NB: Do not make this public. We are trying to remove `@str`. + #[inline] + fn new_from_at_str(string: @str) -> InternedString { + InternedString { + string: string, + } + } + + #[inline] + pub fn get<'a>(&'a self) -> &'a str { + self.string.as_slice() + } +} + +impl fmt::Default for InternedString { + fn fmt(obj: &InternedString, f: &mut fmt::Formatter) { + write!(f.buf, "{}", obj.string); + } +} + +impl<'a> Equiv<&'a str> for InternedString { + fn equiv(&self, other: & &'a str) -> bool { + (*other) == self.string.as_slice() + } +} + +impl Decodable for InternedString { + fn decode(d: &mut D) -> InternedString { + let interner = get_ident_interner(); + get_ident(interner.intern(d.read_str())) + } +} + +impl Encodable for InternedString { + fn encode(&self, e: &mut E) { + e.emit_str(self.string) + } +} + +/// Returns the string contents of an identifier, using the task-local +/// interner. +#[inline] +pub fn get_ident(idx: Name) -> InternedString { + let interner = get_ident_interner(); + InternedString::new_from_at_str(interner.get(idx)) +} + +/// Interns and returns the string contents of an identifier, using the +/// task-local interner. +#[inline] +pub fn intern_and_get_ident(s: &str) -> InternedString { + get_ident(intern(s)) +} + /* for when we don't care about the contents; doesn't interact with TLD or serialization */ pub fn mk_fake_ident_interner() -> @IdentInterner { @@ -532,6 +618,7 @@ pub fn mk_fake_ident_interner() -> @IdentInterner { } // maps a string to its interned representation +#[inline] pub fn intern(str : &str) -> Name { let interner = get_ident_interner(); interner.intern(str) -- cgit 1.4.1-3-g733a5 From 8e52b85d5a6f6e3aaa2f15d7c1e907d0ce8589ee Mon Sep 17 00:00:00 2001 From: Patrick Walton Date: Fri, 10 Jan 2014 14:02:36 -0800 Subject: libsyntax: De-`@str` literal strings in the AST --- src/librustc/driver/driver.rs | 27 ++++++++++--------- src/librustc/driver/session.rs | 27 +++++++++++++------ src/librustc/front/test.rs | 4 ++- src/librustc/metadata/creader.rs | 24 +++++++---------- src/librustc/metadata/decoder.rs | 2 +- src/librustc/metadata/encoder.rs | 8 +++--- src/librustc/middle/check_match.rs | 29 +++++++++++--------- src/librustc/middle/const_eval.rs | 13 ++++----- src/librustc/middle/lang_items.rs | 9 ++++--- src/librustc/middle/trans/_match.rs | 8 +++--- src/librustc/middle/trans/base.rs | 42 ++++++++++++++++------------- src/librustc/middle/trans/common.rs | 16 +++++++----- src/librustc/middle/trans/consts.rs | 6 +++-- src/librustc/middle/trans/context.rs | 15 +++++------ src/librustc/middle/trans/controlflow.rs | 10 ++++--- src/librustc/middle/trans/expr.rs | 8 +++--- src/librustc/middle/trans/foreign.rs | 23 +++++++++------- src/librustc/middle/trans/glue.rs | 14 +++++----- src/librustc/middle/trans/reflect.rs | 34 ++++++++++++++---------- src/librustc/middle/trans/tvec.rs | 32 ++++++++++++++--------- src/librustdoc/clean.rs | 10 ++++--- src/librustdoc/html/render.rs | 6 +++-- src/librustpkg/util.rs | 8 +++--- src/libsyntax/ast.rs | 2 +- src/libsyntax/attr.rs | 45 ++++++++++++++++++-------------- src/libsyntax/ext/asm.rs | 5 ++-- src/libsyntax/ext/base.rs | 12 +++++---- src/libsyntax/ext/build.rs | 20 ++++++++------ src/libsyntax/ext/bytes.rs | 4 +-- src/libsyntax/ext/concat.rs | 9 ++++--- src/libsyntax/ext/deriving/decodable.rs | 40 ++++++++++++++++++++-------- src/libsyntax/ext/deriving/encodable.rs | 41 ++++++++++++++++++++--------- src/libsyntax/ext/deriving/generic.rs | 5 +++- src/libsyntax/ext/deriving/primitive.rs | 11 +++++--- src/libsyntax/ext/deriving/to_str.rs | 44 ++++++++++++++++++++++--------- src/libsyntax/ext/env.rs | 13 ++++++--- src/libsyntax/ext/format.rs | 17 +++++++----- src/libsyntax/ext/quote.rs | 6 +++-- src/libsyntax/ext/source_util.rs | 13 ++++----- src/libsyntax/fold.rs | 4 ++- src/libsyntax/parse/attr.rs | 4 +-- src/libsyntax/parse/comments.rs | 1 - src/libsyntax/parse/parser.rs | 14 ++++++---- src/libsyntax/parse/token.rs | 14 +++++++++- src/libsyntax/print/pprust.rs | 8 +++--- 45 files changed, 432 insertions(+), 275 deletions(-) (limited to 'src/libsyntax/parse') diff --git a/src/librustc/driver/driver.rs b/src/librustc/driver/driver.rs index 2b552aff717..4a3e2ac5e2a 100644 --- a/src/librustc/driver/driver.rs +++ b/src/librustc/driver/driver.rs @@ -74,20 +74,20 @@ pub fn source_name(input: &Input) -> @str { pub fn default_configuration(sess: Session) -> ast::CrateConfig { let tos = match sess.targ_cfg.os { - abi::OsWin32 => @"win32", - abi::OsMacos => @"macos", - abi::OsLinux => @"linux", - abi::OsAndroid => @"android", - abi::OsFreebsd => @"freebsd" + abi::OsWin32 => InternedString::new("win32"), + abi::OsMacos => InternedString::new("macos"), + abi::OsLinux => InternedString::new("linux"), + abi::OsAndroid => InternedString::new("android"), + abi::OsFreebsd => InternedString::new("freebsd"), }; // ARM is bi-endian, however using NDK seems to default // to little-endian unless a flag is provided. let (end,arch,wordsz) = match sess.targ_cfg.arch { - abi::X86 => (@"little", @"x86", @"32"), - abi::X86_64 => (@"little", @"x86_64", @"64"), - abi::Arm => (@"little", @"arm", @"32"), - abi::Mips => (@"big", @"mips", @"32") + abi::X86 => ("little", "x86", "32"), + abi::X86_64 => ("little", "x86_64", "64"), + abi::Arm => ("little", "arm", "32"), + abi::Mips => ("big", "mips", "32") }; let fam = match sess.targ_cfg.os { @@ -99,10 +99,11 @@ pub fn default_configuration(sess: Session) -> return ~[ // Target bindings. attr::mk_word_item(fam.clone()), mk(InternedString::new("target_os"), tos), - mk(InternedString::new("target_family"), fam.get().to_managed()), - mk(InternedString::new("target_arch"), arch), - mk(InternedString::new("target_endian"), end), - mk(InternedString::new("target_word_size"), wordsz), + mk(InternedString::new("target_family"), fam), + mk(InternedString::new("target_arch"), InternedString::new(arch)), + mk(InternedString::new("target_endian"), InternedString::new(end)), + mk(InternedString::new("target_word_size"), + InternedString::new(wordsz)), ]; } diff --git a/src/librustc/driver/session.rs b/src/librustc/driver/session.rs index 57bc9c32cbd..eceed2422b6 100644 --- a/src/librustc/driver/session.rs +++ b/src/librustc/driver/session.rs @@ -417,7 +417,12 @@ pub fn building_library(options: &Options, crate: &ast::Crate) -> bool { } } match syntax::attr::first_attr_value_str_by_name(crate.attrs, "crate_type") { - Some(s) => "lib" == s || "rlib" == s || "dylib" == s || "staticlib" == s, + Some(s) => { + s.equiv(&("lib")) || + s.equiv(&("rlib")) || + s.equiv(&("dylib")) || + s.equiv(&("staticlib")) + } _ => false } } @@ -437,14 +442,20 @@ pub fn collect_outputs(session: &Session, let mut iter = attrs.iter().filter_map(|a| { if a.name().equiv(&("crate_type")) { match a.value_str() { - Some(n) if "rlib" == n => Some(OutputRlib), - Some(n) if "dylib" == n => Some(OutputDylib), - Some(n) if "lib" == n => Some(default_lib_output()), - Some(n) if "staticlib" == n => Some(OutputStaticlib), - Some(n) if "bin" == n => Some(OutputExecutable), + Some(ref n) if n.equiv(&("rlib")) => Some(OutputRlib), + Some(ref n) if n.equiv(&("dylib")) => Some(OutputDylib), + Some(ref n) if n.equiv(&("lib")) => { + Some(default_lib_output()) + } + Some(ref n) if n.equiv(&("staticlib")) => { + Some(OutputStaticlib) + } + Some(ref n) if n.equiv(&("bin")) => Some(OutputExecutable), Some(_) => { - session.add_lint(lint::UnknownCrateType, ast::CRATE_NODE_ID, - a.span, ~"invalid `crate_type` value"); + session.add_lint(lint::UnknownCrateType, + ast::CRATE_NODE_ID, + a.span, + ~"invalid `crate_type` value"); None } _ => { diff --git a/src/librustc/front/test.rs b/src/librustc/front/test.rs index b32568abeb1..6813addc552 100644 --- a/src/librustc/front/test.rs +++ b/src/librustc/front/test.rs @@ -28,6 +28,7 @@ use syntax::fold::Folder; use syntax::fold; use syntax::opt_vec; use syntax::parse::token::InternedString; +use syntax::parse::token; use syntax::print::pprust; use syntax::{ast, ast_util}; use syntax::util::small_vector::SmallVector; @@ -426,7 +427,8 @@ fn mk_test_desc_and_fn_rec(cx: &TestCtxt, test: &Test) -> @ast::Expr { debug!("encoding {}", ast_util::path_name_i(path)); let name_lit: ast::Lit = - nospan(ast::LitStr(ast_util::path_name_i(path).to_managed(), ast::CookedStr)); + nospan(ast::LitStr(token::intern_and_get_ident( + ast_util::path_name_i(path)), ast::CookedStr)); let name_expr = @ast::Expr { id: ast::DUMMY_NODE_ID, diff --git a/src/librustc/metadata/creader.rs b/src/librustc/metadata/creader.rs index 4670757b5c3..c43cf0a6ad7 100644 --- a/src/librustc/metadata/creader.rs +++ b/src/librustc/metadata/creader.rs @@ -27,8 +27,8 @@ use syntax::attr::AttrMetaMethods; use syntax::codemap::{Span, DUMMY_SP}; use syntax::diagnostic::SpanHandler; use syntax::ext::base::{CrateLoader, MacroCrate}; +use syntax::parse::token::{IdentInterner, InternedString}; use syntax::parse::token; -use syntax::parse::token::IdentInterner; use syntax::crateid::CrateId; use syntax::visit; @@ -126,10 +126,8 @@ fn visit_crate(e: &Env, c: &ast::Crate) { for a in c.attrs.iter().filter(|m| m.name().equiv(&("link_args"))) { match a.value_str() { - Some(ref linkarg) => { - cstore.add_used_link_args(*linkarg); - } - None => {/* fallthrough */ } + Some(ref linkarg) => cstore.add_used_link_args(linkarg.get()), + None => { /* fallthrough */ } } } } @@ -214,9 +212,7 @@ fn visit_item(e: &Env, i: &ast::Item) { .to_owned_vec(); for m in link_args.iter() { match m.value_str() { - Some(linkarg) => { - cstore.add_used_link_args(linkarg); - } + Some(linkarg) => cstore.add_used_link_args(linkarg.get()), None => { /* fallthrough */ } } } @@ -238,12 +234,12 @@ fn visit_item(e: &Env, i: &ast::Item) { }).and_then(|a| a.value_str()); let kind = match kind { Some(k) => { - if "static" == k { + if k.equiv(&("static")) { cstore::NativeStatic } else if e.sess.targ_cfg.os == abi::OsMacos && - "framework" == k { + k.equiv(&("framework")) { cstore::NativeFramework - } else if "framework" == k { + } else if k.equiv(&("framework")) { e.sess.span_err(m.span, "native frameworks are only available \ on OSX targets"); @@ -265,13 +261,13 @@ fn visit_item(e: &Env, i: &ast::Item) { e.sess.span_err(m.span, "#[link(...)] specified without \ `name = \"foo\"`"); - @"foo" + InternedString::new("foo") } }; - if n.is_empty() { + if n.get().is_empty() { e.sess.span_err(m.span, "#[link(name = \"\")] given with empty name"); } else { - cstore.add_used_library(n.to_owned(), kind); + cstore.add_used_library(n.get().to_owned(), kind); } } None => {} diff --git a/src/librustc/metadata/decoder.rs b/src/librustc/metadata/decoder.rs index ef6bb30cb51..65eb273b9b8 100644 --- a/src/librustc/metadata/decoder.rs +++ b/src/librustc/metadata/decoder.rs @@ -1050,7 +1050,7 @@ fn get_meta_items(md: ebml::Doc) -> ~[@ast::MetaItem] { let nd = reader::get_doc(meta_item_doc, tag_meta_item_name); let vd = reader::get_doc(meta_item_doc, tag_meta_item_value); let n = token::intern_and_get_ident(nd.as_str_slice()); - let v = vd.as_str_slice().to_managed(); + let v = token::intern_and_get_ident(vd.as_str_slice()); // FIXME (#623): Should be able to decode MetaNameValue variants, // but currently the encoder just drops them items.push(attr::mk_name_value_item_str(n, v)); diff --git a/src/librustc/metadata/encoder.rs b/src/librustc/metadata/encoder.rs index 94a4639975c..d58187641db 100644 --- a/src/librustc/metadata/encoder.rs +++ b/src/librustc/metadata/encoder.rs @@ -1513,15 +1513,15 @@ fn encode_meta_item(ebml_w: &mut writer::Encoder, mi: @MetaItem) { ebml_w.end_tag(); ebml_w.end_tag(); } - MetaNameValue(ref name, value) => { + MetaNameValue(ref name, ref value) => { match value.node { - LitStr(value, _) => { + LitStr(ref value, _) => { ebml_w.start_tag(tag_meta_item_name_value); ebml_w.start_tag(tag_meta_item_name); ebml_w.writer.write(name.get().as_bytes()); ebml_w.end_tag(); ebml_w.start_tag(tag_meta_item_value); - ebml_w.writer.write(value.as_bytes()); + ebml_w.writer.write(value.get().as_bytes()); ebml_w.end_tag(); ebml_w.end_tag(); } @@ -1563,7 +1563,7 @@ fn synthesize_crate_attrs(ecx: &EncodeContext, attr::mk_attr( attr::mk_name_value_item_str( InternedString::new("crate_id"), - ecx.link_meta.crateid.to_str().to_managed())) + token::intern_and_get_ident(ecx.link_meta.crateid.to_str()))) } let mut attrs = ~[]; diff --git a/src/librustc/middle/check_match.rs b/src/librustc/middle/check_match.rs index 38376de4346..228dbb01755 100644 --- a/src/librustc/middle/check_match.rs +++ b/src/librustc/middle/check_match.rs @@ -214,9 +214,14 @@ fn check_exhaustive(cx: &MatchCheckCtxt, sp: Span, pats: ~[@Pat]) { type matrix = ~[~[@Pat]]; -enum useful { useful(ty::t, ctor), useful_, not_useful } +#[deriving(Clone)] +enum useful { + useful(ty::t, ctor), + useful_, + not_useful, +} -#[deriving(Eq)] +#[deriving(Clone, Eq)] enum ctor { single, variant(DefId), @@ -261,7 +266,7 @@ fn is_useful(cx: &MatchCheckCtxt, m: &matrix, v: &[@Pat]) -> useful { val(const_bool(false)), 0u, left_ty) } - ref u => *u, + ref u => (*u).clone(), } } ty::ty_enum(eid, _) => { @@ -269,7 +274,7 @@ fn is_useful(cx: &MatchCheckCtxt, m: &matrix, v: &[@Pat]) -> useful { match is_useful_specialized(cx, m, v, variant(va.id), va.args.len(), left_ty) { not_useful => (), - ref u => return *u, + ref u => return (*u).clone(), } } not_useful @@ -289,7 +294,7 @@ fn is_useful(cx: &MatchCheckCtxt, m: &matrix, v: &[@Pat]) -> useful { for n in iter::range(0u, max_len + 1) { match is_useful_specialized(cx, m, v, vec(n), n, left_ty) { not_useful => (), - ref u => return *u, + ref u => return (*u).clone(), } } not_useful @@ -304,15 +309,15 @@ fn is_useful(cx: &MatchCheckCtxt, m: &matrix, v: &[@Pat]) -> useful { match is_useful(cx, &m.iter().filter_map(|r| default(cx, *r)).collect::(), v.tail()) { - useful_ => useful(left_ty, *ctor), - ref u => *u, + useful_ => useful(left_ty, (*ctor).clone()), + ref u => (*u).clone(), } } } } Some(ref v0_ctor) => { let arity = ctor_arity(cx, v0_ctor, left_ty); - is_useful_specialized(cx, m, v, *v0_ctor, arity, left_ty) + is_useful_specialized(cx, m, v, (*v0_ctor).clone(), arity, left_ty) } } } @@ -329,7 +334,7 @@ fn is_useful_specialized(cx: &MatchCheckCtxt, cx, &ms, specialize(cx, v, &ctor, arity, lty).unwrap()); match could_be_useful { useful_ => useful(lty, ctor), - ref u => *u, + ref u => (*u).clone(), } } @@ -407,7 +412,7 @@ fn missing_ctor(cx: &MatchCheckCtxt, let r = pat_ctor_id(cx, r[0]); for id in r.iter() { if !found.contains(id) { - found.push(*id); + found.push((*id).clone()); } } } @@ -770,8 +775,8 @@ fn specialize(cx: &MatchCheckCtxt, } PatRange(lo, hi) => { let (c_lo, c_hi) = match *ctor_id { - val(ref v) => (*v, *v), - range(ref lo, ref hi) => (*lo, *hi), + val(ref v) => ((*v).clone(), (*v).clone()), + range(ref lo, ref hi) => ((*lo).clone(), (*hi).clone()), single => return Some(r.tail().to_owned()), _ => fail!("type error") }; diff --git a/src/librustc/middle/const_eval.rs b/src/librustc/middle/const_eval.rs index 59057128555..68ac2f11bda 100644 --- a/src/librustc/middle/const_eval.rs +++ b/src/librustc/middle/const_eval.rs @@ -16,10 +16,11 @@ use middle::ty; use middle::typeck::astconv; use middle; -use syntax::{ast, ast_map, ast_util}; -use syntax::visit; -use syntax::visit::Visitor; use syntax::ast::*; +use syntax::parse::token::InternedString; +use syntax::visit::Visitor; +use syntax::visit; +use syntax::{ast, ast_map, ast_util}; use std::cell::RefCell; use std::hashmap::HashMap; @@ -319,7 +320,7 @@ pub enum const_val { const_float(f64), const_int(i64), const_uint(u64), - const_str(@str), + const_str(InternedString), const_binary(@[u8]), const_bool(bool) } @@ -508,7 +509,7 @@ pub fn eval_const_expr_partial(tcx: &T, e: &Expr) pub fn lit_to_const(lit: &Lit) -> const_val { match lit.node { - LitStr(s, _) => const_str(s), + LitStr(ref s, _) => const_str((*s).clone()), LitBinary(data) => const_binary(data), LitChar(n) => const_uint(n as u64), LitInt(n, _) => const_int(n), @@ -530,7 +531,7 @@ pub fn compare_const_vals(a: &const_val, b: &const_val) -> Option { (&const_int(a), &const_int(b)) => compare_vals(a, b), (&const_uint(a), &const_uint(b)) => compare_vals(a, b), (&const_float(a), &const_float(b)) => compare_vals(a, b), - (&const_str(a), &const_str(b)) => compare_vals(a, b), + (&const_str(ref a), &const_str(ref b)) => compare_vals(a, b), (&const_bool(a), &const_bool(b)) => compare_vals(a, b), _ => None } diff --git a/src/librustc/middle/lang_items.rs b/src/librustc/middle/lang_items.rs index 34f8bad9666..2b100ffa4c9 100644 --- a/src/librustc/middle/lang_items.rs +++ b/src/librustc/middle/lang_items.rs @@ -26,8 +26,9 @@ use middle::ty::{BuiltinBound, BoundFreeze, BoundPod, BoundSend, BoundSized}; use syntax::ast; use syntax::ast_util::local_def; use syntax::attr::AttrMetaMethods; -use syntax::visit; +use syntax::parse::token::InternedString; use syntax::visit::Visitor; +use syntax::visit; use std::hashmap::HashMap; use std::iter::Enumerate; @@ -182,11 +183,11 @@ impl LanguageItemCollector { } } -pub fn extract(attrs: &[ast::Attribute]) -> Option<@str> { +pub fn extract(attrs: &[ast::Attribute]) -> Option { for attribute in attrs.iter() { match attribute.name_str_pair() { - Some((ref key, value)) if key.equiv(&("lang")) => { - return Some(value); + Some((ref key, ref value)) if key.equiv(&("lang")) => { + return Some((*value).clone()); } Some(..) | None => {} } diff --git a/src/librustc/middle/trans/_match.rs b/src/librustc/middle/trans/_match.rs index 7bc37d4e695..12183632948 100644 --- a/src/librustc/middle/trans/_match.rs +++ b/src/librustc/middle/trans/_match.rs @@ -229,6 +229,7 @@ use syntax::ast::Ident; use syntax::ast_util::path_to_ident; use syntax::ast_util; use syntax::codemap::{Span, DUMMY_SP}; +use syntax::parse::token::InternedString; // An option identifying a literal: either a unit-like struct or an // expression. @@ -1174,7 +1175,7 @@ fn any_tuple_struct_pat(bcx: &Block, m: &[Match], col: uint) -> bool { struct DynamicFailureHandler<'a> { bcx: &'a Block<'a>, sp: Span, - msg: @str, + msg: InternedString, finished: @Cell>, } @@ -1187,7 +1188,7 @@ impl<'a> DynamicFailureHandler<'a> { let fcx = self.bcx.fcx; let fail_cx = fcx.new_block(false, "case_fallthrough", None); - controlflow::trans_fail(fail_cx, Some(self.sp), self.msg); + controlflow::trans_fail(fail_cx, Some(self.sp), self.msg.clone()); self.finished.set(Some(fail_cx.llbb)); fail_cx.llbb } @@ -1891,7 +1892,8 @@ fn trans_match_inner<'a>(scope_cx: &'a Block<'a>, let fail_handler = ~DynamicFailureHandler { bcx: scope_cx, sp: discr_expr.span, - msg: @"scrutinizing value that can't exist", + msg: InternedString::new("scrutinizing value that can't \ + exist"), finished: fail_cx, }; DynamicFailureHandlerClass(fail_handler) diff --git a/src/librustc/middle/trans/base.rs b/src/librustc/middle/trans/base.rs index 38b34cd13bc..42123f536d6 100644 --- a/src/librustc/middle/trans/base.rs +++ b/src/librustc/middle/trans/base.rs @@ -79,13 +79,18 @@ use std::local_data; use syntax::ast_map::{PathName, PathPrettyName, path_elem_to_str}; use syntax::ast_util::{local_def, is_local}; use syntax::attr; +use syntax::abi::{X86, X86_64, Arm, Mips, Rust, RustIntrinsic, OsWin32}; +use syntax::attr::AttrMetaMethods; use syntax::codemap::Span; +use syntax::parse::token::{InternedString, special_idents}; use syntax::parse::token; use syntax::{ast, ast_util, ast_map}; use syntax::attr::AttrMetaMethods; use syntax::abi::{X86, X86_64, Arm, Mips, Rust, RustIntrinsic, OsWin32}; use syntax::visit; use syntax::visit::Visitor; +use syntax::visit; +use syntax::{ast, ast_util, codemap, ast_map}; pub use middle::trans::context::task_llcx; @@ -604,7 +609,8 @@ pub fn compare_scalar_types<'a>( rslt( controlflow::trans_fail( cx, None, - @"attempt to compare values of type type"), + InternedString::new("attempt to compare values of type \ + type")), C_nil()) } _ => { @@ -856,9 +862,9 @@ pub fn fail_if_zero<'a>( rhs_t: ty::t) -> &'a Block<'a> { let text = if divrem == ast::BiDiv { - @"attempted to divide by zero" + "attempted to divide by zero" } else { - @"attempted remainder with a divisor of zero" + "attempted remainder with a divisor of zero" }; let is_zero = match ty::get(rhs_t).sty { ty::ty_int(t) => { @@ -875,7 +881,7 @@ pub fn fail_if_zero<'a>( } }; with_cond(cx, is_zero, |bcx| { - controlflow::trans_fail(bcx, Some(span), text) + controlflow::trans_fail(bcx, Some(span), InternedString::new(text)) }) } @@ -1951,7 +1957,7 @@ fn exported_name(ccx: &CrateContext, path: ast_map::Path, ty: ty::t, attrs: &[ast::Attribute]) -> ~str { match attr::first_attr_value_str_by_name(attrs, "export_name") { // Use provided name - Some(name) => name.to_owned(), + Some(name) => name.get().to_owned(), // Don't mangle _ if attr::contains_name(attrs, "no_mangle") @@ -2099,7 +2105,7 @@ pub fn get_item_val(ccx: @CrateContext, id: ast::NodeId) -> ValueRef { match attr::first_attr_value_str_by_name(i.attrs, "link_section") { Some(sect) => unsafe { - sect.with_c_str(|buf| { + sect.get().with_c_str(|buf| { llvm::LLVMSetSection(v, buf); }) }, @@ -2161,9 +2167,9 @@ pub fn get_item_val(ccx: @CrateContext, id: ast::NodeId) -> ValueRef { ccx.crate_map } } else { - let ident = foreign::link_name(ccx, ni); + let ident = foreign::link_name(ni); unsafe { - ident.with_c_str(|buf| { + ident.get().with_c_str(|buf| { let ty = type_of(ccx, ty); llvm::LLVMAddGlobal(ccx.llmod, ty.to_ref(), buf) @@ -2476,21 +2482,21 @@ pub fn create_module_map(ccx: &CrateContext) -> (ValueRef, uint) { let mut keys = ~[]; let module_data = ccx.module_data.borrow(); for (k, _) in module_data.get().iter() { - keys.push(k.to_managed()); + keys.push(k.clone()); } keys }; for key in keys.iter() { - let llstrval = C_str_slice(ccx, *key); - let module_data = ccx.module_data.borrow(); - let val = *module_data.get().find_equiv(key).unwrap(); - let v_ptr = p2i(ccx, val); - let elt = C_struct([ - llstrval, - v_ptr - ], false); - elts.push(elt); + let llstrval = C_str_slice(ccx, token::intern_and_get_ident(*key)); + let module_data = ccx.module_data.borrow(); + let val = *module_data.get().find_equiv(key).unwrap(); + let v_ptr = p2i(ccx, val); + let elt = C_struct([ + llstrval, + v_ptr + ], false); + elts.push(elt); } unsafe { llvm::LLVMSetInitializer(map, C_array(elttype, elts)); diff --git a/src/librustc/middle/trans/common.rs b/src/librustc/middle/trans/common.rs index d35f9a28a83..a17ad98e426 100644 --- a/src/librustc/middle/trans/common.rs +++ b/src/librustc/middle/trans/common.rs @@ -30,7 +30,6 @@ use middle::ty; use middle::typeck; use util::ppaux::Repr; - use arena::TypedArena; use std::c_str::ToCStr; use std::cast::transmute; @@ -41,6 +40,7 @@ use std::libc::{c_uint, c_longlong, c_ulonglong, c_char}; use syntax::ast::{Ident}; use syntax::ast_map::{Path, PathElem, PathPrettyName}; use syntax::codemap::Span; +use syntax::parse::token::InternedString; use syntax::parse::token; use syntax::{ast, ast_map}; @@ -597,18 +597,19 @@ pub fn C_u8(i: uint) -> ValueRef { // This is a 'c-like' raw string, which differs from // our boxed-and-length-annotated strings. -pub fn C_cstr(cx: &CrateContext, s: @str) -> ValueRef { +pub fn C_cstr(cx: &CrateContext, s: InternedString) -> ValueRef { unsafe { { let const_cstr_cache = cx.const_cstr_cache.borrow(); - match const_cstr_cache.get().find_equiv(&s) { + match const_cstr_cache.get().find(&s) { Some(&llval) => return llval, None => () } } let sc = llvm::LLVMConstStringInContext(cx.llcx, - s.as_ptr() as *c_char, s.len() as c_uint, + s.get().as_ptr() as *c_char, + s.get().len() as c_uint, False); let gsym = token::gensym("str"); @@ -627,9 +628,9 @@ pub fn C_cstr(cx: &CrateContext, s: @str) -> ValueRef { // NB: Do not use `do_spill_noroot` to make this into a constant string, or // you will be kicked off fast isel. See issue #4352 for an example of this. -pub fn C_str_slice(cx: &CrateContext, s: @str) -> ValueRef { +pub fn C_str_slice(cx: &CrateContext, s: InternedString) -> ValueRef { unsafe { - let len = s.len(); + let len = s.get().len(); let cs = llvm::LLVMConstPointerCast(C_cstr(cx, s), Type::i8p().to_ref()); C_struct([cs, C_uint(cx, len)], false) } @@ -970,7 +971,8 @@ pub fn dummy_substs(tps: ~[ty::t]) -> ty::substs { pub fn filename_and_line_num_from_span(bcx: &Block, span: Span) -> (ValueRef, ValueRef) { let loc = bcx.sess().parse_sess.cm.lookup_char_pos(span.lo); - let filename_cstr = C_cstr(bcx.ccx(), loc.file.name); + let filename_cstr = C_cstr(bcx.ccx(), + token::intern_and_get_ident(loc.file.name)); let filename = build::PointerCast(bcx, filename_cstr, Type::i8p()); let line = C_int(bcx.ccx(), loc.line as int); (filename, line) diff --git a/src/librustc/middle/trans/consts.rs b/src/librustc/middle/trans/consts.rs index 79aa536a0db..ddab6407f9d 100644 --- a/src/librustc/middle/trans/consts.rs +++ b/src/librustc/middle/trans/consts.rs @@ -72,7 +72,7 @@ pub fn const_lit(cx: &CrateContext, e: &ast::Expr, lit: ast::Lit) } ast::LitBool(b) => C_bool(b), ast::LitNil => C_nil(), - ast::LitStr(s, _) => C_str_slice(cx, s), + ast::LitStr(ref s, _) => C_str_slice(cx, (*s).clone()), ast::LitBinary(data) => C_binary_slice(cx, data), } } @@ -312,7 +312,9 @@ fn const_expr_unadjusted(cx: @CrateContext, e: &ast::Expr, unsafe { let _icx = push_ctxt("const_expr"); return match e.node { - ast::ExprLit(lit) => (consts::const_lit(cx, e, *lit), true), + ast::ExprLit(lit) => { + (consts::const_lit(cx, e, (*lit).clone()), true) + } ast::ExprBinary(_, b, e1, e2) => { let (te1, _) = const_expr(cx, e1, is_local); let (te2, _) = const_expr(cx, e2, is_local); diff --git a/src/librustc/middle/trans/context.rs b/src/librustc/middle/trans/context.rs index 8503ce9066b..7968f034209 100644 --- a/src/librustc/middle/trans/context.rs +++ b/src/librustc/middle/trans/context.rs @@ -19,12 +19,12 @@ use middle::resolve; use middle::trans::adt; use middle::trans::base; use middle::trans::builder::Builder; -use middle::trans::debuginfo; use middle::trans::common::{C_i32, C_null}; -use middle::ty; - +use middle::trans::common::{mono_id,ExternMap,tydesc_info,BuilderRef_res,Stats}; +use middle::trans::base::{decl_crate_map}; +use middle::trans::debuginfo; use middle::trans::type_::Type; - +use middle::ty; use util::sha2::Sha256; use std::cell::{Cell, RefCell}; @@ -33,10 +33,7 @@ use std::hashmap::{HashMap, HashSet}; use std::local_data; use std::libc::c_uint; use syntax::ast; - -use middle::trans::common::{mono_id,ExternMap,tydesc_info,BuilderRef_res,Stats}; - -use middle::trans::base::{decl_crate_map}; +use syntax::parse::token::InternedString; pub struct CrateContext { sess: session::Session, @@ -71,7 +68,7 @@ pub struct CrateContext { // Cache generated vtables vtables: RefCell>, // Cache of constant strings, - const_cstr_cache: RefCell>, + const_cstr_cache: RefCell>, // Reverse-direction for const ptrs cast from globals. // Key is an int, cast from a ValueRef holding a *T, diff --git a/src/librustc/middle/trans/controlflow.rs b/src/librustc/middle/trans/controlflow.rs index 8c8c6829e49..6de34d98941 100644 --- a/src/librustc/middle/trans/controlflow.rs +++ b/src/librustc/middle/trans/controlflow.rs @@ -28,6 +28,8 @@ use syntax::ast; use syntax::ast::Name; use syntax::ast_util; use syntax::codemap::Span; +use syntax::parse::token::InternedString; +use syntax::parse::token; use syntax::visit::Visitor; pub fn trans_stmt<'a>(cx: &'a Block<'a>, @@ -342,14 +344,14 @@ pub fn trans_fail_expr<'a>( ppaux::ty_to_str(tcx, arg_datum.ty)); } } - _ => trans_fail(bcx, sp_opt, @"explicit failure") + _ => trans_fail(bcx, sp_opt, InternedString::new("explicit failure")) } } pub fn trans_fail<'a>( bcx: &'a Block<'a>, sp_opt: Option, - fail_str: @str) + fail_str: InternedString) -> &'a Block<'a> { let _icx = push_ctxt("trans_fail"); let V_fail_str = C_cstr(bcx.ccx(), fail_str); @@ -367,11 +369,11 @@ fn trans_fail_value<'a>( Some(sp) => { let sess = bcx.sess(); let loc = sess.parse_sess.cm.lookup_char_pos(sp.lo); - (C_cstr(bcx.ccx(), loc.file.name), + (C_cstr(bcx.ccx(), token::intern_and_get_ident(loc.file.name)), loc.line as int) } None => { - (C_cstr(bcx.ccx(), @""), 0) + (C_cstr(bcx.ccx(), InternedString::new("")), 0) } }; let V_str = PointerCast(bcx, V_fail_str, Type::i8p()); diff --git a/src/librustc/middle/trans/expr.rs b/src/librustc/middle/trans/expr.rs index d0a01f56b53..b5c7284dca5 100644 --- a/src/librustc/middle/trans/expr.rs +++ b/src/librustc/middle/trans/expr.rs @@ -543,9 +543,7 @@ fn trans_datum_unadjusted<'a>(bcx: &'a Block<'a>, let heap = heap_exchange; return trans_boxed_expr(bcx, box_ty, contents, contents_ty, heap) } - ast::ExprLit(lit) => { - trans_immediate_lit(bcx, expr, *lit) - } + ast::ExprLit(lit) => trans_immediate_lit(bcx, expr, (*lit).clone()), ast::ExprBinary(_, op, lhs, rhs) => { // if overloaded, would be RvalueDpsExpr { @@ -836,8 +834,8 @@ fn trans_rvalue_dps_unadjusted<'a>(bcx: &'a Block<'a>, } ast::ExprLit(lit) => { match lit.node { - ast::LitStr(s, _) => { - tvec::trans_lit_str(bcx, expr, s, dest) + ast::LitStr(ref s, _) => { + tvec::trans_lit_str(bcx, expr, (*s).clone(), dest) } _ => { bcx.tcx() diff --git a/src/librustc/middle/trans/foreign.rs b/src/librustc/middle/trans/foreign.rs index d9a34e1da7d..bc9dd767ec6 100644 --- a/src/librustc/middle/trans/foreign.rs +++ b/src/librustc/middle/trans/foreign.rs @@ -31,7 +31,8 @@ use std::vec; use syntax::abi::{Cdecl, Aapcs, C, AbiSet, Win64}; use syntax::abi::{RustIntrinsic, Rust, Stdcall, Fastcall, System}; use syntax::codemap::Span; -use syntax::parse::token::special_idents; +use syntax::parse::token::{InternedString, special_idents}; +use syntax::parse::token; use syntax::{ast}; use syntax::{attr, ast_map}; use util::ppaux::{Repr, UserString}; @@ -135,7 +136,7 @@ pub fn register_foreign_item_fn(ccx: @CrateContext, }; // Register the function as a C extern fn - let lname = link_name(ccx, foreign_item); + let lname = link_name(foreign_item); let tys = foreign_types_for_id(ccx, foreign_item.id); // Make sure the calling convention is right for variadic functions @@ -150,8 +151,12 @@ pub fn register_foreign_item_fn(ccx: @CrateContext, let llfn; { let mut externs = ccx.externs.borrow_mut(); - llfn = base::get_extern_fn(externs.get(), ccx.llmod, lname, - cc, llfn_ty, tys.fn_sig.output); + llfn = base::get_extern_fn(externs.get(), + ccx.llmod, + lname.get(), + cc, + llfn_ty, + tys.fn_sig.output); }; add_argument_attributes(&tys, llfn); @@ -372,9 +377,9 @@ pub fn trans_foreign_mod(ccx: @CrateContext, _ => () } - let lname = link_name(ccx, foreign_item); + let lname = link_name(foreign_item); let mut item_symbols = ccx.item_symbols.borrow_mut(); - item_symbols.get().insert(foreign_item.id, lname.to_owned()); + item_symbols.get().insert(foreign_item.id, lname.get().to_owned()); } } @@ -726,10 +731,10 @@ pub fn trans_rust_fn_with_foreign_abi(ccx: @CrateContext, // This code is kind of a confused mess and needs to be reworked given // the massive simplifications that have occurred. -pub fn link_name(ccx: &CrateContext, i: @ast::ForeignItem) -> @str { +pub fn link_name(i: @ast::ForeignItem) -> InternedString { match attr::first_attr_value_str_by_name(i.attrs, "link_name") { - None => ccx.sess.str_of(i.ident), - Some(ln) => ln, + None => token::get_ident(i.ident.name), + Some(ln) => ln.clone(), } } diff --git a/src/librustc/middle/trans/glue.rs b/src/librustc/middle/trans/glue.rs index 705501c8223..e002ecf0471 100644 --- a/src/librustc/middle/trans/glue.rs +++ b/src/librustc/middle/trans/glue.rs @@ -15,32 +15,33 @@ use back::abi; use back::link::*; -use lib; use lib::llvm::{llvm, ValueRef, True}; +use lib; use middle::lang_items::{FreeFnLangItem, ExchangeFreeFnLangItem}; use middle::trans::adt; use middle::trans::base::*; +use middle::trans::build::*; use middle::trans::callee; use middle::trans::cleanup; use middle::trans::cleanup::CleanupMethods; use middle::trans::common::*; -use middle::trans::build::*; +use middle::trans::datum::immediate_rvalue; use middle::trans::expr; use middle::trans::machine::*; use middle::trans::reflect; use middle::trans::tvec; +use middle::trans::type_::Type; use middle::trans::type_of::type_of; use middle::ty; -use util::ppaux; use util::ppaux::ty_to_short_str; - -use middle::trans::type_::Type; +use util::ppaux; use arena::TypedArena; use std::c_str::ToCStr; use std::cell::Cell; use std::libc::c_uint; use syntax::ast; +use syntax::parse::token; pub fn trans_free<'a>(cx: &'a Block<'a>, v: ValueRef) -> &'a Block<'a> { let _icx = push_ctxt("trans_free"); @@ -480,7 +481,8 @@ pub fn declare_tydesc(ccx: &CrateContext, t: ty::t) -> @tydesc_info { } }); - let ty_name = C_str_slice(ccx, ppaux::ty_to_str(ccx.tcx, t).to_managed()); + let ty_name = token::intern_and_get_ident(ppaux::ty_to_str(ccx.tcx, t)); + let ty_name = C_estr_slice(ccx, ty_name); let inf = @tydesc_info { ty: t, diff --git a/src/librustc/middle/trans/reflect.rs b/src/librustc/middle/trans/reflect.rs index 0e245de6019..7e01f162bb1 100644 --- a/src/librustc/middle/trans/reflect.rs +++ b/src/librustc/middle/trans/reflect.rs @@ -20,6 +20,7 @@ use middle::trans::datum::*; use middle::trans::glue; use middle::trans::machine; use middle::trans::meth; +use middle::trans::type_::Type; use middle::trans::type_of::*; use middle::ty; use util::ppaux::ty_to_str; @@ -31,9 +32,8 @@ use std::vec; use syntax::ast::DefId; use syntax::ast; use syntax::ast_map::PathName; -use syntax::parse::token::special_idents; - -use middle::trans::type_::Type; +use syntax::parse::token::{InternedString, special_idents}; +use syntax::parse::token; pub struct Reflector<'a> { visitor_val: ValueRef, @@ -56,14 +56,14 @@ impl<'a> Reflector<'a> { C_bool(b) } - pub fn c_slice(&mut self, s: @str) -> ValueRef { + pub fn c_slice(&mut self, s: InternedString) -> ValueRef { // We're careful to not use first class aggregates here because that // will kick us off fast isel. (Issue #4352.) let bcx = self.bcx; let str_vstore = ty::vstore_slice(ty::ReStatic); let str_ty = ty::mk_str(bcx.tcx(), str_vstore); let scratch = rvalue_scratch_datum(bcx, str_ty, ""); - let len = C_uint(bcx.ccx(), s.len()); + let len = C_uint(bcx.ccx(), s.get().len()); let c_str = PointerCast(bcx, C_cstr(bcx.ccx(), s), Type::i8p()); Store(bcx, c_str, GEPi(bcx, scratch.val, [ 0, 0 ])); Store(bcx, len, GEPi(bcx, scratch.val, [ 0, 1 ])); @@ -260,15 +260,19 @@ impl<'a> Reflector<'a> { fields[0].ident.name != special_idents::unnamed_field.name; } - let extra = ~[self.c_slice(ty_to_str(tcx, t).to_managed()), - self.c_bool(named_fields), - self.c_uint(fields.len())] + self.c_size_and_align(t); + let extra = ~[ + self.c_slice(token::intern_and_get_ident(ty_to_str(tcx, + t))), + self.c_bool(named_fields), + self.c_uint(fields.len()) + ] + self.c_size_and_align(t); self.bracketed("class", extra, |this| { for (i, field) in fields.iter().enumerate() { - let extra = ~[this.c_uint(i), - this.c_slice(bcx.ccx().sess.str_of(field.ident)), - this.c_bool(named_fields)] - + this.c_mt(&field.mt); + let extra = ~[ + this.c_uint(i), + this.c_slice(token::get_ident(field.ident.name)), + this.c_bool(named_fields) + ] + this.c_mt(&field.mt); this.visit("class_field", extra); } }) @@ -330,7 +334,7 @@ impl<'a> Reflector<'a> { + self.c_size_and_align(t); self.bracketed("enum", enum_args, |this| { for (i, v) in variants.iter().enumerate() { - let name = ccx.sess.str_of(v.name); + let name = token::get_ident(v.name.name); let variant_args = ~[this.c_uint(i), C_u64(v.disr_val), this.c_uint(v.args.len()), @@ -352,7 +356,9 @@ impl<'a> Reflector<'a> { } ty::ty_trait(_, _, _, _, _) => { - let extra = [self.c_slice(ty_to_str(tcx, t).to_managed())]; + let extra = [ + self.c_slice(token::intern_and_get_ident(ty_to_str(tcx, t))) + ]; self.visit("trait", extra); } diff --git a/src/librustc/middle/trans/tvec.rs b/src/librustc/middle/trans/tvec.rs index 5754a9ba88b..b0b7abbf664 100644 --- a/src/librustc/middle/trans/tvec.rs +++ b/src/librustc/middle/trans/tvec.rs @@ -31,6 +31,7 @@ use middle::ty; use util::ppaux::ty_to_str; use syntax::ast; +use syntax::parse::token::InternedString; // Boxed vector types are in some sense currently a "shorthand" for a box // containing an unboxed vector. This expands a boxed vector type into such an @@ -232,7 +233,10 @@ pub fn trans_slice_vstore<'a>( ast::ExprLit(lit) => { match lit.node { ast::LitStr(s, _) => { - return trans_lit_str(bcx, content_expr, s, dest); + return trans_lit_str(bcx, + content_expr, + (*s).clone(), + dest) } _ => {} } @@ -284,7 +288,7 @@ pub fn trans_slice_vstore<'a>( pub fn trans_lit_str<'a>( bcx: &'a Block<'a>, lit_expr: &ast::Expr, - str_lit: @str, + str_lit: InternedString, dest: Dest) -> &'a Block<'a> { /*! @@ -301,7 +305,7 @@ pub fn trans_lit_str<'a>( Ignore => bcx, SaveIn(lldest) => { unsafe { - let bytes = str_lit.len(); + let bytes = str_lit.get().len(); let llbytes = C_uint(bcx.ccx(), bytes); let llcstr = C_cstr(bcx.ccx(), str_lit); let llcstr = llvm::LLVMConstPointerCast(llcstr, Type::i8p().to_ref()); @@ -337,11 +341,15 @@ pub fn trans_uniq_or_managed_vstore<'a>(bcx: &'a Block<'a>, ast::ExprLit(lit) => { match lit.node { ast::LitStr(s, _) => { - let llptrval = C_cstr(bcx.ccx(), s); - let llptrval = PointerCast(bcx, llptrval, Type::i8p()); + let llptrval = C_cstr(bcx.ccx(), (*s).clone()); + let llptrval = PointerCast(bcx, + llptrval, + Type::i8p()); let llsizeval = C_uint(bcx.ccx(), s.len()); let typ = ty::mk_str(bcx.tcx(), ty::vstore_uniq); - let lldestval = rvalue_scratch_datum(bcx, typ, ""); + let lldestval = rvalue_scratch_datum(bcx, + typ, + ""); let alloc_fn = langcall(bcx, Some(lit.span), "", @@ -405,15 +413,13 @@ pub fn write_content<'a>( match content_expr.node { ast::ExprLit(lit) => { match lit.node { - ast::LitStr(s, _) => { + ast::LitStr(ref s, _) => { match dest { - Ignore => { - return bcx; - } + Ignore => return bcx, SaveIn(lldest) => { - let bytes = s.len(); + let bytes = s.get().len(); let llbytes = C_uint(bcx.ccx(), bytes); - let llcstr = C_cstr(bcx.ccx(), s); + let llcstr = C_cstr(bcx.ccx(), (*s).clone()); base::call_memcpy(bcx, lldest, llcstr, @@ -516,7 +522,7 @@ pub fn elements_required(bcx: &Block, content_expr: &ast::Expr) -> uint { match content_expr.node { ast::ExprLit(lit) => { match lit.node { - ast::LitStr(s, _) => s.len(), + ast::LitStr(ref s, _) => s.get().len(), _ => { bcx.tcx().sess.span_bug(content_expr.span, "Unexpected evec content") diff --git a/src/librustdoc/clean.rs b/src/librustdoc/clean.rs index 564fb465c02..4a4e7741982 100644 --- a/src/librustdoc/clean.rs +++ b/src/librustdoc/clean.rs @@ -252,14 +252,16 @@ impl<'a> attr::AttrMetaMethods for &'a Attribute { } } - fn value_str(&self) -> Option<@str> { + fn value_str(&self) -> Option { match **self { - NameValue(_, ref v) => Some(v.to_managed()), + NameValue(_, ref v) => Some(token::intern_and_get_ident(*v)), _ => None, } } fn meta_item_list<'a>(&'a self) -> Option<&'a [@ast::MetaItem]> { None } - fn name_str_pair(&self) -> Option<(InternedString, @str)> { None } + fn name_str_pair(&self) -> Option<(InternedString, InternedString)> { + None + } } #[deriving(Clone, Encodable, Decodable)] @@ -1144,7 +1146,7 @@ impl ToSource for syntax::codemap::Span { fn lit_to_str(lit: &ast::Lit) -> ~str { match lit.node { - ast::LitStr(st, _) => st.to_owned(), + ast::LitStr(ref st, _) => st.get().to_owned(), ast::LitBinary(data) => format!("{:?}", data.as_slice()), ast::LitChar(c) => ~"'" + std::char::from_u32(c).unwrap().to_str() + "'", ast::LitInt(i, _t) => i.to_str(), diff --git a/src/librustdoc/html/render.rs b/src/librustdoc/html/render.rs index 2885d05a5bd..86b6a5734a5 100644 --- a/src/librustdoc/html/render.rs +++ b/src/librustdoc/html/render.rs @@ -45,6 +45,7 @@ use extra::arc::Arc; use extra::json::ToJson; use syntax::ast; use syntax::attr; +use syntax::parse::token::InternedString; use clean; use doctree; @@ -803,12 +804,13 @@ impl<'a> Item<'a> { impl<'a> fmt::Default for Item<'a> { fn fmt(it: &Item<'a>, fmt: &mut fmt::Formatter) { match attr::find_stability(it.item.attrs.iter()) { - Some(stability) => { + Some(ref stability) => { write!(fmt.buf, "{lvl}", lvl = stability.level.to_str(), reason = match stability.text { - Some(s) => s, None => @"", + Some(ref s) => (*s).clone(), + None => InternedString::new(""), }); } None => {} diff --git a/src/librustpkg/util.rs b/src/librustpkg/util.rs index 3f1762009bc..d806194ffbc 100644 --- a/src/librustpkg/util.rs +++ b/src/librustpkg/util.rs @@ -31,6 +31,7 @@ use syntax::{ast, attr, codemap, diagnostic, fold, visit}; use syntax::attr::AttrMetaMethods; use syntax::fold::Folder; use syntax::parse::token::InternedString; +use syntax::parse::token; use syntax::visit::Visitor; use syntax::util::small_vector::SmallVector; use syntax::crateid::CrateId; @@ -317,8 +318,9 @@ pub fn compile_input(context: &BuildContext, if !attr::contains_name(crate.attrs, "crate_id") { // FIXME (#9639): This needs to handle non-utf8 paths let crateid_attr = - attr::mk_name_value_item_str(InternedString::new("crate_id"), - crate_id.to_str().to_managed()); + attr::mk_name_value_item_str( + InternedString::new("crate_id"), + token::intern_and_get_ident(crate_id.to_str())); debug!("crateid attr: {:?}", crateid_attr); crate.attrs.push(attr::mk_attr(crateid_attr)); @@ -646,7 +648,7 @@ pub fn find_and_install_dependencies(installer: &mut CrateInstaller, visit::walk_crate(installer, c, ()) } -pub fn mk_string_lit(s: @str) -> ast::Lit { +pub fn mk_string_lit(s: InternedString) -> ast::Lit { Spanned { node: ast::LitStr(s, ast::CookedStr), span: DUMMY_SP diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index f7e474f666c..7416e213792 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -722,7 +722,7 @@ pub type Lit = Spanned; #[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] pub enum Lit_ { - LitStr(@str, StrStyle), + LitStr(InternedString, StrStyle), LitBinary(@[u8]), LitChar(u32), LitInt(i64, IntTy), diff --git a/src/libsyntax/attr.rs b/src/libsyntax/attr.rs index 6c6f47bae8a..78e9d3bd46f 100644 --- a/src/libsyntax/attr.rs +++ b/src/libsyntax/attr.rs @@ -17,6 +17,7 @@ use codemap::BytePos; use diagnostic::SpanHandler; use parse::comments::{doc_comment_style, strip_doc_comment_decoration}; use parse::token::InternedString; +use parse::token; use crateid::CrateId; use std::hashmap::HashSet; @@ -34,7 +35,7 @@ pub trait AttrMetaMethods { * Gets the string value if self is a MetaNameValue variant * containing a string, otherwise None. */ - fn value_str(&self) -> Option<@str>; + fn value_str(&self) -> Option; /// Gets a list of inner meta items from a list MetaItem type. fn meta_item_list<'a>(&'a self) -> Option<&'a [@MetaItem]>; @@ -42,16 +43,18 @@ pub trait AttrMetaMethods { * If the meta item is a name-value type with a string value then returns * a tuple containing the name and string value, otherwise `None` */ - fn name_str_pair(&self) -> Option<(InternedString, @str)>; + fn name_str_pair(&self) -> Option<(InternedString,InternedString)>; } impl AttrMetaMethods for Attribute { fn name(&self) -> InternedString { self.meta().name() } - fn value_str(&self) -> Option<@str> { self.meta().value_str() } + fn value_str(&self) -> Option { + self.meta().value_str() + } fn meta_item_list<'a>(&'a self) -> Option<&'a [@MetaItem]> { self.node.value.meta_item_list() } - fn name_str_pair(&self) -> Option<(InternedString, @str)> { + fn name_str_pair(&self) -> Option<(InternedString,InternedString)> { self.meta().name_str_pair() } } @@ -65,11 +68,11 @@ impl AttrMetaMethods for MetaItem { } } - fn value_str(&self) -> Option<@str> { + fn value_str(&self) -> Option { match self.node { MetaNameValue(_, ref v) => { match v.node { - ast::LitStr(s, _) => Some(s), + ast::LitStr(ref s, _) => Some((*s).clone()), _ => None, } }, @@ -84,7 +87,7 @@ impl AttrMetaMethods for MetaItem { } } - fn name_str_pair(&self) -> Option<(InternedString, @str)> { + fn name_str_pair(&self) -> Option<(InternedString,InternedString)> { self.value_str().map(|s| (self.name(), s)) } } @@ -92,11 +95,11 @@ impl AttrMetaMethods for MetaItem { // Annoying, but required to get test_cfg to work impl AttrMetaMethods for @MetaItem { fn name(&self) -> InternedString { (**self).name() } - fn value_str(&self) -> Option<@str> { (**self).value_str() } + fn value_str(&self) -> Option { (**self).value_str() } fn meta_item_list<'a>(&'a self) -> Option<&'a [@MetaItem]> { (**self).meta_item_list() } - fn name_str_pair(&self) -> Option<(InternedString, @str)> { + fn name_str_pair(&self) -> Option<(InternedString,InternedString)> { (**self).name_str_pair() } } @@ -119,8 +122,10 @@ impl AttributeMethods for Attribute { fn desugar_doc(&self) -> Attribute { if self.node.is_sugared_doc { let comment = self.value_str().unwrap(); - let meta = mk_name_value_item_str(InternedString::new("doc"), - strip_doc_comment_decoration(comment).to_managed()); + let meta = mk_name_value_item_str( + InternedString::new("doc"), + token::intern_and_get_ident(strip_doc_comment_decoration( + comment.get()))); mk_attr(meta) } else { *self @@ -130,7 +135,7 @@ impl AttributeMethods for Attribute { /* Constructors */ -pub fn mk_name_value_item_str(name: InternedString, value: @str) +pub fn mk_name_value_item_str(name: InternedString, value: InternedString) -> @MetaItem { let value_lit = dummy_spanned(ast::LitStr(value, ast::CookedStr)); mk_name_value_item(name, value_lit) @@ -157,8 +162,9 @@ pub fn mk_attr(item: @MetaItem) -> Attribute { }) } -pub fn mk_sugared_doc_attr(text: @str, lo: BytePos, hi: BytePos) -> Attribute { - let style = doc_comment_style(text); +pub fn mk_sugared_doc_attr(text: InternedString, lo: BytePos, hi: BytePos) + -> Attribute { + let style = doc_comment_style(text.get()); let lit = spanned(lo, hi, ast::LitStr(text, ast::CookedStr)); let attr = Attribute_ { style: style, @@ -191,14 +197,14 @@ pub fn contains_name(metas: &[AM], name: &str) -> bool { } pub fn first_attr_value_str_by_name(attrs: &[Attribute], name: &str) - -> Option<@str> { + -> Option { attrs.iter() .find(|at| at.name().equiv(&name)) .and_then(|at| at.value_str()) } pub fn last_meta_item_value_str_by_name(items: &[@MetaItem], name: &str) - -> Option<@str> { + -> Option { items.rev_iter() .find(|mi| mi.name().equiv(&name)) .and_then(|i| i.value_str()) @@ -247,7 +253,7 @@ pub fn find_linkage_metas(attrs: &[Attribute]) -> ~[@MetaItem] { pub fn find_crateid(attrs: &[Attribute]) -> Option { match first_attr_value_str_by_name(attrs, "crate_id") { None => None, - Some(id) => from_str::(id), + Some(id) => from_str::(id.get()), } } @@ -331,7 +337,7 @@ pub fn test_cfg> /// Represents the #[deprecated="foo"] (etc) attributes. pub struct Stability { level: StabilityLevel, - text: Option<@str> + text: Option } /// The available stability levels. @@ -346,7 +352,8 @@ pub enum StabilityLevel { } /// Find the first stability attribute. `None` if none exists. -pub fn find_stability>(mut metas: It) -> Option { +pub fn find_stability>(mut metas: It) + -> Option { for m in metas { let level = match m.name().get() { "deprecated" => Deprecated, diff --git a/src/libsyntax/ext/asm.rs b/src/libsyntax/ext/asm.rs index 021f0d29d9e..babf0f13874 100644 --- a/src/libsyntax/ext/asm.rs +++ b/src/libsyntax/ext/asm.rs @@ -17,6 +17,7 @@ use codemap::Span; use ext::base; use ext::base::*; use parse; +use parse::token::InternedString; use parse::token; enum State { @@ -43,7 +44,7 @@ pub fn expand_asm(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) cx.cfg(), tts.to_owned()); - let mut asm = @""; + let mut asm = InternedString::new(""); let mut asm_str_style = None; let mut outputs = ~[]; let mut inputs = ~[]; @@ -191,7 +192,7 @@ pub fn expand_asm(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) MRExpr(@ast::Expr { id: ast::DUMMY_NODE_ID, node: ast::ExprInlineAsm(ast::InlineAsm { - asm: asm, + asm: asm.get().to_managed(), asm_str_style: asm_str_style.unwrap(), clobbers: cons.to_managed(), inputs: inputs, diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs index adf1eabf9d9..eda0a47148a 100644 --- a/src/libsyntax/ext/base.rs +++ b/src/libsyntax/ext/base.rs @@ -16,7 +16,7 @@ use ext; use ext::expand; use parse; use parse::token; -use parse::token::{ident_to_str, intern, str_to_ident}; +use parse::token::{InternedString, ident_to_str, intern, str_to_ident}; use util::small_vector::SmallVector; use std::hashmap::HashMap; @@ -407,11 +407,11 @@ impl<'a> ExtCtxt<'a> { /// Extract a string literal from `expr`, emitting `err_msg` if `expr` /// is not a string literal. This does not stop compilation on error, /// merely emits a non-fatal error and returns None. -pub fn expr_to_str(cx: &ExtCtxt, expr: @ast::Expr, - err_msg: &str) -> Option<(@str, ast::StrStyle)> { +pub fn expr_to_str(cx: &ExtCtxt, expr: @ast::Expr, err_msg: &str) + -> Option<(InternedString, ast::StrStyle)> { match expr.node { ast::ExprLit(l) => match l.node { - ast::LitStr(s, style) => return Some((s, style)), + ast::LitStr(s, style) => return Some(((*s).clone(), style)), _ => cx.span_err(l.span, err_msg) }, _ => cx.span_err(expr.span, err_msg) @@ -424,7 +424,9 @@ pub fn expr_to_str(cx: &ExtCtxt, expr: @ast::Expr, /// compilation should call /// `cx.parse_sess.span_diagnostic.abort_if_errors()` (this should be /// done as rarely as possible). -pub fn check_zero_tts(cx: &ExtCtxt, sp: Span, tts: &[ast::TokenTree], +pub fn check_zero_tts(cx: &ExtCtxt, + sp: Span, + tts: &[ast::TokenTree], name: &str) { if tts.len() != 0 { cx.span_err(sp, format!("{} takes no arguments", name)); diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs index 884bd831ce8..c5ee1948466 100644 --- a/src/libsyntax/ext/build.rs +++ b/src/libsyntax/ext/build.rs @@ -19,6 +19,7 @@ use fold::Folder; use opt_vec; use opt_vec::OptVec; use parse::token::special_idents; +use parse::token; pub struct Field { ident: ast::Ident, @@ -134,13 +135,13 @@ 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: InternedString) -> @ast::Expr; + fn expr_str_uniq(&self, sp: Span, s: InternedString) -> @ast::Expr; fn expr_some(&self, sp: Span, expr: @ast::Expr) -> @ast::Expr; fn expr_none(&self, sp: Span) -> @ast::Expr; - fn expr_fail(&self, span: Span, msg: @str) -> @ast::Expr; + fn expr_fail(&self, span: Span, msg: InternedString) -> @ast::Expr; fn expr_unreachable(&self, span: Span) -> @ast::Expr; fn pat(&self, span: Span, pat: ast::Pat_) -> @ast::Pat; @@ -589,10 +590,10 @@ impl<'a> AstBuilder for ExtCtxt<'a> { fn expr_vec_slice(&self, sp: Span, exprs: ~[@ast::Expr]) -> @ast::Expr { self.expr_vstore(sp, self.expr_vec(sp, exprs), ast::ExprVstoreSlice) } - fn expr_str(&self, sp: Span, s: @str) -> @ast::Expr { + fn expr_str(&self, sp: Span, s: InternedString) -> @ast::Expr { self.expr_lit(sp, ast::LitStr(s, ast::CookedStr)) } - fn expr_str_uniq(&self, sp: Span, s: @str) -> @ast::Expr { + fn expr_str_uniq(&self, sp: Span, s: InternedString) -> @ast::Expr { self.expr_vstore(sp, self.expr_str(sp, s), ast::ExprVstoreUniq) } @@ -620,7 +621,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> { self.expr_path(none) } - fn expr_fail(&self, span: Span, msg: @str) -> @ast::Expr { + fn expr_fail(&self, span: Span, msg: InternedString) -> @ast::Expr { let loc = self.codemap().lookup_char_pos(span.lo); self.expr_call_global( span, @@ -631,13 +632,16 @@ impl<'a> AstBuilder for ExtCtxt<'a> { ], ~[ self.expr_str(span, msg), - self.expr_str(span, loc.file.name), + self.expr_str(span, + token::intern_and_get_ident(loc.file.name)), self.expr_uint(span, loc.line), ]) } fn expr_unreachable(&self, span: Span) -> @ast::Expr { - self.expr_fail(span, @"internal error: entered unreachable code") + self.expr_fail(span, + InternedString::new( + "internal error: entered unreachable code")) } diff --git a/src/libsyntax/ext/bytes.rs b/src/libsyntax/ext/bytes.rs index 0c9a23be558..6852a0cec33 100644 --- a/src/libsyntax/ext/bytes.rs +++ b/src/libsyntax/ext/bytes.rs @@ -31,8 +31,8 @@ pub fn expand_syntax_ext(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) -> // expression is a literal ast::ExprLit(lit) => match lit.node { // string literal, push each byte to vector expression - ast::LitStr(s, _) => { - for byte in s.bytes() { + ast::LitStr(ref s, _) => { + for byte in s.get().bytes() { bytes.push(cx.expr_u8(expr.span, byte)); } } diff --git a/src/libsyntax/ext/concat.rs b/src/libsyntax/ext/concat.rs index 2a68674af95..f570ca4c1bf 100644 --- a/src/libsyntax/ext/concat.rs +++ b/src/libsyntax/ext/concat.rs @@ -14,6 +14,7 @@ use ast; use codemap; use ext::base; use ext::build::AstBuilder; +use parse::token; pub fn expand_syntax_ext(cx: &mut base::ExtCtxt, sp: codemap::Span, @@ -28,8 +29,10 @@ pub fn expand_syntax_ext(cx: &mut base::ExtCtxt, match e.node { ast::ExprLit(lit) => { match lit.node { - ast::LitStr(s, _) | ast::LitFloat(s, _) - | ast::LitFloatUnsuffixed(s) => { + ast::LitStr(ref s, _) => { + accumulator.push_str(s.get()); + } + ast::LitFloat(s, _) | ast::LitFloatUnsuffixed(s) => { accumulator.push_str(s); } ast::LitChar(c) => { @@ -55,5 +58,5 @@ pub fn expand_syntax_ext(cx: &mut base::ExtCtxt, } } } - return base::MRExpr(cx.expr_str(sp, accumulator.to_managed())); + base::MRExpr(cx.expr_str(sp, token::intern_and_get_ident(accumulator))) } diff --git a/src/libsyntax/ext/deriving/decodable.rs b/src/libsyntax/ext/deriving/decodable.rs index a9268d85c91..019a4dfe7cc 100644 --- a/src/libsyntax/ext/deriving/decodable.rs +++ b/src/libsyntax/ext/deriving/decodable.rs @@ -18,6 +18,8 @@ use codemap::Span; use ext::base::ExtCtxt; use ext::build::AstBuilder; use ext::deriving::generic::*; +use parse::token::InternedString; +use parse::token; pub fn expand_deriving_decodable(cx: &ExtCtxt, span: Span, @@ -82,10 +84,15 @@ fn decodable_substructure(cx: &ExtCtxt, trait_span: Span, cx.expr_uint(span, field), lambdadecode]) }); - cx.expr_method_call(trait_span, decoder, cx.ident_of("read_struct"), - ~[cx.expr_str(trait_span, cx.str_of(substr.type_ident)), - cx.expr_uint(trait_span, nfields), - cx.lambda_expr_1(trait_span, result, blkarg)]) + cx.expr_method_call(trait_span, + decoder, + cx.ident_of("read_struct"), + ~[ + cx.expr_str(trait_span, + token::get_ident(substr.type_ident.name)), + cx.expr_uint(trait_span, nfields), + cx.lambda_expr_1(trait_span, result, blkarg) + ]) } StaticEnum(_, ref fields) => { let variant = cx.ident_of("i"); @@ -95,7 +102,8 @@ fn decodable_substructure(cx: &ExtCtxt, trait_span: Span, let rvariant_arg = cx.ident_of("read_enum_variant_arg"); for (i, &(name, v_span, ref parts)) in fields.iter().enumerate() { - variants.push(cx.expr_str(v_span, cx.str_of(name))); + variants.push(cx.expr_str(v_span, + token::get_ident(name.name))); let decoded = decode_static_fields(cx, v_span, @@ -120,9 +128,14 @@ fn decodable_substructure(cx: &ExtCtxt, trait_span: Span, let result = cx.expr_method_call(trait_span, blkdecoder, cx.ident_of("read_enum_variant"), ~[variant_vec, lambda]); - cx.expr_method_call(trait_span, decoder, cx.ident_of("read_enum"), - ~[cx.expr_str(trait_span, cx.str_of(substr.type_ident)), - cx.lambda_expr_1(trait_span, result, blkarg)]) + cx.expr_method_call(trait_span, + decoder, + cx.ident_of("read_enum"), + ~[ + cx.expr_str(trait_span, + token::get_ident(substr.type_ident.name)), + cx.lambda_expr_1(trait_span, result, blkarg) + ]) } _ => cx.bug("expected StaticEnum or StaticStruct in deriving(Decodable)") }; @@ -135,7 +148,7 @@ fn decode_static_fields(cx: &ExtCtxt, trait_span: Span, outer_pat_ident: Ident, fields: &StaticFields, - getarg: |Span, @str, uint| -> @Expr) + getarg: |Span, InternedString, uint| -> @Expr) -> @Expr { match *fields { Unnamed(ref fields) => { @@ -143,7 +156,10 @@ fn decode_static_fields(cx: &ExtCtxt, cx.expr_ident(trait_span, outer_pat_ident) } else { let fields = fields.iter().enumerate().map(|(i, &span)| { - getarg(span, format!("_field{}", i).to_managed(), i) + getarg(span, + token::intern_and_get_ident(format!("_field{}", + i)), + i) }).collect(); cx.expr_call_ident(trait_span, outer_pat_ident, fields) @@ -152,7 +168,9 @@ fn decode_static_fields(cx: &ExtCtxt, Named(ref fields) => { // use the field's span to get nicer error messages. let fields = fields.iter().enumerate().map(|(i, &(name, span))| { - cx.field_imm(span, name, getarg(span, cx.str_of(name), i)) + cx.field_imm(span, + name, + getarg(span, token::get_ident(name.name), i)) }).collect(); cx.expr_struct_ident(trait_span, outer_pat_ident, fields) } diff --git a/src/libsyntax/ext/deriving/encodable.rs b/src/libsyntax/ext/deriving/encodable.rs index 9a8861f2e70..1dfc5b59e06 100644 --- a/src/libsyntax/ext/deriving/encodable.rs +++ b/src/libsyntax/ext/deriving/encodable.rs @@ -80,6 +80,7 @@ use codemap::Span; use ext::base::ExtCtxt; use ext::build::AstBuilder; use ext::deriving::generic::*; +use parse::token; pub fn expand_deriving_encodable(cx: &ExtCtxt, span: Span, @@ -125,10 +126,17 @@ fn encodable_substructure(cx: &ExtCtxt, trait_span: Span, Struct(ref fields) => { let emit_struct_field = cx.ident_of("emit_struct_field"); let mut stmts = ~[]; - for (i, &FieldInfo { name, self_, span, .. }) in fields.iter().enumerate() { + for (i, &FieldInfo { + name, + self_, + span, + .. + }) in fields.iter().enumerate() { let name = match name { - Some(id) => cx.str_of(id), - None => format!("_field{}", i).to_managed() + Some(id) => token::get_ident(id), + None => { + token::intern_and_get_ident(format!("_field{}", i)) + } }; let enc = cx.expr_method_call(span, self_, encode, ~[blkencoder]); let lambda = cx.lambda_expr_1(span, enc, blkarg); @@ -141,10 +149,15 @@ fn encodable_substructure(cx: &ExtCtxt, trait_span: Span, } let blk = cx.lambda_stmts_1(trait_span, stmts, blkarg); - cx.expr_method_call(trait_span, encoder, cx.ident_of("emit_struct"), - ~[cx.expr_str(trait_span, cx.str_of(substr.type_ident)), - cx.expr_uint(trait_span, fields.len()), - blk]) + cx.expr_method_call(trait_span, + encoder, + cx.ident_of("emit_struct"), + ~[ + cx.expr_str(trait_span, + token::get_ident(substr.type_ident.name)), + cx.expr_uint(trait_span, fields.len()), + blk + ]) } EnumMatching(idx, variant, ref fields) => { @@ -167,7 +180,8 @@ fn encodable_substructure(cx: &ExtCtxt, trait_span: Span, } let blk = cx.lambda_stmts_1(trait_span, stmts, blkarg); - let name = cx.expr_str(trait_span, cx.str_of(variant.node.name)); + let name = cx.expr_str(trait_span, + token::get_ident(variant.node.name)); let call = cx.expr_method_call(trait_span, blkencoder, cx.ident_of("emit_enum_variant"), ~[name, @@ -175,11 +189,14 @@ fn encodable_substructure(cx: &ExtCtxt, trait_span: Span, cx.expr_uint(trait_span, fields.len()), blk]); let blk = cx.lambda_expr_1(trait_span, call, blkarg); - let ret = cx.expr_method_call(trait_span, encoder, + let ret = cx.expr_method_call(trait_span, + encoder, cx.ident_of("emit_enum"), - ~[cx.expr_str(trait_span, - cx.str_of(substr.type_ident)), - blk]); + ~[ + cx.expr_str(trait_span, + token::get_ident(substr.type_ident.name)), + blk + ]); cx.expr_block(cx.block(trait_span, ~[me], Some(ret))) } diff --git a/src/libsyntax/ext/deriving/generic.rs b/src/libsyntax/ext/deriving/generic.rs index 20a515692e1..45e3be7f23d 100644 --- a/src/libsyntax/ext/deriving/generic.rs +++ b/src/libsyntax/ext/deriving/generic.rs @@ -185,6 +185,7 @@ use codemap; use codemap::Span; use opt_vec; use parse::token::InternedString; +use parse::token; use std::vec; @@ -398,7 +399,9 @@ impl<'a> TraitDef<'a> { self.span, cx.meta_name_value(self.span, InternedString::new("doc"), - ast::LitStr(@"Automatically derived.", ast::CookedStr))); + ast::LitStr(token::intern_and_get_ident( + "Automatically derived."), + ast::CookedStr))); cx.item( self.span, ::parse::token::special_idents::clownshoes_extensions, diff --git a/src/libsyntax/ext/deriving/primitive.rs b/src/libsyntax/ext/deriving/primitive.rs index a4e606f53c0..e2f72e87085 100644 --- a/src/libsyntax/ext/deriving/primitive.rs +++ b/src/libsyntax/ext/deriving/primitive.rs @@ -14,6 +14,7 @@ use codemap::Span; use ext::base::ExtCtxt; use ext::build::AstBuilder; use ext::deriving::generic::*; +use parse::token::InternedString; pub fn expand_deriving_from_primitive(cx: &ExtCtxt, span: Span, @@ -73,13 +74,13 @@ fn cs_from(name: &str, cx: &ExtCtxt, trait_span: Span, substr: &Substructure) -> match *substr.fields { StaticStruct(..) => { cx.span_err(trait_span, "`FromPrimitive` cannot be derived for structs"); - return cx.expr_fail(trait_span, @""); + return cx.expr_fail(trait_span, InternedString::new("")); } StaticEnum(enum_def, _) => { if enum_def.variants.is_empty() { cx.span_err(trait_span, "`FromPrimitive` cannot be derived for enums with no variants"); - return cx.expr_fail(trait_span, @""); + return cx.expr_fail(trait_span, InternedString::new("")); } let mut arms = ~[]; @@ -91,7 +92,8 @@ fn cs_from(name: &str, cx: &ExtCtxt, trait_span: Span, substr: &Substructure) -> cx.span_err(trait_span, "`FromPrimitive` cannot be derived for \ enum variants with arguments"); - return cx.expr_fail(trait_span, @""); + return cx.expr_fail(trait_span, + InternedString::new("")); } let span = variant.span; @@ -117,7 +119,8 @@ fn cs_from(name: &str, cx: &ExtCtxt, trait_span: Span, substr: &Substructure) -> cx.span_err(trait_span, "`FromPrimitive` cannot be derived for enums \ with struct variants"); - return cx.expr_fail(trait_span, @""); + return cx.expr_fail(trait_span, + InternedString::new("")); } } } diff --git a/src/libsyntax/ext/deriving/to_str.rs b/src/libsyntax/ext/deriving/to_str.rs index 81453a5a10b..97412595b29 100644 --- a/src/libsyntax/ext/deriving/to_str.rs +++ b/src/libsyntax/ext/deriving/to_str.rs @@ -14,6 +14,8 @@ use codemap::Span; use ext::base::ExtCtxt; use ext::build::AstBuilder; use ext::deriving::generic::*; +use parse::token::InternedString; +use parse::token; pub fn expand_deriving_to_str(cx: &ExtCtxt, span: Span, @@ -47,18 +49,20 @@ pub fn expand_deriving_to_str(cx: &ExtCtxt, // doesn't invoke the to_str() method on each field. Hence we mirror // the logic of the repr_to_str() method, but with tweaks to call to_str() // on sub-fields. -fn to_str_substructure(cx: &ExtCtxt, span: Span, - substr: &Substructure) -> @Expr { +fn to_str_substructure(cx: &ExtCtxt, span: Span, substr: &Substructure) + -> @Expr { let to_str = cx.ident_of("to_str"); - let doit = |start: &str, end: @str, name: ast::Ident, + let doit = |start: &str, + end: InternedString, + name: ast::Ident, fields: &[FieldInfo]| { if fields.len() == 0 { - cx.expr_str_uniq(span, cx.str_of(name)) + cx.expr_str_uniq(span, token::get_ident(name.name)) } else { let buf = cx.ident_of("buf"); - let start = cx.str_of(name) + start; - let init = cx.expr_str_uniq(span, start.to_managed()); + let start = token::intern_and_get_ident(cx.str_of(name) + start); + let init = cx.expr_str_uniq(span, start); let mut stmts = ~[cx.stmt_let(span, true, buf, init)]; let push_str = cx.ident_of("push_str"); @@ -70,38 +74,52 @@ fn to_str_substructure(cx: &ExtCtxt, span: Span, for (i, &FieldInfo {name, span, self_, .. }) in fields.iter().enumerate() { if i > 0 { - push(cx.expr_str(span, @", ")); + push(cx.expr_str(span, InternedString::new(", "))); } match name { None => {} Some(id) => { let name = cx.str_of(id) + ": "; - push(cx.expr_str(span, name.to_managed())); + push(cx.expr_str(span, + token::intern_and_get_ident(name))); } } push(cx.expr_method_call(span, self_, to_str, ~[])); } push(cx.expr_str(span, end)); - cx.expr_block(cx.block(span, stmts, Some(cx.expr_ident(span, buf)))) + cx.expr_block(cx.block(span, stmts, Some(cx.expr_ident(span, + buf)))) } }; return match *substr.fields { Struct(ref fields) => { if fields.len() == 0 || fields[0].name.is_none() { - doit("(", @")", substr.type_ident, *fields) + doit("(", + InternedString::new(")"), + substr.type_ident, + *fields) } else { - doit("{", @"}", substr.type_ident, *fields) + doit("{", + InternedString::new("}"), + substr.type_ident, + *fields) } } EnumMatching(_, variant, ref fields) => { match variant.node.kind { ast::TupleVariantKind(..) => - doit("(", @")", variant.node.name, *fields), + doit("(", + InternedString::new(")"), + variant.node.name, + *fields), ast::StructVariantKind(..) => - doit("{", @"}", variant.node.name, *fields), + doit("{", + InternedString::new("}"), + variant.node.name, + *fields), } } diff --git a/src/libsyntax/ext/env.rs b/src/libsyntax/ext/env.rs index a9b40ea7ec6..c23a1ce1e28 100644 --- a/src/libsyntax/ext/env.rs +++ b/src/libsyntax/ext/env.rs @@ -19,6 +19,7 @@ use codemap::Span; use ext::base::*; use ext::base; use ext::build::AstBuilder; +use parse::token; use std::os; @@ -52,7 +53,11 @@ pub fn expand_env(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) Some((v, _style)) => v }; let msg = match exprs.len() { - 1 => format!("environment variable `{}` not defined", var).to_managed(), + 1 => { + token::intern_and_get_ident(format!("environment variable `{}` \ + not defined", + var)) + } 2 => { match expr_to_str(cx, exprs[1], "expected string literal") { None => return MacResult::dummy_expr(), @@ -65,12 +70,12 @@ pub fn expand_env(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) } }; - let e = match os::getenv(var) { + let e = match os::getenv(var.get()) { None => { - cx.span_err(sp, msg); + cx.span_err(sp, msg.get()); cx.expr_uint(sp, 0) } - Some(s) => cx.expr_str(sp, s.to_managed()) + Some(s) => cx.expr_str(sp, token::intern_and_get_ident(s)) }; MRExpr(e) } diff --git a/src/libsyntax/ext/format.rs b/src/libsyntax/ext/format.rs index 5730d435c15..5bedb1a887e 100644 --- a/src/libsyntax/ext/format.rs +++ b/src/libsyntax/ext/format.rs @@ -416,7 +416,7 @@ impl<'a> Context<'a> { let result = arm.result.iter().map(|p| { self.trans_piece(p) }).collect(); - let s = arm.selector.to_managed(); + let s = token::intern_and_get_ident(arm.selector); let selector = self.ecx.expr_str(sp, s); self.ecx.expr_struct(sp, p, ~[ self.ecx.field_imm(sp, @@ -492,8 +492,12 @@ impl<'a> Context<'a> { match *piece { parse::String(s) => { - self.ecx.expr_call_global(sp, rtpath("String"), - ~[self.ecx.expr_str(sp, s.to_managed())]) + let s = token::intern_and_get_ident(s); + self.ecx.expr_call_global(sp, + rtpath("String"), + ~[ + self.ecx.expr_str(sp, s) + ]) } parse::CurrentArgument => { let nil = self.ecx.expr_lit(sp, ast::LitNil); @@ -763,8 +767,9 @@ pub fn expand_args(ecx: &mut ExtCtxt, sp: Span, // Be sure to recursively expand macros just in case the format string uses // a macro to build the format expression. let expr = cx.ecx.expand_expr(efmt); - let fmt = match expr_to_str(cx.ecx, expr, - "format argument must be a string literal.") { + let fmt = match expr_to_str(cx.ecx, + expr, + "format argument must be a string literal.") { Some((fmt, _)) => fmt, None => return MacResult::dummy_expr() }; @@ -776,7 +781,7 @@ pub fn expand_args(ecx: &mut ExtCtxt, sp: Span, cx.ecx.span_err(efmt.span, m); } }).inside(|| { - for piece in parse::Parser::new(fmt) { + for piece in parse::Parser::new(fmt.get()) { if !err { cx.verify_piece(&piece); let piece = cx.trans_piece(&piece); diff --git a/src/libsyntax/ext/quote.rs b/src/libsyntax/ext/quote.rs index 6faed270875..425ac8865b2 100644 --- a/src/libsyntax/ext/quote.rs +++ b/src/libsyntax/ext/quote.rs @@ -31,6 +31,7 @@ use parse; pub mod rt { use ast; use ext::base::ExtCtxt; + use parse::token; use parse; use print::pprust; @@ -118,7 +119,8 @@ pub mod rt { impl<'a> ToSource for &'a str { fn to_source(&self) -> @str { - let lit = dummy_spanned(ast::LitStr(self.to_managed(), ast::CookedStr)); + let lit = dummy_spanned(ast::LitStr( + token::intern_and_get_ident(*self), ast::CookedStr)); pprust::lit_to_str(&lit).to_managed() } } @@ -349,7 +351,7 @@ fn id_ext(str: &str) -> ast::Ident { // Lift an ident to the expr that evaluates to that ident. fn mk_ident(cx: &ExtCtxt, sp: Span, ident: ast::Ident) -> @ast::Expr { - let e_str = cx.expr_str(sp, cx.str_of(ident)); + let e_str = cx.expr_str(sp, token::get_ident(ident.name)); cx.expr_method_call(sp, cx.expr_ident(sp, id_ext("ext_cx")), id_ext("ident_of"), diff --git a/src/libsyntax/ext/source_util.rs b/src/libsyntax/ext/source_util.rs index a9f94da7a98..b67f3ed263e 100644 --- a/src/libsyntax/ext/source_util.rs +++ b/src/libsyntax/ext/source_util.rs @@ -16,7 +16,8 @@ use ext::base::*; use ext::base; use ext::build::AstBuilder; use parse; -use parse::token::{get_ident_interner}; +use parse::token::get_ident_interner; +use parse::token; use print::pprust; use std::io; @@ -57,21 +58,21 @@ pub fn expand_file(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) let topmost = topmost_expn_info(cx.backtrace().unwrap()); let loc = cx.codemap().lookup_char_pos(topmost.call_site.lo); - let filename = loc.file.name; + let filename = token::intern_and_get_ident(loc.file.name); base::MRExpr(cx.expr_str(topmost.call_site, filename)) } pub fn expand_stringify(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) -> base::MacResult { let s = pprust::tts_to_str(tts, get_ident_interner()); - base::MRExpr(cx.expr_str(sp, s.to_managed())) + base::MRExpr(cx.expr_str(sp, token::intern_and_get_ident(s))) } pub fn expand_mod(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) -> 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("::").to_managed())) + let string = cx.mod_path().map(|x| cx.str_of(*x)).connect("::"); + base::MRExpr(cx.expr_str(sp, token::intern_and_get_ident(string))) } // include! : parse the given file as an expr @@ -117,7 +118,7 @@ pub fn expand_include_str(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) let filename = file.display().to_str().to_managed(); cx.parse_sess.cm.new_filemap(filename, src); - base::MRExpr(cx.expr_str(sp, src)) + base::MRExpr(cx.expr_str(sp, token::intern_and_get_ident(src))) } None => { cx.span_err(sp, format!("{} wasn't a utf-8 file", file.display())); diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs index c2d54a4f368..9a346e17d28 100644 --- a/src/libsyntax/fold.rs +++ b/src/libsyntax/fold.rs @@ -326,7 +326,9 @@ fn fold_meta_item_(mi: @MetaItem, fld: &mut T) -> @MetaItem { let fold_meta_item = |x| fold_meta_item_(x, fld); MetaList((*id).clone(), mis.map(|e| fold_meta_item(*e))) } - MetaNameValue(ref id, s) => MetaNameValue((*id).clone(), s) + MetaNameValue(ref id, ref s) => { + MetaNameValue((*id).clone(), (*s).clone()) + } }, span: fld.new_span(mi.span) } } diff --git a/src/libsyntax/parse/attr.rs b/src/libsyntax/parse/attr.rs index bc9f7e4b195..c9bea78d02d 100644 --- a/src/libsyntax/parse/attr.rs +++ b/src/libsyntax/parse/attr.rs @@ -45,7 +45,7 @@ impl ParserAttr for Parser { } token::DOC_COMMENT(s) => { let attr = ::attr::mk_sugared_doc_attr( - self.id_to_str(s), + self.id_to_interned_str(s), self.span.lo, self.span.hi ); @@ -133,7 +133,7 @@ impl ParserAttr for Parser { } token::DOC_COMMENT(s) => { self.bump(); - ::attr::mk_sugared_doc_attr(self.id_to_str(s), + ::attr::mk_sugared_doc_attr(self.id_to_interned_str(s), self.span.lo, self.span.hi) } diff --git a/src/libsyntax/parse/comments.rs b/src/libsyntax/parse/comments.rs index aa5e4e01ae0..21a34ab5e1e 100644 --- a/src/libsyntax/parse/comments.rs +++ b/src/libsyntax/parse/comments.rs @@ -54,7 +54,6 @@ pub fn doc_comment_style(comment: &str) -> ast::AttrStyle { } pub fn strip_doc_comment_decoration(comment: &str) -> ~str { - /// remove whitespace-only lines from the start/end of lines fn vertical_trim(lines: ~[~str]) -> ~[~str] { let mut i = 0u; diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 93264f5a6c6..636dc504ff2 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -345,7 +345,7 @@ pub struct Parser { /// extra detail when the same error is seen twice obsolete_set: HashSet, /// Used to determine the path to externally loaded source files - mod_path_stack: ~[@str], + mod_path_stack: ~[InternedString], /// Stack of spans of open delimiters. Used for error message. open_braces: ~[Span], /* do not copy the parser; its state is tied to outside state */ @@ -1408,8 +1408,12 @@ impl Parser { token::LIT_FLOAT(s, ft) => LitFloat(self.id_to_str(s), ft), token::LIT_FLOAT_UNSUFFIXED(s) => LitFloatUnsuffixed(self.id_to_str(s)), - token::LIT_STR(s) => LitStr(self.id_to_str(s), ast::CookedStr), - token::LIT_STR_RAW(s, n) => LitStr(self.id_to_str(s), ast::RawStr(n)), + token::LIT_STR(s) => { + LitStr(self.id_to_interned_str(s), ast::CookedStr) + } + token::LIT_STR_RAW(s, n) => { + LitStr(self.id_to_interned_str(s), ast::RawStr(n)) + } token::LPAREN => { self.expect(&token::RPAREN); LitNil }, _ => { self.unexpected_last(tok); } } @@ -4146,11 +4150,11 @@ impl Parser { } fn push_mod_path(&mut self, id: Ident, attrs: &[Attribute]) { - let default_path = token::interner_get(id.name); + let default_path = self.id_to_interned_str(id); let file_path = match ::attr::first_attr_value_str_by_name(attrs, "path") { Some(d) => d, - None => default_path + None => default_path, }; self.mod_path_stack.push(file_path) } diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs index 97b9b4d53a4..9291cba54f6 100644 --- a/src/libsyntax/parse/token.rs +++ b/src/libsyntax/parse/token.rs @@ -20,6 +20,7 @@ use std::cast; use std::char; use std::fmt; use std::local_data; +use std::path::BytesContainer; #[allow(non_camel_case_types)] #[deriving(Clone, Encodable, Decodable, Eq, IterBytes)] @@ -537,7 +538,7 @@ pub fn get_ident_interner() -> @IdentInterner { /// be fixed in the future by just leaking all strings until task death /// somehow. #[no_send] -#[deriving(Clone, Eq, IterBytes, TotalEq, TotalOrd)] +#[deriving(Clone, Eq, IterBytes, Ord, TotalEq, TotalOrd)] pub struct InternedString { priv string: @str, } @@ -571,6 +572,17 @@ impl InternedString { } } +impl BytesContainer for InternedString { + fn container_as_bytes<'a>(&'a self) -> &'a [u8] { + // XXX(pcwalton): This is a workaround for the incorrect signature of + // `BytesContainer`, which is itself a workaround for the lack of DST. + unsafe { + let this = self.get(); + cast::transmute(this.container_as_bytes()) + } + } +} + impl fmt::Default for InternedString { fn fmt(obj: &InternedString, f: &mut fmt::Formatter) { write!(f.buf, "{}", obj.string); diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index 89d8173f7e7..32b0766249e 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -897,7 +897,7 @@ pub fn print_attribute(s: &mut State, attr: &ast::Attribute) { maybe_print_comment(s, attr.span.lo); if attr.node.is_sugared_doc { let comment = attr.value_str().unwrap(); - word(&mut s.s, comment); + word(&mut s.s, comment.get()); } else { word(&mut s.s, "#["); print_meta_item(s, attr.meta()); @@ -1931,10 +1931,10 @@ pub fn print_meta_item(s: &mut State, item: &ast::MetaItem) { ibox(s, indent_unit); match item.node { ast::MetaWord(ref name) => word(&mut s.s, name.get()), - ast::MetaNameValue(ref name, value) => { + ast::MetaNameValue(ref name, ref value) => { word_space(s, name.get()); word_space(s, "="); - print_literal(s, &value); + print_literal(s, value); } ast::MetaList(ref name, ref items) => { word(&mut s.s, name.get()); @@ -2172,7 +2172,7 @@ pub fn print_literal(s: &mut State, lit: &ast::Lit) { _ => () } match lit.node { - ast::LitStr(st, style) => print_string(s, st, style), + ast::LitStr(ref st, style) => print_string(s, st.get(), style), ast::LitChar(ch) => { let mut res = ~"'"; char::from_u32(ch).unwrap().escape_default(|c| res.push_char(c)); -- cgit 1.4.1-3-g733a5 From f152be7a425e7d66f717ffe8b210bcacf82539cc Mon Sep 17 00:00:00 2001 From: Patrick Walton Date: Wed, 15 Jan 2014 16:01:14 -0800 Subject: libsyntax: Remove the unnecessary `src` field from the lexer --- src/libsyntax/parse/lexer.rs | 15 ++++++--------- 1 file changed, 6 insertions(+), 9 deletions(-) (limited to 'src/libsyntax/parse') diff --git a/src/libsyntax/parse/lexer.rs b/src/libsyntax/parse/lexer.rs index 2521bb515f7..469d3d64f24 100644 --- a/src/libsyntax/parse/lexer.rs +++ b/src/libsyntax/parse/lexer.rs @@ -42,7 +42,6 @@ pub struct TokenAndSpan { pub struct StringReader { span_diagnostic: @SpanHandler, - src: @str, // The absolute offset within the codemap of the next character to read pos: Cell, // The absolute offset within the codemap of the last character read(curr) @@ -73,7 +72,6 @@ pub fn new_low_level_string_reader(span_diagnostic: @SpanHandler, let initial_char = '\n'; let r = @StringReader { span_diagnostic: span_diagnostic, - src: filemap.src, pos: Cell::new(filemap.start_pos), last_pos: Cell::new(filemap.start_pos), col: Cell::new(CharPos(0)), @@ -93,7 +91,6 @@ pub fn new_low_level_string_reader(span_diagnostic: @SpanHandler, fn dup_string_reader(r: @StringReader) -> @StringReader { @StringReader { span_diagnostic: r.span_diagnostic, - src: r.src, pos: Cell::new(r.pos.get()), last_pos: Cell::new(r.last_pos.get()), col: Cell::new(r.col.get()), @@ -188,7 +185,7 @@ fn fatal_span_verbose(rdr: @StringReader, -> ! { let mut m = m; m.push_str(": "); - let s = rdr.src.slice( + let s = rdr.filemap.src.slice( byte_offset(rdr, from_pos).to_uint(), byte_offset(rdr, to_pos).to_uint()); m.push_str(s); @@ -239,7 +236,7 @@ fn with_str_from_to( end: BytePos, f: |s: &str| -> T) -> T { - f(rdr.src.slice( + f(rdr.filemap.src.slice( byte_offset(rdr, start).to_uint(), byte_offset(rdr, end).to_uint())) } @@ -249,12 +246,12 @@ fn with_str_from_to( pub fn bump(rdr: &StringReader) { rdr.last_pos.set(rdr.pos.get()); let current_byte_offset = byte_offset(rdr, rdr.pos.get()).to_uint(); - if current_byte_offset < (rdr.src).len() { + if current_byte_offset < (rdr.filemap.src).len() { assert!(rdr.curr.get() != unsafe { transmute(-1u32) }); // FIXME: #8971: unsound let last_char = rdr.curr.get(); - let next = rdr.src.char_range_at(current_byte_offset); + let next = rdr.filemap.src.char_range_at(current_byte_offset); let byte_offset_diff = next.next - current_byte_offset; rdr.pos.set(rdr.pos.get() + Pos::from_uint(byte_offset_diff)); rdr.curr.set(next.ch); @@ -277,8 +274,8 @@ pub fn is_eof(rdr: @StringReader) -> bool { } pub fn nextch(rdr: @StringReader) -> char { let offset = byte_offset(rdr, rdr.pos.get()).to_uint(); - if offset < (rdr.src).len() { - return rdr.src.char_at(offset); + if offset < (rdr.filemap.src).len() { + return rdr.filemap.src.char_at(offset); } else { return unsafe { transmute(-1u32) }; } // FIXME: #8971: unsound } -- cgit 1.4.1-3-g733a5 From e68108b3e8b8eaef62bb7b7340a77b96fcfc51cd Mon Sep 17 00:00:00 2001 From: Patrick Walton Date: Wed, 15 Jan 2014 16:26:20 -0800 Subject: librustc: Stop using `@str` for source. --- src/librustc/driver/driver.rs | 15 +++--- src/librustc/lib.rs | 13 ++++-- src/librustdoc/test.rs | 4 +- src/libsyntax/codemap.rs | 4 +- src/libsyntax/ext/expand.rs | 2 +- src/libsyntax/ext/quote.rs | 22 ++++----- src/libsyntax/ext/source_util.rs | 4 +- src/libsyntax/parse/comments.rs | 2 +- src/libsyntax/parse/mod.rs | 88 +++++++++++++++++------------------- src/libsyntax/util/parser_testing.rs | 22 ++++----- 10 files changed, 87 insertions(+), 89 deletions(-) (limited to 'src/libsyntax/parse') diff --git a/src/librustc/driver/driver.rs b/src/librustc/driver/driver.rs index 4a3e2ac5e2a..bdefc341872 100644 --- a/src/librustc/driver/driver.rs +++ b/src/librustc/driver/driver.rs @@ -138,7 +138,7 @@ fn parse_cfgspecs(cfgspecs: ~[~str], demitter: @diagnostic::Emitter) -> ast::CrateConfig { cfgspecs.move_iter().map(|s| { let sess = parse::new_parse_sess(Some(demitter)); - parse::parse_meta_from_source_str(@"cfgspec", s.to_managed(), ~[], sess) + parse::parse_meta_from_source_str(@"cfgspec", s, ~[], sess) }).collect::() } @@ -146,8 +146,7 @@ pub enum Input { /// Load source from file FileInput(Path), /// The string is the source - // FIXME (#2319): Don't really want to box the source string - StrInput(@str) + StrInput(~str) } pub fn phase_1_parse_input(sess: Session, cfg: ast::CrateConfig, input: &Input) @@ -157,9 +156,11 @@ pub fn phase_1_parse_input(sess: Session, cfg: ast::CrateConfig, input: &Input) FileInput(ref file) => { parse::parse_crate_from_file(&(*file), cfg.clone(), sess.parse_sess) } - StrInput(src) => { - parse::parse_crate_from_source_str( - anon_src(), src, cfg.clone(), sess.parse_sess) + StrInput(ref src) => { + parse::parse_crate_from_source_str(anon_src(), + (*src).clone(), + cfg.clone(), + sess.parse_sess) } } }) @@ -624,7 +625,7 @@ pub fn pretty_print_input(sess: Session, _ => @pprust::NoAnn as @pprust::PpAnn, }; - let src = sess.codemap.get_filemap(source_name(input)).src; + let src = &sess.codemap.get_filemap(source_name(input)).src; let mut rdr = MemReader::new(src.as_bytes().to_owned()); let stdout = io::stdout(); pprust::print_crate(sess.codemap, diff --git a/src/librustc/lib.rs b/src/librustc/lib.rs index c840faecb55..c34f881b2db 100644 --- a/src/librustc/lib.rs +++ b/src/librustc/lib.rs @@ -236,8 +236,9 @@ pub fn run_compiler(args: &[~str], demitter: @diagnostic::Emitter) { 1u => { let ifile = matches.free[0].as_slice(); if "-" == ifile { - let src = str::from_utf8_owned(io::stdin().read_to_end()).unwrap(); - (d::StrInput(src.to_managed()), None) + let src = + str::from_utf8_owned(io::stdin().read_to_end()).unwrap(); + (d::StrInput(src), None) } else { (d::FileInput(Path::new(ifile)), Some(Path::new(ifile))) } @@ -319,9 +320,11 @@ fn parse_crate_attrs(sess: session::Session, d::FileInput(ref ifile) => { parse::parse_crate_attrs_from_file(ifile, ~[], sess.parse_sess) } - d::StrInput(src) => { - parse::parse_crate_attrs_from_source_str( - d::anon_src(), src, ~[], sess.parse_sess) + d::StrInput(ref src) => { + parse::parse_crate_attrs_from_source_str(d::anon_src(), + (*src).clone(), + ~[], + sess.parse_sess) } } } diff --git a/src/librustdoc/test.rs b/src/librustdoc/test.rs index 9271af9d575..12874d1b502 100644 --- a/src/librustdoc/test.rs +++ b/src/librustdoc/test.rs @@ -137,7 +137,7 @@ fn runtest(test: &str, cratename: &str, libs: HashSet) { } } -fn maketest(s: &str, cratename: &str) -> @str { +fn maketest(s: &str, cratename: &str) -> ~str { let mut prog = ~r" #[deny(warnings)]; #[allow(unused_variable, dead_assignment, unused_mut, attribute_usage, dead_code)]; @@ -156,7 +156,7 @@ fn maketest(s: &str, cratename: &str) -> @str { prog.push_str("\n}"); } - return prog.to_managed(); + return prog; } pub struct Collector { diff --git a/src/libsyntax/codemap.rs b/src/libsyntax/codemap.rs index d4a412bbe9f..16b31f0a415 100644 --- a/src/libsyntax/codemap.rs +++ b/src/libsyntax/codemap.rs @@ -206,7 +206,7 @@ pub struct FileMap { /// e.g. `` name: FileName, /// 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 @@ -267,7 +267,7 @@ impl CodeMap { } } - pub fn new_filemap(&self, filename: FileName, src: @str) -> @FileMap { + pub fn new_filemap(&self, filename: FileName, src: ~str) -> @FileMap { let mut files = self.files.borrow_mut(); let start_pos = match files.get().last() { None => 0, diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs index d98a549725c..3eaafba55cd 100644 --- a/src/libsyntax/ext/expand.rs +++ b/src/libsyntax/ext/expand.rs @@ -1047,7 +1047,7 @@ mod test { ~[], sess); // should fail: let mut loader = ErrLoader; - expand_crate(sess,&mut loader,~[],crate_ast); + expand_crate(sess, &mut loader, ~[], crate_ast); } #[test] fn test_contains_flatten (){ diff --git a/src/libsyntax/ext/quote.rs b/src/libsyntax/ext/quote.rs index 71879fc2f1e..11f61c340fc 100644 --- a/src/libsyntax/ext/quote.rs +++ b/src/libsyntax/ext/quote.rs @@ -203,7 +203,7 @@ pub mod rt { ($t:ty) => ( impl ToTokens for $t { fn to_tokens(&self, cx: &ExtCtxt) -> ~[TokenTree] { - cx.parse_tts(self.to_source().to_managed()) + cx.parse_tts(self.to_source()) } } ) @@ -213,7 +213,7 @@ pub mod rt { ($t:ty) => ( impl<'a> ToTokens for $t { fn to_tokens(&self, cx: &ExtCtxt) -> ~[TokenTree] { - cx.parse_tts(self.to_source().to_managed()) + cx.parse_tts(self.to_source()) } } ) @@ -240,15 +240,15 @@ pub mod rt { impl_to_tokens!(u64) 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::TokenTree]; + 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::TokenTree]; } impl<'a> ExtParseUtils for ExtCtxt<'a> { - fn parse_item(&self, s: @str) -> @ast::Item { + fn parse_item(&self, s: ~str) -> @ast::Item { let res = parse::parse_item_from_source_str( @"", s, @@ -257,13 +257,13 @@ pub mod rt { match res { Some(ast) => ast, None => { - error!("Parse error with ```\n{}\n```", s); + error!("Parse error"); fail!() } } } - fn parse_stmt(&self, s: @str) -> @ast::Stmt { + fn parse_stmt(&self, s: ~str) -> @ast::Stmt { parse::parse_stmt_from_source_str( @"", s, @@ -272,7 +272,7 @@ pub mod rt { 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( @"", s, @@ -280,7 +280,7 @@ pub mod rt { self.parse_sess()) } - fn parse_tts(&self, s: @str) -> ~[ast::TokenTree] { + fn parse_tts(&self, s: ~str) -> ~[ast::TokenTree] { parse::parse_tts_from_source_str( @"", s, diff --git a/src/libsyntax/ext/source_util.rs b/src/libsyntax/ext/source_util.rs index b67f3ed263e..1367ab0677e 100644 --- a/src/libsyntax/ext/source_util.rs +++ b/src/libsyntax/ext/source_util.rs @@ -114,11 +114,11 @@ pub fn expand_include_str(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) Some(src) => { // Add this input file to the code map to make it available as // dependency information - let src = src.to_managed(); let filename = file.display().to_str().to_managed(); + let interned = token::intern_and_get_ident(src); cx.parse_sess.cm.new_filemap(filename, src); - base::MRExpr(cx.expr_str(sp, token::intern_and_get_ident(src))) + base::MRExpr(cx.expr_str(sp, interned)) } None => { cx.span_err(sp, format!("{} wasn't a utf-8 file", file.display())); diff --git a/src/libsyntax/parse/comments.rs b/src/libsyntax/parse/comments.rs index 21a34ab5e1e..bbd0e00f4dd 100644 --- a/src/libsyntax/parse/comments.rs +++ b/src/libsyntax/parse/comments.rs @@ -350,7 +350,7 @@ pub fn gather_comments_and_literals(span_diagnostic: path: @str, srdr: &mut io::Reader) -> (~[Comment], ~[Literal]) { - let src = str::from_utf8_owned(srdr.read_to_end()).unwrap().to_managed(); + let src = str::from_utf8_owned(srdr.read_to_end()).unwrap(); 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/mod.rs b/src/libsyntax/parse/mod.rs index e026a11cafe..e7bc5ff3df3 100644 --- a/src/libsyntax/parse/mod.rs +++ b/src/libsyntax/parse/mod.rs @@ -89,12 +89,11 @@ pub fn parse_crate_attrs_from_file( return inner; } -pub fn parse_crate_from_source_str( - name: @str, - source: @str, - cfg: ast::CrateConfig, - sess: @ParseSess -) -> ast::Crate { +pub fn parse_crate_from_source_str(name: @str, + source: ~str, + cfg: ast::CrateConfig, + sess: @ParseSess) + -> ast::Crate { let mut p = new_parser_from_source_str(sess, /*bad*/ cfg.clone(), name, @@ -102,12 +101,11 @@ pub fn parse_crate_from_source_str( maybe_aborted(p.parse_crate_mod(),p) } -pub fn parse_crate_attrs_from_source_str( - name: @str, - source: @str, - cfg: ast::CrateConfig, - sess: @ParseSess -) -> ~[ast::Attribute] { +pub fn parse_crate_attrs_from_source_str(name: @str, + source: ~str, + cfg: ast::CrateConfig, + sess: @ParseSess) + -> ~[ast::Attribute] { let mut p = new_parser_from_source_str(sess, /*bad*/ cfg.clone(), name, @@ -116,44 +114,40 @@ pub fn parse_crate_attrs_from_source_str( return inner; } -pub fn parse_expr_from_source_str( - name: @str, - source: @str, - cfg: ast::CrateConfig, - sess: @ParseSess -) -> @ast::Expr { +pub fn parse_expr_from_source_str(name: @str, + source: ~str, + cfg: ast::CrateConfig, + sess: @ParseSess) + -> @ast::Expr { let mut p = new_parser_from_source_str(sess, cfg, name, source); maybe_aborted(p.parse_expr(), p) } -pub fn parse_item_from_source_str( - name: @str, - source: @str, - cfg: ast::CrateConfig, - sess: @ParseSess -) -> Option<@ast::Item> { +pub fn parse_item_from_source_str(name: @str, + source: ~str, + cfg: ast::CrateConfig, + sess: @ParseSess) + -> Option<@ast::Item> { let mut p = new_parser_from_source_str(sess, cfg, name, source); let attrs = p.parse_outer_attributes(); maybe_aborted(p.parse_item(attrs),p) } -pub fn parse_meta_from_source_str( - name: @str, - source: @str, - cfg: ast::CrateConfig, - sess: @ParseSess -) -> @ast::MetaItem { +pub fn parse_meta_from_source_str(name: @str, + source: ~str, + cfg: ast::CrateConfig, + sess: @ParseSess) + -> @ast::MetaItem { let mut p = new_parser_from_source_str(sess, cfg, name, source); maybe_aborted(p.parse_meta_item(),p) } -pub fn parse_stmt_from_source_str( - name: @str, - source: @str, - cfg: ast::CrateConfig, - attrs: ~[ast::Attribute], - sess: @ParseSess -) -> @ast::Stmt { +pub fn parse_stmt_from_source_str(name: @str, + source: ~str, + cfg: ast::CrateConfig, + attrs: ~[ast::Attribute], + sess: @ParseSess) + -> @ast::Stmt { let mut p = new_parser_from_source_str( sess, cfg, @@ -163,12 +157,11 @@ pub fn parse_stmt_from_source_str( maybe_aborted(p.parse_stmt(attrs),p) } -pub fn parse_tts_from_source_str( - name: @str, - source: @str, - cfg: ast::CrateConfig, - sess: @ParseSess -) -> ~[ast::TokenTree] { +pub fn parse_tts_from_source_str(name: @str, + source: ~str, + cfg: ast::CrateConfig, + sess: @ParseSess) + -> ~[ast::TokenTree] { let mut p = new_parser_from_source_str( sess, cfg, @@ -184,8 +177,8 @@ pub fn parse_tts_from_source_str( pub fn new_parser_from_source_str(sess: @ParseSess, cfg: ast::CrateConfig, name: @str, - source: @str) - -> Parser { + source: ~str) + -> Parser { filemap_to_parser(sess,string_to_filemap(sess,source,name),cfg) } @@ -248,7 +241,8 @@ pub fn file_to_filemap(sess: @ParseSess, path: &Path, spanopt: Option) }; match str::from_utf8_owned(bytes) { Some(s) => { - return string_to_filemap(sess, s.to_managed(), + return string_to_filemap(sess, + s, path.as_str().unwrap().to_managed()); } None => { @@ -260,7 +254,7 @@ pub fn file_to_filemap(sess: @ParseSess, path: &Path, spanopt: Option) // 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: @ParseSess, source: @str, path: @str) +pub fn string_to_filemap(sess: @ParseSess, source: ~str, path: @str) -> @FileMap { sess.cm.new_filemap(path, source) } diff --git a/src/libsyntax/util/parser_testing.rs b/src/libsyntax/util/parser_testing.rs index dd3ae168149..02bfa31d0e1 100644 --- a/src/libsyntax/util/parser_testing.rs +++ b/src/libsyntax/util/parser_testing.rs @@ -17,29 +17,29 @@ use parse::token; // map a string to tts, using a made-up filename: return both the TokenTree's // and the ParseSess -pub fn string_to_tts_and_sess (source_str : @str) -> (~[ast::TokenTree], @ParseSess) { +pub fn string_to_tts_and_sess (source_str : ~str) -> (~[ast::TokenTree], @ParseSess) { let ps = new_parse_sess(None); (filemap_to_tts(ps,string_to_filemap(ps,source_str,@"bogofile")),ps) } // map a string to tts, using a made-up filename: -pub fn string_to_tts(source_str : @str) -> ~[ast::TokenTree] { +pub fn string_to_tts(source_str : ~str) -> ~[ast::TokenTree] { let (tts,_) = string_to_tts_and_sess(source_str); tts } -pub fn string_to_parser_and_sess(source_str: @str) -> (Parser,@ParseSess) { +pub fn string_to_parser_and_sess(source_str: ~str) -> (Parser,@ParseSess) { let ps = new_parse_sess(None); (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 } -fn with_error_checking_parse(s: @str, f: |&mut Parser| -> T) -> T { +fn with_error_checking_parse(s: ~str, f: |&mut Parser| -> T) -> T { let mut p = string_to_parser(s); let x = f(&mut p); p.abort_if_errors(); @@ -47,34 +47,34 @@ fn with_error_checking_parse(s: @str, f: |&mut Parser| -> T) -> T { } // parse a string, return a crate. -pub fn string_to_crate (source_str : @str) -> ast::Crate { +pub fn string_to_crate (source_str : ~str) -> ast::Crate { with_error_checking_parse(source_str, |p| { p.parse_crate_mod() }) } // parse a string, return a crate and the ParseSess -pub fn string_to_crate_and_sess (source_str : @str) -> (ast::Crate,@ParseSess) { +pub fn string_to_crate_and_sess (source_str : ~str) -> (ast::Crate,@ParseSess) { let (mut p,ps) = string_to_parser_and_sess(source_str); (p.parse_crate_mod(),ps) } // 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 { with_error_checking_parse(source_str, |p| { p.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> { with_error_checking_parse(source_str, |p| { p.parse_item(~[]) }) } // 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 { with_error_checking_parse(source_str, |p| { p.parse_stmt(~[]) }) @@ -82,7 +82,7 @@ pub fn string_to_stmt(source_str : @str) -> @ast::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() } -- cgit 1.4.1-3-g733a5 From 8d6ef2e1b198461fde48565c7efdf92a83a33abd Mon Sep 17 00:00:00 2001 From: Patrick Walton Date: Wed, 15 Jan 2014 16:42:51 -0800 Subject: libsyntax: De-`@str` pathnames --- src/librustc/driver/driver.rs | 14 ++++++++------ src/librustc/middle/trans/debuginfo.rs | 6 +++--- src/libsyntax/codemap.rs | 6 +++--- src/libsyntax/ext/quote.rs | 31 ++++++++++++++----------------- src/libsyntax/ext/source_util.rs | 2 +- src/libsyntax/parse/comments.rs | 2 +- src/libsyntax/parse/mod.rs | 28 ++++++++++++---------------- src/libsyntax/print/pprust.rs | 2 +- 8 files changed, 43 insertions(+), 48 deletions(-) (limited to 'src/libsyntax/parse') diff --git a/src/librustc/driver/driver.rs b/src/librustc/driver/driver.rs index bdefc341872..b808efb3d5b 100644 --- a/src/librustc/driver/driver.rs +++ b/src/librustc/driver/driver.rs @@ -61,12 +61,14 @@ pub enum PpMode { * The name used for source code that doesn't originate in a file * (e.g. source from stdin or a string) */ -pub fn anon_src() -> @str { @"" } +pub fn anon_src() -> ~str { + "".to_str() +} -pub fn source_name(input: &Input) -> @str { +pub fn source_name(input: &Input) -> ~str { match *input { // FIXME (#9639): This needs to handle non-utf8 paths - FileInput(ref ifile) => ifile.as_str().unwrap().to_managed(), + FileInput(ref ifile) => ifile.as_str().unwrap().to_str(), StrInput(_) => anon_src() } } @@ -138,7 +140,7 @@ fn parse_cfgspecs(cfgspecs: ~[~str], demitter: @diagnostic::Emitter) -> ast::CrateConfig { cfgspecs.move_iter().map(|s| { let sess = parse::new_parse_sess(Some(demitter)); - parse::parse_meta_from_source_str(@"cfgspec", s, ~[], sess) + parse::parse_meta_from_source_str("cfgspec".to_str(), s, ~[], sess) }).collect::() } @@ -484,13 +486,13 @@ fn write_out_deps(sess: Session, input: &Input, outputs: &OutputFilenames, crate // Build a list of files used to compile the output and // write Makefile-compatible dependency rules - let files: ~[@str] = { + let files: ~[~str] = { let files = sess.codemap.files.borrow(); files.get() .iter() .filter_map(|fmap| { if fmap.is_real_file() { - Some(fmap.name) + Some(fmap.name.clone()) } else { None } diff --git a/src/librustc/middle/trans/debuginfo.rs b/src/librustc/middle/trans/debuginfo.rs index 36cc6f3afd1..030f38b1745 100644 --- a/src/librustc/middle/trans/debuginfo.rs +++ b/src/librustc/middle/trans/debuginfo.rs @@ -931,7 +931,7 @@ fn declare_local(bcx: &Block, span: Span) { let cx: &CrateContext = bcx.ccx(); - let filename = span_start(cx, span).file.name; + let filename = span_start(cx, span).file.name.clone(); let file_metadata = file_metadata(cx, filename); let name: &str = token::ident_to_str(&variable_ident); @@ -1165,7 +1165,7 @@ fn prepare_struct_metadata(cx: &CrateContext, let (containing_scope, definition_span) = get_namespace_and_span_for_item(cx, def_id, span); - let file_name = span_start(cx, definition_span).file.name; + let file_name = span_start(cx, definition_span).file.name.clone(); let file_metadata = file_metadata(cx, file_name); let struct_metadata_stub = create_struct_stub(cx, @@ -2006,7 +2006,7 @@ fn trait_metadata(cx: &CrateContext, let (containing_scope, definition_span) = get_namespace_and_span_for_item(cx, def_id, usage_site_span); - let file_name = span_start(cx, definition_span).file.name; + let file_name = span_start(cx, definition_span).file.name.clone(); let file_metadata = file_metadata(cx, file_name); let trait_llvm_type = type_of::type_of(cx, trait_type); diff --git a/src/libsyntax/codemap.rs b/src/libsyntax/codemap.rs index 16b31f0a415..3002bc3d40e 100644 --- a/src/libsyntax/codemap.rs +++ b/src/libsyntax/codemap.rs @@ -183,7 +183,7 @@ pub struct ExpnInfo { callee: NameAndSpan } -pub type FileName = @str; +pub type FileName = ~str; pub struct FileLines { @@ -301,7 +301,7 @@ impl CodeMap { pub fn lookup_char_pos_adj(&self, pos: BytePos) -> LocWithOpt { let loc = self.lookup_char_pos(pos); LocWithOpt { - filename: loc.file.name, + filename: loc.file.name.to_str(), line: loc.line, col: loc.col, file: Some(loc.file) @@ -324,7 +324,7 @@ impl CodeMap { pub fn span_to_filename(&self, sp: Span) -> FileName { let lo = self.lookup_char_pos(sp.lo); - lo.file.name + lo.file.name.to_str() } pub fn span_to_lines(&self, sp: Span) -> @FileLines { diff --git a/src/libsyntax/ext/quote.rs b/src/libsyntax/ext/quote.rs index 11f61c340fc..bd1ac616f52 100644 --- a/src/libsyntax/ext/quote.rs +++ b/src/libsyntax/ext/quote.rs @@ -250,7 +250,7 @@ pub mod rt { fn parse_item(&self, s: ~str) -> @ast::Item { let res = parse::parse_item_from_source_str( - @"", + "".to_str(), s, self.cfg(), self.parse_sess()); @@ -264,28 +264,25 @@ pub mod rt { } fn parse_stmt(&self, s: ~str) -> @ast::Stmt { - parse::parse_stmt_from_source_str( - @"", - s, - self.cfg(), - ~[], - self.parse_sess()) + parse::parse_stmt_from_source_str("".to_str(), + s, + self.cfg(), + ~[], + self.parse_sess()) } fn parse_expr(&self, s: ~str) -> @ast::Expr { - parse::parse_expr_from_source_str( - @"", - s, - self.cfg(), - self.parse_sess()) + parse::parse_expr_from_source_str("".to_str(), + s, + self.cfg(), + self.parse_sess()) } fn parse_tts(&self, s: ~str) -> ~[ast::TokenTree] { - parse::parse_tts_from_source_str( - @"", - s, - self.cfg(), - self.parse_sess()) + parse::parse_tts_from_source_str("".to_str(), + s, + self.cfg(), + self.parse_sess()) } } diff --git a/src/libsyntax/ext/source_util.rs b/src/libsyntax/ext/source_util.rs index 1367ab0677e..a248cd84f71 100644 --- a/src/libsyntax/ext/source_util.rs +++ b/src/libsyntax/ext/source_util.rs @@ -114,7 +114,7 @@ pub fn expand_include_str(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) Some(src) => { // Add this input file to the code map to make it available as // dependency information - let filename = file.display().to_str().to_managed(); + let filename = file.display().to_str(); let interned = token::intern_and_get_ident(src); cx.parse_sess.cm.new_filemap(filename, src); diff --git a/src/libsyntax/parse/comments.rs b/src/libsyntax/parse/comments.rs index bbd0e00f4dd..7165e7b404f 100644 --- a/src/libsyntax/parse/comments.rs +++ b/src/libsyntax/parse/comments.rs @@ -347,7 +347,7 @@ pub struct Literal { // probably not a good thing. pub fn gather_comments_and_literals(span_diagnostic: @diagnostic::SpanHandler, - path: @str, + path: ~str, srdr: &mut io::Reader) -> (~[Comment], ~[Literal]) { let src = str::from_utf8_owned(srdr.read_to_end()).unwrap(); diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs index e7bc5ff3df3..76ccc53b846 100644 --- a/src/libsyntax/parse/mod.rs +++ b/src/libsyntax/parse/mod.rs @@ -89,7 +89,7 @@ pub fn parse_crate_attrs_from_file( return inner; } -pub fn parse_crate_from_source_str(name: @str, +pub fn parse_crate_from_source_str(name: ~str, source: ~str, cfg: ast::CrateConfig, sess: @ParseSess) @@ -101,7 +101,7 @@ pub fn parse_crate_from_source_str(name: @str, maybe_aborted(p.parse_crate_mod(),p) } -pub fn parse_crate_attrs_from_source_str(name: @str, +pub fn parse_crate_attrs_from_source_str(name: ~str, source: ~str, cfg: ast::CrateConfig, sess: @ParseSess) @@ -114,7 +114,7 @@ pub fn parse_crate_attrs_from_source_str(name: @str, return inner; } -pub fn parse_expr_from_source_str(name: @str, +pub fn parse_expr_from_source_str(name: ~str, source: ~str, cfg: ast::CrateConfig, sess: @ParseSess) @@ -123,7 +123,7 @@ pub fn parse_expr_from_source_str(name: @str, maybe_aborted(p.parse_expr(), p) } -pub fn parse_item_from_source_str(name: @str, +pub fn parse_item_from_source_str(name: ~str, source: ~str, cfg: ast::CrateConfig, sess: @ParseSess) @@ -133,7 +133,7 @@ pub fn parse_item_from_source_str(name: @str, maybe_aborted(p.parse_item(attrs),p) } -pub fn parse_meta_from_source_str(name: @str, +pub fn parse_meta_from_source_str(name: ~str, source: ~str, cfg: ast::CrateConfig, sess: @ParseSess) @@ -142,7 +142,7 @@ pub fn parse_meta_from_source_str(name: @str, maybe_aborted(p.parse_meta_item(),p) } -pub fn parse_stmt_from_source_str(name: @str, +pub fn parse_stmt_from_source_str(name: ~str, source: ~str, cfg: ast::CrateConfig, attrs: ~[ast::Attribute], @@ -157,7 +157,7 @@ pub fn parse_stmt_from_source_str(name: @str, maybe_aborted(p.parse_stmt(attrs),p) } -pub fn parse_tts_from_source_str(name: @str, +pub fn parse_tts_from_source_str(name: ~str, source: ~str, cfg: ast::CrateConfig, sess: @ParseSess) @@ -176,7 +176,7 @@ pub fn parse_tts_from_source_str(name: @str, // Create a new parser from a source string pub fn new_parser_from_source_str(sess: @ParseSess, cfg: ast::CrateConfig, - name: @str, + name: ~str, source: ~str) -> Parser { filemap_to_parser(sess,string_to_filemap(sess,source,name),cfg) @@ -241,21 +241,17 @@ pub fn file_to_filemap(sess: @ParseSess, path: &Path, spanopt: Option) }; match str::from_utf8_owned(bytes) { Some(s) => { - return string_to_filemap(sess, - s, - path.as_str().unwrap().to_managed()); - } - None => { - err(format!("{} is not UTF-8 encoded", path.display())) + return string_to_filemap(sess, s, path.as_str().unwrap().to_str()) } + None => err(format!("{} is not UTF-8 encoded", path.display())), } unreachable!() } // 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: @ParseSess, source: ~str, path: @str) - -> @FileMap { +pub fn string_to_filemap(sess: @ParseSess, source: ~str, path: ~str) + -> @FileMap { sess.cm.new_filemap(path, source) } diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index 32b0766249e..8bf439818a2 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -117,7 +117,7 @@ pub fn print_crate(cm: @CodeMap, intr: @IdentInterner, span_diagnostic: @diagnostic::SpanHandler, crate: &ast::Crate, - filename: @str, + filename: ~str, input: &mut io::Reader, out: ~io::Writer, ann: @PpAnn, -- cgit 1.4.1-3-g733a5 From b496d7bec2a79feab092e6b4e251f7b0cee2a6a6 Mon Sep 17 00:00:00 2001 From: Patrick Walton Date: Wed, 15 Jan 2014 17:15:39 -0800 Subject: libsyntax: Make float literals not use `@str` --- src/librustc/middle/const_eval.rs | 6 +++--- src/librustc/middle/trans/consts.rs | 8 +++++--- src/librustdoc/clean.rs | 4 ++-- src/libsyntax/ast.rs | 4 ++-- src/libsyntax/ext/concat.rs | 7 +++---- src/libsyntax/parse/parser.rs | 9 ++++++--- src/libsyntax/print/pprust.rs | 6 +++--- 7 files changed, 24 insertions(+), 20 deletions(-) (limited to 'src/libsyntax/parse') diff --git a/src/librustc/middle/const_eval.rs b/src/librustc/middle/const_eval.rs index 68ac2f11bda..51410068378 100644 --- a/src/librustc/middle/const_eval.rs +++ b/src/librustc/middle/const_eval.rs @@ -515,9 +515,9 @@ pub fn lit_to_const(lit: &Lit) -> const_val { LitInt(n, _) => const_int(n), LitUint(n, _) => const_uint(n), LitIntUnsuffixed(n) => const_int(n), - LitFloat(n, _) => const_float(from_str::(n).unwrap() as f64), - LitFloatUnsuffixed(n) => - const_float(from_str::(n).unwrap() as f64), + LitFloat(ref n, _) | LitFloatUnsuffixed(ref n) => { + const_float(from_str::(n.get()).unwrap() as f64) + } LitNil => const_int(0i64), LitBool(b) => const_bool(b) } diff --git a/src/librustc/middle/trans/consts.rs b/src/librustc/middle/trans/consts.rs index ddab6407f9d..8f69b3cc2f2 100644 --- a/src/librustc/middle/trans/consts.rs +++ b/src/librustc/middle/trans/consts.rs @@ -57,12 +57,14 @@ pub fn const_lit(cx: &CrateContext, e: &ast::Expr, lit: ast::Lit) ty_to_str(cx.tcx, lit_int_ty))) } } - ast::LitFloat(fs, t) => C_floating(fs, Type::float_from_ty(t)), - ast::LitFloatUnsuffixed(fs) => { + ast::LitFloat(ref fs, t) => { + C_floating(fs.get(), Type::float_from_ty(t)) + } + ast::LitFloatUnsuffixed(ref fs) => { let lit_float_ty = ty::node_id_to_type(cx.tcx, e.id); match ty::get(lit_float_ty).sty { ty::ty_float(t) => { - C_floating(fs, Type::float_from_ty(t)) + C_floating(fs.get(), Type::float_from_ty(t)) } _ => { cx.sess.span_bug(lit.span, diff --git a/src/librustdoc/clean.rs b/src/librustdoc/clean.rs index 4a4e7741982..09c30ae096c 100644 --- a/src/librustdoc/clean.rs +++ b/src/librustdoc/clean.rs @@ -1152,8 +1152,8 @@ fn lit_to_str(lit: &ast::Lit) -> ~str { ast::LitInt(i, _t) => i.to_str(), ast::LitUint(u, _t) => u.to_str(), ast::LitIntUnsuffixed(i) => i.to_str(), - ast::LitFloat(f, _t) => f.to_str(), - ast::LitFloatUnsuffixed(f) => f.to_str(), + ast::LitFloat(ref f, _t) => f.get().to_str(), + ast::LitFloatUnsuffixed(ref f) => f.get().to_str(), ast::LitBool(b) => b.to_str(), ast::LitNil => ~"", } diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index 7416e213792..380641a8689 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -728,8 +728,8 @@ pub enum Lit_ { LitInt(i64, IntTy), LitUint(u64, UintTy), LitIntUnsuffixed(i64), - LitFloat(@str, FloatTy), - LitFloatUnsuffixed(@str), + LitFloat(InternedString, FloatTy), + LitFloatUnsuffixed(InternedString), LitNil, LitBool(bool), } diff --git a/src/libsyntax/ext/concat.rs b/src/libsyntax/ext/concat.rs index f570ca4c1bf..c13f9bf92af 100644 --- a/src/libsyntax/ext/concat.rs +++ b/src/libsyntax/ext/concat.rs @@ -29,12 +29,11 @@ pub fn expand_syntax_ext(cx: &mut base::ExtCtxt, match e.node { ast::ExprLit(lit) => { match lit.node { - ast::LitStr(ref s, _) => { + ast::LitStr(ref s, _) | + ast::LitFloat(ref s, _) | + ast::LitFloatUnsuffixed(ref s) => { accumulator.push_str(s.get()); } - ast::LitFloat(s, _) | ast::LitFloatUnsuffixed(s) => { - accumulator.push_str(s); - } ast::LitChar(c) => { accumulator.push_char(char::from_u32(c).unwrap()); } diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 636dc504ff2..e86873d6418 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -1405,9 +1405,12 @@ impl Parser { token::LIT_INT(i, it) => LitInt(i, it), token::LIT_UINT(u, ut) => LitUint(u, ut), token::LIT_INT_UNSUFFIXED(i) => LitIntUnsuffixed(i), - token::LIT_FLOAT(s, ft) => LitFloat(self.id_to_str(s), ft), - token::LIT_FLOAT_UNSUFFIXED(s) => - LitFloatUnsuffixed(self.id_to_str(s)), + token::LIT_FLOAT(s, ft) => { + LitFloat(self.id_to_interned_str(s), ft) + } + token::LIT_FLOAT_UNSUFFIXED(s) => { + LitFloatUnsuffixed(self.id_to_interned_str(s)) + } token::LIT_STR(s) => { LitStr(self.id_to_interned_str(s), ast::CookedStr) } diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index 8bf439818a2..d2a388cc14d 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -2202,10 +2202,10 @@ pub fn print_literal(s: &mut State, lit: &ast::Lit) { word(&mut s.s, (i as u64).to_str_radix(10u)); } } - ast::LitFloat(f, t) => { - word(&mut s.s, f.to_owned() + ast_util::float_ty_to_str(t)); + ast::LitFloat(ref f, t) => { + word(&mut s.s, f.get() + ast_util::float_ty_to_str(t)); } - ast::LitFloatUnsuffixed(f) => word(&mut s.s, f), + ast::LitFloatUnsuffixed(ref f) => word(&mut s.s, f.get()), ast::LitNil => word(&mut s.s, "()"), ast::LitBool(val) => { if val { word(&mut s.s, "true"); } else { word(&mut s.s, "false"); } -- cgit 1.4.1-3-g733a5 From f9af11d6cc0266a5690897b4645d8cab2ed1115b Mon Sep 17 00:00:00 2001 From: Patrick Walton Date: Wed, 15 Jan 2014 18:30:40 -0800 Subject: libsyntax: Remove all `@str` from the AST --- src/librustc/metadata/creader.rs | 4 ++-- src/librustc/middle/trans/asm.rs | 18 +++++++++--------- src/libsyntax/ast.rs | 10 +++++----- src/libsyntax/ext/asm.rs | 18 +++++++++--------- src/libsyntax/fold.rs | 8 ++++++-- src/libsyntax/parse/parser.rs | 13 ++++++++----- src/libsyntax/print/pprust.rs | 14 +++++++------- 7 files changed, 46 insertions(+), 39 deletions(-) (limited to 'src/libsyntax/parse') diff --git a/src/librustc/metadata/creader.rs b/src/librustc/metadata/creader.rs index c43cf0a6ad7..56ede9dfce1 100644 --- a/src/librustc/metadata/creader.rs +++ b/src/librustc/metadata/creader.rs @@ -168,8 +168,8 @@ fn extract_crate_info(i: &ast::ViewItem) -> Option { debug!("resolving extern mod stmt. ident: {:?} path_opt: {:?}", ident, path_opt); let (name, version) = match path_opt { - Some((path_str, _)) => { - let crateid: Option = from_str(path_str); + Some((ref path_str, _)) => { + let crateid: Option = from_str(path_str.get()); match crateid { None => (@"", @""), Some(crateid) => { diff --git a/src/librustc/middle/trans/asm.rs b/src/librustc/middle/trans/asm.rs index bae35f68ada..db99bd53704 100644 --- a/src/librustc/middle/trans/asm.rs +++ b/src/librustc/middle/trans/asm.rs @@ -38,8 +38,8 @@ pub fn trans_inline_asm<'a>(bcx: &'a Block<'a>, ia: &ast::InlineAsm) let temp_scope = fcx.push_custom_cleanup_scope(); // Prepare the output operands - let outputs = ia.outputs.map(|&(c, out)| { - constraints.push(c); + let outputs = ia.outputs.map(|&(ref c, out)| { + constraints.push((*c).clone()); let out_datum = unpack_datum!(bcx, expr::trans(bcx, out)); output_types.push(type_of::type_of(bcx.ccx(), out_datum.ty)); @@ -48,8 +48,8 @@ pub fn trans_inline_asm<'a>(bcx: &'a Block<'a>, ia: &ast::InlineAsm) }); // Now the input operands - let inputs = ia.inputs.map(|&(c, input)| { - constraints.push(c); + let inputs = ia.inputs.map(|&(ref c, input)| { + constraints.push((*c).clone()); unpack_result!(bcx, { callee::trans_arg_expr(bcx, @@ -63,13 +63,13 @@ pub fn trans_inline_asm<'a>(bcx: &'a Block<'a>, ia: &ast::InlineAsm) // no failure occurred preparing operands, no need to cleanup fcx.pop_custom_cleanup_scope(temp_scope); - let mut constraints = constraints.connect(","); + let mut constraints = constraints.map(|s| s.get().to_str()).connect(","); let mut clobbers = getClobbers(); - if !ia.clobbers.is_empty() && !clobbers.is_empty() { - clobbers = format!("{},{}", ia.clobbers, clobbers); + if !ia.clobbers.get().is_empty() && !clobbers.is_empty() { + clobbers = format!("{},{}", ia.clobbers.get(), clobbers); } else { - clobbers.push_str(ia.clobbers); + clobbers.push_str(ia.clobbers.get()); } // Add the clobbers to our constraints list @@ -98,7 +98,7 @@ pub fn trans_inline_asm<'a>(bcx: &'a Block<'a>, ia: &ast::InlineAsm) ast::AsmIntel => lib::llvm::AD_Intel }; - let r = ia.asm.with_c_str(|a| { + let r = ia.asm.get().with_c_str(|a| { constraints.with_c_str(|c| { InlineAsmCall(bcx, a, c, inputs, output_type, ia.volatile, ia.alignstack, dialect) }) diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index 380641a8689..a8bbdbd60d3 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -898,11 +898,11 @@ pub enum AsmDialect { #[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] pub struct InlineAsm { - asm: @str, + asm: InternedString, asm_str_style: StrStyle, - clobbers: @str, - inputs: ~[(@str, @Expr)], - outputs: ~[(@str, @Expr)], + clobbers: InternedString, + inputs: ~[(InternedString, @Expr)], + outputs: ~[(InternedString, @Expr)], volatile: bool, alignstack: bool, dialect: AsmDialect @@ -1075,7 +1075,7 @@ pub enum ViewItem_ { // optional @str: if present, this is a location (containing // arbitrary characters) from which to fetch the crate sources // For example, extern mod whatever = "github.com/mozilla/rust" - ViewItemExternMod(Ident, Option<(@str, StrStyle)>, NodeId), + ViewItemExternMod(Ident, Option<(InternedString,StrStyle)>, NodeId), ViewItemUse(~[@ViewPath]), } diff --git a/src/libsyntax/ext/asm.rs b/src/libsyntax/ext/asm.rs index babf0f13874..1a3ebf3ce5d 100644 --- a/src/libsyntax/ext/asm.rs +++ b/src/libsyntax/ext/asm.rs @@ -80,10 +80,10 @@ pub fn expand_asm(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) let (constraint, _str_style) = p.parse_str(); - if constraint.starts_with("+") { + if constraint.get().starts_with("+") { cx.span_unimpl(p.last_span, "'+' (read+write) output operand constraint modifier"); - } else if !constraint.starts_with("=") { + } else if !constraint.get().starts_with("=") { cx.span_err(p.last_span, "output operand constraint lacks '='"); } @@ -105,9 +105,9 @@ pub fn expand_asm(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) let (constraint, _str_style) = p.parse_str(); - if constraint.starts_with("=") { + if constraint.get().starts_with("=") { cx.span_err(p.last_span, "input operand constraint contains '='"); - } else if constraint.starts_with("+") { + } else if constraint.get().starts_with("+") { cx.span_err(p.last_span, "input operand constraint contains '+'"); } @@ -138,11 +138,11 @@ pub fn expand_asm(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) Options => { let (option, _str_style) = p.parse_str(); - if "volatile" == option { + if option.equiv(&("volatile")) { volatile = true; - } else if "alignstack" == option { + } else if option.equiv(&("alignstack")) { alignstack = true; - } else if "intel" == option { + } else if option.equiv(&("intel")) { dialect = ast::AsmIntel; } @@ -192,9 +192,9 @@ pub fn expand_asm(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) MRExpr(@ast::Expr { id: ast::DUMMY_NODE_ID, node: ast::ExprInlineAsm(ast::InlineAsm { - asm: asm.get().to_managed(), + asm: token::intern_and_get_ident(asm.get()), asm_str_style: asm_str_style.unwrap(), - clobbers: cons.to_managed(), + clobbers: token::intern_and_get_ident(cons), inputs: inputs, outputs: outputs, volatile: volatile, diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs index 9a346e17d28..f41d508f07d 100644 --- a/src/libsyntax/fold.rs +++ b/src/libsyntax/fold.rs @@ -814,8 +814,12 @@ pub fn noop_fold_expr(e: @Expr, folder: &mut T) -> @Expr { } ExprInlineAsm(ref a) => { ExprInlineAsm(InlineAsm { - inputs: a.inputs.map(|&(c, input)| (c, folder.fold_expr(input))), - outputs: a.outputs.map(|&(c, out)| (c, folder.fold_expr(out))), + inputs: a.inputs.map(|&(ref c, input)| { + ((*c).clone(), folder.fold_expr(input)) + }), + outputs: a.outputs.map(|&(ref c, out)| { + ((*c).clone(), folder.fold_expr(out)) + }), .. (*a).clone() }) } diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index e86873d6418..07124120b12 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -5130,17 +5130,20 @@ impl Parser { } } - pub fn parse_optional_str(&mut self) -> Option<(@str, ast::StrStyle)> { + pub fn parse_optional_str(&mut self) + -> Option<(InternedString, ast::StrStyle)> { let (s, style) = match self.token { - token::LIT_STR(s) => (s, ast::CookedStr), - token::LIT_STR_RAW(s, n) => (s, ast::RawStr(n)), + token::LIT_STR(s) => (self.id_to_interned_str(s), ast::CookedStr), + token::LIT_STR_RAW(s, n) => { + (self.id_to_interned_str(s), ast::RawStr(n)) + } _ => return None }; self.bump(); - Some((ident_to_str(&s), style)) + Some((s, style)) } - pub fn parse_str(&mut self) -> (@str, StrStyle) { + pub fn parse_str(&mut self) -> (InternedString, StrStyle) { match self.parse_optional_str() { Some(s) => { s } _ => self.fatal("expected string literal") diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index d2a388cc14d..2761cc4ea56 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -1466,25 +1466,25 @@ pub fn print_expr(s: &mut State, expr: &ast::Expr) { word(&mut s.s, "asm!"); } popen(s); - print_string(s, a.asm, a.asm_str_style); + print_string(s, a.asm.get(), a.asm_str_style); word_space(s, ":"); - for &(co, o) in a.outputs.iter() { - print_string(s, co, ast::CookedStr); + for &(ref co, o) in a.outputs.iter() { + print_string(s, co.get(), ast::CookedStr); popen(s); print_expr(s, o); pclose(s); word_space(s, ","); } word_space(s, ":"); - for &(co, o) in a.inputs.iter() { - print_string(s, co, ast::CookedStr); + for &(ref co, o) in a.inputs.iter() { + print_string(s, co.get(), ast::CookedStr); popen(s); print_expr(s, o); pclose(s); word_space(s, ","); } word_space(s, ":"); - print_string(s, a.clobbers, ast::CookedStr); + print_string(s, a.clobbers.get(), ast::CookedStr); pclose(s); } ast::ExprMac(ref m) => print_mac(s, m), @@ -1998,7 +1998,7 @@ pub fn print_view_item(s: &mut State, item: &ast::ViewItem) { space(&mut s.s); word(&mut s.s, "="); space(&mut s.s); - print_string(s, *p, style); + print_string(s, p.get(), style); } } -- cgit 1.4.1-3-g733a5 From 3c9e9d35ac0f6469e0eeffc5c497f4b3ed6f1f8a Mon Sep 17 00:00:00 2001 From: Patrick Walton Date: Wed, 15 Jan 2014 18:38:34 -0800 Subject: libsyntax: Remove `ident_to_str` from the parser, which was returning `@str` values --- src/libsyntax/parse/obsolete.rs | 4 ++-- src/libsyntax/parse/parser.rs | 14 ++++++-------- 2 files changed, 8 insertions(+), 10 deletions(-) (limited to 'src/libsyntax/parse') diff --git a/src/libsyntax/parse/obsolete.rs b/src/libsyntax/parse/obsolete.rs index c4887d55e2a..04c73ce71d0 100644 --- a/src/libsyntax/parse/obsolete.rs +++ b/src/libsyntax/parse/obsolete.rs @@ -22,7 +22,6 @@ use codemap::{Span, respan}; use parse::parser::Parser; use parse::token; -use std::str; use std::to_bytes; /// The specific types of unsupported syntax @@ -178,7 +177,8 @@ impl ParserObsoleteMethods for Parser { fn is_obsolete_ident(&mut self, ident: &str) -> bool { match self.token { token::IDENT(sid, _) => { - str::eq_slice(self.id_to_str(sid), ident) + let interned_string = token::get_ident(sid.name); + interned_string.equiv(&ident) } _ => false } diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 07124120b12..cdf5d440380 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -531,10 +531,11 @@ impl Parser { // otherwise, eat it. pub fn expect_keyword(&mut self, kw: keywords::Keyword) { if !self.eat_keyword(kw) { - let id_str = self.id_to_str(kw.to_ident()).to_str(); + let id_ident = kw.to_ident(); + let id_interned_str = token::get_ident(id_ident.name); let token_str = self.this_token_to_str(); self.fatal(format!("expected `{}`, found `{}`", - id_str, + id_interned_str.get(), token_str)) } } @@ -802,10 +803,6 @@ impl Parser { self.sess.span_diagnostic.handler().abort_if_errors(); } - pub fn id_to_str(&mut self, id: Ident) -> @str { - get_ident_interner().get(id.name) - } - pub fn id_to_interned_str(&mut self, id: Ident) -> InternedString { get_ident(id.name) } @@ -3440,7 +3437,9 @@ impl Parser { loop { match self.token { token::LIFETIME(lifetime) => { - if "static" == self.id_to_str(lifetime) { + let lifetime_interned_string = + token::get_ident(lifetime.name); + if lifetime_interned_string.equiv(&("static")) { result.push(RegionTyParamBound); } else { self.span_err(self.span, @@ -4871,7 +4870,6 @@ impl Parser { let first_ident = self.parse_ident(); let mut path = ~[first_ident]; - debug!("parsed view path: {}", self.id_to_str(first_ident)); match self.token { token::EQ => { // x = foo::bar -- cgit 1.4.1-3-g733a5 From b890237e798030ce337933b14f777a1c3810d1ea Mon Sep 17 00:00:00 2001 From: Patrick Walton Date: Thu, 30 Jan 2014 18:46:19 -0800 Subject: libsyntax: Fix tests. --- src/librustc/front/test.rs | 2 +- src/libsyntax/codemap.rs | 4 ++-- src/libsyntax/ext/expand.rs | 34 +++++++++++++++++----------------- src/libsyntax/fold.rs | 8 +++++--- src/libsyntax/parse/lexer.rs | 26 +++++++++++++------------- src/libsyntax/parse/mod.rs | 24 ++++++++++++------------ src/libsyntax/util/parser_testing.rs | 4 ++-- 7 files changed, 52 insertions(+), 50 deletions(-) (limited to 'src/libsyntax/parse') diff --git a/src/librustc/front/test.rs b/src/librustc/front/test.rs index b653af5b624..2704e828ea4 100644 --- a/src/librustc/front/test.rs +++ b/src/librustc/front/test.rs @@ -134,7 +134,7 @@ impl<'a> fold::Folder for TestHarnessGenerator<'a> { if !cx.sess.building_library.get() { @ast::Item { attrs: item.attrs.iter().filter_map(|attr| { - if attr.name().equiv(&("main")) { + if !attr.name().equiv(&("main")) { Some(*attr) } else { None diff --git a/src/libsyntax/codemap.rs b/src/libsyntax/codemap.rs index edaddc8e8bc..2ada3ac16ea 100644 --- a/src/libsyntax/codemap.rs +++ b/src/libsyntax/codemap.rs @@ -468,7 +468,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: @@ -480,7 +480,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/ext/expand.rs b/src/libsyntax/ext/expand.rs index 8e5bc1d61d2..0372be689a7 100644 --- a/src/libsyntax/ext/expand.rs +++ b/src/libsyntax/ext/expand.rs @@ -1021,11 +1021,11 @@ 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( - @"", + ~"", src, ~[],sess); // should fail: @@ -1036,11 +1036,11 @@ 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( - @"", + ~"", src, ~[],sess); // should fail: @@ -1050,11 +1050,11 @@ 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( - @"", + ~"", src, ~[], sess); // should fail: @@ -1063,9 +1063,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]; @@ -1073,13 +1073,13 @@ mod test { } // make a MetaWord 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_ { style: AttrOuter, value: @Spanned { - node: MetaWord(s), + node: MetaWord(token::intern_and_get_ident(s)), span: codemap::DUMMY_SP, }, is_sugared_doc: false, @@ -1089,7 +1089,7 @@ mod test { #[test] fn renaming () { - let item_ast = string_to_crate(@"fn f() -> int { a }"); + let item_ast = string_to_crate(~"fn f() -> int { a }"); let a_name = intern("a"); let a2_name = gensym("a2"); let mut renamer = new_rename_folder(ast::Ident{name:a_name,ctxt:EMPTY_CTXT}, @@ -1128,7 +1128,7 @@ mod test { // pprust::print_crate_(&mut s, crate); //} - fn expand_crate_str(crate_str: @str) -> ast::Crate { + fn expand_crate_str(crate_str: ~str) -> ast::Crate { let (crate_ast,ps) = string_to_crate_and_sess(crate_str); // the cfg argument actually does matter, here... let mut loader = ErrLoader; @@ -1146,7 +1146,7 @@ mod test { //} #[test] fn macro_tokens_should_match(){ - expand_crate_str(@"macro_rules! m((a)=>(13)) fn main(){m!(a);}"); + expand_crate_str(~"macro_rules! m((a)=>(13)) fn main(){m!(a);}"); } // renaming tests expand a crate and then check that the bindings match @@ -1222,7 +1222,7 @@ mod test { let (teststr, bound_connections, bound_ident_check) = match *t { (ref str,ref conns, bic) => (str.to_managed(), conns.clone(), bic) }; - let cr = expand_crate_str(teststr.to_managed()); + let cr = expand_crate_str(teststr.to_owned()); // find the bindings: let mut name_finder = new_name_finder(~[]); visit::walk_crate(&mut name_finder,&cr,()); @@ -1285,7 +1285,7 @@ mod test { } #[test] fn fmt_in_macro_used_inside_module_macro() { - let crate_str = @"macro_rules! fmt_wrap(($b:expr)=>($b.to_str())) + let crate_str = ~"macro_rules! fmt_wrap(($b:expr)=>($b.to_str())) macro_rules! foo_module (() => (mod generated { fn a() { let xx = 147; fmt_wrap!(xx);}})) foo_module!() "; @@ -1335,7 +1335,7 @@ foo_module!() #[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 mut pat_idents = new_name_finder(~[]); pat_idents.visit_pat(pat, ()); assert_eq!(pat_idents.ident_accumulator, diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs index 6e1b2044657..8f5bbc2cdad 100644 --- a/src/libsyntax/fold.rs +++ b/src/libsyntax/fold.rs @@ -899,7 +899,8 @@ mod test { // make sure idents get transformed everywhere #[test] fn ident_transformation () { let mut zz_fold = ToZzIdentFolder; - 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(&mut zz_fold.fold_crate(ast),fake_print_crate, @@ -910,8 +911,9 @@ mod test { // even inside macro defs.... #[test] fn ident_transformation_in_defs () { let mut zz_fold = ToZzIdentFolder; - let ast = string_to_crate(@"macro_rules! a {(b $c:expr $(d $e:token)f+ -=> (g $(d $d $e)+))} "); + 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", pprust::to_str(&mut zz_fold.fold_crate(ast),fake_print_crate, diff --git a/src/libsyntax/parse/lexer.rs b/src/libsyntax/parse/lexer.rs index 469d3d64f24..8c55990289a 100644 --- a/src/libsyntax/parse/lexer.rs +++ b/src/libsyntax/parse/lexer.rs @@ -972,9 +972,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 { @@ -984,7 +984,7 @@ mod test { #[test] fn t1 () { let Env {string_reader} = - setup(@"/* my source file */ \ + setup(~"/* my source file */ \ fn main() { println!(\"zebra\"); }\n"); let id = str_to_ident("fn"); let tok1 = string_reader.next_token(); @@ -1020,14 +1020,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, @@ -1035,7 +1035,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, @@ -1043,7 +1043,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, @@ -1051,28 +1051,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_CHAR('a' as u32)); } #[test] fn character_space() { - let env = setup(@"' '"); + let env = setup(~"' '"); let TokenAndSpan {tok, sp: _} = env.string_reader.next_token(); assert_eq!(tok, token::LIT_CHAR(' ' as u32)); } #[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_CHAR('\n' as u32)); } #[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"); @@ -1080,7 +1080,7 @@ mod test { } #[test] fn raw_string() { - let env = setup(@"r###\"\"#a\\b\x00c\"\"###"); + let env = setup(~"r###\"\"#a\\b\x00c\"\"###"); let TokenAndSpan {tok, sp: _} = env.string_reader.next_token(); let id = token::str_to_ident("\"#a\\b\x00c\""); @@ -1094,7 +1094,7 @@ mod test { } #[test] fn nested_block_comments() { - let env = setup(@"/* /* */ */'a'"); + let env = setup(~"/* /* */ */'a'"); let TokenAndSpan {tok, sp: _} = env.string_reader.next_token(); assert_eq!(tok,token::LIT_CHAR('a' as u32)); diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs index 76ccc53b846..cec9f7c2d9f 100644 --- a/src/libsyntax/parse/mod.rs +++ b/src/libsyntax/parse/mod.rs @@ -314,7 +314,7 @@ mod test { } #[test] fn path_exprs_1() { - assert_eq!(string_to_expr(@"a"), + assert_eq!(string_to_expr(~"a"), @ast::Expr{ id: ast::DUMMY_NODE_ID, node: ast::ExprPath(ast::Path { @@ -333,7 +333,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: ast::DUMMY_NODE_ID, node: ast::ExprPath(ast::Path { @@ -358,12 +358,12 @@ mod test { #[should_fail] #[test] fn bad_path_expr_1() { - string_to_expr(@"::abc::def::return"); + string_to_expr(~"::abc::def::return"); } // check the token-tree-ization of macros #[test] fn string_to_tts_macro () { - let tts = string_to_tts(@"macro_rules! zip (($a)=>($a))"); + let tts = string_to_tts(~"macro_rules! zip (($a)=>($a))"); match tts { [ast::TTTok(_,_), ast::TTTok(_,token::NOT), @@ -407,7 +407,7 @@ mod test { } #[test] fn string_to_tts_1 () { - let tts = string_to_tts(@"fn a (b : int) { b; }"); + let tts = string_to_tts(~"fn a (b : int) { b; }"); assert_eq!(to_json_str(&tts), ~"[\ {\ @@ -536,7 +536,7 @@ mod test { } #[test] fn ret_expr() { - assert_eq!(string_to_expr(@"return d"), + assert_eq!(string_to_expr(~"return d"), @ast::Expr{ id: ast::DUMMY_NODE_ID, node:ast::ExprRet(Some(@ast::Expr{ @@ -559,7 +559,7 @@ mod test { } #[test] fn parse_stmt_1 () { - assert_eq!(string_to_stmt(@"b;"), + assert_eq!(string_to_stmt(~"b;"), @Spanned{ node: ast::StmtExpr(@ast::Expr { id: ast::DUMMY_NODE_ID, @@ -585,7 +585,7 @@ mod test { } #[test] fn parse_ident_pat () { - let mut parser = string_to_parser(@"b"); + let mut parser = string_to_parser(~"b"); assert_eq!(parser.parse_pat(), @ast::Pat{id: ast::DUMMY_NODE_ID, node: ast::PatIdent( @@ -609,7 +609,7 @@ mod test { // check the contents of the tt manually: #[test] fn parse_fundecl () { // this test depends on the intern order of "fn" and "int" - 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:~[], @@ -701,12 +701,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/util/parser_testing.rs b/src/libsyntax/util/parser_testing.rs index 02bfa31d0e1..58c2bed7a45 100644 --- a/src/libsyntax/util/parser_testing.rs +++ b/src/libsyntax/util/parser_testing.rs @@ -19,7 +19,7 @@ use parse::token; // and the ParseSess pub fn string_to_tts_and_sess (source_str : ~str) -> (~[ast::TokenTree], @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) } // map a string to tts, using a made-up filename: @@ -30,7 +30,7 @@ pub fn string_to_tts(source_str : ~str) -> ~[ast::TokenTree] { pub fn string_to_parser_and_sess(source_str: ~str) -> (Parser,@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) -- cgit 1.4.1-3-g733a5 From 875c9ce30b13de02e447ee95cb50b0111894b14a Mon Sep 17 00:00:00 2001 From: Patrick Walton Date: Fri, 31 Jan 2014 15:26:59 -0800 Subject: libsyntax: Remove many uses of `token::ident_to_str` --- src/libsyntax/ext/expand.rs | 32 +++++++++++++++++++++++--------- src/libsyntax/ext/tt/macro_parser.rs | 17 +++++++++++------ src/libsyntax/ext/tt/transcribe.rs | 14 ++++++++------ src/libsyntax/parse/parser.rs | 8 ++++---- src/libsyntax/print/pprust.rs | 5 +++-- 5 files changed, 49 insertions(+), 27 deletions(-) (limited to 'src/libsyntax/parse') diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs index 0372be689a7..f7419e77ff5 100644 --- a/src/libsyntax/ext/expand.rs +++ b/src/libsyntax/ext/expand.rs @@ -22,8 +22,8 @@ use codemap::{Span, Spanned, ExpnInfo, NameAndSpan, MacroBang, MacroAttribute}; use ext::base::*; use fold::*; use parse; +use parse::token::{fresh_mark, fresh_name, intern}; use parse::token; -use parse::token::{fresh_mark, fresh_name, ident_to_str, intern}; use visit; use visit::Visitor; use util::small_vector::SmallVector; @@ -310,11 +310,12 @@ pub fn expand_item_mac(it: @ast::Item, fld: &mut MacroExpander) Some(&NormalTT(ref expander, span)) => { if it.ident.name != parse::token::special_idents::invalid.name { + let string = token::get_ident(it.ident.name); fld.cx.span_err(pth.span, format!("macro {}! expects no ident argument, \ given '{}'", extnamestr.get(), - ident_to_str(&it.ident))); + string.get())); return SmallVector::zero(); } fld.cx.bt_push(ExpnInfo { @@ -411,7 +412,10 @@ fn load_extern_macros(crate: &ast::ViewItem, fld: &mut MacroExpander) { let MacroCrate { lib, cnum } = fld.cx.loader.load_crate(crate); let crate_name = match crate.node { - ast::ViewItemExternMod(ref name, _, _) => token::ident_to_str(name), + ast::ViewItemExternMod(ref name, _, _) => { + let string = token::get_ident(name.name); + string.get().to_str() + }, _ => unreachable!(), }; let name = format!("<{} macros>", crate_name); @@ -957,7 +961,7 @@ mod test { use fold::*; use ext::base::{CrateLoader, MacroCrate}; use parse; - use parse::token::{fresh_mark, gensym, intern, ident_to_str}; + use parse::token::{fresh_mark, gensym, intern}; use parse::token; use util::parser_testing::{string_to_crate, string_to_crate_and_sess}; use util::parser_testing::{string_to_pat, string_to_tts, strs_to_idents}; @@ -1272,9 +1276,12 @@ mod test { println!("uh oh, matches but shouldn't:"); println!("varref: {:?}",varref); // good lord, you can't make a path with 0 segments, can you? + let string = token::get_ident(varref.segments[0] + .identifier + .name); println!("varref's first segment's uint: {}, and string: \"{}\"", varref.segments[0].identifier.name, - ident_to_str(&varref.segments[0].identifier)); + string.get()); println!("binding: {:?}", bindings[binding_idx]); ast_util::display_sctable(get_sctable()); } @@ -1296,7 +1303,10 @@ foo_module!() let bindings = name_finder.ident_accumulator; let cxbinds : ~[&ast::Ident] = - bindings.iter().filter(|b|{@"xx" == (ident_to_str(*b))}).collect(); + bindings.iter().filter(|b| { + let string = token::get_ident(b); + "xx" == string.get() + }).collect(); let cxbind = match cxbinds { [b] => b, _ => fail!("expected just one binding for ext_cx") @@ -1308,9 +1318,13 @@ foo_module!() let varrefs = path_finder.path_accumulator; // the xx binding should bind all of the xx varrefs: - for (idx,v) in varrefs.iter().filter(|p|{ p.segments.len() == 1 - && (@"xx" == (ident_to_str(&p.segments[0].identifier))) - }).enumerate() { + for (idx,v) in varrefs.iter().filter(|p|{ + p.segments.len() == 1 + && { + let string = token::get_ident(p.segments[0].identifier.name); + "xx" == string.get() + } + }).enumerate() { if (mtwt_resolve(v.segments[0].identifier) != resolved_binding) { println!("uh oh, xx binding didn't match xx varref:"); println!("this is xx varref \\# {:?}",idx); diff --git a/src/libsyntax/ext/tt/macro_parser.rs b/src/libsyntax/ext/tt/macro_parser.rs index d5a30a7cf11..6d1b8dd2358 100644 --- a/src/libsyntax/ext/tt/macro_parser.rs +++ b/src/libsyntax/ext/tt/macro_parser.rs @@ -18,7 +18,7 @@ use parse::lexer::*; //resolve bug? use parse::ParseSess; use parse::attr::ParserAttr; use parse::parser::{LifetimeAndTypesWithoutColons, Parser}; -use parse::token::{Token, EOF, to_str, Nonterminal, get_ident_interner, ident_to_str}; +use parse::token::{Token, EOF, to_str, Nonterminal, get_ident_interner}; use parse::token; use std::hashmap::HashMap; @@ -183,8 +183,9 @@ pub fn nameize(p_s: @ParseSess, ms: &[Matcher], res: &[@NamedMatch]) node: MatchNonterminal(ref bind_name, _, idx), span: sp } => { if ret_val.contains_key(bind_name) { - p_s.span_diagnostic.span_fatal(sp, - "Duplicated bind name: "+ ident_to_str(bind_name)) + let string = token::get_ident(bind_name.name); + p_s.span_diagnostic + .span_fatal(sp, "Duplicated bind name: " + string.get()) } ret_val.insert(*bind_name, res[idx]); } @@ -364,8 +365,11 @@ pub fn parse(sess: @ParseSess, let nts = bb_eis.map(|ei| { match ei.elts[ei.idx].node { MatchNonterminal(ref bind,ref name,_) => { - format!("{} ('{}')", ident_to_str(name), - ident_to_str(bind)) + let bind_string = token::get_ident(bind.name); + let name_string = token::get_ident(name.name); + format!("{} ('{}')", + name_string.get(), + bind_string.get()) } _ => fail!() } }).connect(" or "); @@ -388,8 +392,9 @@ pub fn parse(sess: @ParseSess, let mut ei = bb_eis.pop().unwrap(); match ei.elts[ei.idx].node { MatchNonterminal(_, ref name, idx) => { + let name_string = token::get_ident(name.name); ei.matches[idx].push(@MatchedNonterminal( - parse_nt(&mut rust_parser, ident_to_str(name)))); + parse_nt(&mut rust_parser, name_string.get()))); ei.idx += 1u; } _ => fail!() diff --git a/src/libsyntax/ext/tt/transcribe.rs b/src/libsyntax/ext/tt/transcribe.rs index 87a2f374c90..d2fa24b1cfe 100644 --- a/src/libsyntax/ext/tt/transcribe.rs +++ b/src/libsyntax/ext/tt/transcribe.rs @@ -14,7 +14,7 @@ use codemap::{Span, DUMMY_SP}; use diagnostic::SpanHandler; use ext::tt::macro_parser::{NamedMatch, MatchedSeq, MatchedNonterminal}; use parse::token::{EOF, INTERPOLATED, IDENT, Token, NtIdent}; -use parse::token::{ident_to_str}; +use parse::token; use parse::lexer::TokenAndSpan; use std::cell::{Cell, RefCell}; @@ -122,9 +122,10 @@ fn lookup_cur_matched(r: &TtReader, name: Ident) -> @NamedMatch { match matched_opt { Some(s) => lookup_cur_matched_by_matched(r, s), None => { + let name_string = token::get_ident(name.name); r.sp_diag.span_fatal(r.cur_span.get(), format!("unknown macro variable `{}`", - ident_to_str(&name))); + name_string.get())); } } } @@ -145,11 +146,11 @@ fn lis_merge(lhs: LockstepIterSize, rhs: LockstepIterSize) -> LockstepIterSize { LisContradiction(_) => rhs.clone(), LisConstraint(r_len, _) if l_len == r_len => lhs.clone(), LisConstraint(r_len, ref r_id) => { - let l_n = ident_to_str(l_id); - let r_n = ident_to_str(r_id); + let l_n = token::get_ident(l_id.name); + let r_n = token::get_ident(r_id.name); LisContradiction(format!("Inconsistent lockstep iteration: \ '{}' has {} items, but '{}' has {}", - l_n, l_len, r_n, r_len)) + l_n.get(), l_len, r_n.get(), r_len)) } } } @@ -313,10 +314,11 @@ pub fn tt_next_token(r: &TtReader) -> TokenAndSpan { return ret_val; } MatchedSeq(..) => { + let string = token::get_ident(ident.name); r.sp_diag.span_fatal( r.cur_span.get(), /* blame the macro writer */ format!("variable '{}' is still repeating at this depth", - ident_to_str(&ident))); + string.get())); } } } diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index cdf5d440380..34080ffb624 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -72,9 +72,8 @@ use parse::lexer::Reader; use parse::lexer::TokenAndSpan; use parse::obsolete::*; use parse::token::{INTERPOLATED, InternedString, can_begin_expr, get_ident}; -use parse::token::{get_ident_interner, ident_to_str, is_ident}; -use parse::token::{is_ident_or_path, is_plain_ident, keywords}; -use parse::token::{special_idents, token_to_binop}; +use parse::token::{get_ident_interner, is_ident, is_ident_or_path}; +use parse::token::{is_plain_ident, keywords, special_idents, token_to_binop}; use parse::token; use parse::{new_sub_parser_from_file, ParseSess}; use opt_vec; @@ -4534,7 +4533,8 @@ impl Parser { token::LIT_STR(s) | token::LIT_STR_RAW(s, _) => { self.bump(); - let the_string = ident_to_str(&s); + let identifier_string = token::get_ident(s.name); + let the_string = identifier_string.get(); let mut abis = AbiSet::empty(); for word in the_string.words() { match abi::lookup(word) { diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index 2761cc4ea56..93d912e7522 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -19,7 +19,7 @@ use codemap::{CodeMap, BytePos}; use codemap; use diagnostic; use parse::classify::expr_is_simple_block; -use parse::token::{IdentInterner, ident_to_str, interner_get}; +use parse::token::{IdentInterner, interner_get}; use parse::{comments, token}; use parse; use print::pp::{break_offset, word, space, zerobreak, hardbreak}; @@ -1539,7 +1539,8 @@ pub fn print_decl(s: &mut State, decl: &ast::Decl) { } pub fn print_ident(s: &mut State, ident: ast::Ident) { - word(&mut s.s, ident_to_str(&ident)); + let string = token::get_ident(ident.name); + word(&mut s.s, string.get()); } pub fn print_name(s: &mut State, name: ast::Name) { -- cgit 1.4.1-3-g733a5 From 0d0a3dad68fe03b45ab779e0565e33689edc1c0b Mon Sep 17 00:00:00 2001 From: Patrick Walton Date: Fri, 31 Jan 2014 15:30:19 -0800 Subject: libsyntax: Remove uses of `token::ident_to_str()` --- src/librustdoc/clean.rs | 5 ++--- src/libsyntax/parse/token.rs | 43 ++++++++++++++----------------------------- 2 files changed, 16 insertions(+), 32 deletions(-) (limited to 'src/libsyntax/parse') diff --git a/src/librustdoc/clean.rs b/src/librustdoc/clean.rs index 6abafd5995c..53bae09f58c 100644 --- a/src/librustdoc/clean.rs +++ b/src/librustdoc/clean.rs @@ -11,8 +11,6 @@ //! This module contains the "cleaned" pieces of the AST, and the functions //! that clean them. -use its = syntax::parse::token::ident_to_str; - use syntax; use syntax::ast; use syntax::ast_map; @@ -893,7 +891,8 @@ fn path_to_str(p: &ast::Path) -> ~str { impl Clean<~str> for ast::Ident { fn clean(&self) -> ~str { - its(self).to_owned() + let string = token::get_ident(self.name); + string.get().to_owned() } } diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs index 9291cba54f6..2c57a4effd5 100644 --- a/src/libsyntax/parse/token.rs +++ b/src/libsyntax/parse/token.rs @@ -188,23 +188,29 @@ pub fn to_str(input: @IdentInterner, t: &Token) -> ~str { } LIT_INT_UNSUFFIXED(i) => { i.to_str() } LIT_FLOAT(ref s, t) => { - let mut body = ident_to_str(s).to_owned(); + let body_string = get_ident(s.name); + let mut body = body_string.get().to_str(); if body.ends_with(".") { body.push_char('0'); // `10.f` is not a float literal } body + ast_util::float_ty_to_str(t) } LIT_FLOAT_UNSUFFIXED(ref s) => { - let mut body = ident_to_str(s).to_owned(); + let body_string = get_ident(s.name); + let mut body = body_string.get().to_owned(); if body.ends_with(".") { body.push_char('0'); // `10.f` is not a float literal } body } - LIT_STR(ref s) => { format!("\"{}\"", ident_to_str(s).escape_default()) } + LIT_STR(ref s) => { + let literal_string = get_ident(s.name); + format!("\"{}\"", literal_string.get().escape_default()) + } LIT_STR_RAW(ref s, n) => { + let literal_string = get_ident(s.name); format!("r{delim}\"{string}\"{delim}", - delim="#".repeat(n), string=ident_to_str(s)) + delim="#".repeat(n), string=literal_string.get()) } /* Name components */ @@ -213,7 +219,10 @@ pub fn to_str(input: @IdentInterner, t: &Token) -> ~str { UNDERSCORE => ~"_", /* Other */ - DOC_COMMENT(ref s) => ident_to_str(s).to_owned(), + DOC_COMMENT(ref s) => { + let comment_string = get_ident(s.name); + comment_string.get().to_str() + } EOF => ~"", INTERPOLATED(ref nt) => { match nt { @@ -647,11 +656,6 @@ 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 { - interner_get(id.name) -} - // maps a string to an identifier with an empty syntax context pub fn str_to_ident(str : &str) -> ast::Ident { ast::Ident::new(intern(str)) @@ -768,23 +772,4 @@ mod test { let a1 = mark_ident(a,92); assert!(mtwt_token_eq(&IDENT(a,true),&IDENT(a1,false))); } - - - #[test] fn str_ptr_eq_tests(){ - let a = @"abc"; - let b = @"abc"; - let c = a; - assert!(str_ptr_eq(a,c)); - assert!(!str_ptr_eq(a,b)); - } - - #[test] fn fresh_name_pointer_sharing() { - let ghi = str_to_ident("ghi"); - assert_eq!(ident_to_str(&ghi),@"ghi"); - assert!(str_ptr_eq(ident_to_str(&ghi),ident_to_str(&ghi))) - let fresh = ast::Ident::new(fresh_name(&ghi)); - assert_eq!(ident_to_str(&fresh),@"ghi"); - assert!(str_ptr_eq(ident_to_str(&ghi),ident_to_str(&fresh))); - } - } -- cgit 1.4.1-3-g733a5 From e5dc347ccfe92d9d1dd23f0b4a257a1cb3532462 Mon Sep 17 00:00:00 2001 From: Patrick Walton Date: Fri, 31 Jan 2014 16:10:06 -0800 Subject: libsyntax: Remove the `interner_get` function and all uses --- src/libsyntax/ast.rs | 7 ++++--- src/libsyntax/ast_util.rs | 5 ++++- src/libsyntax/parse/parser.rs | 3 ++- src/libsyntax/parse/token.rs | 27 --------------------------- src/libsyntax/print/pprust.rs | 5 +++-- 5 files changed, 13 insertions(+), 34 deletions(-) (limited to 'src/libsyntax/parse') diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index a8bbdbd60d3..fd8e9dbfa67 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -14,8 +14,8 @@ use codemap::{Span, Spanned, DUMMY_SP}; use abi::AbiSet; use ast_util; use opt_vec::OptVec; -use parse::token::{InternedString, interner_get, special_idents}; -use parse::token::{str_to_ident}; +use parse::token::{InternedString, special_idents, str_to_ident}; +use parse::token; use std::cell::RefCell; use std::hashmap::HashMap; @@ -126,7 +126,8 @@ pub type Mrk = u32; impl Encodable for Ident { fn encode(&self, s: &mut S) { - s.emit_str(interner_get(self.name)); + let string = token::get_ident(self.name); + s.emit_str(string.get()); } } diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs index 405de5c5542..afedb62105b 100644 --- a/src/libsyntax/ast_util.rs +++ b/src/libsyntax/ast_util.rs @@ -25,7 +25,10 @@ use std::num; pub fn path_name_i(idents: &[Ident]) -> ~str { // FIXME: Bad copies (#2543 -- same for everything else that says "bad") - idents.map(|i| token::interner_get(i.name)).connect("::") + idents.map(|i| { + let string = token::get_ident(i.name); + string.get().to_str() + }).connect("::") } // totally scary function: ignores all but the last element, should have diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 34080ffb624..86913711801 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -4178,7 +4178,8 @@ impl Parser { outer_attrs, "path") { Some(d) => dir_path.join(d), None => { - let mod_name = token::interner_get(id.name).to_owned(); + let mod_string = token::get_ident(id.name); + let mod_name = mod_string.get().to_owned(); let default_path_str = mod_name + ".rs"; let secondary_path_str = mod_name + "/mod.rs"; let default_path = dir_path.join(default_path_str.as_slice()); diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs index 2c57a4effd5..806c84c5553 100644 --- a/src/libsyntax/parse/token.rs +++ b/src/libsyntax/parse/token.rs @@ -651,11 +651,6 @@ pub fn gensym(str : &str) -> Name { interner.gensym(str) } -// map an interned representation back to a string -pub fn interner_get(name : Name) -> @str { - get_ident_interner().get(name) -} - // maps a string to an identifier with an empty syntax context pub fn str_to_ident(str : &str) -> ast::Ident { ast::Ident::new(intern(str)) @@ -679,28 +674,6 @@ pub fn fresh_name(src : &ast::Ident) -> Name { gensym(format!("{}_{}",ident_to_str(src),num))*/ } -// it looks like there oughta be a str_ptr_eq fn, but no one bothered to implement it? - -// determine whether two @str values are pointer-equal -pub fn str_ptr_eq(a : @str, b : @str) -> bool { - unsafe { - let p : uint = cast::transmute(a); - let q : uint = cast::transmute(b); - let result = p == q; - // got to transmute them back, to make sure the ref count is correct: - let _junk1 : @str = cast::transmute(p); - let _junk2 : @str = cast::transmute(q); - result - } -} - -// return true when two identifiers refer (through the intern table) to the same ptr_eq -// string. This is used to compare identifiers in places where hygienic comparison is -// not wanted (i.e. not lexical vars). -pub fn ident_spelling_eq(a : &ast::Ident, b : &ast::Ident) -> bool { - str_ptr_eq(interner_get(a.name),interner_get(b.name)) -} - // create a fresh mark. pub fn fresh_mark() -> Mrk { gensym("mark") diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index 93d912e7522..2e20560b9ca 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -19,7 +19,7 @@ use codemap::{CodeMap, BytePos}; use codemap; use diagnostic; use parse::classify::expr_is_simple_block; -use parse::token::{IdentInterner, interner_get}; +use parse::token::IdentInterner; use parse::{comments, token}; use parse; use print::pp::{break_offset, word, space, zerobreak, hardbreak}; @@ -1544,7 +1544,8 @@ pub fn print_ident(s: &mut State, ident: ast::Ident) { } pub fn print_name(s: &mut State, name: ast::Name) { - word(&mut s.s, interner_get(name)); + let string = token::get_ident(name); + word(&mut s.s, string.get()); } pub fn print_for_decl(s: &mut State, loc: &ast::Local, coll: &ast::Expr) { -- cgit 1.4.1-3-g733a5 From 8b8419293cb69d208a0d4f3a89dd01b0d394a6c6 Mon Sep 17 00:00:00 2001 From: Patrick Walton Date: Fri, 31 Jan 2014 16:42:33 -0800 Subject: libsyntax: Remove `@str` from the interner --- src/libsyntax/ast_map.rs | 26 ++++++--- src/libsyntax/parse/parser.rs | 3 +- src/libsyntax/parse/token.rs | 22 ++++---- src/libsyntax/util/interner.rs | 117 ++++++++++++++++++++++++++++------------- 4 files changed, 112 insertions(+), 56 deletions(-) (limited to 'src/libsyntax/parse') diff --git a/src/libsyntax/ast_map.rs b/src/libsyntax/ast_map.rs index bb66d620d29..89209ab2104 100644 --- a/src/libsyntax/ast_map.rs +++ b/src/libsyntax/ast_map.rs @@ -62,9 +62,10 @@ pub fn path_to_str_with_sep(p: &[PathElem], sep: &str, itr: @IdentInterner) pub fn path_ident_to_str(p: &Path, i: Ident, itr: @IdentInterner) -> ~str { if p.is_empty() { - itr.get(i.name).to_owned() + itr.get(i.name).into_owned() } else { - format!("{}::{}", path_to_str(*p, itr), itr.get(i.name)) + let string = itr.get(i.name); + format!("{}::{}", path_to_str(*p, itr), string.as_slice()) } } @@ -75,7 +76,7 @@ pub fn path_to_str(p: &[PathElem], itr: @IdentInterner) -> ~str { pub fn path_elem_to_str(pe: PathElem, itr: @IdentInterner) -> ~str { match pe { PathMod(s) | PathName(s) | PathPrettyName(s, _) => { - itr.get(s.name).to_owned() + itr.get(s.name).into_owned() } } } @@ -105,7 +106,11 @@ fn pretty_ty(ty: &Ty, itr: @IdentInterner, out: &mut ~str) { // need custom handling. TyNil => { out.push_str("$NIL$"); return } TyPath(ref path, _, _) => { - out.push_str(itr.get(path.segments.last().unwrap().identifier.name)); + out.push_str(itr.get(path.segments + .last() + .unwrap() + .identifier + .name).as_slice()); return } TyTup(ref tys) => { @@ -138,7 +143,8 @@ pub fn impl_pretty_name(trait_ref: &Option, ty: &Ty) -> PathElem { match *trait_ref { None => pretty = ~"", Some(ref trait_ref) => { - pretty = itr.get(trait_ref.path.segments.last().unwrap().identifier.name).to_owned(); + pretty = itr.get(trait_ref.path.segments.last().unwrap().identifier.name) + .into_owned(); pretty.push_char('$'); } }; @@ -489,17 +495,21 @@ pub fn node_id_to_str(map: Map, id: NodeId, itr: @IdentInterner) -> ~str { path_ident_to_str(path, item.ident, itr), abi, id) } Some(NodeMethod(m, _, path)) => { + let name = itr.get(m.ident.name); format!("method {} in {} (id={})", - itr.get(m.ident.name), path_to_str(*path, itr), id) + name.as_slice(), path_to_str(*path, itr), id) } Some(NodeTraitMethod(ref tm, _, path)) => { let m = ast_util::trait_method_to_ty_method(&**tm); + let name = itr.get(m.ident.name); format!("method {} in {} (id={})", - itr.get(m.ident.name), path_to_str(*path, itr), id) + name.as_slice(), path_to_str(*path, itr), id) } Some(NodeVariant(ref variant, _, path)) => { + let name = itr.get(variant.node.name.name); format!("variant {} in {} (id={})", - itr.get(variant.node.name.name), path_to_str(*path, itr), id) + name.as_slice(), + path_to_str(*path, itr), id) } Some(NodeExpr(expr)) => { format!("expr {} (id={})", pprust::expr_to_str(expr, itr), id) diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 86913711801..dc16f32b872 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -3979,8 +3979,9 @@ impl Parser { fields.push(self.parse_struct_decl_field()); } if fields.len() == 0 { + let string = get_ident_interner().get(class_name.name); self.fatal(format!("Unit-like struct definition should be written as `struct {};`", - get_ident_interner().get(class_name.name))); + string.as_slice())); } self.bump(); } else if self.token == token::LPAREN { diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs index 806c84c5553..eb2fa151f51 100644 --- a/src/libsyntax/parse/token.rs +++ b/src/libsyntax/parse/token.rs @@ -12,7 +12,7 @@ use ast; use ast::{P, Name, Mrk}; use ast_util; use parse::token; -use util::interner::StrInterner; +use util::interner::{RcStr, StrInterner}; use util::interner; use extra::serialize::{Decodable, Decoder, Encodable, Encoder}; @@ -214,8 +214,11 @@ pub fn to_str(input: @IdentInterner, t: &Token) -> ~str { } /* Name components */ - IDENT(s, _) => input.get(s.name).to_owned(), - LIFETIME(s) => format!("'{}", input.get(s.name)), + IDENT(s, _) => input.get(s.name).into_owned(), + LIFETIME(s) => { + let name = input.get(s.name); + format!("'{}", name.as_slice()) + } UNDERSCORE => ~"_", /* Other */ @@ -549,7 +552,7 @@ pub fn get_ident_interner() -> @IdentInterner { #[no_send] #[deriving(Clone, Eq, IterBytes, Ord, TotalEq, TotalOrd)] pub struct InternedString { - priv string: @str, + priv string: RcStr, } #[unsafe_destructor] @@ -563,13 +566,12 @@ impl InternedString { #[inline] pub fn new(string: &'static str) -> InternedString { InternedString { - string: string.to_managed(), + string: RcStr::new(string), } } - // NB: Do not make this public. We are trying to remove `@str`. #[inline] - fn new_from_at_str(string: @str) -> InternedString { + fn new_from_rc_str(string: RcStr) -> InternedString { InternedString { string: string, } @@ -594,7 +596,7 @@ impl BytesContainer for InternedString { impl fmt::Default for InternedString { fn fmt(obj: &InternedString, f: &mut fmt::Formatter) { - write!(f.buf, "{}", obj.string); + write!(f.buf, "{}", obj.string.as_slice()); } } @@ -613,7 +615,7 @@ impl Decodable for InternedString { impl Encodable for InternedString { fn encode(&self, e: &mut E) { - e.emit_str(self.string) + e.emit_str(self.string.as_slice()) } } @@ -622,7 +624,7 @@ impl Encodable for InternedString { #[inline] pub fn get_ident(idx: Name) -> InternedString { let interner = get_ident_interner(); - InternedString::new_from_at_str(interner.get(idx)) + InternedString::new_from_rc_str(interner.get(idx)) } /// Interns and returns the string contents of an identifier, using the diff --git a/src/libsyntax/util/interner.rs b/src/libsyntax/util/interner.rs index c0fe19ede01..e20efda9c6e 100644 --- a/src/libsyntax/util/interner.rs +++ b/src/libsyntax/util/interner.rs @@ -18,6 +18,7 @@ use std::cast; use std::cell::RefCell; use std::cmp::Equiv; use std::hashmap::HashMap; +use std::rc::Rc; pub struct Interner { priv map: @RefCell>, @@ -83,11 +84,49 @@ impl Interner { } } +#[deriving(Clone, Eq, IterBytes, Ord)] +pub struct RcStr { + priv string: Rc<~str>, +} + +impl TotalEq for RcStr { + fn equals(&self, other: &RcStr) -> bool { + self.as_slice().equals(&other.as_slice()) + } +} + +impl TotalOrd for RcStr { + fn cmp(&self, other: &RcStr) -> Ordering { + self.as_slice().cmp(&other.as_slice()) + } +} + +impl Str for RcStr { + #[inline] + fn as_slice<'a>(&'a self) -> &'a str { + let s: &'a str = *self.string.borrow(); + s + } + + #[inline] + fn into_owned(self) -> ~str { + self.string.borrow().to_owned() + } +} + +impl RcStr { + pub fn new(string: &str) -> RcStr { + RcStr { + string: Rc::new(string.to_owned()), + } + } +} + // A StrInterner differs from Interner in that it accepts // references rather than @ ones, resulting in less allocation. pub struct StrInterner { - priv map: @RefCell>, - priv vect: @RefCell<~[@str]>, + priv map: @RefCell>, + priv vect: @RefCell<~[RcStr]>, } // when traits can extend traits, we should extend index to get [] @@ -113,8 +152,8 @@ impl StrInterner { } let new_idx = self.len() as Name; - let val = val.to_managed(); - map.get().insert(val, new_idx); + let val = RcStr::new(val); + map.get().insert(val.clone(), new_idx); let mut vect = self.vect.borrow_mut(); vect.get().push(val); new_idx @@ -124,7 +163,7 @@ impl StrInterner { let new_idx = self.len() as Name; // leave out of .map to avoid colliding let mut vect = self.vect.borrow_mut(); - vect.get().push(val.to_managed()); + vect.get().push(RcStr::new(val)); new_idx } @@ -142,21 +181,21 @@ impl StrInterner { let new_idx = self.len() as Name; // leave out of map to avoid colliding let mut vect = self.vect.borrow_mut(); - let existing = vect.get()[idx]; + let existing = vect.get()[idx].clone(); vect.get().push(existing); new_idx } - pub fn get(&self, idx: Name) -> @str { + pub fn get(&self, idx: Name) -> RcStr { let vect = self.vect.borrow(); - vect.get()[idx] + vect.get()[idx].clone() } /// Returns this string with lifetime tied to the interner. Since /// strings may never be removed from the interner, this is safe. pub fn get_ref<'a>(&'a self, idx: Name) -> &'a str { let vect = self.vect.borrow(); - let s: &str = vect.get()[idx]; + let s: &str = vect.get()[idx].as_slice(); unsafe { cast::transmute(s) } @@ -167,7 +206,7 @@ impl StrInterner { vect.get().len() } - pub fn find_equiv>(&self, val: &Q) + pub fn find_equiv>(&self, val: &Q) -> Option { let map = self.map.borrow(); match map.get().find_equiv(val) { @@ -183,42 +222,46 @@ mod tests { #[test] #[should_fail] fn i1 () { - let i : Interner<@str> = Interner::new(); + let i : Interner = Interner::new(); i.get(13); } #[test] fn interner_tests () { - let i : Interner<@str> = Interner::new(); + let i : Interner = Interner::new(); // first one is zero: - assert_eq!(i.intern(@"dog"), 0); + assert_eq!(i.intern(RcStr::new("dog")), 0); // re-use gets the same entry: - assert_eq!(i.intern(@"dog"), 0); + assert_eq!(i.intern(RcStr::new("dog")), 0); // different string gets a different #: - assert_eq!(i.intern(@"cat"), 1); - assert_eq!(i.intern(@"cat"), 1); + assert_eq!(i.intern(RcStr::new("cat")), 1); + assert_eq!(i.intern(RcStr::new("cat")), 1); // dog is still at zero - assert_eq!(i.intern(@"dog"), 0); + assert_eq!(i.intern(RcStr::new("dog")), 0); // gensym gets 3 - assert_eq!(i.gensym(@"zebra" ), 2); + assert_eq!(i.gensym(RcStr::new("zebra") ), 2); // gensym of same string gets new number : - assert_eq!(i.gensym (@"zebra" ), 3); + assert_eq!(i.gensym (RcStr::new("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(RcStr::new("dog")), 4); + assert_eq!(i.get(0), RcStr::new("dog")); + assert_eq!(i.get(1), RcStr::new("cat")); + assert_eq!(i.get(2), RcStr::new("zebra")); + assert_eq!(i.get(3), RcStr::new("zebra")); + assert_eq!(i.get(4), RcStr::new("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([ + RcStr::new("Alan"), + RcStr::new("Bob"), + RcStr::new("Carol") + ]); + assert_eq!(i.get(0), RcStr::new("Alan")); + assert_eq!(i.get(1), RcStr::new("Bob")); + assert_eq!(i.get(2), RcStr::new("Carol")); + assert_eq!(i.intern(RcStr::new("Bob")), 1); } #[test] @@ -241,13 +284,13 @@ mod tests { assert_eq!(i.gensym("dog"), 4); // gensym tests again with gensym_copy: assert_eq!(i.gensym_copy(2), 5); - assert_eq!(i.get(5), @"zebra"); + assert_eq!(i.get(5), RcStr::new("zebra")); assert_eq!(i.gensym_copy(2), 6); - assert_eq!(i.get(6), @"zebra"); - 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.get(6), RcStr::new("zebra")); + assert_eq!(i.get(0), RcStr::new("dog")); + assert_eq!(i.get(1), RcStr::new("cat")); + assert_eq!(i.get(2), RcStr::new("zebra")); + assert_eq!(i.get(3), RcStr::new("zebra")); + assert_eq!(i.get(4), RcStr::new("dog")); } } -- cgit 1.4.1-3-g733a5 From c594e675eb3db25cd018d58d8fe06ef6ea2c90de Mon Sep 17 00:00:00 2001 From: Patrick Walton Date: Fri, 31 Jan 2014 18:25:08 -0800 Subject: librustc: Remove `@str` from the language --- src/librustc/middle/lint.rs | 2 +- src/librustc/middle/mem_categorization.rs | 3 +-- src/librustc/middle/trans/debuginfo.rs | 3 +-- src/librustc/middle/trans/type_of.rs | 2 +- src/librustc/middle/typeck/astconv.rs | 11 ++++++++++- src/librustdoc/clean.rs | 7 +++++-- src/libstd/str.rs | 1 - src/libsyntax/ext/expand.rs | 4 ++-- src/libsyntax/parse/obsolete.rs | 5 +++++ src/libsyntax/parse/parser.rs | 5 ++++- src/libsyntax/parse/token.rs | 9 +++++---- src/libsyntax/util/interner.rs | 2 +- src/test/compile-fail/lint-heap-memory.rs | 1 - 13 files changed, 36 insertions(+), 19 deletions(-) (limited to 'src/libsyntax/parse') diff --git a/src/librustc/middle/lint.rs b/src/librustc/middle/lint.rs index af83bc97adc..33f97b3ba2a 100644 --- a/src/librustc/middle/lint.rs +++ b/src/librustc/middle/lint.rs @@ -887,7 +887,7 @@ fn check_heap_type(cx: &Context, span: Span, ty: ty::t) { let mut n_uniq = 0; ty::fold_ty(cx.tcx, ty, |t| { match ty::get(t).sty { - ty::ty_box(_) | ty::ty_str(ty::vstore_box) | + ty::ty_box(_) | ty::ty_vec(_, ty::vstore_box) | ty::ty_trait(_, _, ty::BoxTraitStore, _, _) => { n_box += 1; diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs index d98cf9795b2..9bab74dc56a 100644 --- a/src/librustc/middle/mem_categorization.rs +++ b/src/librustc/middle/mem_categorization.rs @@ -179,8 +179,7 @@ pub fn opt_deref_kind(t: ty::t) -> Option { ty::ty_box(_) | ty::ty_vec(_, ty::vstore_box) | - ty::ty_trait(_, _, ty::BoxTraitStore, _, _) | - ty::ty_str(ty::vstore_box) => { + ty::ty_trait(_, _, ty::BoxTraitStore, _, _) => { Some(deref_ptr(gc_ptr)) } diff --git a/src/librustc/middle/trans/debuginfo.rs b/src/librustc/middle/trans/debuginfo.rs index 2611076f15d..b89ec9d19df 100644 --- a/src/librustc/middle/trans/debuginfo.rs +++ b/src/librustc/middle/trans/debuginfo.rs @@ -2094,8 +2094,7 @@ fn type_metadata(cx: &CrateContext, pointer_type_metadata(cx, t, vec_metadata) } ty::vstore_box => { - let boxed_vec_metadata = boxed_vec_metadata(cx, i8_t, usage_site_span); - pointer_type_metadata(cx, t, boxed_vec_metadata) + fail!("unexpected managed string") } ty::vstore_slice(_region) => { vec_slice_metadata(cx, t, i8_t, usage_site_span) diff --git a/src/librustc/middle/trans/type_of.rs b/src/librustc/middle/trans/type_of.rs index 86456187d1a..b440db66a12 100644 --- a/src/librustc/middle/trans/type_of.rs +++ b/src/librustc/middle/trans/type_of.rs @@ -222,7 +222,7 @@ pub fn type_of(cx: &CrateContext, t: ty::t) -> Type { adt::incomplete_type_of(cx, repr, name) } ty::ty_str(ty::vstore_box) => { - Type::at_box(cx, Type::vec(cx.sess.targ_cfg.arch, &Type::i8())).ptr_to() + fail!("unexpected managed string") } ty::ty_vec(ref mt, ty::vstore_box) => { let e_ty = type_of(cx, mt.ty); diff --git a/src/librustc/middle/typeck/astconv.rs b/src/librustc/middle/typeck/astconv.rs index 9f44aa1a023..9f8b9140417 100644 --- a/src/librustc/middle/typeck/astconv.rs +++ b/src/librustc/middle/typeck/astconv.rs @@ -413,8 +413,17 @@ pub fn ast_ty_to_ty( // will run after this as long as the path isn't a trait. let def_map = tcx.def_map.borrow(); match def_map.get().find(&id) { - Some(&ast::DefPrimTy(ast::TyStr)) if a_seq_ty.mutbl == ast::MutImmutable => { + Some(&ast::DefPrimTy(ast::TyStr)) if + a_seq_ty.mutbl == ast::MutImmutable => { check_path_args(tcx, path, NO_TPS | NO_REGIONS); + match vst { + ty::vstore_box => { + tcx.sess.span_err(path.span, + "managed strings are not \ + supported") + } + _ => {} + } return ty::mk_str(tcx, vst); } Some(&ast::DefTrait(trait_def_id)) => { diff --git a/src/librustdoc/clean.rs b/src/librustdoc/clean.rs index 53bae09f58c..4f7e6df95e1 100644 --- a/src/librustdoc/clean.rs +++ b/src/librustdoc/clean.rs @@ -874,11 +874,14 @@ impl Clean for ast::PathSegment { } fn path_to_str(p: &ast::Path) -> ~str { - use syntax::parse::token::interner_get; + use syntax::parse::token; let mut s = ~""; let mut first = true; - for i in p.segments.iter().map(|x| interner_get(x.identifier.name)) { + for i in p.segments.iter().map(|x| { + let string = token::get_ident(x.identifier.name); + string.get().to_str() + }) { if !first || p.global { s.push_str("::"); } else { diff --git a/src/libstd/str.rs b/src/libstd/str.rs index 5d5beb3609e..0315e560bb7 100644 --- a/src/libstd/str.rs +++ b/src/libstd/str.rs @@ -3477,7 +3477,6 @@ mod tests { let e = $e; assert_eq!(s1 + s2, e.to_owned()); assert_eq!(s1.to_owned() + s2, e.to_owned()); - assert_eq!(s1.to_managed() + s2, e.to_owned()); } } ); diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs index f7419e77ff5..d8d98b27793 100644 --- a/src/libsyntax/ext/expand.rs +++ b/src/libsyntax/ext/expand.rs @@ -1224,7 +1224,7 @@ mod test { fn run_renaming_test(t: &RenamingTest, test_idx: uint) { let invalid_name = token::special_idents::invalid.name; let (teststr, bound_connections, bound_ident_check) = match *t { - (ref str,ref conns, bic) => (str.to_managed(), conns.clone(), bic) + (ref str,ref conns, bic) => (str.to_owned(), conns.clone(), bic) }; let cr = expand_crate_str(teststr.to_owned()); // find the bindings: @@ -1304,7 +1304,7 @@ foo_module!() let cxbinds : ~[&ast::Ident] = bindings.iter().filter(|b| { - let string = token::get_ident(b); + let string = token::get_ident(b.name); "xx" == string.get() }).collect(); let cxbind = match cxbinds { diff --git a/src/libsyntax/parse/obsolete.rs b/src/libsyntax/parse/obsolete.rs index 04c73ce71d0..46f1f33143e 100644 --- a/src/libsyntax/parse/obsolete.rs +++ b/src/libsyntax/parse/obsolete.rs @@ -44,6 +44,7 @@ pub enum ObsoleteSyntax { ObsoleteMultipleImport, ObsoleteExternModAttributesInParens, ObsoleteManagedPattern, + ObsoleteManagedString, } impl to_bytes::IterBytes for ObsoleteSyntax { @@ -149,6 +150,10 @@ impl ParserObsoleteMethods for Parser { "use a nested `match` expression instead of a managed box \ pattern" ), + ObsoleteManagedString => ( + "managed string", + "use `Rc<~str>` instead of a managed string" + ), }; self.report(sp, kind, kind_str, desc); diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index dc16f32b872..fb679fa0460 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -2295,7 +2295,10 @@ impl Parser { ex = match e.node { ExprVec(..) | ExprRepeat(..) => ExprVstore(e, ExprVstoreBox), - ExprLit(lit) if lit_is_str(lit) => ExprVstore(e, ExprVstoreBox), + ExprLit(lit) if lit_is_str(lit) => { + self.obsolete(self.last_span, ObsoleteManagedString); + ExprVstore(e, ExprVstoreBox) + } _ => self.mk_unary(UnBox, e) }; } diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs index eb2fa151f51..fa53f021cdb 100644 --- a/src/libsyntax/parse/token.rs +++ b/src/libsyntax/parse/token.rs @@ -544,8 +544,8 @@ pub fn get_ident_interner() -> @IdentInterner { /// interner lives for the life of the task, this can be safely treated as an /// immortal string, as long as it never crosses between tasks. /// -/// XXX(pcwalton): You must be careful about what you do in the destructors of -/// objects stored in TLS, because they may run after the interner is +/// FIXME(pcwalton): You must be careful about what you do in the destructors +/// of objects stored in TLS, because they may run after the interner is /// destroyed. In particular, they must not access string contents. This can /// be fixed in the future by just leaking all strings until task death /// somehow. @@ -585,8 +585,9 @@ impl InternedString { impl BytesContainer for InternedString { fn container_as_bytes<'a>(&'a self) -> &'a [u8] { - // XXX(pcwalton): This is a workaround for the incorrect signature of - // `BytesContainer`, which is itself a workaround for the lack of DST. + // FIXME(pcwalton): This is a workaround for the incorrect signature + // of `BytesContainer`, which is itself a workaround for the lack of + // DST. unsafe { let this = self.get(); cast::transmute(this.container_as_bytes()) diff --git a/src/libsyntax/util/interner.rs b/src/libsyntax/util/interner.rs index e20efda9c6e..fc3e55dcde2 100644 --- a/src/libsyntax/util/interner.rs +++ b/src/libsyntax/util/interner.rs @@ -253,7 +253,7 @@ mod tests { #[test] fn i3 () { - let i : Interner<@~str> = Interner::prefill([ + let i : Interner = Interner::prefill([ RcStr::new("Alan"), RcStr::new("Bob"), RcStr::new("Carol") diff --git a/src/test/compile-fail/lint-heap-memory.rs b/src/test/compile-fail/lint-heap-memory.rs index 0c19988bef4..5e8c83558fb 100644 --- a/src/test/compile-fail/lint-heap-memory.rs +++ b/src/test/compile-fail/lint-heap-memory.rs @@ -25,7 +25,6 @@ fn main() { @[1]; //~ ERROR type uses managed //~^ ERROR type uses managed fn f(_: @Clone) {} //~ ERROR type uses managed - //~^ ERROR type uses managed ~2; //~ ERROR type uses owned ~[1]; //~ ERROR type uses owned -- cgit 1.4.1-3-g733a5 From f502576fc7a97825ee90b01c724b63a4bd4c85aa Mon Sep 17 00:00:00 2001 From: Huon Wilson Date: Sun, 2 Feb 2014 02:19:55 +1100 Subject: Fix `@str` removal tests. --- src/librustc/driver/driver.rs | 2 +- src/libstd/gc.rs | 1 - src/libsyntax/parse/token.rs | 1 - 3 files changed, 1 insertion(+), 3 deletions(-) (limited to 'src/libsyntax/parse') diff --git a/src/librustc/driver/driver.rs b/src/librustc/driver/driver.rs index 00b878a7bf7..b779c7e73b1 100644 --- a/src/librustc/driver/driver.rs +++ b/src/librustc/driver/driver.rs @@ -1213,7 +1213,7 @@ mod test { let sessopts = build_session_options(~"rustc", matches, @diagnostic::DefaultEmitter); let sess = build_session(sessopts, None, @diagnostic::DefaultEmitter); let cfg = build_configuration(sess); - let mut test_items = cfg.iter().filter(|m| "test" == m.name()); + let mut test_items = cfg.iter().filter(|m| m.name().equiv(&("test"))); assert!(test_items.next().is_some()); assert!(test_items.next().is_none()); } diff --git a/src/libstd/gc.rs b/src/libstd/gc.rs index 8ec07290a31..fa7c94ac994 100644 --- a/src/libstd/gc.rs +++ b/src/libstd/gc.rs @@ -35,7 +35,6 @@ pub struct Gc { } #[cfg(test)] -#[no_send] pub struct Gc { priv ptr: @T, priv marker: marker::NoSend, diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs index fa53f021cdb..c0abbb9222b 100644 --- a/src/libsyntax/parse/token.rs +++ b/src/libsyntax/parse/token.rs @@ -549,7 +549,6 @@ pub fn get_ident_interner() -> @IdentInterner { /// destroyed. In particular, they must not access string contents. This can /// be fixed in the future by just leaking all strings until task death /// somehow. -#[no_send] #[deriving(Clone, Eq, IterBytes, Ord, TotalEq, TotalOrd)] pub struct InternedString { priv string: RcStr, -- cgit 1.4.1-3-g733a5 From e0c1707560d02bb5805b33cb17e8abfc339eb16b Mon Sep 17 00:00:00 2001 From: Huon Wilson Date: Sun, 2 Feb 2014 02:53:26 +1100 Subject: Changes from the review of the @str PR. --- src/librustc/metadata/cstore.rs | 10 +--------- src/librustdoc/clean.rs | 7 ++----- src/libsyntax/parse/token.rs | 7 ------- 3 files changed, 3 insertions(+), 21 deletions(-) (limited to 'src/libsyntax/parse') diff --git a/src/librustc/metadata/cstore.rs b/src/librustc/metadata/cstore.rs index 45eccc94ed8..33625000e4a 100644 --- a/src/librustc/metadata/cstore.rs +++ b/src/librustc/metadata/cstore.rs @@ -215,15 +215,7 @@ impl CStore { debug!(" hash[{}]: {}", x.name, x.hash); } - let mut hashes = ~[]; - for ch in result.move_iter() { - let crate_hash { - hash, - .. - } = ch; - hashes.push(hash) - } - hashes + result.move_iter().map(|crate_hash { hash, ..}| hash).collect() } } diff --git a/src/librustdoc/clean.rs b/src/librustdoc/clean.rs index 4f7e6df95e1..94e5273fced 100644 --- a/src/librustdoc/clean.rs +++ b/src/librustdoc/clean.rs @@ -878,16 +878,13 @@ fn path_to_str(p: &ast::Path) -> ~str { let mut s = ~""; let mut first = true; - for i in p.segments.iter().map(|x| { - let string = token::get_ident(x.identifier.name); - string.get().to_str() - }) { + for i in p.segments.iter().map(|x| token::get_ident(x.identifier.name)) { if !first || p.global { s.push_str("::"); } else { first = false; } - s.push_str(i); + s.push_str(i.get()); } s } diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs index c0abbb9222b..d6edccd33a4 100644 --- a/src/libsyntax/parse/token.rs +++ b/src/libsyntax/parse/token.rs @@ -554,13 +554,6 @@ pub struct InternedString { priv string: RcStr, } -#[unsafe_destructor] -impl Drop for InternedString { - fn drop(&mut self) { - // No-op just to make this not implicitly copyable. - } -} - impl InternedString { #[inline] pub fn new(string: &'static str) -> InternedString { -- cgit 1.4.1-3-g733a5 From aadcf29766553a6b6ed8a3c2f50193ebd674b7a7 Mon Sep 17 00:00:00 2001 From: Huon Wilson Date: Sat, 1 Feb 2014 23:18:45 +1100 Subject: syntax: add an obsolete syntax warning for @[]. --- src/libsyntax/parse/obsolete.rs | 5 +++++ src/libsyntax/parse/parser.rs | 5 ++++- 2 files changed, 9 insertions(+), 1 deletion(-) (limited to 'src/libsyntax/parse') diff --git a/src/libsyntax/parse/obsolete.rs b/src/libsyntax/parse/obsolete.rs index 46f1f33143e..b85d89cf804 100644 --- a/src/libsyntax/parse/obsolete.rs +++ b/src/libsyntax/parse/obsolete.rs @@ -45,6 +45,7 @@ pub enum ObsoleteSyntax { ObsoleteExternModAttributesInParens, ObsoleteManagedPattern, ObsoleteManagedString, + ObsoleteManagedVec, } impl to_bytes::IterBytes for ObsoleteSyntax { @@ -154,6 +155,10 @@ impl ParserObsoleteMethods for Parser { "managed string", "use `Rc<~str>` instead of a managed string" ), + ObsoleteManagedVec => ( + "managed vector", + "use `Rc<~[T]>` instead of a managed vector" + ), }; self.report(sp, kind, kind_str, desc); diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index fb679fa0460..ec2a13c5a0f 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -2294,7 +2294,10 @@ impl Parser { // HACK: turn @[...] into a @-vec ex = match e.node { ExprVec(..) | - ExprRepeat(..) => ExprVstore(e, ExprVstoreBox), + ExprRepeat(..) => { + self.obsolete(e.span, ObsoleteManagedVec); + ExprVstore(e, ExprVstoreBox) + } ExprLit(lit) if lit_is_str(lit) => { self.obsolete(self.last_span, ObsoleteManagedString); ExprVstore(e, ExprVstoreBox) -- cgit 1.4.1-3-g733a5 From e39cd20a4311f6e1377a01462cda5a89a4e67c15 Mon Sep 17 00:00:00 2001 From: Huon Wilson Date: Sun, 2 Feb 2014 00:08:39 +1100 Subject: syntax: remove the handling of @str and @[] from the parser completely. --- src/librustc/front/feature_gate.rs | 3 +-- src/librustc/middle/check_const.rs | 3 +-- src/librustc/middle/const_eval.rs | 1 - src/librustc/middle/lint.rs | 3 +-- src/librustc/middle/trans/expr.rs | 9 -------- src/librustc/middle/ty.rs | 1 - src/librustc/middle/typeck/check/mod.rs | 1 - src/libsyntax/ast.rs | 1 - src/libsyntax/parse/parser.rs | 39 ++++++++------------------------- src/libsyntax/print/pprust.rs | 1 - 10 files changed, 12 insertions(+), 50 deletions(-) (limited to 'src/libsyntax/parse') diff --git a/src/librustc/front/feature_gate.rs b/src/librustc/front/feature_gate.rs index de5a7b7fd88..ed4455c2f89 100644 --- a/src/librustc/front/feature_gate.rs +++ b/src/librustc/front/feature_gate.rs @@ -228,8 +228,7 @@ impl Visitor<()> for Context { fn visit_expr(&mut self, e: &ast::Expr, _: ()) { match e.node { - ast::ExprUnary(_, ast::UnBox, _) | - ast::ExprVstore(_, ast::ExprVstoreBox) => { + ast::ExprUnary(_, ast::UnBox, _) => { self.gate_box(e.span); } _ => {} diff --git a/src/librustc/middle/check_const.rs b/src/librustc/middle/check_const.rs index 2af40163588..d52ae81328f 100644 --- a/src/librustc/middle/check_const.rs +++ b/src/librustc/middle/check_const.rs @@ -192,8 +192,7 @@ pub fn check_expr(v: &mut CheckCrateVisitor, "references in constants may only refer to \ immutable values"); }, - ExprVstore(_, ExprVstoreUniq) | - ExprVstore(_, ExprVstoreBox) => { + ExprVstore(_, ExprVstoreUniq) => { sess.span_err(e.span, "cannot allocate vectors in constant expressions") }, diff --git a/src/librustc/middle/const_eval.rs b/src/librustc/middle/const_eval.rs index d0ca53116b8..cbe1e8f72d9 100644 --- a/src/librustc/middle/const_eval.rs +++ b/src/librustc/middle/const_eval.rs @@ -240,7 +240,6 @@ impl ConstEvalVisitor { match vstore { ast::ExprVstoreSlice => self.classify(e), ast::ExprVstoreUniq | - ast::ExprVstoreBox | ast::ExprVstoreMutSlice => non_const } } diff --git a/src/librustc/middle/lint.rs b/src/librustc/middle/lint.rs index 33f97b3ba2a..39797353993 100644 --- a/src/librustc/middle/lint.rs +++ b/src/librustc/middle/lint.rs @@ -1248,8 +1248,7 @@ fn check_unnecessary_allocation(cx: &Context, e: &ast::Expr) { // Warn if string and vector literals with sigils, or boxing expressions, // are immediately borrowed. let allocation = match e.node { - ast::ExprVstore(e2, ast::ExprVstoreUniq) | - ast::ExprVstore(e2, ast::ExprVstoreBox) => { + ast::ExprVstore(e2, ast::ExprVstoreUniq) => { match e2.node { ast::ExprLit(lit) if ast_util::lit_is_str(lit) => { VectorAllocation diff --git a/src/librustc/middle/trans/expr.rs b/src/librustc/middle/trans/expr.rs index bbe5bdc967b..da5fa8385e9 100644 --- a/src/librustc/middle/trans/expr.rs +++ b/src/librustc/middle/trans/expr.rs @@ -519,14 +519,6 @@ fn trans_datum_unadjusted<'a>(bcx: &'a Block<'a>, ast::ExprIndex(_, base, idx) => { trans_index(bcx, expr, base, idx) } - ast::ExprVstore(contents, ast::ExprVstoreBox) => { - fcx.push_ast_cleanup_scope(contents.id); - let datum = unpack_datum!( - bcx, tvec::trans_uniq_or_managed_vstore(bcx, heap_managed, - expr, contents)); - bcx = fcx.pop_and_trans_ast_cleanup_scope(bcx, contents.id); - DatumBlock(bcx, datum) - } ast::ExprVstore(contents, ast::ExprVstoreUniq) => { fcx.push_ast_cleanup_scope(contents.id); let datum = unpack_datum!( @@ -2030,4 +2022,3 @@ fn deref_once<'a>(bcx: &'a Block<'a>, DatumBlock { bcx: bcx, datum: datum } } } - diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index dd7c0803333..6b42183d42b 100644 --- a/src/librustc/middle/ty.rs +++ b/src/librustc/middle/ty.rs @@ -3303,7 +3303,6 @@ pub fn expr_kind(tcx: ctxt, ast::ExprUnary(..) | ast::ExprAddrOf(..) | ast::ExprBinary(..) | - ast::ExprVstore(_, ast::ExprVstoreBox) | ast::ExprVstore(_, ast::ExprVstoreUniq) => { RvalueDatumExpr } diff --git a/src/librustc/middle/typeck/check/mod.rs b/src/librustc/middle/typeck/check/mod.rs index f446326eb16..43179aa3c92 100644 --- a/src/librustc/middle/typeck/check/mod.rs +++ b/src/librustc/middle/typeck/check/mod.rs @@ -3909,7 +3909,6 @@ pub fn ast_expr_vstore_to_vstore(fcx: @FnCtxt, -> ty::vstore { match v { ast::ExprVstoreUniq => ty::vstore_uniq, - ast::ExprVstoreBox => ty::vstore_box, ast::ExprVstoreSlice | ast::ExprVstoreMutSlice => { match e.node { ast::ExprLit(..) | diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index dcac134329c..a5fb03f051e 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -417,7 +417,6 @@ pub enum Vstore { #[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] pub enum ExprVstore { ExprVstoreUniq, // ~[1,2,3,4] - ExprVstoreBox, // @[1,2,3,4] ExprVstoreSlice, // &[1,2,3,4] ExprVstoreMutSlice, // &mut [1,2,3,4] } diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index ec2a13c5a0f..aa33edf28f5 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -29,7 +29,7 @@ use ast::{ExprField, ExprFnBlock, ExprIf, ExprIndex}; use ast::{ExprLit, ExprLogLevel, ExprLoop, ExprMac}; use ast::{ExprMethodCall, ExprParen, ExprPath, ExprProc}; use ast::{ExprRepeat, ExprRet, ExprStruct, ExprTup, ExprUnary}; -use ast::{ExprVec, ExprVstore, ExprVstoreSlice, ExprVstoreBox}; +use ast::{ExprVec, ExprVstore, ExprVstoreSlice}; use ast::{ExprVstoreMutSlice, ExprWhile, ExprForLoop, ExternFn, Field, FnDecl}; use ast::{ExprVstoreUniq, Onceness, Once, Many}; use ast::{ForeignItem, ForeignItemStatic, ForeignItemFn, ForeignMod}; @@ -2291,16 +2291,18 @@ impl Parser { self.bump(); let e = self.parse_prefix_expr(); hi = e.span.hi; - // HACK: turn @[...] into a @-vec + // HACK: pretending @[] is a (removed) @-vec ex = match e.node { ExprVec(..) | ExprRepeat(..) => { self.obsolete(e.span, ObsoleteManagedVec); - ExprVstore(e, ExprVstoreBox) + // the above error means that no-one will know we're + // lying... hopefully. + ExprVstore(e, ExprVstoreUniq) } ExprLit(lit) if lit_is_str(lit) => { self.obsolete(self.last_span, ObsoleteManagedString); - ExprVstore(e, ExprVstoreBox) + ExprVstore(e, ExprVstoreUniq) } _ => self.mk_unary(UnBox, e) }; @@ -2819,34 +2821,11 @@ impl Parser { token::AT => { self.bump(); let sub = self.parse_pat(); - hi = sub.span.hi; - // HACK: parse @"..." as a literal of a vstore @str - pat = match sub.node { - PatLit(e) => { - match e.node { - ExprLit(lit) if lit_is_str(lit) => { - let vst = @Expr { - id: ast::DUMMY_NODE_ID, - node: ExprVstore(e, ExprVstoreBox), - span: mk_sp(lo, hi), - }; - PatLit(vst) - } - _ => { - self.obsolete(self.span, ObsoleteManagedPattern); - PatUniq(sub) - } - } - } - _ => { - self.obsolete(self.span, ObsoleteManagedPattern); - PatUniq(sub) - } - }; - hi = self.last_span.hi; + self.obsolete(self.span, ObsoleteManagedPattern); + let hi = self.last_span.hi; return @ast::Pat { id: ast::DUMMY_NODE_ID, - node: pat, + node: sub, span: mk_sp(lo, hi) } } diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index bdef5e093f2..cb37bdd72c9 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -1074,7 +1074,6 @@ pub fn print_vstore(s: &mut State, t: ast::Vstore) { pub fn print_expr_vstore(s: &mut State, t: ast::ExprVstore) { match t { ast::ExprVstoreUniq => word(&mut s.s, "~"), - ast::ExprVstoreBox => word(&mut s.s, "@"), ast::ExprVstoreSlice => word(&mut s.s, "&"), ast::ExprVstoreMutSlice => { word(&mut s.s, "&"); -- cgit 1.4.1-3-g733a5 From ec4b456b26cd019b8b2a4a8a3f9fa9841904bf09 Mon Sep 17 00:00:00 2001 From: Huon Wilson Date: Sun, 2 Feb 2014 00:09:11 +1100 Subject: rustc: Remove the vstore handling of @str and @[]. --- src/librustc/metadata/tydecode.rs | 1 - src/librustc/metadata/tyencode.rs | 1 - src/librustc/middle/lint.rs | 1 - src/librustc/middle/mem_categorization.rs | 1 - src/librustc/middle/trans/common.rs | 1 - src/librustc/middle/trans/debuginfo.rs | 24 ------------- src/librustc/middle/trans/glue.rs | 14 +------- src/librustc/middle/trans/reflect.rs | 1 - src/librustc/middle/trans/tvec.rs | 32 ++++-------------- src/librustc/middle/trans/type_of.rs | 9 ----- src/librustc/middle/ty.rs | 23 +++---------- src/librustc/middle/ty_fold.rs | 1 - src/librustc/middle/typeck/astconv.rs | 50 +++++++++++++++++----------- src/librustc/middle/typeck/check/_match.rs | 2 +- src/librustc/middle/typeck/check/method.rs | 2 -- src/librustc/middle/typeck/check/regionck.rs | 5 +-- src/librustc/middle/typeck/infer/coercion.rs | 3 +- src/librustc/middle/typeck/variance.rs | 2 +- src/librustc/util/ppaux.rs | 1 - src/libsyntax/parse/parser.rs | 2 +- 20 files changed, 47 insertions(+), 129 deletions(-) (limited to 'src/libsyntax/parse') diff --git a/src/librustc/metadata/tydecode.rs b/src/librustc/metadata/tydecode.rs index c9860162060..92af631c2bd 100644 --- a/src/librustc/metadata/tydecode.rs +++ b/src/librustc/metadata/tydecode.rs @@ -156,7 +156,6 @@ fn parse_vstore(st: &mut PState, conv: conv_did) -> ty::vstore { match next(st) { '~' => ty::vstore_uniq, - '@' => ty::vstore_box, '&' => ty::vstore_slice(parse_region(st, conv)), c => st.tcx.sess.bug(format!("parse_vstore(): bad input '{}'", c)) } diff --git a/src/librustc/metadata/tyencode.rs b/src/librustc/metadata/tyencode.rs index b7977f9d643..d17a4516543 100644 --- a/src/librustc/metadata/tyencode.rs +++ b/src/librustc/metadata/tyencode.rs @@ -219,7 +219,6 @@ pub fn enc_vstore(w: &mut MemWriter, cx: @ctxt, v: ty::vstore) { match v { ty::vstore_fixed(u) => mywrite!(w, "{}|", u), ty::vstore_uniq => mywrite!(w, "~"), - ty::vstore_box => mywrite!(w, "@"), ty::vstore_slice(r) => { mywrite!(w, "&"); enc_region(w, cx, r); diff --git a/src/librustc/middle/lint.rs b/src/librustc/middle/lint.rs index 39797353993..e674af6b3b3 100644 --- a/src/librustc/middle/lint.rs +++ b/src/librustc/middle/lint.rs @@ -888,7 +888,6 @@ fn check_heap_type(cx: &Context, span: Span, ty: ty::t) { ty::fold_ty(cx.tcx, ty, |t| { match ty::get(t).sty { ty::ty_box(_) | - ty::ty_vec(_, ty::vstore_box) | ty::ty_trait(_, _, ty::BoxTraitStore, _, _) => { n_box += 1; } diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs index 9bab74dc56a..72fd98e56ed 100644 --- a/src/librustc/middle/mem_categorization.rs +++ b/src/librustc/middle/mem_categorization.rs @@ -178,7 +178,6 @@ pub fn opt_deref_kind(t: ty::t) -> Option { } ty::ty_box(_) | - ty::ty_vec(_, ty::vstore_box) | ty::ty_trait(_, _, ty::BoxTraitStore, _, _) => { Some(deref_ptr(gc_ptr)) } diff --git a/src/librustc/middle/trans/common.rs b/src/librustc/middle/trans/common.rs index 04789b9ca70..78affcc69e1 100644 --- a/src/librustc/middle/trans/common.rs +++ b/src/librustc/middle/trans/common.rs @@ -768,7 +768,6 @@ pub fn mono_data_classify(t: ty::t) -> MonoDataClass { ty::ty_float(_) => MonoFloat, ty::ty_rptr(..) | ty::ty_uniq(..) | ty::ty_box(..) | ty::ty_str(ty::vstore_uniq) | ty::ty_vec(_, ty::vstore_uniq) | - ty::ty_str(ty::vstore_box) | ty::ty_vec(_, ty::vstore_box) | ty::ty_bare_fn(..) => MonoNonNull, // Is that everything? Would closures or slices qualify? _ => MonoBits diff --git a/src/librustc/middle/trans/debuginfo.rs b/src/librustc/middle/trans/debuginfo.rs index b89ec9d19df..3cdb1c52d3c 100644 --- a/src/librustc/middle/trans/debuginfo.rs +++ b/src/librustc/middle/trans/debuginfo.rs @@ -1896,23 +1896,6 @@ fn vec_metadata(cx: &CrateContext, span); } -fn boxed_vec_metadata(cx: &CrateContext, - element_type: ty::t, - span: Span) - -> DICompositeType { - let element_llvm_type = type_of::type_of(cx, element_type); - let vec_llvm_type = Type::vec(cx.sess.targ_cfg.arch, &element_llvm_type); - let vec_type_name: &str = format!("[{}]", ppaux::ty_to_str(cx.tcx, element_type)); - let vec_metadata = vec_metadata(cx, element_type, span); - - return boxed_type_metadata( - cx, - Some(vec_type_name), - vec_llvm_type, - vec_metadata, - span); -} - fn vec_slice_metadata(cx: &CrateContext, vec_type: ty::t, element_type: ty::t, @@ -2093,9 +2076,6 @@ fn type_metadata(cx: &CrateContext, let vec_metadata = vec_metadata(cx, i8_t, usage_site_span); pointer_type_metadata(cx, t, vec_metadata) } - ty::vstore_box => { - fail!("unexpected managed string") - } ty::vstore_slice(_region) => { vec_slice_metadata(cx, t, i8_t, usage_site_span) } @@ -2116,10 +2096,6 @@ fn type_metadata(cx: &CrateContext, let vec_metadata = vec_metadata(cx, mt.ty, usage_site_span); pointer_type_metadata(cx, t, vec_metadata) } - ty::vstore_box => { - let boxed_vec_metadata = boxed_vec_metadata(cx, mt.ty, usage_site_span); - pointer_type_metadata(cx, t, boxed_vec_metadata) - } ty::vstore_slice(_) => { vec_slice_metadata(cx, t, mt.ty, usage_site_span) } diff --git a/src/librustc/middle/trans/glue.rs b/src/librustc/middle/trans/glue.rs index 8002559e3f9..1bfbb3f99b1 100644 --- a/src/librustc/middle/trans/glue.rs +++ b/src/librustc/middle/trans/glue.rs @@ -64,10 +64,7 @@ pub fn take_ty<'a>(bcx: &'a Block<'a>, v: ValueRef, t: ty::t) // NB: v is an *alias* of type t here, not a direct value. let _icx = push_ctxt("take_ty"); match ty::get(t).sty { - ty::ty_box(_) | - ty::ty_vec(_, ty::vstore_box) | ty::ty_str(ty::vstore_box) => { - incr_refcnt_of_boxed(bcx, v) - } + ty::ty_box(_) => incr_refcnt_of_boxed(bcx, v), ty::ty_trait(_, _, ty::BoxTraitStore, _, _) => { incr_refcnt_of_boxed(bcx, GEPi(bcx, v, [0u, abi::trt_field_box])) } @@ -113,10 +110,6 @@ fn simplified_glue_type(tcx: ty::ctxt, field: uint, t: ty::t) -> ty::t { if !ty::type_needs_drop(tcx, typ) => return ty::mk_box(tcx, ty::mk_nil()), - ty::ty_vec(mt, ty::vstore_box) - if !ty::type_needs_drop(tcx, mt.ty) => - return ty::mk_box(tcx, ty::mk_nil()), - ty::ty_uniq(typ) if !ty::type_needs_drop(tcx, typ) => return ty::mk_uniq(tcx, ty::mk_nil()), @@ -326,11 +319,6 @@ fn make_drop_glue<'a>(bcx: &'a Block<'a>, v0: ValueRef, t: ty::t) -> &'a Block<' ty::ty_box(body_ty) => { decr_refcnt_maybe_free(bcx, v0, Some(body_ty)) } - ty::ty_str(ty::vstore_box) | ty::ty_vec(_, ty::vstore_box) => { - let unit_ty = ty::sequence_element_type(ccx.tcx, t); - let unboxed_vec_ty = ty::mk_mut_unboxed_vec(ccx.tcx, unit_ty); - decr_refcnt_maybe_free(bcx, v0, Some(unboxed_vec_ty)) - } ty::ty_uniq(content_ty) => { let llbox = Load(bcx, v0); let not_null = IsNotNull(bcx, llbox); diff --git a/src/librustc/middle/trans/reflect.rs b/src/librustc/middle/trans/reflect.rs index 7e01f162bb1..b9d23c47fcd 100644 --- a/src/librustc/middle/trans/reflect.rs +++ b/src/librustc/middle/trans/reflect.rs @@ -140,7 +140,6 @@ impl<'a> Reflector<'a> { } ty::vstore_slice(_) => (~"slice", ~[]), ty::vstore_uniq => (~"uniq", ~[]), - ty::vstore_box => (~"box", ~[]) } } diff --git a/src/librustc/middle/trans/tvec.rs b/src/librustc/middle/trans/tvec.rs index ea1e0f78f44..1043ce69ab4 100644 --- a/src/librustc/middle/trans/tvec.rs +++ b/src/librustc/middle/trans/tvec.rs @@ -44,9 +44,6 @@ pub fn expand_boxed_vec_ty(tcx: ty::ctxt, t: ty::t) -> ty::t { ty::ty_str(ty::vstore_uniq) | ty::ty_vec(_, ty::vstore_uniq) => { ty::mk_uniq(tcx, unboxed_vec_ty) } - ty::ty_str(ty::vstore_box) | ty::ty_vec(_, ty::vstore_box) => { - ty::mk_box(tcx, unboxed_vec_ty) - } _ => tcx.sess.bug("non boxed-vec type \ in tvec::expand_boxed_vec_ty") } @@ -65,21 +62,6 @@ pub fn get_alloc(bcx: &Block, vptr: ValueRef) -> ValueRef { Load(bcx, GEPi(bcx, vptr, [0u, abi::vec_elt_alloc])) } -pub fn get_bodyptr(bcx: &Block, vptr: ValueRef, t: ty::t) -> ValueRef { - let vt = vec_types(bcx, t); - - let managed = match ty::get(vt.vec_ty).sty { - ty::ty_str(ty::vstore_box) | ty::ty_vec(_, ty::vstore_box) => true, - _ => false - }; - - if managed { - GEPi(bcx, vptr, [0u, abi::box_field_body]) - } else { - vptr - } -} - pub fn get_dataptr(bcx: &Block, vptr: ValueRef) -> ValueRef { let _icx = push_ctxt("tvec::get_dataptr"); GEPi(bcx, vptr, [0u, abi::vec_elt_elems, 0u]) @@ -381,7 +363,7 @@ pub fn trans_uniq_or_managed_vstore<'a>(bcx: &'a Block<'a>, let temp_scope = fcx.push_custom_cleanup_scope(); fcx.schedule_free_value(cleanup::CustomScope(temp_scope), val, heap); - let dataptr = get_dataptr(bcx, get_bodyptr(bcx, val, vt.vec_ty)); + let dataptr = get_dataptr(bcx, val); debug!("alloc_vec() returned val={}, dataptr={}", bcx.val_to_str(val), bcx.val_to_str(dataptr)); @@ -570,10 +552,9 @@ pub fn get_base_and_byte_len(bcx: &Block, let len = Mul(bcx, count, vt.llunit_size); (base, len) } - ty::vstore_uniq | ty::vstore_box => { + ty::vstore_uniq => { assert!(type_is_immediate(bcx.ccx(), vt.vec_ty)); - let llval = Load(bcx, llval); - let body = get_bodyptr(bcx, llval, vec_ty); + let body = Load(bcx, llval); (get_dataptr(bcx, body), get_fill(bcx, body)) } } @@ -610,10 +591,9 @@ pub fn get_base_and_len(bcx: &Block, let count = Load(bcx, GEPi(bcx, llval, [0u, abi::slice_elt_len])); (base, count) } - ty::vstore_uniq | ty::vstore_box => { + ty::vstore_uniq => { assert!(type_is_immediate(bcx.ccx(), vt.vec_ty)); - let llval = Load(bcx, llval); - let body = get_bodyptr(bcx, llval, vec_ty); + let body = Load(bcx, llval); (get_dataptr(bcx, body), UDiv(bcx, get_fill(bcx, body), vt.llunit_size)) } } @@ -730,7 +710,7 @@ pub fn iter_vec_uniq<'r, f: iter_vec_block<'r,'b>) -> &'b Block<'b> { let _icx = push_ctxt("tvec::iter_vec_uniq"); - let data_ptr = get_dataptr(bcx, get_bodyptr(bcx, vptr, vec_ty)); + let data_ptr = get_dataptr(bcx, vptr); iter_vec_raw(bcx, data_ptr, vec_ty, fill, f) } diff --git a/src/librustc/middle/trans/type_of.rs b/src/librustc/middle/trans/type_of.rs index b440db66a12..0bc5ffd1019 100644 --- a/src/librustc/middle/trans/type_of.rs +++ b/src/librustc/middle/trans/type_of.rs @@ -115,9 +115,7 @@ pub fn sizing_type_of(cx: &CrateContext, t: ty::t) -> Type { ty::ty_float(t) => Type::float_from_ty(t), ty::ty_str(ty::vstore_uniq) | - ty::ty_str(ty::vstore_box) | ty::ty_vec(_, ty::vstore_uniq) | - ty::ty_vec(_, ty::vstore_box) | ty::ty_box(..) | ty::ty_uniq(..) | ty::ty_ptr(..) | @@ -221,13 +219,6 @@ pub fn type_of(cx: &CrateContext, t: ty::t) -> Type { let name = llvm_type_name(cx, an_enum, did, substs.tps); adt::incomplete_type_of(cx, repr, name) } - ty::ty_str(ty::vstore_box) => { - fail!("unexpected managed string") - } - ty::ty_vec(ref mt, ty::vstore_box) => { - let e_ty = type_of(cx, mt.ty); - Type::at_box(cx, Type::vec(cx.sess.targ_cfg.arch, &e_ty)).ptr_to() - } ty::ty_box(typ) => { Type::at_box(cx, type_of(cx, typ)).ptr_to() } diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index 6b42183d42b..7f27b1a0cfa 100644 --- a/src/librustc/middle/ty.rs +++ b/src/librustc/middle/ty.rs @@ -130,7 +130,6 @@ pub struct mt { pub enum vstore { vstore_fixed(uint), vstore_uniq, - vstore_box, vstore_slice(Region) } @@ -1558,7 +1557,7 @@ pub fn type_is_box(ty: t) -> bool { pub fn type_is_boxed(ty: t) -> bool { match get(ty).sty { - ty_box(_) | ty_vec(_, vstore_box) | ty_str(vstore_box) => true, + ty_box(_) => true, _ => false } } @@ -1682,10 +1681,7 @@ fn type_needs_unwind_cleanup_(cx: ctxt, ty: t, } ty_uniq(_) | ty_str(vstore_uniq) | - ty_str(vstore_box) | - ty_vec(_, vstore_uniq) | - ty_vec(_, vstore_box) - => { + ty_vec(_, vstore_uniq) => { // Once we're inside a box, the annihilator will find // it and destroy it. if !encountered_box { @@ -2028,10 +2024,6 @@ pub fn type_contents(cx: ctxt, ty: t) -> TypeContents { tc_mt(cx, mt, cache).owned_pointer() } - ty_vec(mt, vstore_box) => { - tc_mt(cx, mt, cache).managed_pointer() - } - ty_vec(ref mt, vstore_slice(r)) => { tc_ty(cx, mt.ty, cache).reference( borrowed_contents(r, mt.mutbl)) @@ -2041,10 +2033,6 @@ pub fn type_contents(cx: ctxt, ty: t) -> TypeContents { tc_mt(cx, mt, cache) } - ty_str(vstore_box) => { - TC::Managed - } - ty_str(vstore_slice(r)) => { borrowed_contents(r, ast::MutImmutable) } @@ -2530,8 +2518,8 @@ pub fn type_is_pod(cx: ctxt, ty: t) -> bool { ty_type | ty_ptr(_) | ty_bare_fn(_) => result = true, // Boxed types ty_box(_) | ty_uniq(_) | ty_closure(_) | - ty_str(vstore_uniq) | ty_str(vstore_box) | - ty_vec(_, vstore_uniq) | ty_vec(_, vstore_box) | + ty_str(vstore_uniq) | + ty_vec(_, vstore_uniq) | ty_trait(_, _, _, _, _) | ty_rptr(_,_) => result = false, // Structural types ty_enum(did, ref substs) => { @@ -4426,7 +4414,7 @@ pub fn normalize_ty(cx: ctxt, t: t) -> t { fn fold_vstore(&mut self, vstore: vstore) -> vstore { match vstore { - vstore_fixed(..) | vstore_uniq | vstore_box => vstore, + vstore_fixed(..) | vstore_uniq => vstore, vstore_slice(_) => vstore_slice(ReStatic) } } @@ -4863,7 +4851,6 @@ pub fn hash_crate_independent(tcx: ctxt, t: t, local_hash: ~str) -> u64 { match v { vstore_fixed(_) => hash.input([0]), vstore_uniq => hash.input([1]), - vstore_box => hash.input([2]), vstore_slice(r) => { hash.input([3]); region(hash, r); diff --git a/src/librustc/middle/ty_fold.rs b/src/librustc/middle/ty_fold.rs index e322792c996..63d6e2ae442 100644 --- a/src/librustc/middle/ty_fold.rs +++ b/src/librustc/middle/ty_fold.rs @@ -202,7 +202,6 @@ pub fn super_fold_vstore(this: &mut T, match vstore { ty::vstore_fixed(i) => ty::vstore_fixed(i), ty::vstore_uniq => ty::vstore_uniq, - ty::vstore_box => ty::vstore_box, ty::vstore_slice(r) => ty::vstore_slice(this.fold_region(r)), } } diff --git a/src/librustc/middle/typeck/astconv.rs b/src/librustc/middle/typeck/astconv.rs index 0cc646aa5c3..90abdc5ac50 100644 --- a/src/librustc/middle/typeck/astconv.rs +++ b/src/librustc/middle/typeck/astconv.rs @@ -384,6 +384,23 @@ pub fn ast_ty_to_ty( ty::mt {ty: ast_ty_to_ty(this, rscope, mt.ty), mutbl: mt.mutbl} } + enum PointerTy { + Box, + VStore(ty::vstore) + } + impl PointerTy { + fn expect_vstore(&self, tcx: ty::ctxt, span: Span, ty: &str) -> ty::vstore { + match *self { + Box => { + tcx.sess.span_err(span, format!("managed {} are not supported", ty)); + // everything can be ~, so this is a worth substitute + ty::vstore_uniq + } + VStore(vst) => vst + } + } + } + // Handle @, ~, and & being able to mean strs and vecs. // If a_seq_ty is a str or a vec, make it a str/vec. // Also handle first-class trait types. @@ -392,17 +409,18 @@ pub fn ast_ty_to_ty( this: &AC, rscope: &RS, a_seq_ty: &ast::MutTy, - vst: ty::vstore, + ptr_ty: PointerTy, constr: |ty::mt| -> ty::t) -> ty::t { let tcx = this.tcx(); - debug!("mk_pointer(vst={:?})", vst); + debug!("mk_pointer(ptr_ty={:?})", ptr_ty); match a_seq_ty.ty.node { ast::TyVec(ty) => { + let vst = ptr_ty.expect_vstore(tcx, a_seq_ty.ty.span, "vectors"); let mut mt = ast_ty_to_mt(this, rscope, ty); if a_seq_ty.mutbl == ast::MutMutable { - mt = ty::mt { ty: mt.ty, mutbl: a_seq_ty.mutbl }; + mt.mutbl = ast::MutMutable; } debug!("&[]: vst={:?}", vst); return ty::mk_vec(tcx, mt, vst); @@ -416,26 +434,19 @@ pub fn ast_ty_to_ty( Some(&ast::DefPrimTy(ast::TyStr)) if a_seq_ty.mutbl == ast::MutImmutable => { check_path_args(tcx, path, NO_TPS | NO_REGIONS); - match vst { - ty::vstore_box => { - tcx.sess.span_err(path.span, - "managed strings are not \ - supported") - } - _ => {} - } + let vst = ptr_ty.expect_vstore(tcx, path.span, "strings"); return ty::mk_str(tcx, vst); } Some(&ast::DefTrait(trait_def_id)) => { let result = ast_path_to_trait_ref( this, rscope, trait_def_id, None, path); - let trait_store = match vst { - ty::vstore_box => ty::BoxTraitStore, - ty::vstore_uniq => ty::UniqTraitStore, - ty::vstore_slice(r) => { + let trait_store = match ptr_ty { + Box => ty::BoxTraitStore, + VStore(ty::vstore_uniq) => ty::UniqTraitStore, + VStore(ty::vstore_slice(r)) => { ty::RegionTraitStore(r) } - ty::vstore_fixed(..) => { + VStore(ty::vstore_fixed(..)) => { tcx.sess.span_err( path.span, "@trait, ~trait or &trait are the only supported \ @@ -483,12 +494,11 @@ pub fn ast_ty_to_ty( ast::TyBot => ty::mk_bot(), ast::TyBox(ty) => { let mt = ast::MutTy { ty: ty, mutbl: ast::MutImmutable }; - mk_pointer(this, rscope, &mt, ty::vstore_box, - |tmt| ty::mk_box(tcx, tmt.ty)) + mk_pointer(this, rscope, &mt, Box, |tmt| ty::mk_box(tcx, tmt.ty)) } ast::TyUniq(ty) => { let mt = ast::MutTy { ty: ty, mutbl: ast::MutImmutable }; - mk_pointer(this, rscope, &mt, ty::vstore_uniq, + mk_pointer(this, rscope, &mt, VStore(ty::vstore_uniq), |tmt| ty::mk_uniq(tcx, tmt.ty)) } ast::TyVec(ty) => { @@ -502,7 +512,7 @@ pub fn ast_ty_to_ty( ast::TyRptr(ref region, ref mt) => { let r = opt_ast_region_to_region(this, rscope, ast_ty.span, region); debug!("ty_rptr r={}", r.repr(this.tcx())); - mk_pointer(this, rscope, mt, ty::vstore_slice(r), + mk_pointer(this, rscope, mt, VStore(ty::vstore_slice(r)), |tmt| ty::mk_rptr(tcx, r, tmt)) } ast::TyTup(ref fields) => { diff --git a/src/librustc/middle/typeck/check/_match.rs b/src/librustc/middle/typeck/check/_match.rs index e57e3ff4712..97b07186f4e 100644 --- a/src/librustc/middle/typeck/check/_match.rs +++ b/src/librustc/middle/typeck/check/_match.rs @@ -604,7 +604,7 @@ pub fn check_pat(pcx: &pat_ctxt, pat: &ast::Pat, expected: ty::t) { ty::ty_vec(mt, vstore) => { let region_var = match vstore { ty::vstore_slice(r) => r, - ty::vstore_box | ty::vstore_uniq | ty::vstore_fixed(_) => { + ty::vstore_uniq | ty::vstore_fixed(_) => { default_region_var } }; diff --git a/src/librustc/middle/typeck/check/method.rs b/src/librustc/middle/typeck/check/method.rs index e7e4f61741f..d32d51c251a 100644 --- a/src/librustc/middle/typeck/check/method.rs +++ b/src/librustc/middle/typeck/check/method.rs @@ -699,7 +699,6 @@ impl<'a> LookupContext<'a> { let tcx = self.tcx(); let sty = ty::get(self_ty).sty.clone(); match sty { - ty_vec(mt, vstore_box) | ty_vec(mt, vstore_uniq) | ty_vec(mt, vstore_slice(_)) | // NDM(#3148) ty_vec(mt, vstore_fixed(_)) => { @@ -728,7 +727,6 @@ impl<'a> LookupContext<'a> { }) } - ty_str(vstore_box) | ty_str(vstore_uniq) | ty_str(vstore_fixed(_)) => { let entry = self.search_for_some_kind_of_autorefd_method( diff --git a/src/librustc/middle/typeck/check/regionck.rs b/src/librustc/middle/typeck/check/regionck.rs index f134fb3b6ae..6d46cd38087 100644 --- a/src/librustc/middle/typeck/check/regionck.rs +++ b/src/librustc/middle/typeck/check/regionck.rs @@ -1215,9 +1215,7 @@ pub mod guarantor { } ty::ty_box(..) | ty::ty_ptr(..) | - ty::ty_vec(_, ty::vstore_box) | - ty::ty_trait(_, _, ty::BoxTraitStore, _, _) | - ty::ty_str(ty::vstore_box) => { + ty::ty_trait(_, _, ty::BoxTraitStore, _, _) => { OtherPointer } ty::ty_closure(ref closure_ty) => { @@ -1301,7 +1299,6 @@ pub mod guarantor { let guarantor1 = match vstore { ty::vstore_fixed(_) | ty::vstore_uniq => guarantor, ty::vstore_slice(r) => Some(r), - ty::vstore_box => None }; link_ref_bindings_in_pats(rcx, before, guarantor1); diff --git a/src/librustc/middle/typeck/infer/coercion.rs b/src/librustc/middle/typeck/infer/coercion.rs index 6a4de959c2b..adf36cf973b 100644 --- a/src/librustc/middle/typeck/infer/coercion.rs +++ b/src/librustc/middle/typeck/infer/coercion.rs @@ -67,7 +67,7 @@ we may want to adjust precisely when coercions occur. use middle::ty::{AutoPtr, AutoBorrowVec, AutoBorrowFn, AutoBorrowObj}; use middle::ty::{AutoDerefRef}; -use middle::ty::{vstore_slice, vstore_box, vstore_uniq}; +use middle::ty::{vstore_slice, vstore_uniq}; use middle::ty::{mt}; use middle::ty; use middle::typeck::infer::{CoerceResult, resolve_type, Coercion}; @@ -272,7 +272,6 @@ impl Coerce { b.inf_str(self.get_ref().infcx)); match *sty_a { - ty::ty_str(vstore_box) | ty::ty_str(vstore_uniq) => {} _ => { return self.subtype(a, b); diff --git a/src/librustc/middle/typeck/variance.rs b/src/librustc/middle/typeck/variance.rs index cd4abd70ecd..51364addfed 100644 --- a/src/librustc/middle/typeck/variance.rs +++ b/src/librustc/middle/typeck/variance.rs @@ -736,7 +736,7 @@ impl<'a> ConstraintContext<'a> { self.add_constraints_from_region(r, contra); } - ty::vstore_fixed(_) | ty::vstore_uniq | ty::vstore_box => { + ty::vstore_fixed(_) | ty::vstore_uniq => { } } } diff --git a/src/librustc/util/ppaux.rs b/src/librustc/util/ppaux.rs index 27d15d73825..eba99c7fb5a 100644 --- a/src/librustc/util/ppaux.rs +++ b/src/librustc/util/ppaux.rs @@ -260,7 +260,6 @@ pub fn vstore_to_str(cx: ctxt, vs: ty::vstore) -> ~str { match vs { ty::vstore_fixed(n) => format!("{}", n), ty::vstore_uniq => ~"~", - ty::vstore_box => ~"@", ty::vstore_slice(r) => region_ptr_to_str(cx, r) } } diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index aa33edf28f5..8a3da581607 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -2825,7 +2825,7 @@ impl Parser { let hi = self.last_span.hi; return @ast::Pat { id: ast::DUMMY_NODE_ID, - node: sub, + node: PatUniq(sub), span: mk_sp(lo, hi) } } -- cgit 1.4.1-3-g733a5 From 212507413a2768ec4b6a072dde73d60527c2beee Mon Sep 17 00:00:00 2001 From: Huon Wilson Date: Sun, 2 Feb 2014 02:53:54 +1100 Subject: rustc: update docs & propagate @[]/@str removal more. Various functions can now be made specific to ~[], or just non-managed vectors. --- doc/rust.md | 2 +- src/librustc/middle/borrowck/mod.rs | 10 ---- src/librustc/middle/trans/_match.rs | 7 +-- src/librustc/middle/trans/base.rs | 2 +- src/librustc/middle/trans/controlflow.rs | 2 +- src/librustc/middle/trans/datum.rs | 45 +---------------- src/librustc/middle/trans/expr.rs | 19 +++----- src/librustc/middle/trans/tvec.rs | 83 ++++++++++++++------------------ src/librustc/middle/trans/write_guard.rs | 9 ++-- src/librustc/middle/ty.rs | 4 +- src/libsyntax/parse/parser.rs | 2 +- 11 files changed, 57 insertions(+), 128 deletions(-) (limited to 'src/libsyntax/parse') diff --git a/doc/rust.md b/doc/rust.md index 7a9d5d26b57..0b817539b29 100644 --- a/doc/rust.md +++ b/doc/rust.md @@ -3115,7 +3115,7 @@ Such a definite-sized vector type is a first-class type, since its size is known A vector without such a size is said to be of _indefinite_ size, and is therefore not a _first-class_ type. An indefinite-size vector can only be instantiated through a pointer type, -such as `&[T]`, `@[T]` or `~[T]`. +such as `&[T]` or `~[T]`. The kind of a vector type depends on the kind of its element type, as with other simple structural types. diff --git a/src/librustc/middle/borrowck/mod.rs b/src/librustc/middle/borrowck/mod.rs index 68e205ebb6e..8f6d4de476b 100644 --- a/src/librustc/middle/borrowck/mod.rs +++ b/src/librustc/middle/borrowck/mod.rs @@ -194,16 +194,6 @@ pub struct BorrowStats { // // Note that there is no entry with derefs:3---the type of that expression // is T, which is not a box. -// -// Note that implicit dereferences also occur with indexing of `@[]`, -// `@str`, etc. The same rules apply. So, for example, given a -// variable `x` of type `@[@[...]]`, if I have an instance of the -// expression `x[0]` which is then auto-slice'd, there would be two -// potential entries in the root map, both with the id of the `x[0]` -// expression. The entry with `derefs==0` refers to the deref of `x` -// used as part of evaluating `x[0]`. The entry with `derefs==1` -// refers to the deref of the `x[0]` that occurs as part of the -// auto-slice. #[deriving(Eq, IterBytes)] pub struct root_map_key { id: ast::NodeId, diff --git a/src/librustc/middle/trans/_match.rs b/src/librustc/middle/trans/_match.rs index 12183632948..135b16b22ab 100644 --- a/src/librustc/middle/trans/_match.rs +++ b/src/librustc/middle/trans/_match.rs @@ -1032,7 +1032,6 @@ fn match_datum(bcx: &Block, fn extract_vec_elems<'a>( bcx: &'a Block<'a>, - pat_span: Span, pat_id: ast::NodeId, elem_count: uint, slice: Option, @@ -1041,7 +1040,7 @@ fn extract_vec_elems<'a>( -> ExtractedBlock<'a> { let _icx = push_ctxt("match::extract_vec_elems"); let vec_datum = match_datum(bcx, val, pat_id); - let (bcx, base, len) = vec_datum.get_vec_base_and_len(bcx, pat_span, pat_id, 0); + let (base, len) = vec_datum.get_vec_base_and_len(bcx); let vt = tvec::vec_types(bcx, node_id_type(bcx, pat_id)); let mut elems = vec::from_fn(elem_count, |i| { @@ -1512,13 +1511,11 @@ fn compile_submatch_continue<'r, vals.slice(col + 1u, vals.len())); let ccx = bcx.fcx.ccx; let mut pat_id = 0; - let mut pat_span = DUMMY_SP; for br in m.iter() { // Find a real id (we're adding placeholder wildcard patterns, but // each column is guaranteed to have at least one real pattern) if pat_id == 0 { pat_id = br.pats[col].id; - pat_span = br.pats[col].span; } } @@ -1767,7 +1764,7 @@ fn compile_submatch_continue<'r, vec_len_ge(i) => (n + 1u, Some(i)), vec_len_eq => (n, None) }; - let args = extract_vec_elems(opt_cx, pat_span, pat_id, n, + let args = extract_vec_elems(opt_cx, pat_id, n, slice, val, test_val); size = args.vals.len(); unpacked = args.vals.clone(); diff --git a/src/librustc/middle/trans/base.rs b/src/librustc/middle/trans/base.rs index c74f201091d..7bd2653f869 100644 --- a/src/librustc/middle/trans/base.rs +++ b/src/librustc/middle/trans/base.rs @@ -360,7 +360,7 @@ pub fn malloc_raw_dyn<'a>( None); rslt(r.bcx, PointerCast(r.bcx, r.val, llty_value.ptr_to())) } else { - // we treat ~fn, @fn and @[] as @ here, which isn't ideal + // we treat ~fn as @ here, which isn't ideal let langcall = match heap { heap_managed => { require_alloc_fn(bcx, t, MallocFnLangItem) diff --git a/src/librustc/middle/trans/controlflow.rs b/src/librustc/middle/trans/controlflow.rs index 6de34d98941..d361c36fbda 100644 --- a/src/librustc/middle/trans/controlflow.rs +++ b/src/librustc/middle/trans/controlflow.rs @@ -334,7 +334,7 @@ pub fn trans_fail_expr<'a>( unpack_datum!(bcx, expr::trans_to_lvalue(bcx, arg_expr, "fail")); if ty::type_is_str(arg_datum.ty) { - let (lldata, _) = arg_datum.get_vec_base_and_len_no_root(bcx); + let (lldata, _) = arg_datum.get_vec_base_and_len(bcx); return trans_fail_value(bcx, sp_opt, lldata); } else if bcx.unreachable.get() || ty::type_is_bot(arg_datum.ty) { return bcx; diff --git a/src/librustc/middle/trans/datum.rs b/src/librustc/middle/trans/datum.rs index 4888c2ce4d5..2a2421077a8 100644 --- a/src/librustc/middle/trans/datum.rs +++ b/src/librustc/middle/trans/datum.rs @@ -528,49 +528,8 @@ impl Datum { } } - pub fn get_vec_base_and_byte_len<'a>( - &self, - mut bcx: &'a Block<'a>, - span: Span, - expr_id: ast::NodeId, - derefs: uint) - -> (&'a Block<'a>, ValueRef, ValueRef) { - //! Converts a vector into the slice pair. Performs rooting - //! and write guards checks. - - // only imp't for @[] and @str, but harmless - bcx = write_guard::root_and_write_guard(self, bcx, span, expr_id, derefs); - let (base, len) = self.get_vec_base_and_byte_len_no_root(bcx); - (bcx, base, len) - } - - pub fn get_vec_base_and_byte_len_no_root(&self, bcx: &Block) - -> (ValueRef, ValueRef) { - //! Converts a vector into the slice pair. Des not root - //! nor perform write guard checks. - - tvec::get_base_and_byte_len(bcx, self.val, self.ty) - } - - pub fn get_vec_base_and_len<'a>(&self, - mut bcx: &'a Block<'a>, - span: Span, - expr_id: ast::NodeId, - derefs: uint) - -> (&'a Block<'a>, ValueRef, ValueRef) { - //! Converts a vector into the slice pair. Performs rooting - //! and write guards checks. - - // only imp't for @[] and @str, but harmless - bcx = write_guard::root_and_write_guard(self, bcx, span, expr_id, derefs); - let (base, len) = self.get_vec_base_and_len_no_root(bcx); - (bcx, base, len) - } - - pub fn get_vec_base_and_len_no_root<'a>(&self, bcx: &'a Block<'a>) - -> (ValueRef, ValueRef) { - //! Converts a vector into the slice pair. Des not root - //! nor perform write guard checks. + pub fn get_vec_base_and_len<'a>(&self, bcx: &'a Block<'a>) -> (ValueRef, ValueRef) { + //! Converts a vector into the slice pair. tvec::get_base_and_len(bcx, self.val, self.ty) } diff --git a/src/librustc/middle/trans/expr.rs b/src/librustc/middle/trans/expr.rs index da5fa8385e9..517f9e1a31d 100644 --- a/src/librustc/middle/trans/expr.rs +++ b/src/librustc/middle/trans/expr.rs @@ -202,12 +202,10 @@ fn apply_adjustments<'a>(bcx: &'a Block<'a>, unpack_datum!(bcx, auto_ref(bcx, datum, expr)) } Some(AutoBorrowVec(..)) => { - unpack_datum!(bcx, auto_slice(bcx, adj.autoderefs, - expr, datum)) + unpack_datum!(bcx, auto_slice(bcx, expr, datum)) } Some(AutoBorrowVecRef(..)) => { - unpack_datum!(bcx, auto_slice_and_ref(bcx, adj.autoderefs, - expr, datum)) + unpack_datum!(bcx, auto_slice_and_ref(bcx, expr, datum)) } Some(AutoBorrowFn(..)) => { let adjusted_ty = ty::adjust_ty(bcx.tcx(), expr.span, @@ -271,7 +269,6 @@ fn apply_adjustments<'a>(bcx: &'a Block<'a>, fn auto_slice<'a>( bcx: &'a Block<'a>, - autoderefs: uint, expr: &ast::Expr, datum: Datum) -> DatumBlock<'a, Expr> { @@ -290,8 +287,7 @@ fn apply_adjustments<'a>(bcx: &'a Block<'a>, let datum = unpack_datum!( bcx, datum.to_lvalue_datum(bcx, "auto_slice", expr.id)); - let (bcx, base, len) = - datum.get_vec_base_and_len(bcx, expr.span, expr.id, autoderefs+1); + let (base, len) = datum.get_vec_base_and_len(bcx); // this type may have a different region/mutability than the // real one, but it will have the same runtime representation @@ -323,11 +319,10 @@ fn apply_adjustments<'a>(bcx: &'a Block<'a>, fn auto_slice_and_ref<'a>( bcx: &'a Block<'a>, - autoderefs: uint, expr: &ast::Expr, datum: Datum) -> DatumBlock<'a, Expr> { - let DatumBlock { bcx, datum } = auto_slice(bcx, autoderefs, expr, datum); + let DatumBlock { bcx, datum } = auto_slice(bcx, expr, datum); auto_ref(bcx, datum, expr) } @@ -522,8 +517,7 @@ fn trans_datum_unadjusted<'a>(bcx: &'a Block<'a>, ast::ExprVstore(contents, ast::ExprVstoreUniq) => { fcx.push_ast_cleanup_scope(contents.id); let datum = unpack_datum!( - bcx, tvec::trans_uniq_or_managed_vstore(bcx, heap_exchange, - expr, contents)); + bcx, tvec::trans_uniq_vstore(bcx, expr, contents)); bcx = fcx.pop_and_trans_ast_cleanup_scope(bcx, contents.id); DatumBlock(bcx, datum) } @@ -626,8 +620,7 @@ fn trans_index<'a>(bcx: &'a Block<'a>, let vt = tvec::vec_types(bcx, base_datum.ty); base::maybe_name_value(bcx.ccx(), vt.llunit_size, "unit_sz"); - let (bcx, base, len) = - base_datum.get_vec_base_and_len(bcx, index_expr.span, index_expr.id, 0); + let (base, len) = base_datum.get_vec_base_and_len(bcx); debug!("trans_index: base {}", bcx.val_to_str(base)); debug!("trans_index: len {}", bcx.val_to_str(len)); diff --git a/src/librustc/middle/trans/tvec.rs b/src/librustc/middle/trans/tvec.rs index 1043ce69ab4..a0a1ff20a9a 100644 --- a/src/librustc/middle/trans/tvec.rs +++ b/src/librustc/middle/trans/tvec.rs @@ -110,11 +110,10 @@ pub fn alloc_uniq_raw<'a>( alloc_raw(bcx, unit_ty, fill, alloc, heap_exchange) } -pub fn alloc_vec<'a>( +pub fn alloc_uniq_vec<'a>( bcx: &'a Block<'a>, unit_ty: ty::t, - elts: uint, - heap: heap) + elts: uint) -> Result<'a> { let _icx = push_ctxt("tvec::alloc_uniq"); let ccx = bcx.ccx(); @@ -125,7 +124,7 @@ pub fn alloc_vec<'a>( let alloc = if elts < 4u { Mul(bcx, C_int(ccx, 4), unit_sz) } else { fill }; let Result {bcx: bcx, val: vptr} = - alloc_raw(bcx, unit_ty, fill, alloc, heap); + alloc_raw(bcx, unit_ty, fill, alloc, heap_exchange); return rslt(bcx, vptr); } @@ -302,70 +301,62 @@ pub fn trans_lit_str<'a>( } -pub fn trans_uniq_or_managed_vstore<'a>(bcx: &'a Block<'a>, - heap: heap, - vstore_expr: &ast::Expr, - content_expr: &ast::Expr) - -> DatumBlock<'a, Expr> { +pub fn trans_uniq_vstore<'a>(bcx: &'a Block<'a>, + vstore_expr: &ast::Expr, + content_expr: &ast::Expr) + -> DatumBlock<'a, Expr> { /*! - * @[...] or ~[...] (also @"..." or ~"...") allocate boxes in the - * appropriate heap and write the array elements into them. + * ~[...] and ~"..." allocate boxes in the exchange heap and write + * the array elements into them. */ - debug!("trans_uniq_or_managed_vstore(vstore_expr={}, heap={:?})", - bcx.expr_to_str(vstore_expr), heap); + debug!("trans_uniq_vstore(vstore_expr={})", bcx.expr_to_str(vstore_expr)); let fcx = bcx.fcx; // Handle ~"". - match heap { - heap_exchange => { - match content_expr.node { - ast::ExprLit(lit) => { - match lit.node { - ast::LitStr(ref s, _) => { - let llptrval = C_cstr(bcx.ccx(), (*s).clone()); - let llptrval = PointerCast(bcx, - llptrval, - Type::i8p()); - let llsizeval = C_uint(bcx.ccx(), s.get().len()); - let typ = ty::mk_str(bcx.tcx(), ty::vstore_uniq); - let lldestval = rvalue_scratch_datum(bcx, - typ, - ""); - let alloc_fn = langcall(bcx, - Some(lit.span), - "", - StrDupUniqFnLangItem); - let bcx = callee::trans_lang_call( - bcx, - alloc_fn, - [ llptrval, llsizeval ], - Some(expr::SaveIn(lldestval.val))).bcx; - return DatumBlock(bcx, lldestval).to_expr_datumblock(); - } - _ => {} - } + match content_expr.node { + ast::ExprLit(lit) => { + match lit.node { + ast::LitStr(ref s, _) => { + let llptrval = C_cstr(bcx.ccx(), (*s).clone()); + let llptrval = PointerCast(bcx, + llptrval, + Type::i8p()); + let llsizeval = C_uint(bcx.ccx(), s.get().len()); + let typ = ty::mk_str(bcx.tcx(), ty::vstore_uniq); + let lldestval = rvalue_scratch_datum(bcx, + typ, + ""); + let alloc_fn = langcall(bcx, + Some(lit.span), + "", + StrDupUniqFnLangItem); + let bcx = callee::trans_lang_call( + bcx, + alloc_fn, + [ llptrval, llsizeval ], + Some(expr::SaveIn(lldestval.val))).bcx; + return DatumBlock(bcx, lldestval).to_expr_datumblock(); } _ => {} } } - heap_exchange_closure => fail!("vectors use exchange_alloc"), - heap_managed => {} + _ => {} } let vt = vec_types_from_expr(bcx, vstore_expr); let count = elements_required(bcx, content_expr); - let Result {bcx, val} = alloc_vec(bcx, vt.unit_ty, count, heap); + let Result {bcx, val} = alloc_uniq_vec(bcx, vt.unit_ty, count); // Create a temporary scope lest execution should fail while // constructing the vector. let temp_scope = fcx.push_custom_cleanup_scope(); - fcx.schedule_free_value(cleanup::CustomScope(temp_scope), val, heap); + fcx.schedule_free_value(cleanup::CustomScope(temp_scope), val, heap_exchange); let dataptr = get_dataptr(bcx, val); - debug!("alloc_vec() returned val={}, dataptr={}", + debug!("alloc_uniq_vec() returned val={}, dataptr={}", bcx.val_to_str(val), bcx.val_to_str(dataptr)); let bcx = write_content(bcx, &vt, vstore_expr, diff --git a/src/librustc/middle/trans/write_guard.rs b/src/librustc/middle/trans/write_guard.rs index 5b310feb58d..0f4b11bde70 100644 --- a/src/librustc/middle/trans/write_guard.rs +++ b/src/librustc/middle/trans/write_guard.rs @@ -46,10 +46,10 @@ fn root<'a, K:KindOps>(datum: &Datum, _span: Span, root_key: root_map_key, root_info: RootInfo) -> &'a Block<'a> { - //! In some cases, borrowck will decide that an @T/@[]/@str - //! value must be rooted for the program to be safe. In that - //! case, we will call this function, which will stash a copy - //! away until we exit the scope `scope_id`. + //! In some cases, borrowck will decide that an @T value must be + //! rooted for the program to be safe. In that case, we will call + //! this function, which will stash a copy away until we exit the + //! scope `scope_id`. debug!("write_guard::root(root_key={:?}, root_info={:?}, datum={:?})", root_key, root_info, datum.to_str(bcx.ccx())); @@ -62,4 +62,3 @@ fn root<'a, K:KindOps>(datum: &Datum, cleanup::AstScope(root_info.scope), (), |(), bcx, llval| datum.shallow_copy_and_take(bcx, llval)).bcx } - diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index 7f27b1a0cfa..003a10eb482 100644 --- a/src/librustc/middle/ty.rs +++ b/src/librustc/middle/ty.rs @@ -226,10 +226,10 @@ pub enum AutoRef { /// Convert from T to &T AutoPtr(Region, ast::Mutability), - /// Convert from @[]/~[]/&[] to &[] (or str) + /// Convert from ~[]/&[] to &[] (or str) AutoBorrowVec(Region, ast::Mutability), - /// Convert from @[]/~[]/&[] to &&[] (or str) + /// Convert from ~[]/&[] to &&[] (or str) AutoBorrowVecRef(Region, ast::Mutability), /// Convert from @fn()/~fn()/|| to || diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 8a3da581607..dd7cc3a2314 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -1291,7 +1291,7 @@ impl Parser { } // other things are parsed as @/~ + a type. Note that constructs like - // @[] and @str will be resolved during typeck to slices and so forth, + // ~[] and ~str will be resolved during typeck to slices and so forth, // rather than boxed ptrs. But the special casing of str/vec is not // reflected in the AST type. if sigil == OwnedSigil { -- cgit 1.4.1-3-g733a5