Jan 10, 2023 · Aug 12, 2021 · Aug 24, 2022 · Jan 6, 2023 · Jan 6, 2023 · Jan 6, 2023
diff --git a/mypyc/analysis/ircheck.py b/mypyc/analysis/ircheck.py
            if isinstance(x, tuple):
                self.check_tuple_items_valid_literals(op, x)

    def check_frozenset_items_valid_literals(
        self, op: LoadLiteral, s: frozenset[object, ...]
    ) -> None:
    def check_frozenset_items_valid_literals(self, op: LoadLiteral, s: frozenset[object]) -> None:
        for x in s:
            if x isnotNoneand notisinstance(x, (str, bytes, bool, int, float, complex, tuple)):
 self.fail(op, f"Invalid type for item of frozenset literal: {type(x)})")
 if isinstance(x, tuple):
            if x is Noneorisinstance(x, (str, bytes, bool, int, float, complex)):
 pass
 elif isinstance(x, tuple):
                self.check_tuple_items_valid_literals(op, x)
            else:
                self.fail(op, f"Invalid type for item of frozenset literal: {type(x)})")

    def visit_load_literal(self, op: LoadLiteral) -> None:
        expected_type = None
diff --git a/mypyc/ir/ops.py b/mypyc/ir/ops.py
 )

 if TYPE_CHECKING:
    from mypyc.codegen.literals import LiteralValue
    from mypyc.ir.class_ir import ClassIR
    from mypyc.ir.func_ir import FuncDecl, FuncIR

    error_kind = ERR_NEVER
    is_borrowed = True

    def __init__(
        self,
        value: None
        | str
        | bytes
        | bool
        | int
        | float
        | complex
        | tuple[object, ...]
        | frozenset[object],
        rtype: RType,
    ) -> None:
    def __init__(self, value: LiteralValue, rtype: RType) -> None:
        self.value = value
        self.type = rtype

diff --git a/mypyc/ir/pprint.py b/mypyc/ir/pprint.py

        rvalue = repr(op.value)
        if isinstance(op.value, frozenset):
            # Pretty print frozensets in a hacky but stable way.
            sorted_items = sorted(op.value, key=str)
            rvalue = "frozenset({" + repr(sorted_items)[1:-1] + "})"
            # We need to generate a string representation that won't vary
            # run-to-run because sets are unordered, otherwise we may get
            # spurious irbuild test failures.
            #
            # Sorting by the item's string representation is a bit of a
            # hack, but it's stable and won't cause TypeErrors.
            formatted_items = [repr(i) for i in sorted(op.value, key=str)]
            rvalue = "frozenset({" + ", ".join(formatted_items) + "})"
        return self.format("%r = %s%s", op, prefix, rvalue)

    def visit_get_attr(self, op: GetAttr) -> str:
diff --git a/mypyc/irbuild/expression.py b/mypyc/irbuild/expression.py
        and len(e.operators) == 1
        and isinstance(e.operands[1], SetExpr)
    ):
 literal = precompute_set_literal(builder, e.operands[1])
        ifliteral is not None:
 set_literal = precompute_set_literal(builder, e.operands[1])
        ifset_literal is not None:
            lhs = e.operands[0]
 v = builder.builder.call_c(
                set_in_op, [builder.accept(lhs),literal], e.line, bool_rprimitive
 result = builder.builder.call_c(
                set_in_op, [builder.accept(lhs),set_literal], e.line, bool_rprimitive
            )
            if first_op == "not in":
                return builder.unary_op(v, "not", e.line)
            returnv
                return builder.unary_op(result, "not", e.line)
            returnresult

    if len(e.operators) == 1:
        # Special some common simple cases
diff --git a/mypyc/test-data/irbuild-set.test b/mypyc/test-data/irbuild-set.test
 non_const = 10

 def precomputed(i: object) -> bool:
    return i in {1, 2.7, 1j, "foo", b"bar", CONST, (None, (27,))}
    return i in {1, 2.7, 1j, "foo", b"bar", CONST, (None, (27,)), (), False}
 def not_precomputed_non_final_name(i: int) -> bool:
    return i in {non_const}
 def not_precomputed_nested_set(i: int) -> bool:
    return i in {{1}, 2}
    return i in {frozenset({1}), 2}
 def not_precomputed_add_operation(i: int) -> bool:
    # TODO: support this?
    return i in {1 + 2}
    r2 :: bit
    r3 :: bool
 L0:
    r0 = frozenset({(None, (27,)), 1, 1j, 2.7, b'bar', 'daylily', 'foo'})
    r0 = frozenset({(), (None, (27,)), 1, 1j, 2.7, False, b'bar', 'daylily', 'foo'})
    r1 = PySet_Contains(r0, i)
    r2 = r1 >= 0 :: signed
    r3 = truncate r1: int32 to builtins.bool
    r1 :: object
    r2 :: int32
    r3 :: bit
    r4 :: set
    r5 :: int32
    r6 :: bit
    r7 :: object
    r8 :: int32
    r9 :: bit
    r10 :: object
    r11 :: int32
    r12 :: bit
    r13 :: bool
    r4 :: object
    r5 :: set
    r6 :: int32
    r7 :: bit
    r8 :: object
    r9 :: int32
    r10 :: bit
    r11 :: object
    r12 :: int32
    r13 :: bit
    r14 :: bool
 L0:
    r0 = PySet_New(0)
    r1 = object 1
    r2 = PySet_Add(r0, r1)
    r3 = r2 >= 0 :: signed
    r4 = PySet_New(0)
    r5 = PySet_Add(r4, r0)
    r6 = r5 >= 0 :: signed
    r7 = object 2
    r8 = PySet_Add(r4, r7)
    r9 = r8 >= 0 :: signed
    r10 = box(int, i)
    r11 = PySet_Contains(r4, r10)
    r12 = r11 >= 0 :: signed
    r13 = truncate r11: int32 to builtins.bool
    return r13
    r4 = PyFrozenSet_New(r0)
    r5 = PySet_New(0)
    r6 = PySet_Add(r5, r4)
    r7 = r6 >= 0 :: signed
    r8 = object 2
    r9 = PySet_Add(r5, r8)
    r10 = r9 >= 0 :: signed
    r11 = box(int, i)
    r12 = PySet_Contains(r5, r11)
    r13 = r12 >= 0 :: signed
    r14 = truncate r12: int32 to builtins.bool
    return r14
 def not_precomputed_add_operation(i):
    i :: int
    r0 :: set
diff --git a/mypyc/test-data/run-sets.test b/mypyc/test-data/run-sets.test
 non_const = "non_const"

 def main_set(item: Any) -> bool:
    return item in {None, 1, 2.0, "3", b"4", 5j, (6,), ((7,),), (), CONST}
    return item in {None,False,1, 2.0, "3", b"4", 5j, (6,), ((7,),), (), CONST}

 def main_negated_set(item: Any) -> bool:
    return item not in {None, 1, 2.0, "3", b"4", 5j, (6,), ((7,),), (), CONST}
    return item not in {None,False,1, 2.0, "3", b"4", 5j, (6,), ((7,),), (), CONST}

 def non_final_name_set(item: Any) -> bool:
    return item in {non_const}
 import native
 from native import CONST, main_set, main_negated_set, non_final_name_set

 for item in (None, 1, 2.0, "3", b"4", 5j, (6,), ((7,),), (), CONST):
 for item in (None,False,1, 2.0, "3", b"4", 5j, (6,), ((7,),), (), CONST):
    assert main_set(item), f"{item!r} should be in set_main"
    assert not main_negated_set(item), item
Original file line number	Diff line number	Diff line change
Expand Up		@@ -252,14 +252,14 @@ def check_tuple_items_valid_literals(self, op: LoadLiteral, t: tuple[object, ...
		if isinstance(x, tuple):
		self.check_tuple_items_valid_literals(op, x)

		def check_frozenset_items_valid_literals(
		self, op: LoadLiteral, s: frozenset[object, ...]
		) -> None:
		def check_frozenset_items_valid_literals(self, op: LoadLiteral, s: frozenset[object]) -> None:
		for x in s:
		if x isnotNoneand notisinstance(x, (str, bytes, bool, int, float, complex, tuple)):
		self.fail(op, f"Invalid type for item of frozenset literal: {type(x)})")
		if isinstance(x, tuple):
		if x is Noneorisinstance(x, (str, bytes, bool, int, float, complex)):
		pass
		elif isinstance(x, tuple):
		self.check_tuple_items_valid_literals(op, x)
		else:
		self.fail(op, f"Invalid type for item of frozenset literal: {type(x)})")

		def visit_load_literal(self, op: LoadLiteral) -> None:
		expected_type = None
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -39,6 +39,7 @@
		)

		if TYPE_CHECKING:
		from mypyc.codegen.literals import LiteralValue
		from mypyc.ir.class_ir import ClassIR
		from mypyc.ir.func_ir import FuncDecl, FuncIR

Expand DownExpand Up		@@ -603,19 +604,7 @@ class LoadLiteral(RegisterOp):
		error_kind = ERR_NEVER
		is_borrowed = True

		def __init__(
		self,
		value: None
		\| str
		\| bytes
		\| bool
		\| int
		\| float
		\| complex
		\| tuple[object, ...]
		\| frozenset[object],
		rtype: RType,
		) -> None:
		def __init__(self, value: LiteralValue, rtype: RType) -> None:
		self.value = value
		self.type = rtype

Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -109,9 +109,14 @@ def visit_load_literal(self, op: LoadLiteral) -> str:

		rvalue = repr(op.value)
		if isinstance(op.value, frozenset):
		# Pretty print frozensets in a hacky but stable way.
		sorted_items = sorted(op.value, key=str)
		rvalue = "frozenset({" + repr(sorted_items)[1:-1] + "})"
		# We need to generate a string representation that won't vary
		# run-to-run because sets are unordered, otherwise we may get
		# spurious irbuild test failures.
		#
		# Sorting by the item's string representation is a bit of a
		# hack, but it's stable and won't cause TypeErrors.
		formatted_items = [repr(i) for i in sorted(op.value, key=str)]
		rvalue = "frozenset({" + ", ".join(formatted_items) + "})"
		return self.format("%r = %s%s", op, prefix, rvalue)

		def visit_get_attr(self, op: GetAttr) -> str:
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -718,15 +718,15 @@ def transform_comparison_expr(builder: IRBuilder, e: ComparisonExpr) -> Value:
		and len(e.operators) == 1
		and isinstance(e.operands[1], SetExpr)
		):
		literal = precompute_set_literal(builder, e.operands[1])
		ifliteral is not None:
		set_literal = precompute_set_literal(builder, e.operands[1])
		ifset_literal is not None:
		lhs = e.operands[0]
		v = builder.builder.call_c(
		set_in_op, [builder.accept(lhs),literal], e.line, bool_rprimitive
		result = builder.builder.call_c(
		set_in_op, [builder.accept(lhs),set_literal], e.line, bool_rprimitive
		)
		if first_op == "not in":
		return builder.unary_op(v, "not", e.line)
		returnv
		return builder.unary_op(result, "not", e.line)
		returnresult

		if len(e.operators) == 1:
		# Special some common simple cases
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -663,11 +663,11 @@ CONST: Final = "daylily"
		non_const = 10

		def precomputed(i: object) -> bool:
		return i in {1, 2.7, 1j, "foo", b"bar", CONST, (None, (27,))}
		return i in {1, 2.7, 1j, "foo", b"bar", CONST, (None, (27,)), (), False}
		def not_precomputed_non_final_name(i: int) -> bool:
		return i in {non_const}
		def not_precomputed_nested_set(i: int) -> bool:
		return i in {{1}, 2}
		return i in {frozenset({1}), 2}
		def not_precomputed_add_operation(i: int) -> bool:
		# TODO: support this?
		return i in {1 + 2}
Expand All		@@ -679,7 +679,7 @@ def precomputed(i):
		r2 :: bit
		r3 :: bool
		L0:
		r0 = frozenset({(None, (27,)), 1, 1j, 2.7, b'bar', 'daylily', 'foo'})
		r0 = frozenset({(), (None, (27,)), 1, 1j, 2.7, False, b'bar', 'daylily', 'foo'})
		r1 = PySet_Contains(r0, i)
		r2 = r1 >= 0 :: signed
		r3 = truncate r1: int32 to builtins.bool
Expand DownExpand Up		@@ -718,32 +718,34 @@ def not_precomputed_nested_set(i):
		r1 :: object
		r2 :: int32
		r3 :: bit
		r4 :: set
		r5 :: int32
		r6 :: bit
		r7 :: object
		r8 :: int32
		r9 :: bit
		r10 :: object
		r11 :: int32
		r12 :: bit
		r13 :: bool
		r4 :: object
		r5 :: set
		r6 :: int32
		r7 :: bit
		r8 :: object
		r9 :: int32
		r10 :: bit
		r11 :: object
		r12 :: int32
		r13 :: bit
		r14 :: bool
		L0:
		r0 = PySet_New(0)
		r1 = object 1
		r2 = PySet_Add(r0, r1)
		r3 = r2 >= 0 :: signed
		r4 = PySet_New(0)
		r5 = PySet_Add(r4, r0)
		r6 = r5 >= 0 :: signed
		r7 = object 2
		r8 = PySet_Add(r4, r7)
		r9 = r8 >= 0 :: signed
		r10 = box(int, i)
		r11 = PySet_Contains(r4, r10)
		r12 = r11 >= 0 :: signed
		r13 = truncate r11: int32 to builtins.bool
		return r13
		r4 = PyFrozenSet_New(r0)
		r5 = PySet_New(0)
		r6 = PySet_Add(r5, r4)
		r7 = r6 >= 0 :: signed
		r8 = object 2
		r9 = PySet_Add(r5, r8)
		r10 = r9 >= 0 :: signed
		r11 = box(int, i)
		r12 = PySet_Contains(r5, r11)
		r13 = r12 >= 0 :: signed
		r14 = truncate r12: int32 to builtins.bool
		return r14
		def not_precomputed_add_operation(i):
		i :: int
		r0 :: set
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -123,10 +123,10 @@ CONST: Final = "CONST"
		non_const = "non_const"

		def main_set(item: Any) -> bool:
		return item in {None, 1, 2.0, "3", b"4", 5j, (6,), ((7,),), (), CONST}
		return item in {None,False,1, 2.0, "3", b"4", 5j, (6,), ((7,),), (), CONST}

		def main_negated_set(item: Any) -> bool:
		return item not in {None, 1, 2.0, "3", b"4", 5j, (6,), ((7,),), (), CONST}
		return item not in {None,False,1, 2.0, "3", b"4", 5j, (6,), ((7,),), (), CONST}

		def non_final_name_set(item: Any) -> bool:
		return item in {non_const}
Expand All		@@ -135,7 +135,7 @@ def non_final_name_set(item: Any) -> bool:
		import native
		from native import CONST, main_set, main_negated_set, non_final_name_set

		for item in (None, 1, 2.0, "3", b"4", 5j, (6,), ((7,),), (), CONST):
		for item in (None,False,1, 2.0, "3", b"4", 5j, (6,), ((7,),), (), CONST):
		assert main_set(item), f"{item!r} should be in set_main"
		assert not main_negated_set(item), item

Expand Down