[cs] abstract operator overload + readonly var

[kevinresol]

Haxe revision: 84bf7e5
The following code causes a runtime error on c#:

Unhandled Exception:
Cannot access field for writing.

class Main {
	static function main() {
		var f1:Future<Int> = Future.trigger();
		var f2:Future<Int> = Future.trigger();
		
		var f = f1 || f2; // run-time fail
		var f = f1.first(f2); // ok
		var f = Future.or(f1, f2); // ok
	}
}

abstract Future<T>(FutureTrigger<T>) from FutureTrigger<T> to FutureTrigger<T> {
	public static function trigger<T>():FutureTrigger<T>
		return new FutureTrigger();
		
	public function handle(f:Void->Void)
		return null;
		
  	@:op(a || b) static public function or<A>(a:Future<A>, b:Future<A>):Future<A>
    	return a.first(b);
		
	public function first(other:Future<T>):Future<T> {
		var ret = Future.trigger();
		var l1 = handle(ret.trigger);
		return ret;
	}
}

class FutureTrigger<T> {
	public var triggered(get, never):Bool; // ok if changing never to something else
	public function new() {}
	public function trigger() {}
	public function get_triggered()
		return true;
}

[nadako]

Reduced to this:

class C<T> {
    public var v(get,never):Bool;
    function get_v() return true;

    public function new() {}
}

class Main {
    static function main() {
        var d:Dynamic = new C<Dynamic>();
        var i:C<Int> = d;
    }
}

Bad things happen in the dynamic type param cast helpers: it iterates over Reflect.fields(this) and that include the get,never var, setting of which obviously fails when trying to Reflect.setField it in a copy.

As a (fairly) quick fix we should look into iterating only over physical fields instead of relying on Reflect.fields, but this cast-by-copy thing is so bad we should seriously consider reworking it for 4.0 (see #2103).

[kevinresol]

But I also wonder why there is a need for casting in the operator-overload case, while not in the direct function call case?