betterC: new operator

[Basile B.]

On Sunday, 22 November 2020 at 11:54:01 UTC, Dibyendu Majumdar 
wrote:
> I had assumed that new operator is not available in betterC.
>
> But in following code, it seems the only way to initialize the 
> object correctly ... is there another way I am missing? How 
> should one cleanup objects?
>
> import core.stdc.stdio : printf;
>
> extern (C++) abstract class A {
>     void sayHello();
> }
>
> extern (C++) class B : A {
>     override void sayHello() {
>         printf("hello\n");
>     }
> }
>
> extern (C) void main() {
>     scope b = new B;
>     b.sayHello();
> }

You can recreate the vtable using static introspection, POC:

---
#!dmd -betterC
module a;

import core.stdc.stdlib : malloc;
import core.stdc.stdio  : printf;
import std.traits;

void setVtable(CT)(ref void** memory)
{
     alias members = __traits(allMembers, CT);
     void** entries = cast(void**) malloc(members.length + 1);
     size_t i;
     static foreach(m; members)
         static if (isSomeFunction!(__traits(getMember, CT, m)))
             static foreach (ov; __traits(getVirtualMethods, CT, 
m))
     {
         entries[i++] = &ov;
     }

     memory[0] = *entries;   // pointer to vtable
     memory[1] = null;       // monitor
     memory[2] = null;       // interfaces
}

CT New(CT, A...)(A a) @trusted
if (is(CT == class))
{
     enum size    = __traits(classInstanceSize, CT);
     void** memory = cast(void**) malloc(size);
     setVtable!CT(memory);
     CT result = cast(CT) &memory;
     static if (__traits(hasMember, CT, "__ctor"))
         result.__ctor(a);
     return result;
}

extern (C++) class A {
     abstract void sayHello() {}
}

extern (C++) class B : A {
     override void sayHello() {
         printf("hello\n");
     }
}

extern (C) void main() {
     B b = New!B();
     b.sayHello();
}
---

however note
1. not well tested (e.g overloads)
2. static init of fields is not done because that really rquires 
TypeInfo, so a ctor has to be used instead.

But that's a good start to get things done more properly