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

jaclang/vendor/mypy/typeshed/stubs/mypy-extensions/mypy_extensions.pyi

@@ -1,218 +0,0 @@
-# These stubs are forked from typeshed, since we use some definitions that only make
-# sense in the context of mypy/mypyc (in particular, native int types such as i64).
-
-import abc
-import sys
-from _collections_abc import dict_items, dict_keys, dict_values
-from _typeshed import IdentityFunction, Self
-from collections.abc import Mapping
-from typing import Any, ClassVar, Generic, SupportsInt, TypeVar, overload, type_check_only
-from typing_extensions import Never, SupportsIndex
-from _typeshed import ReadableBuffer, SupportsTrunc
-
-_T = TypeVar("_T")
-_U = TypeVar("_U")
-
-# Internal mypy fallback type for all typed dicts (does not exist at runtime)
-# N.B. Keep this mostly in sync with typing(_extensions)._TypedDict
-@type_check_only
-class _TypedDict(Mapping[str, object], metaclass=abc.ABCMeta):
-    __total__: ClassVar[bool]
-    # Unlike typing(_extensions).TypedDict,
-    # subclasses of mypy_extensions.TypedDict do NOT have the __required_keys__ and __optional_keys__ ClassVars
-    def copy(self: Self) -> Self: ...
-    # Using Never so that only calls using mypy plugin hook that specialize the signature
-    # can go through.
-    def setdefault(self, k: Never, default: object) -> object: ...
-    # Mypy plugin hook for 'pop' expects that 'default' has a type variable type.
-    def pop(self, k: Never, default: _T = ...) -> object: ...  # pyright: ignore[reportInvalidTypeVarUse]
-    def update(self: Self, __m: Self) -> None: ...
-    def items(self) -> dict_items[str, object]: ...
-    def keys(self) -> dict_keys[str, object]: ...
-    def values(self) -> dict_values[str, object]: ...
-    def __delitem__(self, k: Never) -> None: ...
-    if sys.version_info >= (3, 9):
-        def __or__(self: Self, __other: Self) -> Self: ...
-        def __ior__(self: Self, __other: Self) -> Self: ...
-
-def TypedDict(typename: str, fields: dict[str, type[Any]], total: bool = ...) -> type[dict[str, Any]]: ...
-@overload
-def Arg(type: _T, name: str | None = ...) -> _T: ...
-@overload
-def Arg(*, name: str | None = ...) -> Any: ...
-@overload
-def DefaultArg(type: _T, name: str | None = ...) -> _T: ...
-@overload
-def DefaultArg(*, name: str | None = ...) -> Any: ...
-@overload
-def NamedArg(type: _T, name: str | None = ...) -> _T: ...
-@overload
-def NamedArg(*, name: str | None = ...) -> Any: ...
-@overload
-def DefaultNamedArg(type: _T, name: str | None = ...) -> _T: ...
-@overload
-def DefaultNamedArg(*, name: str | None = ...) -> Any: ...
-@overload
-def VarArg(type: _T) -> _T: ...
-@overload
-def VarArg() -> Any: ...
-@overload
-def KwArg(type: _T) -> _T: ...
-@overload
-def KwArg() -> Any: ...
-
-# Return type that indicates a function does not return.
-# Deprecated: Use typing.NoReturn instead.
-class NoReturn: ...
-
-# This is consistent with implementation. Usage intends for this as
-# a class decorator, but mypy does not support type[_T] for abstract
-# classes until this issue is resolved, https://github.com/python/mypy/issues/4717.
-def trait(cls: _T) -> _T: ...
-def mypyc_attr(*attrs: str, **kwattrs: object) -> IdentityFunction: ...
-
-class FlexibleAlias(Generic[_T, _U]): ...
-
-# Native int types such as i64 are magical and support implicit
-# coercions to/from int using special logic in mypy. We generally only
-# include operations here for which we have specialized primitives.
-
-class i64:
-    @overload
-    def __new__(cls, __x: str | ReadableBuffer | SupportsInt | SupportsIndex | SupportsTrunc = ...) -> i64: ...
-    @overload
-    def __new__(cls, __x: str | bytes | bytearray, base: SupportsIndex) -> i64: ...
-
-    def __add__(self, x: i64) -> i64: ...
-    def __radd__(self, x: i64) -> i64: ...
-    def __sub__(self, x: i64) -> i64: ...
-    def __rsub__(self, x: i64) -> i64: ...
-    def __mul__(self, x: i64) -> i64: ...
-    def __rmul__(self, x: i64) -> i64: ...
-    def __floordiv__(self, x: i64) -> i64: ...
-    def __rfloordiv__(self, x: i64) -> i64: ...
-    def __mod__(self, x: i64) -> i64: ...
-    def __rmod__(self, x: i64) -> i64: ...
-    def __and__(self, x: i64) -> i64: ...
-    def __rand__(self, x: i64) -> i64: ...
-    def __or__(self, x: i64) -> i64: ...
-    def __ror__(self, x: i64) -> i64: ...
-    def __xor__(self, x: i64) -> i64: ...
-    def __rxor__(self, x: i64) -> i64: ...
-    def __lshift__(self, x: i64) -> i64: ...
-    def __rlshift__(self, x: i64) -> i64: ...
-    def __rshift__(self, x: i64) -> i64: ...
-    def __rrshift__(self, x: i64) -> i64: ...
-    def __neg__(self) -> i64: ...
-    def __invert__(self) -> i64: ...
-    def __pos__(self) -> i64: ...
-    def __lt__(self, x: i64) -> bool: ...
-    def __le__(self, x: i64) -> bool: ...
-    def __ge__(self, x: i64) -> bool: ...
-    def __gt__(self, x: i64) -> bool: ...
-    def __index__(self) -> int: ...
-
-class i32:
-    @overload
-    def __new__(cls, __x: str | ReadableBuffer | SupportsInt | SupportsIndex | SupportsTrunc = ...) -> i32: ...
-    @overload
-    def __new__(cls, __x: str | bytes | bytearray, base: SupportsIndex) -> i32: ...
-
-    def __add__(self, x: i32) -> i32: ...
-    def __radd__(self, x: i32) -> i32: ...
-    def __sub__(self, x: i32) -> i32: ...
-    def __rsub__(self, x: i32) -> i32: ...
-    def __mul__(self, x: i32) -> i32: ...
-    def __rmul__(self, x: i32) -> i32: ...
-    def __floordiv__(self, x: i32) -> i32: ...
-    def __rfloordiv__(self, x: i32) -> i32: ...
-    def __mod__(self, x: i32) -> i32: ...
-    def __rmod__(self, x: i32) -> i32: ...
-    def __and__(self, x: i32) -> i32: ...
-    def __rand__(self, x: i32) -> i32: ...
-    def __or__(self, x: i32) -> i32: ...
-    def __ror__(self, x: i32) -> i32: ...
-    def __xor__(self, x: i32) -> i32: ...
-    def __rxor__(self, x: i32) -> i32: ...
-    def __lshift__(self, x: i32) -> i32: ...
-    def __rlshift__(self, x: i32) -> i32: ...
-    def __rshift__(self, x: i32) -> i32: ...
-    def __rrshift__(self, x: i32) -> i32: ...
-    def __neg__(self) -> i32: ...
-    def __invert__(self) -> i32: ...
-    def __pos__(self) -> i32: ...
-    def __lt__(self, x: i32) -> bool: ...
-    def __le__(self, x: i32) -> bool: ...
-    def __ge__(self, x: i32) -> bool: ...
-    def __gt__(self, x: i32) -> bool: ...
-    def __index__(self) -> int: ...
-
-class i16:
-    @overload
-    def __new__(cls, __x: str | ReadableBuffer | SupportsInt | SupportsIndex | SupportsTrunc = ...) -> i16: ...
-    @overload
-    def __new__(cls, __x: str | bytes | bytearray, base: SupportsIndex) -> i16: ...
-
-    def __add__(self, x: i16) -> i16: ...
-    def __radd__(self, x: i16) -> i16: ...
-    def __sub__(self, x: i16) -> i16: ...
-    def __rsub__(self, x: i16) -> i16: ...
-    def __mul__(self, x: i16) -> i16: ...
-    def __rmul__(self, x: i16) -> i16: ...
-    def __floordiv__(self, x: i16) -> i16: ...
-    def __rfloordiv__(self, x: i16) -> i16: ...
-    def __mod__(self, x: i16) -> i16: ...
-    def __rmod__(self, x: i16) -> i16: ...
-    def __and__(self, x: i16) -> i16: ...
-    def __rand__(self, x: i16) -> i16: ...
-    def __or__(self, x: i16) -> i16: ...
-    def __ror__(self, x: i16) -> i16: ...
-    def __xor__(self, x: i16) -> i16: ...
-    def __rxor__(self, x: i16) -> i16: ...
-    def __lshift__(self, x: i16) -> i16: ...
-    def __rlshift__(self, x: i16) -> i16: ...
-    def __rshift__(self, x: i16) -> i16: ...
-    def __rrshift__(self, x: i16) -> i16: ...
-    def __neg__(self) -> i16: ...
-    def __invert__(self) -> i16: ...
-    def __pos__(self) -> i16: ...
-    def __lt__(self, x: i16) -> bool: ...
-    def __le__(self, x: i16) -> bool: ...
-    def __ge__(self, x: i16) -> bool: ...
-    def __gt__(self, x: i16) -> bool: ...
-    def __index__(self) -> int: ...
-
-class u8:
-    @overload
-    def __new__(cls, __x: str | ReadableBuffer | SupportsInt | SupportsIndex | SupportsTrunc = ...) -> u8: ...
-    @overload
-    def __new__(cls, __x: str | bytes | bytearray, base: SupportsIndex) -> u8: ...
-
-    def __add__(self, x: u8) -> u8: ...
-    def __radd__(self, x: u8) -> u8: ...
-    def __sub__(self, x: u8) -> u8: ...
-    def __rsub__(self, x: u8) -> u8: ...
-    def __mul__(self, x: u8) -> u8: ...
-    def __rmul__(self, x: u8) -> u8: ...
-    def __floordiv__(self, x: u8) -> u8: ...
-    def __rfloordiv__(self, x: u8) -> u8: ...
-    def __mod__(self, x: u8) -> u8: ...
-    def __rmod__(self, x: u8) -> u8: ...
-    def __and__(self, x: u8) -> u8: ...
-    def __rand__(self, x: u8) -> u8: ...
-    def __or__(self, x: u8) -> u8: ...
-    def __ror__(self, x: u8) -> u8: ...
-    def __xor__(self, x: u8) -> u8: ...
-    def __rxor__(self, x: u8) -> u8: ...
-    def __lshift__(self, x: u8) -> u8: ...
-    def __rlshift__(self, x: u8) -> u8: ...
-    def __rshift__(self, x: u8) -> u8: ...
-    def __rrshift__(self, x: u8) -> u8: ...
-    def __neg__(self) -> u8: ...
-    def __invert__(self) -> u8: ...
-    def __pos__(self) -> u8: ...
-    def __lt__(self, x: u8) -> bool: ...
-    def __le__(self, x: u8) -> bool: ...
-    def __ge__(self, x: u8) -> bool: ...
-    def __gt__(self, x: u8) -> bool: ...
-    def __index__(self) -> int: ...

