[macro] structure extension information is not available after typing

[nadako]

Typer currently seems to generate a new TAnonymous for a TExtend, merging its fields and losing information about extended types. However, I find that info useful sometimes and would love to see it available somehow (maybe as metadata or AnonStatus param). For example:

In our game we have type definitions for game content JSON structures like that:

typedef MapItemDef = {
    name:String
}

typedef DragonDef = {
    >MapItemDef,
    elements:Int
}

What I want to do is macro-generate some C# classes for the Unity3D client that wraps those structures and I want to preserve inheritance hierarchy for those classes:

class MapItemDef {
    public readonly string Name;

    public MapItemDef(JSValue o) {
        Name = o["name"].AsString;
    }
}

class DragonDef : MapItemDef {
    public readonly int Elements;

    public DragonDef (JSValue o) : base(o) {
        Elements = o["elements"].AsInt;
    }
}

[ncannasse]

Suggestion : store it in some metadata ?

[ncannasse]

Or more exactly : let the compiler store it into some metadata that you can later retreive

[nadako]

Yeah that's one option as I said. I'll try to implement it.

[nadako]

Oh wait, but tanon currently can't have any metadata.

[waneck]

Maybe create a new TType to that tanon then?

[nadako]

Meh, i don't know, this is not really a typedef and people may rely on it being plain TAnonymous in their macros.

[ncannasse]

Ah right. We could have it into the a_status then

[nadako]

@ncannasse do you think it will make sense to just add a_extends : t list and don't mess with a_status?

[nadako]

something like this nadako@21a20fd

[nadako]

or is it better to actually have some special a_status for that? i still don't really understand the whole open/closed/const anon status stuff

[Simn]

Maybe this helps:

typedef X = {
    x: Int
}

typedef Xy = {
    x: Int,
    y: String
}

class Main {
    static function main() { }

    static function opened(a) {
        // a is a monomorph here
        // field access turns it into an open anon
        a.x = 12;
        a.y = "foo";
        // note the +
        $type(a); // {+ y : String, x : Int }

        // unify with closed anon Xy
        var a2:Xy = a;
        // a is closed now
        $type(a); // { y : String, x : Int }

        // cannot add any more fields
        a.z = true;

        // can assign to less specific anon
        var a3:X = a;
    }

    static function const() {
        var a = { x: 12, y: "foo" };
        // a is const here, prints the same
        $type(a); // { y : String, x : Int }

        // unifies with closed, remains const
        var a2:Xy = a;

        // does not unify with less specific anon
        var a3:X = a;
    }
}

Open and closed status is quite straightforward: Open anons are only relevant when accessing fields on monomorphs. They allow additional fields to be added. Upon unification they are closed, which means they do not accept any more fields.

Const status is more peculiar and I can never remember why it exists in the first place, although it always makes sense when Nicolas explains it (again). It is relevant when working with structure declarations and as far as I can tell the distinguishing feature is that they do not unify with less specific anon types.

For your case I'd say the new status should be treated just ilke Closed.

[nadako]

Am I right thinking that extension info is only relevant for the Closed status? Then it would make sense to put that info in the Closed argument, but this is a breaking change (we only exposed "AnonStatus" in 3.1 tho).

So what should we do? Here's an implementation with an extra tanon field: nadako/haxe@21a20fd

[nadako]

any comments?:)

[ncannasse]

Add a new case for a_status, that's the best solution

[nadako]

Okay, I've added a pull request #3228 adding new anon_status variant. Please review and merge!