mypyc/test-data/irbuild-constant-fold.test

[case testIntConstantFolding]
def bin_ops() -> None:
    add = 15 + 47
    add_mul = (2 + 3) * 5
    sub = 7 - 11
    div = 3 / 2
    bit_and = 6 & 10
    bit_or = 6 | 10
    bit_xor = 6 ^ 10
    lshift = 5 << 2
    rshift = 13 >> 2
    lshift0 = 5 << 0
    rshift0 = 13 >> 0
def unary_ops() -> None:
    neg1 = -5
    neg2 = --1
    neg3 = -0
    pos = +5
    inverted1 = ~0
    inverted2 = ~5
    inverted3 = ~3
def pow() -> None:
    p0 = 3**0
    p1 = 3**5
    p2 = (-5)**3
    p3 = 0**0
[out]
def bin_ops():
    add, add_mul, sub :: int
    div :: float
    bit_and, bit_or, bit_xor, lshift, rshift, lshift0, rshift0 :: int
L0:
    add = 124
    add_mul = 50
    sub = -8
    div = 1.5
    bit_and = 4
    bit_or = 28
    bit_xor = 24
    lshift = 40
    rshift = 6
    lshift0 = 10
    rshift0 = 26
    return 1
def unary_ops():
    neg1, neg2, neg3, pos, inverted1, inverted2, inverted3 :: int
L0:
    neg1 = -10
    neg2 = 2
    neg3 = 0
    pos = 10
    inverted1 = -2
    inverted2 = -12
    inverted3 = -8
    return 1
def pow():
    p0, p1, p2, p3 :: int
L0:
    p0 = 2
    p1 = 486
    p2 = -250
    p3 = 2
    return 1

[case testIntConstantFoldingDivMod]
def div() -> None:
    div1 = 25 // 5
    div2 = 24 // 5
    div3 = 29 // 5
    div4 = 30 // 5
    div_zero = 0 // 5
    neg1 = -1 // 3
    neg2 = -2 // 3
    neg3 = -3 // 3
    neg4 = -4 // 3
    neg_neg = -765467 // -234
    pos_neg = 983745 // -7864
def mod() -> None:
    mod1 = 25 % 5
    mod2 = 24 % 5
    mod3 = 29 % 5
    mod4 = 30 % 5
    mod_zero = 0 % 5
    neg1 = -4 % 3
    neg2 = -5 % 3
    neg3 = -6 % 3
    neg4 = -7 % 3
    neg_neg = -765467 % -234
    pos_neg = 983745 % -7864
[out]
def div():
    div1, div2, div3, div4, div_zero, neg1, neg2, neg3, neg4, neg_neg, pos_neg :: int
L0:
    div1 = 10
    div2 = 8
    div3 = 10
    div4 = 12
    div_zero = 0
    neg1 = -2
    neg2 = -2
    neg3 = -2
    neg4 = -4
    neg_neg = 6542
    pos_neg = -252
    return 1
def mod():
    mod1, mod2, mod3, mod4, mod_zero, neg1, neg2, neg3, neg4, neg_neg, pos_neg :: int
L0:
    mod1 = 0
    mod2 = 8
    mod3 = 8
    mod4 = 0
    mod_zero = 0
    neg1 = 4
    neg2 = 2
    neg3 = 0
    neg4 = 4
    neg_neg = -106
    pos_neg = -14238
    return 1

[case testIntConstantFoldingUnsupportedCases]
def error_cases() -> None:
    div_by_zero = 5 / 0
    floor_div_by_zero = 5 // 0
    mod_by_zero = 5 % 0
    lshift_neg = 6 << -1
    rshift_neg = 7 >> -1
def unsupported_pow() -> None:
    p = 3 ** (-1)
[out]
def error_cases():
    r0, div_by_zero :: float
    r1, floor_div_by_zero, r2, mod_by_zero, r3, lshift_neg, r4, rshift_neg :: int
L0:
    r0 = CPyTagged_TrueDivide(10, 0)
    div_by_zero = r0
    r1 = CPyTagged_FloorDivide(10, 0)
    floor_div_by_zero = r1
    r2 = CPyTagged_Remainder(10, 0)
    mod_by_zero = r2
    r3 = CPyTagged_Lshift(12, -2)
    lshift_neg = r3
    r4 = CPyTagged_Rshift(14, -2)
    rshift_neg = r4
    return 1
def unsupported_pow():
    r0, r1, r2 :: object
    r3, p :: float
L0:
    r0 = object 3
    r1 = object -1
    r2 = CPyNumber_Power(r0, r1)
    r3 = unbox(float, r2)
    p = r3
    return 1

