Cannot decode large signed Int64

[DrewMcArthur]

from testCases.bal:67

// saving this test case for later: encoding works, 
// but currently trying to run decode([0xd3, ...]) will fail, 
// because 0xd3 == signed Int64, and our algorithm fails.
// this is because we calculat an int, then subtract (1 << 8*nBytes), and 
// if nBytes == 8, we would try to 1 << 64, which doesn't work with 64-bit ints.
TestCase[] SignedInt64TestCase = [
    {"input": -11111111111, "output": [0xd3, 0xff, 0xff, 0xff, 0xfd, 0x69, 0xb9, 0xe6, 0x39]}
];

[DrewMcArthur]

in decoding/int.bal:142, we handle this with an explicit error:

    if nBytes == 8 {
        // since 1 << 64 -> 1 bc 64-bit ints
        return error IntDecodingError("decoding signed Int64 types is not currently supported, sorry!", first_byte = data[0]);
    }

the next line is return [out - (1 << (8 * nBytes)), newdata];, which if nBytes == 8, then that attempts to shift 1 to the left 64 times, which gives us either 0 or 1, since ints are 64 bits, and 1 << 64 > MAX_INT (bc MAX_INT = 2 ** 64 - 1), leading to an incorrect decoded response.

we could probably just use an edge case, since we're trying to do X - 2^64, we can do some algebra -

x - 2 ** 64 == x - (2 * 2 **63)
                   == x - (2 ** 63 + 2 ** 63)
                   == x - 2 ** 63 - 2 ** 63

and that should work within the 64-bit architecture constraints

[DrewMcArthur]

solution wasn't quite as simple as the idea above - looks like i need to spend some time understanding how ballerina handles these large integer types more.

[DrewMcArthur]

am currently getting

 [fail data provider for the function testDecodeCase]
       int range overflow

for decoding these two test cases

TestCase[][] SignedInt64TestCases = [
    [{"input": -11111111111, "output": [0xd3, 0xff, 0xff, 0xff, 0xfd, 0x69, 0xb9, 0xe6, 0x39]}],
    [{"input": -9223372036854775807, "output": [0xd3, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01]}]
];

[DrewMcArthur]

this occurs in handleSignedInt

function handleSignedInt(byte[] data, int nBytes) returns [int, byte[]]|IntDecodingError {
    int out = 0;
    int i = 0;
    byte[] newdata = data;
    while i < nBytes {
        i = i + 1;
        byte next;
        [next, newdata] = core:shift(newdata);
        out = (out << 8) | next;
    }

    if nBytes == 8 {
        // edge case, bc 64 bit ints cannot store 1 << 64
        int QUARTER_MAX_INT = 1 << 62;
        return [out - QUARTER_MAX_INT - QUARTER_MAX_INT - QUARTER_MAX_INT - QUARTER_MAX_INT, newdata];
    }

    return [out - (1 << (8 * nBytes)), newdata];
}