jaclang 0.4.6__py3-none-any.whl → 0.5.0__py3-none-any.whl

jaclang/vendor/mypy/typeops.py

@@ -599,15 +599,15 @@ def _remove_redundant_union_items(items: list[Type], keep_erased: bool) -> list[
     return items
 
 
-def _get_type_special_method_bool_ret_type(t: Type) -> Type | None:
+def _get_type_method_ret_type(t: Type, *, name: str) -> Type | None:
     t = get_proper_type(t)
 
     if isinstance(t, Instance):
-        bool_method = t.type.get("__bool__")
-        if bool_method:
-            callee = get_proper_type(bool_method.type)
-            if isinstance(callee, CallableType):
-                return callee.ret_type
+        sym = t.type.get(name)
+        if sym:
+            sym_type = get_proper_type(sym.type)
+            if isinstance(sym_type, CallableType):
+                return sym_type.ret_type
 
     return None
 
@@ -630,7 +630,9 @@ def true_only(t: Type) -> ProperType:
         can_be_true_items = [item for item in new_items if item.can_be_true]
         return make_simplified_union(can_be_true_items, line=t.line, column=t.column)
     else:
-        ret_type = _get_type_special_method_bool_ret_type(t)
+        ret_type = _get_type_method_ret_type(
+            t, name="__bool__"
+        ) or _get_type_method_ret_type(t, name="__len__")
 
         if ret_type and not ret_type.can_be_true:
             return UninhabitedType(line=t.line, column=t.column)
@@ -663,9 +665,14 @@ def false_only(t: Type) -> ProperType:
         can_be_false_items = [item for item in new_items if item.can_be_false]
         return make_simplified_union(can_be_false_items, line=t.line, column=t.column)
     else:
-        ret_type = _get_type_special_method_bool_ret_type(t)
-
-        if ret_type and not ret_type.can_be_false:
+        ret_type = _get_type_method_ret_type(
+            t, name="__bool__"
+        ) or _get_type_method_ret_type(t, name="__len__")
+
+        if ret_type:
+            if not ret_type.can_be_false:
+                return UninhabitedType(line=t.line)
+        elif isinstance(t, Instance) and t.type.is_final:
             return UninhabitedType(line=t.line)
 
         new_t = copy_type(t)
@@ -945,9 +952,11 @@ def try_contracting_literals_in_union(types: Sequence[Type]) -> list[ProperType]
             if typ.fallback.type.is_enum or isinstance(typ.value, bool):
                 if fullname not in sum_types:
                     sum_types[fullname] = (
-                        set(typ.fallback.get_enum_values())
-                        if typ.fallback.type.is_enum
-                        else {True, False},
+                        (
+                            set(typ.fallback.get_enum_values())
+                            if typ.fallback.type.is_enum
+                            else {True, False}
+                        ),
                         [],
                     )
                 literals, indexes = sum_types[fullname]

jaclang/vendor/mypy/types.py

@@ -56,7 +56,7 @@ JsonDict: _TypeAlias = Dict[str, Any]
 # 1. types.LiteralType's serialize and deserialize methods: this method
 #    needs to make sure it can convert the below types into JSON and back.
 #
-# 2. types.LiteralType's 'alue_repr` method: this method is ultimately used
+# 2. types.LiteralType's 'value_repr` method: this method is ultimately used
 #    by TypeStrVisitor's visit_literal_type to generate a reasonable
 #    repr-able output.
 #
@@ -455,7 +455,7 @@ class TypeGuardedType(Type):
 
     __slots__ = ("type_guard",)
 
-    def __init__(self, type_guard: Type):
+    def __init__(self, type_guard: Type) -> None:
         super().__init__(line=type_guard.line, column=type_guard.column)
         self.type_guard = type_guard
 
@@ -1200,9 +1200,9 @@ class AnyType(ProperType):
         return {
             ".class": "AnyType",
             "type_of_any": self.type_of_any,
-            "source_any": self.source_any.serialize()
-            if self.source_any is not None
-            else None,
+            "source_any": (
+                self.source_any.serialize() if self.source_any is not None else None
+            ),
             "missing_import_name": self.missing_import_name,
         }
 
@@ -1541,9 +1541,11 @@ class Instance(ProperType):
             args if args is not _dummy else self.args,
             self.line,
             self.column,
-            last_known_value=last_known_value
-            if last_known_value is not _dummy
-            else self.last_known_value,
+            last_known_value=(
+                last_known_value
+                if last_known_value is not _dummy
+                else self.last_known_value
+            ),
         )
         # We intentionally don't copy the extra_attrs here, so they will be erased.
         new.can_be_true = self.can_be_true
