Implement RFC#1559: allow all literals in attributes.

Author: SergioBenitez

src/librustc/hir/check_attr.rs

@@ -11,7 +11,7 @@
 use session::Session;
 
 use syntax::ast;
-use syntax::attr::AttrMetaMethods;
+use syntax::attr::{AttrNestedMetaItemMethods, AttrMetaMethods};
 use syntax::visit;
 use syntax::visit::Visitor;
 
@@ -52,18 +52,22 @@ impl<'a> CheckAttrVisitor<'a> {
                 return;
             }
         };
+
         for word in words {
-            let word: &str = &word.name();
-            let message = match word {
+            let name = match word.name() {
+                Some(word) => word,
+                None => continue,
+            };
+
+            let message = match &*name {
                 "C" => {
                     if target != Target::Struct && target != Target::Enum {
-                            "attribute should be applied to struct or enum"
+                        "attribute should be applied to struct or enum"
                     } else {
                         continue
                     }
                 }
-                "packed" |
-                "simd" => {
+                "packed" | "simd" => {
                     if target != Target::Struct {
                         "attribute should be applied to struct"
                     } else {
@@ -74,13 +78,14 @@ impl<'a> CheckAttrVisitor<'a> {
                 "i32" | "u32" | "i64" | "u64" |
                 "isize" | "usize" => {
                     if target != Target::Enum {
-                            "attribute should be applied to enum"
+                        "attribute should be applied to enum"
                     } else {
                         continue
                     }
                 }
                 _ => continue,
             };
+
             span_err!(self.sess, attr.span, E0517, "{}", message);
         }
     }

src/librustc/hir/fold.rs

@@ -12,8 +12,8 @@
 //! and returns a piece of the same type.
 
 use hir::*;
-use syntax::ast::{Name, NodeId, DUMMY_NODE_ID, Attribute, Attribute_, MetaItem};
-use syntax::ast::MetaItemKind;
+use syntax::ast::{Name, NodeId, DUMMY_NODE_ID, Attribute, Attribute_};
+use syntax::ast::{NestedMetaItem, NestedMetaItemKind, MetaItem, MetaItemKind};
 use hir;
 use syntax_pos::Span;
 use syntax::codemap::{respan, Spanned};
@@ -38,6 +38,10 @@ pub trait Folder : Sized {
         noop_fold_meta_items(meta_items, self)
     }
 
+    fn fold_meta_list_item(&mut self, list_item: NestedMetaItem) -> NestedMetaItem {
+        noop_fold_meta_list_item(list_item, self)
+    }
+
     fn fold_meta_item(&mut self, meta_item: P<MetaItem>) -> P<MetaItem> {
         noop_fold_meta_item(meta_item, self)
     }
@@ -486,13 +490,26 @@ pub fn noop_fold_attribute<T: Folder>(at: Attribute, fld: &mut T) -> Option<Attr
     })
 }
 
+pub fn noop_fold_meta_list_item<T: Folder>(li: NestedMetaItem, fld: &mut T)
+    -> NestedMetaItem {
+    Spanned {
+        node: match li.node {
+            NestedMetaItemKind::MetaItem(mi) =>  {
+                NestedMetaItemKind::MetaItem(fld.fold_meta_item(mi))
+            },
+            NestedMetaItemKind::Literal(lit) => NestedMetaItemKind::Literal(lit)
+        },
+        span: fld.new_span(li.span)
+    }
+}
+
 pub fn noop_fold_meta_item<T: Folder>(mi: P<MetaItem>, fld: &mut T) -> P<MetaItem> {
     mi.map(|Spanned { node, span }| {
         Spanned {
             node: match node {
                 MetaItemKind::Word(id) => MetaItemKind::Word(id),
                 MetaItemKind::List(id, mis) => {
-                    MetaItemKind::List(id, mis.move_map(|e| fld.fold_meta_item(e)))
+                    MetaItemKind::List(id, mis.move_map(|e| fld.fold_meta_list_item(e)))
                 }
                 MetaItemKind::NameValue(id, s) => MetaItemKind::NameValue(id, s),
             },