File: C:/Users/fred/anaconda3/Lib/site-packages/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 testIntConstantFoldingFinal]
from typing_extensions 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_extensions import Final
class C:
X: Final = 5
def f() -> None:
a = C.X + 1
[out]
def C.__mypyc_defaults_setup(__mypyc_self__):
__mypyc_self__ :: __main__.C
L0:
__mypyc_self__.X = 10
return 1
def f():
a :: int
L0:
a = 12
return 1
[case testFloatConstantFolding]
from typing_extensions 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_extensions 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_extensions 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_extensions 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