doom2fan / echelonscript Goto Github PK

The WPF UI can only run on Windows, and it'd be better if we could run the tests on any platform.
The export and GC tests are an obvious case for moving to unit tests, since those don't need an UI or code editor.

Basically, sorta like lexical macros. Taken from D.

Not sure if I should add those. Maybe yes, maybe not.

As is, the backends consume a slightly modified AST that passed through the frontend.
The frontend could instead generate some form of simplified IR, for the benefit of both the backend and itself. Things like implicit casts could be made explicit, default args could be filled in, implicit args made explicit, etc.
It'd be a major refactoring, but it should make both the frontend and backend(s) much cleaner and simpler.

Right now, the usage of the shared string pool means those strings will never be released. That's quite wasteful, and it'd be better if they were only pooled relative to the compiler's lifetime.

With a dedicated slicing operator.

This would make comparison faster and simpler, as well as abstracting them.

Should be named something like intN or nint.

Basically, namespaces that span the whole file. This would be pretty useful for when the whole file uses only a single namespace. (i.e., most files)

Inspired by D. Would require strong CTFE.

We could have traits instead of interfaces, while still allowing "trait inheritance". This would mean classes and structs can explicitly implement a trait internally, while also allowing external "extension" of types with traits. e.g.

trait Iterator!(T, TState) {
    TState InitialState ();
    T? TryGetNext (ref TState state);
}

extends IList!(T) with Iteratable!(T, intN) {
    intN InitialState => 0;
    T? TryGetNext (ref intN index) => index < length ? this[index] : null;
}

class ClassWithIterator : Iterator<T, int32> {
    // [...]
}

This should work quite well:

public unsafe interface IEchelonScriptType {
    public static abstract ES_TypeInfo* TypeInfo { get; }
}

(i.e., @global::foo -> foo, @generated::foo& -> foo&)

C# has #line, so we can do this. The IR will need to be changed to carry the line number, however.

While the caching is nice for decreasing the amount of waste, it might be desirable to be able to get rid of the cached data.
Maybe make the cache local to the compiler object? We could also maybe make it cache pointers to make more nodes cacheable.
Line numbers could pose a problem for caching.
Maybe make it unmanaged? Shouldn't be too hard. Could then more easily restrict their lifetime to the compiler or environment.

Would allow bypassing the GC fairly often, with no runtime cost.