[case testBoolToAndFromInt]

from mypy_extensions import i64

def bool_to_int(b: bool) -> int:

return b

def int_to_bool(n: int) -> bool:

return bool(n)

def bool_to_i64(b: bool) -> i64:

return b

def i64_to_bool(n: i64) -> bool:

return bool(n)

def bit_to_int(n1: i64, n2: i64) -> int:

return bool(n1 == n2)

def bit_to_i64(n1: i64, n2: i64) -> i64:

return bool(n1 == n2)

[out]

def bool_to_int(b):

b, r0 :: bool

r1 :: int

L0:

r0 = b << 1

r1 = extend r0: builtins.bool to builtins.int

return r1

def int_to_bool(n):

n :: int

r0 :: bit

L0:

r0 = n != 0

return r0

def bool_to_i64(b):

b :: bool

r0 :: i64

L0:

r0 = extend b: builtins.bool to i64

return r0

def i64_to_bool(n):

n :: i64

r0 :: bit

L0:

r0 = n != 0

return r0

def bit_to_int(n1, n2):

n1, n2 :: i64

r0 :: bit

r1 :: bool

r2 :: int

L0:

r0 = n1 == n2

r1 = r0 << 1

r2 = extend r1: builtins.bool to builtins.int

return r2

def bit_to_i64(n1, n2):

n1, n2 :: i64

r0 :: bit

r1 :: i64

L0:

r0 = n1 == n2

r1 = extend r0: bit to i64

return r1

[case testConversionToBool]

from typing import List, Optional

class C: pass

class D:

def __bool__(self) -> bool:

return True

def list_to_bool(l: List[str]) -> bool:

return bool(l)

def always_truthy_instance_to_bool(o: C) -> bool:

return bool(o)

def instance_to_bool(o: D) -> bool:

return bool(o)

def optional_truthy_to_bool(o: Optional[C]) -> bool:

return bool(o)

def optional_maybe_falsey_to_bool(o: Optional[D]) -> bool:

return bool(o)

[out]

def D.__bool__(self):

self :: __main__.D

L0:

return 1

def list_to_bool(l):

l :: list

r0 :: native_int

r1 :: short_int

r2 :: bit

L0:

r0 = var_object_size l

r1 = r0 << 1

r2 = int_ne r1, 0

return r2

def always_truthy_instance_to_bool(o):

o :: __main__.C

r0 :: i32

r1 :: bit

r2 :: bool

L0:

r0 = PyObject_IsTrue(o)

r1 = r0 >= 0 :: signed

r2 = truncate r0: i32 to builtins.bool

return r2

def instance_to_bool(o):

o :: __main__.D

r0 :: bool

L0:

r0 = o.__bool__()

return r0

def optional_truthy_to_bool(o):

o :: union[__main__.C, None]

r0 :: object

r1 :: bit

L0:

r0 = load_address _Py_NoneStruct

r1 = o != r0

return r1

def optional_maybe_falsey_to_bool(o):

o :: union[__main__.D, None]

r0 :: object

r1 :: bit

r2 :: __main__.D

r3 :: bool

r4 :: bit

L0:

r0 = load_address _Py_NoneStruct

r1 = o != r0

if r1 goto L1 else goto L2 :: bool

L1:

r2 = cast(__main__.D, o)

r3 = r2.__bool__()

r4 = r3

goto L3

L2:

r4 = 0

L3:

return r4

[case testBoolComparisons]

def eq(x: bool, y: bool) -> bool:

return x == y

def neq(x: bool, y: bool) -> bool:

return x != y

def lt(x: bool, y: bool) -> bool:

return x < y

def le(x: bool, y: bool) -> bool:

return x <= y

def gt(x: bool, y: bool) -> bool:

return x > y

def ge(x: bool, y: bool) -> bool:

return x >= y

[out]

def eq(x, y):

x, y :: bool

r0 :: bit

L0:

r0 = x == y

return r0

def neq(x, y):

x, y :: bool

r0 :: bit

L0:

r0 = x != y

return r0

def lt(x, y):

x, y :: bool

r0 :: bit

L0:

r0 = x < y :: signed

return r0

def le(x, y):

x, y :: bool

r0 :: bit

L0:

r0 = x <= y :: signed

return r0

def gt(x, y):

x, y :: bool

r0 :: bit

L0:

r0 = x > y :: signed

return r0

def ge(x, y):

x, y :: bool

r0 :: bit

L0:

r0 = x >= y :: signed

return r0

[case testBoolMixedComparisons1]

from mypy_extensions import i64

def eq1(x: int, y: bool) -> bool:

return x == y

def eq2(x: bool, y: int) -> bool:

return x == y

def neq1(x: i64, y: bool) -> bool:

return x != y

def neq2(x: bool, y: i64) -> bool:

return x != y

[out]

def eq1(x, y):

x :: int

y, r0 :: bool

r1 :: int

r2 :: bit

L0:

r0 = y << 1

