Unexpected values for certain Integer literals

[jvasileff]

Integer literals of the following forms produce unexpected values:

1. outside of 64-bit min/max range, or
2. negative (per 64-bit-signed interpretation) hex or binary literals that are negated

    // one greater than JVM's runtime.maxIntegerValue
    print(9223372036854775808); // -9223372036854776000 on JS

    value x = -#ffff_ffff_ffff_ffff; 
    value y =  #ffff_ffff_ffff_ffff;

    print(x);   // +1 on JVM, -1 on JS 
    print(-y);  // +1

    print(y);   // -1
    print(-x);  // -1 on JVM, +1 on JS

[jvasileff]

My suggestion would be:

• For decimal literals, disallow values outside of the range -9223372036854775808..9223372036854775807
• For binary & hex, interpret as a signed 64-bit long, then perform negation if a negative sign is present

This would allow literals that cannot be stored with perfect precision, and would be smaller than the full range of values possible in JS, but to me seems like a reasonable compromise for cross-platform code.

[gavinking]

+1, the JVM backend already performs this kind of validation.

[chochos]

I use a BigInteger to parse natural literals, so I can just check that they are less than 64 bits long.

[jvasileff]

This one is pretty weird:

    // min in hex
    print (-#8000_0000_0000_0000);   // negative, same as Java
    print (-(#8000_0000_0000_0000)); // positive, opposite of Java
    // so...
    print (-#8000_0000_0000_0000 == -(#8000_0000_0000_0000)); // ** false!

In Java, negating min has no effect, but the operation does of course change the sign in JS. If 64-bit hex literals are to be supported in JS, perhaps it makes sense for all of the above numbers to be positive. Conceptually, I guess, the literal would not be considered to include the "-" sign.

[jvasileff]

Negative decimals still produce unexpected results:

    // min
    print (-9223372036854775808);   // ok, good

    // one less than min 64
    print (-9223372036854775809);   // no compile error

    // a lot less than min: -(2^64 - 1)
    print (-18446744073709551615);  // -1

[chochos]

Perhaps I should revert to parsing Long directly instead of using BigInteger?

[gavinking]

@chochos why, precisely do you need to parse it at all?

[chochos]

Because I need to convert it to base 10, and check that it's a value within valid range

[gavinking]

Ah, so only for binary and hex literals?

[chochos]

Binary and hex literals need to be parsed and converted to base 10. Base 10 literals need to be validated against the max range, so I parse all number literals.

[chochos]

@jvasileff can you check if this is working ok now? I've tested all the cases mentioned in this issue and they work the same way as in JVM.

[jvasileff]

@chochos I tried out several things, and going with the 64-bit scheme, I have a couple thoughts on negatives.

1. For base-10, I believe the negative sign should be considered part of the literal. This is for both internal consistency, and consistency with the JVM. So, we'd have:

print(-9223372036854775808);        // ALLOWED
print(-(9223372036854775808));      // DISALLOWED
print(9223372036854775808.negated); // DISALLOWED

In the disallowed cases, the literal would actually be a positive value that is out of range.

Of course, due to platform differences, we correctly have:

print(-9223372036854775808); // negative on JVM & JS
print(-(-9223372036854775808)); // negative on JVM, positive on JS

2. For hex & binary, I believe the negative sign should not be considered part of the literal. Since we are using a signed 64-bit representation, support for negatives is already baked in before considering the - operator. And, any use of the JVM's concept of negation will inevitably lead to non-sensical results.

So, I believe all of the following should print the same positive number on JS (even though they are all negative on the JVM):

print(-#8000_0000_0000_0000);
print(#8000_0000_0000_0000.negated);
print(-(#8000_0000_0000_0000));
print(-(-(-#8000_0000_0000_0000)));

And, the following should print the same negative number on both JS & JVM:

print(#8000_0000_0000_0000);
print(-#8000_0000_0000_0000.negated);
print(-(-#8000_0000_0000_0000));

[jvasileff]

Worth noting, an adjacent - operator may not be part of the literal in some cases due to precedence rules. The following is currently disallowed by both compilers, which I presume to be correct:

 print(-9223372036854775808.negated);

[FroMage]

Moving to 1.3, that's really edge-case.