---

yaml
---
r: 3658
b: refs/heads/master
c: 0226f56
h: refs/heads/master
v: v3

Author: pcwalton

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: 7714cb297b5ef54690acaec26cae4828adfceab7
+refs/heads/master: 0226f561156e2e01941d643bf261729af4083cae

trunk/src/comp/front/attr.rs

@@ -1,5 +1,6 @@
 // Functions dealing with attributes and meta_items
 
+import std::ivec;
 import std::vec;
 import std::str;
 import std::map;
@@ -28,7 +29,7 @@ export mk_attr;
 
 // From a list of crate attributes get only the meta_items that impact crate
 // linkage
-fn find_linkage_metas(vec[ast::attribute] attrs) -> vec[@ast::meta_item] {
+fn find_linkage_metas(&ast::attribute[] attrs) -> vec[@ast::meta_item] {
     let vec[@ast::meta_item] metas = [];
     for (ast::attribute attr in find_attrs_by_name(attrs, "link")) {
         alt (attr.node.value.node) {
@@ -44,8 +45,8 @@ fn find_linkage_metas(vec[ast::attribute] attrs) -> vec[@ast::meta_item] {
 }
 
 // Search a list of attributes and return only those with a specific name
-fn find_attrs_by_name(vec[ast::attribute] attrs,
-                      ast::ident name) -> vec[ast::attribute] {
+fn find_attrs_by_name(&ast::attribute[] attrs,
+                      ast::ident name) -> ast::attribute[] {
     auto filter = bind fn(&ast::attribute a,
                           ast::ident name) -> option::t[ast::attribute] {
         if (get_attr_name(a) == name) {
@@ -54,7 +55,7 @@ fn find_attrs_by_name(vec[ast::attribute] attrs,
             option::none
         }
     } (_, name);
-    ret vec::filter_map(filter, attrs);
+    ret ivec::filter_map(filter, attrs);
 }
 
 fn get_attr_name(&ast::attribute attr) -> ast::ident {
@@ -101,8 +102,10 @@ fn get_meta_item_value_str(&@ast::meta_item meta) -> option::t[str] {
 fn attr_meta(&ast::attribute attr) -> @ast::meta_item { @attr.node.value }
 
 // Get the meta_items from inside a vector of attributes
-fn attr_metas(&vec[ast::attribute] attrs) -> vec[@ast::meta_item] {
-    ret vec::map(attr_meta, attrs);
+fn attr_metas(&ast::attribute[] attrs) -> vec[@ast::meta_item] {
+    auto mitems = [];
+    for (ast::attribute a in attrs) { mitems += [attr_meta(a)]; }
+    ret mitems;
 }
 
 fn eq(@ast::meta_item a, @ast::meta_item b) -> bool {

trunk/src/comp/front/config.rs

@@ -1,3 +1,4 @@
+import std::ivec;
 import std::option;
 import std::vec;
 import syntax::ast;
@@ -97,11 +98,11 @@ fn native_item_in_cfg(&ast::crate_cfg cfg, &@ast::native_item item) -> bool {
 
 // Determine if an item should be translated in the current crate
 // configuration based on the item's attributes
-fn in_cfg(&ast::crate_cfg cfg, &vec[ast::attribute] attrs) -> bool {
+fn in_cfg(&ast::crate_cfg cfg, &ast::attribute[] attrs) -> bool {
 
     // The "cfg" attributes on the item
     auto item_cfg_attrs = attr::find_attrs_by_name(attrs, "cfg");
-    auto item_has_cfg_attrs = vec::len(item_cfg_attrs) > 0u;
+    auto item_has_cfg_attrs = ivec::len(item_cfg_attrs) > 0u;
     if (!item_has_cfg_attrs) { ret true; }
 
     // Pull the inner meta_items from the #[cfg(meta_item, ...)]  attributes,

trunk/src/comp/metadata/decoder.rs

@@ -290,8 +290,8 @@ fn get_meta_items(&ebml::doc md) -> vec[@ast::meta_item] {
     ret items;
 }
 
-fn get_attributes(&ebml::doc md) -> vec[ast::attribute] {
-    let vec[ast::attribute] attrs = [];
+fn get_attributes(&ebml::doc md) -> ast::attribute[] {
+    let ast::attribute[] attrs = ~[];
     alt (ebml::maybe_get_doc(md, tag_attributes)) {
         case (option::some(?attrs_d)) {
             for each (ebml::doc attr_doc in
@@ -301,9 +301,9 @@ fn get_attributes(&ebml::doc md) -> vec[ast::attribute] {
                 // an attribute
                 assert (vec::len(meta_items) == 1u);
                 auto meta_item = meta_items.(0);
-                attrs += [rec(node=rec(style=ast::attr_outer,
-                                       value=*meta_item),
-                              span=rec(lo=0u, hi=0u))];
+                attrs += ~[rec(node=rec(style=ast::attr_outer,
+                                        value=*meta_item),
+                               span=rec(lo=0u, hi=0u))];
             }
         }
         case (option::none) { }
@@ -327,7 +327,7 @@ fn list_crate_attributes(&ebml::doc md, io::writer out) {
     out.write_str("\n\n");
 }
 
-fn get_crate_attributes(&vec[u8] data) -> vec[ast::attribute] {
+fn get_crate_attributes(&vec[u8] data) -> ast::attribute[] {
     ret get_attributes(ebml::new_doc(data));
 }
 

trunk/src/comp/syntax/ast.rs

@@ -87,13 +87,13 @@ type crate = spanned[crate_];
 
 type crate_ = rec(vec[@crate_directive] directives,
                   _mod module,
-                  vec[attribute] attrs,
+                  attribute[] attrs,
                   crate_cfg config);
 
 tag crate_directive_ {
-    cdir_src_mod(ident, option::t[filename], vec[attribute]);
+    cdir_src_mod(ident, option::t[filename], attribute[]);
     cdir_dir_mod(ident, option::t[filename],
-                 vec[@crate_directive], vec[attribute]);
+                 vec[@crate_directive], attribute[]);
     cdir_view_item(@view_item);
     cdir_syntax(path);
     cdir_auth(path, _auth);
@@ -526,7 +526,7 @@ tag attr_style { attr_outer; attr_inner; }
 type attribute_ = rec(attr_style style, meta_item value);
 
 type item = rec(ident ident,
-                vec[attribute] attrs,
+                attribute[] attrs,
                 node_id id, // For objs and resources, this is the type def_id
                 item_ node,
                 span span);
@@ -544,7 +544,7 @@ tag item_ {
 }
 
 type native_item = rec(ident ident,
-                       vec[attribute] attrs,
+                       attribute[] attrs,
                        native_item_ node,
                        node_id id,
                        span span);

trunk/src/comp/syntax/fold.rs

@@ -132,10 +132,10 @@ fn noop_fold_crate(&crate_ c, ast_fold fld) -> crate_ {
     auto fold_meta_item = bind fold_meta_item_(_,fld);
     auto fold_attribute = bind fold_attribute_(_,fold_meta_item);
 
-    ret rec(directives=map(fld.fold_crate_directive, c.directives),
+    ret rec(directives=vec::map(fld.fold_crate_directive, c.directives),
             module=fld.fold_mod(c.module),
-            attrs=map(fold_attribute, c.attrs),
-            config=map(fold_meta_item, c.config));
+            attrs=ivec::map(fold_attribute, c.attrs),
+            config=vec::map(fold_meta_item, c.config));
 }
 
 fn noop_fold_crate_directive(&crate_directive_ cd, ast_fold fld) 
@@ -167,7 +167,7 @@ fn noop_fold_native_item(&@native_item ni, ast_fold fld) -> @native_item {
     auto fold_attribute = bind fold_attribute_(_,fold_meta_item);
 
     ret @rec(ident=fld.fold_ident(ni.ident),
-             attrs=map(fold_attribute, ni.attrs),
+             attrs=ivec::map(fold_attribute, ni.attrs),
              node=alt (ni.node) {
                  case (native_item_ty) { native_item_ty }
                  case (native_item_fn(?st, ?fdec, ?typms)) {
@@ -189,7 +189,7 @@ fn noop_fold_item(&@item i, ast_fold fld) -> @item {
     auto fold_attribute = bind fold_attribute_(_,fold_meta_item);
 
     ret @rec(ident=fld.fold_ident(i.ident),
-             attrs=map(fold_attribute,i.attrs),
+             attrs=ivec::map(fold_attribute,i.attrs),
              id=i.id, node=fld.fold_item_underscore(i.node),
              span=i.span);
 }