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

jaclang/vendor/mypy/test/testutil.py

@@ -1,111 +0,0 @@
-from __future__ import annotations
-
-import os
-from unittest import TestCase, mock
-
-from mypy.inspections import parse_location
-from mypy.util import _generate_junit_contents, get_terminal_width
-
-
-class TestGetTerminalSize(TestCase):
-    def test_get_terminal_size_in_pty_defaults_to_80(self) -> None:
-        # when run using a pty, `os.get_terminal_size()` returns `0, 0`
-        ret = os.terminal_size((0, 0))
-        mock_environ = os.environ.copy()
-        mock_environ.pop("COLUMNS", None)
-        with mock.patch.object(os, "get_terminal_size", return_value=ret):
-            with mock.patch.dict(os.environ, values=mock_environ, clear=True):
-                assert get_terminal_width() == 80
-
-    def test_parse_location_windows(self) -> None:
-        assert parse_location(r"C:\test.py:1:1") == (r"C:\test.py", [1, 1])
-        assert parse_location(r"C:\test.py:1:1:1:1") == (r"C:\test.py", [1, 1, 1, 1])
-
-
-class TestWriteJunitXml(TestCase):
-    def test_junit_pass(self) -> None:
-        serious = False
-        messages_by_file: dict[str | None, list[str]] = {}
-        expected = """<?xml version="1.0" encoding="utf-8"?>
-<testsuite errors="0" failures="0" name="mypy" skips="0" tests="1" time="1.230">
-  <testcase classname="mypy" file="mypy" line="1" name="mypy-py3.14-test-plat" time="1.230">
-  </testcase>
-</testsuite>
-"""
-        result = _generate_junit_contents(
-            dt=1.23,
-            serious=serious,
-            messages_by_file=messages_by_file,
-            version="3.14",
-            platform="test-plat",
-        )
-        assert result == expected
-
-    def test_junit_fail_escape_xml_chars(self) -> None:
-        serious = False
-        messages_by_file: dict[str | None, list[str]] = {
-            "file1.py": ["Test failed", "another line < > &"]
-        }
-        expected = """<?xml version="1.0" encoding="utf-8"?>
-<testsuite errors="0" failures="1" name="mypy" skips="0" tests="1" time="1.230">
-  <testcase classname="mypy" file="file1.py" line="1" name="mypy-py3.14-test-plat file1.py" time="1.230">
-    <failure message="mypy produced messages">Test failed
-another line &lt; &gt; &amp;</failure>
-  </testcase>
-</testsuite>
-"""
-        result = _generate_junit_contents(
-            dt=1.23,
-            serious=serious,
-            messages_by_file=messages_by_file,
-            version="3.14",
-            platform="test-plat",
-        )
-        assert result == expected
-
-    def test_junit_fail_two_files(self) -> None:
-        serious = False
-        messages_by_file: dict[str | None, list[str]] = {
-            "file1.py": ["Test failed", "another line"],
-            "file2.py": ["Another failure", "line 2"],
-        }
-        expected = """<?xml version="1.0" encoding="utf-8"?>
-<testsuite errors="0" failures="2" name="mypy" skips="0" tests="2" time="1.230">
-  <testcase classname="mypy" file="file1.py" line="1" name="mypy-py3.14-test-plat file1.py" time="1.230">
-    <failure message="mypy produced messages">Test failed
-another line</failure>
-  </testcase>
-  <testcase classname="mypy" file="file2.py" line="1" name="mypy-py3.14-test-plat file2.py" time="1.230">
-    <failure message="mypy produced messages">Another failure
-line 2</failure>
-  </testcase>
-</testsuite>
-"""
-        result = _generate_junit_contents(
-            dt=1.23,
-            serious=serious,
-            messages_by_file=messages_by_file,
-            version="3.14",
-            platform="test-plat",
-        )
-        assert result == expected
-
-    def test_serious_error(self) -> None:
-        serious = True
-        messages_by_file: dict[str | None, list[str]] = {None: ["Error line 1", "Error line 2"]}
-        expected = """<?xml version="1.0" encoding="utf-8"?>
-<testsuite errors="1" failures="0" name="mypy" skips="0" tests="1" time="1.230">
-  <testcase classname="mypy" file="mypy" line="1" name="mypy-py3.14-test-plat" time="1.230">
-    <failure message="mypy produced messages">Error line 1
-Error line 2</failure>
-  </testcase>
-</testsuite>
-"""
-        result = _generate_junit_contents(
-            dt=1.23,
-            serious=serious,
-            messages_by_file=messages_by_file,
-            version="3.14",
-            platform="test-plat",
-        )
-        assert result == expected