[case testIntConstantFoldingBigIntResult_64bit]
def long_and_short() -> None:
    # The smallest and largest representable short integers
    short1 =  0x3ffffffffffffff0 + 0xf  # (1 << 62) - 1
    short2 = -0x3fffffffffffffff - 1    # -(1 << 62)
    short3 = -0x4000000000000000
    # Smallest big integers by absolute value
    big1 = 1 << 62
    big2 = 0x4000000000000000  # 1 << 62
    big3 = -(1 << 62) - 1
    big4 = -0x4000000000000001  # -(1 << 62) - 1
    big5 = 123**41
[out]
def long_and_short():
    short1, short2, short3, r0, big1, r1, big2, r2, big3, r3, big4, r4, big5 :: int
L0:
    short1 = 9223372036854775806
    short2 = -9223372036854775808
    short3 = -9223372036854775808
    r0 = object 4611686018427387904
    big1 = r0
    r1 = object 4611686018427387904
    big2 = r1
    r2 = object -4611686018427387905
    big3 = r2
    r3 = object -4611686018427387905
    big4 = r3
    r4 = object 48541095000524544750127162673405880068636916264012200797813591925035550682238127143323
    big5 = r4
    return 1

[case testConstantFoldFormatArgs]
# This only tests that the callee and args are constant folded,
# it is not intended to test the result.
from typing import Any, Final

FMT: Final = "{} {}"

def f() -> str:
    return FMT.format(400 + 20, "roll" + "up")
[out]
def f():
    r0, r1, r2, r3 :: str
L0:
    r0 = CPyTagged_Str(840)
    r1 = 'rollup'
    r2 = ' '
    r3 = CPyStr_Build(3, r0, r2, r1)
    return r3

[case testIntConstantFoldingFinal]
from typing import Final
X: Final = 5
Y: Final = 2 + 4

def f() -> None:
    a = X + 1
    a = Y + 1
[out]
def f():
    a :: int
L0:
    a = 12
    a = 14
    return 1

[case testIntConstantFoldingClassFinal]
from typing import Final
class C:
    X: Final = 5

def f() -> None:
    a = C.X + 1
[out]
def f():
    a :: int
L0:
    a = 12
    return 1

[case testFloatConstantFolding]
from typing import Final

N: Final = 1.5
N2: Final = 1.5 * 2

def bin_ops() -> None:
    add = 0.5 + 0.5
    add_mul = (1.5 + 3.5) * 5.0
    sub = 7.0 - 7.5
    div = 3.0 / 2.0
    floor_div = 3.0 // 2.0
def bin_ops_neg() -> None:
    add = 0.5 + -0.5
    add_mul = (-1.5 + 3.5) * -5.0
    add_mul2 = (1.5 + -3.5) * -5.0
    sub = 7.0 - -7.5
    div = 3.0 / -2.0
    floor_div = 3.0 // -2.0
def unary_ops() -> None:
    neg1 = -5.5
    neg2 = --1.5
    neg3 = -0.0
    pos = +5.5
def pow() -> None:
    p0 = 16.0**0
    p1 = 16.0**0.5
    p2 = (-5.0)**3
    p3 = 16.0**(-0)
    p4 = 16.0**(-0.5)
    p5 = (-2.0)**(-1)
def error_cases() -> None:
    div = 2.0 / 0.0
    floor_div = 2.0 // 0.0
    power_imag = (-2.0)**0.5
    power_imag2 = (-2.0)**(-0.5)
    power_overflow = 2.0**10000.0
def final_floats() -> None:
    add1 = N + 1.2
    add2 = N + N2
    add3 = -1.2 + N2
[out]
def bin_ops():
    add, add_mul, sub, div, floor_div :: float
L0:
    add = 1.0
    add_mul = 25.0
    sub = -0.5
    div = 1.5
    floor_div = 1.0
    return 1
def bin_ops_neg():
    add, add_mul, add_mul2, sub, div, floor_div :: float
L0:
    add = 0.0
    add_mul = -10.0
    add_mul2 = 10.0
    sub = 14.5
    div = -1.5
    floor_div = -2.0
    return 1
def unary_ops():
    neg1, neg2, neg3, pos :: float
L0:
    neg1 = -5.5
    neg2 = 1.5
    neg3 = -0.0
    pos = 5.5
    return 1
def pow():
    p0, p1, p2, p3, p4, p5 :: float
L0:
    p0 = 1.0
    p1 = 4.0
    p2 = -125.0
    p3 = 1.0
    p4 = 0.25
    p5 = -0.5
    return 1
def error_cases():
    r0 :: bit
    r1 :: bool
    r2, div, r3, floor_div :: float
    r4, r5, r6 :: object
    r7, power_imag :: float
    r8, r9, r10 :: object
    r11, power_imag2 :: float
    r12, r13, r14 :: object
    r15, power_overflow :: float
