** remove class equals (too many equals)
This somewhat obscure point is probably the existence of a whole bunch of x [op]= op-codes (+=, -=, &=, %= etc)
If so I have now removed them.
This turned out to be sort of interesting, actually, since +=, -= and friends did not previously type-check the assignment, only the call to the actual operator.
That is, a += 10 would check that (a+10) did not generate an error, but not that it could be assigned to a. Especially with strict types enabled this is a rather large change.
Take, as an example, gmp.mpz objects (and all other objects overloading operators) since (object(*) + integer) type-checks to 'mixed'. The same is true for the other operators.
I "solved" this for now by adding automatic softcasts to the type to be assigned, which means that it again only checks that the operation can be done validly, not that the assignment will always work.
So, given "Gmp.mpz a": | a += 10;
is now equivalent to | a = [object(Gmp.mpz)](a+10);
On a somewhat related note X[*] = x[*] op <something> was sort of broken as well, it only worked for the short form assignments (x[*] += 10 etc).
I have partially fixed this now.
Previously it always converted the code to
| x = x[*] op <something>
This works, in so far as x gets the new value. But it gives incorrect (semantically, at least) results for this case:
| array x = ..; | array y = x; | x[*] += 10; | /* now x would not be equal to y */
I have fixed this, but auto-map as lvalue (on the left side of assignments) still has at least two issues:
| x[*] = RHS (not an automap)
This will currently just break run time with 'Source is not an array'. (Unless RHS happens to be an array with the same size as the left array, then you will get unexpected results). It should simply assign all elements in the array to RHS.
The other broken thing is multi-level automap assignments.
As an example:
| a[*][*] += 10;
This will currently work, but the expression is basically converted to
| a[*] = (a[*][*]+10)[*];
Which might be closer to what you wanted, but not quite perfect. :)