jaclang/vendor/mypy/test/typefixture.py

@@ -1,415 +0,0 @@
-"""Fixture used in type-related test cases.
-
-It contains class TypeInfos and Type objects.
-"""
-
-from __future__ import annotations
-
-from mypy.nodes import (
-    ARG_OPT,
-    ARG_POS,
-    ARG_STAR,
-    COVARIANT,
-    MDEF,
-    Block,
-    ClassDef,
-    FuncDef,
-    SymbolTable,
-    SymbolTableNode,
-    TypeAlias,
-    TypeInfo,
-)
-from mypy.semanal_shared import set_callable_name
-from mypy.types import (
-    AnyType,
-    CallableType,
-    Instance,
-    LiteralType,
-    NoneType,
-    Type,
-    TypeAliasType,
-    TypeOfAny,
-    TypeType,
-    TypeVarLikeType,
-    TypeVarTupleType,
-    TypeVarType,
-    UninhabitedType,
-    UnionType,
-)
-
-
-class TypeFixture:
-    """Helper class that is used as a fixture in type-related unit tests.
-
-    The members are initialized to contain various type-related values.
-    """
-
-    def __init__(self, variance: int = COVARIANT) -> None:
-        # The 'object' class
-        self.oi = self.make_type_info("builtins.object")  # class object
-        self.o = Instance(self.oi, [])  # object
-
-        # Type variables (these are effectively global)
-
-        def make_type_var(
-            name: str, id: int, values: list[Type], upper_bound: Type, variance: int
-        ) -> TypeVarType:
-            return TypeVarType(
-                name,
-                name,
-                id,
-                values,
-                upper_bound,
-                AnyType(TypeOfAny.from_omitted_generics),
-                variance,
-            )
-
-        self.t = make_type_var("T", 1, [], self.o, variance)  # T`1 (type variable)
-        self.tf = make_type_var("T", -1, [], self.o, variance)  # T`-1 (type variable)
-        self.tf2 = make_type_var("T", -2, [], self.o, variance)  # T`-2 (type variable)
-        self.s = make_type_var("S", 2, [], self.o, variance)  # S`2 (type variable)
-        self.s1 = make_type_var("S", 1, [], self.o, variance)  # S`1 (type variable)
-        self.sf = make_type_var("S", -2, [], self.o, variance)  # S`-2 (type variable)
-        self.sf1 = make_type_var("S", -1, [], self.o, variance)  # S`-1 (type variable)
-        self.u = make_type_var("U", 3, [], self.o, variance)  # U`3 (type variable)
-
-        # Simple types
-        self.anyt = AnyType(TypeOfAny.special_form)
-        self.nonet = NoneType()
-        self.uninhabited = UninhabitedType()
-
-        # Abstract class TypeInfos
-
-        # class F
-        self.fi = self.make_type_info("F", is_abstract=True)
-
-        # class F2
-        self.f2i = self.make_type_info("F2", is_abstract=True)
-
-        # class F3(F)
-        self.f3i = self.make_type_info("F3", is_abstract=True, mro=[self.fi])
-
-        # Class TypeInfos
-        self.std_tuplei = self.make_type_info(
-            "builtins.tuple", mro=[self.oi], typevars=["T"], variances=[COVARIANT]
-        )  # class tuple
-        self.type_typei = self.make_type_info("builtins.type")  # class type
-        self.bool_type_info = self.make_type_info("builtins.bool")
-        self.str_type_info = self.make_type_info("builtins.str")
-        self.functioni = self.make_type_info("builtins.function")  # function TODO
-        self.ai = self.make_type_info("A", mro=[self.oi])  # class A
-        self.bi = self.make_type_info("B", mro=[self.ai, self.oi])  # class B(A)
-        self.ci = self.make_type_info("C", mro=[self.ai, self.oi])  # class C(A)
-        self.di = self.make_type_info("D", mro=[self.oi])  # class D
-        # class E(F)
-        self.ei = self.make_type_info("E", mro=[self.fi, self.oi])
-        # class E2(F2, F)
-        self.e2i = self.make_type_info("E2", mro=[self.f2i, self.fi, self.oi])
-        # class E3(F, F2)
-        self.e3i = self.make_type_info("E3", mro=[self.fi, self.f2i, self.oi])
-
-        # Generic class TypeInfos
-        # G[T]
-        self.gi = self.make_type_info("G", mro=[self.oi], typevars=["T"], variances=[variance])
-        # G2[T]
-        self.g2i = self.make_type_info("G2", mro=[self.oi], typevars=["T"], variances=[variance])
-        # H[S, T]
-        self.hi = self.make_type_info(
-            "H", mro=[self.oi], typevars=["S", "T"], variances=[variance, variance]
-        )
-        # GS[T, S] <: G[S]
-        self.gsi = self.make_type_info(
-            "GS",
-            mro=[self.gi, self.oi],
-            typevars=["T", "S"],
-            variances=[variance, variance],
-            bases=[Instance(self.gi, [self.s])],
-        )
-        # GS2[S] <: G[S]
-        self.gs2i = self.make_type_info(
-            "GS2",
-            mro=[self.gi, self.oi],
-            typevars=["S"],
-            variances=[variance],
-            bases=[Instance(self.gi, [self.s1])],
-        )
-
-        # list[T]
-        self.std_listi = self.make_type_info(
-            "builtins.list", mro=[self.oi], typevars=["T"], variances=[variance]
-        )
-
-        # Instance types
-        self.std_tuple = Instance(self.std_tuplei, [self.anyt])  # tuple
-        self.type_type = Instance(self.type_typei, [])  # type
-        self.function = Instance(self.functioni, [])  # function TODO
-        self.str_type = Instance(self.str_type_info, [])
-        self.bool_type = Instance(self.bool_type_info, [])
-        self.a = Instance(self.ai, [])  # A
-        self.b = Instance(self.bi, [])  # B
-        self.c = Instance(self.ci, [])  # C
-        self.d = Instance(self.di, [])  # D
-
-        self.e = Instance(self.ei, [])  # E
-        self.e2 = Instance(self.e2i, [])  # E2
-        self.e3 = Instance(self.e3i, [])  # E3
-
-        self.f = Instance(self.fi, [])  # F
-        self.f2 = Instance(self.f2i, [])  # F2
-        self.f3 = Instance(self.f3i, [])  # F3
-
-        # Generic instance types
-        self.ga = Instance(self.gi, [self.a])  # G[A]
-        self.gb = Instance(self.gi, [self.b])  # G[B]
-        self.gd = Instance(self.gi, [self.d])  # G[D]
-        self.go = Instance(self.gi, [self.o])  # G[object]
-        self.gt = Instance(self.gi, [self.t])  # G[T`1]
-        self.gtf = Instance(self.gi, [self.tf])  # G[T`-1]
-        self.gtf2 = Instance(self.gi, [self.tf2])  # G[T`-2]
-        self.gs = Instance(self.gi, [self.s])  # G[S]
-        self.gdyn = Instance(self.gi, [self.anyt])  # G[Any]
-        self.gn = Instance(self.gi, [NoneType()])  # G[None]
-
-        self.g2a = Instance(self.g2i, [self.a])  # G2[A]
-
-        self.gsaa = Instance(self.gsi, [self.a, self.a])  # GS[A, A]
-        self.gsab = Instance(self.gsi, [self.a, self.b])  # GS[A, B]
-        self.gsba = Instance(self.gsi, [self.b, self.a])  # GS[B, A]
-
-        self.gs2a = Instance(self.gs2i, [self.a])  # GS2[A]
-        self.gs2b = Instance(self.gs2i, [self.b])  # GS2[B]
-        self.gs2d = Instance(self.gs2i, [self.d])  # GS2[D]
-
-        self.hab = Instance(self.hi, [self.a, self.b])  # H[A, B]
-        self.haa = Instance(self.hi, [self.a, self.a])  # H[A, A]
-        self.hbb = Instance(self.hi, [self.b, self.b])  # H[B, B]
-        self.hts = Instance(self.hi, [self.t, self.s])  # H[T, S]
-        self.had = Instance(self.hi, [self.a, self.d])  # H[A, D]
-        self.hao = Instance(self.hi, [self.a, self.o])  # H[A, object]
-
-        self.lsta = Instance(self.std_listi, [self.a])  # List[A]
-        self.lstb = Instance(self.std_listi, [self.b])  # List[B]
-
-        self.lit1 = LiteralType(1, self.a)
-        self.lit2 = LiteralType(2, self.a)
-        self.lit3 = LiteralType("foo", self.d)
-        self.lit4 = LiteralType(4, self.a)
-        self.lit1_inst = Instance(self.ai, [], last_known_value=self.lit1)
-        self.lit2_inst = Instance(self.ai, [], last_known_value=self.lit2)
-        self.lit3_inst = Instance(self.di, [], last_known_value=self.lit3)
-        self.lit4_inst = Instance(self.ai, [], last_known_value=self.lit4)
-
-        self.lit_str1 = LiteralType("x", self.str_type)
-        self.lit_str2 = LiteralType("y", self.str_type)
-        self.lit_str3 = LiteralType("z", self.str_type)
-        self.lit_str1_inst = Instance(self.str_type_info, [], last_known_value=self.lit_str1)
-        self.lit_str2_inst = Instance(self.str_type_info, [], last_known_value=self.lit_str2)
-        self.lit_str3_inst = Instance(self.str_type_info, [], last_known_value=self.lit_str3)
-
-        self.lit_false = LiteralType(False, self.bool_type)
-        self.lit_true = LiteralType(True, self.bool_type)
-
-        self.type_a = TypeType.make_normalized(self.a)
-        self.type_b = TypeType.make_normalized(self.b)
-        self.type_c = TypeType.make_normalized(self.c)
-        self.type_d = TypeType.make_normalized(self.d)
-        self.type_t = TypeType.make_normalized(self.t)
-        self.type_any = TypeType.make_normalized(self.anyt)
-
-        self._add_bool_dunder(self.bool_type_info)
-        self._add_bool_dunder(self.ai)
-
-        # TypeVars with non-trivial bounds
-        self.ub = make_type_var("UB", 5, [], self.b, variance)  # UB`5 (type variable)
-        self.uc = make_type_var("UC", 6, [], self.c, variance)  # UC`6 (type variable)
-
-        def make_type_var_tuple(name: str, id: int, upper_bound: Type) -> TypeVarTupleType:
-            return TypeVarTupleType(
-                name,
-                name,
-                id,
-                upper_bound,
-                self.std_tuple,
-                AnyType(TypeOfAny.from_omitted_generics),
-            )
-
-        obj_tuple = self.std_tuple.copy_modified(args=[self.o])
-        self.ts = make_type_var_tuple("Ts", 1, obj_tuple)  # Ts`1 (type var tuple)
-        self.ss = make_type_var_tuple("Ss", 2, obj_tuple)  # Ss`2 (type var tuple)
-        self.us = make_type_var_tuple("Us", 3, obj_tuple)  # Us`3 (type var tuple)
-
-        self.gvi = self.make_type_info("GV", mro=[self.oi], typevars=["Ts"], typevar_tuple_index=0)
-        self.gv2i = self.make_type_info(
-            "GV2", mro=[self.oi], typevars=["T", "Ts", "S"], typevar_tuple_index=1
-        )
-
-    def _add_bool_dunder(self, type_info: TypeInfo) -> None:
-        signature = CallableType([], [], [], Instance(self.bool_type_info, []), self.function)
-        bool_func = FuncDef("__bool__", [], Block([]))
-        bool_func.type = set_callable_name(signature, bool_func)
-        type_info.names[bool_func.name] = SymbolTableNode(MDEF, bool_func)
-
-    # Helper methods
-
-    def callable(self, *a: Type) -> CallableType:
-        """callable(a1, ..., an, r) constructs a callable with argument types
-        a1, ... an and return type r.
-        """
-        return CallableType(
-            list(a[:-1]), [ARG_POS] * (len(a) - 1), [None] * (len(a) - 1), a[-1], self.function
-        )
-
-    def callable_type(self, *a: Type) -> CallableType:
-        """callable_type(a1, ..., an, r) constructs a callable with
-        argument types a1, ... an and return type r, and which
-        represents a type.
-        """
-        return CallableType(
-            list(a[:-1]), [ARG_POS] * (len(a) - 1), [None] * (len(a) - 1), a[-1], self.type_type
-        )
-
-    def callable_default(self, min_args: int, *a: Type) -> CallableType:
-        """callable_default(min_args, a1, ..., an, r) constructs a
-        callable with argument types a1, ... an and return type r,
-        with min_args mandatory fixed arguments.
-        """
-        n = len(a) - 1
-        return CallableType(
-            list(a[:-1]),
-            [ARG_POS] * min_args + [ARG_OPT] * (n - min_args),
-            [None] * n,
-            a[-1],
-            self.function,
-        )
-
-    def callable_var_arg(self, min_args: int, *a: Type) -> CallableType:
-        """callable_var_arg(min_args, a1, ..., an, r) constructs a callable
-        with argument types a1, ... *an and return type r.
-        """
-        n = len(a) - 1
-        return CallableType(
-            list(a[:-1]),
-            [ARG_POS] * min_args + [ARG_OPT] * (n - 1 - min_args) + [ARG_STAR],
-            [None] * n,
-            a[-1],
-            self.function,
-        )
-
-    def make_type_info(
-        self,
-        name: str,
-        module_name: str | None = None,
-        is_abstract: bool = False,
-        mro: list[TypeInfo] | None = None,
-        bases: list[Instance] | None = None,
-        typevars: list[str] | None = None,
-        typevar_tuple_index: int | None = None,
-        variances: list[int] | None = None,
-    ) -> TypeInfo:
-        """Make a TypeInfo suitable for use in unit tests."""
-
-        class_def = ClassDef(name, Block([]), None, [])
-        class_def.fullname = name
-
-        if module_name is None:
-            if "." in name:
-                module_name = name.rsplit(".", 1)[0]
-            else:
-                module_name = "__main__"
-
-        if typevars:
-            v: list[TypeVarLikeType] = []
-            for id, n in enumerate(typevars, 1):
-                if typevar_tuple_index is not None and id - 1 == typevar_tuple_index:
-                    v.append(
-                        TypeVarTupleType(
-                            n,
-                            n,
-                            id,
-                            self.std_tuple.copy_modified(args=[self.o]),
-                            self.std_tuple.copy_modified(args=[self.o]),
-                            AnyType(TypeOfAny.from_omitted_generics),
-                        )
-                    )
-                else:
-                    if variances:
-                        variance = variances[id - 1]
-                    else:
-                        variance = COVARIANT
-                    v.append(
-                        TypeVarType(
-                            n,
-                            n,
-                            id,
-                            [],
-                            self.o,
-                            AnyType(TypeOfAny.from_omitted_generics),
-                            variance=variance,
-                        )
-                    )
-            class_def.type_vars = v
-
-        info = TypeInfo(SymbolTable(), class_def, module_name)
-        if mro is None:
-            mro = []
-            if name != "builtins.object":
-                mro.append(self.oi)
-        info.mro = [info] + mro
-        if bases is None:
-            if mro:
-                # By default, assume that there is a single non-generic base.
-                bases = [Instance(mro[0], [])]
-            else:
-                bases = []
-        info.bases = bases
-
-        return info
-
-    def def_alias_1(self, base: Instance) -> tuple[TypeAliasType, Type]:
-        A = TypeAliasType(None, [])
-        target = Instance(
-            self.std_tuplei, [UnionType([base, A])]
-        )  # A = Tuple[Union[base, A], ...]
-        AN = TypeAlias(target, "__main__.A", -1, -1)
-        A.alias = AN
-        return A, target
-
-    def def_alias_2(self, base: Instance) -> tuple[TypeAliasType, Type]:
-        A = TypeAliasType(None, [])
-        target = UnionType(
-            [base, Instance(self.std_tuplei, [A])]
-        )  # A = Union[base, Tuple[A, ...]]
-        AN = TypeAlias(target, "__main__.A", -1, -1)
-        A.alias = AN
-        return A, target
-
-    def non_rec_alias(
-        self,
-        target: Type,
-        alias_tvars: list[TypeVarLikeType] | None = None,
-        args: list[Type] | None = None,
-    ) -> TypeAliasType:
-        AN = TypeAlias(target, "__main__.A", -1, -1, alias_tvars=alias_tvars)
-        if args is None:
-            args = []
-        return TypeAliasType(AN, args)
-
-
-class InterfaceTypeFixture(TypeFixture):
-    """Extension of TypeFixture that contains additional generic
-    interface types."""
-
-    def __init__(self) -> None:
-        super().__init__()
-        # GF[T]
-        self.gfi = self.make_type_info("GF", typevars=["T"], is_abstract=True)
-
-        # M1 <: GF[A]
-        self.m1i = self.make_type_info(
-            "M1", is_abstract=True, mro=[self.gfi, self.oi], bases=[Instance(self.gfi, [self.a])]
-        )
-
-        self.gfa = Instance(self.gfi, [self.a])  # GF[A]
-        self.gfb = Instance(self.gfi, [self.b])  # GF[B]
-
-        self.m1 = Instance(self.m1i, [])  # M1