L0:
    r0 = 0.0 == 0.0
    if r0 goto L1 else goto L2 :: bool
L1:
    r1 = raise ZeroDivisionError('float division by zero')
    unreachable
L2:
    r2 = 2.0 / 0.0
    div = r2
    r3 = CPyFloat_FloorDivide(2.0, 0.0)
    floor_div = r3
    r4 = box(float, -2.0)
    r5 = box(float, 0.5)
    r6 = CPyNumber_Power(r4, r5)
    r7 = unbox(float, r6)
    power_imag = r7
    r8 = box(float, -2.0)
    r9 = box(float, -0.5)
    r10 = CPyNumber_Power(r8, r9)
    r11 = unbox(float, r10)
    power_imag2 = r11
    r12 = box(float, 2.0)
    r13 = box(float, 10000.0)
    r14 = CPyNumber_Power(r12, r13)
    r15 = unbox(float, r14)
    power_overflow = r15
    return 1
def final_floats():
    add1, add2, add3 :: float
L0:
    add1 = 2.7
    add2 = 4.5
    add3 = 1.8
    return 1

[case testMixedFloatIntConstantFolding]
def bin_ops() -> None:
    add = 1 + 0.5
    sub = 1 - 0.5
    mul = 0.5 * 5
    div = 5 / 0.5
    floor_div = 9.5 // 5
def error_cases() -> None:
    div = 2.0 / 0
    floor_div = 2.0 // 0
    power_overflow = 2.0**10000
[out]
def bin_ops():
    add, sub, mul, div, floor_div :: float
L0:
    add = 1.5
    sub = 0.5
    mul = 2.5
    div = 10.0
    floor_div = 1.0
    return 1
def error_cases():
    r0 :: bit
    r1 :: bool
    r2, div, r3, floor_div :: float
    r4, r5, r6 :: object
    r7, power_overflow :: float
L0:
    r0 = 0.0 == 0.0
    if r0 goto L1 else goto L2 :: bool
L1:
    r1 = raise ZeroDivisionError('float division by zero')
    unreachable
L2:
    r2 = 2.0 / 0.0
    div = r2
    r3 = CPyFloat_FloorDivide(2.0, 0.0)
    floor_div = r3
    r4 = box(float, 2.0)
    r5 = box(float, 10000.0)
    r6 = CPyNumber_Power(r4, r5)
    r7 = unbox(float, r6)
    power_overflow = r7
    return 1

[case testStrConstantFolding]
from typing import Final

S: Final = 'z'
N: Final = 2

def f() -> None:
    x = 'foo' + 'bar'
    y = 'x' + 'y' + S
    mul = "foobar" * 2
    mul2 = N * "foobar"
[out]
def f():
    r0, x, r1, y, r2, mul, r3, mul2 :: str
L0:
    r0 = 'foobar'
    x = r0
    r1 = 'xyz'
    y = r1
    r2 = 'foobarfoobar'
    mul = r2
    r3 = 'foobarfoobar'
    mul2 = r3
    return 1

[case testBytesConstantFolding]
from typing import Final

N: Final = 2

def f() -> None:
    # Unfortunately, mypy doesn't store the bytes value of final refs.
    x = b'foo' + b'bar'
    mul = b"foobar" * 2
    mul2 = N * b"foobar"
[out]
def f():
    r0, x, r1, mul, r2, mul2 :: bytes
L0:
    r0 = b'foobar'
    x = r0
    r1 = b'foobarfoobar'
    mul = r1
    r2 = b'foobarfoobar'
    mul2 = r2
    return 1

[case testComplexConstantFolding]
from typing import Final

N: Final = 1
FLOAT_N: Final = 1.5

def integral() -> None:
    pos = 1+2j
    pos_2 = 2j+N
    neg = 1-2j
    neg_2 = 2j-N
def floating() -> None:
    pos = 1.5+2j
    pos_2 = 2j+FLOAT_N
    neg = 1.5-2j
    neg_2 = 2j-FLOAT_N
[out]
def integral():
    r0, pos, r1, pos_2, r2, neg, r3, neg_2 :: object
L0:
    r0 = (1+2j)
    pos = r0
    r1 = (1+2j)
    pos_2 = r1
    r2 = (1-2j)
    neg = r2
    r3 = (-1+2j)
    neg_2 = r3
    return 1
def floating():
    r0, pos, r1, pos_2, r2, neg, r3, neg_2 :: object
L0:
    r0 = (1.5+2j)
    pos = r0
    r1 = (1.5+2j)
    pos_2 = r1
    r2 = (1.5-2j)
    neg = r2
    r3 = (-1.5+2j)
    neg_2 = r3
    return 1