Simplify and truncate Com method call requirements

[marler8997]

For COM, in order to accommodate only a single pass I originally leveraged usingnamespace to mixin inherited interface functions. However, the resulting generated code is not easy to follow and this resulted in symbol conflicts, so, I namespaced all methods with the type/interface they came from <interface>_<method>, i.e.

render_target.ID2D1RenderTarget_GetPixelSize();
// rather than
render_target.GetPixelSize();

However, we now have a 2-pass system where we could accumulate the needed info for this, plus, the benefits of simplifying the generated code outweigh the benefits of keeping the generator simple, so let's do this.

[marler8997]

Some more ideas around COM types, how to convert sub classes to their base class counterparts. I think we're going with using union fields, version 2 from this sample:

const std = @import("std");

const BigPapaDaddyThis = @This();

pub const IUnknown = extern struct {
    pub const VTable = extern struct {
        Release: *const fn(
            self: *const IUnknown, c: [*:0]const u8
        ) callconv(@import("std").os.windows.WINAPI) void,
    };
    vtable: *const VTable,
    pub fn Release(self: *const IUnknown, c: [*:0]const u8) callconv(.Inline) void {
        return @as(
            *const IUnknown.VTable, @ptrCast(self.vtable)
        ).Release(
            @as(*const IUnknown, @ptrCast(self)), c
        );
    }
};

const SubTypeVersion1 = extern struct {
    pub const VTable = extern struct {
        base: BigPapaDaddyThis.IUnknown.VTable,
        MyCoolFunc: *const fn(self: *const SubTypeVersion1) callconv(@import("std").os.windows.WINAPI) void,
    };
    vtable: *const VTable,
    pub fn IUnknown(self: *SubTypeVersion1) *BigPapaDaddyThis.IUnknown {
        return @ptrCast(self);
    }
};

const SubTypeVersion2 = extern union {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        MyCoolFunc: *const fn(self: *const SubTypeVersion2) callconv(@import("std").os.windows.WINAPI) void,
    };
    vtable: *const VTable,
    IUnknown: IUnknown,
    
};

const SubSubTypeVersion2 = extern union {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        JustOkFunc: *const fn(self: *const SubSubTypeVersion2) callconv(@import("std").os.windows.WINAPI) void,
    };
    vtable: *const VTable,
    IUnknown: IUnknown,
    SubTypeVersion2: SubTypeVersion2,
};

fn reallyCoolFunction(i: *IUnknown) void {
    i.Release("from reallyCoolFunction");
}

fn IUnknown_Release(self: *const IUnknown, c: [*:0]const u8) callconv(@import("std").os.windows.WINAPI) void {
    std.log.info("Release called on {*} context='{s}'", .{self, c});
}
fn SubTypeVersion1_MyCoolFunc(self: *const SubTypeVersion1) callconv(@import("std").os.windows.WINAPI) void {
    std.log.info("MyCoolFunc called on {*}", .{self});
}
fn SubTypeVersion2_MyCoolFunc(self: *const SubTypeVersion2) callconv(@import("std").os.windows.WINAPI) void {
    std.log.info("MyCoolFunc called on {*}", .{self});
}
fn SubSubTypeVersion2_JusOkFunc(self: *const SubSubTypeVersion2) callconv(@import("std").os.windows.WINAPI) void {
    std.log.info("JustOkFunc called on {*}", .{self});
}

const iunknown_vtable = IUnknown.VTable{
    .Release = IUnknown_Release,
};
const version1_vtable = SubTypeVersion1.VTable{
    .base = iunknown_vtable,
    .MyCoolFunc = SubTypeVersion1_MyCoolFunc,
};
const version2_vtable = SubTypeVersion2.VTable{
    .base = iunknown_vtable,
    .MyCoolFunc = SubTypeVersion2_MyCoolFunc,
};
const version2sub_vtable = SubSubTypeVersion2.VTable{
    .base = iunknown_vtable,
    .JustOkFunc = SubSubTypeVersion2_JusOkFunc,
};

pub fn main() void {
    const unknown: IUnknown = .{ .vtable = &iunknown_vtable };
    unknown.Release("First");

    var version1_instance: SubTypeVersion1 = .{ .vtable = &version1_vtable };
    const version1 = &version1_instance;
    reallyCoolFunction(version1.IUnknown());
    version1.IUnknown().Release("here2");

    var version2_instance: SubTypeVersion2 = .{ .vtable = &version2_vtable };
    const version2 = &version2_instance;
    reallyCoolFunction(&version2.IUnknown);
    version2.IUnknown.Release("here");

    var version2sub_instance: SubSubTypeVersion2 = .{ .vtable = &version2sub_vtable };
    const version2sub = &version2sub_instance;
    reallyCoolFunction(&version2sub.IUnknown);
    version2sub.IUnknown.Release("here");
    version2sub.SubTypeVersion2.MyCoolFunc();
}

[marler8997]

I've made 2 changes already, I've made the COM types unions instead of structs with their base interface as the extra field alongside the vtable pointer: 1885a50

I've also removed the com type prefix from any methods that are defined by the com type itself: dc8171f

There's still a few more improvements to be made:

• Add all base type ancestors as fields (not just the first parent). Makes it easy/convenient to reinterpret every com type as any/all of it's valid base types.

• Remove MethodMixins, method mixins are unnecessarily difficult to reason about. Instead let's just write out all the methods that each COM type can call.

• Handle method conflicts better. If there is a conflict, maybe we can simply not generate the method and instead have the user call the method through the base type?

const Animal = union {
    pub fn playSound() { }
};

const Dog = union {
    vtable: *VTable,
    Animal: Animal,

    // conflicts with Animal.playSound
    pub fn playSound() { }
};

test {
    var dog: *Dog = createDog();
    dog.playSound();
    dog.Animal.playSound;
}

[marler8997]

Here's the third (but not final) change for this: #38

This adds all base types as union fields and removes the method mixins (yay! over 200K LOC gone!) I haven't yet added code to generate all the inherited interface methods directly on the COM type, but, by adding the base types as union fields we can remove the mixin and be no worse off today because we removed the method namespaces and all methods can be accessed through a single field, i.e.

// instead of
foo.IUnknown_Release();

// now you do
foo.IUnknown.Release();