mypy-dev 1.9.0.dev0__py3-none-any.whl

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

@@ -0,0 +1,218 @@
+# 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: ...

mypy/typestate.py

@@ -0,0 +1,323 @@
+"""
+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

mypy/typetraverser.py

@@ -0,0 +1,142 @@
+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.
+        pass
+
+    def visit_param_spec(self, t: ParamSpecType) -> None:
+        pass
+
+    def visit_parameters(self, t: Parameters) -> None:
+        self.traverse_types(t.arg_types)
+
+    def visit_type_var_tuple(self, t: TypeVarTupleType) -> None:
+        pass
+
+    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)
+
+    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)