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

jaclang/vendor/mypy/stubdoc.py

@@ -351,7 +351,7 @@ class DocStringParser:
             return has_arg("*args", signature) and has_arg("**kwargs", signature)
 
         # Move functions with (*args, **kwargs) in their signature to last place.
-        return list(sorted(self.signatures, key=lambda x: 1 if args_kwargs(x) else 0))
+        return sorted(self.signatures, key=lambda x: 1 if args_kwargs(x) else 0)
 
 
 def infer_sig_from_docstring(docstr: str | None, name: str) -> list[FunctionSig] | None:

jaclang/vendor/mypy/stubgen.py

@@ -22,7 +22,7 @@ Basic usage:
   => Generate out/urllib/parse.pyi.
 
   $ stubgen -p urllib
-  => Generate stubs for whole urlib package (recursively).
+  => Generate stubs for whole urllib package (recursively).
 
 For C modules, you can get more precise function signatures by parsing .rst (Sphinx)
 documentation for extra information. For this, use the --doc-dir option:
@@ -312,6 +312,13 @@ class AliasPrinter(NodeVisitor[str]):
         return repr(node.value)
 
     def visit_index_expr(self, node: IndexExpr) -> str:
+        base_fullname = self.stubgen.get_fullname(node.base)
+        if base_fullname == "typing.Union":
+            if isinstance(node.index, TupleExpr):
+                return " | ".join([item.accept(self) for item in node.index.items])
+            return node.index.accept(self)
+        if base_fullname == "typing.Optional":
+            return f"{node.index.accept(self)} | None"
         base = node.base.accept(self)
         index = node.index.accept(self)
         if len(index) > 2 and index.startswith("(") and index.endswith(")"):
@@ -706,11 +713,11 @@ class ASTStubGenerator(BaseStubGenerator, mypy.traverser.TraverserVisitor):
             elif fullname in OVERLOAD_NAMES:
                 self.add_decorator(qualname, require_name=True)
                 o.func.is_overload = True
-            elif qualname.endswith(".setter"):
+            elif qualname.endswith((".setter", ".deleter")):
                 self.add_decorator(qualname, require_name=False)
 
     def get_fullname(self, expr: Expression) -> str:
-        """Return the full name resolving imports and import aliases."""
+        """Return the expression's full name."""
         if (
             self.analyzed
             and isinstance(expr, (NameExpr, MemberExpr))
@@ -719,22 +726,7 @@ class ASTStubGenerator(BaseStubGenerator, mypy.traverser.TraverserVisitor):
         ):
             return expr.fullname
         name = get_qualified_name(expr)
-        if "." not in name:
-            real_module = self.import_tracker.module_for.get(name)
-            real_short = self.import_tracker.reverse_alias.get(name, name)
-            if real_module is None and real_short not in self.defined_names:
-                real_module = (
-                    "builtins"  # not imported and not defined, must be a builtin
-                )
-        else:
-            name_module, real_short = name.split(".", 1)
-            real_module = self.import_tracker.reverse_alias.get(
-                name_module, name_module
-            )
-        resolved_name = (
-            real_short if real_module is None else f"{real_module}.{real_short}"
-        )
-        return resolved_name
+        return self.resolve_name(name)
 
     def visit_class_def(self, o: ClassDef) -> None:
         self._current_class = o
@@ -1921,8 +1913,7 @@ def parse_options(args: list[str]) -> Options:
         )
 
     # Create the output folder if it doesn't already exist.
-    if not os.path.exists(ns.output_dir):
-        os.makedirs(ns.output_dir)
+    os.makedirs(ns.output_dir, exist_ok=True)
 
     return Options(
         pyversion=pyversion,

jaclang/vendor/mypy/stubgenc.py

@@ -43,7 +43,7 @@ class ExternalSignatureGenerator(SignatureGenerator):
         self,
         func_sigs: dict[str, str] | None = None,
         class_sigs: dict[str, str] | None = None,
-    ):
+    ) -> None:
         """
         Takes a mapping of function/method names to signatures and class name to
         class signatures (usually corresponds to __init__).
@@ -197,7 +197,7 @@ class CFunctionStub:
     Class that mimics a C function in order to provide parseable docstrings.
     """
 
