init

.venv/lib/python3.8/site-packages/mypyc/test-data/irbuild-constant-fold.test

@@ -0,0 +1,263 @@
+[case testIntConstantFolding]
+def bin_ops() -> None:
+    add = 15 + 47
+    add_mul = (2 + 3) * 5
+    sub = 7 - 11
+    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, bit_and, bit_or, bit_xor, lshift, rshift, lshift0, rshift0 :: int
+L0:
+    add = 124
+    add_mul = 50
+    sub = -8
+    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
+    mod_by_zero = 5 % 0
+    lshift_neg = 6 << -1
+    rshift_neg = 7 >> -1
+def unsupported_div() -> None:
+    x = 4 / 6
+    y = 10 / 5
+def unsupported_pow() -> None:
+    p = 3 ** (-1)
+[out]
+def error_cases():
+    r0, div_by_zero, r1, mod_by_zero, r2, lshift_neg, r3, rshift_neg :: int
+L0:
+    r0 = CPyTagged_FloorDivide(10, 0)
+    div_by_zero = r0
+    r1 = CPyTagged_Remainder(10, 0)
+    mod_by_zero = r1
+    r2 = CPyTagged_Lshift(12, -2)
+    lshift_neg = r2
+    r3 = CPyTagged_Rshift(14, -2)
+    rshift_neg = r3
+    return 1
+def unsupported_div():
+    r0, r1, r2 :: object
+    r3, x :: float
+    r4, r5, r6 :: object
+    r7, y :: float
+L0:
+    r0 = box(short_int, 8)
+    r1 = box(short_int, 12)
+    r2 = PyNumber_TrueDivide(r0, r1)
+    r3 = cast(float, r2)
+    x = r3
+    r4 = box(short_int, 20)
+    r5 = box(short_int, 10)
+    r6 = PyNumber_TrueDivide(r4, r5)
+    r7 = cast(float, r6)
+    y = r7
+    return 1
+def unsupported_pow():
+    r0, r1, r2 :: object
+    r3, p :: float
+L0:
+    r0 = box(short_int, 6)
+    r1 = box(short_int, -2)
+    r2 = CPyNumber_Power(r0, r1)
+    r3 = cast(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
+    # TODO: Constant fold this as well
+    a = Y + 1
+[out]
+def f():
+    a, r0 :: int
+    r1 :: bool
+    r2 :: int
+L0:
+    a = 12
+    r0 = __main__.Y :: static
+    if is_error(r0) goto L1 else goto L2
+L1:
+    r1 = raise NameError('value for final name "Y" was not set')
+    unreachable
+L2:
+    r2 = CPyTagged_Add(r0, 2)
+    a = r2
+    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
+    r0 :: bool
+L0:
+    __mypyc_self__.X = 10; r0 = is_error
+    return 1
+def f():
+    a :: int
+L0:
+    a = 12
+    return 1
+
+[case testStrConstantFolding]
+from typing_extensions import Final
+
+S: Final = 'z'
+
+def f() -> None:
+    x = 'foo' + 'bar'
+    y = 'x' + 'y' + S
+[out]
+def f():
+    r0, x, r1, y :: str
+L0:
+    r0 = 'foobar'
+    x = r0
+    r1 = 'xyz'
+    y = r1
+    return 1