r1 = extend r0: builtins.bool to builtins.int

r2 = int_eq x, r1

return r2

def eq2(x, y):

x :: bool

y :: int

r0 :: bool

r1 :: int

r2 :: bit

L0:

r0 = x << 1

r1 = extend r0: builtins.bool to builtins.int

r2 = int_eq r1, y

return r2

def neq1(x, y):

x :: i64

y :: bool

r0 :: i64

r1 :: bit

L0:

r0 = extend y: builtins.bool to i64

r1 = x != r0

return r1

def neq2(x, y):

x :: bool

y, r0 :: i64

r1 :: bit

L0:

r0 = extend x: builtins.bool to i64

r1 = r0 != y

return r1

[case testBoolMixedComparisons2]

from mypy_extensions import i64

def lt1(x: bool, y: int) -> bool:

return x < y

def lt2(x: int, y: bool) -> bool:

return x < y

def gt1(x: bool, y: i64) -> bool:

return x < y

def gt2(x: i64, y: bool) -> bool:

return x < y

[out]

def lt1(x, y):

x :: bool

y :: int

r0 :: bool

r1 :: int

r2 :: bit

L0:

r0 = x << 1

r1 = extend r0: builtins.bool to builtins.int

r2 = int_lt r1, y

return r2

def lt2(x, y):

x :: int

y, r0 :: bool

r1 :: int

r2 :: bit

L0:

r0 = y << 1

r1 = extend r0: builtins.bool to builtins.int

r2 = int_lt x, r1

return r2

def gt1(x, y):

x :: bool

y, r0 :: i64

r1 :: bit

L0:

r0 = extend x: builtins.bool to i64

r1 = r0 < y :: signed

return r1

def gt2(x, y):

x :: i64

y :: bool

r0 :: i64

r1 :: bit

L0:

r0 = extend y: builtins.bool to i64

r1 = x < r0 :: signed

return r1

[case testBoolBitwise]

from mypy_extensions import i64

def bitand(x: bool, y: bool) -> bool:

b = x & y

return b

def bitor(x: bool, y: bool) -> bool:

b = x | y

return b

def bitxor(x: bool, y: bool) -> bool:

b = x ^ y

return b

def invert(x: bool) -> int:

return ~x

def mixed_bitand(x: i64, y: bool) -> i64:

return x & y

[out]

def bitand(x, y):

x, y, r0, b :: bool

L0:

r0 = x & y

b = r0

return b

def bitor(x, y):

x, y, r0, b :: bool

L0:

r0 = x | y

b = r0

return b

def bitxor(x, y):

x, y, r0, b :: bool

L0:

r0 = x ^ y

b = r0

return b

def invert(x):

x, r0 :: bool

r1, r2 :: int

L0:

r0 = x << 1

r1 = extend r0: builtins.bool to builtins.int

r2 = CPyTagged_Invert(r1)

return r2

def mixed_bitand(x, y):

x :: i64

y :: bool

r0, r1 :: i64

L0:

r0 = extend y: builtins.bool to i64

r1 = x & r0

return r1

[case testBoolArithmetic]

def add(x: bool, y: bool) -> int:

z = x + y

return z

def mixed(b: bool, n: int) -> int:

z = b + n

z -= b

z = z * b

return z

def negate(b: bool) -> int:

return -b

def unary_plus(b: bool) -> int:

x = +b

return x

[out]

def add(x, y):

x, y, r0 :: bool

r1 :: int

r2 :: bool

r3, r4, z :: int

L0:

r0 = x << 1

r1 = extend r0: builtins.bool to builtins.int

r2 = y << 1

r3 = extend r2: builtins.bool to builtins.int

r4 = CPyTagged_Add(r1, r3)

z = r4

return z

def mixed(b, n):

b :: bool

n :: int

r0 :: bool

r1, r2, z :: int

r3 :: bool

r4, r5 :: int

r6 :: bool

r7, r8 :: int

L0:

r0 = b << 1

r1 = extend r0: builtins.bool to builtins.int

r2 = CPyTagged_Add(r1, n)

z = r2

r3 = b << 1

r4 = extend r3: builtins.bool to builtins.int

r5 = CPyTagged_Subtract(z, r4)

z = r5

r6 = b << 1

r7 = extend r6: builtins.bool to builtins.int

r8 = CPyTagged_Multiply(z, r7)

z = r8

return z

def negate(b):

b, r0 :: bool

r1, r2 :: int

L0:

r0 = b << 1

r1 = extend r0: builtins.bool to builtins.int

r2 = CPyTagged_Negate(r1)

return r2

def unary_plus(b):

b, r0 :: bool

r1, x :: int

L0:

r0 = b << 1

r1 = extend r0: builtins.bool to builtins.int

x = r1

return x

[case testBitToBoolPromotion]

def bitand(x: float, y: float, z: float) -> bool:

b = (x == y) & (x == z)

return b

def bitor(x: float, y: float, z: float) -> bool:

b = (x == y) | (x == z)

return b

def bitxor(x: float, y: float, z: float) -> bool:

b = (x == y) ^ (x == z)

return b

def invert(x: float, y: float) -> bool:

return not(x == y)

[out]

def bitand(x, y, z):

x, y, z :: float

r0, r1 :: bit

r2, b :: bool

L0:

r0 = x == y

r1 = x == z

r2 = r0 & r1

b = r2

return b

def bitor(x, y, z):

x, y, z :: float

r0, r1 :: bit

r2, b :: bool

L0:

r0 = x == y

r1 = x == z

r2 = r0 | r1

b = r2

return b

def bitxor(x, y, z):

x, y, z :: float

r0, r1 :: bit

r2, b :: bool

L0:

r0 = x == y

r1 = x == z

r2 = r0 ^ r1

b = r2

return b

def invert(x, y):

x, y :: float

r0, r1 :: bit

L0:

r0 = x == y

r1 = r0 ^ 1

return r1

[case testUnaryNotWithPrimitiveTypes]

def not_obj(x: object) -> bool:

return not x

def not_int(x: int) -> bool:

return not x

def not_str(x: str) -> bool:

return not x

def not_list(x: list[int]) -> bool:

return not x

def not_tuple(x: tuple[int, ...]) -> bool:

return not x

def not_dict(x: dict[str, int]) -> bool:

return not x

[out]

def not_obj(x):

x :: object

r0 :: i32

r1 :: bit

r2 :: bool

L0:

r0 = PyObject_Not(x)

r1 = r0 >= 0 :: signed

r2 = truncate r0: i32 to builtins.bool

return r2

def not_int(x):

x :: int

r0 :: bit

L0:

r0 = int_eq x, 0

return r0

def not_str(x):

x :: str

r0, r1 :: bit

L0:

r0 = CPyStr_IsTrue(x)

r1 = r0 ^ 1

return r1

def not_list(x):

x :: list

r0 :: native_int

r1 :: short_int

r2, r3 :: bit

L0:

r0 = var_object_size x

r1 = r0 << 1

r2 = int_ne r1, 0

r3 = r2 ^ 1

return r3

def not_tuple(x):

x :: tuple

r0 :: native_int

r1 :: short_int

r2, r3 :: bit

L0:

r0 = var_object_size x

r1 = r0 << 1

r2 = int_ne r1, 0

r3 = r2 ^ 1

return r3

def not_dict(x):

x :: dict

r0 :: native_int

r1 :: short_int

r2, r3 :: bit

L0:

r0 = PyDict_Size(x)

r1 = r0 << 1

r2 = int_ne r1, 0

r3 = r2 ^ 1

return r3

[case testUnaryNotWithNativeClass]

from __future__ import annotations

class C:

def __bool__(self) -> bool:

return True

def not_c(x: C) -> bool:

return not x

def not_c_opt(x: C | None) -> bool:

return not x

[out]

def C.__bool__(self):

self :: __main__.C

L0:

return 1

def not_c(x):

x :: __main__.C

r0, r1 :: bool

L0:

r0 = x.__bool__()

r1 = r0 ^ 1

return r1

def not_c_opt(x):

x :: union[__main__.C, None]

r0 :: object

r1, r2 :: bit

r3 :: __main__.C

r4, r5 :: bool

L0:

r0 = load_address _Py_NoneStruct

r1 = x == r0

if r1 goto L1 else goto L2 :: bool

L1:

r2 = 1

goto L3

L2:

r3 = unchecked borrow cast(__main__.C, x)

r4 = r3.__bool__()

r5 = r4 ^ 1

r2 = r5

L3:

keep_alive x

return r2

[case testUnaryNotWithOptionalPrimitiveTypes]

from __future__ import annotations

def not_str(x: str | None) -> bool:

return not x

def not_list(x: list[int] | None) -> bool:

return not x

[out]

def not_str(x):

x :: union[str, None]

r0 :: object

r1, r2 :: bit

r3 :: str

r4, r5 :: bit

L0:

r0 = load_address _Py_NoneStruct

r1 = x == r0

if r1 goto L1 else goto L2 :: bool

L1:

r2 = 1

goto L3

L2:

r3 = unchecked borrow cast(str, x)

r4 = CPyStr_IsTrue(r3)

r5 = r4 ^ 1

r2 = r5

L3:

keep_alive x

return r2

def not_list(x):

x :: union[list, None]

r0 :: object

r1, r2 :: bit

r3 :: list

r4 :: native_int

r5 :: short_int

r6, r7 :: bit

L0:

r0 = load_address _Py_NoneStruct

r1 = x == r0

if r1 goto L1 else goto L2 :: bool

L1:

r2 = 1

goto L3

L2:

r3 = unchecked borrow cast(list, x)

r4 = var_object_size r3

r5 = r4 << 1

r6 = int_ne r5, 0

r7 = r6 ^ 1

r2 = r7

L3:

keep_alive x

return r2