Merge pull request rust-lang#7 from benesch/comp-visibility

Track and emit visibility of structs and unions

Author: adetaylor

src/codegen/mod.rs

@@ -1994,6 +1994,7 @@ impl CodeGenerator for CompInfo {
         if unused_template_params {
             attributes.push(attributes::discards_template_param());
         }
+        attributes.push(attributes::visibility(self.visibility()));
 
         if ctx.options().rust_features().repr_align {
             if let Some(explicit) = explicit_align {

src/ir/comp.rs

@@ -4,6 +4,7 @@ use super::analysis::Sizedness;
 use super::annotations::Annotations;
 use super::context::{BindgenContext, FunctionId, ItemId, TypeId, VarId};
 use super::dot::DotAttributes;
+use super::function::Visibility;
 use super::item::{IsOpaque, Item};
 use super::layout::Layout;
 use super::template::TemplateParameters;
@@ -1011,6 +1012,10 @@ pub struct CompInfo {
     /// Whether this is a struct or a union.
     kind: CompKind,
 
+    /// The visibility of this struct or union if it was declared inside of
+    /// another type. Top-level types always have public visibility.
+    visibility: Visibility,
+
     /// The members of this struct or union.
     fields: CompFields,
 
@@ -1085,6 +1090,7 @@ impl CompInfo {
     pub fn new(kind: CompKind) -> Self {
         CompInfo {
             kind,
+            visibility: Visibility::Public,
             fields: CompFields::default(),
             template_params: vec![],
             methods: vec![],
@@ -1202,6 +1208,11 @@ impl CompInfo {
         }
     }
 
+    /// Returns the visibility of the type.
+    pub fn visibility(&self) -> Visibility {
+        self.visibility
+    }
+
     /// Returns whether we have a too large bitfield unit, in which case we may
     /// not be able to derive some of the things we should be able to normally
     /// derive.
@@ -1291,6 +1302,7 @@ impl CompInfo {
         debug!("CompInfo::from_ty({:?}, {:?})", kind, cursor);
 
         let mut ci = CompInfo::new(kind);
+        ci.visibility = Visibility::from(cursor.access_specifier());
         ci.is_forward_declaration =
             location.map_or(true, |cur| match cur.kind() {
                 CXCursor_ParmDecl => true,

src/ir/function.rs

@@ -10,7 +10,7 @@ use crate::clang;
 use crate::parse::{
     ClangItemParser, ClangSubItemParser, ParseError, ParseResult,
 };
-use clang_sys::{self, CXCallingConv};
+use clang_sys::{self, CXCallingConv, CX_CXXAccessSpecifier, CX_CXXPrivate, CX_CXXProtected};
 use proc_macro2;
 use quote;
 use quote::TokenStreamExt;
@@ -79,6 +79,18 @@ pub enum Visibility {
     Private,
 }
 
+impl From<CX_CXXAccessSpecifier> for Visibility {
+    fn from(access_specifier: CX_CXXAccessSpecifier) -> Self {
+        if access_specifier == CX_CXXPrivate {
+            Visibility::Private
+        } else if access_specifier == CX_CXXProtected {
+            Visibility::Protected
+        } else {
+            Visibility::Public
+        }
+    }
+}
+
 /// A function declaration, with a signature, arguments, and argument names.
 ///
 /// The argument names vector must be the same length as the ones in the
@@ -621,13 +633,7 @@ impl ClangSubItemParser for Function {
             return Err(ParseError::Continue);
         }
 
-        let visibility = if cursor.access_specifier() == CX_CXXPrivate {
-            Visibility::Private
-        } else if cursor.access_specifier() == CX_CXXProtected {
-            Visibility::Protected
-        } else {
-            Visibility::Public
-        };
+        let visibility = Visibility::from(cursor.access_specifier());
 
         if cursor.is_inlined_function() {
             if !context.options().generate_inline_functions {