jaclang 0.7.34__py3-none-any.whl → 0.8.0__py3-none-any.whl

jaclang/vendor/mypyc/primitives/tuple_ops.py

@@ -1,83 +0,0 @@
-"""Primitive tuple ops for *variable-length* tuples.
-
-Note: Varying-length tuples are represented as boxed Python tuple
-objects, i.e. tuple_rprimitive (RPrimitive), not RTuple.
-"""
-
-from __future__ import annotations
-
-from mypyc.ir.ops import ERR_FALSE, ERR_MAGIC
-from mypyc.ir.rtypes import (
-    bit_rprimitive,
-    c_pyssize_t_rprimitive,
-    int_rprimitive,
-    list_rprimitive,
-    object_rprimitive,
-    tuple_rprimitive,
-)
-from mypyc.primitives.registry import custom_op, function_op, load_address_op, method_op
-
-# Get the 'builtins.tuple' type object.
-load_address_op(name="builtins.tuple", type=object_rprimitive, src="PyTuple_Type")
-
-# tuple[index] (for an int index)
-tuple_get_item_op = method_op(
-    name="__getitem__",
-    arg_types=[tuple_rprimitive, int_rprimitive],
-    return_type=object_rprimitive,
-    c_function_name="CPySequenceTuple_GetItem",
-    error_kind=ERR_MAGIC,
-)
-
-# Construct a boxed tuple from items: (item1, item2, ...)
-new_tuple_op = custom_op(
-    arg_types=[c_pyssize_t_rprimitive],
-    return_type=tuple_rprimitive,
-    c_function_name="PyTuple_Pack",
-    error_kind=ERR_MAGIC,
-    var_arg_type=object_rprimitive,
-)
-
-new_tuple_with_length_op = custom_op(
-    arg_types=[c_pyssize_t_rprimitive],
-    return_type=tuple_rprimitive,
-    c_function_name="PyTuple_New",
-    error_kind=ERR_MAGIC,
-)
-
-# PyTuple_SET_ITEM does no error checking,
-# and should only be used to fill in brand new tuples.
-new_tuple_set_item_op = custom_op(
-    arg_types=[tuple_rprimitive, int_rprimitive, object_rprimitive],
-    return_type=bit_rprimitive,
-    c_function_name="CPySequenceTuple_SetItemUnsafe",
-    error_kind=ERR_FALSE,
-    steals=[False, False, True],
-)
-
-# Construct tuple from a list.
-list_tuple_op = function_op(
-    name="builtins.tuple",
-    arg_types=[list_rprimitive],
-    return_type=tuple_rprimitive,
-    c_function_name="PyList_AsTuple",
-    error_kind=ERR_MAGIC,
-    priority=2,
-)
-
-# Construct tuple from an arbitrary (iterable) object.
-function_op(
-    name="builtins.tuple",
-    arg_types=[object_rprimitive],
-    return_type=tuple_rprimitive,
-    c_function_name="PySequence_Tuple",
-    error_kind=ERR_MAGIC,
-)
-
-# tuple[begin:end]
-tuple_slice_op = custom_op(
-    arg_types=[tuple_rprimitive, int_rprimitive, int_rprimitive],
-    return_type=object_rprimitive,
-    c_function_name="CPySequenceTuple_GetSlice",
-    error_kind=ERR_MAGIC,
-)

jaclang/vendor/mypyc/rt_subtype.py