jaclang/vendor/mypy/test/update_data.py

@@ -1,87 +0,0 @@
-from __future__ import annotations
-
-import re
-from collections import defaultdict
-from typing import Iterator
-
-from mypy.test.data import DataDrivenTestCase, DataFileCollector, DataFileFix, parse_test_data
-
-
-def update_testcase_output(
-    testcase: DataDrivenTestCase, actual: list[str], *, incremental_step: int
-) -> None:
-    if testcase.xfail:
-        return
-    collector = testcase.parent
-    assert isinstance(collector, DataFileCollector)
-    for fix in _iter_fixes(testcase, actual, incremental_step=incremental_step):
-        collector.enqueue_fix(fix)
-
-
-def _iter_fixes(
-    testcase: DataDrivenTestCase, actual: list[str], *, incremental_step: int
-) -> Iterator[DataFileFix]:
-    reports_by_line: dict[tuple[str, int], list[tuple[str, str]]] = defaultdict(list)
-    for error_line in actual:
-        comment_match = re.match(
-            r"^(?P<filename>[^:]+):(?P<lineno>\d+): (?P<severity>error|note|warning): (?P<msg>.+)$",
-            error_line,
-        )
-        if comment_match:
-            filename = comment_match.group("filename")
-            lineno = int(comment_match.group("lineno"))
-            severity = comment_match.group("severity")
-            msg = comment_match.group("msg")
-            reports_by_line[filename, lineno].append((severity, msg))
-
-    test_items = parse_test_data(testcase.data, testcase.name)
-
-    # If we have [out] and/or [outN], we update just those sections.
-    if any(re.match(r"^out\d*$", test_item.id) for test_item in test_items):
-        for test_item in test_items:
-            if (incremental_step < 2 and test_item.id == "out") or (
-                incremental_step >= 2 and test_item.id == f"out{incremental_step}"
-            ):
-                yield DataFileFix(
-                    lineno=testcase.line + test_item.line - 1,
-                    end_lineno=testcase.line + test_item.end_line - 1,
-                    lines=actual + [""] * test_item.trimmed_newlines,
-                )
-
-        return
-
-    # Update assertion comments within the sections
-    for test_item in test_items:
-        if test_item.id == "case":
-            source_lines = test_item.data
-            file_path = "main"
-        elif test_item.id == "file":
-            source_lines = test_item.data
-            file_path = f"tmp/{test_item.arg}"
-        else:
-            continue  # other sections we don't touch
-
-        fix_lines = []
-        for lineno, source_line in enumerate(source_lines, start=1):
-            reports = reports_by_line.get((file_path, lineno))
-            comment_match = re.search(r"(?P<indent>\s+)(?P<comment># [EWN]: .+)$", source_line)
-            if comment_match:
-                source_line = source_line[: comment_match.start("indent")]  # strip old comment
-            if reports:
-                indent = comment_match.group("indent") if comment_match else "  "
-                # multiline comments are on the first line and then on subsequent lines emtpy lines
-                # with a continuation backslash
-                for j, (severity, msg) in enumerate(reports):
-                    out_l = source_line if j == 0 else " " * len(source_line)
-                    is_last = j == len(reports) - 1
-                    severity_char = severity[0].upper()
-                    continuation = "" if is_last else " \\"
-                    fix_lines.append(f"{out_l}{indent}# {severity_char}: {msg}{continuation}")
-            else:
-                fix_lines.append(source_line)
-
-        yield DataFileFix(
-            lineno=testcase.line + test_item.line - 1,
-            end_lineno=testcase.line + test_item.end_line - 1,
-            lines=fix_lines + [""] * test_item.trimmed_newlines,
-        )

