Update codegen to use syn backend

Author: sfackler

postgres-derive-codegen/Cargo.toml

@@ -7,17 +7,9 @@ description = "Deriving codegen support for Postgres enum, domain, and composite
 repository = "https://github.com/sfackler/rust-postgres-derive"
 readme = "../README.md"
 keywords = ["database", "postgres", "postgresql", "sql"]
-build = "build.rs"
 exclude = ["test"]
 
-[features]
-default = ["with-syntex"]
-nightly = []
-with-syntex = ["syntex", "syntex_syntax"]
-
-[build-dependencies]
-syntex = { version = "0.44", optional = true }
-
 [dependencies]
-syntex = { version = "0.44", optional = true }
-syntex_syntax = { version = "0.44", optional = true }
+syntex = "0.44"
+syntex_syntax = "0.44"
+postgres-derive-internals = { path = "../postgres-derive-internals" }

postgres-derive-codegen/build.rs

@@ -1,21 +1,13 @@
-#![cfg_attr(not(feature = "with-syntex"), feature(rustc_private, quote))]
-
-#[cfg(feature = "with-syntex")]
 extern crate syntex;
-#[cfg(feature = "with-syntex")]
 extern crate syntex_syntax as syntax;
-#[cfg(not(feature = "with-syntex"))]
-extern crate syntax;
-#[cfg(not(feature = "with-syntex"))]
-extern crate rustc_plugin;
-
-#[cfg(feature = "with-syntex")]
-include!(concat!(env!("OUT_DIR"), "/lib.rs"));
+extern crate postgres_derive_internals;
 
-#[cfg(not(feature = "with-syntex"))]
-include!("lib.rs.in");
+use syntax::ext::base::{Annotatable, ExtCtxt};
+use syntax::codemap::Span;
+use syntax::ast::MetaItem;
+use syntax::print::pprust;
+use syntax::parse;
 
-#[cfg(feature = "with-syntex")]
 pub fn expand<S, D>(src: S, dst: D) -> Result<(), syntex::Error>
     where S: AsRef<std::path::Path>,
           D: AsRef<std::path::Path>,
@@ -25,7 +17,6 @@ pub fn expand<S, D>(src: S, dst: D) -> Result<(), syntex::Error>
     registry.expand("", src.as_ref(), dst.as_ref())
 }
 
-#[cfg(feature = "with-syntex")]
 pub fn register(reg: &mut syntex::Registry) {
     use syntax::{ast, fold};
 
@@ -53,22 +44,64 @@ pub fn register(reg: &mut syntex::Registry) {
     reg.add_attr("feature(custom_derive)");
     reg.add_attr("feature(custom_attribute)");
 
-    reg.add_decorator("derive_ToSql", tosql::expand);
-    reg.add_decorator("derive_FromSql", fromsql::expand);
+    reg.add_decorator("derive_ToSql", expand_tosql);
+    reg.add_decorator("derive_FromSql", expand_fromsql);
 
     reg.add_post_expansion_pass(strip_attributes);
 }
 
-#[cfg(not(feature = "with-syntex"))]
-pub fn register(registry: &mut rustc_plugin::Registry) {
-    use syntax::ext::base::SyntaxExtension;
-    use syntax::feature_gate::AttributeType;
-    use syntax::parse::token;
+fn expand_tosql(ctx: &mut ExtCtxt,
+                span: Span,
+                _: &MetaItem,
+                annotatable: &Annotatable,
+                push: &mut FnMut(Annotatable)) {
+    expand_inner(ctx,
+                 span,
+                 "ToSql",
+                 annotatable,
+                 push,
+                 postgres_derive_internals::expand_derive_tosql);
+}
 
-    registry.register_syntax_extension(token::intern("derive_ToSql"),
-                                       SyntaxExtension::MultiDecorator(Box::new(tosql::expand)));
-    registry.register_syntax_extension(token::intern("derive_FromSql"),
-                                       SyntaxExtension::MultiDecorator(Box::new(fromsql::expand)));
+fn expand_fromsql(ctx: &mut ExtCtxt,
+                  span: Span,
+                  _: &MetaItem,
+                  annotatable: &Annotatable,
+                  push: &mut FnMut(Annotatable)) {
+    expand_inner(ctx,
+                 span,
+                 "FromSql",
+                 annotatable,
+                 push,
+                 postgres_derive_internals::expand_derive_fromsql);
+}
 
-    registry.register_attribute("postgres".to_owned(), AttributeType::Normal);
+fn expand_inner(ctx: &mut ExtCtxt,
+                span: Span,
+                trait_: &str,
+                annotatable: &Annotatable,
+                push: &mut FnMut(Annotatable),
+                expand: fn(&str) -> Result<String, String>) {
+    let item = match *annotatable {
+        Annotatable::Item(ref item) => item,
+        _ => {
+            ctx.span_err(span, &format!("#[derive({})] can only be applied to structs, single field \
+                                         tuple structs, and enums", trait_));
+            return;
+        }
+    };
+
+    let item = pprust::item_to_string(item);
+    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() {
+                push(Annotatable::Item(item));
+            }
+        }
+        Err(err) => ctx.span_err(span, &err),
+    }
 }

