AsRef for "implements this COM interface"?

[SimonSapin]

I’d like to write generic code that accepts any type that implements the IUnknown interface (in order to call Release() in Drop). I started with T: Deref<Target=IUnknown>, but then some winapi types only deference indirectly to IUnknown.

What do you think of implementing the AsRef trait (in addition to Deref) to represent the "implements a COM interface" relationship? For example IDXGIDevice would have both AsRef<IDXGIObject> and AsRef<IUnknown> (in addition to Deref<Target=IDXGIObject> that it already has). (The body of all these impls could be just self, since auto-deref is recursive.)

[retep998]

All interfaces inherit from IUnknown either directly or indirectly (except the ones that don't). Upcasting is done by just casting the pointer. As a result, you can trivially cast any interface pointer to an IUnknown pointer. While the ergonomics of having to do so are not great, you also only ever have to do it inside your smart pointer type. The complication of having to add all those AsRef impls (the macro doesn't have enough information to do so, and is exported so its also stable) is not worth the very minor benefit.

Here is an existing ComPtr type that works quite well: https://github.com/retep998/wio-rs/blob/master/src/com.rs

[SimonSapin]

Casting a pointer is fine, I was hoping to use something like AsRef in a where clause to limit which types to cast from. I see that your ComPtr type has T: Interface. Is it the case that anything that implements Interface trait in Rust also implements the IUnknown interface in COM?

---

(I’m making a slightly different ComPtr type that can be null. It is initially null before being passed as an out-parameter to a constructor function like below.)

        let mut d3d_device = Com::<ID3D11Device>::null();
        D3D11CreateDevice(/* … */, d3d_device.as_ptr_ptr(), /* … */).to_result()?;

pub struct Com<T>(*mut T) where T: /* ??? */;
impl<T> Com<T> {
    pub fn null() -> Self { Com(ptr::null_mut()) }
    pub fn as_ptr_ptr(&mut self) -> *mut *mut T { &mut self.0 }
}
// Drop calls Release() iff non-null

impl ToResult for HRESULT {
    fn to_result(self) -> Result<(), Self> {
        if SUCCEEDED(self) { Ok(()) }
        else { Err(self) }
    }
}

[retep998]

There are unfortunately interfaces which do not inherit from IUnknown (interfaces like ID3D12FunctionReflection come to mind). There is currently no way to assert in the type system that an interface eventually derefs to IUnknown so the approach I took with my ComPtr is to make ComPtr::new an unsafe method where the user is effectively asserting that the interface inherits from IUnknown.