jaclang 0.6.0__py3-none-any.whl → 0.6.5__py3-none-any.whl

jaclang/vendor/mypyc/subtype.py

@@ -29,9 +29,7 @@ def is_subtype(left: RType, right: RType) -> bool:
     elif isinstance(right, RUnion):
         if isinstance(left, RUnion):
             for left_item in left.items:
-                if not any(
-                    is_subtype(left_item, right_item) for right_item in right.items
-                ):
+                if not any(is_subtype(left_item, right_item) for right_item in right.items):
                     return False
             return True
         else:
@@ -50,10 +48,7 @@ class SubtypeVisitor(RTypeVisitor[bool]):
         self.right = right
 
     def visit_rinstance(self, left: RInstance) -> bool:
-        return (
-            isinstance(self.right, RInstance)
-            and self.right.class_ir in left.class_ir.mro
-        )
+        return isinstance(self.right, RInstance) and self.right.class_ir in left.class_ir.mro
 
     def visit_runion(self, left: RUnion) -> bool:
         return all(is_subtype(item, self.right) for item in left.items)
@@ -64,11 +59,7 @@ class SubtypeVisitor(RTypeVisitor[bool]):
             if is_tagged(right) or is_fixed_width_rtype(right):
                 return True
         elif is_bit_rprimitive(left):
-            if (
-                is_bool_rprimitive(right)
-                or is_tagged(right)
-                or is_fixed_width_rtype(right)
-            ):
+            if is_bool_rprimitive(right) or is_tagged(right) or is_fixed_width_rtype(right):
                 return True
         elif is_short_int_rprimitive(left):
             if is_int_rprimitive(right):

jaclang/vendor/mypyc/test/test_alwaysdefined.py

@@ -29,9 +29,7 @@ class TestAlwaysDefined(MypycDataSuite):
         if options is None:
             # Skipped test case
             return
-        with use_custom_builtins(
-            os.path.join(self.data_prefix, ICODE_GEN_BUILTINS), testcase
-        ):
+        with use_custom_builtins(os.path.join(self.data_prefix, ICODE_GEN_BUILTINS), testcase):
             try:
                 ir = build_ir_for_single_file2(testcase.input, options)
             except CompileError as e:
@@ -42,9 +40,7 @@ class TestAlwaysDefined(MypycDataSuite):
                     if cl.name.startswith("_"):
                         continue
                     actual.append(
-                        "{}: [{}]".format(
-                            cl.name, ", ".join(sorted(cl._always_initialized_attrs))
-                        )
+                        "{}: [{}]".format(cl.name, ", ".join(sorted(cl._always_initialized_attrs)))
                     )
 
             assert_test_output(testcase, actual, "Invalid test output", testcase.output)

jaclang/vendor/mypyc/test/test_analysis.py

@@ -32,9 +32,7 @@ class TestAnalysis(MypycDataSuite):
     def run_case(self, testcase: DataDrivenTestCase) -> None:
         """Perform a data-flow analysis test case."""
 
-        with use_custom_builtins(
-            os.path.join(self.data_prefix, ICODE_GEN_BUILTINS), testcase
-        ):
+        with use_custom_builtins(os.path.join(self.data_prefix, ICODE_GEN_BUILTINS), testcase):
             try:
                 ir = build_ir_for_single_file(testcase.input)
             except CompileError as e:
@@ -42,9 +40,7 @@ class TestAnalysis(MypycDataSuite):
             else:
                 actual = []
                 for fn in ir:
-                    if fn.name == TOP_LEVEL_NAME and not testcase.name.endswith(
-                        "_toplevel"
-                    ):
+                    if fn.name == TOP_LEVEL_NAME and not testcase.name.endswith("_toplevel"):
                         continue
                     exceptions.insert_exception_handling(fn)
                     actual.extend(format_func(fn))
@@ -53,25 +49,18 @@ class TestAnalysis(MypycDataSuite):
                     name = testcase.name
                     if name.endswith("_MaybeDefined"):
                         # Forward, maybe