jaclang/vendor/mypy/typestate.py

@@ -1,323 +0,0 @@
-"""
-A shared state for all TypeInfos that holds global cache and dependency information,
-and potentially other mutable TypeInfo state. This module contains mutable global state.
-"""
-
-from __future__ import annotations
-
-from typing import Dict, Final, Set, Tuple
-from typing_extensions import TypeAlias as _TypeAlias
-
-from mypy.nodes import TypeInfo
-from mypy.server.trigger import make_trigger
-from mypy.types import Instance, Type, TypeVarId, get_proper_type
-
-MAX_NEGATIVE_CACHE_TYPES: Final = 1000
-MAX_NEGATIVE_CACHE_ENTRIES: Final = 10000
-
-# Represents that the 'left' instance is a subtype of the 'right' instance
-SubtypeRelationship: _TypeAlias = Tuple[Instance, Instance]
-
-# A tuple encoding the specific conditions under which we performed the subtype check.
-# (e.g. did we want a proper subtype? A regular subtype while ignoring variance?)
-SubtypeKind: _TypeAlias = Tuple[bool, ...]
-
-# A cache that keeps track of whether the given TypeInfo is a part of a particular
-# subtype relationship
-SubtypeCache: _TypeAlias = Dict[TypeInfo, Dict[SubtypeKind, Set[SubtypeRelationship]]]
-
-
-class TypeState:
-    """This class provides subtype caching to improve performance of subtype checks.
-    It also holds protocol fine grained dependencies.
-
-    Note: to avoid leaking global state, 'reset_all_subtype_caches()' should be called
-    after a build has finished and after a daemon shutdown. This subtype cache only exists for
-    performance reasons, resetting subtype caches for a class has no semantic effect.
-    The protocol dependencies however are only stored here, and shouldn't be deleted unless
-    not needed any more (e.g. during daemon shutdown).
-    """
-
-    # '_subtype_caches' keeps track of (subtype, supertype) pairs where supertypes are
-    # instances of the given TypeInfo. The cache also keeps track of whether the check
-    # was done in strict optional mode and of the specific *kind* of subtyping relationship,
-    # which we represent as an arbitrary hashable tuple.
-    # We need the caches, since subtype checks for structural types are very slow.
-    _subtype_caches: Final[SubtypeCache]
-
-    # Same as above but for negative subtyping results.
-    _negative_subtype_caches: Final[SubtypeCache]
-
-    # This contains protocol dependencies generated after running a full build,
-    # or after an update. These dependencies are special because:
-    #   * They are a global property of the program; i.e. some dependencies for imported
-    #     classes can be generated in the importing modules.
-    #   * Because of the above, they are serialized separately, after a full run,
-    #     or a full update.
-    # `proto_deps` can be None if after deserialization it turns out that they are
-    # inconsistent with the other cache files (or an error occurred during deserialization).
-    # A blocking error will be generated in this case, since we can't proceed safely.
-    # For the description of kinds of protocol dependencies and corresponding examples,
-    # see _snapshot_protocol_deps.
-    proto_deps: dict[str, set[str]] | None
-
-    # Protocols (full names) a given class attempted to implement.
-    # Used to calculate fine grained protocol dependencies and optimize protocol
-    # subtype cache invalidation in fine grained mode. For example, if we pass a value
-    # of type a.A to a function expecting something compatible with protocol p.P,
-    # we'd have 'a.A' -> {'p.P', ...} in the map. This map is flushed after every incremental
-    # update.
-    _attempted_protocols: Final[dict[str, set[str]]]
-    # We also snapshot protocol members of the above protocols. For example, if we pass
-    # a value of type a.A to a function expecting something compatible with Iterable, we'd have
-    # 'a.A' -> {'__iter__', ...} in the map. This map is also flushed after every incremental
-    # update. This map is needed to only generate dependencies like <a.A.__iter__> -> <a.A>
-    # instead of a wildcard to avoid unnecessarily invalidating classes.
-    _checked_against_members: Final[dict[str, set[str]]]
-    # TypeInfos that appeared as a left type (subtype) in a subtype check since latest
-    # dependency snapshot update. This is an optimisation for fine grained mode; during a full
-    # run we only take a dependency snapshot at the very end, so this set will contain all
-    # subtype-checked TypeInfos. After a fine grained update however, we can gather only new
-    # dependencies generated from (typically) few TypeInfos that were subtype-checked
-    # (i.e. appeared as r.h.s. in an assignment or an argument in a function call in
-    # a re-checked target) during the update.
-    _rechecked_types: Final[set[TypeInfo]]
-
-    # The two attributes below are assumption stacks for subtyping relationships between
-    # recursive type aliases. Normally, one would pass type assumptions as an additional
-    # arguments to is_subtype(), but this would mean updating dozens of related functions
-    # threading this through all callsites (see also comment for TypeInfo.assuming).
-    _assuming: Final[list[tuple[Type, Type]]]
-    _assuming_proper: Final[list[tuple[Type, Type]]]
-    # Ditto for inference of generic constraints against recursive type aliases.
-    inferring: Final[list[tuple[Type, Type]]]
-    # Whether to use joins or unions when solving constraints, see checkexpr.py for details.
-    infer_unions: bool
-    # Whether to use new type inference algorithm that can infer polymorphic types.
-    # This is temporary and will be removed soon when new algorithm is more polished.
-    infer_polymorphic: bool
-
-    # N.B: We do all of the accesses to these properties through
-    # TypeState, instead of making these classmethods and accessing
-    # via the cls parameter, since mypyc can optimize accesses to
-    # Final attributes of a directly referenced type.
-
-    def __init__(self) -> None:
-        self._subtype_caches = {}
-        self._negative_subtype_caches = {}
-        self.proto_deps = {}
-        self._attempted_protocols = {}
-        self._checked_against_members = {}
-        self._rechecked_types = set()
-        self._assuming = []
-        self._assuming_proper = []
-        self.inferring = []
-        self.infer_unions = False
-        self.infer_polymorphic = False
-
-    def is_assumed_subtype(self, left: Type, right: Type) -> bool:
-        for l, r in reversed(self._assuming):
-            if get_proper_type(l) == get_proper_type(left) and get_proper_type(
-                r
-            ) == get_proper_type(right):
-                return True
-        return False
-
-    def is_assumed_proper_subtype(self, left: Type, right: Type) -> bool:
-        for l, r in reversed(self._assuming_proper):
-            if get_proper_type(l) == get_proper_type(left) and get_proper_type(
-                r
-            ) == get_proper_type(right):
-                return True
-        return False
-
-    def get_assumptions(self, is_proper: bool) -> list[tuple[Type, Type]]:
-        if is_proper:
-            return self._assuming_proper
-        return self._assuming
-
-    def reset_all_subtype_caches(self) -> None:
-        """Completely reset all known subtype caches."""
-        self._subtype_caches.clear()
-        self._negative_subtype_caches.clear()
-
-    def reset_subtype_caches_for(self, info: TypeInfo) -> None:
-        """Reset subtype caches (if any) for a given supertype TypeInfo."""
-        if info in self._subtype_caches:
-            self._subtype_caches[info].clear()
-        if info in self._negative_subtype_caches:
-            self._negative_subtype_caches[info].clear()
-
-    def reset_all_subtype_caches_for(self, info: TypeInfo) -> None:
-        """Reset subtype caches (if any) for a given supertype TypeInfo and its MRO."""
-        for item in info.mro:
-            self.reset_subtype_caches_for(item)
-
-    def is_cached_subtype_check(self, kind: SubtypeKind, left: Instance, right: Instance) -> bool:
-        if left.last_known_value is not None or right.last_known_value is not None:
-            # If there is a literal last known value, give up. There
-            # will be an unbounded number of potential types to cache,
-            # making caching less effective.
-            return False
-        info = right.type
-        cache = self._subtype_caches.get(info)
-        if cache is None:
-            return False
-        subcache = cache.get(kind)
-        if subcache is None:
-            return False
-        return (left, right) in subcache
-
-    def is_cached_negative_subtype_check(
-        self, kind: SubtypeKind, left: Instance, right: Instance
-    ) -> bool:
-        if left.last_known_value is not None or right.last_known_value is not None:
-            # If there is a literal last known value, give up. There
-            # will be an unbounded number of potential types to cache,
-            # making caching less effective.
-            return False
-        info = right.type
-        cache = self._negative_subtype_caches.get(info)
-        if cache is None:
-            return False
-        subcache = cache.get(kind)
-        if subcache is None:
-            return False
-        return (left, right) in subcache
-
-    def record_subtype_cache_entry(
-        self, kind: SubtypeKind, left: Instance, right: Instance
-    ) -> None:
-        if left.last_known_value is not None or right.last_known_value is not None:
-            # 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, {})
-        cache.setdefault(kind, set()).add((left, right))
-
-    def record_negative_subtype_cache_entry(
-        self, kind: SubtypeKind, left: Instance, right: Instance
-    ) -> None:
-        if left.last_known_value is not None or right.last_known_value is not None:
-            # These are unlikely to match, due to the large space of
-            # possible values.  Avoid uselessly increasing cache sizes.
-            return
-        if len(self._negative_subtype_caches) > MAX_NEGATIVE_CACHE_TYPES:
-            self._negative_subtype_caches.clear()
-        cache = self._negative_subtype_caches.setdefault(right.type, {})
-        subcache = cache.setdefault(kind, set())
-        if len(subcache) > MAX_NEGATIVE_CACHE_ENTRIES:
-            subcache.clear()
-        cache.setdefault(kind, set()).add((left, right))
-
-    def reset_protocol_deps(self) -> None:
-        """Reset dependencies after a full run or before a daemon shutdown."""
-        self.proto_deps = {}
-        self._attempted_protocols.clear()
-        self._checked_against_members.clear()
-        self._rechecked_types.clear()
-
-    def record_protocol_subtype_check(self, left_type: TypeInfo, right_type: TypeInfo) -> None:
-        assert right_type.is_protocol
-        self._rechecked_types.add(left_type)
-        self._attempted_protocols.setdefault(left_type.fullname, set()).add(right_type.fullname)
-        self._checked_against_members.setdefault(left_type.fullname, set()).update(
-            right_type.protocol_members
-        )
-
-    def _snapshot_protocol_deps(self) -> dict[str, set[str]]:
-        """Collect protocol attribute dependencies found so far from registered subtype checks.
-
-        There are three kinds of protocol dependencies. For example, after a subtype check:
-
-            x: Proto = C()
-
-        the following dependencies will be generated:
-            1. ..., <SuperProto[wildcard]>, <Proto[wildcard]> -> <Proto>
-            2. ..., <B.attr>, <C.attr> -> <C> [for every attr in Proto members]
-            3. <C> -> Proto  # this one to invalidate the subtype cache
-
-        The first kind is generated immediately per-module in deps.py (see also an example there
-        for motivation why it is needed). While two other kinds are generated here after all
-        modules are type checked and we have recorded all the subtype checks. To understand these
-        two kinds, consider a simple example:
-
-            class A:
-                def __iter__(self) -> Iterator[int]:
-                    ...
-
-            it: Iterable[int] = A()
-
-        We add <a.A.__iter__> -> <a.A> to invalidate the assignment (module target in this case),
-        whenever the signature of a.A.__iter__ changes. We also add <a.A> -> typing.Iterable,
-        to invalidate the subtype caches of the latter. (Note that the same logic applies to
-        proper subtype checks, and calculating meets and joins, if this involves calling
-        'subtypes.is_protocol_implementation').
-        """
-        deps: dict[str, set[str]] = {}
-        for info in self._rechecked_types:
-            for attr in self._checked_against_members[info.fullname]:
-                # The need for full MRO here is subtle, during an update, base classes of
-                # a concrete class may not be reprocessed, so not all <B.x> -> <C.x> deps
-                # are added.
-                for base_info in info.mro[:-1]:
-                    trigger = make_trigger(f"{base_info.fullname}.{attr}")
-                    if "typing" in trigger or "builtins" in trigger:
-                        # TODO: avoid everything from typeshed
-                        continue
-                    deps.setdefault(trigger, set()).add(make_trigger(info.fullname))
-            for proto in self._attempted_protocols[info.fullname]:
-                trigger = make_trigger(info.fullname)
-                if "typing" in trigger or "builtins" in trigger:
-                    continue
-                # If any class that was checked against a protocol changes,
-                # we need to reset the subtype cache for the protocol.
-                #
-                # Note: strictly speaking, the protocol doesn't need to be
-                # re-checked, we only need to reset the cache, and its uses
-                # elsewhere are still valid (unless invalidated by other deps).
-                deps.setdefault(trigger, set()).add(proto)
-        return deps
-
-    def update_protocol_deps(self, second_map: dict[str, set[str]] | None = None) -> None:
-        """Update global protocol dependency map.
-
-        We update the global map incrementally, using a snapshot only from recently
-        type checked types. If second_map is given, update it as well. This is currently used
-        by FineGrainedBuildManager that maintains normal (non-protocol) dependencies.
-        """
-        assert self.proto_deps is not None, "This should not be called after failed cache load"
-        new_deps = self._snapshot_protocol_deps()
-        for trigger, targets in new_deps.items():
-            self.proto_deps.setdefault(trigger, set()).update(targets)
-        if second_map is not None:
-            for trigger, targets in new_deps.items():
-                second_map.setdefault(trigger, set()).update(targets)
-        self._rechecked_types.clear()
-        self._attempted_protocols.clear()
-        self._checked_against_members.clear()
-
-    def add_all_protocol_deps(self, deps: dict[str, set[str]]) -> None:
-        """Add all known protocol dependencies to deps.
-
-        This is used by tests and debug output, and also when collecting
-        all collected or loaded dependencies as part of build.
-        """
-        self.update_protocol_deps()  # just in case
-        if self.proto_deps is not None:
-            for trigger, targets in self.proto_deps.items():
-                deps.setdefault(trigger, set()).update(targets)
-
-
-type_state: Final = TypeState()
-
-
-def reset_global_state() -> None:
-    """Reset most existing global state.
-
-    Currently most of it is in this module. Few exceptions are strict optional status
-    and functools.lru_cache.
-    """
-    type_state.reset_all_subtype_caches()
-    type_state.reset_protocol_deps()
-    TypeVarId.next_raw_id = 1

