bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

auto merge of #7902 : huonw/rust/attr++, r=cmr,pcwalton

Browse source 
This does a number of things, but especially dramatically reduce the
number of allocations performed for operations involving attributes/
meta items:

- Converts ast::meta_item & ast::attribute and other associated enums
  to CamelCase.
- Converts several standalone functions in syntax::attr into methods,
  defined on two traits AttrMetaMethods & AttributeMethods. The former
  is common to both MetaItem and Attribute since the latter is a thin
  wrapper around the former.
- Deletes functions that are unnecessary due to iterators.
- Converts other standalone functions to use iterators and the generic
  AttrMetaMethods rather than allocating a lot of new vectors (e.g. the
  old code would have to allocate a new vector to use functions that
  operated on &[meta_item] on &[attribute].)
- Moves the core algorithm of the #[cfg] matching to syntax::attr,
  similar to find_inline_attr and find_linkage_metas.

This doesn't have much of an effect on the speed of #[cfg] stripping,
despite hugely reducing the number of allocations performed; presumably
most of the time is spent in the ast folder rather than doing attribute
checks.

Also fixes the Eq instance of MetaItem_ to correctly ignore spans, so
that `rustc --cfg 'foo(bar)'` now works.
This commit is contained in:
bors 2013-07-20 20:25:31 -07:00
commit d029ebfc5f
60 changed files with 738 additions and 821 deletions
Download patch file Download diff file Expand all files Collapse all files

27
src/librustc/back/link.rs
View file

