[cpp] Gencpp Rework Mk II

[Aidan63]

This is a follow up to my previous cpp generator rework and is what I was aiming for in the first place.

Class and interface generation (as well as native and managed variants) was contained in one big function with a sprawling set of if statements to generate code based on those 4 types. Incorrect branches being taken has been the root of several bugs and the code in general is very unweildy and hard to extend.
When module level functions came out I had a go at extending the generator to output these as namespace level functions / variables but gave up as adding an extra variant was too much to deal with.

So now the cpp generate splits types into one of 5 categories, native class, managed class, native interface, managed interface. or enums. There are now dedicated generator functions for the header and implementation code of these 5 types which is mostly stitching together calls to shared functions with very little branching involved.

The fields for the class and interface types are also split up to make the generators work easier. tclass_fields are divided up into variables (physical), properties (non physical), functions, and dynamic functions. This means that areas such as generating mark and visit functions only need to iterate over the variables which makes the code much easier to follow. Previously it was iterating over all fields and needing to filter out dynamic functions, non physical fields, etc.

This division works really well and there is no case where parts of the generator needs to then further filter the lists which is quite satisfying. When these fields get split up we also handle various hxcpp implementation details. E.g. dynamic functions will put a variable into othe variable list, abstract functions will place a no-op function into the function list, and variables with default functions will place a dynamic function into the dynamic function list. These means a lot of the edge cases which were handled multiple times in various places in the generator are now handled once at retyping which, again, simplifies the generators code.

Some stuff such as class Ids and interface slots are now assigned during retyping which means the context is now more immutable.

There was more I was thinking of doing such as the retyped classes containg tcpp expressions and types but this has been going on for quite a while now and I think its good enough. I've manually ran the hxcpp test suite and it all passes and I've ran some of the tests with the generational GC and that still works.

[Aidan63]

Turns out it does happen on Windows, I just forgot to change the haxe version to this branch...

Good thing is that I can now see more of whats actually erroring. Call stack on windows points to a memset call within PCRE2.

Now to figure out whats going on and see if this is a new issue or something thats been lurking for a while but has only now made itself visible.

[Aidan63]

Figured it out, it was a GC related issue in the end.

Sub classes which contained no GC fields but did inherit from a parent which does contain GC fields was allocating itself with the container flag set to false.
The retyped classes now contain more information on the container status of a class so it will correctly allocate classes with the container flag and only override mark and visit if the current class has GC fields.

[Aidan63]

Didn't expect to do any more but I've updated the main retyper to pass around a context object which stores the previous ref based state.
Had an idea improving my existing callable PR which would require some info from the retyping stage and having this retyping context object opens that up.