-                        analysis_result = dataflow.analyze_maybe_defined_regs(
-                            fn.blocks, cfg, args
-                        )
+                        analysis_result = dataflow.analyze_maybe_defined_regs(fn.blocks, cfg, args)
                     elif name.endswith("_Liveness"):
                         # Backward, maybe
                         analysis_result = dataflow.analyze_live_regs(fn.blocks, cfg)
                     elif name.endswith("_MustDefined"):
                         # Forward, must
                         analysis_result = dataflow.analyze_must_defined_regs(
-                            fn.blocks,
-                            cfg,
-                            args,
-                            regs=all_values(fn.arg_regs, fn.blocks),
+                            fn.blocks, cfg, args, regs=all_values(fn.arg_regs, fn.blocks)
                         )
                     elif name.endswith("_BorrowedArgument"):
                         # Forward, must
-                        analysis_result = dataflow.analyze_borrowed_arguments(
-                            fn.blocks, cfg, args
-                        )
+                        analysis_result = dataflow.analyze_borrowed_arguments(fn.blocks, cfg, args)
                     else:
                         assert False, "No recognized _AnalysisName suffix in test case"
 
@@ -80,14 +69,9 @@ class TestAnalysis(MypycDataSuite):
                     for key in sorted(
                         analysis_result.before.keys(), key=lambda x: (x[0].label, x[1])
                     ):
-                        pre = ", ".join(
-                            sorted(names[reg] for reg in analysis_result.before[key])
-                        )
-                        post = ", ".join(
-                            sorted(names[reg] for reg in analysis_result.after[key])
-                        )
+                        pre = ", ".join(sorted(names[reg] for reg in analysis_result.before[key]))
+                        post = ", ".join(sorted(names[reg] for reg in analysis_result.after[key]))
                         actual.append(
-                            "%-8s %-23s %s"
-                            % ((key[0].label, key[1]), "{%s}" % pre, "{%s}" % post)
+                            "%-8s %-23s %s" % ((key[0].label, key[1]), "{%s}" % pre, "{%s}" % post)
                         )
             assert_test_output(testcase, actual, "Invalid source code output")

jaclang/vendor/mypyc/test/test_cheader.py

@@ -7,6 +7,7 @@ import os
 import re
 import unittest
 
+from mypyc.ir.ops import PrimitiveDescription
 from mypyc.primitives import registry
 from mypyc.primitives.registry import CFunctionDescription
 
@@ -25,17 +26,24 @@ class TestHeaderInclusion(unittest.TestCase):
                     rf"\b{name}\b", header
                 ), f'"{name}" is used in mypyc.primitives but not declared in CPy.h'
 