@ -36,6 +36,7 @@ use std::vec;
use syntax::ast;
use syntax::ast_map::{path, path_mod, path_name};
use syntax::attr;
use syntax::attr::{AttrMetaMethods};
use syntax::print::pprust;
use syntax::parse::token;
@ -502,7 +503,7 @@ pub fn build_link_meta(sess: Session,
struct ProvidedMetas {
name: Option<@str>,
vers: Option<@str>,
cmh_items: ~[@ast::meta_item]
cmh_items: ~[@ast::MetaItem]
}
fn provided_link_metas(sess: Session, c: &ast::crate) ->
@ -513,19 +514,11 @@ pub fn build_link_meta(sess: Session,
let linkage_metas = attr::find_linkage_metas(c.node.attrs);
attr::require_unique_names(sess.diagnostic(), linkage_metas);
for linkage_metas.iter().advance |meta| {
match attr::get_meta_item_value_str(*meta) {
Some(value) => {
let item_name : &str = attr::get_meta_item_name(*meta);
match item_name {
// Changing attr would avoid the need for the copy
// here
"name" => name = Some(value),
"vers" => vers = Some(value),
match meta.name_str_pair() {
Some((n, value)) if "name" == n => name = Some(value),
Some((n, value)) if "vers" == n => vers = Some(value),
_ => cmh_items.push(*meta)
}
},
None => cmh_items.push(*meta)
}
}
ProvidedMetas {
@ -537,7 +530,7 @@ pub fn build_link_meta(sess: Session,
// This calculates CMH as defined above
fn crate_meta_extras_hash(symbol_hasher: &mut hash::State,
cmh_items: ~[@ast::meta_item],
cmh_items: ~[@ast::MetaItem],
dep_hashes: ~[@str]) -> @str {
fn len_and_str(s: &str) -> ~str {
fmt!("%u_%s", s.len(), s)
@ -549,16 +542,16 @@ pub fn build_link_meta(sess: Session,
let cmh_items = attr::sort_meta_items(cmh_items);
fn hash(symbol_hasher: &mut hash::State, m: &@ast::meta_item) {
fn hash(symbol_hasher: &mut hash::State, m: &@ast::MetaItem) {
match m.node {
ast::meta_name_value(key, value) => {
ast::MetaNameValue(key, value) => {
write_string(symbol_hasher, len_and_str(key));
write_string(symbol_hasher, len_and_str_lit(value));
}
ast::meta_word(name) => {
ast::MetaWord(name) => {
write_string(symbol_hasher, len_and_str(name));
}
ast::meta_list(name, ref mis) => {
ast::MetaList(name, ref mis) => {
write_string(symbol_hasher, len_and_str(name));
for mis.iter().advance |m_| {
hash(symbol_hasher, m_);

39
src/librustc/driver/driver.rs
View file

@ -34,6 +34,7 @@ use extra::getopts;
use syntax::ast;
use syntax::abi;
use syntax::attr;
use syntax::attr::{AttrMetaMethods};
use syntax::codemap;
use syntax::diagnostic;
use syntax::parse;
@ -95,12 +96,9 @@ pub fn default_configuration(sess: Session, argv0: @str, input: &input) ->
mk(@"build_input", source_name(input))];
}
pub fn append_configuration(cfg: ast::crate_cfg, name: @str)
-> ast::crate_cfg {
if attr::contains_name(cfg, name) {
cfg
} else {
vec::append_one(cfg, attr::mk_word_item(name))
pub fn append_configuration(cfg: &mut ast::crate_cfg, name: @str) {
if !cfg.iter().any(|mi| mi.name() == name) {
cfg.push(attr::mk_word_item(name))
}
}
@ -109,18 +107,11 @@ pub fn build_configuration(sess: Session, argv0: @str, input: &input) ->
// Combine the configuration requested by the session (command line) with
// some default and generated configuration items
let default_cfg = default_configuration(sess, argv0, input);
let user_cfg = sess.opts.cfg.clone();
let mut user_cfg = sess.opts.cfg.clone();
// If the user wants a test runner, then add the test cfg
let user_cfg = if sess.opts.test {
append_configuration(user_cfg, @"test")
} else {
user_cfg
};
if sess.opts.test { append_configuration(&mut user_cfg, @"test") }
// If the user requested GC, then add the GC cfg
let user_cfg = append_configuration(
user_cfg,
if sess.opts.gc { @"gc" } else { @"nogc" });
append_configuration(&mut user_cfg, if sess.opts.gc { @"gc" } else { @"nogc" });
return vec::append(user_cfg, default_cfg);
}
@ -130,7 +121,7 @@ fn parse_cfgspecs(cfgspecs: ~[~str],
do cfgspecs.consume_iter().transform |s| {
let sess = parse::new_parse_sess(Some(demitter));
parse::parse_meta_from_source_str(@"cfgspec", s.to_managed(), ~[], sess)
}.collect()
}.collect::<ast::crate_cfg>()
}
pub enum input {
@ -215,6 +206,7 @@ pub fn compile_rest(sess: Session,
crate = time(time_passes, ~"configuration 2", ||
front::config::strip_unconfigured_items(crate));
crate = time(time_passes, ~"maybe building test harness", ||
front::test::modify_for_testing(sess, crate));
}
@ -870,7 +862,7 @@ pub struct OutputFilenames {
pub fn build_output_filenames(input: &input,
odir: &Option<Path>,
ofile: &Option<Path>,
attrs: &[ast::attribute],
attrs: &[ast::Attribute],
sess: Session)
-> @OutputFilenames {
let obj_path;
@ -912,13 +904,11 @@ pub fn build_output_filenames(input: &input,
let linkage_metas = attr::find_linkage_metas(attrs);
if !linkage_metas.is_empty() {
// But if a linkage meta is present, that overrides
let maybe_matches = attr::find_meta_items_by_name(linkage_metas, "name");
if !maybe_matches.is_empty() {
match attr::get_meta_item_value_str(maybe_matches[0]) {
let maybe_name = linkage_metas.iter().find_(|m| "name" == m.name());
match maybe_name.chain(|m| m.value_str()) {
Some(s) => stem = s,
_ => ()
}
}
// If the name is missing, we just default to the filename
// version
}
@ -1011,7 +1001,8 @@ mod test {
@"rustc", matches, diagnostic::emit);
let sess = build_session(sessopts, diagnostic::emit);
let cfg = build_configuration(sess, @"whatever", &str_input(@""));
let test_items = attr::find_meta_items_by_name(cfg, "test");
assert_eq!(test_items.len(), 1u);
let mut test_items = cfg.iter().filter(|m| "test" == m.name());
assert!(test_items.next().is_some());
assert!(test_items.next().is_none());
}
}

15
src/librustc/driver/session.rs
View file

@ -369,7 +369,7 @@ pub fn building_library(req_crate_type: crate_type,
match syntax::attr::first_attr_value_str_by_name(
crate.node.attrs,
"crate_type") {
Some(s) if "lib" == s => true,
Some(s) => "lib" == s,
_ => false
}
}
@ -395,18 +395,11 @@ mod test {
use driver::session::{unknown_crate};
use syntax::ast;
use syntax::attr;
use syntax::codemap;
fn make_crate_type_attr(t: @str) -> ast::attribute {
codemap::respan(codemap::dummy_sp(), ast::attribute_ {
style: ast::attr_outer,
value: @codemap::respan(codemap::dummy_sp(),
ast::meta_name_value(
@"crate_type",
codemap::respan(codemap::dummy_sp(),
ast::lit_str(t)))),
is_sugared_doc: false
})
fn make_crate_type_attr(t: @str) -> ast::Attribute {
attr::mk_attr(attr::mk_name_value_item_str(@"crate_type", t))
}
fn make_crate(with_bin: bool, with_lib: bool) -> @ast::crate {

31
src/librustc/front/config.rs
View file

@ -12,7 +12,7 @@
use std::option;
use syntax::{ast, fold, attr};
type in_cfg_pred = @fn(attrs: &[ast::attribute]) -> bool;
type in_cfg_pred = @fn(attrs: &[ast::Attribute]) -> bool;
struct Context {
in_cfg: in_cfg_pred
@ -175,31 +175,6 @@ fn trait_method_in_cfg(cx: @Context, meth: &ast::trait_method) -> bool {
// Determine if an item should be translated in the current crate
// configuration based on the item's attributes
fn in_cfg(cfg: &[@ast::meta_item], attrs: &[ast::attribute]) -> bool {
metas_in_cfg(cfg, attr::attr_metas(attrs))
}
pub fn metas_in_cfg(cfg: &[@ast::meta_item],
metas: &[@ast::meta_item]) -> bool {
// The "cfg" attributes on the item
let cfg_metas = attr::find_meta_items_by_name(metas, "cfg");
// Pull the inner meta_items from the #[cfg(meta_item, ...)] attributes,
// so we can match against them. This is the list of configurations for
// which the item is valid
let cfg_metas = cfg_metas.consume_iter()
.filter_map(|i| attr::get_meta_item_list(i))
.collect::<~[~[@ast::meta_item]]>();
if cfg_metas.iter().all(|c| c.is_empty()) { return true; }
cfg_metas.iter().any(|cfg_meta| {
cfg_meta.iter().all(|cfg_mi| {
match cfg_mi.node {
ast::meta_list(s, ref it) if "not" == s
=> it.iter().all(|mi| !attr::contains(cfg, *mi)),
_ => attr::contains(cfg, *cfg_mi)
}
})
})
fn in_cfg(cfg: &[@ast::MetaItem], attrs: &[ast::Attribute]) -> bool {
attr::test_cfg(cfg, attrs.iter().transform(|x| *x))
}

16
src/librustc/front/std_inject.rs
View file

@ -30,10 +30,10 @@ pub fn maybe_inject_libstd_ref(sess: Session, crate: @ast::crate)
}
fn use_std(crate: &ast::crate) -> bool {
!attr::attrs_contains_name(crate.node.attrs, "no_std")
!attr::contains_name(crate.node.attrs, "no_std")
}
fn no_prelude(attrs: &[ast::attribute]) -> bool {
attr::attrs_contains_name(attrs, "no_implicit_prelude")
fn no_prelude(attrs: &[ast::Attribute]) -> bool {
attr::contains_name(attrs, "no_implicit_prelude")
}
fn inject_libstd_ref(sess: Session, crate: &ast::crate) -> @ast::crate {
@ -48,14 +48,8 @@ fn inject_libstd_ref(sess: Session, crate: &ast::crate) -> @ast::crate {
node: ast::view_item_extern_mod(
sess.ident_of("std"), ~[], n1),
attrs: ~[
spanned(ast::attribute_ {
style: ast::attr_inner,
value: @spanned(ast::meta_name_value(
@"vers",
spanned(ast::lit_str(STD_VERSION.to_managed()))
)),
is_sugared_doc: false
})
attr::mk_attr(
attr::mk_name_value_item_str(@"vers", STD_VERSION.to_managed()))
],
vis: ast::private,
span: dummy_sp()

55
src/librustc/front/test.rs
View file

@ -23,6 +23,7 @@ use syntax::ext::base::ExtCtxt;
use syntax::fold;
use syntax::print::pprust;
use syntax::{ast, ast_util};
use syntax::attr::AttrMetaMethods;
type node_id_gen = @fn() -> ast::node_id;
@ -50,8 +51,7 @@ pub fn modify_for_testing(sess: session::Session,
// We generate the test harness when building in the 'test'
// configuration, either with the '--test' or '--cfg test'
// command line options.
let should_test = attr::contains(crate.node.config,
attr::mk_word_item(@"test"));
let should_test = attr::contains_name(crate.node.config, "test");
if should_test {
generate_test_harness(sess, crate)
@ -95,8 +95,8 @@ fn strip_test_functions(crate: &ast::crate) -> @ast::crate {
// When not compiling with --test we should not compile the
// #[test] functions
do config::strip_items(crate) |attrs| {
!attr::contains_name(attr::attr_metas(attrs), "test") &&
!attr::contains_name(attr::attr_metas(attrs), "bench")
!attr::contains_name(attrs, "test") &&
!attr::contains_name(attrs, "bench")
}
}
@ -111,7 +111,7 @@ fn fold_mod(cx: @mut TestCtxt,
if !*cx.sess.building_library {
@ast::item {
attrs: do item.attrs.iter().filter_map |attr| {
if "main" != attr::get_attr_name(attr) {
if "main" != attr.name() {
Some(*attr)
} else {
None
@ -180,8 +180,7 @@ fn fold_item(cx: @mut TestCtxt, i: @ast::item, fld: @fold::ast_fold)
}
fn is_test_fn(cx: @mut TestCtxt, i: @ast::item) -> bool {
let has_test_attr = !attr::find_attrs_by_name(i.attrs,
"test").is_empty();
let has_test_attr = attr::contains_name(i.attrs, "test");
fn has_test_signature(i: @ast::item) -> bool {
match &i.node {
@ -205,11 +204,12 @@ fn is_test_fn(cx: @mut TestCtxt, i: @ast::item) -> bool {
"functions used as tests must have signature fn() -> ()."
);
}
return has_test_attr && has_test_signature(i);
}
fn is_bench_fn(i: @ast::item) -> bool {
let has_bench_attr = !attr::find_attrs_by_name(i.attrs, "bench").is_empty();
let has_bench_attr = attr::contains_name(i.attrs, "bench");
fn has_test_signature(i: @ast::item) -> bool {
match i.node {
@ -233,21 +233,17 @@ fn is_bench_fn(i: @ast::item) -> bool {
}
fn is_ignored(cx: @mut TestCtxt, i: @ast::item) -> bool {
let ignoreattrs = attr::find_attrs_by_name(i.attrs, "ignore");
let ignoreitems = attr::attr_metas(ignoreattrs);
return if !ignoreitems.is_empty() {
let cfg_metas = ignoreitems.consume_iter()
.filter_map(|i| attr::get_meta_item_list(i))
.collect::<~[~[@ast::meta_item]]>()
.concat_vec();
config::metas_in_cfg(cx.crate.node.config.clone(), cfg_metas)
} else {
false
do i.attrs.iter().any |attr| {
// check ignore(cfg(foo, bar))
"ignore" == attr.name() && match attr.meta_item_list() {
Some(ref cfgs) => attr::test_cfg(cx.crate.node.config, cfgs.iter().transform(|x| *x)),
None => true
}
}
}
fn should_fail(i: @ast::item) -> bool {
!attr::find_attrs_by_name(i.attrs, "should_fail").is_empty()
attr::contains_name(i.attrs, "should_fail")
}
fn add_test_module(cx: &TestCtxt, m: &ast::_mod) -> ast::_mod {
@ -278,19 +274,15 @@ mod __test {
*/
fn mk_std(cx: &TestCtxt) -> ast::view_item {
let vers = ast::lit_str(@"0.8-pre");
let vers = nospan(vers);
let mi = ast::meta_name_value(@"vers", vers);
let mi = nospan(mi);
let id_std = cx.sess.ident_of("extra");
let vi = if is_std(cx) {
let id_extra = cx.sess.ident_of("extra");
let vi = if is_extra(cx) {
ast::view_item_use(
~[@nospan(ast::view_path_simple(id_std,
path_node(~[id_std]),
~[@nospan(ast::view_path_simple(id_extra,
path_node(~[id_extra]),
cx.sess.next_node_id()))])
} else {
ast::view_item_extern_mod(id_std, ~[@mi],
cx.sess.next_node_id())
let mi = attr::mk_name_value_item_str(@"vers", @"0.8-pre");
ast::view_item_extern_mod(id_extra, ~[mi], cx.sess.next_node_id())
};
ast::view_item {
node: vi,
@ -377,15 +369,12 @@ fn mk_tests(cx: &TestCtxt) -> @ast::item {
)).get()
}
fn is_std(cx: &TestCtxt) -> bool {
let is_std = {
fn is_extra(cx: &TestCtxt) -> bool {
let items = attr::find_linkage_metas(cx.crate.node.attrs);
match attr::last_meta_item_value_str_by_name(items, "name") {
Some(s) if "extra" == s => true,
_ => false
}
};
return is_std;
}
fn mk_test_descs(cx: &TestCtxt) -> @ast::expr {

42
src/librustc/metadata/creader.rs
View file

@ -18,6 +18,7 @@ use metadata::loader;
use std::hashmap::HashMap;
use syntax::attr;
use syntax::attr::AttrMetaMethods;
use syntax::codemap::{span, dummy_sp};
use syntax::diagnostic::span_handler;
use syntax::parse::token;
@ -59,7 +60,7 @@ struct cache_entry {
cnum: int,
span: span,
hash: @str,
metas: @~[@ast::meta_item]
metas: @~[@ast::MetaItem]
}
fn dump_crates(crate_cache: &[cache_entry]) {
@ -123,10 +124,9 @@ struct Env {
fn visit_crate(e: &Env, c: &ast::crate) {
let cstore = e.cstore;
let link_args = attr::find_attrs_by_name(c.node.attrs, "link_args");
for link_args.iter().advance |a| {
match attr::get_meta_item_value_str(attr::attr_meta(*a)) {
for c.node.attrs.iter().filter(|m| "link_args" == m.name()).advance |a| {
match a.value_str() {
Some(ref linkarg) => {
cstore::add_used_link_args(cstore, *linkarg);
}
@ -160,13 +160,17 @@ fn visit_item(e: &Env, i: @ast::item) {
let cstore = e.cstore;
let mut already_added = false;
let link_args = attr::find_attrs_by_name(i.attrs, "link_args");
let link_args = i.attrs.iter()
.filter_map(|at| if "link_args" == at.name() {Some(at)} else {None})
.collect::<~[&ast::Attribute]>();
match fm.sort {
ast::named => {
let foreign_name =
match attr::first_attr_value_str_by_name(i.attrs,
"link_name") {
let link_name = i.attrs.iter()
.find_(|at| "link_name" == at.name())
.chain(|at| at.value_str());
let foreign_name = match link_name {
Some(nn) => {
if nn.is_empty() {
e.diag.span_fatal(
@ -178,7 +182,7 @@ fn visit_item(e: &Env, i: @ast::item) {
}
None => token::ident_to_str(&i.ident)
};
if attr::find_attrs_by_name(i.attrs, "nolink").is_empty() {
if !attr::contains_name(i.attrs, "nolink") {
already_added =
!cstore::add_used_library(cstore, foreign_name);
}
@ -190,8 +194,8 @@ fn visit_item(e: &Env, i: @ast::item) {
ast::anonymous => { /* do nothing */ }
}
for link_args.iter().advance |a| {
match attr::get_meta_item_value_str(attr::attr_meta(*a)) {
for link_args.iter().advance |m| {
match m.value_str() {
Some(linkarg) => {
cstore::add_used_link_args(cstore, linkarg);
}
@ -203,21 +207,21 @@ fn visit_item(e: &Env, i: @ast::item) {
}
}
fn metas_with(ident: @str, key: @str, mut metas: ~[@ast::meta_item])
-> ~[@ast::meta_item] {
let name_items = attr::find_meta_items_by_name(metas, key);
if name_items.is_empty() {
fn metas_with(ident: @str, key: @str, mut metas: ~[@ast::MetaItem])
-> ~[@ast::MetaItem] {
// Check if key isn't there yet.
if !attr::contains_name(metas, key) {
metas.push(attr::mk_name_value_item_str(key, ident));
}
metas
}
fn metas_with_ident(ident: @str, metas: ~[@ast::meta_item])
-> ~[@ast::meta_item] {
fn metas_with_ident(ident: @str, metas: ~[@ast::MetaItem])
-> ~[@ast::MetaItem] {
metas_with(ident, @"name", metas)
}
fn existing_match(e: &Env, metas: &[@ast::meta_item], hash: &str)
fn existing_match(e: &Env, metas: &[@ast::MetaItem], hash: &str)
-> Option<int> {
for e.crate_cache.iter().advance |c| {
if loader::metadata_matches(*c.metas, metas)
@ -230,7 +234,7 @@ fn existing_match(e: &Env, metas: &[@ast::meta_item], hash: &str)
fn resolve_crate(e: @mut Env,
ident: ast::ident,
metas: ~[@ast::meta_item],
metas: ~[@ast::MetaItem],
hash: @str,
span: span)
-> ast::crate_num {

2
src/librustc/metadata/csearch.rs
View file

@ -151,7 +151,7 @@ pub fn get_static_methods_if_impl(cstore: @mut cstore::CStore,
pub fn get_item_attrs(cstore: @mut cstore::CStore,
def_id: ast::def_id,
f: &fn(~[@ast::meta_item])) {
f: &fn(~[@ast::MetaItem])) {
let cdata = cstore::get_crate_data(cstore, def_id.crate);
decoder::get_item_attrs(cdata, def_id.node, f)
}

18
src/librustc/metadata/decoder.rs
View file

@ -975,7 +975,7 @@ pub fn get_static_methods_if_impl(intr: @ident_interner,
pub fn get_item_attrs(cdata: cmd,
node_id: ast::node_id,
f: &fn(~[@ast::meta_item])) {
f: &fn(~[@ast::MetaItem])) {
let item = lookup_item(node_id, cdata.data);
for reader::tagged_docs(item, tag_attributes) |attributes| {
@ -1082,8 +1082,8 @@ fn item_family_to_str(fam: Family) -> ~str {
}
}
fn get_meta_items(md: ebml::Doc) -> ~[@ast::meta_item] {
let mut items: ~[@ast::meta_item] = ~[];
fn get_meta_items(md: ebml::Doc) -> ~[@ast::MetaItem] {
let mut items: ~[@ast::MetaItem] = ~[];
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 = nd.as_str_slice().to_managed();
@ -1094,7 +1094,7 @@ fn get_meta_items(md: ebml::Doc) -> ~[@ast::meta_item] {
let vd = reader::get_doc(meta_item_doc, tag_meta_item_value);
let n = nd.as_str_slice().to_managed();
let v = vd.as_str_slice().to_managed();
// FIXME (#623): Should be able to decode meta_name_value variants,
// 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));
};
@ -1107,8 +1107,8 @@ fn get_meta_items(md: ebml::Doc) -> ~[@ast::meta_item] {
return items;
}
fn get_attributes(md: ebml::Doc) -> ~[ast::attribute] {
let mut attrs: ~[ast::attribute] = ~[];
fn get_attributes(md: ebml::Doc) -> ~[ast::Attribute] {
let mut attrs: ~[ast::Attribute] = ~[];
match reader::maybe_get_doc(md, tag_attributes) {
option::Some(attrs_d) => {
for reader::tagged_docs(attrs_d, tag_attribute) |attr_doc| {
@ -1119,8 +1119,8 @@ fn get_attributes(md: ebml::Doc) -> ~[ast::attribute] {
let meta_item = meta_items[0];
attrs.push(
codemap::spanned {
node: ast::attribute_ {
style: ast::attr_outer,
node: ast::Attribute_ {
style: ast::AttrOuter,
value: meta_item,
is_sugared_doc: false,
},
@ -1154,7 +1154,7 @@ fn list_crate_attributes(intr: @ident_interner, md: ebml::Doc, hash: &str,
out.write_str("\n\n");
}
pub fn get_crate_attributes(data: @~[u8]) -> ~[ast::attribute] {
pub fn get_crate_attributes(data: @~[u8]) -> ~[ast::Attribute] {
return get_attributes(reader::Doc(data));
}

48
src/librustc/metadata/encoder.rs
View file

@ -35,6 +35,7 @@ use syntax::ast;
use syntax::ast_map;
use syntax::ast_util::*;
use syntax::attr;
use syntax::attr::AttrMetaMethods;
use syntax::diagnostic::span_handler;
use syntax::parse::token::special_idents;
use syntax::{ast_util, visit};
@ -792,10 +793,11 @@ fn purity_static_method_family(p: purity) -> char {
}
fn should_inline(attrs: &[attribute]) -> bool {
match attr::find_inline_attr(attrs) {
attr::ia_none | attr::ia_never => false,
attr::ia_hint | attr::ia_always => true
fn should_inline(attrs: &[Attribute]) -> bool {
use syntax::attr::*;
match find_inline_attr(attrs) {
InlineNone | InlineNever => false,
InlineHint | InlineAlways => true
}
}
@ -1294,16 +1296,16 @@ fn write_int(writer: @io::Writer, &n: &int) {
writer.write_be_u32(n as u32);
}
fn encode_meta_item(ebml_w: &mut writer::Encoder, mi: @meta_item) {
fn encode_meta_item(ebml_w: &mut writer::Encoder, mi: @MetaItem) {
match mi.node {
meta_word(name) => {
MetaWord(name) => {
ebml_w.start_tag(tag_meta_item_word);
ebml_w.start_tag(tag_meta_item_name);
ebml_w.writer.write(name.as_bytes());
ebml_w.end_tag();
ebml_w.end_tag();
}
meta_name_value(name, value) => {
MetaNameValue(name, value) => {
match value.node {
lit_str(value) => {
ebml_w.start_tag(tag_meta_item_name_value);
@ -1318,7 +1320,7 @@ fn encode_meta_item(ebml_w: &mut writer::Encoder, mi: @meta_item) {
_ => {/* FIXME (#623): encode other variants */ }
}
}
meta_list(name, ref items) => {
MetaList(name, ref items) => {
ebml_w.start_tag(tag_meta_item_list);
ebml_w.start_tag(tag_meta_item_name);
ebml_w.writer.write(name.as_bytes());
@ -1331,7 +1333,7 @@ fn encode_meta_item(ebml_w: &mut writer::Encoder, mi: @meta_item) {
}
}
fn encode_attributes(ebml_w: &mut writer::Encoder, attrs: &[attribute]) {
fn encode_attributes(ebml_w: &mut writer::Encoder, attrs: &[Attribute]) {
ebml_w.start_tag(tag_attributes);
for attrs.iter().advance |attr| {
ebml_w.start_tag(tag_attribute);
@ -1346,10 +1348,10 @@ fn encode_attributes(ebml_w: &mut writer::Encoder, attrs: &[attribute]) {
// 'name' and 'vers' items, so if the user didn't provide them we will throw
// them in anyway with default values.
fn synthesize_crate_attrs(ecx: &EncodeContext,
crate: &crate) -> ~[attribute] {
crate: &crate) -> ~[Attribute] {
fn synthesize_link_attr(ecx: &EncodeContext, items: ~[@meta_item]) ->
attribute {
fn synthesize_link_attr(ecx: &EncodeContext, items: ~[@MetaItem]) ->
Attribute {
assert!(!ecx.link_meta.name.is_empty());
assert!(!ecx.link_meta.vers.is_empty());
@ -1361,29 +1363,29 @@ fn synthesize_crate_attrs(ecx: &EncodeContext,
attr::mk_name_value_item_str(@"vers",
ecx.link_meta.vers);
let other_items =
{
let tmp = attr::remove_meta_items_by_name(items, "name");
attr::remove_meta_items_by_name(tmp, "vers")
};
let mut meta_items = ~[name_item, vers_item];
let meta_items = vec::append(~[name_item, vers_item], other_items);
for items.iter()
.filter(|mi| "name" != mi.name() && "vers" != mi.name())
.advance |&mi| {
meta_items.push(mi);
}
let link_item = attr::mk_list_item(@"link", meta_items);
return attr::mk_attr(link_item);
}
let mut attrs: ~[attribute] = ~[];
let mut attrs = ~[];
let mut found_link_attr = false;
for crate.node.attrs.iter().advance |attr| {
attrs.push(
if "link" != attr::get_attr_name(attr) {
if "link" != attr.name() {
*attr
} else {
match attr.node.value.node {
meta_list(_, ref l) => {
match attr.meta_item_list() {
Some(l) => {
found_link_attr = true;;
synthesize_link_attr(ecx, (*l).clone())
synthesize_link_attr(ecx, l.to_owned())
}
_ => *attr
}

32
src/librustc/metadata/loader.rs
View file

@ -22,6 +22,7 @@ use syntax::parse::token;
use syntax::parse::token::ident_interner;
use syntax::print::pprust;
use syntax::{ast, attr};
use syntax::attr::AttrMetaMethods;
use std::cast;
use std::io;
@ -46,7 +47,7 @@ pub struct Context {
filesearch: @FileSearch,
span: span,
ident: ast::ident,
metas: ~[@ast::meta_item],
metas: ~[@ast::MetaItem],
hash: @str,
os: os,
is_static: bool,
@ -55,7 +56,7 @@ pub struct Context {
pub fn load_library_crate(cx: &Context) -> (~str, @~[u8]) {
match find_library_crate(cx) {
Some(ref t) => return (/*bad*/(*t).clone()),
Some(t) => t,
None => {
cx.diag.span_fatal(cx.span,
fmt!("can't find crate for `%s`",
@ -140,15 +141,11 @@ fn find_library_crate_aux(
}
}
pub fn crate_name_from_metas(metas: &[@ast::meta_item]) -> @str {
pub fn crate_name_from_metas(metas: &[@ast::MetaItem]) -> @str {
for metas.iter().advance |m| {
match m.node {
ast::meta_name_value(s, ref l) if s == @"name" =>
match l.node {
ast::lit_str(s) => return s,
_ => ()
},
_ => ()
match m.name_str_pair() {
Some((name, s)) if "name" == name => { return s; }
_ => {}
}
}
fail!("expected to find the crate name")
@ -156,7 +153,7 @@ pub fn crate_name_from_metas(metas: &[@ast::meta_item]) -> @str {
pub fn note_linkage_attrs(intr: @ident_interner,
diag: @span_handler,
attrs: ~[ast::attribute]) {
attrs: ~[ast::Attribute]) {
let r = attr::find_linkage_metas(attrs);
for r.iter().advance |mi| {
diag.handler().note(fmt!("meta: %s", pprust::meta_item_to_str(*mi,intr)));
@ -164,7 +161,7 @@ pub fn note_linkage_attrs(intr: @ident_interner,
}
fn crate_matches(crate_data: @~[u8],
metas: &[@ast::meta_item],
metas: &[@ast::MetaItem],
hash: @str) -> bool {
let attrs = decoder::get_crate_attributes(crate_data);
let linkage_metas = attr::find_linkage_metas(attrs);
@ -175,18 +172,15 @@ fn crate_matches(crate_data: @~[u8],
metadata_matches(linkage_metas, metas)
}
pub fn metadata_matches(extern_metas: &[@ast::meta_item],
local_metas: &[@ast::meta_item]) -> bool {
pub fn metadata_matches(extern_metas: &[@ast::MetaItem],
local_metas: &[@ast::MetaItem]) -> bool {
debug!("matching %u metadata requirements against %u items",
local_metas.len(), extern_metas.len());
for local_metas.iter().advance |needed| {
if !attr::contains(extern_metas, *needed) {
return false;
do local_metas.iter().all |needed| {
attr::contains(extern_metas, *needed)
}
}
return true;
}
fn get_metadata_section(os: os,

6
src/librustc/middle/entry.rs
View file

@ -13,9 +13,9 @@ use driver::session;
use driver::session::Session;
use syntax::parse::token::special_idents;
use syntax::ast::{crate, node_id, item, item_fn};
use syntax::attr;
use syntax::codemap::span;
use syntax::visit::{default_visitor, mk_vt, vt, Visitor, visit_crate, visit_item};
use syntax::attr::{attrs_contains_name};
use syntax::ast_map;
use std::util;
@ -90,7 +90,7 @@ fn find_item(item: @item, ctxt: @mut EntryContext, visitor: EntryVisitor) {
}
}
if attrs_contains_name(item.attrs, "main") {
if attr::contains_name(item.attrs, "main") {
if ctxt.attr_main_fn.is_none() {
ctxt.attr_main_fn = Some((item.id, item.span));
} else {
@ -100,7 +100,7 @@ fn find_item(item: @item, ctxt: @mut EntryContext, visitor: EntryVisitor) {
}
}
if attrs_contains_name(item.attrs, "start") {
if attr::contains_name(item.attrs, "start") {
if ctxt.start_fn.is_none() {
ctxt.start_fn = Some((item.id, item.span));
} else {

5
src/librustc/middle/kind.rs
View file

@ -17,7 +17,7 @@ use util::ppaux::{Repr, ty_to_str};
use util::ppaux::UserString;
use syntax::ast::*;
use syntax::attr::attrs_contains_name;
use syntax::attr;
use syntax::codemap::span;
use syntax::print::pprust::expr_to_str;
use syntax::{visit, ast_util};
@ -113,7 +113,7 @@ fn check_block(block: &blk, (cx, visitor): (Context, visit::vt<Context>)) {
fn check_item(item: @item, (cx, visitor): (Context, visit::vt<Context>)) {
// If this is a destructor, check kinds.
if !attrs_contains_name(item.attrs, "unsafe_destructor") {
if !attr::contains_name(item.attrs, "unsafe_destructor") {
match item.node {
item_impl(_, Some(ref trait_ref), ref self_type, _) => {
match cx.tcx.def_map.find(&trait_ref.ref_id) {
@ -578,4 +578,3 @@ pub fn check_cast_for_escaping_regions(
cx.tcx.region_maps.is_subregion_of(r_sub, r_sup)
}
}

17
src/librustc/middle/lang_items.rs
View file

@ -23,9 +23,9 @@
use driver::session::Session;
use metadata::csearch::each_lang_item;
use metadata::cstore::iter_crate_data;
use syntax::ast::{crate, def_id, lit_str, meta_item};
use syntax::ast::{meta_list, meta_name_value, meta_word};
use syntax::ast::{crate, def_id, MetaItem};
use syntax::ast_util::local_def;
use syntax::attr::AttrMetaMethods;
use syntax::visit::{default_simple_visitor, mk_simple_visitor, SimpleVisitor};
use syntax::visit::visit_crate;
@ -360,17 +360,12 @@ impl<'self> LanguageItemCollector<'self> {
pub fn match_and_collect_meta_item(&mut self,
item_def_id: def_id,
meta_item: &meta_item) {
match meta_item.node {
meta_name_value(key, literal) => {
match literal.node {
lit_str(value) => {
meta_item: &MetaItem) {
match meta_item.name_str_pair() {
Some((key, value)) => {
self.match_and_collect_item(item_def_id, key, value);
}
_ => {} // Skip.
}
}
meta_word(*) | meta_list(*) => {} // Skip.
None => {} // skip
}
}

34
src/librustc/middle/lint.rs
View file

@ -26,6 +26,7 @@ use std::u64;
use std::u8;
use extra::smallintmap::SmallIntMap;
use syntax::attr;
use syntax::attr::AttrMetaMethods;
use syntax::codemap::span;
use syntax::codemap;
use syntax::{ast, visit, ast_util};
@ -417,7 +418,7 @@ impl Context {
* current lint context, call the provided function, then reset the
* lints in effect to their previous state.
*/
fn with_lint_attrs(@mut self, attrs: &[ast::attribute], f: &fn()) {
fn with_lint_attrs(@mut self, attrs: &[ast::Attribute], f: &fn()) {
// Parse all of the lint attributes, and then add them all to the
// current dictionary of lint information. Along the way, keep a history
// of what we changed so we can roll everything back after invoking the
@ -454,18 +455,14 @@ impl Context {
}
// detect doc(hidden)
let mut doc_hidden = false;
let r = attr::find_attrs_by_name(attrs, "doc");
for r.iter().advance |attr| {
match attr::get_meta_item_list(attr.node.value) {
Some(s) => {
if attr::find_meta_items_by_name(s, "hidden").len() > 0 {
doc_hidden = true;
}
}
None => {}
}
let mut doc_hidden = do attrs.iter().any |attr| {
"doc" == attr.name() &&
match attr.meta_item_list() {
Some(l) => attr::contains_name(l, "hidden"),
None => false // not of the form #[doc(...)]
}
};
if doc_hidden && !self.doc_hidden {
self.doc_hidden = true;
} else {
@ -517,16 +514,15 @@ impl Context {
}
pub fn each_lint(sess: session::Session,
attrs: &[ast::attribute],
f: &fn(@ast::meta_item, level, @str) -> bool) -> bool {
attrs: &[ast::Attribute],
f: &fn(@ast::MetaItem, level, @str) -> bool) -> bool {
let xs = [allow, warn, deny, forbid];
for xs.iter().advance |&level| {
let level_name = level_to_str(level);
let attrs = attr::find_attrs_by_name(attrs, level_name);
for attrs.iter().advance |attr| {
for attrs.iter().filter(|m| level_name == m.name()).advance |attr| {
let meta = attr.node.value;
let metas = match meta.node {
ast::meta_list(_, ref metas) => metas,
ast::MetaList(_, ref metas) => metas,
_ => {
sess.span_err(meta.span, "malformed lint attribute");
loop;
@ -534,7 +530,7 @@ pub fn each_lint(sess: session::Session,
};
for metas.iter().advance |meta| {
match meta.node {
ast::meta_word(lintname) => {
ast::MetaWord(lintname) => {
if !f(*meta, level, lintname) {
return false;
}
@ -1035,7 +1031,7 @@ fn lint_unnecessary_allocations() -> visit::vt<@mut Context> {
}
fn lint_missing_doc() -> visit::vt<@mut Context> {
fn check_attrs(cx: @mut Context, attrs: &[ast::attribute],
fn check_attrs(cx: @mut Context, attrs: &[ast::Attribute],
sp: span, msg: &str) {
// If we're building a test harness, then warning about documentation is
// probably not really relevant right now

3
src/librustc/middle/privacy.rs
View file

@ -350,8 +350,7 @@ pub fn check_crate<'mm>(tcx: ty::ctxt,
visit_item: |item, (method_map, visitor)| {
// Do not check privacy inside items with the resolve_unexported
// attribute. This is used for the test runner.
if !attr::contains_name(attr::attr_metas(item.attrs),
"!resolve_unexported") {
if !attr::contains_name(item.attrs, "!resolve_unexported") {
visit::visit_item(item, (method_map, visitor));
}
},

5
src/librustc/middle/reachable.rs
View file

@ -31,8 +31,8 @@ use syntax::visit;
// Returns true if the given set of attributes contains the `#[inline]`
// attribute.
fn attributes_specify_inlining(attrs: &[attribute]) -> bool {
attr::attrs_contains_name(attrs, "inline")
fn attributes_specify_inlining(attrs: &[Attribute]) -> bool {
attr::contains_name(attrs, "inline")
}
// Returns true if the given set of generics implies that the item it's
@ -431,4 +431,3 @@ pub fn find_reachable(tcx: ty::ctxt,
// Return the set of reachable symbols.
reachable_context.reachable_symbols
}

5
src/librustc/middle/resolve.rs
View file

@ -26,7 +26,7 @@ use syntax::ast_util::{def_id_of_def, local_def};
use syntax::ast_util::{path_to_ident, walk_pat, trait_method_to_ty_method};
use syntax::ast_util::{Privacy, Public, Private};
use syntax::ast_util::{variant_visibility_to_privacy, visibility_to_privacy};
use syntax::attr::{attr_metas, contains_name};
use syntax::attr;
use syntax::parse::token;
use syntax::parse::token::ident_interner;
use syntax::parse::token::special_idents;
@ -3476,8 +3476,7 @@ impl Resolver {
// Items with the !resolve_unexported attribute are X-ray contexts.
// This is used to allow the test runner to run unexported tests.
let orig_xray_flag = self.xray_context;
if contains_name(attr_metas(item.attrs),
"!resolve_unexported") {
if attr::contains_name(item.attrs, "!resolve_unexported") {
self.xray_context = Xray;
}

38
src/librustc/middle/trans/base.rs
View file

@ -79,6 +79,7 @@ use syntax::ast::ident;
use syntax::ast_map::{path, path_elt_to_str, path_name};
use syntax::ast_util::{local_def};
use syntax::attr;
use syntax::attr::AttrMetaMethods;
use syntax::codemap::span;
use syntax::parse::token;
use syntax::parse::token::{special_idents};
@ -464,13 +465,14 @@ pub fn set_inline_hint(f: ValueRef) {
}
}
pub fn set_inline_hint_if_appr(attrs: &[ast::attribute],
pub fn set_inline_hint_if_appr(attrs: &[ast::Attribute],
llfn: ValueRef) {
match attr::find_inline_attr(attrs) {
attr::ia_hint => set_inline_hint(llfn),
attr::ia_always => set_always_inline(llfn),
attr::ia_never => set_no_inline(llfn),
attr::ia_none => { /* fallthrough */ }
use syntax::attr::*;
match find_inline_attr(attrs) {
InlineHint => set_inline_hint(llfn),
InlineAlways => set_always_inline(llfn),
InlineNever => set_no_inline(llfn),
InlineNone => { /* fallthrough */ }
}
}
@ -1844,7 +1846,7 @@ pub fn trans_closure(ccx: @mut CrateContext,
self_arg: self_arg,
param_substs: Option<@param_substs>,
id: ast::node_id,
attributes: &[ast::attribute],
attributes: &[ast::Attribute],
output_type: ty::t,
maybe_load_env: &fn(fn_ctxt),
finish: &fn(block)) {
@ -1867,7 +1869,7 @@ pub fn trans_closure(ccx: @mut CrateContext,
let raw_llargs = create_llargs_for_fn_args(fcx, self_arg, decl.inputs);
// Set the fixed stack segment flag if necessary.
if attr::attrs_contains_name(attributes, "fixed_stack_segment") {
if attr::contains_name(attributes, "fixed_stack_segment") {
set_no_inline(fcx.llfn);
set_fixed_stack_segment(fcx.llfn);
}
@ -1925,7 +1927,7 @@ pub fn trans_fn(ccx: @mut CrateContext,
self_arg: self_arg,
param_substs: Option<@param_substs>,
id: ast::node_id,
attrs: &[ast::attribute]) {
attrs: &[ast::Attribute]) {
let the_path_str = path_str(ccx.sess, path);
let _s = StatRecorder::new(ccx, the_path_str);
@ -2195,13 +2197,10 @@ pub fn trans_item(ccx: @mut CrateContext, item: &ast::item) {
// Do static_assert checking. It can't really be done much earlier because we need to get
// the value of the bool out of LLVM
for item.attrs.iter().advance |attr| {
match attr.node.value.node {
ast::meta_word(x) => {
if x.slice(0, x.len()) == "static_assert" {
if "static_assert" == attr.name() {
if m == ast::m_mutbl {
ccx.sess.span_fatal(expr.span,
"cannot have static_assert \
on a mutable static");
"cannot have static_assert on a mutable static");
}
let v = ccx.const_values.get_copy(&item.id);
unsafe {
@ -2210,9 +2209,6 @@ pub fn trans_item(ccx: @mut CrateContext, item: &ast::item) {
}
}
}
},
_ => ()
}
}
},
ast::item_foreign_mod(ref foreign_mod) => {
@ -2257,7 +2253,7 @@ pub fn register_fn(ccx: @mut CrateContext,
sp: span,
path: path,
node_id: ast::node_id,
attrs: &[ast::attribute])
attrs: &[ast::Attribute])
-> ValueRef {
let t = ty::node_id_to_type(ccx.tcx, node_id);
register_fn_full(ccx, sp, path, node_id, attrs, t)
@ -2267,7 +2263,7 @@ pub fn register_fn_full(ccx: @mut CrateContext,
sp: span,
path: path,
node_id: ast::node_id,
attrs: &[ast::attribute],
attrs: &[ast::Attribute],
node_type: ty::t)
-> ValueRef {
let llfty = type_of_fn_from_ty(ccx, node_type);
@ -2279,7 +2275,7 @@ pub fn register_fn_fuller(ccx: @mut CrateContext,
sp: span,
path: path,
node_id: ast::node_id,
attrs: &[ast::attribute],
attrs: &[ast::Attribute],
node_type: ty::t,
cc: lib::llvm::CallConv,
fn_ty: Type)
@ -2288,7 +2284,7 @@ pub fn register_fn_fuller(ccx: @mut CrateContext,
node_id,
ast_map::path_to_str(path, token::get_ident_interner()));
let ps = if attr::attrs_contains_name(attrs, "no_mangle") {
let ps = if attr::contains_name(attrs, "no_mangle") {
path_elt_to_str(*path.last(), token::get_ident_interner())
} else {
mangle_exported_name(ccx, path, node_type)

10
src/librustc/middle/trans/foreign.rs
View file

@ -351,10 +351,10 @@ pub fn trans_foreign_mod(ccx: @mut CrateContext,
cc: lib::llvm::CallConv) {
let llwrapfn = get_item_val(ccx, id);
let tys = shim_types(ccx, id);
if attr::attrs_contains_name(foreign_item.attrs, "rust_stack") {
if attr::contains_name(foreign_item.attrs, "rust_stack") {
build_direct_fn(ccx, llwrapfn, foreign_item,
&tys, cc);
} else if attr::attrs_contains_name(foreign_item.attrs, "fast_ffi") {
} else if attr::contains_name(foreign_item.attrs, "fast_ffi") {
build_fast_ffi_fn(ccx, llwrapfn, foreign_item, &tys, cc);
} else {
let llshimfn = build_shim_fn(ccx, foreign_item, &tys, cc);
@ -546,7 +546,7 @@ pub fn trans_intrinsic(ccx: @mut CrateContext,
item: &ast::foreign_item,
path: ast_map::path,
substs: @param_substs,
attributes: &[ast::attribute],
attributes: &[ast::Attribute],
ref_id: Option<ast::node_id>) {
debug!("trans_intrinsic(item.ident=%s)", ccx.sess.str_of(item.ident));
@ -624,7 +624,7 @@ pub fn trans_intrinsic(ccx: @mut CrateContext,
set_always_inline(fcx.llfn);
// Set the fixed stack segment flag if necessary.
if attr::attrs_contains_name(attributes, "fixed_stack_segment") {
if attr::contains_name(attributes, "fixed_stack_segment") {
set_fixed_stack_segment(fcx.llfn);
}
@ -1146,7 +1146,7 @@ pub fn register_foreign_fn(ccx: @mut CrateContext,
sp: span,
path: ast_map::path,
node_id: ast::node_id,
attrs: &[ast::attribute])
attrs: &[ast::Attribute])
-> ValueRef {
let _icx = push_ctxt("foreign::register_foreign_fn");

2
src/librustc/middle/ty.rs
View file

@ -3980,7 +3980,7 @@ pub fn has_attr(tcx: ctxt, did: def_id, attr: &str) -> bool {
&ast_map::node_item(@ast::item {
attrs: ref attrs,
_
}, _)) => attr::attrs_contains_name(*attrs, attr),
}, _)) => attr::contains_name(*attrs, attr),
_ => tcx.sess.bug(fmt!("has_attr: %? is not an item",
did))
}

35
src/librustdoc/attr_parser.rs
View file

@ -18,24 +18,20 @@ an AST's attributes.
use syntax::ast;
use syntax::attr;
use syntax::attr::{AttrMetaMethods, AttributeMethods};
pub struct CrateAttrs {
name: Option<~str>
}
fn doc_metas(
attrs: ~[ast::attribute]
) -> ~[@ast::meta_item] {
let doc_attrs = attr::find_attrs_by_name(attrs, "doc");
let doc_metas = do doc_attrs.map |attr| {
attr::attr_meta(attr::desugar_doc_attr(attr))
};
return doc_metas;
fn doc_metas(attrs: ~[ast::Attribute]) -> ~[@ast::MetaItem] {
attrs.iter()
.filter(|at| "doc" == at.name())
.transform(|at| at.desugar_doc().meta())
.collect()
}
pub fn parse_crate(attrs: ~[ast::attribute]) -> CrateAttrs {
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");
@ -44,10 +40,10 @@ pub fn parse_crate(attrs: ~[ast::attribute]) -> CrateAttrs {
}
}
pub fn parse_desc(attrs: ~[ast::attribute]) -> Option<~str> {
pub fn parse_desc(attrs: ~[ast::Attribute]) -> Option<~str> {
let doc_strs = do doc_metas(attrs).consume_iter().filter_map |meta| {
attr::get_meta_item_value_str(meta).map(|s| s.to_owned())
}.collect::<~[~str]>();
meta.value_str()
}.collect::<~[@str]>();
if doc_strs.is_empty() {
None
} else {
@ -55,14 +51,11 @@ pub fn parse_desc(attrs: ~[ast::attribute]) -> Option<~str> {
}
}
pub fn parse_hidden(attrs: ~[ast::attribute]) -> bool {
pub fn parse_hidden(attrs: ~[ast::Attribute]) -> bool {
let r = doc_metas(attrs);
do r.iter().any |meta| {
match attr::get_meta_item_list(*meta) {
Some(metas) => {
let hiddens = attr::find_meta_items_by_name(metas, "hidden");
!hiddens.is_empty()
}
match meta.meta_item_list() {
Some(metas) => attr::contains_name(metas, "hidden"),
None => false
}
}
@ -74,7 +67,7 @@ mod test {
use syntax;
use super::{parse_hidden, parse_crate, parse_desc};
fn parse_attributes(source: @str) -> ~[ast::attribute] {
fn parse_attributes(source: @str) -> ~[ast::Attribute] {
use syntax::parse;
use syntax::parse::attr::parser_attr;

6
src/librustdoc/attr_pass.rs
View file

@ -68,7 +68,7 @@ fn fold_crate(
doc::CrateDoc {
topmod: doc::ModDoc {
item: doc::ItemDoc {
name: attrs.name.clone().get_or_default(doc.topmod.name()),
name: attrs.name.clone().get_or_default(doc.topmod.name_()),
.. doc.topmod.item.clone()
},
.. doc.topmod.clone()
@ -102,7 +102,7 @@ fn fold_item(
fn parse_item_attrs<T:Send>(
srv: astsrv::Srv,
id: doc::AstId,
parse_attrs: ~fn(a: ~[ast::attribute]) -> T) -> T {
parse_attrs: ~fn(a: ~[ast::Attribute]) -> T) -> T {
do astsrv::exec(srv) |ctxt| {
let attrs = match ctxt.ast_map.get_copy(&id) {
ast_map::node_item(item, _) => item.attrs.clone(),
@ -249,7 +249,7 @@ mod test {
#[test]
fn should_replace_top_module_name_with_crate_name() {
let doc = mk_doc(~"#[link(name = \"bond\")];");
assert!(doc.cratemod().name() == ~"bond");
assert!(doc.cratemod().name_() == ~"bond");
}
#[test]

8
src/librustdoc/doc.rs
View file

@ -355,7 +355,11 @@ impl Item for StructDoc {
pub trait ItemUtils {
fn id(&self) -> AstId;
fn name(&self) -> ~str;
/// FIXME #5898: This conflicts with
/// syntax::attr::AttrMetaMethods.name; This rustdoc seems to be on
/// the way out so I'm making this one look bad rather than the
/// new methods in attr.
fn name_(&self) -> ~str;
fn path(&self) -> ~[~str];
fn brief(&self) -> Option<~str>;
fn desc(&self) -> Option<~str>;
@ -367,7 +371,7 @@ impl<A:Item> ItemUtils for A {
self.item().id
}
fn name(&self) -> ~str {
fn name_(&self) -> ~str {
self.item().name.clone()
}

28
src/librustdoc/extract.rs
View file

@ -298,21 +298,21 @@ mod test {
#[test]
fn extract_mods() {
let doc = mk_doc(@"mod a { mod b { } mod c { } }");
assert!(doc.cratemod().mods()[0].name() == ~"a");
assert!(doc.cratemod().mods()[0].mods()[0].name() == ~"b");
assert!(doc.cratemod().mods()[0].mods()[1].name() == ~"c");
assert!(doc.cratemod().mods()[0].name_() == ~"a");
assert!(doc.cratemod().mods()[0].mods()[0].name_() == ~"b");
assert!(doc.cratemod().mods()[0].mods()[1].name_() == ~"c");
}
#[test]
fn extract_fns_from_foreign_mods() {
let doc = mk_doc(@"extern { fn a(); }");
assert!(doc.cratemod().nmods()[0].fns[0].name() == ~"a");
assert!(doc.cratemod().nmods()[0].fns[0].name_() == ~"a");
}
#[test]
fn extract_mods_deep() {
let doc = mk_doc(@"mod a { mod b { mod c { } } }");
assert!(doc.cratemod().mods()[0].mods()[0].mods()[0].name() ==
assert!(doc.cratemod().mods()[0].mods()[0].mods()[0].name_() ==
~"c");
}
@ -328,8 +328,8 @@ mod test {
@"fn a() { } \
mod b { fn c() {
} }");
assert!(doc.cratemod().fns()[0].name() == ~"a");
assert!(doc.cratemod().mods()[0].fns()[0].name() == ~"c");
assert!(doc.cratemod().fns()[0].name_() == ~"a");
assert!(doc.cratemod().mods()[0].fns()[0].name_() == ~"c");
}
#[test]
@ -343,7 +343,7 @@ mod test {
let source = @"";
let ast = parse::from_str(source);
let doc = extract(ast, ~"burp");
assert!(doc.cratemod().name() == ~"burp");
assert!(doc.cratemod().name_() == ~"burp");
}
#[test]
@ -351,7 +351,7 @@ mod test {
let source = ~"";
do astsrv::from_str(source) |srv| {
let doc = from_srv(srv, ~"name");
assert!(doc.cratemod().name() == ~"name");
assert!(doc.cratemod().name_() == ~"name");
}
}
@ -359,14 +359,14 @@ mod test {
fn should_extract_const_name_and_id() {
let doc = mk_doc(@"static a: int = 0;");
assert!(doc.cratemod().consts()[0].id() != 0);
assert!(doc.cratemod().consts()[0].name() == ~"a");
assert!(doc.cratemod().consts()[0].name_() == ~"a");
}
#[test]
fn should_extract_enums() {
let doc = mk_doc(@"enum e { v }");
assert!(doc.cratemod().enums()[0].id() != 0);
assert!(doc.cratemod().enums()[0].name() == ~"e");
assert!(doc.cratemod().enums()[0].name_() == ~"e");
}
#[test]
@ -378,7 +378,7 @@ mod test {
#[test]
fn should_extract_traits() {
let doc = mk_doc(@"trait i { fn f(); }");
assert!(doc.cratemod().traits()[0].name() == ~"i");
assert!(doc.cratemod().traits()[0].name_() == ~"i");
}
#[test]
@ -396,13 +396,13 @@ mod test {
#[test]
fn should_extract_tys() {
let doc = mk_doc(@"type a = int;");
assert!(doc.cratemod().types()[0].name() == ~"a");
assert!(doc.cratemod().types()[0].name_() == ~"a");
}
#[test]
fn should_extract_structs() {
let doc = mk_doc(@"struct Foo { field: () }");
assert!(doc.cratemod().structs()[0].name() == ~"Foo");
assert!(doc.cratemod().structs()[0].name_() == ~"Foo");
}
#[test]

4
src/librustdoc/markdown_pass.rs
View file

@ -172,7 +172,7 @@ pub fn header_kind(doc: doc::ItemTag) -> ~str {
}
pub fn header_name(doc: doc::ItemTag) -> ~str {
let fullpath = (doc.path() + &[doc.name()]).connect("::");
let fullpath = (doc.path() + &[doc.name_()]).connect("::");
match &doc {
&doc::ModTag(_) if doc.id() != syntax::ast::crate_node_id => {
fullpath
@ -200,7 +200,7 @@ pub fn header_name(doc: doc::ItemTag) -> ~str {
fmt!("%s for %s%s", trait_part, *self_ty, bounds)
}
_ => {
doc.name()
doc.name_()
}
}
}

6
src/librustdoc/markdown_writer.rs
View file

@ -159,12 +159,12 @@ pub fn make_filename(
config.output_style == config::DocPerMod {
~"index"
} else {
assert!(doc.topmod.name() != ~"");
doc.topmod.name()
assert!(doc.topmod.name_() != ~"");
doc.topmod.name_()
}
}
doc::ItemPage(doc) => {
(doc.path() + &[doc.name()]).connect("_")
(doc.path() + &[doc.name_()]).connect("_")
}
}
};

2
src/librustdoc/page_pass.rs
View file

@ -174,7 +174,7 @@ mod test {
fn should_make_a_page_for_every_mod() {
let doc = mk_doc(~"mod a { }");
// hidden __std_macros module at the start.
assert_eq!(doc.pages.mods()[0].name(), ~"a");
assert_eq!(doc.pages.mods()[0].name_(), ~"a");
}
#[test]

6
src/librustdoc/pass.rs
View file

@ -48,7 +48,7 @@ fn test_run_passes() {
doc::CratePage(doc::CrateDoc{
topmod: doc::ModDoc{
item: doc::ItemDoc {
name: doc.cratemod().name() + "two",
name: doc.cratemod().name_() + "two",
.. doc.cratemod().item.clone()
},
items: ~[],
@ -67,7 +67,7 @@ fn test_run_passes() {
doc::CratePage(doc::CrateDoc{
topmod: doc::ModDoc{
item: doc::ItemDoc {
name: doc.cratemod().name() + "three",
name: doc.cratemod().name_() + "three",
.. doc.cratemod().item.clone()
},
items: ~[],
@ -91,6 +91,6 @@ fn test_run_passes() {
];
let doc = extract::from_srv(srv.clone(), ~"one");
let doc = run_passes(srv, doc, passes);
assert_eq!(doc.cratemod().name(), ~"onetwothree");
assert_eq!(doc.cratemod().name_(), ~"onetwothree");
}
}

4
src/librustdoc/path_pass.rs
View file

@ -68,7 +68,7 @@ fn fold_item(fold: &fold::Fold<Ctxt>, doc: doc::ItemDoc) -> doc::ItemDoc {
fn fold_mod(fold: &fold::Fold<Ctxt>, doc: doc::ModDoc) -> doc::ModDoc {
let is_topmod = doc.id() == ast::crate_node_id;
if !is_topmod { fold.ctxt.path.push(doc.name()); }
if !is_topmod { fold.ctxt.path.push(doc.name_()); }
let doc = fold::default_any_fold_mod(fold, doc);
if !is_topmod { fold.ctxt.path.pop(); }
@ -79,7 +79,7 @@ fn fold_mod(fold: &fold::Fold<Ctxt>, doc: doc::ModDoc) -> doc::ModDoc {
}
fn fold_nmod(fold: &fold::Fold<Ctxt>, doc: doc::NmodDoc) -> doc::NmodDoc {
fold.ctxt.path.push(doc.name());
fold.ctxt.path.push(doc.name_());
let doc = fold::default_seq_fold_nmod(fold, doc);
fold.ctxt.path.pop();

6
src/librustdoc/sort_item_name_pass.rs
View file

@ -17,7 +17,7 @@ use sort_pass;
pub fn mk_pass() -> Pass {
fn by_item_name(item1: &doc::ItemTag, item2: &doc::ItemTag) -> bool {
(*item1).name() <= (*item2).name()
(*item1).name_() <= (*item2).name_()
}
sort_pass::mk_pass(~"sort_item_name", by_item_name)
}
@ -32,7 +32,7 @@ fn test() {
let doc = extract::from_srv(srv.clone(), ~"");
let doc = (mk_pass().f)(srv.clone(), doc);
// hidden __std_macros module at the start.
assert_eq!(doc.cratemod().items[1].name(), ~"y");
assert_eq!(doc.cratemod().items[2].name(), ~"z");
assert_eq!(doc.cratemod().items[1].name_(), ~"y");
assert_eq!(doc.cratemod().items[2].name_(), ~"z");
}
}

16
src/librustdoc/sort_item_type_pass.rs
View file

@ -54,14 +54,14 @@ fn test() {
let doc = extract::from_srv(srv.clone(), ~"");
let doc = (mk_pass().f)(srv.clone(), doc);
// hidden __std_macros module at the start.
assert_eq!(doc.cratemod().items[0].name(), ~"iconst");
assert_eq!(doc.cratemod().items[1].name(), ~"itype");
assert_eq!(doc.cratemod().items[2].name(), ~"ienum");
assert_eq!(doc.cratemod().items[3].name(), ~"istruct");
assert_eq!(doc.cratemod().items[4].name(), ~"itrait");
assert_eq!(doc.cratemod().items[5].name(), ~"__extensions__");
assert_eq!(doc.cratemod().items[6].name(), ~"ifn");
assert_eq!(doc.cratemod().items[0].name_(), ~"iconst");
assert_eq!(doc.cratemod().items[1].name_(), ~"itype");
assert_eq!(doc.cratemod().items[2].name_(), ~"ienum");
assert_eq!(doc.cratemod().items[3].name_(), ~"istruct");
assert_eq!(doc.cratemod().items[4].name_(), ~"itrait");
assert_eq!(doc.cratemod().items[5].name_(), ~"__extensions__");
assert_eq!(doc.cratemod().items[6].name_(), ~"ifn");
// hidden __std_macros module fits here.
assert_eq!(doc.cratemod().items[8].name(), ~"imod");
assert_eq!(doc.cratemod().items[8].name_(), ~"imod");
}
}

18
src/librustdoc/sort_pass.rs
View file

@ -68,7 +68,7 @@ fn fold_mod(
#[test]
fn test() {
fn name_lteq(item1: &doc::ItemTag, item2: &doc::ItemTag) -> bool {
(*item1).name() <= (*item2).name()
(*item1).name_() <= (*item2).name_()
}
let source = ~"mod z { mod y { } fn x() { } } mod w { }";
@ -76,10 +76,10 @@ fn test() {
let doc = extract::from_srv(srv.clone(), ~"");
let doc = (mk_pass(~"", name_lteq).f)(srv.clone(), doc);
// hidden __std_macros module at the start.
assert_eq!(doc.cratemod().mods()[1].name(), ~"w");
assert_eq!(doc.cratemod().mods()[2].items[0].name(), ~"x");
assert_eq!(doc.cratemod().mods()[2].items[1].name(), ~"y");
assert_eq!(doc.cratemod().mods()[2].name(), ~"z");
assert_eq!(doc.cratemod().mods()[1].name_(), ~"w");
assert_eq!(doc.cratemod().mods()[2].items[0].name_(), ~"x");
assert_eq!(doc.cratemod().mods()[2].items[1].name_(), ~"y");
assert_eq!(doc.cratemod().mods()[2].name_(), ~"z");
}
}
@ -94,10 +94,10 @@ fn should_be_stable() {
let doc = extract::from_srv(srv.clone(), ~"");
let doc = (mk_pass(~"", always_eq).f)(srv.clone(), doc);
// hidden __std_macros module at the start.
assert_eq!(doc.cratemod().mods()[1].items[0].name(), ~"b");
assert_eq!(doc.cratemod().mods()[2].items[0].name(), ~"d");
assert_eq!(doc.cratemod().mods()[1].items[0].name_(), ~"b");
assert_eq!(doc.cratemod().mods()[2].items[0].name_(), ~"d");
let doc = (mk_pass(~"", always_eq).f)(srv.clone(), doc);
assert_eq!(doc.cratemod().mods()[1].items[0].name(), ~"b");
assert_eq!(doc.cratemod().mods()[2].items[0].name(), ~"d");
assert_eq!(doc.cratemod().mods()[1].items[0].name_(), ~"b");
assert_eq!(doc.cratemod().mods()[2].items[0].name_(), ~"d");
}
}

35
src/librustpkg/util.rs
View file

@ -14,11 +14,9 @@ use rustc::metadata::filesearch;
use extra::getopts::groups::getopts;
use syntax::ast_util::*;
use syntax::codemap::{dummy_sp, spanned};
use syntax::codemap::dummy_spanned;
use syntax::ext::base::ExtCtxt;
use syntax::{ast, attr, codemap, diagnostic, fold};
use syntax::ast::{meta_name_value, meta_list};
use syntax::attr::{mk_attr};
use syntax::attr::AttrMetaMethods;
use rustc::back::link::output_type_exe;
use rustc::driver::driver::compile_upto;
use rustc::driver::session::{lib_crate, bin_crate};
@ -81,7 +79,7 @@ fn fold_mod(_ctx: @mut ReadyCtx,
fn strip_main(item: @ast::item) -> @ast::item {
@ast::item {
attrs: do item.attrs.iter().filter_map |attr| {
if "main" != attr::get_attr_name(attr) {
if "main" != attr.name() {
Some(*attr)
} else {
None
@ -104,25 +102,27 @@ fn fold_item(ctx: @mut ReadyCtx,
fold: @fold::ast_fold) -> Option<@ast::item> {
ctx.path.push(item.ident);
let attrs = attr::find_attrs_by_name(item.attrs, "pkg_do");
if attrs.len() > 0 {
let mut cmds = ~[];
let mut had_pkg_do = false;
for attrs.iter().advance |attr| {
for item.attrs.iter().advance |attr| {
if "pkg_do" == attr.name() {
had_pkg_do = true;
match attr.node.value.node {
ast::meta_list(_, ref mis) => {
ast::MetaList(_, ref mis) => {
for mis.iter().advance |mi| {
match mi.node {
ast::meta_word(cmd) => cmds.push(cmd.to_owned()),
ast::MetaWord(cmd) => cmds.push(cmd.to_owned()),
_ => {}
};
}
}
_ => cmds.push(~"build")
};
}
}
}
if had_pkg_do {
ctx.fns.push(ListenerFn {
cmds: cmds,
span: item.span,
@ -245,14 +245,13 @@ pub fn compile_input(ctxt: &Ctx,
_ => pkg_id.short_name.clone()
};
debug!("Injecting link name: %s", short_name_to_use);
let link_options =
~[attr::mk_name_value_item_str(@"name", short_name_to_use.to_managed()),
attr::mk_name_value_item_str(@"vers", pkg_id.version.to_str().to_managed())];
crate = @codemap::respan(crate.span, ast::crate_ {
attrs: ~[mk_attr(@dummy_spanned(
meta_list(@"link",
~[@dummy_spanned(meta_name_value(@"name",
mk_string_lit(short_name_to_use.to_managed()))),
@dummy_spanned(meta_name_value(@"vers",
mk_string_lit(pkg_id.version.to_str().to_managed())))])))],
..crate.node.clone()});
attrs: ~[attr::mk_attr(attr::mk_list_item(@"link", link_options))],
.. crate.node.clone()});
}
debug!("calling compile_crate_from_input, out_dir = %s,

75
src/libsyntax/ast.rs
View file

@ -193,26 +193,51 @@ pub enum def {
}
// The set of meta_items that define the compilation environment of the crate,
// The set of MetaItems that define the compilation environment of the crate,
// used to drive conditional compilation
pub type crate_cfg = ~[@meta_item];
pub type crate_cfg = ~[@MetaItem];
pub type crate = spanned<crate_>;
#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
pub struct crate_ {
module: _mod,
attrs: ~[attribute],
attrs: ~[Attribute],
config: crate_cfg,
}
pub type meta_item = spanned<meta_item_>;
pub type MetaItem = spanned<MetaItem_>;
#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
pub enum meta_item_ {
meta_word(@str),
meta_list(@str, ~[@meta_item]),
meta_name_value(@str, lit),
#[deriving(Clone, Encodable, Decodable, IterBytes)]
pub enum MetaItem_ {
MetaWord(@str),
MetaList(@str, ~[@MetaItem]),
MetaNameValue(@str, lit),
}
// can't be derived because the MetaList requires an unordered comparison
impl Eq for MetaItem_ {
fn eq(&self, other: &MetaItem_) -> bool {
match *self {
MetaWord(ref ns) => match *other {
MetaWord(ref no) => (*ns) == (*no),
_ => false
},
MetaNameValue(ref ns, ref vs) => match *other {
MetaNameValue(ref no, ref vo) => {
(*ns) == (*no) && vs.node == vo.node
}
_ => false
},
MetaList(ref ns, ref miss) => match *other {
MetaList(ref no, ref miso) => {
ns == no &&
miss.iter().all(|mi| miso.iter().any(|x| x.node == mi.node))
}
_ => false
}
}
}
}
//pub type blk = spanned<blk_>;
@ -622,7 +647,7 @@ pub type ty_field = spanned<ty_field_>;
#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
pub struct ty_method {
ident: ident,
attrs: ~[attribute],
attrs: ~[Attribute],
purity: purity,
decl: fn_decl,
generics: Generics,
@ -833,7 +858,7 @@ pub type explicit_self = spanned<explicit_self_>;
#[deriving(Eq, Encodable, Decodable,IterBytes)]
pub struct method {
ident: ident,
attrs: ~[attribute],
attrs: ~[Attribute],
generics: Generics,
explicit_self: explicit_self,
purity: purity,
@ -886,7 +911,7 @@ pub struct enum_def {
#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
pub struct variant_ {
name: ident,
attrs: ~[attribute],
attrs: ~[Attribute],
kind: variant_kind,
id: node_id,
disr_expr: Option<@expr>,
@ -925,34 +950,34 @@ pub enum view_path_ {
#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
pub struct view_item {
node: view_item_,
attrs: ~[attribute],
attrs: ~[Attribute],
vis: visibility,
span: span,
}
#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
pub enum view_item_ {
view_item_extern_mod(ident, ~[@meta_item], node_id),
view_item_extern_mod(ident, ~[@MetaItem], node_id),
view_item_use(~[@view_path]),
}
// Meta-data associated with an item
pub type attribute = spanned<attribute_>;
pub type Attribute = spanned<Attribute_>;
// Distinguishes between attributes that decorate items and attributes that
// Distinguishes between Attributes that decorate items and Attributes that
// are contained as statements within items. These two cases need to be
// distinguished for pretty-printing.
#[deriving(Clone, Eq, Encodable, Decodable,IterBytes)]
pub enum attr_style {
attr_outer,
attr_inner,
pub enum AttrStyle {
AttrOuter,
AttrInner,
}
// doc-comments are promoted to attributes that have is_sugared_doc = true
#[deriving(Clone, Eq, Encodable, Decodable,IterBytes)]
pub struct attribute_ {
style: attr_style,
value: @meta_item,
pub struct Attribute_ {
style: AttrStyle,
value: @MetaItem,
is_sugared_doc: bool,
}
@ -990,7 +1015,7 @@ pub struct struct_field_ {
kind: struct_field_kind,
id: node_id,
ty: Ty,
attrs: ~[attribute],
attrs: ~[Attribute],
}
pub type struct_field = spanned<struct_field_>;
@ -1016,7 +1041,7 @@ pub struct struct_def {
#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
pub struct item {
ident: ident,
attrs: ~[attribute],
attrs: ~[Attribute],
id: node_id,
node: item_,
vis: visibility,
@ -1044,7 +1069,7 @@ pub enum item_ {
#[deriving(Eq, Encodable, Decodable,IterBytes)]
pub struct foreign_item {
ident: ident,
attrs: ~[attribute],
attrs: ~[Attribute],
node: foreign_item_,
id: node_id,
span: span,

472
src/libsyntax/attr.rs
View file

@ -8,101 +8,64 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
// Functions dealing with attributes and meta_items
// Functions dealing with attributes and meta items
use extra;
use ast;
use ast::{Attribute, Attribute_, MetaItem, MetaWord, MetaNameValue, MetaList};
use codemap::{spanned, dummy_spanned};
use attr;
use codemap::BytePos;
use diagnostic::span_handler;
use parse::comments::{doc_comment_style, strip_doc_comment_decoration};
use std::hashmap::HashSet;
/* Constructors */
pub fn mk_name_value_item_str(name: @str, value: @str)
-> @ast::meta_item {
let value_lit = dummy_spanned(ast::lit_str(value));
mk_name_value_item(name, value_lit)
}
pub trait AttrMetaMethods {
// This could be changed to `fn check_name(&self, name: @str) ->
// bool` which would facilitate a side table recording which
// attributes/meta items are used/unused.
pub fn mk_name_value_item(name: @str, value: ast::lit)
-> @ast::meta_item {
@dummy_spanned(ast::meta_name_value(name, value))
}
/// Retrieve the name of the meta item, e.g. foo in #[foo],
/// #[foo="bar"] and #[foo(bar)]
fn name(&self) -> @str;
pub fn mk_list_item(name: @str, items: ~[@ast::meta_item]) ->
@ast::meta_item {
@dummy_spanned(ast::meta_list(name, items))
}
pub fn mk_word_item(name: @str) -> @ast::meta_item {
@dummy_spanned(ast::meta_word(name))
}
pub fn mk_attr(item: @ast::meta_item) -> ast::attribute {
dummy_spanned(ast::attribute_ { style: ast::attr_inner,
value: item,
is_sugared_doc: false })
}
pub fn mk_sugared_doc_attr(text: @str,
lo: BytePos, hi: BytePos) -> ast::attribute {
let style = doc_comment_style(text);
let lit = spanned(lo, hi, ast::lit_str(text));
let attr = ast::attribute_ {
style: style,
value: @spanned(lo, hi, ast::meta_name_value(@"doc", lit)),
is_sugared_doc: true
};
spanned(lo, hi, attr)
}
/* Conversion */
pub fn attr_meta(attr: ast::attribute) -> @ast::meta_item {
attr.node.value
}
// Get the meta_items from inside a vector of attributes
pub fn attr_metas(attrs: &[ast::attribute]) -> ~[@ast::meta_item] {
do attrs.map |a| { attr_meta(*a) }
}
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).to_managed());
mk_attr(meta)
} else {
*attr
}
}
/* Accessors */
pub fn get_attr_name(attr: &ast::attribute) -> @str {
get_meta_item_name(attr.node.value)
}
pub fn get_meta_item_name(meta: @ast::meta_item) -> @str {
match meta.node {
ast::meta_word(n) => n,
ast::meta_name_value(n, _) => n,
ast::meta_list(n, _) => n,
}
}
/**
* Gets the string value if the meta_item is a meta_name_value variant
* containing a string, otherwise none
/**
* Gets the string value if self is a MetaNameValue variant
* containing a string, otherwise None.
*/
pub fn get_meta_item_value_str(meta: @ast::meta_item) -> Option<@str> {
match meta.node {
ast::meta_name_value(_, v) => {
fn value_str(&self) -> Option<@str>;
/// Gets a list of inner meta items from a list MetaItem type.
fn meta_item_list<'a>(&'a self) -> Option<&'a [@MetaItem]>;
/**
* 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<(@str, @str)>;
}
impl AttrMetaMethods for Attribute {
fn name(&self) -> @str { self.meta().name() }
fn value_str(&self) -> Option<@str> { 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<(@str, @str)> { self.meta().name_str_pair() }
}
impl AttrMetaMethods for MetaItem {
fn name(&self) -> @str {
match self.node {
MetaWord(n) => n,
MetaNameValue(n, _) => n,
MetaList(n, _) => n
}
}
fn value_str(&self) -> Option<@str> {
match self.node {
MetaNameValue(_, ref v) => {
match v.node {
ast::lit_str(s) => Some(s),
_ => None,
@ -110,211 +73,191 @@ pub fn get_meta_item_value_str(meta: @ast::meta_item) -> Option<@str> {
},
_ => None
}
}
}
/// Gets a list of inner meta items from a list meta_item type
pub fn get_meta_item_list(meta: @ast::meta_item)
-> Option<~[@ast::meta_item]> {
match meta.node {
ast::meta_list(_, ref l) => Some(/* FIXME (#2543) */ (*l).clone()),
fn meta_item_list<'a>(&'a self) -> Option<&'a [@MetaItem]> {
match self.node {
MetaList(_, ref l) => Some(l.as_slice()),
_ => None
}
}
/**
* If the meta item is a nam-value type with a string value then returns
* a tuple containing the name and string value, otherwise `none`
*/
pub fn get_name_value_str_pair(item: @ast::meta_item)
-> Option<(@str, @str)> {
match attr::get_meta_item_value_str(item) {
Some(value) => {
let name = attr::get_meta_item_name(item);
Some((name, value))
}
None => None
pub fn name_str_pair(&self) -> Option<(@str, @str)> {
self.value_str().map_consume(|s| (self.name(), s))
}
}
// Annoying, but required to get test_cfg to work
impl AttrMetaMethods for @MetaItem {
fn name(&self) -> @str { (**self).name() }
fn value_str(&self) -> Option<@str> { (**self).value_str() }
fn meta_item_list<'a>(&'a self) -> Option<&'a [@MetaItem]> {
(**self).meta_item_list()
}
fn name_str_pair(&self) -> Option<(@str, @str)> { (**self).name_str_pair() }
}
pub trait AttributeMethods {
fn meta(&self) -> @MetaItem;
fn desugar_doc(&self) -> Attribute;
}
impl AttributeMethods for Attribute {
/// Extract the MetaItem from inside this Attribute.
pub fn meta(&self) -> @MetaItem {
self.node.value
}
/// Convert self to a normal #[doc="foo"] comment, if it is a
/// comment like `///` or `/** */`. (Returns self unchanged for
/// non-sugared doc attributes.)
pub fn desugar_doc(&self) -> Attribute {
if self.node.is_sugared_doc {
let comment = self.value_str().get();
let meta = mk_name_value_item_str(@"doc",
strip_doc_comment_decoration(comment).to_managed());
mk_attr(meta)
} else {
*self
}
}
}
/* Constructors */
pub fn mk_name_value_item_str(name: @str, value: @str) -> @MetaItem {
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) -> @MetaItem {
@dummy_spanned(MetaNameValue(name, value))
}
pub fn mk_list_item(name: @str, items: ~[@MetaItem]) -> @MetaItem {
@dummy_spanned(MetaList(name, items))
}
pub fn mk_word_item(name: @str) -> @MetaItem {
@dummy_spanned(MetaWord(name))
}
pub fn mk_attr(item: @MetaItem) -> Attribute {
dummy_spanned(Attribute_ {
style: ast::AttrInner,
value: item,
is_sugared_doc: false,
})
}
pub fn mk_sugared_doc_attr(text: @str, lo: BytePos, hi: BytePos) -> Attribute {
let style = doc_comment_style(text);
let lit = spanned(lo, hi, ast::lit_str(text));
let attr = Attribute_ {
style: style,
value: @spanned(lo, hi, MetaNameValue(@"doc", lit)),
is_sugared_doc: true
};
spanned(lo, hi, attr)
}
/* Searching */
/// Search a list of attributes and return only those with a specific name
pub fn find_attrs_by_name(attrs: &[ast::attribute], name: &str) ->
~[ast::attribute] {
do attrs.iter().filter_map |a| {
if name == get_attr_name(a) {
Some(*a)
} else {
None
}
}.collect()
}
/// Search a list of meta items and return only those with a specific name
pub fn find_meta_items_by_name(metas: &[@ast::meta_item], name: &str) ->
~[@ast::meta_item] {
let mut rs = ~[];
for metas.iter().advance |mi| {
if name == get_meta_item_name(*mi) {
rs.push(*mi)
}
}
rs
}
/**
* Returns true if a list of meta items contains another meta item. The
* comparison is performed structurally.
*/
pub fn contains(haystack: &[@ast::meta_item],
needle: @ast::meta_item) -> bool {
for haystack.iter().advance |item| {
if eq(*item, needle) { return true; }
}
return false;
}
fn eq(a: @ast::meta_item, b: @ast::meta_item) -> bool {
match a.node {
ast::meta_word(ref na) => match b.node {
ast::meta_word(ref nb) => (*na) == (*nb),
_ => false
},
ast::meta_name_value(ref na, va) => match b.node {
ast::meta_name_value(ref nb, vb) => {
(*na) == (*nb) && va.node == vb.node
}
_ => false
},
ast::meta_list(ref na, ref misa) => match b.node {
ast::meta_list(ref nb, ref misb) => {
if na != nb { return false; }
for misa.iter().advance |mi| {
if !misb.iter().any(|x| x == mi) { return false; }
}
true
}
_ => false
}
/// Check if `needle` occurs in `haystack` by a structural
/// comparison. This is slightly subtle, and relies on ignoring the
/// span included in the `==` comparison a plain MetaItem.
pub fn contains(haystack: &[@ast::MetaItem],
needle: @ast::MetaItem) -> bool {
debug!("attr::contains (name=%s)", needle.name());
do haystack.iter().any |item| {
debug!(" testing: %s", item.name());
item.node == needle.node
}
}
pub fn contains_name(metas: &[@ast::meta_item], name: &str) -> bool {
let matches = find_meta_items_by_name(metas, name);
matches.len() > 0u
pub fn contains_name<AM: AttrMetaMethods>(metas: &[AM], name: &str) -> bool {
debug!("attr::contains_name (name=%s)", name);
do metas.iter().any |item| {
debug!(" testing: %s", item.name());
name == item.name()
}
}
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)
pub fn first_attr_value_str_by_name(attrs: &[Attribute], name: &str)
-> Option<@str> {
let mattrs = find_attrs_by_name(attrs, name);
if mattrs.len() > 0 {
get_meta_item_value_str(attr_meta(mattrs[0]))
} else {
None
}
attrs.iter()
.find_(|at| name == at.name())
.chain(|at| at.value_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);
items.last_opt().map(|item| **item)
}
pub fn last_meta_item_value_str_by_name(items: &[@ast::meta_item], name: &str)
pub fn last_meta_item_value_str_by_name(items: &[@MetaItem], name: &str)
-> Option<@str> {
match last_meta_item_by_name(items, name) {
Some(item) => {
match attr::get_meta_item_value_str(item) {
Some(value) => Some(value),
None => None
}
},
None => None
}
items.rev_iter().find_(|mi| name == mi.name()).chain(|i| i.value_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) {
Some(item) => attr::get_meta_item_list(item),
None => None
}
}
/* Higher-level applications */
pub fn sort_meta_items(items: &[@ast::meta_item]) -> ~[@ast::meta_item] {
// This is sort of stupid here, converting to a vec of mutables and back
let mut v = items.to_owned();
do extra::sort::quick_sort(v) |ma, mb| {
get_meta_item_name(*ma) <= get_meta_item_name(*mb)
pub fn sort_meta_items(items: &[@MetaItem]) -> ~[@MetaItem] {
// This is sort of stupid here, but we need to sort by
// human-readable strings.
let mut v = items.iter()
.transform(|&mi| (mi.name(), mi))
.collect::<~[(@str, @MetaItem)]>();
do extra::sort::quick_sort(v) |&(a, _), &(b, _)| {
a <= b
}
// There doesn't seem to be a more optimal way to do this
do v.map |m| {
do v.consume_iter().transform |(_, m)| {
match m.node {
ast::meta_list(n, ref mis) => {
MetaList(n, ref mis) => {
@spanned {
node: ast::meta_list(n, sort_meta_items(*mis)),
.. /*bad*/ (**m).clone()
node: MetaList(n, sort_meta_items(*mis)),
.. /*bad*/ (*m).clone()
}
}
_ => *m
_ => m
}
}
}
pub fn remove_meta_items_by_name(items: ~[@ast::meta_item], name: &str) ->
~[@ast::meta_item] {
items.consume_iter().filter(|item| name != get_meta_item_name(*item)).collect()
}.collect()
}
/**
* From a list of crate attributes get only the meta_items that affect crate
* linkage
*/
pub fn find_linkage_metas(attrs: &[ast::attribute]) -> ~[@ast::meta_item] {
do find_attrs_by_name(attrs, "link").flat_map |attr| {
match attr.node.value.node {
ast::meta_list(_, ref items) => {
/* FIXME (#2543) */ (*items).clone()
}
_ => ~[]
pub fn find_linkage_metas(attrs: &[Attribute]) -> ~[@MetaItem] {
let mut result = ~[];
for attrs.iter().filter(|at| "link" == at.name()).advance |attr| {
match attr.meta().node {
MetaList(_, ref items) => result.push_all(*items),
_ => ()
}
}
result
}
#[deriving(Eq)]
pub enum inline_attr {
ia_none,
ia_hint,
ia_always,
ia_never,
pub enum InlineAttr {
InlineNone,
InlineHint,
InlineAlways,
InlineNever,
}
/// True if something like #[inline] is found in the list of attrs.
pub fn find_inline_attr(attrs: &[ast::attribute]) -> inline_attr {
pub fn find_inline_attr(attrs: &[Attribute]) -> InlineAttr {
// FIXME (#2809)---validate the usage of #[inline] and #[inline]
do attrs.iter().fold(ia_none) |ia,attr| {
do attrs.iter().fold(InlineNone) |ia,attr| {
match attr.node.value.node {
ast::meta_word(s) if "inline" == s => ia_hint,
ast::meta_list(s, ref items) if "inline" == s => {
if !find_meta_items_by_name(*items, "always").is_empty() {
ia_always
} else if !find_meta_items_by_name(*items, "never").is_empty() {
ia_never
MetaWord(n) if "inline" == n => InlineHint,
MetaList(n, ref items) if "inline" == n => {
if contains_name(*items, "always") {
InlineAlways
} else if contains_name(*items, "never") {
InlineNever
} else {
ia_hint
InlineHint
}
}
_ => ia
@ -322,12 +265,59 @@ pub fn find_inline_attr(attrs: &[ast::attribute]) -> inline_attr {
}
}
/// Tests if any `cfg(...)` meta items in `metas` match `cfg`. e.g.
///
/// test_cfg(`[foo="a", bar]`, `[cfg(foo), cfg(bar)]`) == true
/// test_cfg(`[foo="a", bar]`, `[cfg(not(bar))]`) == false
/// test_cfg(`[foo="a", bar]`, `[cfg(bar, foo="a")]`) == true
/// test_cfg(`[foo="a", bar]`, `[cfg(bar, foo="b")]`) == false
pub fn test_cfg<AM: AttrMetaMethods, It: Iterator<AM>>
(cfg: &[@MetaItem], mut metas: It) -> bool {
// having no #[cfg(...)] attributes counts as matching.
let mut no_cfgs = true;
// this would be much nicer as a chain of iterator adaptors, but
// this doesn't work.
let some_cfg_matches = do metas.any |mi| {
debug!("testing name: %s", mi.name());
if "cfg" == mi.name() { // it is a #[cfg()] attribute
debug!("is cfg");
no_cfgs = false;
// only #[cfg(...)] ones are understood.
match mi.meta_item_list() {
Some(cfg_meta) => {
debug!("is cfg(...)");
do cfg_meta.iter().all |cfg_mi| {
debug!("cfg(%s[...])", cfg_mi.name());
match cfg_mi.node {
ast::MetaList(s, ref not_cfgs) if "not" == s => {
debug!("not!");
// inside #[cfg(not(...))], so these need to all
// not match.
not_cfgs.iter().all(|mi| {
debug!("cfg(not(%s[...]))", mi.name());
!contains(cfg, *mi)
})
}
_ => contains(cfg, *cfg_mi)
}
}
}
None => false
}
} else {
false
}
};
debug!("test_cfg (no_cfgs=%?, some_cfg_matches=%?)", no_cfgs, some_cfg_matches);
no_cfgs || some_cfg_matches
}
pub fn require_unique_names(diagnostic: @span_handler,
metas: &[@ast::meta_item]) {
metas: &[@MetaItem]) {
let mut set = HashSet::new();
for metas.iter().advance |meta| {
let name = get_meta_item_name(*meta);
let name = meta.name();
// FIXME: How do I silence the warnings? --pcw (#2619)
if !set.insert(name) {

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

@ -17,7 +17,7 @@ use ext::base::*;
pub fn expand_auto_encode(
cx: @ExtCtxt,
span: span,
_mitem: @ast::meta_item,
_mitem: @ast::MetaItem,
in_items: ~[@ast::item]
) -> ~[@ast::item] {
cx.span_err(span, "`#[auto_encode]` is deprecated, use `#[deriving(Encodable)]` instead");
@ -27,7 +27,7 @@ pub fn expand_auto_encode(
pub fn expand_auto_decode(
cx: @ExtCtxt,
span: span,
_mitem: @ast::meta_item,
_mitem: @ast::MetaItem,
in_items: ~[@ast::item]
) -> ~[@ast::item] {
cx.span_err(span, "`#[auto_decode]` is deprecated, use `#[deriving(Decodable)]` instead");

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

@ -36,7 +36,7 @@ pub struct MacroDef {
pub type ItemDecorator = @fn(@ExtCtxt,
span,
@ast::meta_item,
@ast::MetaItem,
~[@ast::item])
-> ~[@ast::item];

37
src/libsyntax/ext/build.rs
View file

@ -163,7 +163,7 @@ pub trait AstBuilder {
// items
fn item(&self, span: span,
name: ident, attrs: ~[ast::attribute], node: ast::item_) -> @ast::item;
name: ident, attrs: ~[ast::Attribute], node: ast::item_) -> @ast::item;
fn arg(&self, span: span, name: ident, ty: ast::Ty) -> ast::arg;
// XXX unused self
@ -199,7 +199,7 @@ pub trait AstBuilder {
fn item_struct(&self, span: span, name: ident, struct_def: ast::struct_def) -> @ast::item;
fn item_mod(&self, span: span,
name: ident, attrs: ~[ast::attribute],
name: ident, attrs: ~[ast::Attribute],
vi: ~[ast::view_item], items: ~[@ast::item]) -> @ast::item;
fn item_ty_poly(&self,
@ -209,11 +209,11 @@ pub trait AstBuilder {
generics: Generics) -> @ast::item;
fn item_ty(&self, span: span, name: ident, ty: ast::Ty) -> @ast::item;
fn attribute(&self, sp: span, mi: @ast::meta_item) -> ast::attribute;
fn attribute(&self, sp: span, mi: @ast::MetaItem) -> ast::Attribute;
fn meta_word(&self, sp: span, w: @str) -> @ast::meta_item;
fn meta_list(&self, sp: span, name: @str, mis: ~[@ast::meta_item]) -> @ast::meta_item;
fn meta_name_value(&self, sp: span, name: @str, value: ast::lit_) -> @ast::meta_item;
fn meta_word(&self, sp: span, w: @str) -> @ast::MetaItem;
fn meta_list(&self, sp: span, name: @str, mis: ~[@ast::MetaItem]) -> @ast::MetaItem;
fn meta_name_value(&self, sp: span, name: @str, value: ast::lit_) -> @ast::MetaItem;
fn view_use(&self, sp: span,
vis: ast::visibility, vp: ~[@ast::view_path]) -> ast::view_item;
@ -657,7 +657,7 @@ impl AstBuilder for @ExtCtxt {
}
fn item(&self, span: span,
name: ident, attrs: ~[ast::attribute], node: ast::item_) -> @ast::item {
name: ident, attrs: ~[ast::Attribute], node: ast::item_) -> @ast::item {
// XXX: Would be nice if our generated code didn't violate
// Rust coding conventions
@ast::item { ident: name,
@ -754,7 +754,7 @@ impl AstBuilder for @ExtCtxt {
}
fn item_mod(&self, span: span, name: ident,
attrs: ~[ast::attribute],
attrs: ~[ast::Attribute],
vi: ~[ast::view_item],
items: ~[@ast::item]) -> @ast::item {
self.item(
@ -777,23 +777,22 @@ impl AstBuilder for @ExtCtxt {
self.item_ty_poly(span, name, ty, ast_util::empty_generics())
}
fn attribute(&self, sp: span, mi: @ast::meta_item) -> ast::attribute {
respan(sp,
ast::attribute_ {
style: ast::attr_outer,
fn attribute(&self, sp: span, mi: @ast::MetaItem) -> ast::Attribute {
respan(sp, ast::Attribute_ {
style: ast::AttrOuter,
value: mi,
is_sugared_doc: false
is_sugared_doc: false,
})
}
fn meta_word(&self, sp: span, w: @str) -> @ast::meta_item {
@respan(sp, ast::meta_word(w))
fn meta_word(&self, sp: span, w: @str) -> @ast::MetaItem {
@respan(sp, ast::MetaWord(w))
}
fn meta_list(&self, sp: span, name: @str, mis: ~[@ast::meta_item]) -> @ast::meta_item {
@respan(sp, ast::meta_list(name, mis))
fn meta_list(&self, sp: span, name: @str, mis: ~[@ast::MetaItem]) -> @ast::MetaItem {
@respan(sp, ast::MetaList(name, mis))
}
fn meta_name_value(&self, sp: span, name: @str, value: ast::lit_) -> @ast::meta_item {
@respan(sp, ast::meta_name_value(name, respan(sp, value)))
fn meta_name_value(&self, sp: span, name: @str, value: ast::lit_) -> @ast::MetaItem {
@respan(sp, ast::MetaNameValue(name, respan(sp, value)))
}
fn view_use(&self, sp: span,

6
src/libsyntax/ext/deriving/clone.rs
View file

@ -8,7 +8,7 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use ast::{meta_item, item, expr};
use ast::{MetaItem, item, expr};
use codemap::span;
use ext::base::ExtCtxt;
use ext::build::AstBuilder;
@ -16,7 +16,7 @@ use ext::deriving::generic::*;
pub fn expand_deriving_clone(cx: @ExtCtxt,
span: span,
mitem: @meta_item,
mitem: @MetaItem,
in_items: ~[@item])
-> ~[@item] {
let trait_def = TraitDef {
@ -41,7 +41,7 @@ pub fn expand_deriving_clone(cx: @ExtCtxt,
pub fn expand_deriving_deep_clone(cx: @ExtCtxt,
span: span,
mitem: @meta_item,
mitem: @MetaItem,
in_items: ~[@item])
-> ~[@item] {
let trait_def = TraitDef {

4
src/libsyntax/ext/deriving/cmp/eq.rs
View file

@ -8,7 +8,7 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use ast::{meta_item, item, expr};
use ast::{MetaItem, item, expr};
use codemap::span;
use ext::base::ExtCtxt;
use ext::build::AstBuilder;
@ -16,7 +16,7 @@ use ext::deriving::generic::*;
pub fn expand_deriving_eq(cx: @ExtCtxt,
span: span,
mitem: @meta_item,
mitem: @MetaItem,
in_items: ~[@item]) -> ~[@item] {
// structures are equal if all fields are equal, and non equal, if
// any fields are not equal or if the enum variants are different

4
src/libsyntax/ext/deriving/cmp/ord.rs
View file

@ -9,7 +9,7 @@
// except according to those terms.
use ast;
use ast::{meta_item, item, expr};
use ast::{MetaItem, item, expr};
use codemap::span;
use ext::base::ExtCtxt;
use ext::build::AstBuilder;
@ -17,7 +17,7 @@ use ext::deriving::generic::*;
pub fn expand_deriving_ord(cx: @ExtCtxt,
span: span,
mitem: @meta_item,
mitem: @MetaItem,
in_items: ~[@item]) -> ~[@item] {
macro_rules! md (
($name:expr, $op:expr, $equal:expr) => {

5
src/libsyntax/ext/deriving/cmp/totaleq.rs
View file

@ -8,7 +8,7 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use ast::{meta_item, item, expr};
use ast::{MetaItem, item, expr};
use codemap::span;
use ext::base::ExtCtxt;
use ext::build::AstBuilder;
@ -16,9 +16,8 @@ use ext::deriving::generic::*;
pub fn expand_deriving_totaleq(cx: @ExtCtxt,
span: span,
mitem: @meta_item,
mitem: @MetaItem,
in_items: ~[@item]) -> ~[@item] {
fn cs_equals(cx: @ExtCtxt, span: span, substr: &Substructure) -> @expr {
cs_and(|cx, span, _, _| cx.expr_bool(span, false),
cx, span, substr)

4
src/libsyntax/ext/deriving/cmp/totalord.rs
View file

@ -8,7 +8,7 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use ast::{meta_item, item, expr};
use ast::{MetaItem, item, expr};
use codemap::span;
use ext::base::ExtCtxt;
use ext::build::AstBuilder;
@ -17,7 +17,7 @@ use std::cmp::{Ordering, Equal, Less, Greater};
pub fn expand_deriving_totalord(cx: @ExtCtxt,
span: span,
mitem: @meta_item,
mitem: @MetaItem,
in_items: ~[@item]) -> ~[@item] {
let trait_def = TraitDef {
path: Path::new(~["std", "cmp", "TotalOrd"]),

4
src/libsyntax/ext/deriving/decodable.rs
View file

@ -16,7 +16,7 @@ encodable.rs for more.
use std::vec;
use std::uint;
use ast::{meta_item, item, expr, m_mutbl};
use ast::{MetaItem, item, expr, m_mutbl};
use codemap::span;
use ext::base::ExtCtxt;
use ext::build::AstBuilder;
@ -24,7 +24,7 @@ use ext::deriving::generic::*;
pub fn expand_deriving_decodable(cx: @ExtCtxt,
span: span,
mitem: @meta_item,
mitem: @MetaItem,
in_items: ~[@item]) -> ~[@item] {
let trait_def = TraitDef {
path: Path::new_(~["extra", "serialize", "Decodable"], None,

4
src/libsyntax/ext/deriving/encodable.rs
View file

@ -75,7 +75,7 @@ would yield functions like:
}
*/
use ast::{meta_item, item, expr, m_imm, m_mutbl};
use ast::{MetaItem, item, expr, m_imm, m_mutbl};
use codemap::span;
use ext::base::ExtCtxt;
use ext::build::AstBuilder;
@ -83,7 +83,7 @@ use ext::deriving::generic::*;
pub fn expand_deriving_encodable(cx: @ExtCtxt,
span: span,
mitem: @meta_item,
mitem: @MetaItem,
in_items: ~[@item]) -> ~[@item] {
let trait_def = TraitDef {
path: Path::new_(~["extra", "serialize", "Encodable"], None,

5
src/libsyntax/ext/deriving/generic.rs
View file

@ -281,7 +281,7 @@ pub type EnumNonMatchFunc<'self> =
impl<'self> TraitDef<'self> {
pub fn expand(&self, cx: @ExtCtxt,
span: span,
_mitem: @ast::meta_item,
_mitem: @ast::MetaItem,
in_items: ~[@ast::item]) -> ~[@ast::item] {
let mut result = ~[];
for in_items.iter().advance |item| {
@ -361,7 +361,8 @@ impl<'self> TraitDef<'self> {
let doc_attr = cx.attribute(
span,
cx.meta_name_value(span,
@"doc", ast::lit_str(@"Automatically derived.")));
@"doc",
ast::lit_str(@"Automatically derived.")));
cx.item(
span,
::parse::token::special_idents::clownshoes_extensions,

4
src/libsyntax/ext/deriving/iter_bytes.rs
View file

@ -8,7 +8,7 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use ast::{meta_item, item, expr, and};
use ast::{MetaItem, item, expr, and};
use codemap::span;
use ext::base::ExtCtxt;
use ext::build::AstBuilder;
@ -17,7 +17,7 @@ use ext::deriving::generic::*;
pub fn expand_deriving_iter_bytes(cx: @ExtCtxt,
span: span,
mitem: @meta_item,
mitem: @MetaItem,
in_items: ~[@item]) -> ~[@item] {
let trait_def = TraitDef {
path: Path::new(~["std", "to_bytes", "IterBytes"]),

19
src/libsyntax/ext/deriving/mod.rs
View file

@ -18,7 +18,8 @@ library.
*/
use ast::{enum_def, ident, item, Generics, meta_item, struct_def};
use ast::{enum_def, ident, item, Generics, struct_def};
use ast::{MetaItem, MetaList, MetaNameValue, MetaWord};
use ext::base::ExtCtxt;
use ext::build::AstBuilder;
use codemap::span;
@ -58,26 +59,24 @@ pub type ExpandDerivingEnumDefFn<'self> = &'self fn(@ExtCtxt,
pub fn expand_meta_deriving(cx: @ExtCtxt,
_span: span,
mitem: @meta_item,
mitem: @MetaItem,
in_items: ~[@item])
-> ~[@item] {
use ast::{meta_list, meta_name_value, meta_word};
match mitem.node {
meta_name_value(_, ref l) => {
MetaNameValue(_, ref l) => {
cx.span_err(l.span, "unexpected value in `deriving`");
in_items
}
meta_word(_) | meta_list(_, []) => {
MetaWord(_) | MetaList(_, []) => {
cx.span_warn(mitem.span, "empty trait list in `deriving`");
in_items
}
meta_list(_, ref titems) => {
MetaList(_, ref titems) => {
do titems.rev_iter().fold(in_items) |in_items, &titem| {
match titem.node {
meta_name_value(tname, _) |
meta_list(tname, _) |
meta_word(tname) => {
MetaNameValue(tname, _) |
MetaList(tname, _) |
MetaWord(tname) => {
macro_rules! expand(($func:path) => ($func(cx, titem.span,
titem, in_items)));
match tname.as_slice() {

4
src/libsyntax/ext/deriving/rand.rs
View file

@ -9,7 +9,7 @@
// except according to those terms.
use ast;
use ast::{meta_item, item, expr, ident};
use ast::{MetaItem, item, expr, ident};
use codemap::span;
use ext::base::ExtCtxt;
use ext::build::{AstBuilder, Duplicate};
@ -19,7 +19,7 @@ use std::vec;
pub fn expand_deriving_rand(cx: @ExtCtxt,
span: span,
mitem: @meta_item,
mitem: @MetaItem,
in_items: ~[@item])
-> ~[@item] {
let trait_def = TraitDef {

4
src/libsyntax/ext/deriving/to_str.rs
View file

@ -9,7 +9,7 @@
// except according to those terms.
use ast;
use ast::{meta_item, item, expr};
use ast::{MetaItem, item, expr};
use codemap::span;
use ext::base::ExtCtxt;
use ext::build::AstBuilder;
@ -17,7 +17,7 @@ use ext::deriving::generic::*;
pub fn expand_deriving_to_str(cx: @ExtCtxt,
span: span,
mitem: @meta_item,
mitem: @MetaItem,
in_items: ~[@item])
-> ~[@item] {
let trait_def = TraitDef {

4
src/libsyntax/ext/deriving/zero.rs
View file

@ -8,7 +8,7 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use ast::{meta_item, item, expr};
use ast::{MetaItem, item, expr};
use codemap::span;
use ext::base::ExtCtxt;
use ext::build::AstBuilder;
@ -18,7 +18,7 @@ use std::vec;
pub fn expand_deriving_zero(cx: @ExtCtxt,
span: span,
mitem: @meta_item,
mitem: @MetaItem,
in_items: ~[@item])
-> ~[@item] {
let trait_def = TraitDef {

19
src/libsyntax/ext/expand.rs
View file

@ -14,6 +14,7 @@ use ast::{illegal_ctxt};
use ast;
use ast_util::{new_rename, new_mark, resolve};
use attr;
use attr::AttrMetaMethods;
use codemap;
use codemap::{span, ExpnInfo, NameAndSpan};
use ext::base::*;
@ -126,7 +127,7 @@ pub fn expand_mod_items(extsbox: @mut SyntaxEnv,
// the item into a new set of items.
let new_items = do vec::flat_map(module_.items) |item| {
do item.attrs.rev_iter().fold(~[*item]) |items, attr| {
let mname = attr::get_attr_name(attr);
let mname = attr.name();
match (*extsbox).find(&intern(mname)) {
Some(@SE(ItemDecorator(dec_fn))) => {
@ -196,8 +197,8 @@ pub fn expand_item(extsbox: @mut SyntaxEnv,
}
// does this attribute list contain "macro_escape" ?
pub fn contains_macro_escape (attrs: &[ast::attribute]) -> bool {
attrs.iter().any(|attr| "macro_escape" == attr::get_attr_name(attr))
pub fn contains_macro_escape(attrs: &[ast::Attribute]) -> bool {
attr::contains_name(attrs, "macro_escape")
}
// Support for item-position macro invocations, exactly the same
@ -793,7 +794,7 @@ pub fn new_ident_resolver() ->
mod test {
use super::*;
use ast;
use ast::{attribute_, attr_outer, meta_word, empty_ctxt};
use ast::{Attribute_, AttrOuter, MetaWord, empty_ctxt};
use codemap;
use codemap::spanned;
use parse;
@ -883,14 +884,14 @@ mod test {
assert_eq!(contains_macro_escape (attrs2),false);
}
// make a "meta_word" outer attribute with the given name
fn make_dummy_attr(s: @str) -> ast::attribute {
// make a MetaWord outer attribute with the given name
fn make_dummy_attr(s: @str) -> ast::Attribute {
spanned {
span:codemap::dummy_sp(),
node: attribute_ {
style: attr_outer,
node: Attribute_ {
style: AttrOuter,
value: @spanned {
node: meta_word(s),
node: MetaWord(s),
span: codemap::dummy_sp(),
},
is_sugared_doc: false,

27
src/libsyntax/fold.rs
View file

@ -74,35 +74,34 @@ pub type ast_fold_fns = @AstFoldFns;
/* some little folds that probably aren't useful to have in ast_fold itself*/
//used in noop_fold_item and noop_fold_crate and noop_fold_crate_directive
fn fold_meta_item_(mi: @meta_item, fld: @ast_fold) -> @meta_item {
fn fold_meta_item_(mi: @MetaItem, fld: @ast_fold) -> @MetaItem {
@spanned {
node:
match mi.node {
meta_word(id) => meta_word(id),
meta_list(id, ref mis) => {
MetaWord(id) => MetaWord(id),
MetaList(id, ref mis) => {
let fold_meta_item = |x| fold_meta_item_(x, fld);
meta_list(
MetaList(
id,
mis.map(|e| fold_meta_item(*e))
)
}
meta_name_value(id, s) => {
meta_name_value(id, s)
}
MetaNameValue(id, s) => MetaNameValue(id, s)
},
span: fld.new_span(mi.span) }
}
//used in noop_fold_item and noop_fold_crate
fn fold_attribute_(at: attribute, fld: @ast_fold) -> attribute {
fn fold_attribute_(at: Attribute, fld: @ast_fold) -> Attribute {
spanned {
node: ast::attribute_ {
span: fld.new_span(at.span),
node: ast::Attribute_ {
style: at.node.style,
value: fold_meta_item_(at.node.value, fld),
is_sugared_doc: at.node.is_sugared_doc,
},
span: fld.new_span(at.span),
is_sugared_doc: at.node.is_sugared_doc
}
}
}
//used in noop_fold_foreign_item and noop_fold_fn_decl
fn fold_arg_(a: arg, fld: @ast_fold) -> arg {
ast::arg {
@ -936,11 +935,11 @@ impl ast_fold for AstFoldFns {
}
pub trait AstFoldExtensions {
fn fold_attributes(&self, attrs: ~[attribute]) -> ~[attribute];
fn fold_attributes(&self, attrs: ~[Attribute]) -> ~[Attribute];
}
impl AstFoldExtensions for @ast_fold {
fn fold_attributes(&self, attrs: ~[attribute]) -> ~[attribute] {
fn fold_attributes(&self, attrs: ~[Attribute]) -> ~[Attribute] {
attrs.map(|x| fold_attribute_(*x, *self))
}
}

56
src/libsyntax/parse/attr.rs
View file

@ -17,32 +17,32 @@ use parse::parser::Parser;
// a parser that can parse attributes.
pub trait parser_attr {
fn parse_outer_attributes(&self) -> ~[ast::attribute];
fn parse_attribute(&self, style: ast::attr_style) -> ast::attribute;
fn parse_outer_attributes(&self) -> ~[ast::Attribute];
fn parse_attribute(&self, style: ast::AttrStyle) -> ast::Attribute;
fn parse_attribute_naked(
&self,
style: ast::attr_style,
style: ast::AttrStyle,
lo: BytePos
) -> ast::attribute;
) -> ast::Attribute;
fn parse_inner_attrs_and_next(&self) ->
(~[ast::attribute], ~[ast::attribute]);
fn parse_meta_item(&self) -> @ast::meta_item;
fn parse_meta_seq(&self) -> ~[@ast::meta_item];
fn parse_optional_meta(&self) -> ~[@ast::meta_item];
(~[ast::Attribute], ~[ast::Attribute]);
fn parse_meta_item(&self) -> @ast::MetaItem;
fn parse_meta_seq(&self) -> ~[@ast::MetaItem];
fn parse_optional_meta(&self) -> ~[@ast::MetaItem];
}
impl parser_attr for Parser {
// Parse attributes that appear before an item
fn parse_outer_attributes(&self) -> ~[ast::attribute] {
let mut attrs: ~[ast::attribute] = ~[];
fn parse_outer_attributes(&self) -> ~[ast::Attribute] {
let mut attrs: ~[ast::Attribute] = ~[];
loop {
match *self.token {
token::POUND => {
if self.look_ahead(1, |t| *t != token::LBRACKET) {
break;
}
attrs.push(self.parse_attribute(ast::attr_outer));
attrs.push(self.parse_attribute(ast::AttrOuter));
}
token::DOC_COMMENT(s) => {
let attr = ::attr::mk_sugared_doc_attr(
@ -50,7 +50,7 @@ impl parser_attr for Parser {
self.span.lo,
self.span.hi
);
if attr.node.style != ast::attr_outer {
if attr.node.style != ast::AttrOuter {
self.fatal("expected outer comment");
}
attrs.push(attr);
@ -63,20 +63,20 @@ impl parser_attr for Parser {
}
// matches attribute = # attribute_naked
fn parse_attribute(&self, style: ast::attr_style) -> ast::attribute {
fn parse_attribute(&self, style: ast::AttrStyle) -> ast::Attribute {
let lo = self.span.lo;
self.expect(&token::POUND);
return self.parse_attribute_naked(style, lo);
}
// matches attribute_naked = [ meta_item ]
fn parse_attribute_naked(&self, style: ast::attr_style, lo: BytePos) ->
ast::attribute {
fn parse_attribute_naked(&self, style: ast::AttrStyle, lo: BytePos) ->
ast::Attribute {
self.expect(&token::LBRACKET);
let meta_item = self.parse_meta_item();
self.expect(&token::RBRACKET);
let hi = self.span.hi;
return spanned(lo, hi, ast::attribute_ { style: style,
return spanned(lo, hi, ast::Attribute_ { style: style,
value: meta_item, is_sugared_doc: false }); }
// Parse attributes that appear after the opening of an item, each
@ -90,9 +90,9 @@ impl parser_attr for Parser {
// you can make the 'next' field an Option, but the result is going to be
// more useful as a vector.
fn parse_inner_attrs_and_next(&self) ->
(~[ast::attribute], ~[ast::attribute]) {
let mut inner_attrs: ~[ast::attribute] = ~[];
let mut next_outer_attrs: ~[ast::attribute] = ~[];
(~[ast::Attribute], ~[ast::Attribute]) {
let mut inner_attrs: ~[ast::Attribute] = ~[];
let mut next_outer_attrs: ~[ast::Attribute] = ~[];
loop {
match *self.token {
token::POUND => {
@ -100,7 +100,7 @@ impl parser_attr for Parser {
// This is an extension
break;
}
let attr = self.parse_attribute(ast::attr_inner);
let attr = self.parse_attribute(ast::AttrInner);
if *self.token == token::SEMI {
self.bump();
inner_attrs.push(attr);
@ -108,7 +108,7 @@ impl parser_attr for Parser {
// It's not really an inner attribute
let outer_attr =
spanned(attr.span.lo, attr.span.hi,
ast::attribute_ { style: ast::attr_outer,
ast::Attribute_ { style: ast::AttrOuter,
value: attr.node.value,
is_sugared_doc: false });
next_outer_attrs.push(outer_attr);
@ -122,7 +122,7 @@ impl parser_attr for Parser {
self.span.hi
);
self.bump();
if attr.node.style == ast::attr_inner {
if attr.node.style == ast::AttrInner {
inner_attrs.push(attr);
} else {
next_outer_attrs.push(attr);
@ -138,7 +138,7 @@ impl parser_attr for Parser {
// matches meta_item = IDENT
// | IDENT = lit
// | IDENT meta_seq
fn parse_meta_item(&self) -> @ast::meta_item {
fn parse_meta_item(&self) -> @ast::MetaItem {
let lo = self.span.lo;
let name = self.id_to_str(self.parse_ident());
match *self.token {
@ -146,29 +146,29 @@ impl parser_attr for Parser {
self.bump();
let lit = self.parse_lit();
let hi = self.span.hi;
@spanned(lo, hi, ast::meta_name_value(name, lit))
@spanned(lo, hi, ast::MetaNameValue(name, lit))
}
token::LPAREN => {
let inner_items = self.parse_meta_seq();
let hi = self.span.hi;
@spanned(lo, hi, ast::meta_list(name, inner_items))
@spanned(lo, hi, ast::MetaList(name, inner_items))
}
_ => {
let hi = self.last_span.hi;
@spanned(lo, hi, ast::meta_word(name))
@spanned(lo, hi, ast::MetaWord(name))
}
}
}
// matches meta_seq = ( COMMASEP(meta_item) )
fn parse_meta_seq(&self) -> ~[@ast::meta_item] {
fn parse_meta_seq(&self) -> ~[@ast::MetaItem] {
self.parse_seq(&token::LPAREN,
&token::RPAREN,
seq_sep_trailing_disallowed(token::COMMA),
|p| p.parse_meta_item()).node
}
fn parse_optional_meta(&self) -> ~[@ast::meta_item] {
fn parse_optional_meta(&self) -> ~[@ast::MetaItem] {
match *self.token {
token::LPAREN => self.parse_meta_seq(),
_ => ~[]

6
src/libsyntax/parse/comments.rs
View file

@ -44,12 +44,12 @@ pub fn is_doc_comment(s: &str) -> bool {
s.starts_with("/*!")
}
pub fn doc_comment_style(comment: &str) -> ast::attr_style {
pub fn doc_comment_style(comment: &str) -> ast::AttrStyle {
assert!(is_doc_comment(comment));
if comment.starts_with("//!") || comment.starts_with("/*!") {
ast::attr_inner
ast::AttrInner
} else {
ast::attr_outer
ast::AttrOuter
}
}

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

@ -115,7 +115,7 @@ pub fn parse_item_from_source_str(
name: @str,
source: @str,
cfg: ast::crate_cfg,
attrs: ~[ast::attribute],
attrs: ~[ast::Attribute],
sess: @mut ParseSess
) -> Option<@ast::item> {
let p = new_parser_from_source_str(
@ -132,7 +132,7 @@ pub fn parse_meta_from_source_str(
source: @str,
cfg: ast::crate_cfg,
sess: @mut ParseSess
) -> @ast::meta_item {
) -> @ast::MetaItem {
let p = new_parser_from_source_str(
sess,
cfg,
@ -146,7 +146,7 @@ pub fn parse_stmt_from_source_str(
name: @str,
source: @str,
cfg: ast::crate_cfg,
attrs: ~[ast::attribute],
attrs: ~[ast::Attribute],
sess: @mut ParseSess
) -> @ast::stmt {
let p = new_parser_from_source_str(

6
src/libsyntax/parse/obsolete.rs
View file

@ -17,7 +17,7 @@ Obsolete syntax that becomes too hard to parse can be
removed.
*/
use ast::{expr, expr_lit, lit_nil, attribute};
use ast::{expr, expr_lit, lit_nil, Attribute};
use ast;
use codemap::{span, respan};
use parse::parser::Parser;
@ -89,7 +89,7 @@ pub trait ParserObsoleteMethods {
fn eat_obsolete_ident(&self, ident: &str) -> bool;
fn try_parse_obsolete_struct_ctor(&self) -> bool;
fn try_parse_obsolete_with(&self) -> bool;
fn try_parse_obsolete_priv_section(&self, attrs: &[attribute]) -> bool;
fn try_parse_obsolete_priv_section(&self, attrs: &[Attribute]) -> bool;
}
impl ParserObsoleteMethods for Parser {
@ -328,7 +328,7 @@ impl ParserObsoleteMethods for Parser {
}
}
pub fn try_parse_obsolete_priv_section(&self, attrs: &[attribute])
pub fn try_parse_obsolete_priv_section(&self, attrs: &[Attribute])
-> bool {
if self.is_keyword(keywords::Priv) &&
self.look_ahead(1, |t| *t == token::LBRACE) {

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

@ -15,7 +15,7 @@ use ast::{CallSugar, NoSugar, DoSugar, ForSugar};
use ast::{TyBareFn, TyClosure};
use ast::{RegionTyParamBound, TraitTyParamBound};
use ast::{provided, public, purity};
use ast::{_mod, add, arg, arm, attribute, bind_by_ref, bind_infer};
use ast::{_mod, add, arg, arm, Attribute, bind_by_ref, bind_infer};
use ast::{bitand, bitor, bitxor, blk};
use ast::{blk_check_mode, box};
use ast::{crate, crate_cfg, decl, decl_item};
@ -109,12 +109,12 @@ enum restriction {
}
type arg_or_capture_item = Either<arg, ()>;
type item_info = (ident, item_, Option<~[attribute]>);
type item_info = (ident, item_, Option<~[Attribute]>);
pub enum item_or_view_item {
// Indicates a failure to parse any kind of item. The attributes are
// returned.
iovi_none(~[attribute]),
iovi_none(~[Attribute]),
iovi_item(@item),
iovi_foreign_item(@foreign_item),
iovi_view_item(view_item)
@ -242,8 +242,8 @@ macro_rules! maybe_whole (
)
fn maybe_append(lhs: ~[attribute], rhs: Option<~[attribute]>)
-> ~[attribute] {
fn maybe_append(lhs: ~[Attribute], rhs: Option<~[Attribute]>)
-> ~[Attribute] {
match rhs {
None => lhs,
Some(ref attrs) => vec::append(lhs, (*attrs))
@ -252,7 +252,7 @@ fn maybe_append(lhs: ~[attribute], rhs: Option<~[attribute]>)
struct ParsedItemsAndViewItems {
attrs_remaining: ~[attribute],
attrs_remaining: ~[Attribute],
view_items: ~[view_item],
items: ~[@item],
foreign_items: ~[@foreign_item]
@ -2959,7 +2959,7 @@ impl Parser {
// parse a structure field
fn parse_name_and_ty(&self,
pr: visibility,
attrs: ~[attribute]) -> @struct_field {
attrs: ~[Attribute]) -> @struct_field {
let lo = self.span.lo;
if !is_plain_ident(&*self.token) {
self.fatal("expected ident");
@ -2977,7 +2977,7 @@ impl Parser {
// parse a statement. may include decl.
// precondition: any attributes are parsed already
pub fn parse_stmt(&self, item_attrs: ~[attribute]) -> @stmt {
pub fn parse_stmt(&self, item_attrs: ~[Attribute]) -> @stmt {
maybe_whole!(self, nt_stmt);
fn check_expected_item(p: &Parser, found_attrs: bool) {
@ -3091,7 +3091,7 @@ impl Parser {
// parse a block. Inner attrs are allowed.
fn parse_inner_attrs_and_block(&self)
-> (~[attribute], blk) {
-> (~[Attribute], blk) {
maybe_whole!(pair_empty self, nt_block);
@ -3115,7 +3115,7 @@ impl Parser {
// parse the rest of a block expression or function body
fn parse_block_tail_(&self, lo: BytePos, s: blk_check_mode,
first_item_attrs: ~[attribute]) -> blk {
first_item_attrs: ~[Attribute]) -> blk {
let mut stmts = ~[];
let mut expr = None;
@ -3594,7 +3594,7 @@ impl Parser {
fn mk_item(&self, lo: BytePos, hi: BytePos, ident: ident,
node: item_, vis: visibility,
attrs: ~[attribute]) -> @item {
attrs: ~[Attribute]) -> @item {
@ast::item { ident: ident,
attrs: attrs,
id: self.get_id(),
@ -3825,7 +3825,7 @@ impl Parser {
// parse a structure field declaration
pub fn parse_single_struct_field(&self,
vis: visibility,
attrs: ~[attribute])
attrs: ~[Attribute])
-> @struct_field {
if self.eat_obsolete_ident("let") {
self.obsolete(*self.last_span, ObsoleteLet);
@ -3894,7 +3894,7 @@ impl Parser {
// attributes (of length 0 or 1), parse all of the items in a module
fn parse_mod_items(&self,
term: token::Token,
first_item_attrs: ~[attribute])
first_item_attrs: ~[Attribute])
-> _mod {
// parse all of the items up to closing or an attribute.
// view items are legal here.
@ -3953,7 +3953,7 @@ impl Parser {
}
// parse a `mod <foo> { ... }` or `mod <foo>;` item
fn parse_item_mod(&self, outer_attrs: &[ast::attribute]) -> item_info {
fn parse_item_mod(&self, outer_attrs: &[Attribute]) -> item_info {
let id_span = *self.span;
let id = self.parse_ident();
if *self.token == token::SEMI {
@ -3972,11 +3972,10 @@ impl Parser {
}
}
fn push_mod_path(&self, id: ident, attrs: &[ast::attribute]) {
fn push_mod_path(&self, id: ident, attrs: &[Attribute]) {
let default_path = token::interner_get(id.name);
let file_path = match ::attr::first_attr_value_str_by_name(
attrs, "path") {
let file_path = match ::attr::first_attr_value_str_by_name(attrs,
"path") {
Some(d) => d,
None => default_path
};
@ -3990,14 +3989,13 @@ impl Parser {
// read a module from a source file.
fn eval_src_mod(&self,
id: ast::ident,
outer_attrs: &[ast::attribute],
outer_attrs: &[ast::Attribute],
id_sp: span)
-> (ast::item_, ~[ast::attribute]) {
-> (ast::item_, ~[ast::Attribute]) {
let prefix = Path(self.sess.cm.span_to_filename(*self.span));
let prefix = prefix.dir_path();
let mod_path_stack = &*self.mod_path_stack;
let mod_path = Path(".").push_many(*mod_path_stack);
let default_path = token::interner_get(id.name).to_owned() + ".rs";
let file_path = match ::attr::first_attr_value_str_by_name(
outer_attrs, "path") {
Some(d) => {
@ -4008,7 +4006,7 @@ impl Parser {
path
}
}
None => mod_path.push(default_path)
None => mod_path.push(token::interner_get(id.name) + ".rs") // default
};
self.eval_src_mod_from_path(prefix,
@ -4020,8 +4018,8 @@ impl Parser {
fn eval_src_mod_from_path(&self,
prefix: Path,
path: Path,
outer_attrs: ~[ast::attribute],
id_sp: span) -> (ast::item_, ~[ast::attribute]) {
outer_attrs: ~[ast::Attribute],
id_sp: span) -> (ast::item_, ~[ast::Attribute]) {
let full_path = if path.is_absolute {
path
@ -4057,17 +4055,10 @@ impl Parser {
let m0 = p0.parse_mod_items(token::EOF, first_item_outer_attrs);
self.sess.included_mod_stack.pop();
return (ast::item_mod(m0), mod_attrs);
fn cdir_path_opt(default: @str, attrs: ~[ast::attribute]) -> @str {
match ::attr::first_attr_value_str_by_name(attrs, "path") {
Some(d) => d,
None => default
}
}
}
// parse a function declaration from a foreign module
fn parse_item_foreign_fn(&self, attrs: ~[attribute]) -> @foreign_item {
fn parse_item_foreign_fn(&self, attrs: ~[Attribute]) -> @foreign_item {
let lo = self.span.lo;
let vis = self.parse_visibility();
let purity = self.parse_fn_purity();
@ -4085,7 +4076,7 @@ impl Parser {
// parse a const definition from a foreign module
fn parse_item_foreign_const(&self, vis: ast::visibility,
attrs: ~[attribute]) -> @foreign_item {
attrs: ~[Attribute]) -> @foreign_item {
let lo = self.span.lo;
// XXX: Obsolete; remove after snap.
@ -4130,7 +4121,7 @@ impl Parser {
fn parse_foreign_mod_items(&self,
sort: ast::foreign_mod_sort,
abis: AbiSet,
first_item_attrs: ~[attribute])
first_item_attrs: ~[Attribute])
-> foreign_mod {
let ParsedItemsAndViewItems {
attrs_remaining: attrs_remaining,
@ -4156,7 +4147,7 @@ impl Parser {
lo: BytePos,
opt_abis: Option<AbiSet>,
visibility: visibility,
attrs: ~[attribute],
attrs: ~[Attribute],
items_allowed: bool)
-> item_or_view_item {
let mut must_be_named_mod = false;
@ -4437,7 +4428,7 @@ impl Parser {
// NB: this function no longer parses the items inside an
// extern mod.
fn parse_item_or_view_item(&self,
attrs: ~[attribute],
attrs: ~[Attribute],
macros_allowed: bool)
-> item_or_view_item {
maybe_whole!(iovi self, nt_item);
@ -4569,7 +4560,7 @@ impl Parser {
// parse a foreign item; on failure, return iovi_none.
fn parse_foreign_item(&self,
attrs: ~[attribute],
attrs: ~[Attribute],
macros_allowed: bool)
-> item_or_view_item {
maybe_whole!(iovi self, nt_item);
@ -4594,7 +4585,7 @@ impl Parser {
// this is the fall-through for parsing items.
fn parse_macro_use_or_failure(
&self,
attrs: ~[attribute],
attrs: ~[Attribute],
macros_allowed: bool,
lo : BytePos,
visibility : visibility
@ -4656,7 +4647,7 @@ impl Parser {
return iovi_none(attrs);
}
pub fn parse_item(&self, attrs: ~[attribute]) -> Option<@ast::item> {
pub fn parse_item(&self, attrs: ~[Attribute]) -> Option<@ast::item> {
match self.parse_item_or_view_item(attrs, true) {
iovi_none(_) =>
None,
@ -4793,7 +4784,7 @@ impl Parser {
// parse a view item.
fn parse_view_item(
&self,
attrs: ~[attribute],
attrs: ~[Attribute],
vis: visibility
) -> view_item {
let lo = self.span.lo;
@ -4819,7 +4810,7 @@ impl Parser {
// - mod_items uses extern_mod_allowed = true
// - block_tail_ uses extern_mod_allowed = false
fn parse_items_and_view_items(&self,
first_item_attrs: ~[attribute],
first_item_attrs: ~[Attribute],
mut extern_mod_allowed: bool,
macros_allowed: bool)
-> ParsedItemsAndViewItems {
@ -4901,7 +4892,7 @@ impl Parser {
// Parses a sequence of foreign items. Stops when it finds program
// text that can't be parsed as an item
fn parse_foreign_items(&self, first_item_attrs: ~[attribute],
fn parse_foreign_items(&self, first_item_attrs: ~[Attribute],
macros_allowed: bool)
-> ParsedItemsAndViewItems {
let mut attrs = vec::append(first_item_attrs,

37
src/libsyntax/print/pprust.rs
View file

@ -14,7 +14,7 @@ use ast;
use ast_util;
use opt_vec::OptVec;
use opt_vec;
use attr;
use attr::{AttrMetaMethods, AttributeMethods};
use codemap::{CodeMap, BytePos};
use codemap;
use diagnostic;
@ -212,11 +212,11 @@ pub fn block_to_str(blk: &ast::blk, intr: @ident_interner) -> ~str {
}
}
pub fn meta_item_to_str(mi: &ast::meta_item, intr: @ident_interner) -> ~str {
pub fn meta_item_to_str(mi: &ast::MetaItem, intr: @ident_interner) -> ~str {
to_str(mi, print_meta_item, intr)
}
pub fn attribute_to_str(attr: &ast::attribute, intr: @ident_interner) -> ~str {
pub fn attribute_to_str(attr: &ast::Attribute, intr: @ident_interner) -> ~str {
to_str(attr, print_attribute, intr)
}
@ -352,7 +352,7 @@ pub fn commasep_exprs(s: @ps, b: breaks, exprs: &[@ast::expr]) {
commasep_cmnt(s, b, exprs, |p, &e| print_expr(p, e), |e| e.span);
}
pub fn print_mod(s: @ps, _mod: &ast::_mod, attrs: &[ast::attribute]) {
pub fn print_mod(s: @ps, _mod: &ast::_mod, attrs: &[ast::Attribute]) {
print_inner_attributes(s, attrs);
for _mod.view_items.iter().advance |vitem| {
print_view_item(s, vitem);
@ -361,7 +361,7 @@ pub fn print_mod(s: @ps, _mod: &ast::_mod, attrs: &[ast::attribute]) {
}
pub fn print_foreign_mod(s: @ps, nmod: &ast::foreign_mod,
attrs: &[ast::attribute]) {
attrs: &[ast::Attribute]) {
print_inner_attributes(s, attrs);
for nmod.view_items.iter().advance |vitem| {
print_view_item(s, vitem);
@ -843,22 +843,22 @@ pub fn print_method(s: @ps, meth: &ast::method) {
print_block_with_attrs(s, &meth.body, meth.attrs);
}
pub fn print_outer_attributes(s: @ps, attrs: &[ast::attribute]) {
pub fn print_outer_attributes(s: @ps, attrs: &[ast::Attribute]) {
let mut count = 0;
for attrs.iter().advance |attr| {
match attr.node.style {
ast::attr_outer => { print_attribute(s, attr); count += 1; }
ast::AttrOuter => { print_attribute(s, attr); count += 1; }
_ => {/* fallthrough */ }
}
}
if count > 0 { hardbreak_if_not_bol(s); }
}
pub fn print_inner_attributes(s: @ps, attrs: &[ast::attribute]) {
pub fn print_inner_attributes(s: @ps, attrs: &[ast::Attribute]) {
let mut count = 0;
for attrs.iter().advance |attr| {
match attr.node.style {
ast::attr_inner => {
ast::AttrInner => {
print_attribute(s, attr);
if !attr.node.is_sugared_doc {
word(s.s, ";");
@ -871,16 +871,15 @@ pub fn print_inner_attributes(s: @ps, attrs: &[ast::attribute]) {
if count > 0 { hardbreak_if_not_bol(s); }
}
pub fn print_attribute(s: @ps, attr: &ast::attribute) {
pub fn print_attribute(s: @ps, attr: &ast::Attribute) {
hardbreak_if_not_bol(s);
maybe_print_comment(s, attr.span.lo);
if attr.node.is_sugared_doc {
let meta = attr::attr_meta(*attr);
let comment = attr::get_meta_item_value_str(meta).get();
let comment = attr.value_str().get();
word(s.s, comment);
} else {
word(s.s, "#[");
print_meta_item(s, attr.node.value);
print_meta_item(s, attr.meta());
word(s.s, "]");
}
}
@ -927,7 +926,7 @@ pub fn print_block_unclosed_indent(s: @ps, blk: &ast::blk, indented: uint) {
pub fn print_block_with_attrs(s: @ps,
blk: &ast::blk,
attrs: &[ast::attribute]) {
attrs: &[ast::Attribute]) {
print_possibly_embedded_block_(s, blk, block_normal, indent_unit, attrs,
true);
}
@ -946,7 +945,7 @@ pub fn print_possibly_embedded_block_(s: @ps,
blk: &ast::blk,
embedded: embed_type,
indented: uint,
attrs: &[ast::attribute],
attrs: &[ast::Attribute],
close_box: bool) {
match blk.rules {
ast::unsafe_blk => word_space(s, "unsafe"),
@ -1793,16 +1792,16 @@ pub fn print_generics(s: @ps, generics: &ast::Generics) {
}
}
pub fn print_meta_item(s: @ps, item: &ast::meta_item) {
pub fn print_meta_item(s: @ps, item: &ast::MetaItem) {
ibox(s, indent_unit);
match item.node {
ast::meta_word(name) => word(s.s, name),
ast::meta_name_value(name, value) => {
ast::MetaWord(name) => word(s.s, name),
ast::MetaNameValue(name, value) => {
word_space(s, name);
word_space(s, "=");
print_literal(s, @value);
}
ast::meta_list(name, ref items) => {
ast::MetaList(name, ref items) => {
word(s.s, name);
popen(s);
commasep(s,