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

jaclang/vendor/mypy/fixup.py

@@ -47,9 +47,7 @@ from mypy.visitor import NodeVisitor
 # N.B: we do a allow_missing fixup when fixing up a fine-grained
 # incremental cache load (since there may be cross-refs into deleted
 # modules)
-def fixup_module(
-    tree: MypyFile, modules: dict[str, MypyFile], allow_missing: bool
-) -> None:
+def fixup_module(tree: MypyFile, modules: dict[str, MypyFile], allow_missing: bool) -> None:
     node_fixer = NodeFixer(modules, allow_missing)
     node_fixer.visit_symbol_table(tree.names, tree.fullname)
 
@@ -145,10 +143,7 @@ class NodeFixer(NodeVisitor[None]):
                             # as it would stop dependency propagation.
                             value.node = Var(key + "@deleted")
                         else:
-                            assert stnode.node is not None, (
-                                table_fullname + "." + key,
-                                cross_ref,
-                            )
+                            assert stnode.node is not None, (table_fullname + "." + key, cross_ref)
                             value.node = stnode.node
                     elif not self.allow_missing:
                         assert False, f"Could not find cross-ref {cross_ref}"
@@ -275,6 +270,8 @@ class TypeFixer(TypeVisitor[None]):
                 arg.accept(self)
         if ct.type_guard is not None:
             ct.type_guard.accept(self)
+        if ct.type_is is not None:
+            ct.type_is.accept(self)
 
     def visit_overloaded(self, t: Overloaded) -> None:
         for ct in t.items:
@@ -420,9 +417,7 @@ def missing_info(modules: dict[str, MypyFile]) -> TypeInfo:
     dummy_def.fullname = suggestion
 
     info = TypeInfo(SymbolTable(), dummy_def, "<missing>")
-    obj_type = lookup_fully_qualified_typeinfo(
-        modules, "builtins.object", allow_missing=False
-    )
+    obj_type = lookup_fully_qualified_typeinfo(modules, "builtins.object", allow_missing=False)
     info.bases = [Instance(obj_type, [])]
     info.mro = [info, obj_type]
     return info

jaclang/vendor/mypy/indirection.py

@@ -64,9 +64,7 @@ class TypeIndirectionVisitor(TypeVisitor[Set[str]]):
         return set()
 
     def visit_type_var(self, t: types.TypeVarType) -> set[str]:
-        return (
-            self._visit(t.values) | self._visit(t.upper_bound) | self._visit(t.default)
-        )
+        return self._visit(t.values) | self._visit(t.upper_bound) | self._visit(t.default)
 
     def visit_param_spec(self, t: types.ParamSpecType) -> set[str]:
         return self._visit(t.upper_bound) | self._visit(t.default)

jaclang/vendor/mypy/infer.py

@@ -71,9 +71,5 @@ def infer_type_arguments(
 ) -> list[Type | None]:
     # Like infer_function_type_arguments, but only match a single type
     # against a generic type.
-    constraints = infer_constraints(
-        template, actual, SUPERTYPE_OF if is_supertype else SUBTYPE_OF
-    )
-    return solve_constraints(type_vars, constraints, skip_unsatisfied=skip_unsatisfied)[
-        0
-    ]
+    constraints = infer_constraints(template, actual, SUPERTYPE_OF if is_supertype else SUBTYPE_OF)
+    return solve_constraints(type_vars, constraints, skip_unsatisfied=skip_unsatisfied)[0]

jaclang/vendor/mypy/inspections.py

@@ -505,11 +505,7 @@ class InspectionEngine:
 
         if expression is None:
             span = f"{line}:{column}:{end_line}:{end_column}"
-            return {
-                "out": f"Can't find expression at span {span}",
-                "err": "",
-                "status": 1,
-            }
+            return {"out": f"Can't find expression at span {span}", "err": "", "status": 1}
 
         inspection_str, success = method(expression)
         return {"out": inspection_str, "err": "", "status": 0 if success else 1}