-        for values in [
+        for old_values in [
             registry.method_call_ops.values(),
             registry.function_ops.values(),
-            registry.binary_ops.values(),
             registry.unary_ops.values(),
         ]:
+            for old_ops in old_values:
+                if isinstance(old_ops, CFunctionDescription):
+                    old_ops = [old_ops]
+                for old_op in old_ops:
+                    check_name(old_op.c_function_name)
+
+        for values in [registry.binary_ops.values()]:
             for ops in values:
-                if isinstance(ops, CFunctionDescription):
+                if isinstance(ops, PrimitiveDescription):
                     ops = [ops]
                 for op in ops:
-                    check_name(op.c_function_name)
+                    if op.c_function_name is not None:
+                        check_name(op.c_function_name)
 
         primitives_path = os.path.join(os.path.dirname(__file__), "..", "primitives")
         for fnam in glob.glob(f"{primitives_path}/*.py"):

jaclang/vendor/mypyc/test/test_emit.py

@@ -24,10 +24,7 @@ class TestEmitter(unittest.TestCase):
 
     def test_object_annotation(self) -> None:
         emitter = Emitter(self.context, {})
-        assert (
-            emitter.object_annotation("hello, world", "line;")
-            == " /* 'hello, world' */"
-        )
+        assert emitter.object_annotation("hello, world", "line;") == " /* 'hello, world' */"
         assert (
             emitter.object_annotation(list(range(30)), "line;")
             == """\
@@ -62,18 +59,11 @@ CPyStatics[1]; /* [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
     def test_emit_undefined_value_for_tuple(self) -> None:
         emitter = Emitter(self.context, {})
         assert (
-            emitter.c_undefined_value(
-                RTuple([str_rprimitive, int_rprimitive, bool_rprimitive])
-            )
+            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([str_rprimitive]))
-            == "(tuple_T1O) { NULL }"
-        )
-        assert (
-            emitter.c_undefined_value(
-                RTuple([RTuple([str_rprimitive]), bool_rprimitive])
-            )
+            emitter.c_undefined_value(RTuple([RTuple([str_rprimitive]), bool_rprimitive]))
             == "(tuple_T2T1OC) { { NULL }, 2 }"
         )

jaclang/vendor/mypyc/test/test_emitclass.py

@@ -9,14 +9,7 @@ from mypyc.namegen import NameGenerator
 
 class TestEmitClass(unittest.TestCase):
     def test_slot_key(self) -> None:
-        attrs = [
-            "__add__",
-            "__radd__",
-            "__rshift__",
-            "__rrshift__",
-            "__setitem__",
-            "__delitem__",
-        ]
+        attrs = ["__add__", "__radd__", "__rshift__", "__rrshift__", "__setitem__", "__delitem__"]
         s = sorted(attrs, key=lambda x: slot_key(x))
         # __delitem__ and reverse methods should come last.
         assert s == [

jaclang/vendor/mypyc/test/test_emitfunc.py

@@ -129,9 +129,7 @@ class TestFunctionEmitterVisitor(unittest.TestCase):
 
     def test_integer(self) -> None:
         self.assert_emit(Assign(self.n, Integer(5)), "cpy_r_n = 10;")
-        self.assert_emit(
-            Assign(self.i32, Integer(5, c_int_rprimitive)), "cpy_r_i32 = 5;"
-        )
+        self.assert_emit(Assign(self.i32, Integer(5, c_int_rprimitive)), "cpy_r_i32 = 5;")
 
     def test_tuple_get(self) -> None:
         self.assert_emit(TupleGet(self.t, 1, 0), "cpy_r_r0 = cpy_r_t.f1;")
@@ -152,11 +150,7 @@ class TestFunctionEmitterVisitor(unittest.TestCase):
 
     def test_int_sub(self) -> None:
         self.assert_emit_binary_op(
-            "-",
-            self.n,
-            self.m,
-            self.k,
-            "cpy_r_r0 = CPyTagged_Subtract(cpy_r_m, cpy_r_k);",
+            "-", self.n, self.m, self.k, "cpy_r_r0 = CPyTagged_Subtract(cpy_r_m, cpy_r_k);"
         )
 
     def test_int_neg(self) -> None:
@@ -258,22 +252,15 @@ class TestFunctionEmitterVisitor(unittest.TestCase):
         )
         next_block = BasicBlock(8)
         b = Branch(self.b, next_block, BasicBlock(9), Branch.BOOL, rare=True)
-        self.assert_emit(
-            b, """if (likely(!cpy_r_b)) goto CPyL9;""", next_block=next_block
-        )
+        self.assert_emit(b, """if (likely(!cpy_r_b)) goto CPyL9;""", next_block=next_block)
         next_block = BasicBlock(8)
         b = Branch(self.b, next_block, BasicBlock(9), Branch.BOOL, rare=True)
         b.negated = True
-        self.assert_emit(
-            b, """if (likely(cpy_r_b)) goto CPyL9;""", next_block=next_block
-        )
+        self.assert_emit(b, """if (likely(cpy_r_b)) goto CPyL9;""", next_block=next_block)
 
     def test_call(self) -> None:
         decl = FuncDecl(
-            "myfn",
-            None,
-            "mod",
-            FuncSignature([RuntimeArg("m", int_rprimitive)], int_rprimitive),
+            "myfn", None, "mod", FuncSignature([RuntimeArg("m", int_rprimitive)], int_rprimitive)
         )
         self.assert_emit(Call(decl, [self.m], 55), "cpy_r_r0 = CPyDef_myfn(cpy_r_m);")
 
@@ -283,13 +270,11 @@ class TestFunctionEmitterVisitor(unittest.TestCase):
             None,
             "mod",
             FuncSignature(
-                [RuntimeArg("m", int_rprimitive), RuntimeArg("n", int_rprimitive)],
-                int_rprimitive,
+                [RuntimeArg("m", int_rprimitive), RuntimeArg("n", int_rprimitive)], int_rprimitive
             ),
         )
         self.assert_emit(
-            Call(decl, [self.m, self.k], 55),
-            "cpy_r_r0 = CPyDef_myfn(cpy_r_m, cpy_r_k);",
+            Call(decl, [self.m, self.k], 55), "cpy_r_r0 = CPyDef_myfn(cpy_r_m, cpy_r_k);"
         )
 
     def test_inc_ref(self) -> None:
@@ -343,9 +328,7 @@ class TestFunctionEmitterVisitor(unittest.TestCase):
         )
 
     def test_box_int(self) -> None:
-        self.assert_emit(
-            Box(self.n), """cpy_r_r0 = CPyTagged_StealAsObject(cpy_r_n);"""
-        )
+        self.assert_emit(Box(self.n), """cpy_r_r0 = CPyTagged_StealAsObject(cpy_r_n);""")
 
     def test_unbox_int(self) -> None:
         self.assert_emit(
@@ -359,14 +342,11 @@ class TestFunctionEmitterVisitor(unittest.TestCase):
         )
 
     def test_box_i64(self) -> None:
-        self.assert_emit(
-            Box(self.i64), """cpy_r_r0 = PyLong_FromLongLong(cpy_r_i64);"""
-        )
+        self.assert_emit(Box(self.i64), """cpy_r_r0 = PyLong_FromLongLong(cpy_r_i64);""")
 
     def test_unbox_i64(self) -> None:
         self.assert_emit(
-            Unbox(self.o, int64_rprimitive, 55),
-            """cpy_r_r0 = CPyLong_AsInt64(cpy_r_o);""",
+            Unbox(self.o, int64_rprimitive, 55), """cpy_r_r0 = CPyLong_AsInt64(cpy_r_o);"""
         )
 
     def test_list_append(self) -> None:
@@ -567,11 +547,7 @@ class TestFunctionEmitterVisitor(unittest.TestCase):
 
     def test_dict_contains(self) -> None:
         self.assert_emit_binary_op(
-            "in",
-            self.b,
-            self.o,
-            self.d,
-            """cpy_r_r0 = PyDict_Contains(cpy_r_d, cpy_r_o);""",
+            "in", self.b, self.o, self.d, """cpy_r_r0 = PyDict_Contains(cpy_r_d, cpy_r_o);"""
         )
 
     def test_int_op(self) -> None:
@@ -659,33 +635,25 @@ class TestFunctionEmitterVisitor(unittest.TestCase):
         )
 
     def test_load_mem(self) -> None:
-        self.assert_emit(
-            LoadMem(bool_rprimitive, self.ptr), """cpy_r_r0 = *(char *)cpy_r_ptr;"""
-        )
+        self.assert_emit(LoadMem(bool_rprimitive, self.ptr), """cpy_r_r0 = *(char *)cpy_r_ptr;""")
 
     def test_set_mem(self) -> None:
         self.assert_emit(
-            SetMem(bool_rprimitive, self.ptr, self.b),
-            """*(char *)cpy_r_ptr = cpy_r_b;""",
+            SetMem(bool_rprimitive, self.ptr, self.b), """*(char *)cpy_r_ptr = cpy_r_b;"""
         )
 
     def test_get_element_ptr(self) -> None:
         r = RStruct(
-            "Foo",
-            ["b", "i32", "i64"],
-            [bool_rprimitive, int32_rprimitive, int64_rprimitive],
+            "Foo", ["b", "i32", "i64"], [bool_rprimitive, int32_rprimitive, int64_rprimitive]
         )
         self.assert_emit(
-            GetElementPtr(self.o, r, "b"),
-            """cpy_r_r0 = (CPyPtr)&((Foo *)cpy_r_o)->b;""",
+            GetElementPtr(self.o, r, "b"), """cpy_r_r0 = (CPyPtr)&((Foo *)cpy_r_o)->b;"""
         )
         self.assert_emit(
-            GetElementPtr(self.o, r, "i32"),
-            """cpy_r_r0 = (CPyPtr)&((Foo *)cpy_r_o)->i32;""",
+            GetElementPtr(self.o, r, "i32"), """cpy_r_r0 = (CPyPtr)&((Foo *)cpy_r_o)->i32;"""
         )
         self.assert_emit(
-            GetElementPtr(self.o, r, "i64"),
-            """cpy_r_r0 = (CPyPtr)&((Foo *)cpy_r_o)->i64;""",
+            GetElementPtr(self.o, r, "i64"), """cpy_r_r0 = (CPyPtr)&((Foo *)cpy_r_o)->i64;"""
         )
 
     def test_load_address(self) -> None:
@@ -699,8 +667,7 @@ class TestFunctionEmitterVisitor(unittest.TestCase):
         a = Register(t, "a")
         self.registers.append(a)
         self.assert_emit(
-            AssignMulti(a, [self.o, self.o2]),
-            """PyObject *cpy_r_a[2] = {cpy_r_o, cpy_r_o2};""",
+            AssignMulti(a, [self.o, self.o2]), """PyObject *cpy_r_a[2] = {cpy_r_o, cpy_r_o2};"""
         )
 
     def test_long_unsigned(self) -> None:
@@ -709,19 +676,16 @@ class TestFunctionEmitterVisitor(unittest.TestCase):
             Assign(a, Integer(1 << 31, int64_rprimitive)), """cpy_r_a = 2147483648LL;"""
         )
         self.assert_emit(
-            Assign(a, Integer((1 << 31) - 1, int64_rprimitive)),
-            """cpy_r_a = 2147483647;""",
+            Assign(a, Integer((1 << 31) - 1, int64_rprimitive)), """cpy_r_a = 2147483647;"""
         )
 
     def test_long_signed(self) -> None:
         a = Register(int64_rprimitive, "a")
         self.assert_emit(
-            Assign(a, Integer(-(1 << 31) + 1, int64_rprimitive)),
-            """cpy_r_a = -2147483647;""",
+            Assign(a, Integer(-(1 << 31) + 1, int64_rprimitive)), """cpy_r_a = -2147483647;"""
         )
         self.assert_emit(
-            Assign(a, Integer(-(1 << 31), int64_rprimitive)),
-            """cpy_r_a = -2147483648LL;""",
+            Assign(a, Integer(-(1 << 31), int64_rprimitive)), """cpy_r_a = -2147483648LL;"""
         )
 
     def test_cast_and_branch_merge(self) -> None:
@@ -822,12 +786,9 @@ else {
 
     def test_extend(self) -> None:
         a = Register(int32_rprimitive, "a")
+        self.assert_emit(Extend(a, int64_rprimitive, signed=True), """cpy_r_r0 = cpy_r_a;""")
         self.assert_emit(
-            Extend(a, int64_rprimitive, signed=True), """cpy_r_r0 = cpy_r_a;"""
-        )
-        self.assert_emit(
-            Extend(a, int64_rprimitive, signed=False),
-            """cpy_r_r0 = (uint32_t)cpy_r_a;""",
+            Extend(a, int64_rprimitive, signed=False), """cpy_r_r0 = (uint32_t)cpy_r_a;"""
         )
         if PLATFORM_SIZE == 4:
             self.assert_emit(
@@ -835,16 +796,12 @@ else {
                 """cpy_r_r0 = (Py_ssize_t)cpy_r_n;""",
             )
             self.assert_emit(
-                Extend(self.n, int64_rprimitive, signed=False),
-                """cpy_r_r0 = cpy_r_n;""",
+                Extend(self.n, int64_rprimitive, signed=False), """cpy_r_r0 = cpy_r_n;"""
             )
         if PLATFORM_SIZE == 8:
+            self.assert_emit(Extend(a, int_rprimitive, signed=True), """cpy_r_r0 = cpy_r_a;""")
             self.assert_emit(
-                Extend(a, int_rprimitive, signed=True), """cpy_r_r0 = cpy_r_a;"""
-            )
-            self.assert_emit(
-                Extend(a, int_rprimitive, signed=False),
-                """cpy_r_r0 = (uint32_t)cpy_r_a;""",
+                Extend(a, int_rprimitive, signed=False), """cpy_r_r0 = (uint32_t)cpy_r_a;"""
             )
 
     def assert_emit(
@@ -884,9 +841,7 @@ else {
         else:
             expected_lines = expected.rstrip().split("\n")
         expected_lines = [line.strip(" ") for line in expected_lines]
-        assert_string_arrays_equal(
-            expected_lines, actual_lines, msg="Generated code unexpected"
-        )
+        assert_string_arrays_equal(expected_lines, actual_lines, msg="Generated code unexpected")
         if skip_next:
             assert visitor.op_index == 1
         else:
@@ -904,6 +859,8 @@ else {
                     args = [left, right]
                     if desc.ordering is not None:
                         args = [args[i] for i in desc.ordering]
+                    # This only supports primitives that map to C calls
+                    assert desc.c_function_name is not None
                     self.assert_emit(
                         CallC(
                             desc.c_function_name,
@@ -939,11 +896,7 @@ class TestGenerateFunction(unittest.TestCase):
         generate_native_function(fn, emitter, "prog.py", "prog")
         result = emitter.fragments
         assert_string_arrays_equal(
-            [
-                "CPyTagged CPyDef_myfunc(CPyTagged cpy_r_arg) {\n",
-                "    return cpy_r_arg;\n",
-                "}\n",
-            ],
+            ["CPyTagged CPyDef_myfunc(CPyTagged cpy_r_arg) {\n", "    return cpy_r_arg;\n", "}\n"],
             result,
             msg="Generated code invalid",
         )

jaclang/vendor/mypyc/test/test_emitwrapper.py

@@ -33,9 +33,7 @@ class TestArgCheck(unittest.TestCase):
     def test_check_int(self) -> None:
         emitter = Emitter(self.context)
         generate_arg_check("x", int_rprimitive, emitter, ReturnHandler("NULL"))
-        generate_arg_check(
-            "y", int_rprimitive, emitter, ReturnHandler("NULL"), optional=True
-        )
+        generate_arg_check("y", int_rprimitive, emitter, ReturnHandler("NULL"), optional=True)
         lines = emitter.fragments
         self.assert_lines(
             [

jaclang/vendor/mypyc/test/test_exceptions.py

@@ -34,9 +34,7 @@ class TestExceptionTransform(MypycDataSuite):
 
     def run_case(self, testcase: DataDrivenTestCase) -> None:
         """Perform a runtime checking transformation test case."""
-        with use_custom_builtins(
-            os.path.join(self.data_prefix, ICODE_GEN_BUILTINS), testcase
-        ):
+        with use_custom_builtins(os.path.join(self.data_prefix, ICODE_GEN_BUILTINS), testcase):
             expected_output = remove_comment_lines(testcase.output)
             try:
                 ir = build_ir_for_single_file(testcase.input)
@@ -45,9 +43,7 @@ class TestExceptionTransform(MypycDataSuite):
             else:
                 actual = []
                 for fn in ir:
-                    if fn.name == TOP_LEVEL_NAME and not testcase.name.endswith(
-                        "_toplevel"
-                    ):
+                    if fn.name == TOP_LEVEL_NAME and not testcase.name.endswith("_toplevel"):
                         continue
                     insert_uninit_checks(fn)
                     insert_exception_handling(fn)
@@ -55,10 +51,6 @@ class TestExceptionTransform(MypycDataSuite):
                     actual.extend(format_func(fn))
                     if testcase.name.endswith("_freq"):
                         common = frequently_executed_blocks(fn.blocks[0])
-                        actual.append(
-                            "hot blocks: %s" % sorted(b.label for b in common)
-                        )
+                        actual.append("hot blocks: %s" % sorted(b.label for b in common))
 
-            assert_test_output(
-                testcase, actual, "Invalid source code output", expected_output
-            )
+            assert_test_output(testcase, actual, "Invalid source code output", expected_output)

jaclang/vendor/mypyc/test/test_external.py

@@ -41,11 +41,7 @@ class TestExternal(unittest.TestCase):
             if "GTEST_COLOR" not in os.environ:
                 env["GTEST_COLOR"] = "yes"  # Use fancy colors
             status = subprocess.call(
-                [
-                    sys.executable,
-                    "-c",
-                    "import sys, test_capi; sys.exit(test_capi.run_tests())",
-                ],
+                [sys.executable, "-c", "import sys, test_capi; sys.exit(test_capi.run_tests())"],
                 env=env,
                 cwd=tmpdir,
             )

jaclang/vendor/mypyc/test/test_irbuild.py

@@ -69,9 +69,7 @@ class TestGenOps(MypycDataSuite):
         if options is None:
             # Skipped test case
             return
-        with use_custom_builtins(
-            os.path.join(self.data_prefix, ICODE_GEN_BUILTINS), testcase
-        ):
+        with use_custom_builtins(os.path.join(self.data_prefix, ICODE_GEN_BUILTINS), testcase):
             expected_output = remove_comment_lines(testcase.output)
             expected_output = replace_word_size(expected_output)
             name = testcase.name
@@ -86,6 +84,4 @@ class TestGenOps(MypycDataSuite):
                         continue
                     actual.extend(format_func(fn))
 
-            assert_test_output(
-                testcase, actual, "Invalid source code output", expected_output
-            )
+            assert_test_output(testcase, actual, "Invalid source code output", expected_output)

jaclang/vendor/mypyc/test/test_ircheck.py

@@ -80,9 +80,7 @@ class TestIrcheck(unittest.TestCase):
     def test_valid_goto(self) -> None:
         block_1 = self.basic_block([Return(value=NONE_VALUE)])
         block_2 = self.basic_block([Goto(label=block_1)])
-        fn = FuncIR(
-            decl=self.func_decl(name="func_1"), arg_regs=[], blocks=[block_1, block_2]
-        )
+        fn = FuncIR(decl=self.func_decl(name="func_1"), arg_regs=[], blocks=[block_1, block_2])
         assert_no_errors(fn)
 
     def test_invalid_goto(self) -> None:
@@ -95,25 +93,20 @@ class TestIrcheck(unittest.TestCase):
             # block_1 omitted
             blocks=[block_2],
         )
-        assert_has_error(
-            fn, FnError(source=goto, desc="Invalid control operation target: 1")
-        )
+        assert_has_error(fn, FnError(source=goto, desc="Invalid control operation target: 1"))
 
     def test_invalid_register_source(self) -> None:
         ret = Return(value=Register(type=none_rprimitive, name="r1"))
         block = self.basic_block([ret])
         fn = FuncIR(decl=self.func_decl(name="func_1"), arg_regs=[], blocks=[block])
-        assert_has_error(
-            fn, FnError(source=ret, desc="Invalid op reference to register 'r1'")
-        )
+        assert_has_error(fn, FnError(source=ret, desc="Invalid op reference to register 'r1'"))
 
     def test_invalid_op_source(self) -> None:
         ret = Return(value=LoadLiteral(value="foo", rtype=str_rprimitive))
         block = self.basic_block([ret])
         fn = FuncIR(decl=self.func_decl(name="func_1"), arg_regs=[], blocks=[block])
         assert_has_error(
-            fn,
-            FnError(source=ret, desc="Invalid op reference to op of type LoadLiteral"),
+            fn, FnError(source=ret, desc="Invalid op reference to op of type LoadLiteral")
         )
 
     def test_invalid_return_type(self) -> None:
@@ -124,8 +117,7 @@ class TestIrcheck(unittest.TestCase):
             blocks=[self.basic_block([ret])],
         )
         assert_has_error(
-            fn,
-            FnError(source=ret, desc="Cannot coerce source type i32 to dest type i64"),
+            fn, FnError(source=ret, desc="Cannot coerce source type i32 to dest type i64")
         )
 
     def test_invalid_assign(self) -> None:
@@ -138,10 +130,7 @@ class TestIrcheck(unittest.TestCase):
             blocks=[self.basic_block([assign, ret])],
         )
         assert_has_error(
-            fn,
-            FnError(
-                source=assign, desc="Cannot coerce source type i32 to dest type i64"
-            ),
+            fn, FnError(source=assign, desc="Cannot coerce source type i32 to dest type i64")
         )
 
     def test_can_coerce_to(self) -> None:

jaclang/vendor/mypyc/test/test_literals.py

@@ -41,10 +41,7 @@ class TestLiterals(unittest.TestCase):
             bytes([1, 70]) + b"x" * 70,
             b"",
         ]
-        assert _encode_bytes_values({b"y" * 100: 0}) == [
-            bytes([1, 100]) + b"y" * 100,
-            b"",
-        ]
+        assert _encode_bytes_values({b"y" * 100: 0}) == [bytes([1, 100]) + b"y" * 100, b""]
 
     def test_encode_int_values(self) -> None:
         assert _encode_int_values({}) == [b""]