@@ -1,77 +0,0 @@
-"""'Runtime subtype' check for RTypes.
-
-A type S is a runtime subtype of T if a value of type S can be used at runtime
-when a value of type T is expected without requiring any runtime conversions.
-
-For boxed types, runtime subtyping is the same as regular subtyping.
-Unboxed subtypes, on the other hand, are not runtime subtypes of object
-(since they require boxing to be used as an object), but short ints
-are runtime subtypes of int.
-
-Subtyping is used to determine whether an object can be in a
-particular place and runtime subtyping is used to determine whether a
-coercion is necessary first.
-"""
-
-from __future__ import annotations
-
-from mypyc.ir.rtypes import (
-    RArray,
-    RInstance,
-    RPrimitive,
-    RStruct,
-    RTuple,
-    RType,
-    RTypeVisitor,
-    RUnion,
-    RVoid,
-    is_bit_rprimitive,
-    is_bool_rprimitive,
-    is_int_rprimitive,
-    is_short_int_rprimitive,
-)
-from mypyc.subtype import is_subtype
-
-
-def is_runtime_subtype(left: RType, right: RType) -> bool:
-    return left.accept(RTSubtypeVisitor(right))
-
-
-class RTSubtypeVisitor(RTypeVisitor[bool]):
-    """Is left a runtime subtype of right?
-
-    A few special cases such as right being 'object' are handled in
-    is_runtime_subtype and don't need to be covered here.
-    """
-
-    def __init__(self, right: RType) -> None:
-        self.right = right
-
-    def visit_rinstance(self, left: RInstance) -> bool:
-        return is_subtype(left, self.right)
-
-    def visit_runion(self, left: RUnion) -> bool:
-        return not self.right.is_unboxed and is_subtype(left, self.right)
-
-    def visit_rprimitive(self, left: RPrimitive) -> bool:
-        if is_short_int_rprimitive(left) and is_int_rprimitive(self.right):
-            return True
-        if is_bit_rprimitive(left) and is_bool_rprimitive(self.right):
-            return True
-        return left is self.right
-
-    def visit_rtuple(self, left: RTuple) -> bool:
-        if isinstance(self.right, RTuple):
-            return len(self.right.types) == len(left.types) and all(
-                is_runtime_subtype(t1, t2) for t1, t2 in zip(left.types, self.right.types)
-            )
-        return False
-
-    def visit_rstruct(self, left: RStruct) -> bool:
-        return isinstance(self.right, RStruct) and self.right.name == left.name
-
-    def visit_rarray(self, left: RArray) -> bool:
-        return left == self.right
-
-    def visit_rvoid(self, left: RVoid) -> bool:
-        return isinstance(self.right, RVoid)

jaclang/vendor/mypyc/sametype.py

@@ -1,83 +0,0 @@
-"""Same type check for RTypes."""
-
-from __future__ import annotations
-
-from mypyc.ir.func_ir import FuncSignature
-from mypyc.ir.rtypes import (
-    RArray,
-    RInstance,
-    RPrimitive,
-    RStruct,
-    RTuple,
-    RType,
-    RTypeVisitor,
-    RUnion,
-    RVoid,
-)
-
-
-def is_same_type(a: RType, b: RType) -> bool:
-    return a.accept(SameTypeVisitor(b))
-
-
-def is_same_signature(a: FuncSignature, b: FuncSignature) -> bool:
-    return (
-        len(a.args) == len(b.args)
-        and is_same_type(a.ret_type, b.ret_type)
-        and all(
-            is_same_type(t1.type, t2.type) and t1.name == t2.name for t1, t2 in zip(a.args, b.args)
-        )
-    )
-
-
-def is_same_method_signature(a: FuncSignature, b: FuncSignature) -> bool:
-    return (
-        len(a.args) == len(b.args)
-        and is_same_type(a.ret_type, b.ret_type)
-        and all(
-            is_same_type(t1.type, t2.type)
-            and ((t1.pos_only and t2.pos_only) or t1.name == t2.name)
-            and t1.optional == t2.optional
-            for t1, t2 in zip(a.args[1:], b.args[1:])
-        )
-    )
-
-
-class SameTypeVisitor(RTypeVisitor[bool]):
-    def __init__(self, right: RType) -> None:
-        self.right = right
-
-    def visit_rinstance(self, left: RInstance) -> bool:
-        return isinstance(self.right, RInstance) and left.name == self.right.name
-
-    def visit_runion(self, left: RUnion) -> bool:
-        if isinstance(self.right, RUnion):
-            items = list(self.right.items)
-            for left_item in left.items:
-                for j, right_item in enumerate(items):
-                    if is_same_type(left_item, right_item):
-                        del items[j]
-                        break
-                else:
-                    return False
-            return not items
-        return False
-
-    def visit_rprimitive(self, left: RPrimitive) -> bool:
-        return left is self.right
-
-    def visit_rtuple(self, left: RTuple) -> bool:
-        return (
-            isinstance(self.right, RTuple)
-            and len(self.right.types) == len(left.types)
-            and all(is_same_type(t1, t2) for t1, t2 in zip(left.types, self.right.types))
-        )
-
-    def visit_rstruct(self, left: RStruct) -> bool:
-        return isinstance(self.right, RStruct) and self.right.name == left.name
-
-    def visit_rarray(self, left: RArray) -> bool:
-        return left == self.right
-
-    def visit_rvoid(self, left: RVoid) -> bool:
-        return isinstance(self.right, RVoid)