@@ -1970,13 +1972,13 @@ class CallableType(FunctionLike):
             ),
             implicit=implicit if implicit is not _dummy else self.implicit,
             special_sig=special_sig if special_sig is not _dummy else self.special_sig,
-            from_type_type=from_type_type
-            if from_type_type is not _dummy
-            else self.from_type_type,
+            from_type_type=(
+                from_type_type if from_type_type is not _dummy else self.from_type_type
+            ),
             bound_args=bound_args if bound_args is not _dummy else self.bound_args,
-            def_extras=def_extras
-            if def_extras is not _dummy
-            else dict(self.def_extras),
+            def_extras=(
+                def_extras if def_extras is not _dummy else dict(self.def_extras)
+            ),
             type_guard=type_guard if type_guard is not _dummy else self.type_guard,
             from_concatenate=(
                 from_concatenate
@@ -1988,9 +1990,9 @@ class CallableType(FunctionLike):
                 if imprecise_arg_kinds is not _dummy
                 else self.imprecise_arg_kinds
             ),
-            unpack_kwargs=unpack_kwargs
-            if unpack_kwargs is not _dummy
-            else self.unpack_kwargs,
+            unpack_kwargs=(
+                unpack_kwargs if unpack_kwargs is not _dummy else self.unpack_kwargs
+            ),
         )
         # Optimization: Only NewTypes are supported as subtypes since
         # the class is effectively final, so we can use a cast safely.
@@ -2168,9 +2170,11 @@ class CallableType(FunctionLike):
         last_type = get_proper_type(self.arg_types[-1])
         assert isinstance(last_type, TypedDictType)
         extra_kinds = [
-            ArgKind.ARG_NAMED
-            if name in last_type.required_keys
-            else ArgKind.ARG_NAMED_OPT
+            (
+                ArgKind.ARG_NAMED
+                if name in last_type.required_keys
+                else ArgKind.ARG_NAMED_OPT
+            )
             for name in last_type.items
         ]
         new_arg_kinds = self.arg_kinds[:-1] + extra_kinds
@@ -2304,9 +2308,9 @@ class CallableType(FunctionLike):
                 (None if t is None else t.serialize()) for t in self.bound_args
             ],
             "def_extras": dict(self.def_extras),
-            "type_guard": self.type_guard.serialize()
-            if self.type_guard is not None
-            else None,
+            "type_guard": (
+                self.type_guard.serialize() if self.type_guard is not None else None
+            ),
             "from_concatenate": self.from_concatenate,
             "imprecise_arg_kinds": self.imprecise_arg_kinds,
             "unpack_kwargs": self.unpack_kwargs,
@@ -2943,13 +2947,11 @@ class UnionType(ProperType):
     @staticmethod
     def make_union(
         items: Sequence[ProperType], line: int = -1, column: int = -1
-    ) -> ProperType:
-        ...
+    ) -> ProperType: ...
 
     @overload
     @staticmethod
-    def make_union(items: Sequence[Type], line: int = -1, column: int = -1) -> Type:
-        ...
+    def make_union(items: Sequence[Type], line: int = -1, column: int = -1) -> Type: ...
 
     @staticmethod
     def make_union(items: Sequence[Type], line: int = -1, column: int = -1) -> Type:
@@ -3167,13 +3169,11 @@ class PlaceholderType(ProperType):
 
 
 @overload
-def get_proper_type(typ: None) -> None:
-    ...
+def get_proper_type(typ: None) -> None: ...
 
 
 @overload
-def get_proper_type(typ: Type) -> ProperType:
-    ...
+def get_proper_type(typ: Type) -> ProperType: ...
 
 
 def get_proper_type(typ: Type | None) -> ProperType | None:
@@ -3203,8 +3203,7 @@ def get_proper_types(types: list[Type] | tuple[Type, ...]) -> list[ProperType]:
 @overload
 def get_proper_types(
     types: list[Type | None] | tuple[Type | None, ...]
-) -> list[ProperType | None]:
-    ...
+) -> list[ProperType | None]: ...
 
 
 def get_proper_types(
@@ -3226,7 +3225,7 @@ def get_proper_types(
 # to make it easier to gradually get modules working with mypyc.
 # Import them here, after the types are defined.
 # This is intended as a re-export also.
-from mypy.type_visitor import (  # noqa: F811
+from mypy.type_visitor import (
     ALL_STRATEGY as ALL_STRATEGY,
     ANY_STRATEGY as ANY_STRATEGY,
     BoolTypeQuery as BoolTypeQuery,

jaclang/vendor/mypy/typestate.py

@@ -194,7 +194,7 @@ class TypeState:
             # These are unlikely to match, due to the large space of
             # possible values.  Avoid uselessly increasing cache sizes.
             return
-        cache = self._subtype_caches.setdefault(right.type, dict())
+        cache = self._subtype_caches.setdefault(right.type, {})
         cache.setdefault(kind, set()).add((left, right))
 
     def record_negative_subtype_cache_entry(
@@ -206,7 +206,7 @@ class TypeState:
             return
         if len(self._negative_subtype_caches) > MAX_NEGATIVE_CACHE_TYPES:
             self._negative_subtype_caches.clear()
-        cache = self._negative_subtype_caches.setdefault(right.type, dict())
+        cache = self._negative_subtype_caches.setdefault(right.type, {})
         subcache = cache.setdefault(kind, set())
         if len(subcache) > MAX_NEGATIVE_CACHE_ENTRIES:
             subcache.clear()

jaclang/vendor/mypy/util.py

@@ -270,6 +270,8 @@ def _generate_junit_contents(
     version: str,
     platform: str,
 ) -> str:
+    from xml.sax.saxutils import escape
+
     if serious:
         failures = 0
         errors = len(messages_by_file)
@@ -293,7 +295,7 @@ def _generate_junit_contents(
         for filename, messages in messages_by_file.items():
             if filename is not None:
                 xml += JUNIT_TESTCASE_FAIL_TEMPLATE.format(
-                    text="\n".join(messages),
+                    text=escape("\n".join(messages)),
                     filename=filename,
                     time=dt,
                     name="mypy-py{ver}-{platform} {filename}".format(
@@ -302,7 +304,7 @@ def _generate_junit_contents(
                 )
             else:
                 xml += JUNIT_TESTCASE_FAIL_TEMPLATE.format(
-                    text="\n".join(messages),
+                    text=escape("\n".join(messages)),
                     filename="mypy",
                     time=dt,
                     name="mypy-py{ver}-{platform}".format(
@@ -325,10 +327,9 @@ def write_junit_xml(
 ) -> None:
     xml = _generate_junit_contents(dt, serious, messages_by_file, version, platform)
 
-    # checks for a directory structure in path and creates folders if needed
+    # creates folders if needed
     xml_dirs = os.path.dirname(os.path.abspath(path))
-    if not os.path.isdir(xml_dirs):
-        os.makedirs(xml_dirs)
+    os.makedirs(xml_dirs, exist_ok=True)
 
     with open(path, "wb") as f:
         f.write(xml.encode("utf-8"))
@@ -464,7 +465,7 @@ def get_unique_redefinition_name(name: str, existing: Container[str]) -> str:
 def check_python_version(program: str) -> None:
     """Report issues with the Python used to run mypy, dmypy, or stubgen"""
     # Check for known bad Python versions.
-    if sys.version_info[:2] < (3, 8):
+    if sys.version_info[:2] < (3, 8):  # noqa: UP036
         sys.exit(
             "Running {name} with Python 3.7 or lower is not supported; "
             "please upgrade to 3.8 or newer".format(name=program)

jaclang/vendor/mypy/version.py

@@ -8,7 +8,7 @@ from mypy import git
 # - Release versions have the form "1.2.3".
 # - Dev versions have the form "1.2.3+dev" (PLUS sign to conform to PEP 440).
 # - Before 1.0 we had the form "0.NNN".
-__version__ = "1.8.0+dev"
+__version__ = "1.9.0+dev"
 base_version = __version__
 
 mypy_dir = os.path.abspath(os.path.dirname(os.path.dirname(__file__)))

jaclang/vendor/mypyc/analysis/ircheck.py

@@ -1,4 +1,5 @@
 """Utilities for checking that internal ir is valid and consistent."""
+
 from __future__ import annotations
 
 from mypyc.ir.func_ir import FUNC_STATICMETHOD, FuncIR

jaclang/vendor/mypyc/codegen/emitfunc.py

@@ -559,9 +559,11 @@ class FunctionEmitterVisitor(OpVisitor[None]):
         obj_args = (
             []
             if method.decl.kind == FUNC_STATICMETHOD
-            else [f"(PyObject *)Py_TYPE({obj})"]
-            if method.decl.kind == FUNC_CLASSMETHOD
-            else [obj]
+            else (
+                [f"(PyObject *)Py_TYPE({obj})"]
+                if method.decl.kind == FUNC_CLASSMETHOD
+                else [obj]
+            )
         )
         args = ", ".join(obj_args + [self.reg(arg) for arg in op.args])
         mtype = native_function_type(method, self.emitter)

jaclang/vendor/mypyc/codegen/emitmodule.py

@@ -461,21 +461,21 @@ def compile_modules_to_c(
 
 
 def generate_function_declaration(fn: FuncIR, emitter: Emitter) -> None:
-    emitter.context.declarations[
-        emitter.native_function_name(fn.decl)
-    ] = HeaderDeclaration(
-        f"{native_function_header(fn.decl, emitter)};", needs_export=True
+    emitter.context.declarations[emitter.native_function_name(fn.decl)] = (
+        HeaderDeclaration(
+            f"{native_function_header(fn.decl, emitter)};", needs_export=True
+        )
     )
     if fn.name != TOP_LEVEL_NAME:
         if is_fastcall_supported(fn, emitter.capi_version):
-            emitter.context.declarations[
-                PREFIX + fn.cname(emitter.names)
-            ] = HeaderDeclaration(f"{wrapper_function_header(fn, emitter.names)};")
+            emitter.context.declarations[PREFIX + fn.cname(emitter.names)] = (
+                HeaderDeclaration(f"{wrapper_function_header(fn, emitter.names)};")
+            )
         else:
-            emitter.context.declarations[
-                PREFIX + fn.cname(emitter.names)
-            ] = HeaderDeclaration(
-                f"{legacy_wrapper_function_header(fn, emitter.names)};"
+            emitter.context.declarations[PREFIX + fn.cname(emitter.names)] = (
+                HeaderDeclaration(
+                    f"{legacy_wrapper_function_header(fn, emitter.names)};"
+                )
             )
 
 
@@ -1059,7 +1059,7 @@ class GroupGenerator:
             result.append(decl.declaration)
             decl.mark = True
 
-        for name, marked_declaration in marked_declarations.items():
+        for name in marked_declarations:
             _toposort_visit(name)
 
         return result

jaclang/vendor/mypyc/codegen/emitwrapper.py

@@ -165,7 +165,7 @@ def generate_wrapper_function(
     real_args = list(fn.args)
     if fn.sig.num_bitmap_args:
         real_args = real_args[: -fn.sig.num_bitmap_args]
-    if fn.class_name and not fn.decl.kind == FUNC_STATICMETHOD:
+    if fn.class_name and fn.decl.kind != FUNC_STATICMETHOD:
         arg = real_args.pop(0)
         emitter.emit_line(f"PyObject *obj_{arg.name} = self;")
 
@@ -264,7 +264,7 @@ def generate_legacy_wrapper_function(
     real_args = list(fn.args)
     if fn.sig.num_bitmap_args:
         real_args = real_args[: -fn.sig.num_bitmap_args]
-    if fn.class_name and not fn.decl.kind == FUNC_STATICMETHOD:
+    if fn.class_name and fn.decl.kind != FUNC_STATICMETHOD:
         arg = real_args.pop(0)
         emitter.emit_line(f"PyObject *obj_{arg.name} = self;")
 

jaclang/vendor/mypyc/ir/class_ir.py

@@ -388,9 +388,11 @@ class ClassIR:
             "traits": [cir.fullname for cir in self.traits],
             "mro": [cir.fullname for cir in self.mro],
             "base_mro": [cir.fullname for cir in self.base_mro],
-            "children": [cir.fullname for cir in self.children]
-            if self.children is not None
-            else None,
+            "children": (
+                [cir.fullname for cir in self.children]
+                if self.children is not None
+                else None
+            ),
             "deletable": self.deletable,
             "attrs_with_defaults": sorted(self.attrs_with_defaults),
             "_always_initialized_attrs": sorted(self._always_initialized_attrs),
@@ -418,9 +420,11 @@ class ClassIR:
         ir.ctor = FuncDecl.deserialize(data["ctor"], ctx)
         ir.attributes = {k: deserialize_type(t, ctx) for k, t in data["attributes"]}
         ir.method_decls = {
-            k: ctx.functions[v].decl
-            if isinstance(v, str)
-            else FuncDecl.deserialize(v, ctx)
+            k: (
+                ctx.functions[v].decl
+                if isinstance(v, str)
+                else FuncDecl.deserialize(v, ctx)
+            )
             for k, v in data["method_decls"]
         }
         ir.methods = {k: ctx.functions[v] for k, v in data["methods"]}

jaclang/vendor/mypyc/irbuild/builder.py

@@ -10,6 +10,7 @@ AST node type to code that actually does the bulk of the work. For
 example, expressions are transformed in mypyc.irbuild.expression and
 functions are transformed in mypyc.irbuild.function.
 """
+
 from __future__ import annotations
 
 from contextlib import contextmanager
@@ -241,12 +242,10 @@ class IRBuilder:
         self.builder.set_module(module_name, module_path)
 
     @overload
-    def accept(self, node: Expression, *, can_borrow: bool = False) -> Value:
-        ...
+    def accept(self, node: Expression, *, can_borrow: bool = False) -> Value: ...
 
     @overload
-    def accept(self, node: Statement) -> None:
-        ...
+    def accept(self, node: Statement) -> None: ...
 
     def accept(
         self, node: Statement | Expression, *, can_borrow: bool = False

jaclang/vendor/mypyc/irbuild/function.py

@@ -655,9 +655,11 @@ def get_args(builder: IRBuilder, rt_args: Sequence[RuntimeArg], line: int) -> Ar
         for var, type in fake_vars
     ]
     arg_names = [
-        arg.name
-        if arg.kind.is_named() or (arg.kind.is_optional() and not arg.pos_only)
-        else None
+        (
+            arg.name
+            if arg.kind.is_named() or (arg.kind.is_optional() and not arg.pos_only)
+            else None
+        )
         for arg in rt_args
     ]
     arg_kinds = [arg.kind for arg in rt_args]

jaclang/vendor/mypyc/irbuild/nonlocalcontrol.py

@@ -125,8 +125,7 @@ class CleanupNonlocalControl(NonlocalControl):
         self.outer = outer
 
     @abstractmethod
-    def gen_cleanup(self, builder: IRBuilder, line: int) -> None:
-        ...
+    def gen_cleanup(self, builder: IRBuilder, line: int) -> None: ...
 
     def gen_break(self, builder: IRBuilder, line: int) -> None:
         self.gen_cleanup(builder, line)

jaclang/vendor/mypyc/irbuild/prepare.py

@@ -156,7 +156,7 @@ def load_type_map(
 ) -> None:
     """Populate a Mapper with deserialized IR from a list of modules."""
     for module in modules:
-        for name, node in module.names.items():
+        for node in module.names.values():
             if isinstance(node.node, TypeInfo) and is_from_module(node.node, module):
                 ir = deser_ctx.classes[node.node.fullname]
                 mapper.type_to_ir[node.node] = ir
@@ -170,7 +170,7 @@ def load_type_map(
 
 def get_module_func_defs(module: MypyFile) -> Iterable[FuncDef]:
     """Collect all of the (non-method) functions declared in a module."""
-    for name, node in module.names.items():
+    for node in module.names.values():
         # We need to filter out functions that are imported or
         # aliases.  The best way to do this seems to be by
         # checking that the fullname matches.
@@ -513,7 +513,7 @@ def prepare_non_ext_class_def(
     ir = mapper.type_to_ir[cdef.info]
     info = cdef.info
 
-    for name, node in info.names.items():
+    for node in info.names.values():
         if isinstance(node.node, (FuncDef, Decorator)):
             prepare_method_def(ir, module_name, cdef, mapper, node.node)
         elif isinstance(node.node, OverloadedFuncDef):
@@ -569,9 +569,9 @@ class SingledispatchVisitor(TraverserVisitor):
         super().__init__()
 
         # Map of main singledispatch function to list of registered implementations
-        self.singledispatch_impls: defaultdict[
-            FuncDef, list[RegisterImplInfo]
-        ] = defaultdict(list)
+        self.singledispatch_impls: defaultdict[FuncDef, list[RegisterImplInfo]] = (
+            defaultdict(list)
+        )
 
         # Map of decorated function to the indices of any decorators to remove
         self.decorators_to_remove: dict[FuncDef, list[int]] = {}

jaclang/vendor/mypyc/primitives/registry.py

@@ -93,7 +93,7 @@ def method_op(
     var_arg_type: RType | None = None,
     truncated_type: RType | None = None,
     ordering: list[int] | None = None,
-    extra_int_constants: list[tuple[int, RType]] = [],
+    extra_int_constants: list[tuple[int, RType]] | None = None,
     steals: StealsDescription = False,
     is_borrowed: bool = False,
     priority: int = 1,
@@ -122,6 +122,8 @@ def method_op(
         is_borrowed: if True, returned value is borrowed (no need to decrease refcount)
         priority: if multiple ops match, the one with the highest priority is picked
     """
+    if extra_int_constants is None:
+        extra_int_constants = []
     ops = method_call_ops.setdefault(name, [])
     desc = CFunctionDescription(
         name,
@@ -150,7 +152,7 @@ def function_op(
     var_arg_type: RType | None = None,
     truncated_type: RType | None = None,
     ordering: list[int] | None = None,
-    extra_int_constants: list[tuple[int, RType]] = [],
+    extra_int_constants: list[tuple[int, RType]] | None = None,
     steals: StealsDescription = False,
     is_borrowed: bool = False,
     priority: int = 1,
@@ -165,6 +167,8 @@ def function_op(
         name: full name of the function
         arg_types: positional argument types for which this applies
     """
+    if extra_int_constants is None:
+        extra_int_constants = []
     ops = function_ops.setdefault(name, [])
     desc = CFunctionDescription(
         name,
@@ -193,7 +197,7 @@ def binary_op(
     var_arg_type: RType | None = None,
     truncated_type: RType | None = None,
     ordering: list[int] | None = None,
-    extra_int_constants: list[tuple[int, RType]] = [],
+    extra_int_constants: list[tuple[int, RType]] | None = None,
     steals: StealsDescription = False,
     is_borrowed: bool = False,
     priority: int = 1,
@@ -205,6 +209,8 @@ def binary_op(
     Most arguments are similar to method_op(), but exactly two argument types
     are expected.
     """
+    if extra_int_constants is None:
+        extra_int_constants = []
     ops = binary_ops.setdefault(name, [])
     desc = CFunctionDescription(
         name,
@@ -232,7 +238,7 @@ def custom_op(
     var_arg_type: RType | None = None,
     truncated_type: RType | None = None,
     ordering: list[int] | None = None,
-    extra_int_constants: list[tuple[int, RType]] = [],
+    extra_int_constants: list[tuple[int, RType]] | None = None,
     steals: StealsDescription = False,
     is_borrowed: bool = False,
 ) -> CFunctionDescription:
@@ -240,6 +246,8 @@ def custom_op(
 
     Most arguments are similar to method_op().
     """
+    if extra_int_constants is None:
+        extra_int_constants = []
     return CFunctionDescription(
         "<custom>",
         arg_types,
@@ -264,7 +272,7 @@ def unary_op(
     error_kind: int,
     truncated_type: RType | None = None,
     ordering: list[int] | None = None,
-    extra_int_constants: list[tuple[int, RType]] = [],
+    extra_int_constants: list[tuple[int, RType]] | None = None,
     steals: StealsDescription = False,
     is_borrowed: bool = False,
     priority: int = 1,
@@ -276,6 +284,8 @@ def unary_op(
     Most arguments are similar to method_op(), but exactly one argument type
     is expected.
     """
+    if extra_int_constants is None:
+        extra_int_constants = []
     ops = unary_ops.setdefault(name, [])
     desc = CFunctionDescription(
         name,

jaclang/vendor/mypyc/test/test_run.py

@@ -15,7 +15,7 @@ from typing import Any, Iterator
 
 from mypy import build
 from mypy.errors import CompileError
-from mypy.options import TYPE_VAR_TUPLE, UNPACK, Options
+from mypy.options import Options
 from mypy.test.config import test_temp_dir
 from mypy.test.data import DataDrivenTestCase
 from mypy.test.helpers import assert_module_equivalence, perform_file_operations
@@ -198,7 +198,6 @@ class TestRun(MypycDataSuite):
         options.preserve_asts = True
         options.allow_empty_bodies = True
         options.incremental = self.separate
-        options.enable_incomplete_feature = [TYPE_VAR_TUPLE, UNPACK]
 
         # Avoid checking modules/packages named 'unchecked', to provide a way
         # to test interacting with code we don't have types for.

jaclang/vendor/mypyc/transform/uninit.py

@@ -75,9 +75,9 @@ def split_blocks_at_uninits(
                     and not isinstance(op, LoadAddress)
                 ):
                     new_block, error_block = BasicBlock(), BasicBlock()
-                    new_block.error_handler = (
-                        error_block.error_handler
-                    ) = cur_block.error_handler
+                    new_block.error_handler = error_block.error_handler = (
+                        cur_block.error_handler
+                    )
                     new_blocks += [error_block, new_block]
 
                     if src not in init_registers_set:

jaclang/vendor/pluggy/_callers.py

@@ -1,6 +1,7 @@
 """
 Call loop machinery
 """
+
 from __future__ import annotations
 
 from typing import cast