jaclang/vendor/mypy/test/visitors.py

@@ -1,63 +0,0 @@
-"""Visitor classes pulled out from different tests
-
-These are here because we don't currently support having interpreted
-classes subtype compiled ones but pytest grabs the python file
-even if the test was compiled.
-
-"""
-
-from __future__ import annotations
-
-from mypy.nodes import AssignmentStmt, CallExpr, Expression, IntExpr, NameExpr, Node, TypeVarExpr
-from mypy.traverser import TraverserVisitor
-from mypy.treetransform import TransformVisitor
-from mypy.types import Type
-
-
-# from testtypegen
-class SkippedNodeSearcher(TraverserVisitor):
-    def __init__(self) -> None:
-        self.nodes: set[Node] = set()
-        self.ignore_file = False
-
-    def visit_assignment_stmt(self, s: AssignmentStmt) -> None:
-        if s.type or ignore_node(s.rvalue):
-            for lvalue in s.lvalues:
-                if isinstance(lvalue, NameExpr):
-                    self.nodes.add(lvalue)
-        super().visit_assignment_stmt(s)
-
-    def visit_name_expr(self, n: NameExpr) -> None:
-        if self.ignore_file:
-            self.nodes.add(n)
-        super().visit_name_expr(n)
-
-    def visit_int_expr(self, n: IntExpr) -> None:
-        if self.ignore_file:
-            self.nodes.add(n)
-        super().visit_int_expr(n)
-
-
-def ignore_node(node: Expression) -> bool:
-    """Return True if node is to be omitted from test case output."""
-
-    # We want to get rid of object() expressions in the typing module stub
-    # and also TypeVar(...) expressions. Since detecting whether a node comes
-    # from the typing module is not easy, we just to strip them all away.
-    if isinstance(node, TypeVarExpr):
-        return True
-    if isinstance(node, NameExpr) and node.fullname == "builtins.object":
-        return True
-    if isinstance(node, NameExpr) and node.fullname == "builtins.None":
-        return True
-    if isinstance(node, CallExpr) and (ignore_node(node.callee) or node.analyzed):
-        return True
-
-    return False
-
-
-# from testtransform
-class TypeAssertTransformVisitor(TransformVisitor):
-    def type(self, type: Type) -> Type:
-        assert type is not None
-        return type