@@ -557,17 +553,11 @@ class InspectionEngine:
         # We are using a bit slower but robust way to find a module by path,
         # to be sure that namespace packages are handled properly.
         abs_path = os.path.abspath(file)
-        state = next(
-            (s for s in self.fg_manager.graph.values() if s.abspath == abs_path), None
-        )
+        state = next((s for s in self.fg_manager.graph.values() if s.abspath == abs_path), None)
         self.module = state
         return (
             state,
-            (
-                {"out": f"Unknown module: {file}", "err": "", "status": 1}
-                if state is None
-                else {}
-            ),
+            {"out": f"Unknown module: {file}", "err": "", "status": 1} if state is None else {},
         )
 
     def run_inspection(

jaclang/vendor/mypy/ipc.py

@@ -79,11 +79,7 @@ class IPCBase:
                 ov, err = _winapi.ReadFile(self.connection, size, overlapped=True)
                 try:
                     if err == _winapi.ERROR_IO_PENDING:
-                        timeout = (
-                            int(self.timeout * 1000)
-                            if self.timeout
-                            else _winapi.INFINITE
-                        )
+                        timeout = int(self.timeout * 1000) if self.timeout else _winapi.INFINITE
                         res = _winapi.WaitForSingleObject(ov.event, timeout)
                         if res != _winapi.WAIT_OBJECT_0:
                             raise IPCException(f"Bad result from I/O wait: {res}")
@@ -134,16 +130,10 @@ class IPCBase:
 
         if sys.platform == "win32":
             try:
-                ov, err = _winapi.WriteFile(
-                    self.connection, encoded_data, overlapped=True
-                )
+                ov, err = _winapi.WriteFile(self.connection, encoded_data, overlapped=True)
                 try:
                     if err == _winapi.ERROR_IO_PENDING:
-                        timeout = (
-                            int(self.timeout * 1000)
-                            if self.timeout
-                            else _winapi.INFINITE
-                        )
+                        timeout = int(self.timeout * 1000) if self.timeout else _winapi.INFINITE
                         res = _winapi.WaitForSingleObject(ov.event, timeout)
                         if res != _winapi.WAIT_OBJECT_0:
                             raise IPCException(f"Bad result from I/O wait: {res}")
@@ -174,17 +164,11 @@ class IPCClient(IPCBase):
     def __init__(self, name: str, timeout: float | None) -> None:
         super().__init__(name, timeout)
         if sys.platform == "win32":
-            timeout = (
-                int(self.timeout * 1000)
-                if self.timeout
-                else _winapi.NMPWAIT_WAIT_FOREVER
-            )
+            timeout = int(self.timeout * 1000) if self.timeout else _winapi.NMPWAIT_WAIT_FOREVER
             try:
                 _winapi.WaitNamedPipe(self.name, timeout)
             except FileNotFoundError as e:
-                raise IPCException(
-                    f"The NamedPipe at {self.name} was not found."
-                ) from e
+                raise IPCException(f"The NamedPipe at {self.name} was not found.") from e
             except OSError as e:
                 if e.winerror == _winapi.ERROR_SEM_TIMEOUT:
                     raise IPCException("Timed out waiting for connection.") from e
@@ -272,16 +256,11 @@ class IPCServer(IPCBase):
                 ov = _winapi.ConnectNamedPipe(self.connection, overlapped=True)
             except OSError as e:
                 # Don't raise if the client already exists, or the client already connected
-                if e.winerror not in (
-                    _winapi.ERROR_PIPE_CONNECTED,
-                    _winapi.ERROR_NO_DATA,
-                ):
+                if e.winerror not in (_winapi.ERROR_PIPE_CONNECTED, _winapi.ERROR_NO_DATA):
                     raise
             else:
                 try:
-                    timeout = (
-                        int(self.timeout * 1000) if self.timeout else _winapi.INFINITE
-                    )
+                    timeout = int(self.timeout * 1000) if self.timeout else _winapi.INFINITE
                     res = _winapi.WaitForSingleObject(ov.event, timeout)
                     assert res == _winapi.WAIT_OBJECT_0
                 except BaseException:

jaclang/vendor/mypy/join.py

@@ -81,12 +81,8 @@ class InstanceJoiner:
                 tvt = s.type.defn.type_vars[prefix]
                 assert isinstance(tvt, TypeVarTupleType)
                 fallback = tvt.tuple_fallback
-                s_prefix, s_middle, s_suffix = split_with_prefix_and_suffix(
-                    s.args, prefix, suffix
-                )
-                t_prefix, t_middle, t_suffix = split_with_prefix_and_suffix(
-                    t.args, prefix, suffix
-                )
+                s_prefix, s_middle, s_suffix = split_with_prefix_and_suffix(s.args, prefix, suffix)
+                t_prefix, t_middle, t_suffix = split_with_prefix_and_suffix(t.args, prefix, suffix)
                 s_args = s_prefix + (TupleType(list(s_middle), fallback),) + s_suffix
                 t_args = t_prefix + (TupleType(list(t_middle), fallback),) + t_suffix
             else:
@@ -103,10 +99,7 @@ class InstanceJoiner:
                 elif isinstance(type_var, TypeVarType):
                     if type_var.variance == COVARIANT:
                         new_type = join_types(ta, sa, self)
-                        if (
-                            len(type_var.values) != 0
-                            and new_type not in type_var.values
-                        ):
+                        if len(type_var.values) != 0 and new_type not in type_var.values:
                             self.seen_instances.pop()
                             return object_from_instance(t)
                         if not is_subtype(new_type, type_var.upper_bound):
@@ -115,12 +108,17 @@ class InstanceJoiner:
                     # TODO: contravariant case should use meet but pass seen instances as
                     # an argument to keep track of recursive checks.
                     elif type_var.variance in (INVARIANT, CONTRAVARIANT):
-                        if not is_equivalent(ta, sa):
+                        if isinstance(ta_proper, UninhabitedType) and not ta_proper.is_noreturn:
+                            new_type = sa
+                        elif isinstance(sa_proper, UninhabitedType) and not sa_proper.is_noreturn:
+                            new_type = ta
+                        elif not is_equivalent(ta, sa):
                             self.seen_instances.pop()
                             return object_from_instance(t)
-                        # If the types are different but equivalent, then an Any is involved
-                        # so using a join in the contravariant case is also OK.
-                        new_type = join_types(ta, sa, self)
+                        else:
+                            # If the types are different but equivalent, then an Any is involved
+                            # so using a join in the contravariant case is also OK.
+                            new_type = join_types(ta, sa, self)
                 elif isinstance(type_var, TypeVarTupleType):
                     new_type = get_proper_type(join_types(ta, sa, self))
                     # Put the joined arguments back into instance in the normal form:
@@ -248,9 +246,7 @@ def join_types(
 
 
 @overload
-def join_types(
-    s: Type, t: Type, instance_joiner: InstanceJoiner | None = None
-) -> Type: ...
+def join_types(s: Type, t: Type, instance_joiner: InstanceJoiner | None = None) -> Type: ...
 
 
 def join_types(s: Type, t: Type, instance_joiner: InstanceJoiner | None = None) -> Type:
@@ -299,9 +295,7 @@ class TypeJoinVisitor(TypeVisitor[ProperType]):
       s: The other (left) type operand.
     """
 
-    def __init__(
-        self, s: ProperType, instance_joiner: InstanceJoiner | None = None
-    ) -> None:
+    def __init__(self, s: ProperType, instance_joiner: InstanceJoiner | None = None) -> None:
         self.s = s
         self.instance_joiner = instance_joiner
 
@@ -364,8 +358,7 @@ class TypeJoinVisitor(TypeVisitor[ProperType]):
 
             return t.copy_modified(
                 arg_types=[
-                    meet_types(s_a, t_a)
-                    for s_a, t_a in zip(self.s.arg_types, t.arg_types)
+                    meet_types(s_a, t_a) for s_a, t_a in zip(self.s.arg_types, t.arg_types)
                 ],
                 arg_names=combine_arg_names(self.s, t),
             )
@@ -522,10 +515,7 @@ class TypeJoinVisitor(TypeVisitor[ProperType]):
                 joined = join_types(s_unpacked, t_unpacked)
                 if isinstance(joined, TypeVarTupleType):
                     items.append(UnpackType(joined))
-                elif (
-                    isinstance(joined, Instance)
-                    and joined.type.fullname == "builtins.tuple"
-                ):
+                elif isinstance(joined, Instance) and joined.type.fullname == "builtins.tuple":
                     items.append(UnpackType(joined))
                 else:
                     if isinstance(t_unpacked, Instance):
@@ -549,10 +539,7 @@ class TypeJoinVisitor(TypeVisitor[ProperType]):
                 # Another case we can handle is when one of tuple is purely variadic
                 # (i.e. a non-normalized form of tuple[X, ...]), in this case the join
                 # will be again purely variadic.
-                if not (
-                    isinstance(s_unpacked, Instance)
-                    and isinstance(t_unpacked, Instance)
-                ):
+                if not (isinstance(s_unpacked, Instance) and isinstance(t_unpacked, Instance)):
                     return None
                 assert s_unpacked.type.fullname == "builtins.tuple"
                 assert t_unpacked.type.fullname == "builtins.tuple"
@@ -638,8 +625,7 @@ class TypeJoinVisitor(TypeVisitor[ProperType]):
                 for (item_name, s_item_type, t_item_type) in self.s.zip(t)
                 if (
                     is_equivalent(s_item_type, t_item_type)
-                    and (item_name in t.required_keys)
-                    == (item_name in self.s.required_keys)
+                    and (item_name in t.required_keys) == (item_name in self.s.required_keys)
                 )
             }
             fallback = self.s.create_anonymous_fallback()
@@ -669,9 +655,7 @@ class TypeJoinVisitor(TypeVisitor[ProperType]):
 
     def visit_type_type(self, t: TypeType) -> ProperType:
         if isinstance(self.s, TypeType):
-            return TypeType.make_normalized(
-                join_types(t.item, self.s.item), line=t.line
-            )
+            return TypeType.make_normalized(join_types(t.item, self.s.item), line=t.line)
         elif isinstance(self.s, Instance) and self.s.type.fullname == "builtins.type":
             return self.s
         else:
@@ -777,10 +761,7 @@ def safe_meet(t: Type, s: Type) -> Type:
         elif isinstance(unpacked, TupleType):
             fallback_type = unpacked.partial_fallback.type
         else:
-            assert (
-                isinstance(unpacked, Instance)
-                and unpacked.type.fullname == "builtins.tuple"
-            )
+            assert isinstance(unpacked, Instance) and unpacked.type.fullname == "builtins.tuple"
             fallback_type = unpacked.type
         res = meet_types(t.type, s.type)
         if isinstance(res, UninhabitedType):

jaclang/vendor/mypy/literals.py

@@ -115,11 +115,7 @@ def literal(e: Expression) -> int:
             return LITERAL_NO
 
     elif isinstance(e, NameExpr):
-        if (
-            isinstance(e.node, Var)
-            and e.node.is_final
-            and e.node.final_value is not None
-        ):
+        if isinstance(e.node, Var) and e.node.is_final and e.node.final_value is not None:
             return LITERAL_YES
         return LITERAL_TYPE
 
@@ -173,11 +169,7 @@ class _Hasher(ExpressionVisitor[Optional[Key]]):
         return ("Star", literal_hash(e.expr))
 
     def visit_name_expr(self, e: NameExpr) -> Key:
-        if (
-            isinstance(e.node, Var)
-            and e.node.is_final
-            and e.node.final_value is not None
-        ):
+        if isinstance(e.node, Var) and e.node.is_final and e.node.final_value is not None:
             return ("Literal", e.node.final_value)
         # N.B: We use the node itself as the key, and not the name,
         # because using the name causes issues when there is shadowing