Extremely basic Vtable generation

Author: DrChat

src/codegen/mod.rs

@@ -1049,15 +1049,65 @@ impl<'a> CodeGenerator for Vtable<'a> {
     ) {
         assert_eq!(item.id(), self.item_id);
         debug_assert!(item.is_enabled_for_codegen(ctx));
-
-        // For now, generate an empty struct, later we should generate function
-        // pointers and whatnot.
         let name = ctx.rust_ident(&self.canonical_name(ctx));
-        let void = helpers::ast_ty::c_void(ctx);
-        result.push(quote! {
-            #[repr(C)]
-            pub struct #name ( #void );
-        });
+
+        // For now, we will only generate vtables for classes that do not inherit from others.
+        if self.base_classes.is_empty() {
+            let methods = self
+                .methods
+                .iter()
+                .filter_map(|m| {
+                    if !m.is_virtual() {
+                        return None;
+                    }
+
+                    let function_item = ctx.resolve_item(m.signature());
+                    if !function_item.process_before_codegen(ctx, result) {
+                        return None;
+                    }
+
+                    let function = function_item.expect_function();
+                    let signature_item = ctx.resolve_item(function.signature());
+                    let signature = match signature_item.expect_type().kind() {
+                        TypeKind::Function(ref sig) => sig,
+                        _ => panic!("Function signature type mismatch"),
+                    };
+
+                    // FIXME: Is there a canonical name without the class prepended?
+                    let function_name = function_item.canonical_name(ctx);
+
+                    // FIXME: Need to account for overloading with times_seen (separately from regular function path).
+                    let function_name = ctx.rust_ident(function_name);
+                    let mut args = utils::fnsig_arguments(ctx, signature);
+                    let ret = utils::fnsig_return_ty(ctx, signature);
+
+                    args[0] = if m.is_const() {
+                        quote! { &self }
+                    } else {
+                        quote! { &mut self }
+                    };
+
+                    Some(quote! {
+                        #function_name : fn( #( #args ),* ) #ret
+                    })
+                })
+                .collect::<Vec<_>>();
+
+            result.push(quote! {
+                #[repr(C)]
+                pub struct #name {
+                    #( #methods ),*
+                }
+            })
+        } else {
+            // For the cases we don't support, simply generate an empty struct.
+            let void = helpers::ast_ty::c_void(ctx);
+
+            result.push(quote! {
+                #[repr(C)]
+                pub struct #name ( #void );
+            });
+        }
     }
 }
 

tests/expectations/tests/virtual_interface.rs

@@ -0,0 +1,125 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+pub struct PureVirtualIFace__bindgen_vtable {
+    PureVirtualIFace_Foo: fn(&mut self),
+    PureVirtualIFace_Bar: fn(&mut self, arg1: ::std::os::raw::c_uint),
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct PureVirtualIFace {
+    pub vtable_: *const PureVirtualIFace__bindgen_vtable,
+}
+#[test]
+fn bindgen_test_layout_PureVirtualIFace() {
+    assert_eq!(
+        ::std::mem::size_of::<PureVirtualIFace>(),
+        8usize,
+        concat!("Size of: ", stringify!(PureVirtualIFace))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<PureVirtualIFace>(),
+        8usize,
+        concat!("Alignment of ", stringify!(PureVirtualIFace))
+    );
+}
+impl Default for PureVirtualIFace {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+pub struct AnotherInterface__bindgen_vtable {
+    AnotherInterface_Baz: fn(&mut self),
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct AnotherInterface {
+    pub vtable_: *const AnotherInterface__bindgen_vtable,
+}
+#[test]
+fn bindgen_test_layout_AnotherInterface() {
+    assert_eq!(
+        ::std::mem::size_of::<AnotherInterface>(),
+        8usize,
+        concat!("Size of: ", stringify!(AnotherInterface))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<AnotherInterface>(),
+        8usize,
+        concat!("Alignment of ", stringify!(AnotherInterface))
+    );
+}
+impl Default for AnotherInterface {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct Implementation {
+    pub _base: PureVirtualIFace,
+}
+#[test]
+fn bindgen_test_layout_Implementation() {
+    assert_eq!(
+        ::std::mem::size_of::<Implementation>(),
+        8usize,
+        concat!("Size of: ", stringify!(Implementation))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Implementation>(),
+        8usize,
+        concat!("Alignment of ", stringify!(Implementation))
+    );
+}
+impl Default for Implementation {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct DoubleImpl {
+    pub _base: PureVirtualIFace,
+    pub _base_1: AnotherInterface,
+}
+#[test]
+fn bindgen_test_layout_DoubleImpl() {
+    assert_eq!(
+        ::std::mem::size_of::<DoubleImpl>(),
+        16usize,
+        concat!("Size of: ", stringify!(DoubleImpl))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<DoubleImpl>(),
+        8usize,
+        concat!("Alignment of ", stringify!(DoubleImpl))
+    );
+}
+impl Default for DoubleImpl {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}

tests/headers/virtual_interface.hpp

@@ -0,0 +1,24 @@
+class PureVirtualIFace {
+public:
+    virtual void Foo() = 0;
+    virtual void Bar(unsigned int) = 0;
+};
+
+class AnotherInterface {
+public:
+    virtual void Baz() = 0;
+};
+
+class Implementation : public PureVirtualIFace {
+public:
+    void Foo() override {}
+    void Bar(unsigned int) override {}
+};
+
+class DoubleImpl : public PureVirtualIFace, public AnotherInterface {
+public:
+    void Foo() override {}
+    void Bar(unsigned int) override {}
+
+    void Baz() override {}
+};