Allow using inert attributes from proc_macro_derives with #![feature(proc_macro)].

Author: jseyfried

src/librustc_metadata/creader.rs

@@ -616,10 +616,9 @@ impl<'a> CrateLoader<'a> {
                                       trait_name: &str,
                                       expand: fn(TokenStream) -> TokenStream,
                                       attributes: &[&'static str]) {
-                let attrs = attributes.iter().cloned().map(Symbol::intern).collect();
-                let derive = SyntaxExtension::ProcMacroDerive(
-                    Box::new(ProcMacroDerive::new(expand, attrs))
-                );
+                let attrs = attributes.iter().cloned().map(Symbol::intern).collect::<Vec<_>>();
+                let derive = ProcMacroDerive::new(expand, attrs.clone());
+                let derive = SyntaxExtension::ProcMacroDerive(Box::new(derive), attrs);
                 self.0.push((Symbol::intern(trait_name), Rc::new(derive)));
             }
 

src/librustc_resolve/macros.rs

@@ -27,7 +27,7 @@ use syntax::ext::base::{NormalTT, Resolver as SyntaxResolver, SyntaxExtension};
 use syntax::ext::expand::{Expansion, mark_tts};
 use syntax::ext::hygiene::Mark;
 use syntax::ext::tt::macro_rules;
-use syntax::feature_gate::{self, emit_feature_err, GateIssue, is_builtin_attr};
+use syntax::feature_gate::{self, emit_feature_err, GateIssue};
 use syntax::fold::{self, Folder};
 use syntax::ptr::P;
 use syntax::symbol::{Symbol, keywords};
@@ -130,12 +130,16 @@ impl<'a> base::Resolver for Resolver<'a> {
         self.whitelisted_legacy_custom_derives.contains(&name)
     }
 
-    fn visit_expansion(&mut self, mark: Mark, expansion: &Expansion) {
+    fn visit_expansion(&mut self, mark: Mark, expansion: &Expansion, derives: &[Mark]) {
         let invocation = self.invocations[&mark];
         self.collect_def_ids(invocation, expansion);
 
         self.current_module = invocation.module.get();
         self.current_module.unresolved_invocations.borrow_mut().remove(&mark);
+        self.current_module.unresolved_invocations.borrow_mut().extend(derives);
+        for &derive in derives {
+            self.invocations.insert(derive, invocation);
+        }
         let mut visitor = BuildReducedGraphVisitor {
             resolver: self,
             legacy_scope: LegacyScope::Invocation(invocation),
@@ -172,7 +176,9 @@ impl<'a> base::Resolver for Resolver<'a> {
         ImportResolver { resolver: self }.resolve_imports()
     }
 
-    fn find_attr_invoc(&mut self, attrs: &mut Vec<ast::Attribute>) -> Option<ast::Attribute> {
+    // Resolves attribute and derive legacy macros from `#![plugin(..)]`.
+    fn find_legacy_attr_invoc(&mut self, attrs: &mut Vec<ast::Attribute>)
+                              -> Option<ast::Attribute> {
         for i in 0..attrs.len() {
             match self.builtin_macros.get(&attrs[i].name()).cloned() {
                 Some(binding) => match *binding.get_macro(self) {
@@ -183,10 +189,6 @@ impl<'a> base::Resolver for Resolver<'a> {
                 },
                 None => {}
             }
-
-            if self.proc_macro_enabled && !is_builtin_attr(&attrs[i]) {
-                return Some(attrs.remove(i));
-            }
         }
 
         // Check for legacy derives
@@ -212,7 +214,7 @@ impl<'a> base::Resolver for Resolver<'a> {
                     } else {
                         attrs[i].value = ast::MetaItem {
                             name: attrs[i].name(),
-                            span: span,
+                            span: attrs[i].span,
                             node: ast::MetaItemKind::List(traits),
                         };
                     }
@@ -279,7 +281,7 @@ impl<'a> base::Resolver for Resolver<'a> {
                 Ok(binding) => Ok(binding.get_macro(self)),
                 Err(Determinacy::Undetermined) if !force => return Err(Determinacy::Undetermined),
                 _ => {
-                    let msg = format!("macro undefined: '{}!'", name);
+                    let msg = format!("macro undefined: `{}`", name);
                     let mut err = self.session.struct_span_err(span, &msg);
                     self.suggest_macro_name(&name.as_str(), &mut err);
                     err.emit();
@@ -294,13 +296,6 @@ impl<'a> base::Resolver for Resolver<'a> {
         result
     }
 
-    fn resolve_builtin_macro(&mut self, tname: Name) -> Result<Rc<SyntaxExtension>, Determinacy> {
-        match self.builtin_macros.get(&tname).cloned() {
-            Some(binding) => Ok(binding.get_macro(self)),
-            None => Err(Determinacy::Undetermined),
-        }
-    }
-
     fn resolve_derive_macro(&mut self, scope: Mark, path: &ast::Path, force: bool)
                             -> Result<Rc<SyntaxExtension>, Determinacy> {
         let ast::Path { span, .. } = *path;

src/libsyntax/ext/base.rs

@@ -514,7 +514,7 @@ pub enum SyntaxExtension {
     /// The input is the annotated item.
     /// Allows generating code to implement a Trait for a given struct
     /// or enum item.
-    ProcMacroDerive(Box<MultiItemModifier>),
+    ProcMacroDerive(Box<MultiItemModifier>, Vec<Symbol> /* inert attribute names */),
 
     /// An attribute-like procedural macro that derives a builtin trait.
     BuiltinDerive(BuiltinDeriveFn),
@@ -528,15 +528,15 @@ pub trait Resolver {
     fn eliminate_crate_var(&mut self, item: P<ast::Item>) -> P<ast::Item>;
     fn is_whitelisted_legacy_custom_derive(&self, name: Name) -> bool;
 
-    fn visit_expansion(&mut self, mark: Mark, expansion: &Expansion);
+    fn visit_expansion(&mut self, mark: Mark, expansion: &Expansion, derives: &[Mark]);
     fn add_ext(&mut self, ident: ast::Ident, ext: Rc<SyntaxExtension>);
     fn add_expansions_at_stmt(&mut self, id: ast::NodeId, macros: Vec<Mark>);
 
     fn resolve_imports(&mut self);
-    fn find_attr_invoc(&mut self, attrs: &mut Vec<Attribute>) -> Option<Attribute>;
+    // Resolves attribute and derive legacy macros from `#![plugin(..)]`.
+    fn find_legacy_attr_invoc(&mut self, attrs: &mut Vec<Attribute>) -> Option<Attribute>;
     fn resolve_macro(&mut self, scope: Mark, path: &ast::Path, force: bool)
                      -> Result<Rc<SyntaxExtension>, Determinacy>;
-    fn resolve_builtin_macro(&mut self, tname: Name) -> Result<Rc<SyntaxExtension>, Determinacy>;
     fn resolve_derive_macro(&mut self, scope: Mark, path: &ast::Path, force: bool)
                             -> Result<Rc<SyntaxExtension>, Determinacy>;
 }
@@ -555,19 +555,16 @@ impl Resolver for DummyResolver {
     fn eliminate_crate_var(&mut self, item: P<ast::Item>) -> P<ast::Item> { item }
     fn is_whitelisted_legacy_custom_derive(&self, _name: Name) -> bool { false }
 
-    fn visit_expansion(&mut self, _invoc: Mark, _expansion: &Expansion) {}
+    fn visit_expansion(&mut self, _invoc: Mark, _expansion: &Expansion, _derives: &[Mark]) {}
     fn add_ext(&mut self, _ident: ast::Ident, _ext: Rc<SyntaxExtension>) {}
     fn add_expansions_at_stmt(&mut self, _id: ast::NodeId, _macros: Vec<Mark>) {}
 
     fn resolve_imports(&mut self) {}
-    fn find_attr_invoc(&mut self, _attrs: &mut Vec<Attribute>) -> Option<Attribute> { None }
+    fn find_legacy_attr_invoc(&mut self, _attrs: &mut Vec<Attribute>) -> Option<Attribute> { None }
     fn resolve_macro(&mut self, _scope: Mark, _path: &ast::Path, _force: bool)
                      -> Result<Rc<SyntaxExtension>, Determinacy> {
         Err(Determinacy::Determined)
     }
-    fn resolve_builtin_macro(&mut self, _tname: Name) -> Result<Rc<SyntaxExtension>, Determinacy> {
-        Err(Determinacy::Determined)
-    }
     fn resolve_derive_macro(&mut self, _scope: Mark, _path: &ast::Path, _force: bool)
                             -> Result<Rc<SyntaxExtension>, Determinacy> {
         Err(Determinacy::Determined)

src/libsyntax/ext/derive.rs

@@ -8,124 +8,42 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use ast::Name;
-use attr;
-use ast::{self, NestedMetaItem}; use ext::base::{ExtCtxt, SyntaxExtension};
-use codemap;
+use attr::HasAttrs;
+use {ast, codemap};
+use ext::base::ExtCtxt;
 use ext::build::AstBuilder;
 use symbol::Symbol;
 use syntax_pos::Span;
 
-pub fn derive_attr_trait<'a>(cx: &mut ExtCtxt, attr: &'a ast::Attribute)
-                             -> Option<&'a NestedMetaItem> {
-    if attr.name() != "derive" {
-        return None;
-    }
-    if attr.value_str().is_some() {
-        cx.span_err(attr.span, "unexpected value in `derive`");
-        return None;
-    }
-
-    let traits = attr.meta_item_list().unwrap_or(&[]);
-
-    if traits.is_empty() {
-        cx.span_warn(attr.span, "empty trait list in `derive`");
-        return None;
-    }
-
-    return traits.get(0);
-}
-
-pub fn verify_derive_attrs(cx: &mut ExtCtxt, attrs: &[ast::Attribute]) {
-    for attr in attrs {
+pub fn collect_derives(cx: &mut ExtCtxt, attrs: &mut Vec<ast::Attribute>) -> Vec<(Symbol, Span)> {
+    let mut result = Vec::new();
+    attrs.retain(|attr| {
         if attr.name() != "derive" {
-            continue;
+            return true;
         }
 
         if attr.value_str().is_some() {
             cx.span_err(attr.span, "unexpected value in `derive`");
+            return false;
         }
 
         let traits = attr.meta_item_list().unwrap_or(&[]).to_owned();
-
         if traits.is_empty() {
             cx.span_warn(attr.span, "empty trait list in `derive`");
-            attr::mark_used(&attr);
-            continue;
+            return false;
         }
+
         for titem in traits {
             if titem.word().is_none() {
                 cx.span_err(titem.span, "malformed `derive` entry");
+                return false;
             }
-        }
-    }
-}
-
-#[derive(PartialEq, Debug, Clone, Copy)]
-pub enum DeriveType {
-    ProcMacro,
-    Builtin
-}
-
-impl DeriveType {
-    // Classify a derive trait name by resolving the macro.
-    pub fn classify(cx: &mut ExtCtxt, tname: Name) -> DeriveType {
-        match cx.resolver.resolve_builtin_macro(tname) {
-            Ok(ext) => match *ext {
-                SyntaxExtension::BuiltinDerive(..) => DeriveType::Builtin,
-                _ => DeriveType::ProcMacro,
-            },
-            Err(_) => DeriveType::ProcMacro,
-        }
-    }
-}
-
-pub fn get_derive_attr(cx: &mut ExtCtxt, attrs: &mut Vec<ast::Attribute>,
-                       derive_type: DeriveType) -> Option<ast::Attribute> {
-    for i in 0..attrs.len() {
-        if attrs[i].name() != "derive" {
-            continue;
-        }
-
-        if attrs[i].value_str().is_some() {
-            continue;
-        }
-
-        let mut traits = attrs[i].meta_item_list().unwrap_or(&[]).to_owned();
-
-        // First, weed out malformed #[derive]
-        traits.retain(|titem| titem.word().is_some());
-
-        let mut titem = None;
-
-        // See if we can find a matching trait.
-        for j in 0..traits.len() {
-            let tname = match traits[j].name() {
-                Some(tname) => tname,
-                _ => continue,
-            };
-
-            if DeriveType::classify(cx, tname) == derive_type {
-                titem = Some(traits.remove(j));
-                break;
-            }
+            result.push((titem.name().unwrap(), titem.span));
         }
 
-        // If we find a trait, remove the trait from the attribute.
-        if let Some(titem) = titem {
-            if traits.len() == 0 {
-                attrs.remove(i);
-            } else {
-                let derive = Symbol::intern("derive");
-                let mitem = cx.meta_list(titem.span, derive, traits);
-                attrs[i] = cx.attribute(titem.span, mitem);
-            }
-            let derive = Symbol::intern("derive");
-            let mitem = cx.meta_list(titem.span, derive, vec![titem]);
-            return Some(cx.attribute(mitem.span, mitem));
-        }
-    }
-    return None;
+        true
+    });
+    result
 }
 
 fn allow_unstable(cx: &mut ExtCtxt, span: Span, attr_name: &str) -> Span {
@@ -142,43 +60,25 @@ fn allow_unstable(cx: &mut ExtCtxt, span: Span, attr_name: &str) -> Span {
     }
 }
 
-pub fn add_derived_markers(cx: &mut ExtCtxt, attrs: &mut Vec<ast::Attribute>) {
-    if attrs.is_empty() {
-        return;
-    }
-
-    let titems = attrs.iter().filter(|a| {
-        a.name() == "derive"
-    }).flat_map(|a| {
-        a.meta_item_list().unwrap_or(&[]).iter()
-    }).filter_map(|titem| {
-        titem.name()
-    }).collect::<Vec<_>>();
-
-    let span = attrs[0].span;
-
-    if !attrs.iter().any(|a| a.name() == "structural_match") &&
-       titems.iter().any(|t| *t == "PartialEq") && titems.iter().any(|t| *t == "Eq") {
-        let structural_match = Symbol::intern("structural_match");
-        let span = allow_unstable(cx, span, "derive(PartialEq, Eq)");
-        let meta = cx.meta_word(span, structural_match);
-        attrs.push(cx.attribute(span, meta));
-    }
-
-    if !attrs.iter().any(|a| a.name() == "rustc_copy_clone_marker") &&
-       titems.iter().any(|t| *t == "Copy") && titems.iter().any(|t| *t == "Clone") {
-        let structural_match = Symbol::intern("rustc_copy_clone_marker");
-        let span = allow_unstable(cx, span, "derive(Copy, Clone)");
-        let meta = cx.meta_word(span, structural_match);
-        attrs.push(cx.attribute(span, meta));
-    }
-}
-
-pub fn find_derive_attr(cx: &mut ExtCtxt, attrs: &mut Vec<ast::Attribute>)
-                        -> Option<ast::Attribute> {
-    verify_derive_attrs(cx, attrs);
-    get_derive_attr(cx, attrs, DeriveType::ProcMacro).or_else(|| {
-        add_derived_markers(cx, attrs);
-        get_derive_attr(cx, attrs, DeriveType::Builtin)
+pub fn add_derived_markers<T: HasAttrs>(cx: &mut ExtCtxt, traits: &[(Symbol, Span)], item: T) -> T {
+    let span = match traits.get(0) {
+        Some(&(_, span)) => span,
+        None => return item,
+    };
+
+    item.map_attrs(|mut attrs| {
+        if traits.iter().any(|&(name, _)| name == "PartialEq") &&
+           traits.iter().any(|&(name, _)| name == "Eq") {
+            let span = allow_unstable(cx, span, "derive(PartialEq, Eq)");
+            let meta = cx.meta_word(span, Symbol::intern("structural_match"));
+            attrs.push(cx.attribute(span, meta));
+        }
+        if traits.iter().any(|&(name, _)| name == "Copy") &&
+           traits.iter().any(|&(name, _)| name == "Clone") {
+            let span = allow_unstable(cx, span, "derive(Copy, Clone)");
+            let meta = cx.meta_word(span, Symbol::intern("rustc_copy_clone_marker"));
+            attrs.push(cx.attribute(span, meta));
+        }
+        attrs
     })
 }