mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

convert syntax::attr to use @~strs

Browse Source
This commit is contained in:
Erick Tryzelaar 2013-02-14 20:19:27 -08:00
parent 1808d747f6
commit a2b754788d
16 changed files with 130 additions and 132 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/librustc/back/link.rs
View File

@ -466,14 +466,14 @@ fn provided_link_metas(sess: Session, c: &ast::crate) ->
let linkage_metas = attr::find_linkage_metas(c.node.attrs);
attr::require_unique_names(sess.diagnostic(), linkage_metas);
for linkage_metas.each |meta| {
if attr::get_meta_item_name(*meta) == ~"name" {
if *attr::get_meta_item_name(*meta) == ~"name" {
match attr::get_meta_item_value_str(*meta) {
// Changing attr would avoid the need for the copy
// here
Some(v) => { name = Some(v.to_managed()); }
None => cmh_items.push(*meta)
}
} else if attr::get_meta_item_name(*meta) == ~"vers" {
} else if *attr::get_meta_item_name(*meta) == ~"vers" {
match attr::get_meta_item_value_str(*meta) {
Some(v) => { vers = Some(v.to_managed()); }
None => cmh_items.push(*meta)

22
src/librustc/driver/driver.rs
View File

@ -97,16 +97,16 @@ pub fn default_configuration(sess: Session, +argv0: ~str, input: input) ->
};
return ~[ // Target bindings.
attr::mk_word_item(str::from_slice(os::FAMILY)),
mk(~"target_os", tos),
mk(~"target_family", str::from_slice(os::FAMILY)),
mk(~"target_arch", arch),
mk(~"target_endian", end),
mk(~"target_word_size", wordsz),
mk(~"target_libc", libc),
attr::mk_word_item(@str::from_slice(os::FAMILY)),
mk(@~"target_os", @tos),
mk(@~"target_family", @str::from_slice(os::FAMILY)),
mk(@~"target_arch", @arch),
mk(@~"target_endian", @end),
mk(@~"target_word_size", @wordsz),
mk(@~"target_libc", @libc),
// Build bindings.
mk(~"build_compiler", argv0),
mk(~"build_input", source_name(input))];
mk(@~"build_compiler", @argv0),
mk(@~"build_input", @source_name(input))];
}
pub fn append_configuration(+cfg: ast::crate_cfg, +name: ~str)
@ -114,7 +114,7 @@ pub fn append_configuration(+cfg: ast::crate_cfg, +name: ~str)
if attr::contains_name(cfg, name) {
cfg
} else {
vec::append_one(cfg, attr::mk_word_item(name))
vec::append_one(cfg, attr::mk_word_item(@name))
}
}
@ -142,7 +142,7 @@ pub fn parse_cfgspecs(cfgspecs: ~[~str]) -> ast::crate_cfg {
// meta_word variant.
let mut words = ~[];
for cfgspecs.each |s| {
words.push(attr::mk_word_item(/*bad*/copy *s));
words.push(attr::mk_word_item(@/*bad*/copy *s));
}
return words;
}

2
src/librustc/driver/session.rs
View File

@ -310,7 +310,7 @@ pub fn building_library(req_crate_type: crate_type,
match syntax::attr::first_attr_value_str_by_name(
crate.node.attrs,
~"crate_type") {
option::Some(~"lib") => true,
Some(@~"lib") => true,
_ => false
}
}

8
src/librustc/front/test.rs
View File