jaclang/vendor/mypy/typetraverser.py

@@ -1,148 +0,0 @@
-from __future__ import annotations
-
-from typing import Iterable
-
-from mypy_extensions import trait
-
-from mypy.types import (
-    AnyType,
-    CallableArgument,
-    CallableType,
-    DeletedType,
-    EllipsisType,
-    ErasedType,
-    Instance,
-    LiteralType,
-    NoneType,
-    Overloaded,
-    Parameters,
-    ParamSpecType,
-    PartialType,
-    PlaceholderType,
-    RawExpressionType,
-    SyntheticTypeVisitor,
-    TupleType,
-    Type,
-    TypeAliasType,
-    TypedDictType,
-    TypeList,
-    TypeType,
-    TypeVarTupleType,
-    TypeVarType,
-    UnboundType,
-    UninhabitedType,
-    UnionType,
-    UnpackType,
-)
-
-
-@trait
-class TypeTraverserVisitor(SyntheticTypeVisitor[None]):
-    """Visitor that traverses all components of a type"""
-
-    # Atomic types
-
-    def visit_any(self, t: AnyType) -> None:
-        pass
-
-    def visit_uninhabited_type(self, t: UninhabitedType) -> None:
-        pass
-
-    def visit_none_type(self, t: NoneType) -> None:
-        pass
-
-    def visit_erased_type(self, t: ErasedType) -> None:
-        pass
-
-    def visit_deleted_type(self, t: DeletedType) -> None:
-        pass
-
-    def visit_type_var(self, t: TypeVarType) -> None:
-        # Note that type variable values and upper bound aren't treated as
-        # components, since they are components of the type variable
-        # definition. We want to traverse everything just once.
-        t.default.accept(self)
-
-    def visit_param_spec(self, t: ParamSpecType) -> None:
-        t.default.accept(self)
-
-    def visit_parameters(self, t: Parameters) -> None:
-        self.traverse_types(t.arg_types)
-
-    def visit_type_var_tuple(self, t: TypeVarTupleType) -> None:
-        t.default.accept(self)
-
-    def visit_literal_type(self, t: LiteralType) -> None:
-        t.fallback.accept(self)
-
-    # Composite types
-
-    def visit_instance(self, t: Instance) -> None:
-        self.traverse_types(t.args)
-
-    def visit_callable_type(self, t: CallableType) -> None:
-        # FIX generics
-        self.traverse_types(t.arg_types)
-        t.ret_type.accept(self)
-        t.fallback.accept(self)
-
-        if t.type_guard is not None:
-            t.type_guard.accept(self)
-
-        if t.type_is is not None:
-            t.type_is.accept(self)
-
-    def visit_tuple_type(self, t: TupleType) -> None:
-        self.traverse_types(t.items)
-        t.partial_fallback.accept(self)
-
-    def visit_typeddict_type(self, t: TypedDictType) -> None:
-        self.traverse_types(t.items.values())
-        t.fallback.accept(self)
-
-    def visit_union_type(self, t: UnionType) -> None:
-        self.traverse_types(t.items)
-
-    def visit_overloaded(self, t: Overloaded) -> None:
-        self.traverse_types(t.items)
-
-    def visit_type_type(self, t: TypeType) -> None:
-        t.item.accept(self)
-
-    # Special types (not real types)
-
-    def visit_callable_argument(self, t: CallableArgument) -> None:
-        t.typ.accept(self)
-
-    def visit_unbound_type(self, t: UnboundType) -> None:
-        self.traverse_types(t.args)
-
-    def visit_type_list(self, t: TypeList) -> None:
-        self.traverse_types(t.items)
-
-    def visit_ellipsis_type(self, t: EllipsisType) -> None:
-        pass
-
-    def visit_placeholder_type(self, t: PlaceholderType) -> None:
-        self.traverse_types(t.args)
-
-    def visit_partial_type(self, t: PartialType) -> None:
-        pass
-
-    def visit_raw_expression_type(self, t: RawExpressionType) -> None:
-        pass
-
-    def visit_type_alias_type(self, t: TypeAliasType) -> None:
-        # TODO: sometimes we want to traverse target as well
-        # We need to find a way to indicate explicitly the intent,
-        # maybe make this method abstract (like for TypeTranslator)?
-        self.traverse_types(t.args)
-
-    def visit_unpack_type(self, t: UnpackType) -> None:
-        t.type.accept(self)
-
-    # Helpers
-
-    def traverse_types(self, types: Iterable[Type]) -> None:
-        for typ in types:
-            typ.accept(self)