bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

libsyntax: add some more explicit copies

Browse source
This commit is contained in:
Erick Tryzelaar 2013-02-26 20:18:01 -08:00
parent da7aedc230
commit ea36a0dee1
6 changed files with 160 additions and 91 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/libsyntax/ext/deriving.rs
View file

@ -838,7 +838,7 @@ fn expand_deriving_eq_struct_tuple_method(cx: ext_ctxt,
let self_str = ~"self";
let other_str = ~"__other";
let type_path = build::mk_raw_path(span, ~[type_ident]);
let fields = struct_def.fields;
let fields = copy struct_def.fields;
// Create comparison expression, comparing each of the fields
let mut match_body = None;

6
src/libsyntax/ext/trace_macros.rs
View file

@ -29,7 +29,11 @@ pub fn expand_trace_macros(cx: ext_ctxt, sp: span,
vec::from_slice(tt)
);
let rdr = tt_rdr as reader;
let rust_parser = Parser(sess, cfg, rdr.dup());
let rust_parser = Parser(
sess,
copy cfg,
rdr.dup()
);
if rust_parser.is_keyword(&~"true") {
cx.set_trace_macros(true);

21
src/libsyntax/ext/tt/macro_parser.rs
View file

@ -224,8 +224,12 @@ pub enum parse_result {
error(codemap::span, ~str)
}
pub fn parse_or_else(sess: @mut ParseSess, cfg: ast::crate_cfg, rdr: reader,
ms: ~[matcher]) -> HashMap<ident, @named_match> {
pub fn parse_or_else(
sess: @mut ParseSess,
+cfg: ast::crate_cfg,
rdr: reader,
ms: ~[matcher]
) -> HashMap<ident, @named_match> {
match parse(sess, cfg, rdr, ms) {
success(m) => m,
failure(sp, ref str) => sess.span_diagnostic.span_fatal(sp, (*str)),
@ -233,11 +237,12 @@ pub fn parse_or_else(sess: @mut ParseSess, cfg: ast::crate_cfg, rdr: reader,
}
}
pub fn parse(sess: @mut ParseSess,
cfg: ast::crate_cfg,
rdr: reader,
ms: ~[matcher])
-> parse_result {
pub fn parse(
sess: @mut ParseSess,
cfg: ast::crate_cfg,
rdr: reader,
ms: ~[matcher]
) -> parse_result {
let mut cur_eis = ~[];
cur_eis.push(initial_matcher_pos(copy ms, None, rdr.peek().sp.lo));
@ -387,7 +392,7 @@ pub fn parse(sess: @mut ParseSess,
}
rdr.next_token();
} else /* bb_eis.len() == 1 */ {
let rust_parser = Parser(sess, cfg, rdr.dup());
let rust_parser = Parser(sess, copy cfg, rdr.dup());
let mut ei = bb_eis.pop();
match ei.elts[ei.idx].node {

4
src/libsyntax/ext/tt/transcribe.rs
View file

@ -202,9 +202,9 @@ pub fn tt_next_token(r: @mut TtReader) -> TokenAndSpan {
loop { /* because it's easiest, this handles `tt_delim` not starting
with a `tt_tok`, even though it won't happen */
match r.cur.readme[r.cur.idx] {
tt_delim(tts) => {
tt_delim(copy tts) => {
r.cur = @mut TtFrame {
readme: @mut copy tts,
readme: @mut tts,
idx: 0u,
dotdotdoted: false,
sep: None,

216
src/libsyntax/parse/mod.rs
View file

@ -81,78 +81,116 @@ pub fn new_parse_sess_special_handler(sh: span_handler, cm: @codemap::CodeMap)
// this appears to be the main entry point for rust parsing by
// rustc and crate:
pub fn parse_crate_from_file(input: &Path, cfg: ast::crate_cfg,
sess: @mut ParseSess) -> @ast::crate {
let p = new_parser_from_file(sess, cfg, input);
p.parse_crate_mod(cfg)
pub fn parse_crate_from_file(
input: &Path,
cfg: ast::crate_cfg,
sess: @mut ParseSess
) -> @ast::crate {
let p = new_parser_from_file(sess, /*bad*/ copy cfg, input);
p.parse_crate_mod(/*bad*/ copy cfg)
// why is there no p.abort_if_errors here?
}
pub fn parse_crate_from_source_str(name: ~str,
source: @~str,
cfg: ast::crate_cfg,
sess: @mut ParseSess) -> @ast::crate {
let p = new_parser_from_source_str(sess, cfg, /*bad*/ copy name,
codemap::FssNone, source);
let r = p.parse_crate_mod(cfg);
pub fn parse_crate_from_source_str(
name: ~str,
source: @~str,
cfg: ast::crate_cfg,
sess: @mut ParseSess
) -> @ast::crate {
let p = new_parser_from_source_str(
sess,
/*bad*/ copy cfg,
/*bad*/ copy name,
codemap::FssNone,
source
);
let r = p.parse_crate_mod(/*bad*/ copy cfg);
p.abort_if_errors();
return r;
r
}
pub fn parse_expr_from_source_str(name: ~str,
source: @~str,
cfg: ast::crate_cfg,
sess: @mut ParseSess) -> @ast::expr {
let p = new_parser_from_source_str(sess, cfg, /*bad*/ copy name,
codemap::FssNone, source);
pub fn parse_expr_from_source_str(
name: ~str,
source: @~str,
+cfg: ast::crate_cfg,
sess: @mut ParseSess
) -> @ast::expr {
let p = new_parser_from_source_str(
sess,
cfg,
/*bad*/ copy name,
codemap::FssNone,
source
);
let r = p.parse_expr();
p.abort_if_errors();
return r;
r
}
pub fn parse_item_from_source_str(name: ~str,
source: @~str,
cfg: ast::crate_cfg,
+attrs: ~[ast::attribute],
sess: @mut ParseSess)
-> Option<@ast::item> {
let p = new_parser_from_source_str(sess, cfg, /*bad*/ copy name,
codemap::FssNone, source);
pub fn parse_item_from_source_str(
name: ~str,
source: @~str,
+cfg: ast::crate_cfg,
+attrs: ~[ast::attribute],
sess: @mut ParseSess
) -> Option<@ast::item> {
let p = new_parser_from_source_str(
sess,
cfg,
/*bad*/ copy name,
codemap::FssNone,
source
);
let r = p.parse_item(attrs);
p.abort_if_errors();
return r;
r
}
pub fn parse_stmt_from_source_str(name: ~str,
source: @~str,
cfg: ast::crate_cfg,
+attrs: ~[ast::attribute],
sess: @mut ParseSess) -> @ast::stmt {
let p = new_parser_from_source_str(sess, cfg, /*bad*/ copy name,
codemap::FssNone, source);
pub fn parse_stmt_from_source_str(
name: ~str,
source: @~str,
+cfg: ast::crate_cfg,
+attrs: ~[ast::attribute],
sess: @mut ParseSess
) -> @ast::stmt {
let p = new_parser_from_source_str(
sess,
cfg,
/*bad*/ copy name,
codemap::FssNone,
source
);
let r = p.parse_stmt(attrs);
p.abort_if_errors();
return r;
r
}
pub fn parse_tts_from_source_str(name: ~str,
source: @~str,
cfg: ast::crate_cfg,
sess: @mut ParseSess) -> ~[ast::token_tree] {
let p = new_parser_from_source_str(sess, cfg, /*bad*/ copy name,
codemap::FssNone, source);
pub fn parse_tts_from_source_str(
name: ~str,
source: @~str,
+cfg: ast::crate_cfg,
sess: @mut ParseSess
) -> ~[ast::token_tree] {
let p = new_parser_from_source_str(
sess,
cfg,
/*bad*/ copy name,
codemap::FssNone,
source
);
*p.quote_depth += 1u;
let r = p.parse_all_token_trees();
p.abort_if_errors();
return r;
r
}
pub fn parse_from_source_str<T>(f: fn (p: Parser) -> T,
name: ~str, ss: codemap::FileSubstr,
source: @~str, cfg: ast::crate_cfg,
sess: @mut ParseSess)
-> T
{
pub fn parse_from_source_str<T>(
f: fn (Parser) -> T,
name: ~str, ss: codemap::FileSubstr,
source: @~str,
+cfg: ast::crate_cfg,
sess: @mut ParseSess
) -> T {
let p = new_parser_from_source_str(
sess,
cfg,
@ -176,40 +214,51 @@ pub fn next_node_id(sess: @mut ParseSess) -> node_id {
return rv;
}
pub fn new_parser_from_source_str(sess: @mut ParseSess, cfg: ast::crate_cfg,
+name: ~str, +ss: codemap::FileSubstr,
source: @~str) -> Parser {
pub fn new_parser_from_source_str(
sess: @mut ParseSess,
+cfg: ast::crate_cfg,
+name: ~str,
+ss: codemap::FileSubstr,
source: @~str
) -> Parser {
let filemap = sess.cm.new_filemap_w_substr(name, ss, source);
let srdr = lexer::new_string_reader(copy sess.span_diagnostic,
filemap,
sess.interner);
return Parser(sess, cfg, srdr as reader);
let srdr = lexer::new_string_reader(
copy sess.span_diagnostic,
filemap,
sess.interner
);
Parser(sess, cfg, srdr as reader)
}
// Read the entire source file, return a parser
// that draws from that string
pub fn new_parser_result_from_file(sess: @mut ParseSess,
cfg: ast::crate_cfg,
path: &Path)
-> Result<Parser, ~str> {
pub fn new_parser_result_from_file(
sess: @mut ParseSess,
+cfg: ast::crate_cfg,
path: &Path
) -> Result<Parser, ~str> {
match io::read_whole_file_str(path) {
result::Ok(src) => {
Ok(src) => {
let filemap = sess.cm.new_filemap(path.to_str(), @src);
let srdr = lexer::new_string_reader(
copy sess.span_diagnostic,
filemap,
sess.interner
);
Ok(Parser(sess, cfg, srdr as reader))
let filemap = sess.cm.new_filemap(path.to_str(), @src);
let srdr = lexer::new_string_reader(copy sess.span_diagnostic,
filemap,
sess.interner);
Ok(Parser(sess, cfg, srdr as reader))
}
result::Err(e) => Err(e)
}
Err(e) => Err(e)
}
}
/// Create a new parser for an entire crate, handling errors as appropriate
/// if the file doesn't exist
pub fn new_parser_from_file(sess: @mut ParseSess, cfg: ast::crate_cfg,
path: &Path) -> Parser {
pub fn new_parser_from_file(
sess: @mut ParseSess,
+cfg: ast::crate_cfg,
path: &Path
) -> Parser {
match new_parser_result_from_file(sess, cfg, path) {
Ok(parser) => parser,
Err(e) => {
@ -220,8 +269,12 @@ pub fn new_parser_from_file(sess: @mut ParseSess, cfg: ast::crate_cfg,
/// Create a new parser based on a span from an existing parser. Handles
/// error messages correctly when the file does not exist.
pub fn new_sub_parser_from_file(sess: @mut ParseSess, cfg: ast::crate_cfg,
path: &Path, sp: span) -> Parser {
pub fn new_sub_parser_from_file(
sess: @mut ParseSess,
+cfg: ast::crate_cfg,
path: &Path,
sp: span
) -> Parser {
match new_parser_result_from_file(sess, cfg, path) {
Ok(parser) => parser,
Err(e) => {
@ -230,11 +283,18 @@ pub fn new_sub_parser_from_file(sess: @mut ParseSess, cfg: ast::crate_cfg,
}
}
pub fn new_parser_from_tts(sess: @mut ParseSess, cfg: ast::crate_cfg,
+tts: ~[ast::token_tree]) -> Parser {
let trdr = lexer::new_tt_reader(copy sess.span_diagnostic, sess.interner,
None, tts);
return Parser(sess, cfg, trdr as reader)
pub fn new_parser_from_tts(
sess: @mut ParseSess,
+cfg: ast::crate_cfg,
+tts: ~[ast::token_tree]
) -> Parser {
let trdr = lexer::new_tt_reader(
copy sess.span_diagnostic,
sess.interner,
None,
tts
);
Parser(sess, cfg, trdr as reader)
}

2
src/libsyntax/parse/parser.rs
View file

@ -3492,7 +3492,7 @@ pub impl Parser {
};
let full_path = full_path.normalize();
let p0 =
new_sub_parser_from_file(self.sess, self.cfg,
new_sub_parser_from_file(self.sess, copy self.cfg,
&full_path, id_sp);
let (inner, next) = p0.parse_inner_attrs_and_next();
let mod_attrs = vec::append(