squash! Move code to a helpers module, ugly hack included.

Author: emilio

build.rs

@@ -10,6 +10,7 @@ mod codegen {
 
         quasi_codegen::expand(&src, &dst).unwrap();
         println!("cargo:rerun-if-changed=src/codegen/mod.rs");
+        println!("cargo:rerun-if-changed=src/codegen/helpers.rs");
     }
 }
 

src/codegen/helpers.rs

@@ -0,0 +1,113 @@
+/// Helpers for code generation that don't need macro expansion.
+
+use aster;
+use ir::layout::Layout;
+use syntax::ast;
+use syntax::codemap::respan;
+use syntax::ptr::P;
+
+
+pub mod attributes {
+    use aster;
+    use syntax::ast;
+
+    pub fn repr(which: &str) -> ast::Attribute {
+        aster::AstBuilder::new().attr().list("repr").words(&[which]).build()
+    }
+
+    pub fn repr_list(which_ones: &[&str]) -> ast::Attribute {
+        aster::AstBuilder::new().attr().list("repr").words(which_ones).build()
+    }
+
+    pub fn derives(which_ones: &[&str]) -> ast::Attribute {
+        aster::AstBuilder::new().attr().list("derive").words(which_ones).build()
+    }
+
+    pub fn inline() -> ast::Attribute {
+        aster::AstBuilder::new().attr().word("inline")
+    }
+
+    pub fn doc(comment: &str) -> ast::Attribute {
+        aster::AstBuilder::new().attr().doc(comment)
+    }
+
+    pub fn link_name(name: &str) -> ast::Attribute {
+        aster::AstBuilder::new().attr().name_value("link_name").str(name)
+    }
+}
+
+/// Generates a proper type for a field or type with a given `Layout`, that is,
+/// a type with the correct size and alignment restrictions.
+pub struct BlobTyBuilder {
+    layout: Layout,
+}
+
+impl BlobTyBuilder {
+    pub fn new(layout: Layout) -> Self {
+        BlobTyBuilder {
+            layout: layout,
+        }
+    }
+
+    pub fn build(self) -> P<ast::Ty> {
+        use std::cmp;
+
+        let ty_name = match self.layout.align {
+            8 => "u64",
+            4 => "u32",
+            2 => "u16",
+            1 | _ => "u8",
+        };
+        let data_len = if ty_name == "u8" {
+            self.layout.size
+        } else {
+            self.layout.size / cmp::max(self.layout.align, 1)
+        };
+
+        let inner_ty = aster::AstBuilder::new().ty().path().id(ty_name).build();
+        if data_len == 1 {
+            inner_ty
+        } else {
+            ArrayTyBuilder::new().with_len(data_len).build(inner_ty)
+        }
+    }
+}
+
+pub struct ArrayTyBuilder {
+    len: usize,
+}
+
+impl ArrayTyBuilder {
+    pub fn new() -> Self {
+        ArrayTyBuilder {
+            len: 0,
+        }
+    }
+
+    pub fn with_len(mut self, len: usize) -> Self {
+        self.len = len;
+        self
+    }
+
+    pub fn build(self, ty: P<ast::Ty>) -> P<ast::Ty> {
+        use syntax::codemap::DUMMY_SP;
+        let size =
+            ast::LitKind::Int(self.len as u64,
+                              ast::LitIntType::Unsigned(ast::UintTy::Us));
+        let size = ast::ExprKind::Lit(P(respan(DUMMY_SP, size)));
+        let array_kind = ast::TyKind::FixedLengthVec(ty,
+            P(ast::Expr {
+                id: ast::DUMMY_NODE_ID,
+                node: size,
+                span: DUMMY_SP,
+                attrs: ast::ThinVec::new(),
+            })
+        );
+
+        P(ast::Ty {
+            id: ast::DUMMY_NODE_ID,
+            node: array_kind,
+            span: DUMMY_SP,
+        })
+    }
+}

src/codegen/mod.rs

