IDiaEnumSymbols::Next mismatch with docs

[jdupak-ms]

Hi, I think I have found mis-generated binding,

dia-rs/src/bindings.rs

Line 1715 in 62849f0

rgelt: *mut Option<IDiaSymbol>,

Rust says (out) pointer to optional (1x) and DIA (https://learn.microsoft.com/en-us/visualstudio/debugger/debug-interface-access/idiaenumsymbols-next?view=vs-2022) says pointer to array.

[riverar]

I believe this is a documentation bug. IDiaEnumSymbols is an enumerator, and its backing array is not exposed to developers. Each invocation of IDiaEnumSymbols::Next provides a single IDiaSymbol through the rgelt parameter.

Closing for now, but feel free to continue the discussion.

[riverar]

Oh, just realized this method accepts a fetch count. So this is indeed a bug.

[kennykerr]

Possibly related: microsoft/windows-rs#3402 (comment)

[kennykerr]

Note that the metadata does not indicate that this is an array:

[riverar]

Yep, something we can tweak in metadata generation (in this repository). Will try it out later today.

[tim-weis]

That's a bug, but it isn't fatal in rendering the IDiaEnumSymbols API entirely unusable. It currently inhibits batch processing (in part), but there are ways to work around this:

• The Item method gets properly translated, allowing for one-item-at-a-time processing:

  let symbols = session./* ... */;
  
  for i in 0..symbols.Count()? {
      println!("{}", symbols.Item(i as u32)?.name()?);
  }

• The _NewEnum method is accurately expressed in the Rust bindings as well, which produces an IEnumVARIANT that does support batch retrieval. The number of hoops to jump through to go from a VARIANT to an IDiaSymbol is greater than zero, so I haven't personally verified this to work (it probably does, nonetheless).

I'm just leaving this here in case someone else is blocked on this bug.

[jdupak-ms]

The next method does works for one element currently. But I am not sure how much is it accidental. I am using this abstractions:

pub struct IDiaSymbolIterator {
    symbols: IDiaEnumSymbols,
}

impl Iterator for IDiaSymbolIterator {
    type Item = IDiaSymbol;

    fn next(&mut self) -> Option<Self::Item> {
        unsafe {
            let mut result = ::core::mem::zeroed();
            let mut count = 0;
            self.symbols.Next(1, &mut result, &mut count).ok()?;

            if count == 0 || result.is_none() {
                None
            } else {
                result
            }
        }
    }
}

[tim-weis]

Arrays in C are expressed as a pointer to the first element and a length. A pointer to a single object is identical to an array of length 1. The impl Iterator looks fine.

That aside, consider keeping unsafe blocks as narrow as possible. If you write let mut result = None; instead, you'll wind up with a single expression that needs to be wrapped inside an unsafe block.

[riverar]

Am working on this method, but just a heads up--it's much easier to work with the Count/Item methods on the enumerator as such:

for i in 0..symbols.Count()? {
    println!("{}", symbols.Item(i as u32)?.name()?);
}