jaclang/vendor/mypyc/subtype.py

@@ -1,88 +0,0 @@
-"""Subtype check for RTypes."""
-
-from __future__ import annotations
-
-from mypyc.ir.rtypes import (
-    RArray,
-    RInstance,
-    RPrimitive,
-    RStruct,
-    RTuple,
-    RType,
-    RTypeVisitor,
-    RUnion,
-    RVoid,
-    is_bit_rprimitive,
-    is_bool_rprimitive,
-    is_fixed_width_rtype,
-    is_int_rprimitive,
-    is_object_rprimitive,
-    is_short_int_rprimitive,
-    is_tagged,
-    is_tuple_rprimitive,
-)
-
-
-def is_subtype(left: RType, right: RType) -> bool:
-    if is_object_rprimitive(right):
-        return True
-    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):
-                    return False
-            return True
-        else:
-            return any(is_subtype(left, item) for item in right.items)
-    return left.accept(SubtypeVisitor(right))
-
-
-class SubtypeVisitor(RTypeVisitor[bool]):
-    """Is left a subtype of right?
-
-    A few special cases such as right being 'object' are handled in
-    is_subtype and don't need to be covered here.
-    """
-
-    def __init__(self, right: RType) -> None:
-        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
-
-    def visit_runion(self, left: RUnion) -> bool:
-        return all(is_subtype(item, self.right) for item in left.items)
-
-    def visit_rprimitive(self, left: RPrimitive) -> bool:
-        right = self.right
-        if is_bool_rprimitive(left):
-            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):
-                return True
-        elif is_short_int_rprimitive(left):
-            if is_int_rprimitive(right):
-                return True
-        elif is_fixed_width_rtype(left):
-            if is_int_rprimitive(right):
-                return True
-        return left is right
-
-    def visit_rtuple(self, left: RTuple) -> bool:
-        if is_tuple_rprimitive(self.right):
-            return True
-        if isinstance(self.right, RTuple):
-            return len(self.right.types) == len(left.types) and all(
-                is_subtype(t1, t2) for t1, t2 in zip(left.types, self.right.types)
-            )
-        return False
-
-    def visit_rstruct(self, left: RStruct) -> bool:
-        return isinstance(self.right, RStruct) and self.right.name == left.name
-
-    def visit_rarray(self, left: RArray) -> bool:
-        return left == self.right
-
-    def visit_rvoid(self, left: RVoid) -> bool:
-        return isinstance(self.right, RVoid)

jaclang/vendor/mypyc/test/config.py

@@ -1,13 +0,0 @@
-from __future__ import annotations
-
-import os
-
-provided_prefix = os.getenv("MYPY_TEST_PREFIX", None)
-if provided_prefix:
-    PREFIX = provided_prefix
-else:
-    this_file_dir = os.path.dirname(os.path.realpath(__file__))
-    PREFIX = os.path.dirname(os.path.dirname(this_file_dir))
-
-# Location of test data files such as test case descriptions.
-test_data_prefix = os.path.join(PREFIX, "mypyc", "test-data")

jaclang/vendor/mypyc/test/test_alwaysdefined.py