@ -57,7 +57,7 @@ pub fn modify_for_testing(sess: session::Session,
// configuration, either with the '--test' or '--cfg test'
// command line options.
let should_test = attr::contains(crate.node.config,
attr::mk_word_item(~"test"));
attr::mk_word_item(@~"test"));
if should_test {
generate_test_harness(sess, crate)
@ -111,7 +111,7 @@ fn fold_mod(cx: @mut TestCtxt,
fn nomain(cx: @mut TestCtxt, item: @ast::item) -> @ast::item {
if !*cx.sess.building_library {
@ast::item{attrs: item.attrs.filtered(|attr| {
attr::get_attr_name(attr) != ~"main"
*attr::get_attr_name(attr) != ~"main"
}),.. copy *item}
} else { item }
}
@ -310,7 +310,7 @@ pub fn main() {
// This attribute tells resolve to let us call unexported functions
let resolve_unexported_attr =
attr::mk_attr(attr::mk_word_item(~"!resolve_unexported"));
attr::mk_attr(attr::mk_word_item(@~"!resolve_unexported"));
let item = ast::item {
ident: cx.sess.ident_of(~"__test"),
@ -366,7 +366,7 @@ fn is_std(cx: &TestCtxt) -> bool {
let is_std = {
let items = attr::find_linkage_metas(cx.crate.node.attrs);
match attr::last_meta_item_value_str_by_name(items, ~"name") {
Some(~"std") => true,
Some(@~"std") => true,
_ => false
}
};

21
src/librustc/metadata/creader.rs
View File

@ -105,7 +105,7 @@ fn warn_if_multiple_versions(e: @mut Env,
diag.span_note(match_.span, ~"used here");
let attrs = ~[
attr::mk_attr(attr::mk_list_item(
~"link", /*bad*/copy *match_.metas))
@~"link", /*bad*/copy *match_.metas))
];
loader::note_linkage_attrs(e.intr, diag, attrs);
}
@ -133,7 +133,7 @@ fn visit_crate(e: @mut Env, c: ast::crate) {
for link_args.each |a| {
match attr::get_meta_item_value_str(attr::attr_meta(*a)) {
Some(ref linkarg) => {
cstore::add_used_link_args(cstore, (/*bad*/copy *linkarg));
cstore::add_used_link_args(cstore, **linkarg);
}
None => {/* fallthrough */ }
}
@ -173,21 +173,22 @@ fn visit_item(e: @mut Env, i: @ast::item) {
match attr::first_attr_value_str_by_name(i.attrs,
~"link_name") {
Some(ref nn) => {
if (*nn) == ~"" {
if **nn == ~"" {
e.diag.span_fatal(
i.span,
~"empty #[link_name] not allowed; use #[nolink].");
}
(/*bad*/copy *nn)
}
None => /*bad*/copy *e.intr.get(i.ident)
None => @/*bad*/copy *e.intr.get(i.ident)
};
if attr::find_attrs_by_name(i.attrs, ~"nolink").is_empty() {
already_added =
!cstore::add_used_library(cstore, copy foreign_name);
!cstore::add_used_library(cstore,
/*bad*/ copy *foreign_name);
}
if !link_args.is_empty() && already_added {
e.diag.span_fatal(i.span, ~"library '" + foreign_name +
e.diag.span_fatal(i.span, ~"library '" + *foreign_name +
~"' already added: can't specify link_args.");
}
}
@ -197,7 +198,7 @@ fn visit_item(e: @mut Env, i: @ast::item) {
for link_args.each |a| {
match attr::get_meta_item_value_str(attr::attr_meta(*a)) {
Some(ref linkarg) => {
cstore::add_used_link_args(cstore, *linkarg);
cstore::add_used_link_args(cstore, /*bad*/copy **linkarg);
}
None => {/* fallthrough */ }
}
@ -211,7 +212,7 @@ fn metas_with(+ident: ~str, +key: ~str, +metas: ~[@ast::meta_item])
-> ~[@ast::meta_item] {
let name_items = attr::find_meta_items_by_name(metas, key);
if name_items.is_empty() {
vec::append_one(metas, attr::mk_name_value_item_str(key, ident))
vec::append_one(metas, attr::mk_name_value_item_str(@key, @ident))
} else {
metas
}
@ -276,9 +277,9 @@ fn resolve_crate(e: @mut Env,
match attr::last_meta_item_value_str_by_name(load_ctxt.metas,
~"name") {
option::Some(ref v) => (/*bad*/copy *v),
option::None => /*bad*/copy *e.intr.get(ident)
option::None => @/*bad*/copy *e.intr.get(ident)
};
let cmeta = @{name: cname, data: cdata,
let cmeta = @{name: /*bad*/copy *cname, data: cdata,
cnum_map: cnum_map, cnum: cnum};
let cstore = e.cstore;

8
src/librustc/metadata/decoder.rs
View File

@ -962,7 +962,7 @@ fn get_meta_items(md: ebml::Doc) -> ~[@ast::meta_item] {
for reader::tagged_docs(md, tag_meta_item_word) |meta_item_doc| {
let nd = reader::get_doc(meta_item_doc, tag_meta_item_name);
let n = str::from_bytes(reader::doc_data(nd));
items.push(attr::mk_word_item(n));
items.push(attr::mk_word_item(@n));
};
for reader::tagged_docs(md, tag_meta_item_name_value) |meta_item_doc| {
let nd = reader::get_doc(meta_item_doc, tag_meta_item_name);
@ -971,13 +971,13 @@ fn get_meta_items(md: ebml::Doc) -> ~[@ast::meta_item] {
let v = str::from_bytes(reader::doc_data(vd));
// FIXME (#623): Should be able to decode meta_name_value variants,
// but currently the encoder just drops them
items.push(attr::mk_name_value_item_str(n, v));
items.push(attr::mk_name_value_item_str(@n, @v));
};
for reader::tagged_docs(md, tag_meta_item_list) |meta_item_doc| {
let nd = reader::get_doc(meta_item_doc, tag_meta_item_name);
let n = str::from_bytes(reader::doc_data(nd));
let subitems = get_meta_items(meta_item_doc);
items.push(attr::mk_list_item(n, subitems));
items.push(attr::mk_list_item(@n, subitems));
};
return items;
}
@ -1073,7 +1073,7 @@ pub fn get_crate_vers(data: @~[u8]) -> ~str {
let attrs = decoder::get_crate_attributes(data);
return match attr::last_meta_item_value_str_by_name(
attr::find_linkage_metas(attrs), ~"vers") {
Some(ref ver) => (/*bad*/copy *ver),
Some(ref ver) => (/*bad*/copy **ver),
None => ~"0.0"
};
}

12
src/librustc/metadata/encoder.rs
View File

@ -1075,11 +1075,11 @@ fn synthesize_link_attr(ecx: @encode_ctxt, +items: ~[@meta_item]) ->
assert !ecx.link_meta.vers.is_empty();
let name_item =
attr::mk_name_value_item_str(~"name",
ecx.link_meta.name.to_owned());
attr::mk_name_value_item_str(@~"name",
@ecx.link_meta.name.to_owned());
let vers_item =
attr::mk_name_value_item_str(~"vers",
ecx.link_meta.vers.to_owned());
attr::mk_name_value_item_str(@~"vers",
@ecx.link_meta.vers.to_owned());
let other_items =
{
@ -1088,7 +1088,7 @@ fn synthesize_link_attr(ecx: @encode_ctxt, +items: ~[@meta_item]) ->
};
let meta_items = vec::append(~[name_item, vers_item], other_items);
let link_item = attr::mk_list_item(~"link", meta_items);
let link_item = attr::mk_list_item(@~"link", meta_items);
return attr::mk_attr(link_item);
}
@ -1097,7 +1097,7 @@ fn synthesize_link_attr(ecx: @encode_ctxt, +items: ~[@meta_item]) ->
let mut found_link_attr = false;
for crate.node.attrs.each |attr| {
attrs.push(
if attr::get_attr_name(attr) != ~"link" {
if *attr::get_attr_name(attr) != ~"link" {
/*bad*/copy *attr
} else {
match /*bad*/copy attr.node.value.node {

2
src/librustc/metadata/loader.rs
View File

@ -147,7 +147,7 @@ pub fn crate_name_from_metas(+metas: ~[@ast::meta_item]) -> ~str {
match vec::last_opt(name_items) {
Some(i) => {
match attr::get_meta_item_value_str(i) {
Some(ref n) => (/*bad*/copy *n),
Some(ref n) => /*bad*/copy **n,
// FIXME (#2406): Probably want a warning here since the user
// is using the wrong type of meta item.
_ => fail!()

2
src/librustc/middle/trans/foreign.rs
View File

@ -50,7 +50,7 @@ fn abi_info(arch: session::arch) -> cabi::ABIInfo {
pub fn link_name(ccx: @crate_ctxt, i: @ast::foreign_item) -> ~str {
match attr::first_attr_value_str_by_name(i.attrs, ~"link_name") {
None => ccx.sess.str_of(i.ident),
option::Some(ref ln) => (/*bad*/copy *ln)
option::Some(ref ln) => (/*bad*/copy **ln)
}
}

5
src/librustdoc/attr_parser.rs
View File

@ -65,9 +65,10 @@ fn doc_metas(
pub fn parse_crate(attrs: ~[ast::attribute]) -> CrateAttrs {
let link_metas = attr::find_linkage_metas(attrs);
let name = attr::last_meta_item_value_str_by_name(link_metas, ~"name");
CrateAttrs {
name: attr::last_meta_item_value_str_by_name(link_metas, ~"name")
name: name.map(|s| copy **s)
}
}
@ -97,7 +98,7 @@ fn should_not_extract_crate_name_if_no_name_value_in_link_attribute() {
pub fn parse_desc(attrs: ~[ast::attribute]) -> Option<~str> {
let doc_strs = do doc_metas(attrs).filter_mapped |meta| {
attr::get_meta_item_value_str(*meta)
attr::get_meta_item_value_str(*meta).map(|s| copy **s)
};
if doc_strs.is_empty() {
None

4
src/librustpkg/util.rs
View File

@ -81,7 +81,7 @@ fn fold_mod(_ctx: @ReadyCtx, m: ast::_mod,
fn strip_main(item: @ast::item) -> @ast::item {
@ast::item {
attrs: do item.attrs.filtered |attr| {
attr::get_attr_name(*attr) != ~"main"
*attr::get_attr_name(attr) != ~"main"
},
.. copy *item
}
@ -609,7 +609,7 @@ pub fn compile_input(sysroot: Option<Path>, input: driver::input, dir: &Path,
let mut crate_cfg = options.cfg;
for cfgs.each |&cfg| {
crate_cfg.push(attr::mk_word_item(cfg));
crate_cfg.push(attr::mk_word_item(@cfg));
}
let options = @{

142
src/libsyntax/attr.rs
View File

@ -29,24 +29,24 @@
/* Constructors */
pub fn mk_name_value_item_str(name: ~str, value: ~str)
pub fn mk_name_value_item_str(name: @~str, value: @~str)
-> @ast::meta_item {
let value_lit = dummy_spanned(ast::lit_str(@value));
return mk_name_value_item(name, value_lit);
let value_lit = dummy_spanned(ast::lit_str(value));
mk_name_value_item(name, value_lit)
}
pub fn mk_name_value_item(name: ~str, +value: ast::lit)
pub fn mk_name_value_item(name: @~str, +value: ast::lit)
-> @ast::meta_item {
return @dummy_spanned(ast::meta_name_value(name, value));
@dummy_spanned(ast::meta_name_value(/*bad*/ copy *name, value))
}
pub fn mk_list_item(name: ~str, +items: ~[@ast::meta_item]) ->
pub fn mk_list_item(name: @~str, +items: ~[@ast::meta_item]) ->
@ast::meta_item {
return @dummy_spanned(ast::meta_list(name, items));
@dummy_spanned(ast::meta_list(/*bad*/ copy *name, items))
}
pub fn mk_word_item(name: ~str) -> @ast::meta_item {
return @dummy_spanned(ast::meta_word(name));
pub fn mk_word_item(name: @~str) -> @ast::meta_item {
@dummy_spanned(ast::meta_word(/*bad*/ copy *name))
}
pub fn mk_attr(item: @ast::meta_item) -> ast::attribute {
@ -80,9 +80,9 @@ pub fn attr_metas(attrs: ~[ast::attribute]) -> ~[@ast::meta_item] {
pub fn desugar_doc_attr(attr: &ast::attribute) -> ast::attribute {
if attr.node.is_sugared_doc {
let comment = get_meta_item_value_str(@attr.node.value).get();
let meta = mk_name_value_item_str(~"doc",
strip_doc_comment_decoration(comment));
return mk_attr(meta);
let meta = mk_name_value_item_str(@~"doc",
@strip_doc_comment_decoration(*comment));
mk_attr(meta)
} else {
*attr
}
@ -90,15 +90,15 @@ pub fn desugar_doc_attr(attr: &ast::attribute) -> ast::attribute {
/* Accessors */
pub fn get_attr_name(attr: &ast::attribute) -> ~str {
pub pure fn get_attr_name(attr: &ast::attribute) -> @~str {
get_meta_item_name(@attr.node.value)
}
pub fn get_meta_item_name(meta: @ast::meta_item) -> ~str {
pub pure fn get_meta_item_name(meta: @ast::meta_item) -> @~str {
match meta.node {
ast::meta_word(ref n) => (*n),
ast::meta_name_value(ref n, _) => (*n),
ast::meta_list(ref n, _) => (*n)
ast::meta_word(ref n) => @/*bad*/ copy *n,
ast::meta_name_value(ref n, _) => @/*bad*/ copy *n,
ast::meta_list(ref n, _) => @/*bad*/ copy *n,
}
}
@ -106,13 +106,15 @@ pub fn get_meta_item_name(meta: @ast::meta_item) -> ~str {
* Gets the string value if the meta_item is a meta_name_value variant
* containing a string, otherwise none
*/
pub fn get_meta_item_value_str(meta: @ast::meta_item) -> Option<~str> {
pub fn get_meta_item_value_str(meta: @ast::meta_item) -> Option<@~str> {
match meta.node {
ast::meta_name_value(_, v) => match v.node {
ast::lit_str(s) => option::Some(*s),
_ => option::None
ast::meta_name_value(_, v) => {
match v.node {
ast::lit_str(s) => Some(s),
_ => None,
}
},
_ => option::None
_ => None
}
}
@ -130,11 +132,11 @@ pub fn get_meta_item_list(meta: @ast::meta_item)
* a tuple containing the name and string value, otherwise `none`
*/
pub fn get_name_value_str_pair(item: @ast::meta_item)
-> Option<(~str, ~str)> {
-> Option<(@~str, @~str)> {
match attr::get_meta_item_value_str(item) {
Some(ref value) => {
Some(value) => {
let name = attr::get_meta_item_name(item);
Some((name, (*value)))
Some((name, value))
}
None => None
}
@ -147,7 +149,7 @@ pub fn get_name_value_str_pair(item: @ast::meta_item)
pub fn find_attrs_by_name(attrs: &[ast::attribute], name: &str) ->
~[ast::attribute] {
do vec::filter_mapped(attrs) |a| {
if name == get_attr_name(a) {
if name == *get_attr_name(a) {
Some(*a)
} else {
None
@ -160,7 +162,7 @@ pub fn find_meta_items_by_name(metas: &[@ast::meta_item], name: &str) ->
~[@ast::meta_item] {
let mut rs = ~[];
for metas.each |mi| {
if name == get_meta_item_name(*mi) {
if name == *get_meta_item_name(*mi) {
rs.push(*mi)
}
}
@ -213,36 +215,39 @@ pub fn attrs_contains_name(attrs: &[ast::attribute], name: &str) -> bool {
!find_attrs_by_name(attrs, name).is_empty()
}
pub fn first_attr_value_str_by_name(attrs: ~[ast::attribute], name: ~str)
-> Option<~str> {
pub fn first_attr_value_str_by_name(attrs: ~[ast::attribute], name: &str)
-> Option<@~str> {
let mattrs = find_attrs_by_name(attrs, name);
if vec::len(mattrs) > 0u {
return get_meta_item_value_str(attr_meta(mattrs[0]));
if mattrs.len() > 0 {
get_meta_item_value_str(attr_meta(mattrs[0]))
} else {
None
}
return option::None;
}
fn last_meta_item_by_name(items: ~[@ast::meta_item], name: ~str)
fn last_meta_item_by_name(items: ~[@ast::meta_item], name: &str)
-> Option<@ast::meta_item> {
let items = attr::find_meta_items_by_name(items, name);
vec::last_opt(items)
}
pub fn last_meta_item_value_str_by_name(items: ~[@ast::meta_item], name: ~str)
-> Option<~str> {
pub fn last_meta_item_value_str_by_name(items: ~[@ast::meta_item], name: &str)
-> Option<@~str> {
match last_meta_item_by_name(items, name) {
Some(item) => match attr::get_meta_item_value_str(item) {
Some(ref value) => Some((*value)),
Some(item) => {
match attr::get_meta_item_value_str(item) {
Some(value) => Some(value),
None => None
}
},
None => None
},
None => None
}
}
pub fn last_meta_item_list_by_name(items: ~[@ast::meta_item], name: ~str)
pub fn last_meta_item_list_by_name(items: ~[@ast::meta_item], name: &str)
-> Option<~[@ast::meta_item]> {
match last_meta_item_by_name(items, name) {
@ -255,20 +260,11 @@ pub fn last_meta_item_list_by_name(items: ~[@ast::meta_item], name: ~str)
/* Higher-level applications */
pub fn sort_meta_items(+items: ~[@ast::meta_item]) -> ~[@ast::meta_item] {
pure fn lteq(ma: &@ast::meta_item, mb: &@ast::meta_item) -> bool {
pure fn key(m: &ast::meta_item) -> ~str {
match m.node {
ast::meta_word(ref name) => (*name),
ast::meta_name_value(ref name, _) => (*name),
ast::meta_list(ref name, _) => (*name)
}
}
key(*ma) <= key(*mb)
}
// This is sort of stupid here, converting to a vec of mutables and back
let mut v = items;
std::sort::quick_sort(v, lteq);
do std::sort::quick_sort(v) |ma, mb| {
get_meta_item_name(*ma) <= get_meta_item_name(*mb)
}
// There doesn't seem to be a more optimal way to do this
do v.map |&m| {
@ -282,14 +278,14 @@ pub fn sort_meta_items(+items: ~[@ast::meta_item]) -> ~[@ast::meta_item] {
}
}
pub fn remove_meta_items_by_name(items: ~[@ast::meta_item], name: ~str) ->
pub fn remove_meta_items_by_name(items: ~[@ast::meta_item], name: &str) ->
~[@ast::meta_item] {
return vec::filter_mapped(items, |item| {
if get_meta_item_name(*item) != name {
option::Some(*item)
if name != *get_meta_item_name(*item) {
Some(*item)
} else {
option::None
None
}
});
}
@ -310,21 +306,21 @@ pub fn find_linkage_metas(attrs: &[ast::attribute]) -> ~[@ast::meta_item] {
pub fn foreign_abi(attrs: ~[ast::attribute])
-> Either<~str, ast::foreign_abi> {
return match attr::first_attr_value_str_by_name(attrs, ~"abi") {
option::None => {
either::Right(ast::foreign_abi_cdecl)
}
option::Some(~"rust-intrinsic") => {
either::Right(ast::foreign_abi_rust_intrinsic)
}
option::Some(~"cdecl") => {
either::Right(ast::foreign_abi_cdecl)
}
option::Some(~"stdcall") => {
either::Right(ast::foreign_abi_stdcall)
}
option::Some(ref t) => {
either::Left(~"unsupported abi: " + (*t))
}
None => {
Right(ast::foreign_abi_cdecl)
}
Some(@~"rust-intrinsic") => {
Right(ast::foreign_abi_rust_intrinsic)
}
Some(@~"cdecl") => {
Right(ast::foreign_abi_cdecl)
}
Some(@~"stdcall") => {
Right(ast::foreign_abi_stdcall)
}
Some(t) => {
Left(~"unsupported abi: " + *t)
}
};
}
@ -371,9 +367,9 @@ pub fn require_unique_names(diagnostic: span_handler,
let name = get_meta_item_name(*meta);
// FIXME: How do I silence the warnings? --pcw (#2619)
if !set.insert(copy name) {
if !set.insert(name) {
diagnostic.span_fatal(meta.span,
fmt!("duplicate meta item `%s`", name));
fmt!("duplicate meta item `%s`", *name));
}
}
}

4
src/libsyntax/ext/auto_encode.rs
View File

@ -114,7 +114,7 @@ pub fn expand_auto_encode(
in_items: ~[@ast::item]
) -> ~[@ast::item] {
fn is_auto_encode(a: &ast::attribute) -> bool {
attr::get_attr_name(a) == ~"auto_encode"
*attr::get_attr_name(a) == ~"auto_encode"
}
fn filter_attrs(item: @ast::item) -> @ast::item {
@ -169,7 +169,7 @@ pub fn expand_auto_decode(
in_items: ~[@ast::item]
) -> ~[@ast::item] {
fn is_auto_decode(a: &ast::attribute) -> bool {
attr::get_attr_name(a) == ~"auto_decode"
*attr::get_attr_name(a) == ~"auto_decode"
}
fn filter_attrs(item: @ast::item) -> @ast::item {

4
src/libsyntax/ext/expand.rs
View File

@ -102,11 +102,11 @@ pub fn expand_mod_items(exts: SyntaxExtensions, cx: ext_ctxt,
do vec::foldr(item.attrs, ~[*item]) |attr, items| {
let mname = attr::get_attr_name(attr);
match exts.find(&mname) {
match exts.find(&*mname) {
None | Some(NormalTT(_)) | Some(ItemTT(*)) => items,
Some(ItemDecorator(dec_fn)) => {
cx.bt_push(ExpandedFrom({call_site: attr.span,
callie: {name: copy mname,
callie: {name: /*bad*/ copy *mname,
span: None}}));
let r = dec_fn(cx, attr.span, attr.node.value, items);
cx.bt_pop();

14
src/libsyntax/parse/parser.rs
View File

@ -3247,11 +3247,11 @@ fn parse_item_mod(outer_attrs: ~[ast::attribute]) -> item_info {
// on the mod, then we'll go and suck in another file and merge
// its contents
match ::attr::first_attr_value_str_by_name(outer_attrs, ~"merge") {
Some(ref path) => {
Some(path) => {
let prefix = Path(
self.sess.cm.span_to_filename(copy self.span));
let prefix = prefix.dir_path();
let path = Path((*path));
let path = Path(copy *path);
let (new_mod_item, new_attrs) = self.eval_src_mod_from_path(
prefix, path, ~[], id_span);
@ -3280,7 +3280,7 @@ fn push_mod_path(id: ident, attrs: ~[ast::attribute]) {
let file_path = match ::attr::first_attr_value_str_by_name(
attrs, ~"path") {
Some(ref d) => (*d),
Some(d) => copy *d,
None => copy *default_path
};
self.mod_path_stack.push(file_path)
@ -3300,10 +3300,10 @@ fn eval_src_mod(id: ast::ident,
let default_path = self.sess.interner.get(id) + ~".rs";
let file_path = match ::attr::first_attr_value_str_by_name(
outer_attrs, ~"path") {
Some(ref d) => {
let path = Path(*d);
Some(d) => {
let path = Path(copy *d);
if !path.is_absolute {
mod_path.push(*d)
mod_path.push(copy *d)
} else {
path
}
@ -3337,7 +3337,7 @@ fn eval_src_mod_from_path(prefix: Path, path: Path,
fn cdir_path_opt(default: ~str, attrs: ~[ast::attribute]) -> ~str {
match ::attr::first_attr_value_str_by_name(attrs, ~"path") {
Some(ref d) => (*d),
Some(d) => copy *d,
None => default
}
}

8
src/libsyntax/print/pprust.rs
View File

@ -897,7 +897,7 @@ pub fn print_attribute(s: @ps, attr: ast::attribute) {
if attr.node.is_sugared_doc {
let meta = attr::attr_meta(attr);
let comment = attr::get_meta_item_value_str(meta).get();
word(s.s, comment);
word(s.s, *comment);
} else {
word(s.s, ~"#[");
print_meta_item(s, @attr.node.value);
@ -1816,14 +1816,14 @@ fn printParam(s: @ps, param: ast::ty_param) {
pub fn print_meta_item(s: @ps, &&item: @ast::meta_item) {
ibox(s, indent_unit);
match item.node {
ast::meta_word(ref name) => word(s.s, (*name)),
ast::meta_word(ref name) => word(s.s, *name),
ast::meta_name_value(ref name, value) => {
word_space(s, (*name));
word_space(s, *name);
word_space(s, ~"=");
print_literal(s, @value);
}
ast::meta_list(ref name, ref items) => {
word(s.s, (*name));
word(s.s, *name);
popen(s);
commasep(
s,