---

yaml
---
r: 64478
b: refs/heads/snap-stage3
c: 968f7f5
h: refs/heads/master
v: v3

Author: Eric Reed

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: cc760a647ac0094814f592d08813ebae0b3bec47
+refs/heads/snap-stage3: 968f7f5d3d64b481fb68651d9274768fe5e98853
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/src/librustc/back/link.rs

@@ -36,7 +36,6 @@ 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;
 
@@ -503,7 +502,7 @@ pub fn build_link_meta(sess: Session,
     struct ProvidedMetas {
         name: Option<@str>,
         vers: Option<@str>,
-        cmh_items: ~[@ast::MetaItem]
+        cmh_items: ~[@ast::meta_item]
     }
 
     fn provided_link_metas(sess: Session, c: &ast::crate) ->
@@ -514,10 +513,18 @@ 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 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)
+            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),
+                        _ => cmh_items.push(*meta)
+                    }
+                },
+                None => cmh_items.push(*meta)
             }
         }
 
@@ -530,7 +537,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::MetaItem],
+                              cmh_items: ~[@ast::meta_item],
                               dep_hashes: ~[@str]) -> @str {
         fn len_and_str(s: &str) -> ~str {
             fmt!("%u_%s", s.len(), s)
@@ -542,16 +549,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::MetaItem) {
+        fn hash(symbol_hasher: &mut hash::State, m: &@ast::meta_item) {
             match m.node {
-              ast::MetaNameValue(key, value) => {
+              ast::meta_name_value(key, value) => {
                 write_string(symbol_hasher, len_and_str(key));
                 write_string(symbol_hasher, len_and_str_lit(value));
               }
-              ast::MetaWord(name) => {
+              ast::meta_word(name) => {
                 write_string(symbol_hasher, len_and_str(name));
               }
-              ast::MetaList(name, ref mis) => {
+              ast::meta_list(name, ref mis) => {
                 write_string(symbol_hasher, len_and_str(name));
                 for mis.iter().advance |m_| {
                     hash(symbol_hasher, m_);

branches/snap-stage3/src/librustc/driver/driver.rs

@@ -34,7 +34,6 @@ 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;
@@ -96,9 +95,12 @@ pub fn default_configuration(sess: Session, argv0: @str, input: &input) ->
          mk(@"build_input", source_name(input))];
 }
 
-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))
+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))
     }
 }
 
@@ -107,11 +109,18 @@ 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 mut user_cfg = sess.opts.cfg.clone();
+    let user_cfg = sess.opts.cfg.clone();
     // If the user wants a test runner, then add the test cfg
-    if sess.opts.test { append_configuration(&mut user_cfg, @"test") }
+    let user_cfg = if sess.opts.test {
+        append_configuration(user_cfg, @"test")
+    } else {
+        user_cfg
+    };
+
     // If the user requested GC, then add the GC cfg
-    append_configuration(&mut user_cfg, if sess.opts.gc { @"gc" } else { @"nogc" });
+    let user_cfg = append_configuration(
+        user_cfg,
+        if sess.opts.gc { @"gc" } else { @"nogc" });
     return vec::append(user_cfg, default_cfg);
 }
 
@@ -121,7 +130,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::<ast::crate_cfg>()
+    }.collect()
 }
 
 pub enum input {
@@ -206,7 +215,6 @@ 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));
     }
@@ -862,7 +870,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;
@@ -904,10 +912,12 @@ 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_name = linkage_metas.iter().find_(|m| "name" == m.name());
-              match maybe_name.chain(|m| m.value_str()) {
-                  Some(s) => stem = s,
-                  _ => ()
+              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]) {
+                      Some(s) => stem = s,
+                      _ => ()
+                  }
               }
               // If the name is missing, we just default to the filename
               // version
@@ -1001,8 +1011,7 @@ mod test {
             @"rustc", matches, diagnostic::emit);
         let sess = build_session(sessopts, diagnostic::emit);
         let cfg = build_configuration(sess, @"whatever", &str_input(@""));
-        let mut test_items = cfg.iter().filter(|m| "test" == m.name());
-        assert!(test_items.next().is_some());
-        assert!(test_items.next().is_none());
+        let test_items = attr::find_meta_items_by_name(cfg, "test");
+        assert_eq!(test_items.len(), 1u);
     }
 }

branches/snap-stage3/src/librustc/driver/session.rs

@@ -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) => "lib" == s,
+              Some(s) if "lib" == s => true,
               _ => false
             }
         }
@@ -395,11 +395,18 @@ 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 {
-        attr::mk_attr(attr::mk_name_value_item_str(@"crate_type", t))
+    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(with_bin: bool, with_lib: bool) -> @ast::crate {

branches/snap-stage3/src/librustc/front/config.rs

@@ -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,6 +175,31 @@ 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::MetaItem], attrs: &[ast::Attribute]) -> bool {
-    attr::test_cfg(cfg, attrs.iter().transform(|x| *x))
+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)
+            }
+        })
+    })
 }

branches/snap-stage3/src/librustc/front/std_inject.rs

@@ -30,10 +30,10 @@ pub fn maybe_inject_libstd_ref(sess: Session, crate: @ast::crate)
 }
 
 fn use_std(crate: &ast::crate) -> bool {
-    !attr::contains_name(crate.node.attrs, "no_std")
+    !attr::attrs_contains_name(crate.node.attrs, "no_std")
 }
-fn no_prelude(attrs: &[ast::Attribute]) -> bool {
-    attr::contains_name(attrs, "no_implicit_prelude")
+fn no_prelude(attrs: &[ast::attribute]) -> bool {
+    attr::attrs_contains_name(attrs, "no_implicit_prelude")
 }
 
 fn inject_libstd_ref(sess: Session, crate: &ast::crate) -> @ast::crate {
@@ -48,8 +48,14 @@ fn inject_libstd_ref(sess: Session, crate: &ast::crate) -> @ast::crate {
                 node: ast::view_item_extern_mod(
                         sess.ident_of("std"), ~[], n1),
                 attrs: ~[
-                    attr::mk_attr(
-                        attr::mk_name_value_item_str(@"vers", STD_VERSION.to_managed()))
+                    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
+                    })
                 ],
                 vis: ast::private,
                 span: dummy_sp()