Added support for visibility for fields

src/field.rs

@@ -14,6 +14,9 @@ pub struct Field {
 
     /// Field annotation
     pub annotation: Vec<String>,
+
+    /// The visibility of the field
+    pub visibility: Option<String>,
 }
 
 impl Field {
@@ -27,6 +30,7 @@ impl Field {
             ty: ty.into(),
             documentation: Vec::new(),
             annotation: Vec::new(),
+            visibility: None,
         }
     }
 
@@ -41,4 +45,10 @@ impl Field {
         self.annotation = annotation.iter().map(|ann| ann.to_string()).collect();
         self
     }
+
+    /// Set the visibility of the field
+    pub fn vis(&mut self, visibility: &str) -> &mut Self {
+        self.visibility = Some(visibility.to_string());
+        self
+    }
 }

src/fields.rs

@@ -37,9 +37,23 @@ impl Fields {
             ty: ty.into(),
             documentation: Vec::new(),
             annotation: Vec::new(),
+            visibility: None,
         })
     }
 
+    pub fn new_named<T>(&mut self, name: &str, ty: T) -> &mut Field
+    where
+        T: Into<Type>,
+    {
+        self.named(name, ty);
+        if let Fields::Named(ref mut fields) = *self {
+            fields.last_mut().unwrap()
+        }
+        else {
+            unreachable!()
+        }
+    }
+
     pub fn tuple<T>(&mut self, ty: T) -> &mut Self
     where
         T: Into<Type>,
@@ -74,6 +88,9 @@ impl Fields {
                                 write!(fmt, "{}\n", ann)?;
                             }
                         }
+                        if let Some(visibility) = &f.visibility {
+                            write!(fmt, "{} ", visibility)?;
+                        }
                         write!(fmt, "{}: ", f.name)?;
                         f.ty.fmt(fmt)?;
                         write!(fmt, ",\n")?;

src/function.rs

@@ -129,11 +129,12 @@ impl Function {
         self.args.push(Field {
             name: name.to_string(),
             ty: ty.into(),
-            // While a `Field` is used here, both `documentation`
+            // While a `Field` is used here, both `documentation`, `visibility`
             // and `annotation` does not make sense for function arguments.
             // Simply use empty strings.
             documentation: Vec::new(),
             annotation: Vec::new(),
+            visibility: None,
         });
 
         self

src/impl.rs

@@ -89,6 +89,7 @@ impl Impl {
             ty: ty.into(),
             documentation: Vec::new(),
             annotation: Vec::new(),
+            visibility: None,
         });
 
         self

src/struct.rs

@@ -96,6 +96,17 @@ impl Struct {
         self
     }
 
+    /// Create a named field for the struct.
+    ///
+    /// A struct can either set named fields with this function or tuple fields
+    /// with `tuple_field`, but not both.
+    pub fn new_field<T>(&mut self, name: &str, ty: T) -> &mut Field
+    where
+        T: Into<Type>,
+    {
+        self.fields.new_named(name, ty)
+    }
+
     /// Add a tuple field to the struct.
     ///
     /// A struct can either set tuple fields with this function or named fields

tests/codegen.rs

@@ -603,5 +603,26 @@ enum IpAddrKind {
     V6,
 }"#;
 
+    assert_eq!(scope.to_string(), &expect[1..]);
+}
+
+#[test]
+fn struct_with_member_visibility() {
+    let mut scope = Scope::new();
+
+    let struct_description = scope.new_struct("Foo");
+
+    let mut bar = Field::new("bar", "usize");
+    bar.vis("pub");
+
+    struct_description.push_field(bar);
+    struct_description.new_field("baz", "i16").vis("pub(crate)");
+
+    let expect = r#"
+struct Foo {
+    pub bar: usize,
+    pub(crate) baz: i16,
+}"#;
+
     assert_eq!(scope.to_string(), &expect[1..]);
 }