-    def __init__(self, name: str, doc: str, is_abstract: bool = False):
+    def __init__(self, name: str, doc: str, is_abstract: bool = False) -> None:
         self.__name__ = name
         self.__doc__ = doc
         self.__abstractmethod__ = is_abstract
@@ -423,7 +423,7 @@ class InspectionStubGenerator(BaseStubGenerator):
                         self.import_tracker.reexport(name)
 
         self.set_defined_names(
-            set([name for name, obj in all_items if not inspect.ismodule(obj)])
+            {name for name, obj in all_items if not inspect.ismodule(obj)}
         )
 
         if self.resort_members:
@@ -552,10 +552,16 @@ class InspectionStubGenerator(BaseStubGenerator):
     def is_staticmethod(
         self, class_info: ClassInfo | None, name: str, obj: object
     ) -> bool:
-        if self.is_c_module:
+        if class_info is None:
             return False
+        elif self.is_c_module:
+            raw_lookup: Mapping[str, Any] = getattr(
+                class_info.cls, "__dict__"
+            )  # noqa: B009
+            raw_value = raw_lookup.get(name, obj)
+            return isinstance(raw_value, staticmethod)
         else:
-            return class_info is not None and isinstance(
+            return isinstance(
                 inspect.getattr_static(class_info.cls, name), staticmethod
             )
 
@@ -798,11 +804,11 @@ class InspectionStubGenerator(BaseStubGenerator):
         The result lines will be appended to 'output'. If necessary, any
         required names will be added to 'imports'.
         """
-        raw_lookup = getattr(cls, "__dict__")  # noqa: B009
+        raw_lookup: Mapping[str, Any] = getattr(cls, "__dict__")  # noqa: B009
         items = self.get_members(cls)
         if self.resort_members:
             items = sorted(items, key=lambda x: method_name_sort_key(x[0]))
-        names = set(x[0] for x in items)
+        names = {x[0] for x in items}
         methods: list[str] = []
         types: list[str] = []
         static_properties: list[str] = []
@@ -830,7 +836,9 @@ class InspectionStubGenerator(BaseStubGenerator):
                         continue
                     attr = "__init__"
                 # FIXME: make this nicer
-                if self.is_classmethod(class_info, attr, value):
+                if self.is_staticmethod(class_info, attr, value):
+                    class_info.self_var = ""
+                elif self.is_classmethod(class_info, attr, value):
                     class_info.self_var = "cls"
                 else:
                     class_info.self_var = "self"

jaclang/vendor/mypy/stubtest.py

@@ -10,6 +10,7 @@ import argparse
 import collections.abc
 import copy
 import enum
+import functools
 import importlib
 import importlib.machinery
 import inspect
@@ -317,47 +318,31 @@ def _verify_exported_names(
         stub_object=MISSING,
         runtime_object=MISSING,
         stub_desc=(
-            f"Names exported in the stub but not at runtime: "
-            f"{names_in_stub_not_runtime}"
+            f"Names exported in the stub but not at runtime: {names_in_stub_not_runtime}"
         ),
         runtime_desc=(
-            f"Names exported at runtime but not in the stub: "
-            f"{names_in_runtime_not_stub}"
+            f"Names exported at runtime but not in the stub: {names_in_runtime_not_stub}"
         ),
     )
 
 
-def _get_imported_symbol_names(runtime: types.ModuleType) -> frozenset[str] | None:
-    """Retrieve the names in the global namespace which are known to be imported.
+@functools.lru_cache
+def _module_symbol_table(runtime: types.ModuleType) -> symtable.SymbolTable | None:
+    """Retrieve the symbol table for the module (or None on failure).
 
-    1). Use inspect to retrieve the source code of the module
-    2). Use symtable to parse the source and retrieve names that are known to be imported
-        from other modules.
-
-    If either of the above steps fails, return `None`.
-
-    Note that if a set of names is returned,
-    it won't include names imported via `from foo import *` imports.
+    1) Use inspect to retrieve the source code of the module
+    2) Use symtable to parse the source (and use what symtable knows for its purposes)
     """
     try:
         source = inspect.getsource(runtime)
     except (OSError, TypeError, SyntaxError):
         return None
 
-    if not source.strip():
-        # The source code for the module was an empty file,
-        # no point in parsing it with symtable
-        return frozenset()
-
     try:
-        module_symtable = symtable.symtable(source, runtime.__name__, "exec")
+        return symtable.symtable(source, runtime.__name__, "exec")
     except SyntaxError:
         return None
 
-    return frozenset(
-        sym.get_name() for sym in module_symtable.get_symbols() if sym.is_imported()
-    )
-
 
 @verify.register(nodes.MypyFile)
 def verify_mypyfile(
@@ -390,25 +375,37 @@ def verify_mypyfile(
         if not o.module_hidden and (not is_probably_private(m) or hasattr(runtime, m))
     }
 
-    imported_symbols = _get_imported_symbol_names(runtime)
-
     def _belongs_to_runtime(r: types.ModuleType, attr: str) -> bool:
         """Heuristics to determine whether a name originates from another module."""
         obj = getattr(r, attr)
         if isinstance(obj, types.ModuleType):
             return False
-        if callable(obj):
-            # It's highly likely to be a class or a function if it's callable,
-            # so the __module__ attribute will give a good indication of which module it comes from
+
+        symbol_table = _module_symbol_table(r)
+        if symbol_table is not None:
             try:
-                obj_mod = obj.__module__
-            except Exception:
+                symbol = symbol_table.lookup(attr)
+            except KeyError:
                 pass
             else:
-                if isinstance(obj_mod, str):
-                    return bool(obj_mod == r.__name__)
-        if imported_symbols is not None:
-            return attr not in imported_symbols
+                if symbol.is_imported():
+                    # symtable says we got this from another module
+                    return False
+                # But we can't just return True here, because symtable doesn't know about symbols
+                # that come from `from module import *`
+                if symbol.is_assigned():
+                    # symtable knows we assigned this symbol in the module
+                    return True
+
+        # The __module__ attribute is unreliable for anything except functions and classes,
+        # but it's our best guess at this point
+        try:
+            obj_mod = obj.__module__
+        except Exception:
+            pass
+        else:
+            if isinstance(obj_mod, str):
+                return bool(obj_mod == r.__name__)
         return True
 
     runtime_public_contents = (
@@ -713,7 +710,7 @@ def _verify_arg_default_value(
                 runtime_type is not None
                 and stub_type is not None
                 # Avoid false positives for marker objects
-                and type(runtime_arg.default) != object
+                and type(runtime_arg.default) is not object
                 # And ellipsis
                 and runtime_arg.default is not ...
                 and not is_subtype_helper(runtime_type, stub_type)
@@ -875,7 +872,10 @@ class Signature(Generic[T]):
                 # argument. To accomplish this, we just make up a fake index-based name.
                 name = (
                     f"__{index}"
-                    if arg.variable.name.startswith("__") or assume_positional_only
+                    if arg.variable.name.startswith("__")
+                    or arg.pos_only
+                    or assume_positional_only
+                    or arg.variable.name.strip("_") == "self"
                     else arg.variable.name
                 )
                 all_args.setdefault(name, []).append((arg, index))
@@ -920,6 +920,7 @@ class Signature(Generic[T]):
                 type_annotation=None,
                 initializer=None,
                 kind=get_kind(arg_name),
+                pos_only=all(arg.pos_only for arg, _ in all_args[arg_name]),
             )
             if arg.kind.is_positional():
                 sig.pos.append(arg)
@@ -947,7 +948,7 @@ def _verify_signature(
             runtime_arg.kind == inspect.Parameter.POSITIONAL_ONLY
             and not stub_arg.pos_only
             and not stub_arg.variable.name.startswith("__")
-            and not stub_arg.variable.name.strip("_") == "self"
+            and stub_arg.variable.name.strip("_") != "self"
             and not is_dunder(
                 function_name, exclude_special=True
             )  # noisy for dunder methods
@@ -959,6 +960,7 @@ def _verify_signature(
         if (
             runtime_arg.kind != inspect.Parameter.POSITIONAL_ONLY
             and (stub_arg.pos_only or stub_arg.variable.name.startswith("__"))
+            and stub_arg.variable.name.strip("_") != "self"
             and not is_dunder(
                 function_name, exclude_special=True
             )  # noisy for dunder methods
@@ -1153,6 +1155,13 @@ def verify_var(
             runtime_type = get_mypy_type_of_runtime_value(runtime.value)
             if runtime_type is not None and is_subtype_helper(runtime_type, stub.type):
                 should_error = False
+            # We always allow setting the stub value to ...
+            proper_type = mypy.types.get_proper_type(stub.type)
+            if (
+                isinstance(proper_type, mypy.types.Instance)
+                and proper_type.type.fullname == "builtins.ellipsis"
+            ):
+                should_error = False
 
         if should_error:
             yield Error(
@@ -1603,9 +1612,11 @@ def safe_inspect_signature(runtime: Any) -> inspect.Signature | None:
                 sig = inspect._signature_fromstr(inspect.Signature, runtime, sig)  # type: ignore[attr-defined]
                 assert isinstance(sig, inspect.Signature)
                 new_params = [
-                    parameter.replace(default=UNREPRESENTABLE)
-                    if parameter.default is ...
-                    else parameter
+                    (
+                        parameter.replace(default=UNREPRESENTABLE)
+                        if parameter.default is ...
+                        else parameter
+                    )
                     for parameter in sig.parameters.values()
                 ]
                 return sig.replace(parameters=new_params)
@@ -1872,9 +1883,9 @@ def get_importable_stdlib_modules() -> set[str]:
         all_stdlib_modules = sys.stdlib_module_names
     else:
         all_stdlib_modules = set(sys.builtin_module_names)
-        modules_by_finder: defaultdict[
-            importlib.machinery.FileFinder, set[str]
-        ] = defaultdict(set)
+        modules_by_finder: defaultdict[importlib.machinery.FileFinder, set[str]] = (
+            defaultdict(set)
+        )
         for m in pkgutil.iter_modules():
             if isinstance(m.module_finder, importlib.machinery.FileFinder):
                 modules_by_finder[m.module_finder].add(m.name)
@@ -1924,10 +1935,8 @@ def get_importable_stdlib_modules() -> set[str]:
             # test.* modules do weird things like raising exceptions in __del__ methods,
             # leading to unraisable exceptions being logged to the terminal
             # as a warning at the end of the stubtest run
-            if (
-                submodule_name.endswith(".__main__")
-                or submodule_name.startswith("idlelib.")
-                or submodule_name.startswith("test.")
+            if submodule_name.endswith(".__main__") or submodule_name.startswith(
+                ("idlelib.", "test.")
             ):
                 continue
 

jaclang/vendor/mypy/stubutil.py

@@ -148,13 +148,11 @@ def fail_missing(mod: str, reason: ModuleNotFoundReason) -> None:
 
 
 @overload
-def remove_misplaced_type_comments(source: bytes) -> bytes:
-    ...
+def remove_misplaced_type_comments(source: bytes) -> bytes: ...
 
 
 @overload
-def remove_misplaced_type_comments(source: str) -> str:
-    ...
+def remove_misplaced_type_comments(source: str) -> str: ...
 
 
 def remove_misplaced_type_comments(source: str | bytes) -> str | bytes:
@@ -236,6 +234,11 @@ class AnnotationPrinter(TypeStrVisitor):
 
     def visit_unbound_type(self, t: UnboundType) -> str:
         s = t.name
+        fullname = self.stubgen.resolve_name(s)
+        if fullname == "typing.Union":
+            return " | ".join([item.accept(self) for item in t.args])
+        if fullname == "typing.Optional":
+            return f"{t.args[0].accept(self)} | None"
         if self.known_modules is not None and "." in s:
             # see if this object is from any of the modules that we're currently processing.
             # reverse sort so that subpackages come before parents: e.g. "foo.bar" before "foo".
@@ -515,9 +518,9 @@ class ImportTracker:
 
         for name in sorted(
             self.required_names,
-            key=lambda n: (self.reverse_alias[n], n)
-            if n in self.reverse_alias
-            else (n, ""),
+            key=lambda n: (
+                (self.reverse_alias[n], n) if n in self.reverse_alias else (n, "")
+            ),
         ):
             # If we haven't seen this name in an import statement, ignore it
             if name not in self.module_for:
@@ -593,7 +596,7 @@ class BaseStubGenerator:
         include_private: bool = False,
         export_less: bool = False,
         include_docstrings: bool = False,
-    ):
+    ) -> None:
         # Best known value of __all__.
         self._all_ = _all_
         self._include_private = include_private
@@ -623,14 +626,24 @@ class BaseStubGenerator:
     def get_sig_generators(self) -> list[SignatureGenerator]:
         return []
 
-    def refers_to_fullname(self, name: str, fullname: str | tuple[str, ...]) -> bool:
-        """Return True if the variable name identifies the same object as the given fullname(s)."""
-        if isinstance(fullname, tuple):
-            return any(self.refers_to_fullname(name, fname) for fname in fullname)
-        module, short = fullname.rsplit(".", 1)
-        return self.import_tracker.module_for.get(name) == module and (
-            name == short or self.import_tracker.reverse_alias.get(name) == short
+    def resolve_name(self, name: str) -> str:
+        """Return the full name resolving imports and import aliases."""
+        if "." not in name:
+            real_module = self.import_tracker.module_for.get(name)
+            real_short = self.import_tracker.reverse_alias.get(name, name)
+            if real_module is None and real_short not in self.defined_names:
+                real_module = (
+                    "builtins"  # not imported and not defined, must be a builtin
+                )
+        else:
+            name_module, real_short = name.split(".", 1)
+            real_module = self.import_tracker.reverse_alias.get(
+                name_module, name_module
+            )
+        resolved_name = (
+            real_short if real_module is None else f"{real_module}.{real_short}"
         )
+        return resolved_name
 
     def add_name(self, fullname: str, require: bool = True) -> str:
         """Add a name to be imported and return the name reference.

jaclang/vendor/mypy/subtypes.py

@@ -746,10 +746,10 @@ class SubtypeVisitor(TypeVisitor[bool]):
                 is_proper_subtype=self.proper_subtype,
                 ignore_pos_arg_names=self.subtype_context.ignore_pos_arg_names,
                 strict_concatenate=(
-                    self.options.extra_checks or self.options.strict_concatenate
-                )
-                if self.options
-                else False,
+                    (self.options.extra_checks or self.options.strict_concatenate)
+                    if self.options
+                    else False
+                ),
             )
         elif isinstance(right, Overloaded):
             return all(self._is_subtype(left, item) for item in right.items)

jaclang/vendor/mypy/test/helpers.py

@@ -157,7 +157,7 @@ def assert_module_equivalence(
         expected_normalized,
         actual_normalized,
         (
-            "Actual modules ({}) do not match expected modules ({}) " 'for "[{} ...]"'
+            'Actual modules ({}) do not match expected modules ({}) for "[{} ...]"'
         ).format(", ".join(actual_normalized), ", ".join(expected_normalized), name),
     )
 
@@ -170,7 +170,7 @@ def assert_target_equivalence(
         expected,
         actual,
         (
-            "Actual targets ({}) do not match expected targets ({}) " 'for "[{} ...]"'
+            'Actual targets ({}) do not match expected targets ({}) for "[{} ...]"'
         ).format(", ".join(actual), ", ".join(expected), name),
     )
 

jaclang/vendor/mypy/test/meta/test_parse_data.py

@@ -2,6 +2,7 @@
 A "meta test" which tests the parsing of .test files. This is not meant to become exhaustive
 but to ensure we maintain a basic level of ergonomics for mypy contributors.
 """
+
 from mypy.test.helpers import Suite
 from mypy.test.meta._pytest import PytestResult, run_pytest_data_suite
 

jaclang/vendor/mypy/test/meta/test_update_data.py

@@ -3,6 +3,7 @@ A "meta test" which tests the `--update-data` feature for updating .test files.
 Updating the expected output, especially when it's in the form of inline (comment) assertions,
 can be brittle, which is why we're "meta-testing" here.
 """
+
 from mypy.test.helpers import Suite
 from mypy.test.meta._pytest import PytestResult, dedent_docstring, run_pytest_data_suite
 

jaclang/vendor/mypy/test/testargs.py

@@ -4,6 +4,7 @@ In particular, verify that the argparse defaults are the same as the Options
 defaults, and that argparse doesn't assign any new members to the Options
 object it creates.
 """
+
 from __future__ import annotations
 
 import argparse

jaclang/vendor/mypy/test/testcheck.py

@@ -34,6 +34,7 @@ try:
 except ImportError:
     lxml = None
 
+
 import pytest
 
 # List of files that contain test case descriptions.
@@ -108,9 +109,11 @@ class TypeCheckSuite(DataSuite):
     def run_case_once(
         self,
         testcase: DataDrivenTestCase,
-        operations: list[FileOperation] = [],
+        operations: list[FileOperation] | None = None,
         incremental_step: int = 0,
     ) -> None:
+        if operations is None:
+            operations = []
         original_program_text = "\n".join(testcase.input)
         module_data = self.parse_module(original_program_text, incremental_step)
 

jaclang/vendor/mypy/test/testconstraints.py

@@ -36,17 +36,24 @@ class ConstraintsSuite(Suite):
 
     def test_basic_type_var_tuple(self) -> None:
         fx = self.fx
-        assert infer_constraints(
-            Instance(fx.gvi, [UnpackType(fx.ts)]),
-            Instance(fx.gvi, [fx.a, fx.b]),
-            SUPERTYPE_OF,
-        ) == [
+        assert set(
+            infer_constraints(
+                Instance(fx.gvi, [UnpackType(fx.ts)]),
+                Instance(fx.gvi, [fx.a, fx.b]),
+                SUPERTYPE_OF,
+            )
+        ) == {
             Constraint(
                 type_var=fx.ts,
                 op=SUPERTYPE_OF,
                 target=TupleType([fx.a, fx.b], fx.std_tuple),
-            )
-        ]
+            ),
+            Constraint(
+                type_var=fx.ts,
+                op=SUBTYPE_OF,
+                target=TupleType([fx.a, fx.b], fx.std_tuple),
+            ),
+        }
 
     def test_type_var_tuple_with_prefix_and_suffix(self) -> None:
         fx = self.fx
@@ -63,6 +70,11 @@ class ConstraintsSuite(Suite):
                 op=SUPERTYPE_OF,
                 target=TupleType([fx.b, fx.c], fx.std_tuple),
             ),
+            Constraint(
+                type_var=fx.ts,
+                op=SUBTYPE_OF,
+                target=TupleType([fx.b, fx.c], fx.std_tuple),
+            ),
             Constraint(type_var=fx.s, op=SUPERTYPE_OF, target=fx.d),
         }
 
@@ -76,7 +88,9 @@ class ConstraintsSuite(Suite):
             )
         ) == {
             Constraint(type_var=fx.t, op=SUPERTYPE_OF, target=fx.a),
+            Constraint(type_var=fx.t, op=SUBTYPE_OF, target=fx.a),
             Constraint(type_var=fx.t, op=SUPERTYPE_OF, target=fx.b),
+            Constraint(type_var=fx.t, op=SUBTYPE_OF, target=fx.b),
         }
 
     def test_unpack_homogenous_tuple_with_prefix_and_suffix(self) -> None:
@@ -92,7 +106,9 @@ class ConstraintsSuite(Suite):
         ) == {
             Constraint(type_var=fx.t, op=SUPERTYPE_OF, target=fx.a),
             Constraint(type_var=fx.s, op=SUPERTYPE_OF, target=fx.b),
+            Constraint(type_var=fx.s, op=SUBTYPE_OF, target=fx.b),
             Constraint(type_var=fx.s, op=SUPERTYPE_OF, target=fx.c),
+            Constraint(type_var=fx.s, op=SUBTYPE_OF, target=fx.c),
             Constraint(type_var=fx.u, op=SUPERTYPE_OF, target=fx.d),
         }
 
@@ -107,7 +123,9 @@ class ConstraintsSuite(Suite):
         ) == {
             Constraint(type_var=fx.u, op=SUPERTYPE_OF, target=fx.a),
             Constraint(type_var=fx.t, op=SUPERTYPE_OF, target=fx.b),
+            Constraint(type_var=fx.t, op=SUBTYPE_OF, target=fx.b),
             Constraint(type_var=fx.s, op=SUPERTYPE_OF, target=fx.c),
+            Constraint(type_var=fx.s, op=SUBTYPE_OF, target=fx.c),
             Constraint(type_var=fx.u, op=SUPERTYPE_OF, target=fx.d),
         }
 

jaclang/vendor/mypy/test/testerrorstream.py

@@ -1,4 +1,5 @@
 """Tests for mypy incremental error output."""
+
 from __future__ import annotations
 
 from mypy import build

jaclang/vendor/mypy/test/testformatter.py

@@ -52,14 +52,14 @@ class FancyErrorFormattingTestCases(TestCase):
 
     def test_split_words(self) -> None:
         assert split_words("Simple message") == ["Simple", "message"]
-        assert split_words('Message with "Some[Long, Types]"' " in it") == [
+        assert split_words('Message with "Some[Long, Types]" in it') == [
             "Message",
             "with",
             '"Some[Long, Types]"',
             "in",
             "it",
         ]
-        assert split_words('Message with "Some[Long, Types]"' " and [error-code]") == [
+        assert split_words('Message with "Some[Long, Types]" and [error-code]') == [
             "Message",
             "with",
             '"Some[Long, Types]"',

jaclang/vendor/mypy/test/testparse.py

@@ -8,7 +8,7 @@ from pytest import skip
 
 from mypy import defaults
 from mypy.config_parser import parse_mypy_comments
-from mypy.errors import CompileError
+from mypy.errors import CompileError, Errors
 from mypy.options import Options
 from mypy.parse import parse
 from mypy.test.data import DataDrivenTestCase, DataSuite
@@ -54,8 +54,9 @@ def test_parser(testcase: DataDrivenTestCase) -> None:
             bytes(source, "ascii"),
             fnam="main",
             module="__main__",
-            errors=None,
+            errors=Errors(options),
             options=options,
+            raise_on_error=True,
         )
         a = n.str_with_options(options).split("\n")
     except CompileError as e:
@@ -91,8 +92,9 @@ def test_parse_error(testcase: DataDrivenTestCase) -> None:
             bytes("\n".join(testcase.input), "utf-8"),
             INPUT_FILE_NAME,
             "__main__",
-            None,
-            options,
+            errors=Errors(options),
+            options=options,
+            raise_on_error=True,
         )
         raise AssertionError("No errors reported")
     except CompileError as e:

jaclang/vendor/mypy/test/testpythoneval.py

@@ -55,6 +55,7 @@ def test_python_evaluation(testcase: DataDrivenTestCase, cache_dir: str) -> None
         "--hide-error-codes",
         "--allow-empty-bodies",
         "--force-uppercase-builtins",
+        "--test-env",  # Speeds up some checks
     ]
     interpreter = python3_path
     mypy_cmdline.append(f"--python-version={'.'.join(map(str, PYTHON3_VERSION))}")