Support operators of structs in derived types

[ddobrev]

The only way seems to be implicit cast operators from the derived type to the base one so that operators can be used.

[genuinelucifer]

@ddobrev
I was trying to recreate this issue..
I tried:

struct DLL_API BaseClassWithOperator
{
private:
    int n;
public:
    BaseClassWithOperator(int m)
    {
        n = m;
    }
    BaseClassWithOperator operator+(int m)
    {
        BaseClassWithOperator temp(n);
        temp.n += m;
        return temp;
    }
    int getN()
    {
        return n;
    }
};

BaseClassWithOperator funcCheckOperatorForBaseClass()
{
    BaseClassWithOperator a(5);
    return (a + 6);
}

class DLL_API DerivedClassForOperator : public BaseClassWithOperator
{
public:
    DerivedClassForOperator(int n) : BaseClassWithOperator(n) { }
};

BaseClassWithOperator funcCheckOperatorForDerivedClass()
{
    DerivedClassForOperator a(5);
    return (a + 6);
}

But, it compiled without any errors so my guess is that the operator of base was supported for derived class.
Am I doing something wrong?

[ddobrev]

@genuinelucifer the reason you cannot reproduce it is that we do not (yet) automatically wrap structs as such. You need to explicitly mark "BaseClassWithOperator" in the generator settings by using SetClassAsValueType.

[genuinelucifer]

@ddobrev I marked both the classes with CS_VALUE_TYPE and yet there is no problem!
Well, isn't that meant to do same task as SetClassAsValueType? Or did I do something wrong?

[ddobrev]

Please check the generated code you get. If BaseClassWithOperator and DerivedClassForOperator are classes in C# - that is, generated with the "class" keyword - then you didn't get it right. I don't know how CS_VALUE_TYPE is supposed to work, I have not been involved in that part. What I meant was calling ASTContext.SetClassAsValueType in ILibrary.Preprocess - you get the ASTContext as a parameter:

lib.SetClassAsValueType("BaseClassWithOperator");
lib.SetClassAsValueType("DerivedClassForOperator");

[genuinelucifer]

using CS_VALUE_TYPE generated them as
"public unsafe partial struct BaseClassWithOperator" and
"public unsafe partial struct DerivedClassForOperator"
And there were no build errors.

[ddobrev]

Sorry, my mistake. You indeed get correct results. I forgot to mention that this issue is not about compilable code. The code does compile but it does not give the same freedom as the original C++. The idea is that since in C++ DerivedClassForOperator inherits from BaseClassWithOperator, you should be able to pass a DerivedClassForOperator object to the operator from BaseClassWithOperator:

DerivedClassForOperator d;
BaseClassWithOperator b = d + 1;

You cannot do this in C# because there DerivedClassForOperator does not inherit from BaseClassWithOperator - C# structs, unlike C++ structs, cannot be subclassed. So this task is about finding a solution, if any, which would enable this case to be possible in C#.

[genuinelucifer]

One of the first solutions that comes at first glance to me (noticing that C# structs can't be subclassed) is that of simply copying all the members and functions from base struct which aren't already present in the derived struct (to allow override). Although this may lead to incompilable code generation in certain cases of conflict.
You mentioned in the issue that we can use implicit cast to Base but since there is no relation between Base and Derived structs, how are we supposed to cast them!?

[ddobrev]

The casting would be implemented by creating a C# implicit operator taking a Derived and returning a Base which would be done by copying the relevant internal fields. However, your idea looks good as well so I am not sure which solution would be better. So please implement #402 first, it's way more important anyway, and we'll see about this one later.

[genuinelucifer]

Ohk. I thought explicit conversion would require similar structures in base and derived. Well, yes we can discuss this later on. I will start working on the other issues today. :)