| from __future__ import annotations |
| |
| import unittest |
| |
| from mypyc.codegen.emit import Emitter, EmitterContext |
| from mypyc.common import HAVE_IMMORTAL |
| from mypyc.ir.class_ir import ClassIR |
| from mypyc.ir.ops import BasicBlock, Register, Value |
| from mypyc.ir.rtypes import ( |
| RInstance, |
| RTuple, |
| RUnion, |
| bool_rprimitive, |
| int_rprimitive, |
| list_rprimitive, |
| none_rprimitive, |
| object_rprimitive, |
| str_rprimitive, |
| ) |
| from mypyc.irbuild.vtable import compute_vtable |
| from mypyc.namegen import NameGenerator |
| |
| |
| class TestEmitter(unittest.TestCase): |
| def setUp(self) -> None: |
| self.n = Register(int_rprimitive, "n") |
| self.context = EmitterContext(NameGenerator([["mod"]]), True) |
| self.emitter = Emitter(self.context, {}) |
| |
| ir = ClassIR("A", "mod") |
| compute_vtable(ir) |
| ir.mro = [ir] |
| self.instance_a = RInstance(ir) |
| |
| def test_label(self) -> None: |
| assert self.emitter.label(BasicBlock(4)) == "CPyL4" |
| |
| def test_reg(self) -> None: |
| names: dict[Value, str] = {self.n: "n"} |
| emitter = Emitter(self.context, names) |
| assert emitter.reg(self.n) == "cpy_r_n" |
| |
| def test_object_annotation(self) -> None: |
| assert self.emitter.object_annotation("hello, world", "line;") == " /* 'hello, world' */" |
| assert self.emitter.object_annotation(42, "line;") == " /* 42 */" |
| assert self.emitter.object_annotation((1, "x", None), "line;") == " /* (1, 'x', None) */" |
| # Annotations containing illegal C comment characters are dropped. |
| assert self.emitter.object_annotation("a /* b */ c", "line;") == "" |
| |
| def test_object_annotation_frozenset_is_deterministic(self) -> None: |
| assert ( |
| self.emitter.object_annotation(frozenset({"self", "cls"}), "line;") |
| == self.emitter.object_annotation(frozenset({"cls", "self"}), "line;") |
| == " /* frozenset({'cls', 'self'}) */" |
| ) |
| assert ( |
| self.emitter.object_annotation((frozenset({"b", "a"}),), "line;") |
| == self.emitter.object_annotation((frozenset({"a", "b"}),), "line;") |
| == " /* (frozenset({'a', 'b'}),) */" |
| ) |
| assert self.emitter.object_annotation(frozenset(), "line;") == " /* frozenset() */" |
| |
| def test_emit_line(self) -> None: |
| emitter = self.emitter |
| emitter.emit_line("line;") |
| emitter.emit_line("a {") |
| emitter.emit_line("f();") |
| emitter.emit_line("}") |
| assert emitter.fragments == ["line;\n", "a {\n", " f();\n", "}\n"] |
| emitter = Emitter(self.context, {}) |
| emitter.emit_line("CPyStatics[0];", ann="hello, world") |
| emitter.emit_line("CPyStatics[1];", ann=42) |
| assert emitter.fragments[0] == "CPyStatics[0]; /* 'hello, world' */\n" |
| assert emitter.fragments[1] == "CPyStatics[1]; /* 42 */\n" |
| |
| def test_emit_undefined_value_for_simple_type(self) -> None: |
| emitter = self.emitter |
| assert emitter.c_undefined_value(int_rprimitive) == "CPY_INT_TAG" |
| assert emitter.c_undefined_value(str_rprimitive) == "NULL" |
| assert emitter.c_undefined_value(bool_rprimitive) == "2" |
| |
| def test_emit_undefined_value_for_tuple(self) -> None: |
| emitter = self.emitter |
| assert ( |
| emitter.c_undefined_value(RTuple([str_rprimitive, int_rprimitive, bool_rprimitive])) |
| == "(tuple_T3OIC) { NULL, CPY_INT_TAG, 2 }" |
| ) |
| assert emitter.c_undefined_value(RTuple([str_rprimitive])) == "(tuple_T1O) { NULL }" |
| assert ( |
| emitter.c_undefined_value(RTuple([RTuple([str_rprimitive]), bool_rprimitive])) |
| == "(tuple_T2T1OC) { { NULL }, 2 }" |
| ) |
| |
| def test_emit_inc_ref_object(self) -> None: |
| self.emitter.emit_inc_ref("x", object_rprimitive) |
| self.assert_output("CPy_INCREF(x);\n") |
| |
| def test_emit_inc_ref_int(self) -> None: |
| self.emitter.emit_inc_ref("x", int_rprimitive) |
| self.assert_output("CPyTagged_INCREF(x);\n") |
| |
| def test_emit_inc_ref_rare(self) -> None: |
| self.emitter.emit_inc_ref("x", object_rprimitive, rare=True) |
| self.assert_output("CPy_INCREF(x);\n") |
| self.emitter.emit_inc_ref("x", int_rprimitive, rare=True) |
| self.assert_output("CPyTagged_IncRef(x);\n") |
| |
| def test_emit_inc_ref_list(self) -> None: |
| self.emitter.emit_inc_ref("x", list_rprimitive) |
| if HAVE_IMMORTAL: |
| self.assert_output("CPy_INCREF_NO_IMM(x);\n") |
| else: |
| self.assert_output("CPy_INCREF(x);\n") |
| |
| def test_emit_inc_ref_instance(self) -> None: |
| self.emitter.emit_inc_ref("x", self.instance_a) |
| if HAVE_IMMORTAL: |
| self.assert_output("CPy_INCREF_NO_IMM(x);\n") |
| else: |
| self.assert_output("CPy_INCREF(x);\n") |
| |
| def test_emit_inc_ref_optional(self) -> None: |
| optional = RUnion([self.instance_a, none_rprimitive]) |
| self.emitter.emit_inc_ref("o", optional) |
| self.assert_output("CPy_INCREF(o);\n") |
| |
| def test_emit_dec_ref_object(self) -> None: |
| self.emitter.emit_dec_ref("x", object_rprimitive) |
| self.assert_output("CPy_DECREF(x);\n") |
| self.emitter.emit_dec_ref("x", object_rprimitive, is_xdec=True) |
| self.assert_output("CPy_XDECREF(x);\n") |
| |
| def test_emit_dec_ref_int(self) -> None: |
| self.emitter.emit_dec_ref("x", int_rprimitive) |
| self.assert_output("CPyTagged_DECREF(x);\n") |
| self.emitter.emit_dec_ref("x", int_rprimitive, is_xdec=True) |
| self.assert_output("CPyTagged_XDECREF(x);\n") |
| |
| def test_emit_dec_ref_rare(self) -> None: |
| self.emitter.emit_dec_ref("x", object_rprimitive, rare=True) |
| self.assert_output("CPy_DecRef(x);\n") |
| self.emitter.emit_dec_ref("x", int_rprimitive, rare=True) |
| self.assert_output("CPyTagged_DecRef(x);\n") |
| |
| def test_emit_dec_ref_list(self) -> None: |
| self.emitter.emit_dec_ref("x", list_rprimitive) |
| if HAVE_IMMORTAL: |
| self.assert_output("CPy_DECREF_NO_IMM(x);\n") |
| else: |
| self.assert_output("CPy_DECREF(x);\n") |
| self.emitter.emit_dec_ref("x", list_rprimitive, is_xdec=True) |
| if HAVE_IMMORTAL: |
| self.assert_output("CPy_XDECREF_NO_IMM(x);\n") |
| else: |
| self.assert_output("CPy_XDECREF(x);\n") |
| |
| def test_emit_dec_ref_instance(self) -> None: |
| self.emitter.emit_dec_ref("x", self.instance_a) |
| if HAVE_IMMORTAL: |
| self.assert_output("CPy_DECREF_NO_IMM(x);\n") |
| else: |
| self.assert_output("CPy_DECREF(x);\n") |
| self.emitter.emit_dec_ref("x", self.instance_a, is_xdec=True) |
| if HAVE_IMMORTAL: |
| self.assert_output("CPy_XDECREF_NO_IMM(x);\n") |
| else: |
| self.assert_output("CPy_XDECREF(x);\n") |
| |
| def test_emit_dec_ref_optional(self) -> None: |
| optional = RUnion([self.instance_a, none_rprimitive]) |
| self.emitter.emit_dec_ref("o", optional) |
| self.assert_output("CPy_DECREF(o);\n") |
| |
| def assert_output(self, expected: str) -> None: |
| assert "".join(self.emitter.fragments) == expected |
| self.emitter.fragments = [] |