@@ -23,31 +23,21 @@ use syntax::codemap::{Span, respan};
 use syntax::ptr::P;
 use aster;
 
+// FIXME: This is shame, but we need to do this here since quasi eats the
+// includes in the "helpers" mod otherwise.
+mod helpers {
+    include!("helpers.rs");
+}
+
+use self::helpers::{attributes, ArrayTyBuilder, BlobTyBuilder};
+
 fn root_import(ctx: &BindgenContext) -> P<ast::Item> {
     assert!(ctx.options().enable_cxx_namespaces, "Somebody messed it up");
     let root = ctx.root_module().canonical_name(ctx);
     let root_ident = ctx.rust_ident(&root);
     quote_item!(ctx.ext_cx(), use $root_ident;).unwrap()
 }
 
-macro_rules! repr {
-    ($which:expr) => {{
-        aster::AstBuilder::new().attr().list("repr").words(&[$which]).build()
-    }}
-}
-
-macro_rules! doc {
-    ($comment:expr) => {{
-        aster::AstBuilder::new().attr().doc($comment)
-    }}
-}
-
-macro_rules! link_name {
-    ($name:expr) => {{
-        aster::AstBuilder::new().attr().name_value("link_name").str($name)
-    }}
-}
-
 struct CodegenResult {
     items: Vec<P<ast::Item>>,
     saw_union: bool,
@@ -166,83 +156,6 @@ impl ForeignModBuilder {
     }
 }
 
-struct ArrayTyBuilder {
-    len: usize,
-}
-
-// TODO: Aster seem to lack a array builder?
-impl ArrayTyBuilder {
-    fn new() -> Self {
-        ArrayTyBuilder {
-            len: 0,
-        }
-    }
-
-    fn with_len(mut self, len: usize) -> Self {
-        self.len = len;
-        self
-    }
-
-    fn build(self, ty: P<ast::Ty>) -> P<ast::Ty> {
-        use syntax::codemap::DUMMY_SP;
-        let size =
-            ast::LitKind::Int(self.len as u64,
-                              ast::LitIntType::Unsigned(ast::UintTy::Us));
-        let size = ast::ExprKind::Lit(P(respan(DUMMY_SP, size)));
-        let array_kind = ast::TyKind::FixedLengthVec(ty,
-            P(ast::Expr {
-                id: ast::DUMMY_NODE_ID,
-                node: size,
-                span: DUMMY_SP,
-                attrs: ast::ThinVec::new(),
-            })
-        );
-
-        P(ast::Ty {
-            id: ast::DUMMY_NODE_ID,
-            node: array_kind,
-            span: DUMMY_SP,
-        })
-    }
-}
-
-/// Generates a proper type for a field or type with a given `Layout`, that is,
-/// a type with the correct size and alignment restrictions.
-struct BlobTyBuilder {
-    layout: Layout,
-}
-
-impl BlobTyBuilder {
-    fn new(layout: Layout) -> Self {
-        BlobTyBuilder {
-            layout: layout,
-        }
-    }
-
-    fn build(self) -> P<ast::Ty> {
-        use std::cmp;
-
-        let ty_name = match self.layout.align {
-            8 => "u64",
-            4 => "u32",
-            2 => "u16",
-            1 | _ => "u8",
-        };
-        let data_len = if ty_name == "u8" {
-            self.layout.size
-        } else {
-            self.layout.size / cmp::max(self.layout.align, 1)
-        };
-
-        let inner_ty = aster::AstBuilder::new().ty().path().id(ty_name).build();
-        if data_len == 1 {
-            inner_ty
-        } else {
-            ArrayTyBuilder::new().with_len(data_len).build(inner_ty)
-        }
-    }
-}
-
 /// A trait to convert a rust type into a pointer, optionally const, to the same
 /// type.
 ///
