diff --git a/mypyc/irbuild/ll_builder.py b/mypyc/irbuild/ll_builder.py index cb1bfa0203eb7..7f6024683ca91 100644 --- a/mypyc/irbuild/ll_builder.py +++ b/mypyc/irbuild/ll_builder.py @@ -558,33 +558,35 @@ def matching_primitive_op(self, def binary_op(self, lreg: Value, rreg: Value, - expr_op: str, + op: str, line: int) -> Value: - # special case tuple comparison here so that nested tuples can be supported - if (isinstance(lreg.type, RTuple) and isinstance(rreg.type, RTuple) - and expr_op in ('==', '!=')): - return self.compare_tuples(lreg, rreg, expr_op, line) - # Special case == and != when we can resolve the method call statically. - value = None - if expr_op in ('==', '!='): - value = self.translate_eq_cmp(lreg, rreg, expr_op, line) - if value is not None: - return value - - # Special case 'is' and 'is not' - if expr_op in ('is', 'is not'): - return self.translate_is_op(lreg, rreg, expr_op, line) - - if (is_str_rprimitive(lreg.type) and is_str_rprimitive(rreg.type) - and expr_op in ('==', '!=')): - return self.compare_strings(lreg, rreg, expr_op, line) - - if is_tagged(lreg.type) and is_tagged(rreg.type) and expr_op in int_comparison_op_mapping: - return self.compare_tagged(lreg, rreg, expr_op, line) - - call_c_ops_candidates = c_binary_ops.get(expr_op, []) + ltype = lreg.type + rtype = rreg.type + + # Special case tuple comparison here so that nested tuples can be supported + if isinstance(ltype, RTuple) and isinstance(rtype, RTuple) and op in ('==', '!='): + return self.compare_tuples(lreg, rreg, op, line) + + # Special case == and != when we can resolve the method call statically + if op in ('==', '!='): + value = self.translate_eq_cmp(lreg, rreg, op, line) + if value is not None: + return value + + # Special case various ops + if op in ('is', 'is not'): + return self.translate_is_op(lreg, rreg, op, line) + if is_str_rprimitive(ltype) and is_str_rprimitive(rtype) and op in ('==', '!='): + return self.compare_strings(lreg, rreg, op, line) + if is_tagged(ltype) and is_tagged(rtype) and op in int_comparison_op_mapping: + return self.compare_tagged(lreg, rreg, op, line) + if is_bool_rprimitive(ltype) and is_bool_rprimitive(rtype) and op in ( + '&', '&=', '|', '|=', '^', '^='): + return self.bool_bitwise_op(lreg, rreg, op[0], line) + + call_c_ops_candidates = c_binary_ops.get(op, []) target = self.matching_call_c(call_c_ops_candidates, [lreg, rreg], line) - assert target, 'Unsupported binary operation: %s' % expr_op + assert target, 'Unsupported binary operation: %s' % op return target def check_tagged_short_int(self, val: Value, line: int) -> Value: @@ -710,6 +712,17 @@ def compare_tuples(self, self.goto_and_activate(out) return result + def bool_bitwise_op(self, lreg: Value, rreg: Value, op: str, line: int) -> Value: + if op == '&': + code = BinaryIntOp.AND + elif op == '|': + code = BinaryIntOp.OR + elif op == '^': + code = BinaryIntOp.XOR + else: + assert False, op + return self.add(BinaryIntOp(bool_rprimitive, lreg, rreg, code, line)) + def unary_not(self, value: Value, line: int) -> Value: diff --git a/mypyc/lib-rt/CPy.h b/mypyc/lib-rt/CPy.h index c367efdae032e..c4f84e29077b7 100644 --- a/mypyc/lib-rt/CPy.h +++ b/mypyc/lib-rt/CPy.h @@ -129,11 +129,17 @@ void CPyTagged_IncRef(CPyTagged x); void CPyTagged_DecRef(CPyTagged x); void CPyTagged_XDecRef(CPyTagged x); CPyTagged CPyTagged_Negate(CPyTagged num); +CPyTagged CPyTagged_Invert(CPyTagged num); CPyTagged CPyTagged_Add(CPyTagged left, CPyTagged right); CPyTagged CPyTagged_Subtract(CPyTagged left, CPyTagged right); CPyTagged CPyTagged_Multiply(CPyTagged left, CPyTagged right); CPyTagged CPyTagged_FloorDivide(CPyTagged left, CPyTagged right); CPyTagged CPyTagged_Remainder(CPyTagged left, CPyTagged right); +CPyTagged CPyTagged_And(CPyTagged left, CPyTagged right); +CPyTagged CPyTagged_Or(CPyTagged left, CPyTagged right); +CPyTagged CPyTagged_Xor(CPyTagged left, CPyTagged right); +CPyTagged CPyTagged_Rshift(CPyTagged left, CPyTagged right); +CPyTagged CPyTagged_Lshift(CPyTagged left, CPyTagged right); bool CPyTagged_IsEq_(CPyTagged left, CPyTagged right); bool CPyTagged_IsLt_(CPyTagged left, CPyTagged right); PyObject *CPyTagged_Str(CPyTagged n); diff --git a/mypyc/lib-rt/int_ops.c b/mypyc/lib-rt/int_ops.c index 371e5de065b34..a43eddfaccc7b 100644 --- a/mypyc/lib-rt/int_ops.c +++ b/mypyc/lib-rt/int_ops.c @@ -273,3 +273,211 @@ PyObject *CPyLong_FromFloat(PyObject *o) { PyObject *CPyBool_Str(bool b) { return PyObject_Str(b ? Py_True : Py_False); } + +static void CPyLong_NormalizeUnsigned(PyLongObject *v) { + Py_ssize_t i = v->ob_base.ob_size; + while (i > 0 && v->ob_digit[i - 1] == 0) + i--; + v->ob_base.ob_size = i; +} + +// Bitwise op '&', '|' or '^' using the generic (slow) API +static CPyTagged GenericBitwiseOp(CPyTagged a, CPyTagged b, char op) { + PyObject *aobj = CPyTagged_AsObject(a); + PyObject *bobj = CPyTagged_AsObject(b); + PyObject *r; + if (op == '&') { + r = PyNumber_And(aobj, bobj); + } else if (op == '|') { + r = PyNumber_Or(aobj, bobj); + } else { + r = PyNumber_Xor(aobj, bobj); + } + if (unlikely(r == NULL)) { + CPyError_OutOfMemory(); + } + Py_DECREF(aobj); + Py_DECREF(bobj); + return CPyTagged_StealFromObject(r); +} + +// Return pointer to digits of a PyLong object. If it's a short +// integer, place digits in the buffer buf instead to avoid memory +// allocation (it's assumed to be big enough). Return the number of +// digits in *size. *size is negative if the integer is negative. +static digit *GetIntDigits(CPyTagged n, Py_ssize_t *size, digit *buf) { + if (CPyTagged_CheckShort(n)) { + Py_ssize_t val = CPyTagged_ShortAsSsize_t(n); + bool neg = val < 0; + int len = 1; + if (neg) { + val = -val; + } + buf[0] = val & PyLong_MASK; + if (val > PyLong_MASK) { + val >>= PyLong_SHIFT; + buf[1] = val & PyLong_MASK; + if (val > PyLong_MASK) { + buf[2] = val >> PyLong_SHIFT; + len = 3; + } else { + len = 2; + } + } + *size = neg ? -len : len; + return buf; + } else { + PyLongObject *obj = (PyLongObject *)CPyTagged_LongAsObject(n); + *size = obj->ob_base.ob_size; + return obj->ob_digit; + } +} + +// Shared implementation of bitwise '&', '|' and '^' (specified by op) for at least +// one long operand. This is somewhat optimized for performance. +static CPyTagged BitwiseLongOp(CPyTagged a, CPyTagged b, char op) { + // Directly access the digits, as there is no fast C API function for this. + digit abuf[3]; + digit bbuf[3]; + Py_ssize_t asize; + Py_ssize_t bsize; + digit *adigits = GetIntDigits(a, &asize, abuf); + digit *bdigits = GetIntDigits(b, &bsize, bbuf); + + PyLongObject *r; + if (unlikely(asize < 0 || bsize < 0)) { + // Negative operand. This is slower, but bitwise ops on them are pretty rare. + return GenericBitwiseOp(a, b, op); + } + // Optimized implementation for two non-negative integers. + // Swap a and b as needed to ensure a is no longer than b. + if (asize > bsize) { + digit *tmp = adigits; + adigits = bdigits; + bdigits = tmp; + Py_ssize_t tmp_size = asize; + asize = bsize; + bsize = tmp_size; + } + r = _PyLong_New(op == '&' ? asize : bsize); + if (unlikely(r == NULL)) { + CPyError_OutOfMemory(); + } + Py_ssize_t i; + if (op == '&') { + for (i = 0; i < asize; i++) { + r->ob_digit[i] = adigits[i] & bdigits[i]; + } + } else { + if (op == '|') { + for (i = 0; i < asize; i++) { + r->ob_digit[i] = adigits[i] | bdigits[i]; + } + } else { + for (i = 0; i < asize; i++) { + r->ob_digit[i] = adigits[i] ^ bdigits[i]; + } + } + for (; i < bsize; i++) { + r->ob_digit[i] = bdigits[i]; + } + } + CPyLong_NormalizeUnsigned(r); + return CPyTagged_StealFromObject((PyObject *)r); +} + +// Bitwise '&' +CPyTagged CPyTagged_And(CPyTagged left, CPyTagged right) { + if (likely(CPyTagged_CheckShort(left) && CPyTagged_CheckShort(right))) { + return left & right; + } + return BitwiseLongOp(left, right, '&'); +} + +// Bitwise '|' +CPyTagged CPyTagged_Or(CPyTagged left, CPyTagged right) { + if (likely(CPyTagged_CheckShort(left) && CPyTagged_CheckShort(right))) { + return left | right; + } + return BitwiseLongOp(left, right, '|'); +} + +// Bitwise '^' +CPyTagged CPyTagged_Xor(CPyTagged left, CPyTagged right) { + if (likely(CPyTagged_CheckShort(left) && CPyTagged_CheckShort(right))) { + return left ^ right; + } + return BitwiseLongOp(left, right, '^'); +} + +// Bitwise '~' +CPyTagged CPyTagged_Invert(CPyTagged num) { + if (likely(CPyTagged_CheckShort(num) && num != CPY_TAGGED_ABS_MIN)) { + return ~num & ~CPY_INT_TAG; + } else { + PyObject *obj = CPyTagged_AsObject(num); + PyObject *result = PyNumber_Invert(obj); + if (unlikely(result == NULL)) { + CPyError_OutOfMemory(); + } + Py_DECREF(obj); + return CPyTagged_StealFromObject(result); + } +} + +// Bitwise '>>' +CPyTagged CPyTagged_Rshift(CPyTagged left, CPyTagged right) { + if (likely(CPyTagged_CheckShort(left) + && CPyTagged_CheckShort(right) + && (Py_ssize_t)right >= 0)) { + CPyTagged count = CPyTagged_ShortAsSsize_t(right); + if (unlikely(count >= CPY_INT_BITS)) { + if ((Py_ssize_t)left >= 0) { + return 0; + } else { + return CPyTagged_ShortFromInt(-1); + } + } + return ((Py_ssize_t)left >> count) & ~CPY_INT_TAG; + } else { + // Long integer or negative shift -- use generic op + PyObject *lobj = CPyTagged_AsObject(left); + PyObject *robj = CPyTagged_AsObject(right); + PyObject *result = PyNumber_Rshift(lobj, robj); + Py_DECREF(lobj); + Py_DECREF(robj); + if (result == NULL) { + // Propagate error (could be negative shift count) + return CPY_INT_TAG; + } + return CPyTagged_StealFromObject(result); + } +} + +static inline bool IsShortLshiftOverflow(Py_ssize_t short_int, Py_ssize_t shift) { + return ((Py_ssize_t)(short_int << shift) >> shift) != short_int; +} + +// Bitwise '<<' +CPyTagged CPyTagged_Lshift(CPyTagged left, CPyTagged right) { + if (likely(CPyTagged_CheckShort(left) + && CPyTagged_CheckShort(right) + && (Py_ssize_t)right >= 0 + && right < CPY_INT_BITS * 2)) { + CPyTagged shift = CPyTagged_ShortAsSsize_t(right); + if (!IsShortLshiftOverflow(left, shift)) + // Short integers, no overflow + return left << shift; + } + // Long integer or out of range shift -- use generic op + PyObject *lobj = CPyTagged_AsObject(left); + PyObject *robj = CPyTagged_AsObject(right); + PyObject *result = PyNumber_Lshift(lobj, robj); + Py_DECREF(lobj); + Py_DECREF(robj); + if (result == NULL) { + // Propagate error (could be negative shift count) + return CPY_INT_TAG; + } + return CPyTagged_StealFromObject(result); +} diff --git a/mypyc/primitives/int_ops.py b/mypyc/primitives/int_ops.py index 18fe891c31eaa..88fca784e507f 100644 --- a/mypyc/primitives/int_ops.py +++ b/mypyc/primitives/int_ops.py @@ -84,10 +84,16 @@ def int_binary_op(name: str, c_function_name: str, int_binary_op('+', 'CPyTagged_Add') int_binary_op('-', 'CPyTagged_Subtract') int_binary_op('*', 'CPyTagged_Multiply') +int_binary_op('&', 'CPyTagged_And') +int_binary_op('|', 'CPyTagged_Or') +int_binary_op('^', 'CPyTagged_Xor') # Divide and remainder we honestly propagate errors from because they # can raise ZeroDivisionError int_binary_op('//', 'CPyTagged_FloorDivide', error_kind=ERR_MAGIC) int_binary_op('%', 'CPyTagged_Remainder', error_kind=ERR_MAGIC) +# Negative shift counts raise an exception +int_binary_op('>>', 'CPyTagged_Rshift', error_kind=ERR_MAGIC) +int_binary_op('<<', 'CPyTagged_Lshift', error_kind=ERR_MAGIC) # This should work because assignment operators are parsed differently # and the code in irbuild that handles it does the assignment @@ -95,8 +101,13 @@ def int_binary_op(name: str, c_function_name: str, int_binary_op('+=', 'CPyTagged_Add') int_binary_op('-=', 'CPyTagged_Subtract') int_binary_op('*=', 'CPyTagged_Multiply') +int_binary_op('&=', 'CPyTagged_And') +int_binary_op('|=', 'CPyTagged_Or') +int_binary_op('^=', 'CPyTagged_Xor') int_binary_op('//=', 'CPyTagged_FloorDivide', error_kind=ERR_MAGIC) int_binary_op('%=', 'CPyTagged_Remainder', error_kind=ERR_MAGIC) +int_binary_op('>>=', 'CPyTagged_Rshift', error_kind=ERR_MAGIC) +int_binary_op('<<=', 'CPyTagged_Lshift', error_kind=ERR_MAGIC) def int_unary_op(name: str, c_function_name: str) -> CFunctionDescription: @@ -108,6 +119,7 @@ def int_unary_op(name: str, c_function_name: str) -> CFunctionDescription: int_neg_op = int_unary_op('-', 'CPyTagged_Negate') +int_invert_op = int_unary_op('~', 'CPyTagged_Invert') # integer comparsion operation implementation related: diff --git a/mypyc/test-data/fixtures/ir.py b/mypyc/test-data/fixtures/ir.py index 2050427a51d2c..66d1c58137437 100644 --- a/mypyc/test-data/fixtures/ir.py +++ b/mypyc/test-data/fixtures/ir.py @@ -37,6 +37,12 @@ def __floordiv__(self, x: int) -> int: pass def __mod__(self, x: int) -> int: pass def __neg__(self) -> int: pass def __pos__(self) -> int: pass + def __invert__(self) -> int: pass + def __and__(self, n: int) -> int: pass + def __or__(self, n: int) -> int: pass + def __xor__(self, n: int) -> int: pass + def __lshift__(self, x: int) -> int: pass + def __rshift__(self, x: int) -> int: pass def __eq__(self, n: object) -> bool: pass def __ne__(self, n: object) -> bool: pass def __lt__(self, n: int) -> bool: pass @@ -89,9 +95,20 @@ def __eq__(self, x:object) -> bool:pass def __ne__(self, x: object) -> bool: pass def join(self, x: Iterable[object]) -> bytes: pass -class bool: +class bool(int): def __init__(self, o: object = ...) -> None: ... - + @overload + def __and__(self, n: bool) -> bool: ... + @overload + def __and__(self, n: int) -> int: ... + @overload + def __or__(self, n: bool) -> bool: ... + @overload + def __or__(self, n: int) -> int: ... + @overload + def __xor__(self, n: bool) -> bool: ... + @overload + def __xor__(self, n: int) -> int: ... class tuple(Generic[T_co], Sequence[T_co], Iterable[T_co]): def __init__(self, i: Iterable[T_co]) -> None: pass @@ -231,6 +248,7 @@ def enumerate(x: Iterable[T]) -> Iterator[Tuple[int, T]]: ... def zip(x: Iterable[T], y: Iterable[S]) -> Iterator[Tuple[T, S]]: ... @overload def zip(x: Iterable[T], y: Iterable[S], z: Iterable[V]) -> Iterator[Tuple[T, S, V]]: ... +def eval(e: str) -> Any: ... # Dummy definitions. class classmethod: pass diff --git a/mypyc/test-data/run-bools.test b/mypyc/test-data/run-bools.test new file mode 100644 index 0000000000000..95c63aacb7e37 --- /dev/null +++ b/mypyc/test-data/run-bools.test @@ -0,0 +1,67 @@ +# Test cases for booleans (compile and run) + +[case testTrueAndFalse] +def t() -> bool: + return True + +def f() -> bool: + return False +[file driver.py] +from native import t, f +print(t()) +print(f()) +[out] +True +False + +[case testBoolOps] +def f(x: bool) -> bool: + if x: + return False + else: + return True + +def test_if() -> None: + assert f(True) is False + assert f(False) is True + +def test_bitwise_and() -> None: + # Use eval() to avoid constand folding + t = eval('True') # type: bool + f = eval('False') # type: bool + assert t & t == True + assert t & f == False + assert f & t == False + assert f & f == False + t &= t + assert t == True + t &= f + assert t == False + +def test_bitwise_or() -> None: + # Use eval() to avoid constand folding + t = eval('True') # type: bool + f = eval('False') # type: bool + assert t | t == True + assert t | f == True + assert f | t == True + assert f | f == False + t |= f + assert t == True + f |= t + assert f == True + +def test_bitwise_xor() -> None: + # Use eval() to avoid constand folding + t = eval('True') # type: bool + f = eval('False') # type: bool + assert t ^ t == False + assert t ^ f == True + assert f ^ t == True + assert f ^ f == False + t ^= f + assert t == True + t ^= t + assert t == False + f ^= f + assert f == False diff --git a/mypyc/test-data/run-integers.test b/mypyc/test-data/run-integers.test index a24a36470207e..23eaf8818b22a 100644 --- a/mypyc/test-data/run-integers.test +++ b/mypyc/test-data/run-integers.test @@ -130,3 +130,173 @@ assert neg(9223372036854775807) == -9223372036854775807 assert neg(-9223372036854775807) == 9223372036854775807 assert neg(9223372036854775808) == -9223372036854775808 assert neg(-9223372036854775808) == 9223372036854775808 + +[case testIntOps] +def check_and(x: int, y: int) -> None: + # eval() can be trusted to calculate expected result + expected = eval('{} & {}'.format(x, y)) + actual = x & y + assert actual == expected, '{} & {}: got {}, expected {}'.format(x, y, actual, expected) + +def check_or(x: int, y: int) -> None: + # eval() can be trusted to calculate expected result + expected = eval('{} | {}'.format(x, y)) + actual = x | y + assert actual == expected, '{} | {}: got {}, expected {}'.format(x, y, actual, expected) + +def check_xor(x: int, y: int) -> None: + # eval() can be trusted to calculate expected result + expected = eval('{} ^ {}'.format(x, y)) + actual = x ^ y + assert actual == expected, '{} ^ {}: got {}, expected {}'.format(x, y, actual, expected) + +def check_bitwise(x: int, y: int) -> None: + for l, r in (x, y), (y, x): + for ll, rr in (l, r), (-l, r), (l, -r), (-l, -r): + check_and(ll, rr) + check_or(ll, rr) + check_xor(ll, rr) + +SHIFT = 30 +DIGIT0a = 615729753 +DIGIT0b = 832796681 +DIGIT1a = 744342356 << SHIFT +DIGIT1b = 321006080 << SHIFT +DIGIT2a = 643582106 << (SHIFT * 2) +DIGIT2b = 656420725 << (SHIFT * 2) +DIGIT50 = 315723472 << (SHIFT * 50) +DIGIT100a = 1020652627 << (SHIFT * 100) +DIGIT100b = 923752451 << (SHIFT * 100) +BIG_SHORT = 3491190729721336556 +MAX_SHORT = (1 << 62) - 1 +MIN_SHORT = -(1 << 62) +MAX_SHORT_32 = (1 << 30) - 1 +MIN_SHORT_32 = -(1 << 30) + +def test_and_or_xor() -> None: + check_bitwise(0, 0) + check_bitwise(0, 1) + check_bitwise(1, 1) + check_bitwise(DIGIT0a, DIGIT0b) + check_bitwise(DIGIT1a, DIGIT1b) + check_bitwise(DIGIT2a, DIGIT2b) + check_bitwise(DIGIT100a, DIGIT100b) + check_bitwise(DIGIT0a, DIGIT0b + DIGIT2a) + check_bitwise(DIGIT0a, DIGIT0b + DIGIT50) + check_bitwise(DIGIT50 + DIGIT1a, DIGIT100a + DIGIT2b) + check_bitwise(BIG_SHORT, DIGIT0a) + check_bitwise(BIG_SHORT, DIGIT0a + DIGIT1a) + check_bitwise(BIG_SHORT, DIGIT0a + DIGIT1a + DIGIT2a) + check_bitwise(BIG_SHORT, DIGIT0a + DIGIT1a + DIGIT2a + DIGIT50) + +def test_bitwise_inplace() -> None: + # Basic sanity checks; these should use the same code as the non-in-place variants + for x, y in (DIGIT0a, DIGIT1a), (DIGIT2a, DIGIT0a + DIGIT2b): + n = x + n &= y + assert n == x & y + n = x + n |= y + assert n == x | y + n = x + n ^= y + assert n == x ^ y + +def check_invert(x: int) -> None: + # Use eval() as the source of truth + assert ~x == eval('~{}'.format(x)) + assert ~(-x) == eval('~({})'.format(-x)) + +def test_invert() -> None: + check_invert(0) + check_invert(1) + check_invert(DIGIT0a) + check_invert(DIGIT0a + DIGIT1a) + check_invert(DIGIT0a + DIGIT1a + DIGIT2a) + check_invert(DIGIT0a + DIGIT1a + DIGIT2a + DIGIT50) + check_invert(BIG_SHORT) + for delta in -1, 0, 1: + check_invert(MAX_SHORT + delta) + check_invert(MIN_SHORT + delta) + check_invert(MAX_SHORT_32 + delta) + check_invert(MIN_SHORT_32 + delta) + +def check_right_shift(x: int, n: int) -> None: + if n < 0: + try: + x >> n + except ValueError: + return + assert False, "no exception raised" + # Use eval() as the source of truth + expected = eval('{} >> {}'.format(x, n)) + actual = x >> n + assert actual == expected, "{} >> {}: got {}, expected {}".format(x, n, actual, expected) + +def test_right_shift() -> None: + for x in 0, 1, 1235, DIGIT0a, DIGIT0a + DIGIT1a, DIGIT0a + DIGIT50: + for n in 0, 1, 2, 3, 4, 10, 40, 10000, DIGIT1a, -1, -1334444, -DIGIT1a: + check_right_shift(x, n) + check_right_shift(-x, n) + x = DIGIT0a + x >>= 1 + assert x == DIGIT0a >> 1 + x = DIGIT50 + x >>= 5 + assert x == DIGIT50 >> 5 + for i in range(256): + check_right_shift(1, i) + check_right_shift(137, i) + check_right_shift(MAX_SHORT, i) + check_right_shift(MAX_SHORT_32, i) + check_right_shift(MAX_SHORT + 1, i) + check_right_shift(MAX_SHORT_32 + 1, i) + for x in 1, DIGIT50: + try: + # It's okay if this raises an exception + assert x >> DIGIT2a == 0 + except Exception: + pass + try: + x >> -DIGIT2a + assert False + except Exception: + pass + +def check_left_shift(x: int, n: int) -> None: + if n < 0: + try: + x << n + except ValueError: + return + assert False, "no exception raised" + # Use eval() as the source of truth + expected = eval('{} << {}'.format(x, n)) + actual = x << n + assert actual == expected, "{} << {}: got {}, expected {}".format(x, n, actual, expected) + +def test_left_shift() -> None: + for x in 0, 1, 1235, DIGIT0a, DIGIT0a + DIGIT1a, DIGIT0a + DIGIT50: + for n in 0, 1, 2, 10, 40, 10000, -1, -1334444: + check_left_shift(x, n) + check_left_shift(-x, n) + x = DIGIT0a + x <<= 1 + assert x == DIGIT0a << 1 + x = DIGIT50 + x <<= 5 + assert x == DIGIT50 << 5 + for shift in range(256): + check_left_shift(1, shift) + check_left_shift(137, shift) + for x in 1, DIGIT50: + try: + x << DIGIT50 + assert False + except Exception: + pass + try: + x << -DIGIT50 + assert False + except Exception: + pass diff --git a/mypyc/test-data/run-misc.test b/mypyc/test-data/run-misc.test index d0b66920658da..4a567b0c5fd1b 100644 --- a/mypyc/test-data/run-misc.test +++ b/mypyc/test-data/run-misc.test @@ -26,29 +26,6 @@ loop = asyncio.get_event_loop() result = loop.run_until_complete(f()) assert result == 1 -[case testTrue] -def f() -> bool: - return True -[file driver.py] -from native import f -print(f()) -[out] -True - -[case testBoolIf] -def f(x: bool) -> bool: - if x: - return False - else: - return True -[file driver.py] -from native import f -print(f(True)) -print(f(False)) -[out] -False -True - [case testMaybeUninitVar] class C: def __init__(self, x: int) -> None: diff --git a/mypyc/test/test_run.py b/mypyc/test/test_run.py index 9c7c48aa69ef8..61d89caa08f7d 100644 --- a/mypyc/test/test_run.py +++ b/mypyc/test/test_run.py @@ -33,6 +33,7 @@ 'run-misc.test', 'run-functions.test', 'run-integers.test', + 'run-bools.test', 'run-strings.test', 'run-tuples.test', 'run-lists.test',