Use post-expansion to clean up modifier attributes

Author: sfackler

postgres-derive-codegen/Cargo.toml

@@ -10,6 +10,6 @@ keywords = ["database", "postgres", "postgresql", "sql"]
 exclude = ["test"]
 
 [dependencies]
-syntex = "0.44"
-syntex_syntax = "0.44"
+syntex = "0.48"
+syntex_syntax = "0.48"
 postgres-derive-internals = { version = "0.2.0", path = "../postgres-derive-internals" }

postgres-derive-codegen/src/lib.rs

@@ -95,7 +95,6 @@ fn expand_inner(ctx: &mut ExtCtxt,
     match expand(&item) {
         Ok(source) => {
             let mut parser = parse::new_parser_from_source_str(&ctx.parse_sess,
-                                                               ctx.cfg.clone(),
                                                                "<macro src>".to_owned(),
                                                                source);
             while let Some(item) = parser.parse_item().unwrap() {

postgres-derive-internals/Cargo.toml

@@ -9,5 +9,5 @@ readme = "../README.md"
 keywords = ["database", "postgres", "postgresql", "sql"]
 
 [dependencies]
-syn = "0.9"
+syn = "0.10"
 quote = "0.3"

postgres-derive-internals/src/lib.rs

@@ -1,13 +1,9 @@
 #![recursion_limit = "256"]
+
 extern crate syn;
 #[macro_use]
 extern crate quote;
 
-use syn::{MacroInput, MetaItem, Body, VariantData};
-use quote::{Tokens, ToTokens};
-
-use overrides::Overrides;
-
 mod accepts;
 mod composites;
 mod enums;
@@ -24,86 +20,3 @@ pub fn expand_derive_fromsql(source: &str) -> Result<String, String> {
     let input = try!(syn::parse_macro_input(source));
     fromsql::expand_derive_fromsql(&input)
 }
-
-pub fn expand_derive(source: &str) -> Result<String, String> {
-    let mut input = try!(syn::parse_macro_input(source));
-    let (tosql, fromsql) = strip_derives(&mut input);
-
-    let tosql = if tosql {
-        try!(tosql::expand_derive_tosql(&input))
-    } else {
-        "".to_owned()
-    };
-    let fromsql = if fromsql {
-        try!(fromsql::expand_derive_fromsql(&input))
-    } else {
-        "".to_owned()
-    };
-
-    strip_overrides(&mut input);
-
-    let mut tokens = Tokens::new();
-    input.to_tokens(&mut tokens);
-
-    Ok(format!("{}{}{}", tokens, tosql, fromsql))
-}
-
-fn strip_derives(input: &mut MacroInput) -> (bool, bool) {
-    let mut tosql = false;
-    let mut fromsql = false;
-
-    let mut other_attrs = vec![];
-    for mut attr in input.attrs.drain(..) {
-        {
-            let mut items = match attr.value {
-                MetaItem::List(ref name, ref mut items) if name == "derive" => items,
-                _ => {
-                    other_attrs.push(attr);
-                    continue;
-                }
-            };
-
-            items.retain(|i| {
-                match *i {
-                    MetaItem::Word(ref name) if name == "ToSql" => {
-                        tosql = true;
-                        false
-                    }
-                    MetaItem::Word(ref name) if name == "FromSql" => {
-                        fromsql = true;
-                        false
-                    }
-                    _ => true,
-                }
-            });
-
-            if items.is_empty() {
-                continue;
-            }
-        }
-
-        other_attrs.push(attr);
-    }
-
-    input.attrs = other_attrs;
-    (tosql, fromsql)
-}
-
-fn strip_overrides(input: &mut MacroInput) {
-    Overrides::strip(&mut input.attrs);
-
-    match input.body {
-        Body::Enum(ref mut variants) => {
-            for variant in variants {
-                Overrides::strip(&mut variant.attrs);
-            }
-        }
-        Body::Struct(VariantData::Struct(ref mut fields)) |
-        Body::Struct(VariantData::Tuple(ref mut fields)) => {
-            for field in fields {
-                Overrides::strip(&mut field.attrs);
-            }
-        }
-        Body::Struct(VariantData::Unit) => {}
-    }
-}

postgres-derive-internals/src/overrides.rs

@@ -1,4 +1,4 @@
-use syn::{Attribute, MetaItem, Lit};
+use syn::{Attribute, MetaItem, NestedMetaItem, Lit};
 
 pub struct Overrides {
     pub name: Option<String>,
@@ -22,7 +22,7 @@ impl Overrides {
 
             for item in list {
                 match *item {
-                    MetaItem::NameValue(ref name, ref value) => {
+                    NestedMetaItem::MetaItem(MetaItem::NameValue(ref name, ref value)) => {
                         if name != "name" {
                             return Err(format!("unknown override `{}`", name));
                         }
@@ -41,8 +41,4 @@ impl Overrides {
 
         Ok(overrides)
     }
-
-    pub fn strip(attrs: &mut Vec<Attribute>) {
-        attrs.retain(|a| a.name() != "postgres");
-    }
 }

postgres-derive/Cargo.toml

@@ -14,6 +14,9 @@ test = false
 
 [dependencies]
 postgres-derive-internals = { version = "0.2.0", path = "../postgres-derive-internals" }
+post-expansion = "0.2"
+syn = "0.10"
+quote = "0.3"
 
 [dev-dependencies]
 postgres = "0.12"

postgres-derive/src/lib.rs

@@ -2,23 +2,45 @@
 
 extern crate proc_macro;
 extern crate postgres_derive_internals;
+#[macro_use]
+extern crate post_expansion;
+extern crate syn;
+extern crate quote;
 
 use proc_macro::TokenStream;
+use quote::{ToTokens, Tokens};
+
+register_post_expansion!(PostExpansion_postgres_derive);
 
 #[proc_macro_derive(ToSql)]
 pub fn derive_tosql(input: TokenStream) -> TokenStream {
-    derive("ToSql", input)
+    derive(input, postgres_derive_internals::expand_derive_tosql)
 }
 
 #[proc_macro_derive(FromSql)]
 pub fn derive_fromsql(input: TokenStream) -> TokenStream {
-    derive("FromSql", input)
+    derive(input, postgres_derive_internals::expand_derive_fromsql)
 }
 
-fn derive(trait_: &str, input: TokenStream) -> TokenStream {
-    let input = format!("#[derive({})] {}", trait_, input);
-    match postgres_derive_internals::expand_derive(&input) {
-        Ok(expanded) => expanded.parse().unwrap(),
-        Err(err) => panic!(err),
-    }
+fn derive(input: TokenStream, expand: fn(&str) -> Result<String, String>) -> TokenStream {
+    let source = input.to_string();
+
+    let decl = expand_decl(&source);
+
+    let impl_ = match expand(&source) {
+        Ok(impl_) => impl_,
+        Err(e) => panic!("{}", e),
+    };
+
+    let expanded = format!("{}\n{}", decl, impl_);
+    expanded.parse().unwrap()
+}
+
+fn expand_decl(source: &str) -> String {
+    let ast = syn::parse_macro_input(source).unwrap();
+    let stripped = post_expansion::strip_attrs_later(ast, &["postgres"], "postgres_derive");
+
+    let mut tokens = Tokens::new();
+    stripped.to_tokens(&mut tokens);
+    tokens.to_string()
 }