@@ -366,9 +279,9 @@ impl CodeGenerator for Var {
         } else {
             let mut attrs = vec![];
             if let Some(mangled) = self.mangled_name() {
-                attrs.push(link_name!(mangled));
+                attrs.push(attributes::link_name(mangled));
             } else if name != self.name() {
-                attrs.push(link_name!(self.name()));
+                attrs.push(attributes::link_name(self.name()));
             }
 
             let item = ast::ForeignItem {
@@ -501,7 +414,7 @@ impl<'a> CodeGenerator for Vtable<'a> {
         // For now, generate an empty struct, later we should generate function
         // pointers and whatnot.
         let vtable = aster::AstBuilder::new().item().pub_()
-                            .with_attr(repr!("C"))
+                            .with_attr(attributes::repr("C"))
                             .struct_(self.canonical_name(ctx))
                             .build();
         result.push(vtable);
@@ -628,16 +541,12 @@ impl CodeGenerator for CompInfo {
         let mut attributes = vec![];
         let mut needs_clone_impl = false;
         if let Some(comment) = item.comment() {
-            attributes.push(doc!(comment));
+            attributes.push(attributes::doc(comment));
         }
         if self.packed() {
-            // TODO: reuse the repr! macro?
-            let c_packed =
-                aster::AstBuilder::new().attr().list("repr")
-                    .words(&["C", "packed"]).build();
-            attributes.push(c_packed);
+            attributes.push(attributes::repr_list(&["C", "packed"]));
         } else {
-            attributes.push(repr!("C"));
+            attributes.push(attributes::repr("C"));
         }
 
         let mut derives = vec![];
@@ -662,9 +571,7 @@ impl CodeGenerator for CompInfo {
         }
 
         if !derives.is_empty() {
-            let derives = aster::AstBuilder::new().attr().list("derive")
-                                .words(&derives).build();
-            attributes.push(derives)
+            attributes.push(attributes::derives(&derives))
         }
 
         let mut template_args_used = vec![false; applicable_template_args.len()];
@@ -809,7 +716,7 @@ impl CodeGenerator for CompInfo {
 
             let mut attrs = vec![];
             if let Some(comment) = field.comment() {
-                attrs.push(doc!(comment));
+                attrs.push(attributes::doc(comment));
             }
             let field_name = match field.name() {
                 Some(name) => ctx.rust_mangle(name).into_owned(),
@@ -1198,7 +1105,7 @@ impl MethodCodegen for Method {
         };
 
         let mut attrs = vec![];
-        attrs.push(aster::AstBuilder::new().attr().word("inline"));
+        attrs.push(attributes::inline());
 
         let item = ast::ImplItem {
             id: ast::DUMMY_NODE_ID,
@@ -1260,17 +1167,16 @@ impl CodeGenerator for Enum {
         // FIXME: Rust forbids repr with empty enums. Remove this condition when
         // this is allowed.
         if !self.variants().is_empty() {
-            builder = builder.with_attr(repr!(repr_name));
+            builder = builder.with_attr(attributes::repr(repr_name));
         }
 
         if let Some(comment) = item.comment() {
-            builder = builder.with_attr(doc!(comment));
+            builder = builder.with_attr(attributes::doc(comment));
         }
 
         let derives =
-            aster::AstBuilder::new().attr().list("derive")
-                .words(&["Debug", "Copy", "Clone", "PartialEq", "Eq", "Hash"])
-                .build();
+            attributes::derives(&["Debug", "Copy", "Clone", "PartialEq", "Eq", "Hash"]);
+
         builder = builder.with_attr(derives);
 
         let mut builder = builder.enum_(&name);
@@ -1586,13 +1492,13 @@ impl CodeGenerator for Function {
         let mut attributes = vec![];
 
         if let Some(comment) = item.comment() {
-            attributes.push(doc!(comment));
+            attributes.push(attributes::doc(comment));
         }
 
         if let Some(mangled) = self.mangled_name() {
-            attributes.push(link_name!(mangled));
+            attributes.push(attributes::link_name(mangled));
         } else if name != canonical_name {
-            attributes.push(link_name!(name));
+            attributes.push(attributes::link_name(name));
         }
 
         let foreign_item_kind =