@@ -1,46 +0,0 @@
-"""Test cases for inferring always defined attributes in classes."""
-
-from __future__ import annotations
-
-import os.path
-
-from mypy.errors import CompileError
-from mypy.test.config import test_temp_dir
-from mypy.test.data import DataDrivenTestCase
-from mypyc.test.testutil import (
-    ICODE_GEN_BUILTINS,
-    MypycDataSuite,
-    assert_test_output,
-    build_ir_for_single_file2,
-    infer_ir_build_options_from_test_name,
-    use_custom_builtins,
-)
-
-files = ["alwaysdefined.test"]
-
-
-class TestAlwaysDefined(MypycDataSuite):
-    files = files
-    base_path = test_temp_dir
-
-    def run_case(self, testcase: DataDrivenTestCase) -> None:
-        """Perform a runtime checking transformation test case."""
-        options = infer_ir_build_options_from_test_name(testcase.name)
-        if options is None:
-            # Skipped test case
-            return
-        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:
-                actual = e.messages
-            else:
-                actual = []
-                for cl in ir.classes:
-                    if cl.name.startswith("_"):
-                        continue
-                    actual.append(
-                        "{}: [{}]".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

@@ -1,77 +0,0 @@
-"""Test runner for data-flow analysis test cases."""
-
-from __future__ import annotations
-
-import os.path
-
-from mypy.errors import CompileError
-from mypy.test.config import test_temp_dir
-from mypy.test.data import DataDrivenTestCase
-from mypyc.analysis import dataflow
-from mypyc.common import TOP_LEVEL_NAME
-from mypyc.ir.func_ir import all_values
-from mypyc.ir.ops import Value
-from mypyc.ir.pprint import format_func, generate_names_for_ir
-from mypyc.test.testutil import (
-    ICODE_GEN_BUILTINS,
-    MypycDataSuite,
-    assert_test_output,
-    build_ir_for_single_file,
-    use_custom_builtins,
-)
-from mypyc.transform import exceptions
-
-files = ["analysis.test"]
-
-
-class TestAnalysis(MypycDataSuite):
-    files = files
-    base_path = test_temp_dir
-    optional_out = True
-
-    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):
-            try:
-                ir = build_ir_for_single_file(testcase.input)
-            except CompileError as e:
-                actual = e.messages
-            else:
-                actual = []
-                for fn in ir:
-                    if fn.name == TOP_LEVEL_NAME and not testcase.name.endswith("_toplevel"):
-                        continue
-                    exceptions.insert_exception_handling(fn)
-                    actual.extend(format_func(fn))
-                    cfg = dataflow.get_cfg(fn.blocks)
-                    args: set[Value] = set(fn.arg_regs)
-                    name = testcase.name
-                    if name.endswith("_MaybeDefined"):
-                        # Forward, maybe
-                        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)
-                        )
-                    elif name.endswith("_BorrowedArgument"):
-                        # Forward, must
-                        analysis_result = dataflow.analyze_borrowed_arguments(fn.blocks, cfg, args)
-                    else:
-                        assert False, "No recognized _AnalysisName suffix in test case"
-
-                    names = generate_names_for_ir(fn.arg_regs, fn.blocks)
-
-                    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]))
-                        actual.append(
-                            "%-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

@@ -1,53 +0,0 @@
-"""Test that C functions used in primitives are declared in a header such as CPy.h."""
-
-from __future__ import annotations
-
-import glob
-import os
-import re
-import unittest
-
-from mypyc.ir.ops import PrimitiveDescription
-from mypyc.primitives import registry
-from mypyc.primitives.registry import CFunctionDescription
-
-
-class TestHeaderInclusion(unittest.TestCase):
-    def test_primitives_included_in_header(self) -> None:
-        base_dir = os.path.join(os.path.dirname(__file__), "..", "lib-rt")
-        with open(os.path.join(base_dir, "CPy.h")) as f:
-            header = f.read()
-        with open(os.path.join(base_dir, "pythonsupport.h")) as f:
-            header += f.read()
-
-        def check_name(name: str) -> None:
-            if name.startswith("CPy"):
-                assert re.search(
-                    rf"\b{name}\b", header
-                ), f'"{name}" is used in mypyc.primitives but not declared in CPy.h'
-
-        for old_values in [
-            registry.method_call_ops.values(),
-            registry.function_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, PrimitiveDescription):
-                    ops = [ops]
-                for op in ops:
-                    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"):
-            with open(fnam) as f:
-                content = f.read()
-            for name in re.findall(r'c_function_name=["\'](CPy[A-Z_a-z0-9]+)', content):
-                check_name(name)

jaclang/vendor/mypyc/test/test_commandline.py

@@ -1,82 +0,0 @@
-"""Test cases for invoking mypyc on the command line.
-
-These are slow -- do not add test cases unless you have a very good reason to do so.
-"""
-
-from __future__ import annotations
-
-import glob
-import os
-import os.path
-import re
-import subprocess
-import sys
-
-from mypy.test.config import test_temp_dir
-from mypy.test.data import DataDrivenTestCase
-from mypy.test.helpers import normalize_error_messages
-from mypyc.test.testutil import MypycDataSuite, assert_test_output
-
-files = ["commandline.test"]
-
-
-base_path = os.path.join(os.path.dirname(__file__), "..", "..")
-
-python3_path = sys.executable
-
-
-class TestCommandLine(MypycDataSuite):
-    files = files
-    base_path = test_temp_dir
-    optional_out = True
-
-    def run_case(self, testcase: DataDrivenTestCase) -> None:
-        # Parse options from test case description (arguments must not have spaces)
-        text = "\n".join(testcase.input)
-        m = re.search(r"# *cmd: *(.*)", text)
-        assert m is not None, 'Test case missing "# cmd: <files>" section'
-        args = m.group(1).split()
-
-        # Write main program to run (not compiled)
-        program = "_%s.py" % testcase.name
-        program_path = os.path.join(test_temp_dir, program)
-        with open(program_path, "w") as f:
-            f.write(text)
-
-        env = os.environ.copy()
-        env["PYTHONPATH"] = base_path
-
-        out = b""
-        try:
-            # Compile program
-            cmd = subprocess.run(
-                [sys.executable, "-m", "mypyc", *args],
-                stdout=subprocess.PIPE,
-                stderr=subprocess.STDOUT,
-                cwd="tmp",
-                env=env,
-            )
-            if "ErrorOutput" in testcase.name or cmd.returncode != 0:
-                out += cmd.stdout
-            elif "WarningOutput" in testcase.name:
-                # Strip out setuptools build related output since we're only
-                # interested in the messages emitted during compilation.
-                messages, _, _ = cmd.stdout.partition(b"running build_ext")
-                out += messages
-
-            if cmd.returncode == 0:
-                # Run main program
-                out += subprocess.check_output([python3_path, program], cwd="tmp")
-        finally:
-            suffix = "pyd" if sys.platform == "win32" else "so"
-            so_paths = glob.glob(f"tmp/**/*.{suffix}", recursive=True)
-            for path in so_paths:
-                os.remove(path)
-
-        # Strip out 'tmp/' from error message paths in the testcase output,
-        # due to a mismatch between this test and mypy's test suite.
-        expected = [x.replace("tmp/", "") for x in testcase.output]
-
-        # Verify output
-        actual = normalize_error_messages(out.decode().splitlines())
-        assert_test_output(testcase, actual, "Invalid output", expected=expected)

jaclang/vendor/mypyc/test/test_emit.py

@@ -1,69 +0,0 @@
-from __future__ import annotations
-
-import unittest
-
-from mypyc.codegen.emit import Emitter, EmitterContext
-from mypyc.ir.ops import BasicBlock, Register, Value
-from mypyc.ir.rtypes import RTuple, bool_rprimitive, int_rprimitive, str_rprimitive
-from mypyc.namegen import NameGenerator
-
-
-class TestEmitter(unittest.TestCase):
-    def setUp(self) -> None:
-        self.n = Register(int_rprimitive, "n")
-        self.context = EmitterContext(NameGenerator([["mod"]]))
-
-    def test_label(self) -> None:
-        emitter = Emitter(self.context, {})
-        assert 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:
-        emitter = Emitter(self.context, {})
-        assert emitter.object_annotation("hello, world", "line;") == " /* 'hello, world' */"
-        assert (
-            emitter.object_annotation(list(range(30)), "line;")
-            == """\
- /* [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
-         23, 24, 25, 26, 27, 28, 29] */"""
-        )
-
-    def test_emit_line(self) -> None:
-        emitter = Emitter(self.context, {})
-        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=list(range(30)))
-        assert emitter.fragments[0] == "CPyStatics[0]; /* 'hello, world' */\n"
-        assert (
-            emitter.fragments[1]
-            == """\
-CPyStatics[1]; /* [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
-                  21, 22, 23, 24, 25, 26, 27, 28, 29] */\n"""
-        )
-
-    def test_emit_undefined_value_for_simple_type(self) -> None:
-        emitter = Emitter(self.context, {})
-        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 = Emitter(self.context, {})
-        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 }"
-        )