From 847c5e4e9892ef56873ac52a552997267c4d385a Mon Sep 17 00:00:00 2001 From: Patrick Walton Date: Thu, 7 Jun 2012 20:12:05 -0700 Subject: [PATCH 1/4] syntax: Remove a bunch of implicit copies --- src/libsyntax/ast_map.rs | 22 ++++++------ src/libsyntax/ast_util.rs | 26 ++++++++------ src/libsyntax/attr.rs | 70 +++++++++++++++++++++---------------- src/libsyntax/codemap.rs | 12 ++++--- src/libsyntax/diagnostic.rs | 10 +++--- 5 files changed, 80 insertions(+), 60 deletions(-) diff --git a/src/libsyntax/ast_map.rs b/src/libsyntax/ast_map.rs index fbea5026b3c2f..b0cb1d22cf745 100644 --- a/src/libsyntax/ast_map.rs +++ b/src/libsyntax/ast_map.rs @@ -12,8 +12,8 @@ type path = [path_elt]; fn path_to_str_with_sep(p: path, sep: str) -> str { let strs = vec::map(p) {|e| alt e { - path_mod(s) { s } - path_name(s) { s } + path_mod(s) { /* FIXME: bad */ copy s } + path_name(s) { /* FIXME: bad */ copy s } } }; str::connect(strs, sep) @@ -21,7 +21,7 @@ fn path_to_str_with_sep(p: path, sep: str) -> str { fn path_ident_to_str(p: path, i: ident) -> str { if vec::is_empty(p) { - i + /* FIXME: bad */ copy i } else { #fmt["%s::%s", path_to_str(p), i] } @@ -59,7 +59,7 @@ type ctx = {map: map, mut path: path, mut local_id: uint, diag: span_handler}; type vt = visit::vt; -fn extend(cx: ctx, elt: str) -> @path { +fn extend(cx: ctx, +elt: str) -> @path { @(cx.path + [path_name(elt)]) } @@ -89,7 +89,7 @@ fn map_crate(diag: span_handler, c: crate) -> map { // crate. The `path` should be the path to the item but should not include // the item itself. fn map_decoded_item(diag: span_handler, - map: map, path: path, ii: inlined_item) { + map: map, +path: path, ii: inlined_item) { // I believe it is ok for the local IDs of inlined items from other crates // to overlap with the local ids from this crate, so just generate the ids // starting from 0. (In particular, I think these ids are only used in @@ -97,7 +97,7 @@ fn map_decoded_item(diag: span_handler, // even if we did I think it only needs an ordering between local // variables that are simultaneously in scope). let cx = {map: map, - mut path: path, + mut path: /* FIXME: bad */ copy path, mut local_id: 0u, diag: diag}; let v = mk_ast_map_visitor(); @@ -128,11 +128,13 @@ fn map_fn(fk: visit::fn_kind, decl: fn_decl, body: blk, } alt fk { visit::fk_ctor(nm, tps, self_id, parent_id) { - let ct = @{node: {id: id, self_id: self_id, - dec: decl, body: body}, + let ct = @{node: {id: id, + self_id: self_id, + dec: /* FIXME: bad */ copy decl, + body: /* FIXME: bad */ copy body}, span: sp}; - cx.map.insert(id, node_ctor(nm, tps, class_ctor(ct, parent_id), - @cx.path)); + cx.map.insert(id, node_ctor(/* FIXME: bad */ copy nm, tps, + class_ctor(ct, parent_id), @cx.path)); } visit::fk_dtor(tps, self_id, parent_id) { let dt = @{node: {id: id, self_id: self_id, body: body}, diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs index cc4593d4af864..c81f6d9590fcb 100644 --- a/src/libsyntax/ast_util.rs +++ b/src/libsyntax/ast_util.rs @@ -156,7 +156,7 @@ fn is_exported(i: ident, m: _mod) -> bool { for variants.each {|v| if v.node.name == i { local = true; - parent_enum = some(it.ident); + parent_enum = some(/* FIXME: bad */ copy it.ident); } } } @@ -247,12 +247,12 @@ fn block_from_expr(e: @expr) -> blk { ret {node: blk_, span: e.span}; } -fn default_block(stmts1: [@stmt], expr1: option<@expr>, id1: node_id) -> +fn default_block(+stmts1: [@stmt], expr1: option<@expr>, id1: node_id) -> blk_ { {view_items: [], stmts: stmts1, expr: expr1, id: id1, rules: default_blk} } -fn ident_to_path(s: span, i: ident) -> @path { +fn ident_to_path(s: span, +i: ident) -> @path { @{span: s, global: false, idents: [i], rp: none, types: []} } @@ -265,7 +265,7 @@ pure fn is_unguarded(&&a: arm) -> bool { } pure fn unguarded_pat(a: arm) -> option<[@pat]> { - if is_unguarded(a) { some(a.pats) } else { none } + if is_unguarded(a) { some(/* FIXME: bad */ copy a.pats) } else { none } } // Provides an extra node_id to hang callee information on, in case the @@ -275,8 +275,8 @@ fn op_expr_callee_id(e: @expr) -> node_id { e.id - 1 } pure fn class_item_ident(ci: @class_member) -> ident { alt ci.node { - instance_var(i,_,_,_,_) { i } - class_method(it) { it.ident } + instance_var(i,_,_,_,_) { /* FIXME: bad */ copy i } + class_method(it) { /* FIXME: bad */ copy it.ident } } } @@ -294,7 +294,11 @@ fn split_class_items(cs: [@class_member]) -> ([ivar], [@method]) { for cs.each {|c| alt c.node { instance_var(i, t, cm, id, vis) { - vs += [{ident: i, ty: t, cm: cm, id: id, vis: vis}]; + vs += [{ident: /* FIXME: bad */ copy i, + ty: t, + cm: cm, + id: id, + vis: vis}]; } class_method(m) { ms += [m]; } } @@ -312,10 +316,10 @@ pure fn class_member_visibility(ci: @class_member) -> visibility { impl inlined_item_methods for inlined_item { fn ident() -> ident { alt self { - ii_item(i) { i.ident } - ii_native(i) { i.ident } - ii_method(_, m) { m.ident } - ii_ctor(_, nm, _, _) { nm } + ii_item(i) { /* FIXME: bad */ copy i.ident } + ii_native(i) { /* FIXME: bad */ copy i.ident } + ii_method(_, m) { /* FIXME: bad */ copy m.ident } + ii_ctor(_, nm, _, _) { /* FIXME: bad */ copy nm } } } diff --git a/src/libsyntax/attr.rs b/src/libsyntax/attr.rs index f9393890f3c90..204973ade02d9 100644 --- a/src/libsyntax/attr.rs +++ b/src/libsyntax/attr.rs @@ -46,21 +46,21 @@ export require_unique_names; /* Constructors */ -fn mk_name_value_item_str(name: ast::ident, value: str) -> @ast::meta_item { +fn mk_name_value_item_str(+name: ast::ident, +value: str) -> @ast::meta_item { let value_lit = dummy_spanned(ast::lit_str(value)); ret mk_name_value_item(name, value_lit); } -fn mk_name_value_item(name: ast::ident, value: ast::lit) -> @ast::meta_item { +fn mk_name_value_item(+name: ast::ident, +value: ast::lit) -> @ast::meta_item { ret @dummy_spanned(ast::meta_name_value(name, value)); } -fn mk_list_item(name: ast::ident, items: [@ast::meta_item]) -> +fn mk_list_item(+name: ast::ident, +items: [@ast::meta_item]) -> @ast::meta_item { ret @dummy_spanned(ast::meta_list(name, items)); } -fn mk_word_item(name: ast::ident) -> @ast::meta_item { +fn mk_word_item(+name: ast::ident) -> @ast::meta_item { ret @dummy_spanned(ast::meta_word(name)); } @@ -89,9 +89,9 @@ fn get_attr_name(attr: ast::attribute) -> ast::ident { fn get_meta_item_name(meta: @ast::meta_item) -> ast::ident { alt meta.node { - ast::meta_word(n) { n } - ast::meta_name_value(n, _) { n } - ast::meta_list(n, _) { n } + ast::meta_word(n) { /* FIXME bad */ copy n } + ast::meta_name_value(n, _) { /* FIXME bad */ copy n } + ast::meta_list(n, _) { /* FIXME bad */ copy n } } } @@ -102,7 +102,14 @@ containing a string, otherwise none fn get_meta_item_value_str(meta: @ast::meta_item) -> option { alt meta.node { ast::meta_name_value(_, v) { - alt v.node { ast::lit_str(s) { option::some(s) } _ { option::none } } + alt v.node { + ast::lit_str(s) { + option::some(/* FIXME bad */ copy s) + } + _ { + option::none + } + } } _ { option::none } } @@ -111,7 +118,7 @@ fn get_meta_item_value_str(meta: @ast::meta_item) -> option { #[doc = "Gets a list of inner meta items from a list meta_item type"] fn get_meta_item_list(meta: @ast::meta_item) -> option<[@ast::meta_item]> { alt meta.node { - ast::meta_list(_, l) { option::some(l) } + ast::meta_list(_, l) { option::some(/* FIXME bad */ copy l) } _ { option::none } } } @@ -126,7 +133,7 @@ fn get_name_value_str_pair( alt attr::get_meta_item_value_str(item) { some(value) { let name = attr::get_meta_item_name(item); - some((name, value)) + some((name, /* FIXME bad */ copy value)) } none { none } } @@ -138,7 +145,7 @@ fn get_name_value_str_pair( #[doc = " Search a list of attributes and return only those with a specific name "] -fn find_attrs_by_name(attrs: [ast::attribute], name: ast::ident) -> +fn find_attrs_by_name(attrs: [ast::attribute], +name: ast::ident) -> [ast::attribute] { let filter = ( fn@(a: ast::attribute) -> option { @@ -153,7 +160,7 @@ fn find_attrs_by_name(attrs: [ast::attribute], name: ast::ident) -> #[doc = " Searcha list of meta items and return only those with a specific name "] -fn find_meta_items_by_name(metas: [@ast::meta_item], name: ast::ident) -> +fn find_meta_items_by_name(metas: [@ast::meta_item], +name: ast::ident) -> [@ast::meta_item] { let filter = fn@(&&m: @ast::meta_item) -> option<@ast::meta_item> { if get_meta_item_name(m) == name { @@ -201,16 +208,16 @@ fn eq(a: @ast::meta_item, b: @ast::meta_item) -> bool { } } -fn contains_name(metas: [@ast::meta_item], name: ast::ident) -> bool { +fn contains_name(metas: [@ast::meta_item], +name: ast::ident) -> bool { let matches = find_meta_items_by_name(metas, name); ret vec::len(matches) > 0u; } -fn attrs_contains_name(attrs: [ast::attribute], name: ast::ident) -> bool { +fn attrs_contains_name(attrs: [ast::attribute], +name: ast::ident) -> bool { vec::is_not_empty(find_attrs_by_name(attrs, name)) } -fn first_attr_value_str_by_name(attrs: [ast::attribute], name: ast::ident) +fn first_attr_value_str_by_name(attrs: [ast::attribute], +name: ast::ident) -> option { let mattrs = find_attrs_by_name(attrs, name); if vec::len(mattrs) > 0u { @@ -221,7 +228,7 @@ fn first_attr_value_str_by_name(attrs: [ast::attribute], name: ast::ident) fn last_meta_item_by_name( items: [@ast::meta_item], - name: str + +name: str ) -> option<@ast::meta_item> { let items = attr::find_meta_items_by_name(items, name); vec::last_opt(items) @@ -229,12 +236,12 @@ fn last_meta_item_by_name( fn last_meta_item_value_str_by_name( items: [@ast::meta_item], - name: str + +name: str ) -> option { alt last_meta_item_by_name(items, name) { some(item) { alt attr::get_meta_item_value_str(item) { - some(value) { some(value) } + some(value) { some(/* FIXME bad */ copy value) } none { none } } } @@ -244,7 +251,7 @@ fn last_meta_item_value_str_by_name( fn last_meta_item_list_by_name( items: [@ast::meta_item], - name: str + +name: str ) -> option<[@ast::meta_item]> { alt last_meta_item_by_name(items, name) { some(item) { @@ -259,13 +266,13 @@ fn last_meta_item_list_by_name( // FIXME: This needs to sort by meta_item variant in addition to the item name // (See [Fixme-sorting]) -fn sort_meta_items(items: [@ast::meta_item]) -> [@ast::meta_item] { +fn sort_meta_items(+items: [@ast::meta_item]) -> [@ast::meta_item] { fn lteq(&&ma: @ast::meta_item, &&mb: @ast::meta_item) -> bool { fn key(m: @ast::meta_item) -> ast::ident { alt m.node { - ast::meta_word(name) { name } - ast::meta_name_value(name, _) { name } - ast::meta_list(name, _) { name } + ast::meta_word(name) { /* FIXME bad */ copy name } + ast::meta_name_value(name, _) { /* FIXME bad */ copy name } + ast::meta_list(name, _) { /* FIXME bad */ copy name } } } ret key(ma) <= key(mb); @@ -280,13 +287,14 @@ fn sort_meta_items(items: [@ast::meta_item]) -> [@ast::meta_item] { fn remove_meta_items_by_name(items: [@ast::meta_item], name: str) -> [@ast::meta_item] { - let filter = fn@(&&item: @ast::meta_item) -> option<@ast::meta_item> { + ret vec::filter_map(items, { + |item| if get_meta_item_name(item) != name { - option::some(item) - } else { option::none } - }; - - ret vec::filter_map(items, filter); + option::some(/* FIXME bad */ copy item) + } else { + option::none + } + }); } fn find_linkage_attrs(attrs: [ast::attribute]) -> [ast::attribute] { @@ -307,7 +315,7 @@ linkage fn find_linkage_metas(attrs: [ast::attribute]) -> [@ast::meta_item] { find_linkage_attrs(attrs).flat_map {|attr| alt check attr.node.value.node { - ast::meta_list(_, items) { items } + ast::meta_list(_, items) { /* FIXME bad */ copy items } } } } @@ -362,6 +370,8 @@ fn require_unique_names(diagnostic: span_handler, let map = map::str_hash(); for metas.each {|meta| let name = get_meta_item_name(meta); + + // FIXME: How do I silence the warnings? --pcw if map.contains_key(name) { diagnostic.span_fatal(meta.span, #fmt["duplicate meta item `%s`", name]); diff --git a/src/libsyntax/codemap.rs b/src/libsyntax/codemap.rs index 0fa419cd4a96a..97911f9d8b881 100644 --- a/src/libsyntax/codemap.rs +++ b/src/libsyntax/codemap.rs @@ -51,7 +51,7 @@ type loc = {file: filemap, line: uint, col: uint}; fn new_codemap() -> codemap { @{files: dvec()} } -fn new_filemap_w_substr(filename: filename, substr: file_substr, +fn new_filemap_w_substr(+filename: filename, +substr: file_substr, src: @str, start_pos_ch: uint, start_pos_byte: uint) -> filemap { @@ -60,7 +60,7 @@ fn new_filemap_w_substr(filename: filename, substr: file_substr, mut lines: [{ch: start_pos_ch, byte: start_pos_byte}]}; } -fn new_filemap(filename: filename, src: @str, +fn new_filemap(+filename: filename, src: @str, start_pos_ch: uint, start_pos_byte: uint) -> filemap { ret new_filemap_w_substr(filename, fss_none, src, @@ -123,14 +123,16 @@ fn lookup_char_pos_adj(map: codemap, pos: uint) let loc = lookup_char_pos(map, pos); alt (loc.file.substr) { fss_none { - {filename: loc.file.name, line: loc.line, col: loc.col, + {filename: /* FIXME bad */ copy loc.file.name, + line: loc.line, + col: loc.col, file: some(loc.file)} } fss_internal(sp) { lookup_char_pos_adj(map, sp.lo + (pos - loc.file.start_pos.ch)) } fss_external(eloc) { - {filename: eloc.filename, + {filename: /* FIXME bad */ copy eloc.filename, line: eloc.line + loc.line - 1u, col: if loc.line == 1u {eloc.col + loc.col} else {loc.col}, file: none} @@ -176,7 +178,7 @@ type file_lines = {file: filemap, lines: [uint]}; fn span_to_filename(sp: span, cm: codemap::codemap) -> filename { let lo = lookup_char_pos(cm, sp.lo); - ret lo.file.name; + ret /* FIXME bad */ copy lo.file.name; } fn span_to_lines(sp: span, cm: codemap::codemap) -> @file_lines { diff --git a/src/libsyntax/diagnostic.rs b/src/libsyntax/diagnostic.rs index f58333c5599be..b65c6524d1206 100644 --- a/src/libsyntax/diagnostic.rs +++ b/src/libsyntax/diagnostic.rs @@ -201,7 +201,7 @@ fn highlight_lines(cm: codemap::codemap, sp: span, // arbitrarily only print up to six lines of the error let max_lines = 6u; let mut elided = false; - let mut display_lines = lines.lines; + let mut display_lines = /* FIXME bad */ copy lines.lines; if vec::len(display_lines) > max_lines { display_lines = vec::slice(display_lines, 0u, max_lines); elided = true; @@ -250,9 +250,11 @@ fn highlight_lines(cm: codemap::codemap, sp: span, fn print_macro_backtrace(cm: codemap::codemap, sp: span) { option::iter (sp.expn_info) {|ei| - let ss = option::map_default(ei.callie.span, "", - bind codemap::span_to_str(_, cm)); - print_diagnostic(ss, note, + let ss = option::map_default(ei.callie.span, @"", { + |span| + @codemap::span_to_str(span, cm) + }); + print_diagnostic(*ss, note, #fmt("in expansion of #%s", ei.callie.name)); let ss = codemap::span_to_str(ei.call_site, cm); print_diagnostic(ss, note, "expansion site"); From 26faa37305f59e2b09a92b089b78abc4f01da8e8 Mon Sep 17 00:00:00 2001 From: Patrick Walton Date: Thu, 7 Jun 2012 21:53:47 -0700 Subject: [PATCH 2/4] syntax: Add a lot of copy keywords --- src/libsyntax/ast_map.rs | 44 ++++++++++++++++----------- src/libsyntax/attr.rs | 3 +- src/libsyntax/fold.rs | 57 ++++++++++++++++++++--------------- src/libsyntax/parse/common.rs | 5 ++- src/libsyntax/parse/eval.rs | 10 +++--- src/libsyntax/visit.rs | 27 +++++++++++------ 6 files changed, 87 insertions(+), 59 deletions(-) diff --git a/src/libsyntax/ast_map.rs b/src/libsyntax/ast_map.rs index b0cb1d22cf745..b2e6446d7ee01 100644 --- a/src/libsyntax/ast_map.rs +++ b/src/libsyntax/ast_map.rs @@ -123,7 +123,7 @@ fn map_decoded_item(diag: span_handler, fn map_fn(fk: visit::fn_kind, decl: fn_decl, body: blk, sp: codemap::span, id: node_id, cx: ctx, v: vt) { for decl.inputs.each {|a| - cx.map.insert(a.id, node_arg(a, cx.local_id)); + cx.map.insert(a.id, node_arg(/* FIXME: bad */ copy a, cx.local_id)); cx.local_id += 1u; } alt fk { @@ -133,13 +133,17 @@ fn map_fn(fk: visit::fn_kind, decl: fn_decl, body: blk, dec: /* FIXME: bad */ copy decl, body: /* FIXME: bad */ copy body}, span: sp}; - cx.map.insert(id, node_ctor(/* FIXME: bad */ copy nm, tps, - class_ctor(ct, parent_id), @cx.path)); + cx.map.insert(id, node_ctor(/* FIXME: bad */ copy nm, + /* FIXME: bad */ copy tps, + class_ctor(ct, parent_id), + @/* FIXME: bad */ copy cx.path)); } visit::fk_dtor(tps, self_id, parent_id) { - let dt = @{node: {id: id, self_id: self_id, body: body}, - span: sp}; - cx.map.insert(id, node_dtor(tps, dt, parent_id, @cx.path)); + let dt = @{node: {id: id, self_id: self_id, + body: /* FIXME: bad */ copy body}, span: sp}; + cx.map.insert(id, node_dtor(/* FIXME: bad */ copy tps, dt, + parent_id, + @/* FIXME: bad */ copy cx.path)); } _ {} @@ -148,7 +152,7 @@ fn map_fn(fk: visit::fn_kind, decl: fn_decl, body: blk, } fn map_block(b: blk, cx: ctx, v: vt) { - cx.map.insert(b.node.id, node_block(b)); + cx.map.insert(b.node.id, node_block(/* FIXME: bad */ copy b)); visit::visit_block(b, cx, v); } @@ -182,25 +186,29 @@ fn map_method(impl_did: def_id, impl_path: @path, } fn map_item(i: @item, cx: ctx, v: vt) { - let item_path = @cx.path; + let item_path = @/* FIXME: bad */ copy cx.path; cx.map.insert(i.id, node_item(i, item_path)); alt i.node { item_impl(_, _, _, _, ms) { let impl_did = ast_util::local_def(i.id); for ms.each {|m| - map_method(impl_did, extend(cx, i.ident), m, cx); + map_method(impl_did, extend(cx, /* FIXME: bad */ copy i.ident), m, + cx); } } item_res(decl, tps, _, dtor_id, ctor_id, _) { - cx.map.insert(ctor_id, node_ctor(i.ident, tps, - res_ctor(decl, ctor_id, i.span), + cx.map.insert(ctor_id, node_ctor(/* FIXME: bad */ copy i.ident, + /* FIXME: bad */ copy tps, + res_ctor(/* FIXME: bad */ copy decl, + ctor_id, i.span), item_path)); cx.map.insert(dtor_id, node_item(i, item_path)); } item_enum(vs, _, _) { for vs.each {|v| cx.map.insert(v.node.id, node_variant( - v, i, extend(cx, i.ident))); + /* FIXME: bad */ copy v, i, + extend(cx, /* FIXME: bad */ copy i.ident))); } } item_native_mod(nm) { @@ -209,7 +217,9 @@ fn map_item(i: @item, cx: ctx, v: vt) { either::right(abi) { abi } }; for nm.items.each {|nitem| - cx.map.insert(nitem.id, node_native_item(nitem, abi, @cx.path)); + cx.map.insert(nitem.id, + node_native_item(nitem, abi, + @/* FIXME: bad */ copy cx.path)); } } item_class(tps, ifces, items, ctor, dtor, _) { @@ -219,7 +229,7 @@ fn map_item(i: @item, cx: ctx, v: vt) { vec::iter(ifces) {|p| cx.map.insert(p.id, node_item(i, item_path)); }; let d_id = ast_util::local_def(i.id); - let p = extend(cx, i.ident); + let p = extend(cx, /* FIXME: bad */ copy i.ident); // only need to handle methods vec::iter(ms) {|m| map_method(d_id, p, m, cx); } } @@ -227,9 +237,9 @@ fn map_item(i: @item, cx: ctx, v: vt) { } alt i.node { item_mod(_) | item_native_mod(_) { - cx.path += [path_mod(i.ident)]; + cx.path += [path_mod(/* FIXME: bad */ copy i.ident)]; } - _ { cx.path += [path_name(i.ident)]; } + _ { cx.path += [path_name(/* FIXME: bad */ copy i.ident)]; } } visit::visit_item(i, cx, v); vec::pop(cx.path); @@ -240,7 +250,7 @@ fn map_view_item(vi: @view_item, cx: ctx, _v: vt) { view_item_export(vps) { for vps.each {|vp| let (id, name) = alt vp.node { - view_path_simple(nm, _, id) { (id, nm) } + view_path_simple(nm, _, id) { (id, /* FIXME: bad */ copy nm) } view_path_glob(pth, id) | view_path_list(pth, _, id) { (id, path_to_ident(pth)) } diff --git a/src/libsyntax/attr.rs b/src/libsyntax/attr.rs index 204973ade02d9..af780bc5e3836 100644 --- a/src/libsyntax/attr.rs +++ b/src/libsyntax/attr.rs @@ -51,7 +51,8 @@ fn mk_name_value_item_str(+name: ast::ident, +value: str) -> @ast::meta_item { ret mk_name_value_item(name, value_lit); } -fn mk_name_value_item(+name: ast::ident, +value: ast::lit) -> @ast::meta_item { +fn mk_name_value_item(+name: ast::ident, +value: ast::lit) + -> @ast::meta_item { ret @dummy_spanned(ast::meta_name_value(name, value)); } diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs index ecdb8d328fb91..04a3c95ce1c0e 100644 --- a/src/libsyntax/fold.rs +++ b/src/libsyntax/fold.rs @@ -88,10 +88,11 @@ fn fold_meta_item_(&&mi: @meta_item, fld: ast_fold) -> @meta_item { meta_word(id) { meta_word(fld.fold_ident(id)) } meta_list(id, mis) { let fold_meta_item = bind fold_meta_item_(_, fld); - meta_list(id, vec::map(mis, fold_meta_item)) + meta_list(/* FIXME: bad */ copy id, + vec::map(mis, fold_meta_item)) } meta_name_value(id, s) { - meta_name_value(fld.fold_ident(id), s) + meta_name_value(fld.fold_ident(id), /* FIXME: bad */ copy s) } }, span: fld.new_span(mi.span)}; @@ -121,8 +122,8 @@ fn fold_mac_(m: mac, fld: ast_fold) -> mac { mac_embed_type(ty) { mac_embed_type(fld.fold_ty(ty)) } mac_embed_block(blk) { mac_embed_block(fld.fold_block(blk)) } mac_ellipsis { mac_ellipsis } - mac_aq(_,_) { /* fixme */ m.node } - mac_var(_) { /* fixme */ m.node } + mac_aq(_,_) { /* FIXME: bad */ copy m.node } + mac_var(_) { /* FIXME: bad */ copy m.node } }, span: fld.new_span(m.span)}; } @@ -143,7 +144,7 @@ fn fold_ty_param_bound(tpb: ty_param_bound, fld: ast_fold) -> ty_param_bound { } fn fold_ty_param(tp: ty_param, fld: ast_fold) -> ty_param { - {ident: tp.ident, + {ident: /* FIXME: bad */ copy tp.ident, id: fld.new_id(tp.id), bounds: @vec::map(*tp.bounds, fold_ty_param_bound(_, fld))} } @@ -166,19 +167,20 @@ fn noop_fold_crate_directive(cd: crate_directive_, fld: ast_fold) -> crate_directive_ { ret alt cd { cdir_src_mod(id, attrs) { - cdir_src_mod(fld.fold_ident(id), attrs) + cdir_src_mod(fld.fold_ident(id), /* FIXME: bad */ copy attrs) } cdir_dir_mod(id, cds, attrs) { cdir_dir_mod(fld.fold_ident(id), - vec::map(cds, fld.fold_crate_directive), attrs) + vec::map(cds, fld.fold_crate_directive), + /* FIXME: bad */ copy attrs) } cdir_view_item(vi) { cdir_view_item(fld.fold_view_item(vi)) } - cdir_syntax(_) { cd } + cdir_syntax(_) { copy cd } } } fn noop_fold_view_item(vi: view_item_, _fld: ast_fold) -> view_item_ { - ret vi; + ret /* FIXME: bad */ copy vi; } @@ -220,7 +222,8 @@ fn noop_fold_class_item(&&ci: @class_member, fld: ast_fold) -> @class_member { @{node: alt ci.node { instance_var(ident, t, cm, id, p) { - instance_var(ident, fld.fold_ty(t), cm, id, p) + instance_var(/* FIXME: bad */ copy ident, fld.fold_ty(t), cm, id, + p) } class_method(m) { class_method(fld.fold_method(m)) } }, @@ -256,7 +259,7 @@ fn noop_fold_item_underscore(i: item_, fld: ast_fold) -> item_ { id: dtor_id with dtor.node} with dtor}}; item_class( - typms, + /* FIXME: bad */ copy typms, vec::map(ifaces, {|p| fold_iface_ref(p, fld) }), vec::map(items, fld.fold_class_item), {node: {body: ctor_body, @@ -274,7 +277,7 @@ fn noop_fold_item_underscore(i: item_, fld: ast_fold) -> item_ { item_iface(tps, rp, methods) { item_iface(fold_ty_params(tps, fld), rp, - methods) + /* FIXME: bad */ copy methods) } item_res(decl, typms, body, did, cid, rp) { item_res(fold_fn_decl(decl, fld), @@ -293,7 +296,7 @@ fn fold_iface_ref(&&p: @iface_ref, fld: ast_fold) -> @iface_ref { fn noop_fold_method(&&m: @method, fld: ast_fold) -> @method { ret @{ident: fld.fold_ident(m.ident), - attrs: m.attrs, + attrs: /* FIXME: bad */ copy m.attrs, tps: fold_ty_params(m.tps, fld), decl: fold_fn_decl(m.decl, fld), body: fld.fold_block(m.body), @@ -328,7 +331,7 @@ fn noop_fold_arm(a: arm, fld: ast_fold) -> arm { fn noop_fold_pat(p: pat_, fld: ast_fold) -> pat_ { ret alt p { - pat_wild { p } + pat_wild { pat_wild } pat_ident(pth, sub) { pat_ident(fld.fold_path(pth), option::map(sub, fld.fold_pat)) } @@ -340,7 +343,8 @@ fn noop_fold_pat(p: pat_, fld: ast_fold) -> pat_ { pat_rec(fields, etc) { let mut fs = []; for fields.each {|f| - fs += [{ident: f.ident, pat: fld.fold_pat(f.pat)}]; + fs += [{ident: /* FIXME: bad */ copy f.ident, + pat: fld.fold_pat(f.pat)}]; } pat_rec(fs, etc) } @@ -410,7 +414,7 @@ fn noop_fold_expr(e: expr_, fld: ast_fold) -> expr_ { } expr_unary(binop, ohs) { expr_unary(binop, fld.fold_expr(ohs)) } expr_loop_body(f) { expr_loop_body(fld.fold_expr(f)) } - expr_lit(_) { e } + expr_lit(_) { copy e } expr_cast(expr, ty) { expr_cast(fld.fold_expr(expr), ty) } expr_addr_of(m, ohs) { expr_addr_of(m, fld.fold_expr(ohs)) } expr_if(cond, tr, fl) { @@ -462,7 +466,7 @@ fn noop_fold_expr(e: expr_, fld: ast_fold) -> expr_ { } expr_path(pth) { expr_path(fld.fold_path(pth)) } expr_fail(e) { expr_fail(option::map(e, fld.fold_expr)) } - expr_break | expr_cont { e } + expr_break | expr_cont { copy e } expr_ret(e) { expr_ret(option::map(e, fld.fold_expr)) } expr_log(i, lv, e) { expr_log(i, fld.fold_expr(lv), fld.fold_expr(e)) } @@ -487,7 +491,7 @@ fn noop_fold_ty(t: ty_, fld: ast_fold) -> ty_ { span: fld.new_span(f.span)} } alt t { - ty_nil | ty_bot {t} + ty_nil | ty_bot | ty_infer {copy t} ty_box(mt) {ty_box(fold_mt(mt, fld))} ty_uniq(mt) {ty_uniq(fold_mt(mt, fld))} ty_vec(mt) {ty_vec(fold_mt(mt, fld))} @@ -501,17 +505,18 @@ fn noop_fold_ty(t: ty_, fld: ast_fold) -> ty_ { vec::map(constrs, fld.fold_ty_constr))} ty_vstore(t, vs) {ty_vstore(fld.fold_ty(t), vs)} ty_mac(mac) {ty_mac(fold_mac(mac))} - ty_infer {t} } } fn noop_fold_constr(c: constr_, fld: ast_fold) -> constr_ { - {path: fld.fold_path(c.path), args: c.args, id: fld.new_id(c.id)} + {path: fld.fold_path(c.path), args: /* FIXME: bad */ copy c.args, + id: fld.new_id(c.id)} } fn noop_fold_ty_constr(c: ty_constr_, fld: ast_fold) -> ty_constr_ { let rslt: ty_constr_ = - {path: fld.fold_path(c.path), args: c.args, id: fld.new_id(c.id)}; + {path: fld.fold_path(c.path), args: /* FIXME: bad */ copy c.args, + id: fld.new_id(c.id)}; rslt } // ...nor do modules @@ -539,14 +544,16 @@ fn noop_fold_variant(v: variant_, fld: ast_fold) -> variant_ { some(e) {some(fld.fold_expr(e))} none {none} }; - ret {name: v.name, + ret {name: /* FIXME: bad */ copy v.name, attrs: attrs, args: args, id: fld.new_id(v.id), disr_expr: de, vis: v.vis}; } -fn noop_fold_ident(&&i: ident, _fld: ast_fold) -> ident { ret i; } +fn noop_fold_ident(&&i: ident, _fld: ast_fold) -> ident { + ret /* FIXME: bad */ copy i; +} fn noop_fold_path(&&p: path, fld: ast_fold) -> path { ret {span: fld.new_span(p.span), global: p.global, @@ -639,8 +646,8 @@ impl of ast_fold for ast_fold_precursor { fn fold_class_item(&&ci: @class_member) -> @class_member { @{node: alt ci.node { instance_var(nm, t, mt, id, p) { - instance_var(nm, (self as ast_fold).fold_ty(t), - mt, id, p) + instance_var(/* FIXME: bad */ copy nm, + (self as ast_fold).fold_ty(t), mt, id, p) } class_method(m) { class_method(self.fold_method(m, self as ast_fold)) diff --git a/src/libsyntax/parse/common.rs b/src/libsyntax/parse/common.rs index 35afb79ce63f0..c0a2f9b9e6e9a 100644 --- a/src/libsyntax/parse/common.rs +++ b/src/libsyntax/parse/common.rs @@ -209,6 +209,9 @@ impl parser_common for parser { ret v; } + // FIXME: A lot of callers go through here, only to copy out the T and + // discard the spanned<> wrapper. I feel as though there should be a + // version of this that does not return a spanned result. fn parse_seq(bra: token::token, ket: token::token, sep: seq_sep, f: fn(parser) -> T) -> spanned<[T]> { let lo = self.span.lo; @@ -218,4 +221,4 @@ impl parser_common for parser { self.bump(); ret spanned(lo, hi, result); } -} \ No newline at end of file +} diff --git a/src/libsyntax/parse/eval.rs b/src/libsyntax/parse/eval.rs index 98d7549987881..254d5cc5d5d09 100644 --- a/src/libsyntax/parse/eval.rs +++ b/src/libsyntax/parse/eval.rs @@ -44,7 +44,7 @@ optional suffix then adding the .rs extension. fn parse_companion_mod(cx: ctx, prefix: str, suffix: option) -> ([@ast::view_item], [@ast::item], [ast::attribute]) { - fn companion_file(prefix: str, suffix: option) -> str { + fn companion_file(+prefix: str, suffix: option) -> str { ret alt suffix { option::some(s) { path::connect(prefix, s) } option::none { prefix } @@ -66,8 +66,7 @@ fn parse_companion_mod(cx: ctx, prefix: str, suffix: option) #debug("found companion mod"); let p0 = new_parser_from_file(cx.sess, cx.cfg, modpath, SOURCE_FILE); let inner_attrs = p0.parse_inner_attrs_and_next(); - let first_item_outer_attrs = inner_attrs.next; - let m0 = p0.parse_mod_items(token::EOF, first_item_outer_attrs); + let m0 = p0.parse_mod_items(token::EOF, inner_attrs.next); cx.sess.chpos = p0.reader.chpos; cx.sess.byte_pos = cx.sess.byte_pos + p0.reader.pos; ret (m0.view_items, m0.items, inner_attrs.inner); @@ -102,7 +101,8 @@ fn eval_crate_directive(cx: ctx, cdir: @ast::crate_directive, prefix: str, let first_item_outer_attrs = inner_attrs.next; let m0 = p0.parse_mod_items(token::EOF, first_item_outer_attrs); - let i = p0.mk_item(cdir.span.lo, cdir.span.hi, id, + let i = p0.mk_item(cdir.span.lo, cdir.span.hi, + /* FIXME: bad */ copy id, ast::item_mod(m0), ast::public, mod_attrs); // Thread defids, chpos and byte_pos through the parsers cx.sess.chpos = p0.reader.chpos; @@ -118,7 +118,7 @@ fn eval_crate_directive(cx: ctx, cdir: @ast::crate_directive, prefix: str, let (m0, a0) = eval_crate_directives_to_mod( cx, cdirs, full_path, none); let i = - @{ident: id, + @{ident: /* FIXME: bad */ copy id, attrs: attrs + a0, id: cx.sess.next_id, node: ast::item_mod(m0), diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs index c5be778572b82..fa0286ded812c 100644 --- a/src/libsyntax/visit.rs +++ b/src/libsyntax/visit.rs @@ -28,7 +28,7 @@ enum fn_kind { fn name_of_fn(fk: fn_kind) -> ident { alt fk { fk_item_fn(name, _) | fk_method(name, _, _) | fk_res(name, _, _) - | fk_ctor(name, _, _, _) { name } + | fk_ctor(name, _, _, _) { /* FIXME: bad */ copy name } fk_anon(*) | fk_fn_block(*) { "anon" } fk_dtor(*) { "drop" } } @@ -37,7 +37,9 @@ fn name_of_fn(fk: fn_kind) -> ident { fn tps_of_fn(fk: fn_kind) -> [ty_param] { alt fk { fk_item_fn(_, tps) | fk_method(_, tps, _) | fk_res(_, tps, _) - | fk_ctor(_, tps, _, _) | fk_dtor(tps, _, _) { tps } + | fk_ctor(_, tps, _, _) | fk_dtor(tps, _, _) { + /* FIXME: bad */ copy tps + } fk_anon(*) | fk_fn_block(*) { [] } } } @@ -115,7 +117,9 @@ fn visit_item(i: @item, e: E, v: vt) { alt i.node { item_const(t, ex) { v.visit_ty(t, e, v); v.visit_expr(ex, e, v); } item_fn(decl, tp, body) { - v.visit_fn(fk_item_fn(i.ident, tp), decl, body, i.span, i.id, e, v); + v.visit_fn(fk_item_fn(/* FIXME: bad */ copy i.ident, + /* FIXME: bad */ copy tp), decl, body, + i.span, i.id, e, v); } item_mod(m) { v.visit_mod(m, i.span, i.id, e, v); } item_native_mod(nm) { @@ -127,8 +131,10 @@ fn visit_item(i: @item, e: E, v: vt) { v.visit_ty_params(tps, e, v); } item_res(decl, tps, body, dtor_id, _, rp) { - v.visit_fn(fk_res(i.ident, tps, rp), decl, body, i.span, - dtor_id, e, v); + v.visit_fn(fk_res(/* FIXME: bad */ copy i.ident, + /* FIXME: bad */ copy tps, + rp), + decl, body, i.span, dtor_id, e, v); } item_enum(variants, tps, _) { v.visit_ty_params(tps, e, v); @@ -281,22 +287,23 @@ fn visit_fn_decl(fd: fn_decl, e: E, v: vt) { // because it is not a default impl of any method, though I doubt that really // clarifies anything. - Niko fn visit_method_helper(m: @method, e: E, v: vt) { - v.visit_fn(fk_method(m.ident, m.tps, m), m.decl, m.body, m.span, - m.id, e, v); + v.visit_fn(fk_method(/* FIXME: bad */ copy m.ident, + /* FIXME: bad */ copy m.tps, m), + m.decl, m.body, m.span, m.id, e, v); } // Similar logic to the comment on visit_method_helper - Tim fn visit_class_ctor_helper(ctor: class_ctor, nm: ident, tps: [ty_param], parent_id: def_id, e: E, v: vt) { - v.visit_fn(fk_ctor(nm, tps, ctor.node.self_id, - parent_id), ctor.node.dec, + v.visit_fn(fk_ctor(/* FIXME: bad */ copy nm, /* FIXME: bad */ copy tps, + ctor.node.self_id, parent_id), ctor.node.dec, ctor.node.body, ctor.span, ctor.node.id, e, v) } fn visit_class_dtor_helper(dtor: class_dtor, tps: [ty_param], parent_id: def_id, e: E, v: vt) { - v.visit_fn(fk_dtor(tps, dtor.node.self_id, + v.visit_fn(fk_dtor(/* FIXME: bad */ copy tps, dtor.node.self_id, parent_id), ast_util::dtor_dec(), dtor.node.body, dtor.span, dtor.node.id, e, v) From fd85239119ffba1c57a493603d63deed9be60521 Mon Sep 17 00:00:00 2001 From: Patrick Walton Date: Thu, 7 Jun 2012 22:09:27 -0700 Subject: [PATCH 3/4] syntax: Remove several deep copies that were happening due to misuse of parse_seq --- src/libsyntax/parse/common.rs | 13 ++- src/libsyntax/parse/parser.rs | 153 ++++++++++++++++++---------------- 2 files changed, 90 insertions(+), 76 deletions(-) diff --git a/src/libsyntax/parse/common.rs b/src/libsyntax/parse/common.rs index c0a2f9b9e6e9a..0c2718c3b4b58 100644 --- a/src/libsyntax/parse/common.rs +++ b/src/libsyntax/parse/common.rs @@ -209,9 +209,16 @@ impl parser_common for parser { ret v; } - // FIXME: A lot of callers go through here, only to copy out the T and - // discard the spanned<> wrapper. I feel as though there should be a - // version of this that does not return a spanned result. + fn parse_unspanned_seq(bra: token::token, ket: token::token, + sep: seq_sep, f: fn(parser) -> T) -> [T] { + self.expect(bra); + let result = self.parse_seq_to_before_end::(ket, sep, f); + self.bump(); + ret result; + } + + // NB: Do not use this function unless you actually plan to place the + // spanned list in the AST. fn parse_seq(bra: token::token, ket: token::token, sep: seq_sep, f: fn(parser) -> T) -> spanned<[T]> { let lo = self.span.lo; diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 33e7d082bfb0b..df27b2388e073 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -150,8 +150,8 @@ class parser { fn parse_ty_fn_decl(purity: ast::purity) -> fn_decl { let inputs = - self.parse_seq(token::LPAREN, token::RPAREN, - seq_sep(token::COMMA)) { |p| + self.parse_unspanned_seq(token::LPAREN, token::RPAREN, + seq_sep(token::COMMA)) { |p| let mode = p.parse_arg_mode(); let name = if is_plain_ident(p.token) && p.look_ahead(1u) == token::COLON { @@ -170,13 +170,14 @@ class parser { // story on constrained types. let constrs: [@constr] = []; let (ret_style, ret_ty) = self.parse_ret_ty(); - ret {inputs: inputs.node, output: ret_ty, + ret {inputs: inputs, output: ret_ty, purity: purity, cf: ret_style, constraints: constrs}; } fn parse_ty_methods() -> [ty_method] { - (self.parse_seq(token::LBRACE, token::RBRACE, seq_sep_none()) { |p| + self.parse_unspanned_seq(token::LBRACE, token::RBRACE, + seq_sep_none()) { |p| let attrs = p.parse_outer_attributes(); let flo = p.span.lo; let pur = p.parse_fn_purity(); @@ -186,7 +187,7 @@ class parser { self.expect(token::SEMI); {ident: ident, attrs: attrs, decl: {purity: pur with d}, tps: tps, span: mk_sp(flo, fhi)} - }).node + } } fn parse_mt() -> mt { @@ -241,21 +242,21 @@ class parser { fn parse_ty_constr(fn_args: [arg]) -> @constr { let lo = self.span.lo; let path = self.parse_path_without_tps(); - let args: {node: [@constr_arg], span: span} = - self.parse_seq(token::LPAREN, token::RPAREN, - seq_sep(token::COMMA), - {|p| p.parse_constr_arg(fn_args)}); - ret @spanned(lo, args.span.hi, - {path: path, args: args.node, id: self.get_id()}); + let args = + self.parse_unspanned_seq(token::LPAREN, token::RPAREN, + seq_sep(token::COMMA), + {|p| p.parse_constr_arg(fn_args)}); + ret @spanned(lo, self.span.hi, + {path: path, args: args, id: self.get_id()}); } fn parse_constr_in_type() -> @ty_constr { let lo = self.span.lo; let path = self.parse_path_without_tps(); let args: [@ty_constr_arg] = - self.parse_seq(token::LPAREN, token::RPAREN, - seq_sep(token::COMMA), - {|p| p.parse_type_constr_arg()}).node; + self.parse_unspanned_seq(token::LPAREN, token::RPAREN, + seq_sep(token::COMMA), + {|p| p.parse_type_constr_arg()}); let hi = self.span.lo; let tc: ty_constr_ = {path: path, args: args, id: self.get_id()}; ret @spanned(lo, hi, tc); @@ -370,15 +371,15 @@ class parser { self.bump(); ty_ptr(self.parse_mt()) } else if self.token == token::LBRACE { - let elems = self.parse_seq(token::LBRACE, token::RBRACE, - seq_sep_opt(token::COMMA), - {|p| p.parse_ty_field()}); - if vec::len(elems.node) == 0u { + let elems = self.parse_unspanned_seq(token::LBRACE, token::RBRACE, + seq_sep_opt(token::COMMA), + {|p| p.parse_ty_field()}); + if vec::len(elems) == 0u { self.unexpected_last(token::RBRACE); } - let hi = elems.span.hi; + let hi = self.span.hi; - let t = ty_rec(elems.node); + let t = ty_rec(elems); if self.token == token::COLON { self.bump(); ty_constr(@{id: self.get_id(), @@ -813,11 +814,11 @@ class parser { ex = ex_ext.node; } else if self.eat_keyword("bind") { let e = self.parse_expr_res(RESTRICT_NO_CALL_EXPRS); - let es = self.parse_seq(token::LPAREN, token::RPAREN, - seq_sep(token::COMMA), - {|p| p.parse_expr_or_hole()}); - hi = es.span.hi; - ex = expr_bind(e, es.node); + let es = self.parse_unspanned_seq(token::LPAREN, token::RPAREN, + seq_sep(token::COMMA), + {|p| p.parse_expr_or_hole()}); + hi = self.span.hi; + ex = expr_bind(e, es); } else if self.eat_keyword("fail") { if can_begin_expr(self.token) { let e = self.parse_expr(); @@ -920,37 +921,37 @@ class parser { let sep = seq_sep(token::COMMA); let mut e = none; if (self.token == token::LPAREN || self.token == token::LBRACKET) { + let lo = self.span.lo; let es = if self.token == token::LPAREN { - self.parse_seq(token::LPAREN, token::RPAREN, - sep, {|p| p.parse_expr()}) - } else { - self.parse_seq(token::LBRACKET, token::RBRACKET, - sep, {|p| p.parse_expr()}) - }; - let hi = es.span.hi; - e = some(self.mk_expr(es.span.lo, hi, - expr_vec(es.node, m_imm))); - } - let mut b = none; - if self.token == token::LBRACE { - self.bump(); - let lo = self.span.lo; - let mut depth = 1u; - while (depth > 0u) { - alt (self.token) { - token::LBRACE {depth += 1u;} - token::RBRACE {depth -= 1u;} - token::EOF {self.fatal("unexpected EOF in macro body");} - _ {} - } + self.parse_unspanned_seq(token::LPAREN, token::RPAREN, + sep, {|p| p.parse_expr()}) + } else { + self.parse_unspanned_seq(token::LBRACKET, token::RBRACKET, + sep, {|p| p.parse_expr()}) + }; + let hi = self.span.hi; + e = some(self.mk_expr(lo, hi, expr_vec(es, m_imm))); + } + let mut b = none; + if self.token == token::LBRACE { self.bump(); + let lo = self.span.lo; + let mut depth = 1u; + while (depth > 0u) { + alt (self.token) { + token::LBRACE {depth += 1u;} + token::RBRACE {depth -= 1u;} + token::EOF {self.fatal("unexpected EOF in macro body");} + _ {} + } + self.bump(); + } + let hi = self.last_span.lo; + b = some({span: mk_sp(lo,hi)}); } - let hi = self.last_span.lo; - b = some({span: mk_sp(lo,hi)}); + ret self.mk_mac_expr(lo, self.span.hi, mac_invoc(pth, e, b)); } - ret self.mk_mac_expr(lo, self.span.hi, mac_invoc(pth, e, b)); -} fn parse_dot_or_call_expr() -> pexpr { let b = self.parse_bottom_expr(); @@ -989,16 +990,17 @@ class parser { alt copy self.token { // expr(...) token::LPAREN if self.permits_call() { - let es_opt = self.parse_seq(token::LPAREN, token::RPAREN, - seq_sep(token::COMMA), - {|p| p.parse_expr_or_hole()}); - hi = es_opt.span.hi; + let es_opt = + self.parse_unspanned_seq(token::LPAREN, token::RPAREN, + seq_sep(token::COMMA), + {|p| p.parse_expr_or_hole()}); + hi = self.span.hi; let nd = - if vec::any(es_opt.node, {|e| option::is_none(e) }) { - expr_bind(self.to_expr(e), es_opt.node) + if vec::any(es_opt, {|e| option::is_none(e) }) { + expr_bind(self.to_expr(e), es_opt) } else { - let es = vec::map(es_opt.node) {|e| option::get(e) }; + let es = vec::map(es_opt) {|e| option::get(e) }; expr_call(self.to_expr(e), es, false) }; e = self.mk_pexpr(lo, hi, nd); @@ -1458,11 +1460,12 @@ class parser { self.expect(token::RPAREN); } _ { - let a = self.parse_seq(token::LPAREN, token::RPAREN, - seq_sep(token::COMMA), - {|p| p.parse_pat()}); - args = a.node; - hi = a.span.hi; + args = + self.parse_unspanned_seq(token::LPAREN, + token::RPAREN, + seq_sep(token::COMMA), + {|p| p.parse_pat()}); + hi = self.span.hi; } } } @@ -1761,8 +1764,8 @@ class parser { -> (fn_decl, capture_clause) { let args_or_capture_items: [arg_or_capture_item] = - self.parse_seq(token::LPAREN, token::RPAREN, - seq_sep(token::COMMA), parse_arg_fn).node; + self.parse_unspanned_seq(token::LPAREN, token::RPAREN, + seq_sep(token::COMMA), parse_arg_fn); let inputs = either::lefts(args_or_capture_items); let capture_clause = @either::rights(args_or_capture_items); @@ -1788,9 +1791,10 @@ class parser { if self.eat(token::OROR) { [] } else { - self.parse_seq(token::BINOP(token::OR), - token::BINOP(token::OR), seq_sep(token::COMMA), - {|p| p.parse_fn_block_arg()}).node + self.parse_unspanned_seq(token::BINOP(token::OR), + token::BINOP(token::OR), + seq_sep(token::COMMA), + {|p| p.parse_fn_block_arg()}) } }; let output = if self.eat(token::RARROW) { @@ -2242,10 +2246,12 @@ class parser { let mut args = [], disr_expr = none; if self.token == token::LPAREN { all_nullary = false; - let arg_tys = self.parse_seq(token::LPAREN, token::RPAREN, + let arg_tys = + self.parse_unspanned_seq(token::LPAREN, + token::RPAREN, seq_sep(token::COMMA), {|p| p.parse_ty(false)}); - for arg_tys.node.each {|ty| + for arg_tys.each {|ty| args += [{ty: ty, id: self.get_id()}]; } } else if self.eat(token::EQ) { @@ -2385,9 +2391,10 @@ class parser { // foo::bar::{a,b,c} token::LBRACE { let idents = - self.parse_seq(token::LBRACE, token::RBRACE, - seq_sep(token::COMMA), - {|p| p.parse_path_list_ident()}).node; + self.parse_unspanned_seq(token::LBRACE, token::RBRACE, + seq_sep(token::COMMA), + {|p| + p.parse_path_list_ident()}); let path = @{span: mk_sp(lo, self.span.hi), global: false, idents: path, rp: none, types: []}; From cdcae39ba37b212d4f85e251082205cedc6b38ef Mon Sep 17 00:00:00 2001 From: Patrick Walton Date: Thu, 7 Jun 2012 22:51:00 -0700 Subject: [PATCH 4/4] syntax: Remove some more implicit copies --- src/libsyntax/ext/source_util.rs | 16 ++++++++++------ src/libsyntax/parse.rs | 32 +++++++++++++------------------- 2 files changed, 23 insertions(+), 25 deletions(-) diff --git a/src/libsyntax/ext/source_util.rs b/src/libsyntax/ext/source_util.rs index 99b928cfb9cf1..0680194ea6b4b 100644 --- a/src/libsyntax/ext/source_util.rs +++ b/src/libsyntax/ext/source_util.rs @@ -34,8 +34,9 @@ fn expand_col(cx: ext_ctxt, sp: span, arg: ast::mac_arg, fn expand_file(cx: ext_ctxt, sp: span, arg: ast::mac_arg, _body: ast::mac_body) -> @ast::expr { get_mac_args(cx, sp, arg, 0u, option::some(0u), "file"); - let loc = codemap::lookup_char_pos(cx.codemap(), sp.lo); - ret make_new_lit(cx, sp, ast::lit_str(loc.file.name)); + let { file: @{ name: filename, _ }, _ } = + codemap::lookup_char_pos(cx.codemap(), sp.lo); + ret make_new_lit(cx, sp, ast::lit_str(filename)); } fn expand_stringify(cx: ext_ctxt, sp: span, arg: ast::mac_arg, @@ -66,12 +67,15 @@ fn expand_include_str(cx: ext_ctxt, sp: codemap::span, arg: ast::mac_arg, let file = expr_to_str(cx, args[0], "#include_str requires a string"); - alt io::read_whole_file_str(res_rel_file(cx, sp, file)) { - result::ok(src) { ret make_new_lit(cx, sp, ast::lit_str(src)); } + let res = io::read_whole_file_str(res_rel_file(cx, sp, file)); + alt res { + result::ok(_) { /* Continue. */ } result::err(e) { - cx.parse_sess().span_diagnostic.handler().fatal(e) + cx.parse_sess().span_diagnostic.handler().fatal(e); } } + + ret make_new_lit(cx, sp, ast::lit_str(result::unwrap(res))); } fn expand_include_bin(cx: ext_ctxt, sp: codemap::span, arg: ast::mac_arg, @@ -93,7 +97,7 @@ fn expand_include_bin(cx: ext_ctxt, sp: codemap::span, arg: ast::mac_arg, } } -fn res_rel_file(cx: ext_ctxt, sp: codemap::span, arg: path) -> path { +fn res_rel_file(cx: ext_ctxt, sp: codemap::span, +arg: path) -> path { // NB: relative paths are resolved relative to the compilation unit if !path::path_is_absolute(arg) { let cu = codemap::span_to_filename(sp, cx.codemap()); diff --git a/src/libsyntax/parse.rs b/src/libsyntax/parse.rs index c6535bd1a4d3c..65f7de6ea1608 100644 --- a/src/libsyntax/parse.rs +++ b/src/libsyntax/parse.rs @@ -46,14 +46,11 @@ fn parse_crate_from_crate_file(input: str, cfg: ast::crate_cfg, let lo = p.span.lo; let prefix = path::dirname(p.reader.filemap.name); let leading_attrs = p.parse_inner_attrs_and_next(); - let crate_attrs = leading_attrs.inner; - let first_cdir_attr = leading_attrs.next; + let { inner: crate_attrs, next: first_cdir_attr } = leading_attrs; let cdirs = p.parse_crate_directives(token::EOF, first_cdir_attr); sess.chpos = p.reader.chpos; sess.byte_pos = sess.byte_pos + p.reader.pos; - let cx = - @{sess: sess, - cfg: p.cfg}; + let cx = @{sess: sess, cfg: /* FIXME: bad */ copy p.cfg}; let (companionmod, _) = path::splitext(path::basename(input)); let (m, attrs) = eval::eval_crate_directives_to_mod( cx, cdirs, prefix, option::some(companionmod)); @@ -63,7 +60,7 @@ fn parse_crate_from_crate_file(input: str, cfg: ast::crate_cfg, {directives: cdirs, module: m, attrs: crate_attrs + attrs, - config: p.cfg}); + config: /* FIXME: bad */ copy p.cfg}); } fn parse_crate_from_source_file(input: str, cfg: ast::crate_cfg, @@ -131,7 +128,7 @@ fn next_node_id(sess: parse_sess) -> node_id { } fn new_parser_from_source_str(sess: parse_sess, cfg: ast::crate_cfg, - name: str, ss: codemap::file_substr, + +name: str, +ss: codemap::file_substr, source: @str) -> parser { let ftype = parser::SOURCE_FILE; let filemap = codemap::new_filemap_w_substr @@ -143,20 +140,17 @@ fn new_parser_from_source_str(sess: parse_sess, cfg: ast::crate_cfg, ret parser(sess, cfg, rdr, ftype); } -fn new_parser_from_file(sess: parse_sess, cfg: ast::crate_cfg, path: str, +fn new_parser_from_file(sess: parse_sess, cfg: ast::crate_cfg, +path: str, ftype: parser::file_type) -> parser { - let src = alt io::read_whole_file_str(path) { - result::ok(src) { - // FIXME: This copy is unfortunate (#2319) - @src - } - result::err(e) { - sess.span_diagnostic.handler().fatal(e) - } - }; - let filemap = codemap::new_filemap(path, src, - sess.chpos, sess.byte_pos); + let res = io::read_whole_file_str(path); + alt res { + result::ok(_) { /* Continue. */ } + result::err(e) { sess.span_diagnostic.handler().fatal(e); } + } + // FIXME: This copy is unfortunate (#2319). + let src = @copy result::unwrap(res); + let filemap = codemap::new_filemap(path, src, sess.chpos, sess.byte_pos); sess.cm.files.push(filemap); let itr = @interner::mk(str::hash, str::eq); let rdr = lexer::new_reader(sess.span_diagnostic, filemap, itr);