postgres-derive-codegen/src/lib.rs

@@ -8,4 +8,4 @@ build = "build.rs"
 postgres-derive-codegen = { path = ".." }
 
 [dependencies]
-postgres = "0.11.1"
+postgres = { git = "https://github.com/sfackler/rust-postgres" }

postgres-derive-codegen/test/Cargo.toml

@@ -1,7 +1,7 @@
 #[macro_use]
 extern crate postgres;
 
-use postgres::{Connection, SslMode};
+use postgres::{Connection, TlsMode};
 use postgres::types::{FromSql, ToSql};
 use std::fmt;
 
@@ -23,7 +23,7 @@ pub fn test_type<T, S>(conn: &Connection, sql_type: &str, checks: &[(T, S)])
 
 #[test]
 fn domain() {
-    let conn = Connection::connect("postgres://postgres@localhost", SslMode::None).unwrap();
+    let conn = Connection::connect("postgres://postgres@localhost", TlsMode::None).unwrap();
     conn.execute("CREATE DOMAIN pg_temp.session_id AS bytea CHECK(octet_length(VALUE) = 16);", &[])
         .unwrap();
 
@@ -33,7 +33,7 @@ fn domain() {
 
 #[test]
 fn enum_() {
-    let conn = Connection::connect("postgres://postgres@localhost", SslMode::None).unwrap();
+    let conn = Connection::connect("postgres://postgres@localhost", TlsMode::None).unwrap();
     conn.execute("CREATE TYPE pg_temp.mood AS ENUM ('sad', 'ok', 'happy')", &[]).unwrap();
 
     test_type(&conn,

postgres-derive-codegen/test/src/main.rs

@@ -5,8 +5,6 @@ use syn::{MacroInput, MetaItem, Body, VariantData};
 use quote::{Tokens, ToTokens};
 
 use overrides::Overrides;
-use fromsql::expand_derive_fromsql;
-use tosql::expand_derive_tosql;
 
 mod accepts;
 mod composites;
@@ -15,17 +13,27 @@ mod fromsql;
 mod overrides;
 mod tosql;
 
+pub fn expand_derive_tosql(source: &str) -> Result<String, String> {
+    let input = try!(syn::parse_macro_input(source));
+    tosql::expand_derive_tosql(&input)
+}
+
+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!(expand_derive_tosql(&input))
+        try!(tosql::expand_derive_tosql(&input))
     } else {
         "".to_owned()
     };
     let fromsql = if fromsql {
-        try!(expand_derive_fromsql(&input))
+        try!(fromsql::expand_derive_fromsql(&input))
     } else {
         "".to_owned()
     };