Add files using upload-large-folder tool

micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/mypy-1.20.2-py314h5a2d7ad_0/Lib/site-packages/mypy-1.20.2.dist-info/INSTALLER

@@ -0,0 +1 @@
+conda

micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/mypy-1.20.2-py314h5a2d7ad_0/Lib/site-packages/mypy-1.20.2.dist-info/METADATA

@@ -0,0 +1,56 @@
+Metadata-Version: 2.4
+Name: mypy
+Version: 1.20.2
+Summary: Optional static typing for Python
+Author-email: Jukka Lehtosalo <jukka.lehtosalo@iki.fi>
+License-Expression: MIT
+Project-URL: Homepage, https://www.mypy-lang.org/
+Project-URL: Documentation, https://mypy.readthedocs.io/en/stable/index.html
+Project-URL: Repository, https://github.com/python/mypy
+Project-URL: Changelog, https://github.com/python/mypy/blob/master/CHANGELOG.md
+Project-URL: Issues, https://github.com/python/mypy/issues
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+License-File: mypy/typeshed/LICENSE
+Requires-Dist: typing_extensions>=4.6.0; python_version < "3.15"
+Requires-Dist: typing_extensions>=4.14.0; python_version >= "3.15"
+Requires-Dist: mypy_extensions>=1.0.0
+Requires-Dist: pathspec>=1.0.0
+Requires-Dist: tomli>=1.1.0; python_version < "3.11"
+Requires-Dist: librt>=0.8.0; platform_python_implementation != "PyPy"
+Provides-Extra: dmypy
+Requires-Dist: psutil>=4.0; extra == "dmypy"
+Provides-Extra: mypyc
+Requires-Dist: setuptools>=50; extra == "mypyc"
+Provides-Extra: python2
+Provides-Extra: reports
+Requires-Dist: lxml; extra == "reports"
+Provides-Extra: install-types
+Requires-Dist: pip; extra == "install-types"
+Provides-Extra: faster-cache
+Requires-Dist: orjson; extra == "faster-cache"
+Provides-Extra: native-parser
+Requires-Dist: ast-serialize<1.0.0,>=0.1.1; extra == "native-parser"
+Dynamic: license-file
+
+Mypy -- Optional Static Typing for Python
+=========================================
+
+Add type annotations to your Python programs, and use mypy to type
+check them.  Mypy is essentially a Python linter on steroids, and it
+can catch many programming errors by analyzing your program, without
+actually having to run it.  Mypy has a powerful type system with
+features such as type inference, gradual typing, generics and union
+types.

micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/mypy-1.20.2-py314h5a2d7ad_0/Lib/site-packages/mypy-1.20.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: false
+Tag: cp314-cp314-win_amd64
+

micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/mypy-1.20.2-py314h5a2d7ad_0/Lib/site-packages/mypy-1.20.2.dist-info/direct_url.json

@@ -0,0 +1 @@
+{"dir_info": {}, "url": "file:///D:/bld/mypy-split_1776801208905/work"}

micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/mypy-1.20.2-py314h5a2d7ad_0/Lib/site-packages/mypy-1.20.2.dist-info/entry_points.txt

@@ -0,0 +1,6 @@
+[console_scripts]
+dmypy = mypy.dmypy.client:console_entry
+mypy = mypy.__main__:console_entry
+mypyc = mypyc.__main__:main
+stubgen = mypy.stubgen:main
+stubtest = mypy.stubtest:main

micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/mypy-1.20.2-py314h5a2d7ad_0/Lib/site-packages/mypy-1.20.2.dist-info/top_level.txt

@@ -0,0 +1,3 @@
+0aca9ce3d91742c5b361__mypyc
+mypy
+mypyc

micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/mypy-1.20.2-py314h5a2d7ad_0/Lib/site-packages/mypy/__init__.py

@@ -0,0 +1 @@
+# This page intentionally left blank

micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/mypy-1.20.2-py314h5a2d7ad_0/Lib/site-packages/mypy/__main__.py

@@ -0,0 +1,50 @@
+"""Mypy type checker command line tool."""
+
+from __future__ import annotations
+
+import os
+import sys
+import traceback
+
+from mypy.main import main, process_options
+from mypy.util import FancyFormatter
+
+
+def console_entry() -> None:
+    try:
+        main()
+        sys.stdout.flush()
+        sys.stderr.flush()
+    except BrokenPipeError:
+        # Python flushes standard streams on exit; redirect remaining output
+        # to devnull to avoid another BrokenPipeError at shutdown
+        devnull = os.open(os.devnull, os.O_WRONLY)
+        os.dup2(devnull, sys.stdout.fileno())
+        sys.exit(2)
+    except KeyboardInterrupt:
+        _, options = process_options(args=sys.argv[1:])
+        if options.show_traceback:
+            sys.stdout.write(traceback.format_exc())
+        formatter = FancyFormatter(sys.stdout, sys.stderr, False)
+        msg = "Interrupted\n"
+        sys.stdout.write(formatter.style(msg, color="red", bold=True))
+        sys.stdout.flush()
+        sys.stderr.flush()
+        sys.exit(2)
+    except Exception as e:
+        # Try reporting any uncaught error canonically, otherwise just flush the traceback.
+        try:
+            import mypy.errors
+
+            _, options = process_options(args=sys.argv[1:])
+            mypy.errors.report_internal_error(e, None, 0, None, options)
+        except Exception:
+            pass
+        sys.stdout.write(traceback.format_exc())
+        sys.stdout.flush()
+        sys.stderr.flush()
+        sys.exit(2)
+
+
+if __name__ == "__main__":
+    console_entry()

micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/mypy-1.20.2-py314h5a2d7ad_0/Lib/site-packages/mypy/api.py

@@ -0,0 +1,95 @@
+"""This module makes it possible to use mypy as part of a Python application.
+
+Since mypy still changes, the API was kept utterly simple and non-intrusive.
+It just mimics command line activation without starting a new interpreter.
+So the normal docs about the mypy command line apply.
+Changes in the command line version of mypy will be immediately usable.
+
+Just import this module and then call the 'run' function with a parameter of
+type List[str], containing what normally would have been the command line
+arguments to mypy.
+
+Function 'run' returns a Tuple[str, str, int], namely
+(<normal_report>, <error_report>, <exit_status>),
+in which <normal_report> is what mypy normally writes to sys.stdout,
+<error_report> is what mypy normally writes to sys.stderr and exit_status is
+the exit status mypy normally returns to the operating system.
+
+Any pretty formatting is left to the caller.
+
+The 'run_dmypy' function is similar, but instead mimics invocation of
+dmypy. Note that run_dmypy is not thread-safe and modifies sys.stdout
+and sys.stderr during its invocation.
+
+Note that these APIs don't support incremental generation of error
+messages.
+
+Trivial example of code using this module:
+
+import sys
+from mypy import api
+
+result = api.run(sys.argv[1:])
+
+if result[0]:
+    print('\nType checking report:\n')
+    print(result[0])  # stdout
+
+if result[1]:
+    print('\nError report:\n')
+    print(result[1])  # stderr
+
+print('\nExit status:', result[2])
+
+"""
+
+from __future__ import annotations
+
+import sys
+from collections.abc import Callable
+from io import StringIO
+from typing import TextIO
+
+
+def _run(main_wrapper: Callable[[TextIO, TextIO], None]) -> tuple[str, str, int]:
+    stdout = StringIO()
+    stderr = StringIO()
+
+    try:
+        main_wrapper(stdout, stderr)
+        exit_status = 0
+    except SystemExit as system_exit:
+        assert isinstance(system_exit.code, int)
+        exit_status = system_exit.code
+
+    return stdout.getvalue(), stderr.getvalue(), exit_status
+
+
+def run(args: list[str]) -> tuple[str, str, int]:
+    # Lazy import to avoid needing to import all of mypy to call run_dmypy
+    from mypy.main import main
+
+    return _run(
+        lambda stdout, stderr: main(args=args, stdout=stdout, stderr=stderr, clean_exit=True)
+    )
+
+
+def run_dmypy(args: list[str]) -> tuple[str, str, int]:
+    from mypy.dmypy.client import main
+
+    # A bunch of effort has been put into threading stdout and stderr
+    # through the main API to avoid the threadsafety problems of
+    # modifying sys.stdout/sys.stderr, but that hasn't been done for
+    # the dmypy client, so we just do the non-threadsafe thing.
+    def f(stdout: TextIO, stderr: TextIO) -> None:
+        old_stdout = sys.stdout
+        old_stderr = sys.stderr
+        try:
+            sys.stdout = stdout
+            sys.stderr = stderr
+            main(args)
+        finally:
+            sys.stdout = old_stdout
+            sys.stderr = old_stderr
+
+    return _run(f)

micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/mypy-1.20.2-py314h5a2d7ad_0/Lib/site-packages/mypy/applytype.py

@@ -0,0 +1,303 @@
+from __future__ import annotations
+
+from collections.abc import Callable, Iterable, Sequence
+
+import mypy.subtypes
+from mypy.erasetype import erase_typevars
+from mypy.expandtype import expand_type
+from mypy.nodes import Context, TypeInfo
+from mypy.type_visitor import TypeTranslator
+from mypy.typeops import get_all_type_vars
+from mypy.types import (
+    AnyType,
+    CallableType,
+    Instance,
+    Parameters,
+    ParamSpecFlavor,
+    ParamSpecType,
+    PartialType,
+    ProperType,
+    Type,
+    TypeAliasType,
+    TypeVarId,
+    TypeVarLikeType,
+    TypeVarTupleType,
+    TypeVarType,
+    UninhabitedType,
+    UnpackType,
+    get_proper_type,
+    remove_dups,
+)
+
+
+def get_target_type(
+    tvar: TypeVarLikeType,
+    type: Type,
+    callable: CallableType,
+    report_incompatible_typevar_value: Callable[[CallableType, Type, str, Context], None],
+    context: Context,
+    skip_unsatisfied: bool,
+) -> Type | None:
+    p_type = get_proper_type(type)
+    if isinstance(p_type, UninhabitedType) and tvar.has_default():
+        return tvar.default
+    if isinstance(tvar, ParamSpecType):
+        return type
+    if isinstance(tvar, TypeVarTupleType):
+        return type
+    assert isinstance(tvar, TypeVarType)
+    values = tvar.values
+    if values:
+        if isinstance(p_type, AnyType):
+            return type
+        if isinstance(p_type, TypeVarType) and p_type.values:
+            # Allow substituting T1 for T if every allowed value of T1
+            # is also a legal value of T.
+            if all(any(mypy.subtypes.is_same_type(v, v1) for v in values) for v1 in p_type.values):
+                return type
+        matching = []
+        for value in values:
+            if mypy.subtypes.is_subtype(type, value):
+                matching.append(value)
+        if matching:
+            best = matching[0]
+            # If there are more than one matching value, we select the narrowest
+            for match in matching[1:]:
+                if mypy.subtypes.is_subtype(match, best):
+                    best = match
+            return best
+        if skip_unsatisfied:
+            return None
+        report_incompatible_typevar_value(callable, type, tvar.name, context)
+    else:
+        upper_bound = tvar.upper_bound
+        if tvar.name == "Self":
+            # Internally constructed Self-types contain class type variables in upper bound,
+            # so we need to erase them to avoid false positives. This is safe because we do
+            # not support type variables in upper bounds of user defined types.
+            upper_bound = erase_typevars(upper_bound)
+        if not mypy.subtypes.is_subtype(type, upper_bound):
+            if skip_unsatisfied:
+                return None
+            report_incompatible_typevar_value(callable, type, tvar.name, context)
+    return type
+
+
+def apply_generic_arguments(
+    callable: CallableType,
+    orig_types: Sequence[Type | None],
+    report_incompatible_typevar_value: Callable[[CallableType, Type, str, Context], None],
+    context: Context,
+    skip_unsatisfied: bool = False,
+) -> CallableType:
+    """Apply generic type arguments to a callable type.
+
+    For example, applying [int] to 'def [T] (T) -> T' results in
+    'def (int) -> int'.
+
+    Note that each type can be None; in this case, it will not be applied.
+
+    If `skip_unsatisfied` is True, then just skip the types that don't satisfy type variable
+    bound or constraints, instead of giving an error.
+    """
+    tvars = callable.variables
+    assert len(orig_types) <= len(tvars)
+    # Check that inferred type variable values are compatible with allowed
+    # values and bounds.  Also, promote subtype values to allowed values.
+    # Create a map from type variable id to target type.
+    id_to_type: dict[TypeVarId, Type] = {}
+
+    for tvar, type in zip(tvars, orig_types):
+        assert not isinstance(type, PartialType), "Internal error: must never apply partial type"
+        if type is None:
+            continue
+
+        target_type = get_target_type(
+            tvar, type, callable, report_incompatible_typevar_value, context, skip_unsatisfied
+        )
+        if target_type is not None:
+            id_to_type[tvar.id] = target_type
+
+    # TODO: validate arg_kinds/arg_names for ParamSpec and TypeVarTuple replacements,
+    # not just type variable bounds above.
+    param_spec = callable.param_spec()
+    if param_spec is not None:
+        nt = id_to_type.get(param_spec.id)
+        if nt is not None:
+            # ParamSpec expansion is special-cased, so we need to always expand callable
+            # as a whole, not expanding arguments individually.
+            callable = expand_type(callable, id_to_type)
+            assert isinstance(callable, CallableType)
+            return callable.copy_modified(
+                variables=[tv for tv in tvars if tv.id not in id_to_type]
+            )
+
+    # Apply arguments to argument types.
+    var_arg = callable.var_arg()
+    if var_arg is not None and isinstance(var_arg.typ, UnpackType):
+        # Same as for ParamSpec, callable with variadic types needs to be expanded as a whole.
+        callable = expand_type(callable, id_to_type)
+        assert isinstance(callable, CallableType)
+        return callable.copy_modified(variables=[tv for tv in tvars if tv.id not in id_to_type])
+    else:
+        callable = callable.copy_modified(
+            arg_types=[expand_type(at, id_to_type) for at in callable.arg_types]
+        )
+
+    # Apply arguments to TypeGuard and TypeIs if any.
+    if callable.type_guard is not None:
+        type_guard = expand_type(callable.type_guard, id_to_type)
+    else:
+        type_guard = None
+    if callable.type_is is not None:
+        type_is = expand_type(callable.type_is, id_to_type)
+    else:
+        type_is = None
+
+    # The callable may retain some type vars if only some were applied.
+    # TODO: move apply_poly() logic here when new inference
+    # becomes universally used (i.e. in all passes + in unification).
+    # With this new logic we can actually *add* some new free variables.
+    remaining_tvars: list[TypeVarLikeType] = []
+    for tv in tvars:
+        if tv.id in id_to_type:
+            continue
+        if not tv.has_default():
+            remaining_tvars.append(tv)
+            continue
+        # TypeVarLike isn't in id_to_type mapping.
+        # Only expand the TypeVar default here.
+        typ = expand_type(tv, id_to_type)
+        assert isinstance(typ, TypeVarLikeType)
+        remaining_tvars.append(typ)
+
+    return callable.copy_modified(
+        ret_type=expand_type(callable.ret_type, id_to_type),
+        variables=remaining_tvars,
+        type_guard=type_guard,
+        type_is=type_is,
+    )
+
+
+def apply_poly(tp: CallableType, poly_tvars: Sequence[TypeVarLikeType]) -> CallableType | None:
+    """Make free type variables generic in the type if possible.
+
+    This will translate the type `tp` while trying to create valid bindings for
+    type variables `poly_tvars` while traversing the type. This follows the same rules
+    as we do during semantic analysis phase, examples:
+      * Callable[Callable[[T], T], T] -> def [T] (def (T) -> T) -> T
+      * Callable[[], Callable[[T], T]] -> def () -> def [T] (T -> T)
+      * List[T] -> None (not possible)
+    """
+    try:
+        return tp.copy_modified(
+            arg_types=[t.accept(PolyTranslator(poly_tvars)) for t in tp.arg_types],
+            ret_type=tp.ret_type.accept(PolyTranslator(poly_tvars)),
+            variables=[],
+        )
+    except PolyTranslationError:
+        return None
+
+
+class PolyTranslationError(Exception):
+    pass
+
+
+class PolyTranslator(TypeTranslator):
+    """Make free type variables generic in the type if possible.
+
+    See docstring for apply_poly() for details.
+    """
+
+    def __init__(
+        self,
+        poly_tvars: Iterable[TypeVarLikeType],
+        bound_tvars: frozenset[TypeVarLikeType] = frozenset(),
+        seen_aliases: frozenset[TypeInfo] = frozenset(),
+    ) -> None:
+        super().__init__()
+        self.poly_tvars = set(poly_tvars)
+        # This is a simplified version of TypeVarScope used during semantic analysis.
+        self.bound_tvars = bound_tvars
+        self.seen_aliases = seen_aliases
+
+    def collect_vars(self, t: CallableType | Parameters) -> list[TypeVarLikeType]:
+        found_vars = []
+        for arg in t.arg_types:
+            for tv in get_all_type_vars(arg):
+                if isinstance(tv, ParamSpecType):
+                    normalized: TypeVarLikeType = tv.copy_modified(
+                        flavor=ParamSpecFlavor.BARE, prefix=Parameters([], [], [])
+                    )
+                else:
+                    normalized = tv
+                if normalized in self.poly_tvars and normalized not in self.bound_tvars:
+                    found_vars.append(normalized)
+        return remove_dups(found_vars)
+
+    def visit_callable_type(self, t: CallableType) -> Type:
+        found_vars = self.collect_vars(t)
+        self.bound_tvars |= set(found_vars)
+        result = super().visit_callable_type(t)
+        self.bound_tvars -= set(found_vars)
+
+        assert isinstance(result, ProperType) and isinstance(result, CallableType)
+        result.variables = result.variables + tuple(found_vars)
+        return result
+
+    def visit_type_var(self, t: TypeVarType) -> Type:
+        if t in self.poly_tvars and t not in self.bound_tvars:
+            raise PolyTranslationError()
+        return super().visit_type_var(t)
+
+    def visit_param_spec(self, t: ParamSpecType) -> Type:
+        if t in self.poly_tvars and t not in self.bound_tvars:
+            raise PolyTranslationError()
+        return super().visit_param_spec(t)
+
+    def visit_type_var_tuple(self, t: TypeVarTupleType) -> Type:
+        if t in self.poly_tvars and t not in self.bound_tvars:
+            raise PolyTranslationError()
+        return super().visit_type_var_tuple(t)
+
+    def visit_type_alias_type(self, t: TypeAliasType) -> Type:
+        if not t.args:
+            return t.copy_modified()
+        if not t.is_recursive:
+            return get_proper_type(t).accept(self)
+        # We can't handle polymorphic application for recursive generic aliases
+        # without risking an infinite recursion, just give up for now.
+        raise PolyTranslationError()
+
+    def visit_instance(self, t: Instance) -> Type:
+        if t.type.has_param_spec_type:
+            # We need this special-casing to preserve the possibility to store a
+            # generic function in an instance type. Things like
+            #     forall T . Foo[[x: T], T]
+            # are not really expressible in current type system, but this looks like
+            # a useful feature, so let's keep it.
+            param_spec_index = next(
+                i for (i, tv) in enumerate(t.type.defn.type_vars) if isinstance(tv, ParamSpecType)
+            )
+            p = get_proper_type(t.args[param_spec_index])
+            if isinstance(p, Parameters):
+                found_vars = self.collect_vars(p)
+                self.bound_tvars |= set(found_vars)
+                new_args = [a.accept(self) for a in t.args]
+                self.bound_tvars -= set(found_vars)
+
+                repl = new_args[param_spec_index]
+                assert isinstance(repl, ProperType) and isinstance(repl, Parameters)
+                repl.variables = list(repl.variables) + list(found_vars)
+                return t.copy_modified(args=new_args)
+        # There is the same problem with callback protocols as with aliases
+        # (callback protocols are essentially more flexible aliases to callables).
+        if t.args and t.type.is_protocol and t.type.protocol_members == ["__call__"]:
+            if t.type in self.seen_aliases:
+                raise PolyTranslationError()
+            call = mypy.subtypes.find_member("__call__", t, t, is_operator=True)
+            assert call is not None
+            return call.accept(
+                PolyTranslator(self.poly_tvars, self.bound_tvars, self.seen_aliases | {t.type})
+            )
+        return super().visit_instance(t)

micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/mypy-1.20.2-py314h5a2d7ad_0/Lib/site-packages/mypy/argmap.py

@@ -0,0 +1,269 @@
+"""Utilities for mapping between actual and formal arguments (and their types)."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Sequence
+from typing import TYPE_CHECKING
+
+from mypy import nodes
+from mypy.maptype import map_instance_to_supertype
+from mypy.types import (
+    AnyType,
+    Instance,
+    ParamSpecType,
+    TupleType,
+    Type,
+    TypedDictType,
+    TypeOfAny,
+    TypeVarTupleType,
+    UnpackType,
+    get_proper_type,
+)
+
+if TYPE_CHECKING:
+    from mypy.infer import ArgumentInferContext
+
+
+def map_actuals_to_formals(
+    actual_kinds: list[nodes.ArgKind],
+    actual_names: Sequence[str | None] | None,
+    formal_kinds: list[nodes.ArgKind],
+    formal_names: Sequence[str | None],
+    actual_arg_type: Callable[[int], Type],
+) -> list[list[int]]:
+    """Calculate mapping between actual (caller) args and formals.
+
+    The result contains a list of caller argument indexes mapping to each
+    callee argument index, indexed by callee index.
+
+    The actual_arg_type argument should evaluate to the type of the actual
+    argument with the given index.
+    """
+    nformals = len(formal_kinds)
+    formal_to_actual: list[list[int]] = [[] for i in range(nformals)]
+    ambiguous_actual_kwargs: list[int] = []
+    fi = 0
+    for ai, actual_kind in enumerate(actual_kinds):
+        if actual_kind == nodes.ARG_POS:
+            if fi < nformals:
+                if not formal_kinds[fi].is_star():
+                    formal_to_actual[fi].append(ai)
+                    fi += 1
+                elif formal_kinds[fi] == nodes.ARG_STAR:
+                    formal_to_actual[fi].append(ai)
+        elif actual_kind == nodes.ARG_STAR:
+            # We need to know the actual type to map varargs.
+            actualt = get_proper_type(actual_arg_type(ai))
+            if isinstance(actualt, TupleType):
+                # A tuple actual maps to a fixed number of formals.
+                for _ in range(len(actualt.items)):
+                    if fi < nformals:
+                        if formal_kinds[fi] != nodes.ARG_STAR2:
+                            formal_to_actual[fi].append(ai)
+                        else:
+                            break
+                        if formal_kinds[fi] != nodes.ARG_STAR:
+                            fi += 1
+            else:
+                # Assume that it is an iterable (if it isn't, there will be
+                # an error later).
+                while fi < nformals:
+                    if formal_kinds[fi].is_named(star=True):
+                        break
+                    else:
+                        formal_to_actual[fi].append(ai)
+                    if formal_kinds[fi] == nodes.ARG_STAR:
+                        break
+                    fi += 1
+        elif actual_kind.is_named():
+            assert actual_names is not None, "Internal error: named kinds without names given"
+            name = actual_names[ai]
+            if name in formal_names and formal_kinds[formal_names.index(name)] != nodes.ARG_STAR:
+                formal_to_actual[formal_names.index(name)].append(ai)
+            elif nodes.ARG_STAR2 in formal_kinds:
+                formal_to_actual[formal_kinds.index(nodes.ARG_STAR2)].append(ai)
+        else:
+            assert actual_kind == nodes.ARG_STAR2
+            actualt = get_proper_type(actual_arg_type(ai))
+            if isinstance(actualt, TypedDictType):
+                for name in actualt.items:
+                    if name in formal_names:
+                        formal_to_actual[formal_names.index(name)].append(ai)
+                    elif nodes.ARG_STAR2 in formal_kinds:
+                        formal_to_actual[formal_kinds.index(nodes.ARG_STAR2)].append(ai)
+            else:
+                # We don't exactly know which **kwargs are provided by the
+                # caller, so we'll defer until all the other unambiguous
+                # actuals have been processed
+                ambiguous_actual_kwargs.append(ai)
+
+    if ambiguous_actual_kwargs:
+        # Assume the ambiguous kwargs will fill the remaining arguments.
+        #
+        # TODO: If there are also tuple varargs, we might be missing some potential
+        #       matches if the tuple was short enough to not match everything.
+        unmatched_formals = [
+            fi
+            for fi in range(nformals)
+            if (
+                formal_names[fi]
+                and (
+                    not formal_to_actual[fi]
+                    or actual_kinds[formal_to_actual[fi][0]] == nodes.ARG_STAR
+                )
+                and formal_kinds[fi] != nodes.ARG_STAR
+            )
+            or formal_kinds[fi] == nodes.ARG_STAR2
+        ]
+        for ai in ambiguous_actual_kwargs:
+            for fi in unmatched_formals:
+                formal_to_actual[fi].append(ai)
+
+    return formal_to_actual
+
+
+def map_formals_to_actuals(
+    actual_kinds: list[nodes.ArgKind],
+    actual_names: Sequence[str | None] | None,
+    formal_kinds: list[nodes.ArgKind],
+    formal_names: list[str | None],
+    actual_arg_type: Callable[[int], Type],
+) -> list[list[int]]:
+    """Calculate the reverse mapping of map_actuals_to_formals."""
+    formal_to_actual = map_actuals_to_formals(
+        actual_kinds, actual_names, formal_kinds, formal_names, actual_arg_type
+    )
+    # Now reverse the mapping.
+    actual_to_formal: list[list[int]] = [[] for _ in actual_kinds]
+    for formal, actuals in enumerate(formal_to_actual):
+        for actual in actuals:
+            actual_to_formal[actual].append(formal)
+    return actual_to_formal
+
+
+class ArgTypeExpander:
+    """Utility class for mapping actual argument types to formal arguments.
+
+    One of the main responsibilities is to expand caller tuple *args and TypedDict
+    **kwargs, and to keep track of which tuple/TypedDict items have already been
+    consumed.
+
+    Example:
+
+       def f(x: int, *args: str) -> None: ...
+       f(*(1, 'x', 1.1))
+
+    We'd call expand_actual_type three times:
+
+      1. The first call would provide 'int' as the actual type of 'x' (from '1').
+      2. The second call would provide 'str' as one of the actual types for '*args'.
+      2. The third call would provide 'float' as one of the actual types for '*args'.
+
+    A single instance can process all the arguments for a single call. Each call
+    needs a separate instance since instances have per-call state.
+    """
+
+    def __init__(self, context: ArgumentInferContext) -> None:
+        # Next tuple *args index to use.
+        self.tuple_index = 0
+        # Keyword arguments in TypedDict **kwargs used.
+        self.kwargs_used: set[str] | None = None
+        # Type context for `*` and `**` arg kinds.
+        self.context = context
+
+    def expand_actual_type(
+        self,
+        actual_type: Type,
+        actual_kind: nodes.ArgKind,
+        formal_name: str | None,
+        formal_kind: nodes.ArgKind,
+        allow_unpack: bool = False,
+    ) -> Type:
+        """Return the actual (caller) type(s) of a formal argument with the given kinds.
+
+        If the actual argument is a tuple *args, return the next individual tuple item that
+        maps to the formal arg.
+
+        If the actual argument is a TypedDict **kwargs, return the next matching typed dict
+        value type based on formal argument name and kind.
+
+        This is supposed to be called for each formal, in order. Call multiple times per
+        formal if multiple actuals map to a formal.
+        """
+        original_actual = actual_type
+        actual_type = get_proper_type(actual_type)
+        if actual_kind == nodes.ARG_STAR:
+            if isinstance(actual_type, TypeVarTupleType):
+                # This code path is hit when *Ts is passed to a callable and various
+                # special-handling didn't catch this. The best thing we can do is to use
+                # the upper bound.
+                actual_type = get_proper_type(actual_type.upper_bound)
+            if isinstance(actual_type, Instance) and actual_type.args:
+                from mypy.subtypes import is_subtype
+
+                if is_subtype(actual_type, self.context.iterable_type):
+                    return map_instance_to_supertype(
+                        actual_type, self.context.iterable_type.type
+                    ).args[0]
+                else:
+                    # We cannot properly unpack anything other
+                    # than `Iterable` type with `*`.
+                    # Just return `Any`, other parts of code would raise
+                    # a different error for improper use.
+                    return AnyType(TypeOfAny.from_error)
+            elif isinstance(actual_type, TupleType):
+                # Get the next tuple item of a tuple *arg.
+                if self.tuple_index >= len(actual_type.items):
+                    # Exhausted a tuple -- continue to the next *args.
+                    self.tuple_index = 1
+                else:
+                    self.tuple_index += 1
+                item = actual_type.items[self.tuple_index - 1]
+                if isinstance(item, UnpackType) and not allow_unpack:
+                    # An unpack item that doesn't have special handling, use upper bound as above.
+                    unpacked = get_proper_type(item.type)
+                    if isinstance(unpacked, TypeVarTupleType):
+                        fallback = get_proper_type(unpacked.upper_bound)
+                    else:
+                        fallback = unpacked
+                    assert (
+                        isinstance(fallback, Instance)
+                        and fallback.type.fullname == "builtins.tuple"
+                    )
+                    item = fallback.args[0]
+                return item
+            elif isinstance(actual_type, ParamSpecType):
+                # ParamSpec is valid in *args but it can't be unpacked.
+                return actual_type
+            else:
+                return AnyType(TypeOfAny.from_error)
+        elif actual_kind == nodes.ARG_STAR2:
+            from mypy.subtypes import is_subtype
+
+            if isinstance(actual_type, TypedDictType):
+                if self.kwargs_used is None:
+                    self.kwargs_used = set()
+                if formal_kind != nodes.ARG_STAR2 and formal_name in actual_type.items:
+                    # Lookup type based on keyword argument name.
+                    assert formal_name is not None
+                else:
+                    # Pick an arbitrary item if no specified keyword is expected.
+                    formal_name = (set(actual_type.items.keys()) - self.kwargs_used).pop()
+                self.kwargs_used.add(formal_name)
+                return actual_type.items[formal_name]
+            elif isinstance(actual_type, Instance) and is_subtype(
+                actual_type, self.context.mapping_type
+            ):
+                # Only `Mapping` type can be unpacked with `**`.
+                # Other types will produce an error somewhere else.
+                return map_instance_to_supertype(actual_type, self.context.mapping_type.type).args[
+                    1
+                ]
+            elif isinstance(actual_type, ParamSpecType):
+                # ParamSpec is valid in **kwargs but it can't be unpacked.
+                return actual_type
+            else:
+                return AnyType(TypeOfAny.from_error)
+        else:
+            # No translation for other kinds -- 1:1 mapping.
+            return original_actual

micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/mypy-1.20.2-py314h5a2d7ad_0/Lib/site-packages/mypy/binder.py

@@ -0,0 +1,709 @@
+from __future__ import annotations
+
+from collections import defaultdict
+from collections.abc import Iterator
+from contextlib import contextmanager
+from typing import Literal, NamedTuple, TypeAlias as _TypeAlias
+
+from mypy.erasetype import remove_instance_last_known_values
+from mypy.literals import Key, extract_var_from_literal_hash, literal, literal_hash, subkeys
+from mypy.nodes import (
+    LITERAL_NO,
+    Expression,
+    IndexExpr,
+    MemberExpr,
+    NameExpr,
+    RefExpr,
+    TypeInfo,
+    Var,
+)
+from mypy.options import Options
+from mypy.subtypes import is_same_type, is_subtype
+from mypy.typeops import make_simplified_union
+from mypy.types import (
+    AnyType,
+    Instance,
+    NoneType,
+    PartialType,
+    ProperType,
+    TupleType,
+    Type,
+    TypeOfAny,
+    TypeType,
+    TypeVarType,
+    UnionType,
+    UnpackType,
+    find_unpack_in_list,
+    flatten_nested_unions,
+    get_proper_type,
+)
+from mypy.typevars import fill_typevars_with_any
+
+BindableExpression: _TypeAlias = IndexExpr | MemberExpr | NameExpr
+
+
+class CurrentType(NamedTuple):
+    type: Type
+    from_assignment: bool
+
+
+class Frame:
+    """A Frame represents a specific point in the execution of a program.
+
+    It carries information about the current types of expressions at
+    that point, arising either from assignments to those expressions
+    or the result of isinstance checks and other type narrowing
+    operations. It also records whether it is possible to reach that
+    point at all.
+
+    We add a new frame wherenever there is a new scope or control flow
+    branching.
+
+    This information is not copied into a new Frame when it is pushed
+    onto the stack, so a given Frame only has information about types
+    that were assigned in that frame.
+
+    Expressions are stored in dicts using 'literal hashes' as keys (type
+    "Key"). These are hashable values derived from expression AST nodes
+    (only those that can be narrowed). literal_hash(expr) is used to
+    calculate the hashes. Note that this isn't directly related to literal
+    types -- the concept predates literal types.
+    """
+
+    def __init__(self, id: int, conditional_frame: bool = False) -> None:
+        self.id = id
+        self.types: dict[Key, CurrentType] = {}
+        self.unreachable = False
+        self.conditional_frame = conditional_frame
+        self.suppress_unreachable_warnings = False
+
+    def __repr__(self) -> str:
+        return f"Frame({self.id}, {self.types}, {self.unreachable}, {self.conditional_frame})"
+
+
+Assigns = defaultdict[Expression, list[tuple[Type, Type | None]]]
+
+
+class FrameContext:
+    """Context manager pushing a Frame to ConditionalTypeBinder.
+
+    See frame_context() below for documentation on parameters. We use this class
+    instead of @contextmanager as a mypyc-specific performance optimization.
+    """
+
+    def __init__(
+        self,
+        binder: ConditionalTypeBinder,
+        can_skip: bool,
+        fall_through: int,
+        break_frame: int,
+        continue_frame: int,
+        conditional_frame: bool,
+        try_frame: bool,
+        discard: bool,
+    ) -> None:
+        self.binder = binder
+        self.can_skip = can_skip
+        self.fall_through = fall_through
+        self.break_frame = break_frame
+        self.continue_frame = continue_frame
+        self.conditional_frame = conditional_frame
+        self.try_frame = try_frame
+        self.discard = discard
+
+    def __enter__(self) -> Frame:
+        assert len(self.binder.frames) > 1
+
+        if self.break_frame:
+            self.binder.break_frames.append(len(self.binder.frames) - self.break_frame)
+        if self.continue_frame:
+            self.binder.continue_frames.append(len(self.binder.frames) - self.continue_frame)
+        if self.try_frame:
+            self.binder.try_frames.add(len(self.binder.frames) - 1)
+
+        new_frame = self.binder.push_frame(self.conditional_frame)
+        if self.try_frame:
+            # An exception may occur immediately
+            self.binder.allow_jump(-1)
+        return new_frame
+
+    def __exit__(self, exc_type: object, exc_val: object, exc_tb: object) -> Literal[False]:
+        self.binder.pop_frame(self.can_skip, self.fall_through, discard=self.discard)
+
+        if self.break_frame:
+            self.binder.break_frames.pop()
+        if self.continue_frame:
+            self.binder.continue_frames.pop()
+        if self.try_frame:
+            self.binder.try_frames.remove(len(self.binder.frames) - 1)
+        return False
+
+
+class ConditionalTypeBinder:
+    """Keep track of conditional types of variables.
+
+    NB: Variables are tracked by literal hashes of expressions, so it is
+    possible to confuse the binder when there is aliasing. Example:
+
+        class A:
+            a: int | str
+
+        x = A()
+        lst = [x]
+        reveal_type(x.a)      # int | str
+        x.a = 1
+        reveal_type(x.a)      # int
+        reveal_type(lst[0].a) # int | str
+        lst[0].a = 'a'
+        reveal_type(x.a)      # int
+        reveal_type(lst[0].a) # str
+    """
+
+    # Stored assignments for situations with tuple/list lvalue and rvalue of union type.
+    # This maps an expression to a list of bound types for every item in the union type.
+    type_assignments: Assigns | None = None
+
+    def __init__(self, options: Options) -> None:
+        # Each frame gets an increasing, distinct id.
+        self.next_id = 1
+
+        # The stack of frames currently used.  These map
+        # literal_hash(expr) -- literals like 'foo.bar' --
+        # to types. The last element of this list is the
+        # top-most, current frame. Each earlier element
+        # records the state as of when that frame was last
+        # on top of the stack.
+        self.frames = [Frame(self._get_id())]
+
+        # For frames higher in the stack, we record the set of
+        # Frames that can escape there, either by falling off
+        # the end of the frame or by a loop control construct
+        # or raised exception. The last element of self.frames
+        # has no corresponding element in this list.
+        self.options_on_return: list[list[Frame]] = []
+
+        # Maps literal_hash(expr) to get_declaration(expr)
+        # for every expr stored in the binder
+        self.declarations: dict[Key, Type | None] = {}
+        # Set of other keys to invalidate if a key is changed, e.g. x -> {x.a, x[0]}
+        # Whenever a new key (e.g. x.a.b) is added, we update this
+        self.dependencies: dict[Key, set[Key]] = {}
+
+        # Whether the last pop changed the newly top frame on exit
+        self.last_pop_changed = False
+
+        # These are used to track control flow in try statements and loops.
+        self.try_frames: set[int] = set()
+        self.break_frames: list[int] = []
+        self.continue_frames: list[int] = []
+
+        # If True, initial assignment to a simple variable (e.g. "x", but not "x.y")
+        # is added to the binder. This allows more precise narrowing and more
+        # flexible inference of variable types (--allow-redefinition-new).
+        self.bind_all = options.allow_redefinition_new
+
+        # This tracks any externally visible changes in binder to invalidate
+        # expression caches when needed.
+        self.version = 0
+
+    def _get_id(self) -> int:
+        self.next_id += 1
+        return self.next_id
+
+    def _add_dependencies(self, key: Key, value: Key | None = None) -> None:
+        if value is None:
+            value = key
+        else:
+            self.dependencies.setdefault(key, set()).add(value)
+        for elt in subkeys(key):
+            self._add_dependencies(elt, value)
+
+    def push_frame(self, conditional_frame: bool = False) -> Frame:
+        """Push a new frame into the binder."""
+        f = Frame(self._get_id(), conditional_frame)
+        self.frames.append(f)
+        self.options_on_return.append([])
+        return f
+
+    def _put(self, key: Key, type: Type, from_assignment: bool, index: int = -1) -> None:
+        self.version += 1
+        self.frames[index].types[key] = CurrentType(type, from_assignment)
+
+    def _get(self, key: Key, index: int = -1) -> CurrentType | None:
+        if index < 0:
+            index += len(self.frames)
+        for i in range(index, -1, -1):
+            if key in self.frames[i].types:
+                return self.frames[i].types[key]
+        return None
+
+    @classmethod
+    def can_put_directly(cls, expr: Expression) -> bool:
+        """Will `.put()` on this expression be successful?
+
+        This is inlined in `.put()` because the logic is rather hot and must be kept
+        in sync.
+        """
+        return isinstance(expr, (IndexExpr, MemberExpr, NameExpr)) and literal(expr) > LITERAL_NO
+
+    def put(self, expr: Expression, typ: Type, *, from_assignment: bool = True) -> None:
+        """Directly set the narrowed type of expression (if it supports it).
+
+        This is used for isinstance() etc. Assignments should go through assign_type().
+        """
+        if not isinstance(expr, (IndexExpr, MemberExpr, NameExpr)):
+            return
+        if not literal(expr):
+            return
+        key = literal_hash(expr)
+        assert key is not None, "Internal error: binder tried to put non-literal"
+        if key not in self.declarations:
+            self.declarations[key] = get_declaration(expr)
+            self._add_dependencies(key)
+        self._put(key, typ, from_assignment)
+
+    def unreachable(self) -> None:
+        self.version += 1
+        self.frames[-1].unreachable = True
+
+    def suppress_unreachable_warnings(self) -> None:
+        self.frames[-1].suppress_unreachable_warnings = True
+
+    def get(self, expr: Expression) -> Type | None:
+        key = literal_hash(expr)
+        assert key is not None, "Internal error: binder tried to get non-literal"
+        found = self._get(key)
+        if found is None:
+            return None
+        return found.type
+
+    def is_unreachable(self) -> bool:
+        # TODO: Copy the value of unreachable into new frames to avoid
+        # this traversal on every statement?
+        return any(f.unreachable for f in self.frames)
+
+    def is_unreachable_warning_suppressed(self) -> bool:
+        return any(f.suppress_unreachable_warnings for f in self.frames)
+
+    def cleanse(self, expr: Expression) -> None:
+        """Remove all references to a Node from the binder."""
+        key = literal_hash(expr)
+        assert key is not None, "Internal error: binder tried cleanse non-literal"
+        self._cleanse_key(key)
+
+    def _cleanse_key(self, key: Key) -> None:
+        """Remove all references to a key from the binder."""
+        for frame in self.frames:
+            if key in frame.types:
+                del frame.types[key]
+
+    def update_from_options(self, frames: list[Frame]) -> bool:
+        """Update the frame to reflect that each key will be updated
+        as in one of the frames.  Return whether any item changes.
+
+        If a key is declared as AnyType, only update it if all the
+        options are the same.
+        """
+        all_reachable = all(not f.unreachable for f in frames)
+        if not all_reachable:
+            frames = [f for f in frames if not f.unreachable]
+        changed = False
+        keys = [key for f in frames for key in f.types]
+        if len(keys) > 1:
+            keys = list(set(keys))
+        for key in keys:
+            current_value = self._get(key)
+            resulting_values = [f.types.get(key, current_value) for f in frames]
+            # Keys can be narrowed using two different semantics. The new semantics
+            # is enabled for inferred variables when bind_all is true, and it allows
+            # variable types to be widened using subsequent assignments. This is
+            # not allowed for instance attributes and annotated variables.
+            var = extract_var_from_literal_hash(key)
+            old_semantics = (
+                not self.bind_all or var is None or not var.is_inferred and not var.is_argument
+            )
+            if old_semantics and any(x is None for x in resulting_values):
+                # We didn't know anything about key before
+                # (current_value must be None), and we still don't
+                # know anything about key in at least one possible frame.
+                continue
+
+            resulting_values = [x for x in resulting_values if x is not None]
+
+            if all_reachable and all(not x.from_assignment for x in resulting_values):
+                # Do not synthesize a new type if we encountered a conditional block
+                # (if, while or match-case) without assignments.
+                # See check-isinstance.test::testNoneCheckDoesNotMakeTypeVarOptional
+                # This is a safe assumption: the fact that we checked something with `is`
+                # or `isinstance` does not change the type of the value.
+                continue
+
+            # Remove exact duplicates to save pointless work later, this is
+            # a micro-optimization for --allow-redefinition-new.
+            seen_types = set()
+            resulting_types = []
+            for rv in resulting_values:
+                assert rv is not None
+                if rv.type in seen_types:
+                    continue
+                resulting_types.append(rv.type)
+                seen_types.add(rv.type)
+
+            type = resulting_types[0]
+            declaration_type = get_proper_type(self.declarations.get(key))
+            if isinstance(declaration_type, AnyType):
+                # At this point resulting values can't contain None, see continue above
+                if not all(is_same_type(type, t) for t in resulting_types[1:]):
+                    type = AnyType(TypeOfAny.from_another_any, source_any=declaration_type)
+            else:
+                possible_types = []
+                for t in resulting_types:
+                    assert t is not None
+                    possible_types.append(t)
+                if len(possible_types) == 1:
+                    # This is to avoid calling get_proper_type() unless needed, as this may
+                    # interfere with our (hacky) TypeGuard support.
+                    type = possible_types[0]
+                else:
+                    type = make_simplified_union(possible_types)
+                    # Legacy guard for corner case when the original type is TypeVarType.
+                    if isinstance(declaration_type, TypeVarType) and not is_subtype(
+                        type, declaration_type
+                    ):
+                        type = declaration_type
+                    # Try simplifying resulting type for unions involving variadic tuples.
+                    # Technically, everything is still valid without this step, but if we do
+                    # not do this, this may create long unions after exiting an if check like:
+                    #     x: tuple[int, ...]
+                    #     if len(x) < 10:
+                    #         ...
+                    # We want the type of x to be tuple[int, ...] after this block (if it is
+                    # still equivalent to such type).
+                    if isinstance(type, UnionType):
+                        type = collapse_variadic_union(type)
+                    if (
+                        old_semantics
+                        and isinstance(type, ProperType)
+                        and isinstance(type, UnionType)
+                    ):
+                        # Simplify away any extra Any's that were added to the declared
+                        # type when popping a frame.
+                        simplified = UnionType.make_union(
+                            [t for t in type.items if not isinstance(get_proper_type(t), AnyType)]
+                        )
+                        if simplified == self.declarations[key]:
+                            type = simplified
+            if (
+                current_value is None
+                or not is_same_type(type, current_value.type)
+                # Manually carry over any narrowing from hasattr() from inner frames. This is
+                # a bit ad-hoc, but our handling of hasattr() is on best effort basis anyway.
+                or isinstance(p_type := get_proper_type(type), Instance)
+                and p_type.extra_attrs
+            ):
+                self._put(key, type, from_assignment=True)
+                if current_value is not None or extract_var_from_literal_hash(key) is None:
+                    # We definitely learned something new
+                    changed = True
+                elif not changed:
+                    # If there is no current value compare with the declaration. This prevents
+                    # reporting false changes in cases like this:
+                    #     x: int
+                    #     if foo():
+                    #         x = 1
+                    #     else:
+                    #         x = 2
+                    # We check partial types and widening in accept_loop() separately, so
+                    # this should be safe.
+                    changed = declaration_type is not None and not is_same_type(
+                        type, declaration_type
+                    )
+
+        self.frames[-1].unreachable = not frames
+
+        return changed
+
+    def pop_frame(self, can_skip: bool, fall_through: int, *, discard: bool = False) -> Frame:
+        """Pop a frame and return it.
+
+        See frame_context() for documentation of fall_through and discard.
+        """
+
+        if fall_through > 0:
+            self.allow_jump(-fall_through)
+
+        result = self.frames.pop()
+        options = self.options_on_return.pop()
+
+        if discard:
+            self.last_pop_changed = False
+            return result
+
+        if can_skip:
+            options.insert(0, self.frames[-1])
+
+        self.last_pop_changed = self.update_from_options(options)
+
+        return result
+
+    @contextmanager
+    def accumulate_type_assignments(self) -> Iterator[Assigns]:
+        """Push a new map to collect assigned types in multiassign from union.
+
+        If this map is not None, actual binding is deferred until all items in
+        the union are processed (a union of collected items is later bound
+        manually by the caller).
+        """
+        old_assignments = None
+        if self.type_assignments is not None:
+            old_assignments = self.type_assignments
+        self.type_assignments = defaultdict(list)
+        yield self.type_assignments
+        self.type_assignments = old_assignments
+
+    def assign_type(self, expr: Expression, type: Type, declared_type: Type | None) -> None:
+        """Narrow type of expression through an assignment.
+
+        Do nothing if the expression doesn't support narrowing.
+
+        When not narrowing though an assignment (isinstance() etc.), use put()
+        directly. This omits some special-casing logic for assignments.
+        """
+        # We should erase last known value in binder, because if we are using it,
+        # it means that the target is not final, and therefore can't hold a literal.
+        type = remove_instance_last_known_values(type)
+
+        if self.type_assignments is not None:
+            # We are in a multiassign from union, defer the actual binding,
+            # just collect the types.
+            self.type_assignments[expr].append((type, declared_type))
+            return
+        if not isinstance(expr, (IndexExpr, MemberExpr, NameExpr)):
+            return
+        if not literal(expr):
+            return
+        self.invalidate_dependencies(expr)
+
+        if declared_type is None:
+            # Not sure why this happens.  It seems to mainly happen in
+            # member initialization.
+            return
+        if not is_subtype(type, declared_type):
+            # Pretty sure this is only happens when there's a type error.
+
+            # Ideally this function wouldn't be called if the
+            # expression has a type error, though -- do other kinds of
+            # errors cause this function to get called at invalid
+            # times?
+            return
+
+        p_declared = get_proper_type(declared_type)
+        p_type = get_proper_type(type)
+        if isinstance(p_type, AnyType):
+            # Any type requires some special casing, for both historical reasons,
+            # and to optimise user experience without sacrificing correctness too much.
+            if isinstance(expr, RefExpr) and isinstance(expr.node, Var) and expr.node.is_inferred:
+                # First case: a local/global variable without explicit annotation,
+                # in this case we just assign Any (essentially following the SSA logic).
+                self.put(expr, type)
+            elif isinstance(p_declared, UnionType):
+                all_items = flatten_nested_unions(p_declared.items)
+                if any(isinstance(get_proper_type(item), NoneType) for item in all_items):
+                    # Second case: explicit optional type, in this case we optimize for
+                    # a common pattern when an untyped value used as a fallback replacing None.
+                    new_items = [
+                        type if isinstance(get_proper_type(item), NoneType) else item
+                        for item in all_items
+                    ]
+                    self.put(expr, UnionType(new_items))
+                elif any(isinstance(get_proper_type(item), AnyType) for item in all_items):
+                    # Third case: a union already containing Any (most likely from
+                    # an un-imported name), in this case we allow assigning Any as well.
+                    self.put(expr, type)
+                else:
+                    # In all other cases we don't narrow to Any to minimize false negatives.
+                    self.put(expr, declared_type)
+            else:
+                self.put(expr, declared_type)
+        elif isinstance(p_declared, AnyType):
+            # Mirroring the first case above, we don't narrow to a precise type if the variable
+            # has an explicit `Any` type annotation.
+            if isinstance(expr, RefExpr) and isinstance(expr.node, Var) and expr.node.is_inferred:
+                self.put(expr, type)
+            else:
+                self.put(expr, declared_type)
+        else:
+            self.put(expr, type)
+
+        for i in self.try_frames:
+            # XXX This should probably not copy the entire frame, but
+            # just copy this variable into a single stored frame.
+            self.allow_jump(i)
+
+    def invalidate_dependencies(self, expr: BindableExpression) -> None:
+        """Invalidate knowledge of types that include expr, but not expr itself.
+
+        For example, when expr is foo.bar, invalidate foo.bar.baz.
+
+        It is overly conservative: it invalidates globally, including
+        in code paths unreachable from here.
+        """
+        key = literal_hash(expr)
+        assert key is not None
+        for dep in self.dependencies.get(key, set()):
+            self._cleanse_key(dep)
+
+    def allow_jump(self, index: int) -> None:
+        # self.frames and self.options_on_return have different lengths
+        # so make sure the index is positive
+        if index < 0:
+            index += len(self.options_on_return)
+        frame = Frame(self._get_id())
+        for f in self.frames[index + 1 :]:
+            frame.types.update(f.types)
+            if f.unreachable:
+                frame.unreachable = True
+        self.options_on_return[index].append(frame)
+
+    def handle_break(self) -> None:
+        self.allow_jump(self.break_frames[-1])
+        self.unreachable()
+
+    def handle_continue(self) -> None:
+        self.allow_jump(self.continue_frames[-1])
+        self.unreachable()
+
+    def frame_context(
+        self,
+        *,
+        can_skip: bool,
+        fall_through: int = 1,
+        break_frame: int = 0,
+        continue_frame: int = 0,
+        conditional_frame: bool = False,
+        try_frame: bool = False,
+        discard: bool = False,
+    ) -> FrameContext:
+        """Return a context manager that pushes/pops frames on enter/exit.
+
+        If can_skip is True, control flow is allowed to bypass the
+        newly-created frame.
+
+        If fall_through > 0, then it will allow control flow that
+        falls off the end of the frame to escape to its ancestor
+        `fall_through` levels higher. Otherwise, control flow ends
+        at the end of the frame.
+
+        If break_frame > 0, then 'break' statements within this frame
+        will jump out to the frame break_frame levels higher than the
+        frame created by this call to frame_context. Similarly, for
+        continue_frame and 'continue' statements.
+
+        If try_frame is true, then execution is allowed to jump at any
+        point within the newly created frame (or its descendants) to
+        its parent (i.e., to the frame that was on top before this
+        call to frame_context).
+
+        If discard is True, then this is a temporary throw-away frame
+        (used e.g. for isolation) and its effect will be discarded on pop.
+
+        After the context manager exits, self.last_pop_changed indicates
+        whether any types changed in the newly-topmost frame as a result
+        of popping this frame.
+        """
+        return FrameContext(
+            self,
+            can_skip=can_skip,
+            fall_through=fall_through,
+            break_frame=break_frame,
+            continue_frame=continue_frame,
+            conditional_frame=conditional_frame,
+            try_frame=try_frame,
+            discard=discard,
+        )
+
+    @contextmanager
+    def top_frame_context(self) -> Iterator[Frame]:
+        """A variant of frame_context for use at the top level of
+        a namespace (module, function, or class).
+        """
+        assert len(self.frames) == 1
+        yield self.push_frame()
+        self.pop_frame(True, 0)
+        assert len(self.frames) == 1
+
+
+def get_declaration(expr: BindableExpression) -> Type | None:
+    """Get the declared or inferred type of a RefExpr expression.
+
+    Return None if there is no type or the expression is not a RefExpr.
+    This can return None if the type hasn't been inferred yet.
+    """
+    if isinstance(expr, RefExpr):
+        if isinstance(expr.node, Var):
+            type = expr.node.type
+            if not isinstance(get_proper_type(type), PartialType):
+                return type
+        elif isinstance(expr.node, TypeInfo):
+            return TypeType(fill_typevars_with_any(expr.node))
+    return None
+
+
+def collapse_variadic_union(typ: UnionType) -> Type:
+    """Simplify a union involving variadic tuple if possible.
+
+    This will collapse a type like e.g.
+        tuple[X, Z] | tuple[X, Y, Z] | tuple[X, Y, Y, *tuple[Y, ...], Z]
+    back to
+        tuple[X, *tuple[Y, ...], Z]
+    which is equivalent, but much simpler form of the same type.
+    """
+    tuple_items = []
+    other_items = []
+    for t in typ.items:
+        p_t = get_proper_type(t)
+        if isinstance(p_t, TupleType):
+            tuple_items.append(p_t)
+        else:
+            other_items.append(t)
+    if len(tuple_items) <= 1:
+        # This type cannot be simplified further.
+        return typ
+    tuple_items = sorted(tuple_items, key=lambda t: len(t.items))
+    first = tuple_items[0]
+    last = tuple_items[-1]
+    unpack_index = find_unpack_in_list(last.items)
+    if unpack_index is None:
+        return typ
+    unpack = last.items[unpack_index]
+    assert isinstance(unpack, UnpackType)
+    unpacked = get_proper_type(unpack.type)
+    if not isinstance(unpacked, Instance):
+        return typ
+    assert unpacked.type.fullname == "builtins.tuple"
+    suffix = last.items[unpack_index + 1 :]
+
+    # Check that first item matches the expected pattern and infer prefix.
+    if len(first.items) < len(suffix):
+        return typ
+    if suffix and first.items[-len(suffix) :] != suffix:
+        return typ
+    if suffix:
+        prefix = first.items[: -len(suffix)]
+    else:
+        prefix = first.items
+
+    # Check that all middle types match the expected pattern as well.
+    arg = unpacked.args[0]
+    for i, it in enumerate(tuple_items[1:-1]):
+        if it.items != prefix + [arg] * (i + 1) + suffix:
+            return typ
+
+    # Check the last item (the one with unpack), and choose an appropriate simplified type.
+    if last.items != prefix + [arg] * (len(typ.items) - 1) + [unpack] + suffix:
+        return typ
+    if len(first.items) == 0:
+        simplified: Type = unpacked.copy_modified()
+    else:
+        simplified = TupleType(prefix + [unpack] + suffix, fallback=last.partial_fallback)
+    return UnionType.make_union([simplified] + other_items)

micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/mypy-1.20.2-py314h5a2d7ad_0/Lib/site-packages/mypy/bogus_type.py

@@ -0,0 +1,27 @@
+"""A Bogus[T] type alias for marking when we subvert the type system
+
+We need this for compiling with mypyc, which inserts runtime
+typechecks that cause problems when we subvert the type system. So
+when compiling with mypyc, we turn those places into Any, while
+keeping the types around for normal typechecks.
+
+Since this causes the runtime types to be Any, this is best used
+in places where efficient access to properties is not important.
+For those cases some other technique should be used.
+"""
+
+from __future__ import annotations
+
+from typing import Any, TypeVar
+
+from mypy_extensions import FlexibleAlias
+
+T = TypeVar("T")
+
+# This won't ever be true at runtime, but we consider it true during
+# mypyc compilations.
+MYPYC = False
+if MYPYC:
+    Bogus = FlexibleAlias[T, Any]
+else:
+    Bogus = FlexibleAlias[T, T]

micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/mypy-1.20.2-py314h5a2d7ad_0/Lib/site-packages/mypy/cache.py

@@ -0,0 +1,532 @@
+"""
+This module contains high-level logic for fixed format serialization.
+
+Lower-level parts are implemented in C in mypyc/lib-rt/internal/librt_internal.c
+Short summary of low-level functionality:
+* integers are automatically serialized as 1, 2, or 4 bytes, or arbitrary length.
+* str/bytes are serialized as size (1, 2, or 4 bytes) followed by bytes buffer.
+* floats are serialized as C doubles.
+
+At high-level we add type tags as needed so that our format is self-descriptive.
+More precisely:
+* False, True, and None are stored as just a tag: 0, 1, 2 correspondingly.
+* builtin primitives like int/str/bytes/float are stored as their type tag followed
+  by bare (low-level) representation of the value. Reserved tag range for primitives is
+  3 ... 19.
+* generic (heterogeneous) list are stored as tag, followed by bare size, followed by
+  sequence of tagged values.
+* homogeneous lists of primitives are stored as tag, followed by bare size, followed
+  by sequence of bare values.
+* reserved tag range for sequence-like builtins is 20 ... 29
+* currently we have only one mapping-like format: string-keyed dictionary with heterogeneous
+  values. It is stored as tag, followed by bare size, followed by sequence of pairs: bare
+  string key followed by tagged value.
+* reserved tag range for mapping-like builtins is 30 ... 39
+* there is an additional reserved tag range 40 ... 49 for any other builtin collections.
+* custom classes (like types, symbols etc.) are stored as tag, followed by a sequence of
+  tagged field values, followed by a special end tag 255. Names of class fields are
+  *not* stored, the caller should know the field names and order for the given class tag.
+* reserved tag range for symbols (TypeInfo, Var, etc) is 50 ... 79.
+* class Instance is the only exception from the above format (since it is the most common one).
+  It has two extra formats: few most common instances like "builtins.object" are stored as
+  instance tag followed by a secondary tag, other plain non-generic instances are stored as
+  instance tag followed by secondary tag followed by fullname as bare string. All generic
+  readers must handle these.
+* reserved tag range for Instance type formats is 80 ... 99, for other types it is 100 ... 149.
+* tag 254 is reserved for if we would ever need to extend the tag range to indicated second tag
+  page. Tags 150 ... 253 are free for everything else (e.g. AST nodes etc).
+
+General convention is that custom classes implement write() and read() methods for FF
+serialization. The write method should write both class tag and end tag. The read method
+conventionally *does not* read the start tag (to simplify logic for unions). Known exceptions
+are MypyFile.read() and SymbolTableNode.read(), since those two never appear in a union.
+
+If any of these details change, or if the structure of CacheMeta changes please
+bump CACHE_VERSION below.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import Any, Final, TypeAlias as _TypeAlias
+
+from librt.internal import (
+    ReadBuffer as ReadBuffer,
+    WriteBuffer as WriteBuffer,
+    read_bool as read_bool,
+    read_bytes as read_bytes_bare,
+    read_float as read_float_bare,
+    read_int as read_int_bare,
+    read_str as read_str_bare,
+    read_tag as read_tag,
+    write_bool as write_bool,
+    write_bytes as write_bytes_bare,
+    write_float as write_float_bare,
+    write_int as write_int_bare,
+    write_str as write_str_bare,
+    write_tag as write_tag,
+)
+from mypy_extensions import u8
+
+# High-level cache layout format
+CACHE_VERSION: Final = 7
+
+# Type used internally to represent errors:
+#   (path, line, column, end_line, end_column, severity, message, code)
+ErrorTuple: _TypeAlias = tuple[str | None, int, int, int, int, str, str, str | None]
+
+
+class CacheMeta:
+    """Class representing cache metadata for a module."""
+
+    def __init__(
+        self,
+        *,
+        id: str,
+        path: str,
+        mtime: int,
+        size: int,
+        hash: str,
+        dependencies: list[str],
+        data_mtime: int,
+        data_file: str,
+        suppressed: list[str],
+        imports_ignored: dict[int, list[str]],
+        options: dict[str, object],
+        suppressed_deps_opts: bytes,
+        dep_prios: list[int],
+        dep_lines: list[int],
+        dep_hashes: list[bytes],
+        interface_hash: bytes,
+        trans_dep_hash: bytes,
+        version_id: str,
+        ignore_all: bool,
+        plugin_data: Any,
+    ) -> None:
+        self.id = id
+        self.path = path
+        self.mtime = mtime  # source file mtime
+        self.size = size  # source file size
+        self.hash = hash  # source file hash (as a hex string for historical reasons)
+        self.dependencies = dependencies  # names of imported modules
+        self.data_mtime = data_mtime  # mtime of data_file
+        self.data_file = data_file  # path of <id>.data.json or <id>.data.ff
+        self.suppressed = suppressed  # dependencies that weren't imported
+        self.imports_ignored = imports_ignored  # type ignore codes by line
+        self.options = options  # build options snapshot
+        self.suppressed_deps_opts = suppressed_deps_opts  # hash of import-related options
+        # dep_prios and dep_lines are both aligned with dependencies + suppressed
+        self.dep_prios = dep_prios
+        self.dep_lines = dep_lines
+        # dep_hashes list is aligned with dependencies only
+        self.dep_hashes = dep_hashes  # list of interface_hash for dependencies
+        self.interface_hash = interface_hash  # hash representing the public interface
+        self.trans_dep_hash = trans_dep_hash  # hash of import structure (transitive)
+        self.version_id = version_id  # mypy version for cache invalidation
+        self.ignore_all = ignore_all  # if errors were ignored
+        self.plugin_data = plugin_data  # config data from plugins
+
+    def serialize(self) -> dict[str, Any]:
+        return {
+            "id": self.id,
+            "path": self.path,
+            "mtime": self.mtime,
+            "size": self.size,
+            "hash": self.hash,
+            "data_mtime": self.data_mtime,
+            "dependencies": self.dependencies,
+            "suppressed": self.suppressed,
+            "imports_ignored": {str(line): codes for line, codes in self.imports_ignored.items()},
+            "options": self.options,
+            "suppressed_deps_opts": self.suppressed_deps_opts.hex(),
+            "dep_prios": self.dep_prios,
+            "dep_lines": self.dep_lines,
+            "dep_hashes": [dep.hex() for dep in self.dep_hashes],
+            "interface_hash": self.interface_hash.hex(),
+            "trans_dep_hash": self.trans_dep_hash.hex(),
+            "version_id": self.version_id,
+            "ignore_all": self.ignore_all,
+            "plugin_data": self.plugin_data,
+        }
+
+    @classmethod
+    def deserialize(cls, meta: dict[str, Any], data_file: str) -> CacheMeta | None:
+        try:
+            return CacheMeta(
+                id=meta["id"],
+                path=meta["path"],
+                mtime=meta["mtime"],
+                size=meta["size"],
+                hash=meta["hash"],
+                dependencies=meta["dependencies"],
+                data_mtime=meta["data_mtime"],
+                data_file=data_file,
+                suppressed=meta["suppressed"],
+                imports_ignored={
+                    int(line): codes for line, codes in meta["imports_ignored"].items()
+                },
+                options=meta["options"],
+                suppressed_deps_opts=bytes.fromhex(meta["suppressed_deps_opts"]),
+                dep_prios=meta["dep_prios"],
+                dep_lines=meta["dep_lines"],
+                dep_hashes=[bytes.fromhex(dep) for dep in meta["dep_hashes"]],
+                interface_hash=bytes.fromhex(meta["interface_hash"]),
+                trans_dep_hash=bytes.fromhex(meta["trans_dep_hash"]),
+                version_id=meta["version_id"],
+                ignore_all=meta["ignore_all"],
+                plugin_data=meta["plugin_data"],
+            )
+        except (KeyError, ValueError):
+            return None
+
+    def write(self, data: WriteBuffer) -> None:
+        write_str(data, self.id)
+        write_str(data, self.path)
+        write_int(data, self.mtime)
+        write_int(data, self.size)
+        write_str(data, self.hash)
+        write_str_list(data, self.dependencies)
+        write_int(data, self.data_mtime)
+        write_str_list(data, self.suppressed)
+        write_int_bare(data, len(self.imports_ignored))
+        for line, codes in self.imports_ignored.items():
+            write_int(data, line)
+            write_str_list(data, codes)
+        write_json(data, self.options)
+        write_bytes(data, self.suppressed_deps_opts)
+        write_int_list(data, self.dep_prios)
+        write_int_list(data, self.dep_lines)
+        write_bytes_list(data, self.dep_hashes)
+        write_bytes(data, self.interface_hash)
+        write_bytes(data, self.trans_dep_hash)
+        write_str(data, self.version_id)
+        write_bool(data, self.ignore_all)
+        # Plugin data may be not a dictionary, so we use
+        # a more generic write_json_value() here.
+        write_json_value(data, self.plugin_data)
+
+    @classmethod
+    def read(cls, data: ReadBuffer, data_file: str) -> CacheMeta | None:
+        try:
+            return CacheMeta(
+                id=read_str(data),
+                path=read_str(data),
+                mtime=read_int(data),
+                size=read_int(data),
+                hash=read_str(data),
+                dependencies=read_str_list(data),
+                data_mtime=read_int(data),
+                data_file=data_file,
+                suppressed=read_str_list(data),
+                imports_ignored={
+                    read_int(data): read_str_list(data) for _ in range(read_int_bare(data))
+                },
+                options=read_json(data),
+                suppressed_deps_opts=read_bytes(data),
+                dep_prios=read_int_list(data),
+                dep_lines=read_int_list(data),
+                dep_hashes=read_bytes_list(data),
+                interface_hash=read_bytes(data),
+                trans_dep_hash=read_bytes(data),
+                version_id=read_str(data),
+                ignore_all=read_bool(data),
+                plugin_data=read_json_value(data),
+            )
+        except (ValueError, AssertionError):
+            return None
+
+
+# Always use this type alias to refer to type tags.
+Tag = u8
+
+# Primitives.
+LITERAL_FALSE: Final[Tag] = 0
+LITERAL_TRUE: Final[Tag] = 1
+LITERAL_NONE: Final[Tag] = 2
+LITERAL_INT: Final[Tag] = 3
+LITERAL_STR: Final[Tag] = 4
+LITERAL_BYTES: Final[Tag] = 5
+LITERAL_FLOAT: Final[Tag] = 6
+LITERAL_COMPLEX: Final[Tag] = 7
+
+# Collections.
+LIST_GEN: Final[Tag] = 20
+LIST_INT: Final[Tag] = 21
+LIST_STR: Final[Tag] = 22
+LIST_BYTES: Final[Tag] = 23
+TUPLE_GEN: Final[Tag] = 24
+DICT_STR_GEN: Final[Tag] = 30
+DICT_INT_GEN: Final[Tag] = 31
+
+# Misc classes.
+EXTRA_ATTRS: Final[Tag] = 150
+DT_SPEC: Final[Tag] = 151
+# Four integers representing source file (line, column) range.
+LOCATION: Final[Tag] = 152
+
+END_TAG: Final[Tag] = 255
+
+
+def read_literal(data: ReadBuffer, tag: Tag) -> int | str | bool | float:
+    if tag == LITERAL_INT:
+        return read_int_bare(data)
+    elif tag == LITERAL_STR:
+        return read_str_bare(data)
+    elif tag == LITERAL_FALSE:
+        return False
+    elif tag == LITERAL_TRUE:
+        return True
+    elif tag == LITERAL_FLOAT:
+        return read_float_bare(data)
+    assert False, f"Unknown literal tag {tag}"
+
+
+# There is an intentional asymmetry between read and write for literals because
+# None and/or complex values are only allowed in some contexts but not in others.
+def write_literal(data: WriteBuffer, value: int | str | bool | float | complex | None) -> None:
+    if isinstance(value, bool):
+        write_bool(data, value)
+    elif isinstance(value, int):
+        write_tag(data, LITERAL_INT)
+        write_int_bare(data, value)
+    elif isinstance(value, str):
+        write_tag(data, LITERAL_STR)
+        write_str_bare(data, value)
+    elif isinstance(value, float):
+        write_tag(data, LITERAL_FLOAT)
+        write_float_bare(data, value)
+    elif isinstance(value, complex):
+        write_tag(data, LITERAL_COMPLEX)
+        write_float_bare(data, value.real)
+        write_float_bare(data, value.imag)
+    else:
+        write_tag(data, LITERAL_NONE)
+
+
+def read_int(data: ReadBuffer) -> int:
+    assert read_tag(data) == LITERAL_INT
+    return read_int_bare(data)
+
+
+def write_int(data: WriteBuffer, value: int) -> None:
+    write_tag(data, LITERAL_INT)
+    write_int_bare(data, value)
+
+
+def read_str(data: ReadBuffer) -> str:
+    assert read_tag(data) == LITERAL_STR
+    return read_str_bare(data)
+
+
+def write_str(data: WriteBuffer, value: str) -> None:
+    write_tag(data, LITERAL_STR)
+    write_str_bare(data, value)
+
+
+def read_bytes(data: ReadBuffer) -> bytes:
+    assert read_tag(data) == LITERAL_BYTES
+    return read_bytes_bare(data)
+
+
+def write_bytes(data: WriteBuffer, value: bytes) -> None:
+    write_tag(data, LITERAL_BYTES)
+    write_bytes_bare(data, value)
+
+
+def read_int_opt(data: ReadBuffer) -> int | None:
+    tag = read_tag(data)
+    if tag == LITERAL_NONE:
+        return None
+    assert tag == LITERAL_INT
+    return read_int_bare(data)
+
+
+def write_int_opt(data: WriteBuffer, value: int | None) -> None:
+    if value is not None:
+        write_tag(data, LITERAL_INT)
+        write_int_bare(data, value)
+    else:
+        write_tag(data, LITERAL_NONE)
+
+
+def read_str_opt(data: ReadBuffer) -> str | None:
+    tag = read_tag(data)
+    if tag == LITERAL_NONE:
+        return None
+    assert tag == LITERAL_STR
+    return read_str_bare(data)
+
+
+def write_str_opt(data: WriteBuffer, value: str | None) -> None:
+    if value is not None:
+        write_tag(data, LITERAL_STR)
+        write_str_bare(data, value)
+    else:
+        write_tag(data, LITERAL_NONE)
+
+
+def read_int_list(data: ReadBuffer) -> list[int]:
+    assert read_tag(data) == LIST_INT
+    size = read_int_bare(data)
+    return [read_int_bare(data) for _ in range(size)]
+
+
+def write_int_list(data: WriteBuffer, value: list[int]) -> None:
+    write_tag(data, LIST_INT)
+    write_int_bare(data, len(value))
+    for item in value:
+        write_int_bare(data, item)
+
+
+def read_str_list(data: ReadBuffer) -> list[str]:
+    assert read_tag(data) == LIST_STR
+    size = read_int_bare(data)
+    return [read_str_bare(data) for _ in range(size)]
+
+
+def write_str_list(data: WriteBuffer, value: Sequence[str]) -> None:
+    write_tag(data, LIST_STR)
+    write_int_bare(data, len(value))
+    for item in value:
+        write_str_bare(data, item)
+
+
+def read_bytes_list(data: ReadBuffer) -> list[bytes]:
+    assert read_tag(data) == LIST_BYTES
+    size = read_int_bare(data)
+    return [read_bytes_bare(data) for _ in range(size)]
+
+
+def write_bytes_list(data: WriteBuffer, value: Sequence[bytes]) -> None:
+    write_tag(data, LIST_BYTES)
+    write_int_bare(data, len(value))
+    for item in value:
+        write_bytes_bare(data, item)
+
+
+def read_str_opt_list(data: ReadBuffer) -> list[str | None]:
+    assert read_tag(data) == LIST_GEN
+    size = read_int_bare(data)
+    return [read_str_opt(data) for _ in range(size)]
+
+
+def write_str_opt_list(data: WriteBuffer, value: list[str | None]) -> None:
+    write_tag(data, LIST_GEN)
+    write_int_bare(data, len(value))
+    for item in value:
+        write_str_opt(data, item)
+
+
+Value: _TypeAlias = None | int | str | bool
+
+# Our JSON format is somewhat non-standard as we distinguish lists and tuples.
+# This is convenient for some internal things, like mypyc plugin and error serialization.
+JsonValue: _TypeAlias = (
+    Value | list["JsonValue"] | dict[str, "JsonValue"] | tuple["JsonValue", ...]
+)
+
+
+def read_json_value(data: ReadBuffer) -> JsonValue:
+    tag = read_tag(data)
+    if tag == LITERAL_NONE:
+        return None
+    if tag == LITERAL_FALSE:
+        return False
+    if tag == LITERAL_TRUE:
+        return True
+    if tag == LITERAL_INT:
+        return read_int_bare(data)
+    if tag == LITERAL_STR:
+        return read_str_bare(data)
+    if tag == LIST_GEN:
+        size = read_int_bare(data)
+        return [read_json_value(data) for _ in range(size)]
+    if tag == TUPLE_GEN:
+        size = read_int_bare(data)
+        return tuple(read_json_value(data) for _ in range(size))
+    if tag == DICT_STR_GEN:
+        size = read_int_bare(data)
+        return {read_str_bare(data): read_json_value(data) for _ in range(size)}
+    assert False, f"Invalid JSON tag: {tag}"
+
+
+def write_json_value(data: WriteBuffer, value: JsonValue) -> None:
+    if value is None:
+        write_tag(data, LITERAL_NONE)
+    elif isinstance(value, bool):
+        write_bool(data, value)
+    elif isinstance(value, int):
+        write_tag(data, LITERAL_INT)
+        write_int_bare(data, value)
+    elif isinstance(value, str):
+        write_tag(data, LITERAL_STR)
+        write_str_bare(data, value)
+    elif isinstance(value, list):
+        write_tag(data, LIST_GEN)
+        write_int_bare(data, len(value))
+        for val in value:
+            write_json_value(data, val)
+    elif isinstance(value, tuple):
+        write_tag(data, TUPLE_GEN)
+        write_int_bare(data, len(value))
+        for val in value:
+            write_json_value(data, val)
+    elif isinstance(value, dict):
+        write_tag(data, DICT_STR_GEN)
+        write_int_bare(data, len(value))
+        for key in sorted(value):
+            write_str_bare(data, key)
+            write_json_value(data, value[key])
+    else:
+        assert False, f"Invalid JSON value: {value}"
+
+
+# These are functions for JSON *dictionaries* specifically. Unfortunately, we
+# must use imprecise types here, because the callers use imprecise types.
+def read_json(data: ReadBuffer) -> dict[str, Any]:
+    assert read_tag(data) == DICT_STR_GEN
+    size = read_int_bare(data)
+    return {read_str_bare(data): read_json_value(data) for _ in range(size)}
+
+
+def write_json(data: WriteBuffer, value: dict[str, Any]) -> None:
+    write_tag(data, DICT_STR_GEN)
+    write_int_bare(data, len(value))
+    for key in sorted(value):
+        write_str_bare(data, key)
+        write_json_value(data, value[key])
+
+
+def write_errors(data: WriteBuffer, errs: list[ErrorTuple]) -> None:
+    write_tag(data, LIST_GEN)
+    write_int_bare(data, len(errs))
+    for path, line, column, end_line, end_column, severity, message, code in errs:
+        write_tag(data, TUPLE_GEN)
+        write_str_opt(data, path)
+        write_int(data, line)
+        write_int(data, column)
+        write_int(data, end_line)
+        write_int(data, end_column)
+        write_str(data, severity)
+        write_str(data, message)
+        write_str_opt(data, code)
+
+
+def read_errors(data: ReadBuffer) -> list[ErrorTuple]:
+    assert read_tag(data) == LIST_GEN
+    result = []
+    for _ in range(read_int_bare(data)):
+        assert read_tag(data) == TUPLE_GEN
+        result.append(
+            (
+                read_str_opt(data),
+                read_int(data),
+                read_int(data),
+                read_int(data),
+                read_int(data),
+                read_str(data),
+                read_str(data),
+                read_str_opt(data),
+            )
+        )
+    return result

micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/mypy-1.20.2-py314h5a2d7ad_0/Lib/site-packages/mypy/checker_shared.py

@@ -0,0 +1,365 @@
+"""Shared definitions used by different parts of type checker."""
+
+from __future__ import annotations
+
+from abc import abstractmethod
+from collections.abc import Iterator, Sequence, Set as AbstractSet
+from contextlib import contextmanager
+from typing import NamedTuple, overload
+
+from mypy_extensions import trait
+
+from mypy.errorcodes import ErrorCode
+from mypy.errors import ErrorWatcher
+from mypy.message_registry import ErrorMessage
+from mypy.nodes import (
+    ArgKind,
+    Context,
+    Expression,
+    FuncItem,
+    LambdaExpr,
+    MypyFile,
+    Node,
+    RefExpr,
+    SymbolNode,
+    TypeInfo,
+    Var,
+)
+from mypy.plugin import CheckerPluginInterface, Plugin
+from mypy.types import (
+    CallableType,
+    Instance,
+    LiteralValue,
+    Overloaded,
+    PartialType,
+    TupleType,
+    Type,
+    TypedDictType,
+    TypeType,
+)
+from mypy.typevars import fill_typevars
+
+
+# An object that represents either a precise type or a type with an upper bound;
+# it is important for correct type inference with isinstance.
+class TypeRange(NamedTuple):
+    item: Type
+    is_upper_bound: bool  # False => precise type
+
+
+@trait
+class ExpressionCheckerSharedApi:
+    @abstractmethod
+    def accept(
+        self,
+        node: Expression,
+        type_context: Type | None = None,
+        allow_none_return: bool = False,
+        always_allow_any: bool = False,
+        is_callee: bool = False,
+    ) -> Type:
+        raise NotImplementedError
+
+    @abstractmethod
+    def analyze_ref_expr(self, e: RefExpr, lvalue: bool = False) -> Type:
+        raise NotImplementedError
+
+    @abstractmethod
+    def check_call(
+        self,
+        callee: Type,
+        args: list[Expression],
+        arg_kinds: list[ArgKind],
+        context: Context,
+        arg_names: Sequence[str | None] | None = None,
+        callable_node: Expression | None = None,
+        callable_name: str | None = None,
+        object_type: Type | None = None,
+        original_type: Type | None = None,
+    ) -> tuple[Type, Type]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def transform_callee_type(
+        self,
+        callable_name: str | None,
+        callee: Type,
+        args: list[Expression],
+        arg_kinds: list[ArgKind],
+        context: Context,
+        arg_names: Sequence[str | None] | None = None,
+        object_type: Type | None = None,
+    ) -> Type:
+        raise NotImplementedError
+
+    @abstractmethod
+    def method_fullname(self, object_type: Type, method_name: str) -> str | None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def check_method_call_by_name(
+        self,
+        method: str,
+        base_type: Type,
+        args: list[Expression],
+        arg_kinds: list[ArgKind],
+        context: Context,
+        original_type: Type | None = None,
+    ) -> tuple[Type, Type]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def visit_typeddict_index_expr(
+        self, td_type: TypedDictType, index: Expression, setitem: bool = False
+    ) -> tuple[Type, set[str]]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def infer_literal_expr_type(self, value: LiteralValue, fallback_name: str) -> Type:
+        raise NotImplementedError
+
+    @abstractmethod
+    def analyze_static_reference(
+        self,
+        node: SymbolNode,
+        ctx: Context,
+        is_lvalue: bool,
+        *,
+        include_modules: bool = True,
+        suppress_errors: bool = False,
+    ) -> Type:
+        raise NotImplementedError
+
+
+@trait
+class TypeCheckerSharedApi(CheckerPluginInterface):
+    plugin: Plugin
+    module_refs: set[str]
+    scope: CheckerScope
+    checking_missing_await: bool
+    allow_constructor_cache: bool
+
+    @property
+    @abstractmethod
+    def expr_checker(self) -> ExpressionCheckerSharedApi:
+        raise NotImplementedError
+
+    @abstractmethod
+    def named_type(self, name: str) -> Instance:
+        raise NotImplementedError
+
+    @abstractmethod
+    def lookup_typeinfo(self, fullname: str) -> TypeInfo:
+        raise NotImplementedError
+
+    @abstractmethod
+    def lookup_type(self, node: Expression) -> Type:
+        raise NotImplementedError
+
+    @abstractmethod
+    def handle_cannot_determine_type(self, name: str, context: Context) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def handle_partial_var_type(
+        self, typ: PartialType, is_lvalue: bool, node: Var, context: Context
+    ) -> Type:
+        raise NotImplementedError
+
+    @overload
+    @abstractmethod
+    def check_subtype(
+        self,
+        subtype: Type,
+        supertype: Type,
+        context: Context,
+        msg: str,
+        subtype_label: str | None = None,
+        supertype_label: str | None = None,
+        *,
+        notes: list[str] | None = None,
+        code: ErrorCode | None = None,
+        outer_context: Context | None = None,
+    ) -> bool: ...
+
+    @overload
+    @abstractmethod
+    def check_subtype(
+        self,
+        subtype: Type,
+        supertype: Type,
+        context: Context,
+        msg: ErrorMessage,
+        subtype_label: str | None = None,
+        supertype_label: str | None = None,
+        *,
+        notes: list[str] | None = None,
+        outer_context: Context | None = None,
+    ) -> bool: ...
+
+    # Unfortunately, mypyc doesn't support abstract overloads yet.
+    @abstractmethod
+    def check_subtype(
+        self,
+        subtype: Type,
+        supertype: Type,
+        context: Context,
+        msg: str | ErrorMessage,
+        subtype_label: str | None = None,
+        supertype_label: str | None = None,
+        *,
+        notes: list[str] | None = None,
+        code: ErrorCode | None = None,
+        outer_context: Context | None = None,
+    ) -> bool:
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_final_context(self) -> bool:
+        raise NotImplementedError
+
+    @overload
+    @abstractmethod
+    def conditional_types_with_intersection(
+        self,
+        expr_type: Type,
+        type_ranges: list[TypeRange] | None,
+        ctx: Context,
+        default: None = None,
+    ) -> tuple[Type | None, Type | None]: ...
+
+    @overload
+    @abstractmethod
+    def conditional_types_with_intersection(
+        self, expr_type: Type, type_ranges: list[TypeRange] | None, ctx: Context, default: Type
+    ) -> tuple[Type, Type]: ...
+
+    # Unfortunately, mypyc doesn't support abstract overloads yet.
+    @abstractmethod
+    def conditional_types_with_intersection(
+        self,
+        expr_type: Type,
+        type_ranges: list[TypeRange] | None,
+        ctx: Context,
+        default: Type | None = None,
+    ) -> tuple[Type | None, Type | None]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def narrow_type_by_identity_equality(
+        self,
+        operator: str,
+        operands: list[Expression],
+        operand_types: list[Type],
+        expr_indices: list[int],
+        narrowable_indices: AbstractSet[int],
+    ) -> tuple[dict[Expression, Type] | None, dict[Expression, Type] | None]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def check_deprecated(self, node: Node | None, context: Context) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def warn_deprecated(self, node: Node | None, context: Context) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def type_is_iterable(self, type: Type) -> bool:
+        raise NotImplementedError
+
+    @abstractmethod
+    def iterable_item_type(
+        self, it: Instance | CallableType | TypeType | Overloaded, context: Context
+    ) -> Type:
+        raise NotImplementedError
+
+    @abstractmethod
+    @contextmanager
+    def checking_await_set(self) -> Iterator[None]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_precise_awaitable_type(self, typ: Type, local_errors: ErrorWatcher) -> Type | None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def add_any_attribute_to_type(self, typ: Type, name: str) -> Type:
+        raise NotImplementedError
+
+    @abstractmethod
+    def is_defined_in_stub(self, typ: Instance, /) -> bool:
+        raise NotImplementedError
+
+
+class CheckerScope:
+    # We keep two stacks combined, to maintain the relative order
+    stack: list[TypeInfo | FuncItem | MypyFile]
+
+    def __init__(self, module: MypyFile) -> None:
+        self.stack = [module]
+
+    def current_function(self) -> FuncItem | None:
+        for e in reversed(self.stack):
+            if isinstance(e, FuncItem):
+                return e
+        return None
+
+    def top_level_function(self) -> FuncItem | None:
+        """Return top-level non-lambda function."""
+        for e in self.stack:
+            if isinstance(e, FuncItem) and not isinstance(e, LambdaExpr):
+                return e
+        return None
+
+    def active_class(self) -> TypeInfo | None:
+        if isinstance(self.stack[-1], TypeInfo):
+            return self.stack[-1]
+        return None
+
+    def enclosing_class(self, func: FuncItem | None = None) -> TypeInfo | None:
+        """Is there a class *directly* enclosing this function?"""
+        func = func or self.current_function()
+        assert func, "This method must be called from inside a function"
+        index = self.stack.index(func)
+        assert index, "CheckerScope stack must always start with a module"
+        enclosing = self.stack[index - 1]
+        if isinstance(enclosing, TypeInfo):
+            return enclosing
+        return None
+
+    def active_self_type(self) -> Instance | TupleType | None:
+        """An instance or tuple type representing the current class.
+
+        This returns None unless we are in class body or in a method.
+        In particular, inside a function nested in method this returns None.
+        """
+        info = self.active_class()
+        if not info and self.current_function():
+            info = self.enclosing_class()
+        if info:
+            return fill_typevars(info)
+        return None
+
+    def current_self_type(self) -> Instance | TupleType | None:
+        """Same as active_self_type() but handle functions nested in methods."""
+        for item in reversed(self.stack):
+            if isinstance(item, TypeInfo):
+                return fill_typevars(item)
+        return None
+
+    def is_top_level(self) -> bool:
+        """Is current scope top-level (no classes or functions)?"""
+        return len(self.stack) == 1
+
+    @contextmanager
+    def push_function(self, item: FuncItem) -> Iterator[None]:
+        self.stack.append(item)
+        yield
+        self.stack.pop()
+
+    @contextmanager
+    def push_class(self, info: TypeInfo) -> Iterator[None]:
+        self.stack.append(info)
+        yield
+        self.stack.pop()

micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/mypy-1.20.2-py314h5a2d7ad_0/Lib/site-packages/mypy/checker_state.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from collections.abc import Iterator
+from contextlib import contextmanager
+from typing import Final
+
+from mypy.checker_shared import TypeCheckerSharedApi
+
+# This is global mutable state. Don't add anything here unless there's a very
+# good reason.
+
+
+class TypeCheckerState:
+    # Wrap this in a class since it's faster that using a module-level attribute.
+
+    def __init__(self, type_checker: TypeCheckerSharedApi | None) -> None:
+        # Value varies by file being processed
+        self.type_checker = type_checker
+
+    @contextmanager
+    def set(self, value: TypeCheckerSharedApi) -> Iterator[None]:
+        saved = self.type_checker
+        self.type_checker = value
+        try:
+            yield
+        finally:
+            self.type_checker = saved
+
+
+checker_state: Final = TypeCheckerState(type_checker=None)

micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/mypy-1.20.2-py314h5a2d7ad_0/Lib/site-packages/mypy/checkmember.py

@@ -0,0 +1,1588 @@
+"""Type checking of attribute access"""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Sequence
+from typing import TypeVar, cast
+
+from mypy import message_registry, state
+from mypy.checker_shared import TypeCheckerSharedApi
+from mypy.erasetype import erase_typevars
+from mypy.expandtype import (
+    expand_self_type,
+    expand_type_by_instance,
+    freshen_all_functions_type_vars,
+)
+from mypy.maptype import map_instance_to_supertype
+from mypy.meet import is_overlapping_types
+from mypy.messages import MessageBuilder
+from mypy.nodes import (
+    ARG_POS,
+    ARG_STAR,
+    ARG_STAR2,
+    EXCLUDED_ENUM_ATTRIBUTES,
+    SYMBOL_FUNCBASE_TYPES,
+    Context,
+    Decorator,
+    Expression,
+    FuncBase,
+    FuncDef,
+    IndexExpr,
+    MypyFile,
+    NameExpr,
+    OverloadedFuncDef,
+    SymbolTable,
+    TempNode,
+    TypeAlias,
+    TypeInfo,
+    TypeVarLikeExpr,
+    Var,
+    is_final_node,
+)
+from mypy.plugin import AttributeContext
+from mypy.subtypes import is_subtype
+from mypy.typeops import (
+    bind_self,
+    erase_to_bound,
+    freeze_all_type_vars,
+    function_type,
+    get_all_type_vars,
+    make_simplified_union,
+    supported_self_type,
+    tuple_fallback,
+)
+from mypy.types import (
+    AnyType,
+    CallableType,
+    DeletedType,
+    FunctionLike,
+    Instance,
+    LiteralType,
+    NoneType,
+    Overloaded,
+    ParamSpecType,
+    PartialType,
+    ProperType,
+    TupleType,
+    Type,
+    TypedDictType,
+    TypeOfAny,
+    TypeType,
+    TypeVarLikeType,
+    TypeVarTupleType,
+    TypeVarType,
+    UninhabitedType,
+    UnionType,
+    get_proper_type,
+)
+
+
+class MemberContext:
+    """Information and objects needed to type check attribute access.
+
+    Look at the docstring of analyze_member_access for more information.
+    """
+
+    def __init__(
+        self,
+        *,
+        is_lvalue: bool,
+        is_super: bool,
+        is_operator: bool,
+        original_type: Type,
+        context: Context,
+        chk: TypeCheckerSharedApi,
+        self_type: Type | None = None,
+        module_symbol_table: SymbolTable | None = None,
+        no_deferral: bool = False,
+        is_self: bool = False,
+        rvalue: Expression | None = None,
+        suppress_errors: bool = False,
+        preserve_type_var_ids: bool = False,
+    ) -> None:
+        self.is_lvalue = is_lvalue
+        self.is_super = is_super
+        self.is_operator = is_operator
+        self.original_type = original_type
+        self.self_type = self_type or original_type
+        self.context = context  # Error context
+        self.chk = chk
+        self.msg = chk.msg
+        self.module_symbol_table = module_symbol_table
+        self.no_deferral = no_deferral
+        self.is_self = is_self
+        if rvalue is not None:
+            assert is_lvalue
+        self.rvalue = rvalue
+        self.suppress_errors = suppress_errors
+        # This attribute is only used to preserve old protocol member access logic.
+        # It is needed to avoid infinite recursion in cases involving self-referential
+        # generic methods, see find_member() for details. Do not use for other purposes!
+        self.preserve_type_var_ids = preserve_type_var_ids
+
+    def named_type(self, name: str) -> Instance:
+        return self.chk.named_type(name)
+
+    def not_ready_callback(self, name: str, context: Context) -> None:
+        self.chk.handle_cannot_determine_type(name, context)
+
+    def fail(self, msg: str) -> None:
+        if not self.suppress_errors:
+            self.msg.fail(msg, self.context)
+
+    def copy_modified(
+        self,
+        *,
+        self_type: Type | None = None,
+        is_lvalue: bool | None = None,
+        original_type: Type | None = None,
+    ) -> MemberContext:
+        mx = MemberContext(
+            is_lvalue=self.is_lvalue,
+            is_super=self.is_super,
+            is_operator=self.is_operator,
+            original_type=self.original_type,
+            context=self.context,
+            chk=self.chk,
+            self_type=self.self_type,
+            module_symbol_table=self.module_symbol_table,
+            no_deferral=self.no_deferral,
+            rvalue=self.rvalue,
+            suppress_errors=self.suppress_errors,
+            preserve_type_var_ids=self.preserve_type_var_ids,
+        )
+        if self_type is not None:
+            mx.self_type = self_type
+        if is_lvalue is not None:
+            mx.is_lvalue = is_lvalue
+        if original_type is not None:
+            mx.original_type = original_type
+        return mx
+
+
+def analyze_member_access(
+    name: str,
+    typ: Type,
+    context: Context,
+    *,
+    is_lvalue: bool,
+    is_super: bool,
+    is_operator: bool,
+    original_type: Type,
+    chk: TypeCheckerSharedApi,
+    override_info: TypeInfo | None = None,
+    in_literal_context: bool = False,
+    self_type: Type | None = None,
+    module_symbol_table: SymbolTable | None = None,
+    no_deferral: bool = False,
+    is_self: bool = False,
+    rvalue: Expression | None = None,
+    suppress_errors: bool = False,
+) -> Type:
+    """Return the type of attribute 'name' of 'typ'.
+
+    The actual implementation is in '_analyze_member_access' and this docstring
+    also applies to it.
+
+    This is a general operation that supports various different variations:
+
+      1. lvalue or non-lvalue access (setter or getter access)
+      2. supertype access when using super() (is_super == True and
+         'override_info' should refer to the supertype)
+
+    'original_type' is the most precise inferred or declared type of the base object
+    that we have available. When looking for an attribute of 'typ', we may perform
+    recursive calls targeting the fallback type, and 'typ' may become some supertype
+    of 'original_type'. 'original_type' is always preserved as the 'typ' type used in
+    the initial, non-recursive call. The 'self_type' is a component of 'original_type'
+    to which generic self should be bound (a narrower type that has a fallback to instance).
+    Currently, this is used only for union types.
+
+    'module_symbol_table' is passed to this function if 'typ' is actually a module,
+    and we want to keep track of the available attributes of the module (since they
+    are not available via the type object directly)
+
+    'rvalue' can be provided optionally to infer better setter type when is_lvalue is True,
+    most notably this helps for descriptors with overloaded __set__() method.
+
+    'suppress_errors' will skip any logic that is only needed to generate error messages.
+    Note that this more of a performance optimization, one should not rely on this to not
+    show any messages, as some may be show e.g. by callbacks called here,
+    use msg.filter_errors(), if needed.
+    """
+    mx = MemberContext(
+        is_lvalue=is_lvalue,
+        is_super=is_super,
+        is_operator=is_operator,
+        original_type=original_type,
+        context=context,
+        chk=chk,
+        self_type=self_type,
+        module_symbol_table=module_symbol_table,
+        no_deferral=no_deferral,
+        is_self=is_self,
+        rvalue=rvalue,
+        suppress_errors=suppress_errors,
+    )
+    result = _analyze_member_access(name, typ, mx, override_info)
+    possible_literal = get_proper_type(result)
+    if (
+        in_literal_context
+        and isinstance(possible_literal, Instance)
+        and possible_literal.last_known_value is not None
+    ):
+        return possible_literal.last_known_value
+    else:
+        return result
+
+
+def _analyze_member_access(
+    name: str, typ: Type, mx: MemberContext, override_info: TypeInfo | None = None
+) -> Type:
+    typ = get_proper_type(typ)
+    if isinstance(typ, Instance):
+        return analyze_instance_member_access(name, typ, mx, override_info)
+    elif isinstance(typ, AnyType):
+        # The base object has dynamic type.
+        return AnyType(TypeOfAny.from_another_any, source_any=typ)
+    elif isinstance(typ, UnionType):
+        return analyze_union_member_access(name, typ, mx)
+    elif isinstance(typ, FunctionLike) and typ.is_type_obj():
+        return analyze_type_callable_member_access(name, typ, mx)
+    elif isinstance(typ, TypeType):
+        return analyze_type_type_member_access(name, typ, mx, override_info)
+    elif isinstance(typ, TupleType):
+        # Actually look up from the fallback instance type.
+        return _analyze_member_access(name, tuple_fallback(typ), mx, override_info)
+    elif isinstance(typ, (LiteralType, FunctionLike)):
+        # Actually look up from the fallback instance type.
+        return _analyze_member_access(name, typ.fallback, mx, override_info)
+    elif isinstance(typ, TypedDictType):
+        return analyze_typeddict_access(name, typ, mx, override_info)
+    elif isinstance(typ, NoneType):
+        return analyze_none_member_access(name, typ, mx)
+    elif isinstance(typ, TypeVarLikeType):
+        if isinstance(typ, TypeVarType) and typ.values:
+            return _analyze_member_access(
+                name, make_simplified_union(typ.values), mx, override_info
+            )
+        return _analyze_member_access(name, typ.upper_bound, mx, override_info)
+    elif isinstance(typ, DeletedType):
+        if not mx.suppress_errors:
+            mx.msg.deleted_as_rvalue(typ, mx.context)
+        return AnyType(TypeOfAny.from_error)
+    elif isinstance(typ, UninhabitedType):
+        attr_type = UninhabitedType()
+        attr_type.ambiguous = typ.ambiguous
+        return attr_type
+    return report_missing_attribute(mx.original_type, typ, name, mx)
+
+
+def may_be_awaitable_attribute(
+    name: str, typ: Type, mx: MemberContext, override_info: TypeInfo | None = None
+) -> bool:
+    """Check if the given type has the attribute when awaited."""
+    if mx.chk.checking_missing_await:
+        # Avoid infinite recursion.
+        return False
+    with mx.chk.checking_await_set(), mx.msg.filter_errors() as local_errors:
+        aw_type = mx.chk.get_precise_awaitable_type(typ, local_errors)
+        if aw_type is None:
+            return False
+        _ = _analyze_member_access(
+            name, aw_type, mx.copy_modified(self_type=aw_type), override_info
+        )
+        return not local_errors.has_new_errors()
+
+
+def report_missing_attribute(
+    original_type: Type,
+    typ: Type,
+    name: str,
+    mx: MemberContext,
+    override_info: TypeInfo | None = None,
+) -> Type:
+    if mx.suppress_errors:
+        return AnyType(TypeOfAny.from_error)
+    error_code = mx.msg.has_no_attr(original_type, typ, name, mx.context, mx.module_symbol_table)
+    if not mx.msg.prefer_simple_messages():
+        if may_be_awaitable_attribute(name, typ, mx, override_info):
+            mx.msg.possible_missing_await(mx.context, error_code)
+    return AnyType(TypeOfAny.from_error)
+
+
+# The several functions that follow implement analyze_member_access for various
+# types and aren't documented individually.
+
+
+def analyze_instance_member_access(
+    name: str, typ: Instance, mx: MemberContext, override_info: TypeInfo | None
+) -> Type:
+    info = typ.type
+    if override_info:
+        info = override_info
+
+    method = info.get_method(name)
+
+    if name == "__init__" and not mx.is_super and not info.is_final:
+        if not method or not method.is_final:
+            # Accessing __init__ in statically typed code would compromise
+            # type safety unless used via super() or the method/class is final.
+            mx.fail(message_registry.CANNOT_ACCESS_INIT)
+            return AnyType(TypeOfAny.from_error)
+
+    # The base object has an instance type.
+
+    if (
+        state.find_occurrences
+        and info.name == state.find_occurrences[0]
+        and name == state.find_occurrences[1]
+        and not mx.suppress_errors
+    ):
+        mx.msg.note("Occurrence of '{}.{}'".format(*state.find_occurrences), mx.context)
+
+    # Look up the member. First look up the method dictionary.
+    if method and not isinstance(method, Decorator):
+        if mx.is_super and not mx.suppress_errors:
+            validate_super_call(method, mx)
+
+        if method.is_property:
+            assert isinstance(method, OverloadedFuncDef)
+            getter = method.items[0]
+            assert isinstance(getter, Decorator)
+            if mx.is_lvalue and getter.var.is_settable_property:
+                mx.chk.warn_deprecated(method.setter, mx.context)
+            return analyze_var(name, getter.var, typ, mx)
+
+        if mx.is_lvalue and not mx.suppress_errors:
+            mx.msg.cant_assign_to_method(mx.context)
+        if not isinstance(method, OverloadedFuncDef):
+            signature = function_type(method, mx.named_type("builtins.function"))
+        else:
+            if method.type is None:
+                # Overloads may be not ready if they are decorated. Handle this in same
+                # manner as we would handle a regular decorated function: defer if possible.
+                if not mx.no_deferral and method.items:
+                    mx.not_ready_callback(method.name, mx.context)
+                return AnyType(TypeOfAny.special_form)
+            assert isinstance(method.type, Overloaded)
+            signature = method.type
+        if not mx.preserve_type_var_ids:
+            signature = freshen_all_functions_type_vars(signature)
+        if not method.is_static:
+            if isinstance(method, (FuncDef, OverloadedFuncDef)) and method.is_trivial_self:
+                signature = bind_self_fast(signature, mx.self_type)
+            else:
+                signature = check_self_arg(
+                    signature, mx.self_type, method.is_class, mx.context, name, mx.msg
+                )
+                signature = bind_self(signature, mx.self_type, is_classmethod=method.is_class)
+        typ = map_instance_to_supertype(typ, method.info)
+        member_type = expand_type_by_instance(signature, typ)
+        freeze_all_type_vars(member_type)
+        return member_type
+    else:
+        # Not a method.
+        return analyze_member_var_access(name, typ, info, mx)
+
+
+def validate_super_call(node: FuncBase, mx: MemberContext) -> None:
+    unsafe_super = False
+    if isinstance(node, FuncDef) and node.is_trivial_body:
+        unsafe_super = True
+    elif isinstance(node, OverloadedFuncDef):
+        if node.impl:
+            impl = node.impl if isinstance(node.impl, FuncDef) else node.impl.func
+            unsafe_super = impl.is_trivial_body
+        elif not node.is_property and node.items:
+            assert isinstance(node.items[0], Decorator)
+            unsafe_super = node.items[0].func.is_trivial_body
+    if unsafe_super:
+        mx.msg.unsafe_super(node.name, node.info.name, mx.context)
+
+
+def analyze_type_callable_member_access(name: str, typ: FunctionLike, mx: MemberContext) -> Type:
+    # Class attribute.
+    # TODO super?
+    ret_type = typ.items[0].ret_type
+    assert isinstance(ret_type, ProperType)
+    if isinstance(ret_type, TupleType):
+        ret_type = tuple_fallback(ret_type)
+    if isinstance(ret_type, TypedDictType):
+        ret_type = ret_type.fallback
+    if isinstance(ret_type, LiteralType):
+        ret_type = ret_type.fallback
+    if isinstance(ret_type, Instance):
+        if not mx.is_operator:
+            # When Python sees an operator (eg `3 == 4`), it automatically translates that
+            # into something like `int.__eq__(3, 4)` instead of `(3).__eq__(4)` as an
+            # optimization.
+            #
+            # While it normally it doesn't matter which of the two versions are used, it
+            # does cause inconsistencies when working with classes. For example, translating
+            # `int == int` to `int.__eq__(int)` would not work since `int.__eq__` is meant to
+            # compare two int _instances_. What we really want is `type(int).__eq__`, which
+            # is meant to compare two types or classes.
+            #
+            # This check makes sure that when we encounter an operator, we skip looking up
+            # the corresponding method in the current instance to avoid this edge case.
+            # See https://github.com/python/mypy/pull/1787 for more info.
+            # TODO: do not rely on same type variables being present in all constructor overloads.
+            result = analyze_class_attribute_access(
+                ret_type, name, mx, original_vars=typ.items[0].variables, mcs_fallback=typ.fallback
+            )
+            if result:
+                return result
+        # Look up from the 'type' type.
+        return _analyze_member_access(name, typ.fallback, mx)
+    else:
+        assert False, f"Unexpected type {ret_type!r}"
+
+
+def analyze_type_type_member_access(
+    name: str, typ: TypeType, mx: MemberContext, override_info: TypeInfo | None
+) -> Type:
+    # Similar to analyze_type_callable_attribute_access.
+    item = None
+    fallback = mx.named_type("builtins.type")
+    if isinstance(typ.item, Instance):
+        item = typ.item
+    elif isinstance(typ.item, AnyType):
+        with mx.msg.filter_errors():
+            return _analyze_member_access(name, fallback, mx, override_info)
+    elif isinstance(typ.item, TypeVarType):
+        upper_bound = get_proper_type(typ.item.upper_bound)
+        if isinstance(upper_bound, Instance):
+            item = upper_bound
+        elif isinstance(upper_bound, UnionType):
+            return _analyze_member_access(
+                name,
+                TypeType.make_normalized(upper_bound, line=typ.line, column=typ.column),
+                mx,
+                override_info,
+            )
+        elif isinstance(upper_bound, TupleType):
+            item = tuple_fallback(upper_bound)
+        elif isinstance(upper_bound, AnyType):
+            with mx.msg.filter_errors():
+                return _analyze_member_access(name, fallback, mx, override_info)
+    elif isinstance(typ.item, TupleType):
+        item = tuple_fallback(typ.item)
+    elif isinstance(typ.item, FunctionLike) and typ.item.is_type_obj():
+        item = typ.item.fallback
+    elif isinstance(typ.item, TypeType):
+        # Access member on metaclass object via Type[Type[C]]
+        if isinstance(typ.item.item, Instance):
+            item = typ.item.item.type.metaclass_type
+    ignore_messages = False
+
+    if item is not None:
+        fallback = item.type.metaclass_type or fallback
+
+    if item and not mx.is_operator:
+        # See comment above for why operators are skipped
+        result = analyze_class_attribute_access(
+            item, name, mx, mcs_fallback=fallback, override_info=override_info
+        )
+        if result:
+            if not (isinstance(get_proper_type(result), AnyType) and item.type.fallback_to_any):
+                return result
+            else:
+                # We don't want errors on metaclass lookup for classes with Any fallback
+                ignore_messages = True
+
+    with mx.msg.filter_errors(filter_errors=ignore_messages):
+        return _analyze_member_access(name, fallback, mx, override_info)
+
+
+def analyze_union_member_access(name: str, typ: UnionType, mx: MemberContext) -> Type:
+    with mx.msg.disable_type_names():
+        results = []
+        for subtype in typ.relevant_items():
+            # Self types should be bound to every individual item of a union.
+            item_mx = mx.copy_modified(self_type=subtype)
+            results.append(_analyze_member_access(name, subtype, item_mx))
+    return make_simplified_union(results)
+
+
+def analyze_none_member_access(name: str, typ: NoneType, mx: MemberContext) -> Type:
+    if name == "__bool__":
+        literal_false = LiteralType(False, fallback=mx.named_type("builtins.bool"))
+        return CallableType(
+            arg_types=[],
+            arg_kinds=[],
+            arg_names=[],
+            ret_type=literal_false,
+            fallback=mx.named_type("builtins.function"),
+        )
+    else:
+        return _analyze_member_access(name, mx.named_type("builtins.object"), mx)
+
+
+def analyze_member_var_access(
+    name: str, itype: Instance, info: TypeInfo, mx: MemberContext
+) -> Type:
+    """Analyse attribute access that does not target a method.
+
+    This is logically part of analyze_member_access and the arguments are similar.
+
+    original_type is the type of E in the expression E.var
+    """
+    # It was not a method. Try looking up a variable.
+    node = info.get(name)
+    v = node.node if node else None
+
+    mx.chk.warn_deprecated(v, mx.context)
+
+    vv = v
+    is_trivial_self = False
+    if isinstance(vv, Decorator):
+        # The associated Var node of a decorator contains the type.
+        v = vv.var
+        is_trivial_self = vv.func.is_trivial_self and not vv.decorators
+        if mx.is_super and not mx.suppress_errors:
+            validate_super_call(vv.func, mx)
+    if isinstance(v, FuncDef):
+        assert False, "Did not expect a function"
+    if isinstance(v, MypyFile):
+        # Special case: accessing module on instances is allowed, but will not
+        # be recorded by semantic analyzer.
+        mx.chk.module_refs.add(v.fullname)
+
+    if isinstance(vv, (TypeInfo, TypeAlias, MypyFile, TypeVarLikeExpr)):
+        # If the associated variable is a TypeInfo synthesize a Var node for
+        # the purposes of type checking.  This enables us to type check things
+        # like accessing class attributes on an inner class. Similar we allow
+        # using qualified type aliases in runtime context. For example:
+        #     class C:
+        #         A = List[int]
+        #     x = C.A() <- this is OK
+        typ = mx.chk.expr_checker.analyze_static_reference(vv, mx.context, mx.is_lvalue)
+        v = Var(name, type=typ)
+        v.info = info
+
+    if isinstance(v, Var):
+        implicit = info[name].implicit
+
+        # An assignment to final attribute is always an error,
+        # independently of types.
+        if mx.is_lvalue and not mx.chk.get_final_context():
+            check_final_member(name, info, mx.msg, mx.context)
+
+        return analyze_var(name, v, itype, mx, implicit=implicit, is_trivial_self=is_trivial_self)
+    elif (
+        not v
+        and name not in ["__getattr__", "__setattr__", "__getattribute__"]
+        and not mx.is_operator
+        and mx.module_symbol_table is None
+    ):
+        # Above we skip ModuleType.__getattr__ etc. if we have a
+        # module symbol table, since the symbol table allows precise
+        # checking.
+        if not mx.is_lvalue:
+            for method_name in ("__getattribute__", "__getattr__"):
+                method = info.get_method(method_name)
+
+                # __getattribute__ is defined on builtins.object and returns Any, so without
+                # the guard this search will always find object.__getattribute__ and conclude
+                # that the attribute exists
+                if method and method.info.fullname != "builtins.object":
+                    bound_method = analyze_decorator_or_funcbase_access(
+                        defn=method, itype=itype, name=method_name, mx=mx
+                    )
+                    typ = map_instance_to_supertype(itype, method.info)
+                    getattr_type = get_proper_type(expand_type_by_instance(bound_method, typ))
+                    if isinstance(getattr_type, CallableType):
+                        result = getattr_type.ret_type
+                    else:
+                        result = getattr_type
+
+                    # Call the attribute hook before returning.
+                    fullname = f"{method.info.fullname}.{name}"
+                    hook = mx.chk.plugin.get_attribute_hook(fullname)
+                    if hook:
+                        result = hook(
+                            AttributeContext(
+                                get_proper_type(mx.original_type),
+                                result,
+                                mx.is_lvalue,
+                                mx.context,
+                                mx.chk,
+                            )
+                        )
+                    return result
+        else:
+            setattr_meth = info.get_method("__setattr__")
+            if setattr_meth and setattr_meth.info.fullname != "builtins.object":
+                bound_type = analyze_decorator_or_funcbase_access(
+                    defn=setattr_meth,
+                    itype=itype,
+                    name="__setattr__",
+                    mx=mx.copy_modified(is_lvalue=False),
+                )
+                typ = map_instance_to_supertype(itype, setattr_meth.info)
+                setattr_type = get_proper_type(expand_type_by_instance(bound_type, typ))
+                if isinstance(setattr_type, CallableType) and len(setattr_type.arg_types) > 0:
+                    return setattr_type.arg_types[-1]
+
+    if itype.type.fallback_to_any:
+        return AnyType(TypeOfAny.special_form)
+
+    # Could not find the member.
+    if itype.extra_attrs and name in itype.extra_attrs.attrs:
+        # For modules use direct symbol table lookup.
+        if not itype.extra_attrs.mod_name:
+            return itype.extra_attrs.attrs[name]
+
+    if mx.is_super and not mx.suppress_errors:
+        mx.msg.undefined_in_superclass(name, mx.context)
+        return AnyType(TypeOfAny.from_error)
+    else:
+        ret = report_missing_attribute(mx.original_type, itype, name, mx)
+        # Avoid paying double jeopardy if we can't find the member due to --no-implicit-reexport
+        if (
+            mx.module_symbol_table is not None
+            and name in mx.module_symbol_table
+            and not mx.module_symbol_table[name].module_public
+        ):
+            v = mx.module_symbol_table[name].node
+            e = NameExpr(name)
+            e.set_line(mx.context)
+            e.node = v
+            return mx.chk.expr_checker.analyze_ref_expr(e, lvalue=mx.is_lvalue)
+        return ret
+
+
+def check_final_member(name: str, info: TypeInfo, msg: MessageBuilder, ctx: Context) -> None:
+    """Give an error if the name being assigned was declared as final."""
+    for base in info.mro:
+        sym = base.names.get(name)
+        if sym and is_final_node(sym.node):
+            msg.cant_assign_to_final(name, attr_assign=True, ctx=ctx)
+
+
+def analyze_descriptor_access(descriptor_type: Type, mx: MemberContext) -> Type:
+    """Type check descriptor access.
+
+    Arguments:
+        descriptor_type: The type of the descriptor attribute being accessed
+            (the type of ``f`` in ``a.f`` when ``f`` is a descriptor).
+        mx: The current member access context.
+    Return:
+        The return type of the appropriate ``__get__/__set__`` overload for the descriptor.
+    """
+    instance_type = get_proper_type(mx.self_type)
+    orig_descriptor_type = descriptor_type
+    descriptor_type = get_proper_type(descriptor_type)
+
+    if isinstance(descriptor_type, UnionType):
+        # Map the access over union types
+        return make_simplified_union(
+            [analyze_descriptor_access(typ, mx) for typ in descriptor_type.items]
+        )
+    elif not isinstance(descriptor_type, Instance):
+        return orig_descriptor_type
+
+    if not mx.is_lvalue and not descriptor_type.type.has_readable_member("__get__"):
+        return orig_descriptor_type
+
+    # We do this check first to accommodate for descriptors with only __set__ method.
+    # If there is no __set__, we type-check that the assigned value matches
+    # the return type of __get__. This doesn't match the python semantics,
+    # (which allow you to override the descriptor with any value), but preserves
+    # the type of accessing the attribute (even after the override).
+    if mx.is_lvalue and descriptor_type.type.has_readable_member("__set__"):
+        return analyze_descriptor_assign(descriptor_type, mx)
+
+    if mx.is_lvalue and not descriptor_type.type.has_readable_member("__get__"):
+        # This turned out to be not a descriptor after all.
+        return orig_descriptor_type
+
+    dunder_get = descriptor_type.type.get_method("__get__")
+    if dunder_get is None:
+        mx.fail(
+            message_registry.DESCRIPTOR_GET_NOT_CALLABLE.format(
+                descriptor_type.str_with_options(mx.msg.options)
+            )
+        )
+        return AnyType(TypeOfAny.from_error)
+
+    bound_method = analyze_decorator_or_funcbase_access(
+        defn=dunder_get,
+        itype=descriptor_type,
+        name="__get__",
+        mx=mx.copy_modified(self_type=descriptor_type),
+    )
+
+    typ = map_instance_to_supertype(descriptor_type, dunder_get.info)
+    dunder_get_type = expand_type_by_instance(bound_method, typ)
+
+    if isinstance(instance_type, FunctionLike) and instance_type.is_type_obj():
+        owner_type = instance_type.items[0].ret_type
+        instance_type = NoneType()
+    elif isinstance(instance_type, TypeType):
+        owner_type = instance_type.item
+        instance_type = NoneType()
+    else:
+        owner_type = instance_type
+
+    callable_name = mx.chk.expr_checker.method_fullname(descriptor_type, "__get__")
+    dunder_get_type = mx.chk.expr_checker.transform_callee_type(
+        callable_name,
+        dunder_get_type,
+        [
+            TempNode(instance_type, context=mx.context),
+            TempNode(TypeType.make_normalized(owner_type), context=mx.context),
+        ],
+        [ARG_POS, ARG_POS],
+        mx.context,
+        object_type=descriptor_type,
+    )
+
+    _, inferred_dunder_get_type = mx.chk.expr_checker.check_call(
+        dunder_get_type,
+        [
+            TempNode(instance_type, context=mx.context),
+            TempNode(TypeType.make_normalized(owner_type), context=mx.context),
+        ],
+        [ARG_POS, ARG_POS],
+        mx.context,
+        object_type=descriptor_type,
+        callable_name=callable_name,
+    )
+
+    # Search for possible deprecations:
+    mx.chk.warn_deprecated(dunder_get, mx.context)
+
+    inferred_dunder_get_type = get_proper_type(inferred_dunder_get_type)
+    if isinstance(inferred_dunder_get_type, AnyType):
+        # check_call failed, and will have reported an error
+        return inferred_dunder_get_type
+
+    if not isinstance(inferred_dunder_get_type, CallableType):
+        mx.fail(
+            message_registry.DESCRIPTOR_GET_NOT_CALLABLE.format(
+                descriptor_type.str_with_options(mx.msg.options)
+            )
+        )
+        return AnyType(TypeOfAny.from_error)
+
+    return inferred_dunder_get_type.ret_type
+
+
+def analyze_descriptor_assign(descriptor_type: Instance, mx: MemberContext) -> Type:
+    instance_type = get_proper_type(mx.self_type)
+    dunder_set = descriptor_type.type.get_method("__set__")
+    if dunder_set is None:
+        mx.fail(
+            message_registry.DESCRIPTOR_SET_NOT_CALLABLE.format(
+                descriptor_type.str_with_options(mx.msg.options)
+            ).value
+        )
+        return AnyType(TypeOfAny.from_error)
+
+    bound_method = analyze_decorator_or_funcbase_access(
+        defn=dunder_set,
+        itype=descriptor_type,
+        name="__set__",
+        mx=mx.copy_modified(is_lvalue=False, self_type=descriptor_type),
+    )
+    typ = map_instance_to_supertype(descriptor_type, dunder_set.info)
+    dunder_set_type = expand_type_by_instance(bound_method, typ)
+
+    callable_name = mx.chk.expr_checker.method_fullname(descriptor_type, "__set__")
+    rvalue = mx.rvalue or TempNode(AnyType(TypeOfAny.special_form), context=mx.context)
+    dunder_set_type = mx.chk.expr_checker.transform_callee_type(
+        callable_name,
+        dunder_set_type,
+        [TempNode(instance_type, context=mx.context), rvalue],
+        [ARG_POS, ARG_POS],
+        mx.context,
+        object_type=descriptor_type,
+    )
+
+    # For non-overloaded setters, the result should be type-checked like a regular assignment.
+    # Hence, we first only try to infer the type by using the rvalue as type context.
+    type_context = rvalue
+    with mx.msg.filter_errors():
+        _, inferred_dunder_set_type = mx.chk.expr_checker.check_call(
+            dunder_set_type,
+            [TempNode(instance_type, context=mx.context), type_context],
+            [ARG_POS, ARG_POS],
+            mx.context,
+            object_type=descriptor_type,
+            callable_name=callable_name,
+        )
+
+    # And now we in fact type check the call, to show errors related to wrong arguments
+    # count, etc., replacing the type context for non-overloaded setters only.
+    inferred_dunder_set_type = get_proper_type(inferred_dunder_set_type)
+    if isinstance(inferred_dunder_set_type, CallableType):
+        type_context = TempNode(AnyType(TypeOfAny.special_form), context=mx.context)
+    mx.chk.expr_checker.check_call(
+        dunder_set_type,
+        [TempNode(instance_type, context=mx.context), type_context],
+        [ARG_POS, ARG_POS],
+        mx.context,
+        object_type=descriptor_type,
+        callable_name=callable_name,
+    )
+
+    # Search for possible deprecations:
+    mx.chk.warn_deprecated(dunder_set, mx.context)
+
+    # In the following cases, a message already will have been recorded in check_call.
+    if (not isinstance(inferred_dunder_set_type, CallableType)) or (
+        len(inferred_dunder_set_type.arg_types) < 2
+    ):
+        return AnyType(TypeOfAny.from_error)
+    return inferred_dunder_set_type.arg_types[1]
+
+
+def is_instance_var(var: Var) -> bool:
+    """Return if var is an instance variable according to PEP 526."""
+    return (
+        # check the type_info node is the var (not a decorated function, etc.)
+        var.name in var.info.names
+        and var.info.names[var.name].node is var
+        and not var.is_classvar
+        # variables without annotations are treated as classvar
+        and not var.is_inferred
+    )
+
+
+def analyze_var(
+    name: str,
+    var: Var,
+    itype: Instance,
+    mx: MemberContext,
+    *,
+    implicit: bool = False,
+    is_trivial_self: bool = False,
+) -> Type:
+    """Analyze access to an attribute via a Var node.
+
+    This is conceptually part of analyze_member_access and the arguments are similar.
+    itype is the instance type in which attribute should be looked up
+    original_type is the type of E in the expression E.var
+    if implicit is True, the original Var was created as an assignment to self
+    if is_trivial_self is True, we can use fast path for bind_self().
+    """
+    # Found a member variable.
+    original_itype = itype
+    itype = map_instance_to_supertype(itype, var.info)
+    if var.is_settable_property and mx.is_lvalue:
+        typ: Type | None = var.setter_type
+        if typ is None and var.is_ready:
+            # Existing synthetic properties may not set setter type. Fall back to getter.
+            typ = var.type
+    else:
+        typ = var.type
+    if typ:
+        if isinstance(typ, PartialType):
+            return mx.chk.handle_partial_var_type(typ, mx.is_lvalue, var, mx.context)
+        if mx.is_lvalue and not mx.suppress_errors:
+            if var.is_property and not var.is_settable_property:
+                mx.msg.read_only_property(name, itype.type, mx.context)
+            if var.is_classvar:
+                mx.msg.cant_assign_to_classvar(name, mx.context)
+        # This is the most common case for variables, so start with this.
+        result = expand_without_binding(typ, var, itype, original_itype, mx)
+
+        # A non-None value indicates that we should actually bind self for this variable.
+        call_type: ProperType | None = None
+        if var.is_initialized_in_class and (not is_instance_var(var) or mx.is_operator):
+            typ = get_proper_type(typ)
+            if isinstance(typ, FunctionLike) and not typ.is_type_obj():
+                call_type = typ
+            elif var.is_property:
+                deco_mx = mx.copy_modified(original_type=typ, self_type=typ, is_lvalue=False)
+                call_type = get_proper_type(_analyze_member_access("__call__", typ, deco_mx))
+            else:
+                call_type = typ
+
+        # Bound variables with callable types are treated like methods
+        # (these are usually method aliases like __rmul__ = __mul__).
+        if isinstance(call_type, FunctionLike) and not call_type.is_type_obj():
+            if mx.is_lvalue and not var.is_property and not mx.suppress_errors:
+                mx.msg.cant_assign_to_method(mx.context)
+
+        # Bind the self type for each callable component (when needed).
+        if call_type and not var.is_staticmethod:
+            bound_items = []
+            for ct in call_type.items if isinstance(call_type, UnionType) else [call_type]:
+                p_ct = get_proper_type(ct)
+                if isinstance(p_ct, FunctionLike) and (not p_ct.bound() or var.is_property):
+                    item = expand_and_bind_callable(p_ct, var, itype, name, mx, is_trivial_self)
+                else:
+                    item = expand_without_binding(ct, var, itype, original_itype, mx)
+                bound_items.append(item)
+            result = UnionType.make_union(bound_items)
+    else:
+        if not var.is_ready and not mx.no_deferral:
+            mx.not_ready_callback(var.name, mx.context)
+        # Implicit 'Any' type.
+        result = AnyType(TypeOfAny.special_form)
+    fullname = f"{var.info.fullname}.{name}"
+    hook = mx.chk.plugin.get_attribute_hook(fullname)
+
+    if var.info.is_enum and not mx.is_lvalue:
+        if name in var.info.enum_members and name not in {"name", "value"}:
+            enum_literal = LiteralType(name, fallback=itype)
+            result = itype.copy_modified(last_known_value=enum_literal)
+        elif (
+            isinstance(p_result := get_proper_type(result), Instance)
+            and p_result.type.fullname == "enum.nonmember"
+            and p_result.args
+        ):
+            # Unwrap nonmember similar to class-level access
+            result = p_result.args[0]
+    if result and not (implicit or var.info.is_protocol and is_instance_var(var)):
+        result = analyze_descriptor_access(result, mx)
+    if hook:
+        result = hook(
+            AttributeContext(
+                get_proper_type(mx.original_type), result, mx.is_lvalue, mx.context, mx.chk
+            )
+        )
+    return result
+
+
+def expand_without_binding(
+    typ: Type, var: Var, itype: Instance, original_itype: Instance, mx: MemberContext
+) -> Type:
+    if not mx.preserve_type_var_ids:
+        typ = freshen_all_functions_type_vars(typ)
+    typ = expand_self_type_if_needed(typ, mx, var, original_itype)
+    expanded = expand_type_by_instance(typ, itype)
+    freeze_all_type_vars(expanded)
+    return expanded
+
+
+def expand_and_bind_callable(
+    functype: FunctionLike,
+    var: Var,
+    itype: Instance,
+    name: str,
+    mx: MemberContext,
+    is_trivial_self: bool,
+) -> Type:
+    if not mx.preserve_type_var_ids:
+        functype = freshen_all_functions_type_vars(functype)
+    typ = get_proper_type(expand_self_type(var, functype, mx.self_type))
+    assert isinstance(typ, FunctionLike)
+    if is_trivial_self:
+        typ = bind_self_fast(typ, mx.self_type)
+    else:
+        typ = check_self_arg(typ, mx.self_type, var.is_classmethod, mx.context, name, mx.msg)
+        typ = bind_self(typ, mx.self_type, var.is_classmethod)
+    expanded = expand_type_by_instance(typ, itype)
+    freeze_all_type_vars(expanded)
+    if not var.is_property:
+        return expanded
+    if isinstance(expanded, Overloaded):
+        # Legacy way to store settable properties is with overloads. Also in case it is
+        # an actual overloaded property, selecting first item that passed check_self_arg()
+        # is a good approximation, long-term we should use check_call() inference below.
+        if not expanded.items:
+            # A broken overload, error should be already reported.
+            return AnyType(TypeOfAny.from_error)
+        expanded = expanded.items[0]
+    assert isinstance(expanded, CallableType), expanded
+    if var.is_settable_property and mx.is_lvalue and var.setter_type is not None:
+        if expanded.variables:
+            type_ctx = mx.rvalue or TempNode(AnyType(TypeOfAny.special_form), context=mx.context)
+            _, inferred_expanded = mx.chk.expr_checker.check_call(
+                expanded, [type_ctx], [ARG_POS], mx.context
+            )
+            expanded = get_proper_type(inferred_expanded)
+            assert isinstance(expanded, CallableType)
+        if not expanded.arg_types:
+            # This can happen when accessing invalid property from its own body,
+            # error will be reported elsewhere.
+            return AnyType(TypeOfAny.from_error)
+        return expanded.arg_types[0]
+    else:
+        return expanded.ret_type
+
+
+def expand_self_type_if_needed(
+    t: Type, mx: MemberContext, var: Var, itype: Instance, is_class: bool = False
+) -> Type:
+    """Expand special Self type in a backwards compatible manner.
+
+    This should ensure that mixing old-style and new-style self-types work
+    seamlessly. Also, re-bind new style self-types in subclasses if needed.
+    """
+    original = get_proper_type(mx.self_type)
+    if not (mx.is_self or mx.is_super):
+        repl = mx.self_type
+        if is_class:
+            if isinstance(original, TypeType):
+                repl = original.item
+            elif isinstance(original, CallableType):
+                # Problematic access errors should have been already reported.
+                repl = erase_typevars(original.ret_type)
+            else:
+                repl = itype
+        return expand_self_type(var, t, repl)
+    elif supported_self_type(
+        # Support compatibility with plain old style T -> T and Type[T] -> T only.
+        get_proper_type(mx.self_type),
+        allow_instances=False,
+        allow_callable=False,
+    ):
+        repl = mx.self_type
+        if is_class and isinstance(original, TypeType):
+            repl = original.item
+        return expand_self_type(var, t, repl)
+    elif (
+        mx.is_self
+        and itype.type != var.info
+        # If an attribute with Self-type was defined in a supertype, we need to
+        # rebind the Self type variable to Self type variable of current class...
+        and itype.type.self_type is not None
+        # ...unless `self` has an explicit non-trivial annotation.
+        and itype == mx.chk.scope.active_self_type()
+    ):
+        return expand_self_type(var, t, itype.type.self_type)
+    else:
+        return t
+
+
+def check_self_arg(
+    functype: FunctionLike,
+    dispatched_arg_type: Type,
+    is_classmethod: bool,
+    context: Context,
+    name: str,
+    msg: MessageBuilder,
+) -> FunctionLike:
+    """Check that an instance has a valid type for a method with annotated 'self'.
+
+    For example if the method is defined as:
+        class A:
+            def f(self: S) -> T: ...
+    then for 'x.f' we check that type(x) <: S. If the method is overloaded, we select
+    only overloads items that satisfy this requirement. If there are no matching
+    overloads, an error is generated.
+    """
+    items = functype.items
+    if not items:
+        return functype
+    new_items = []
+    if is_classmethod:
+        dispatched_arg_type = TypeType.make_normalized(dispatched_arg_type)
+    p_dispatched_arg_type = get_proper_type(dispatched_arg_type)
+
+    for item in items:
+        if not item.arg_types or item.arg_kinds[0] not in (ARG_POS, ARG_STAR):
+            # No positional first (self) argument (*args is okay).
+            msg.no_formal_self(name, item, context)
+            # This is pretty bad, so just return the original signature if
+            # there is at least one such error.
+            return functype
+        selfarg = get_proper_type(item.arg_types[0])
+        if isinstance(selfarg, Instance) and isinstance(p_dispatched_arg_type, Instance):
+            if selfarg.type is p_dispatched_arg_type.type and selfarg.args:
+                if not is_overlapping_types(p_dispatched_arg_type, selfarg):
+                    # This special casing is needed since `actual <: erased(template)`
+                    # logic below doesn't always work, and a more correct approach may
+                    # be tricky.
+                    continue
+        new_items.append(item)
+
+    if new_items:
+        items = new_items
+        new_items = []
+
+    for item in items:
+        selfarg = get_proper_type(item.arg_types[0])
+        # This matches similar special-casing in bind_self(), see more details there.
+        self_callable = name == "__call__" and isinstance(selfarg, CallableType)
+        if self_callable or is_subtype(
+            dispatched_arg_type,
+            # This level of erasure matches the one in checker.check_func_def(),
+            # better keep these two checks consistent.
+            erase_typevars(erase_to_bound(selfarg)),
+            # This is to work around the fact that erased ParamSpec and TypeVarTuple
+            # callables are not always compatible with non-erased ones both ways.
+            always_covariant=any(
+                not isinstance(tv, TypeVarType) for tv in get_all_type_vars(selfarg)
+            ),
+            ignore_pos_arg_names=True,
+        ):
+            new_items.append(item)
+        elif isinstance(selfarg, ParamSpecType):
+            # TODO: This is not always right. What's the most reasonable thing to do here?
+            new_items.append(item)
+        elif isinstance(selfarg, TypeVarTupleType):
+            raise NotImplementedError
+    if not new_items:
+        # Choose first item for the message (it may be not very helpful for overloads).
+        msg.incompatible_self_argument(
+            name, dispatched_arg_type, items[0], is_classmethod, context
+        )
+        return functype
+    if len(new_items) == 1:
+        return new_items[0]
+    return Overloaded(new_items)
+
+
+def analyze_class_attribute_access(
+    itype: Instance,
+    name: str,
+    mx: MemberContext,
+    *,
+    mcs_fallback: Instance,
+    override_info: TypeInfo | None = None,
+    original_vars: Sequence[TypeVarLikeType] | None = None,
+) -> Type | None:
+    """Analyze access to an attribute on a class object.
+
+    itype is the return type of the class object callable, original_type is the type
+    of E in the expression E.var, original_vars are type variables of the class callable
+    (for generic classes).
+    """
+    info = itype.type
+    if override_info:
+        info = override_info
+
+    fullname = f"{info.fullname}.{name}"
+    hook = mx.chk.plugin.get_class_attribute_hook(fullname)
+
+    node = info.get(name)
+    if not node:
+        if itype.extra_attrs and name in itype.extra_attrs.attrs:
+            # For modules use direct symbol table lookup.
+            if not itype.extra_attrs.mod_name:
+                return itype.extra_attrs.attrs[name]
+        if info.fallback_to_any or info.meta_fallback_to_any:
+            return apply_class_attr_hook(mx, hook, AnyType(TypeOfAny.special_form))
+        return None
+
+    if (
+        isinstance(node.node, Var)
+        and not node.node.is_classvar
+        and not hook
+        and mcs_fallback.type.get(name)
+    ):
+        # If the same attribute is declared on the metaclass and the class but with different types,
+        # and the attribute on the class is not a ClassVar,
+        # the type of the attribute on the metaclass should take priority
+        # over the type of the attribute on the class,
+        # when the attribute is being accessed from the class object itself.
+        #
+        # Return `None` here to signify that the name should be looked up
+        # on the class object itself rather than the instance.
+        return None
+
+    mx.chk.warn_deprecated(node.node, mx.context)
+
+    is_decorated = isinstance(node.node, Decorator)
+    is_method = is_decorated or isinstance(node.node, FuncBase)
+    if mx.is_lvalue and not mx.suppress_errors:
+        if is_method:
+            mx.msg.cant_assign_to_method(mx.context)
+        if isinstance(node.node, TypeInfo):
+            mx.fail(message_registry.CANNOT_ASSIGN_TO_TYPE)
+
+    # Refuse class attribute access if slot defined
+    if info.slots and name in info.slots:
+        mx.fail(message_registry.CLASS_VAR_CONFLICTS_SLOTS.format(name))
+
+    if node.implicit and isinstance(node.node, Var):
+        if node.node.is_final:
+            # If a final attribute was declared on `self` in `__init__`, then it
+            # can't be accessed on the class object.
+            mx.fail(message_registry.CANNOT_ACCESS_FINAL_INSTANCE_ATTR.format(node.node.name))
+        elif not mx.is_lvalue and not defined_in_superclass(info, name):
+            mx.fail(message_registry.CANNOT_ACCESS_INSTANCE_ONLY_ATTR.format(node.node.name))
+
+    # An assignment to final attribute on class object is also always an error,
+    # independently of types.
+    if mx.is_lvalue and not mx.chk.get_final_context():
+        check_final_member(name, info, mx.msg, mx.context)
+
+    if info.is_enum and not (mx.is_lvalue or is_decorated or is_method):
+        enum_class_attribute_type = analyze_enum_class_attribute_access(itype, name, mx)
+        if enum_class_attribute_type:
+            return apply_class_attr_hook(mx, hook, enum_class_attribute_type)
+
+    t = node.type
+    if t:
+        if isinstance(t, PartialType):
+            symnode = node.node
+            assert isinstance(symnode, Var)
+            return apply_class_attr_hook(
+                mx, hook, mx.chk.handle_partial_var_type(t, mx.is_lvalue, symnode, mx.context)
+            )
+
+        # Find the class where method/variable was defined.
+        if isinstance(node.node, Decorator):
+            super_info: TypeInfo | None = node.node.var.info
+        elif isinstance(node.node, (Var, SYMBOL_FUNCBASE_TYPES)):
+            super_info = node.node.info
+        else:
+            super_info = None
+
+        # Map the type to how it would look as a defining class. For example:
+        #     class C(Generic[T]): ...
+        #     class D(C[Tuple[T, S]]): ...
+        #     D[int, str].method()
+        # Here itype is D[int, str], isuper is C[Tuple[int, str]].
+        if not super_info:
+            isuper = None
+        else:
+            isuper = map_instance_to_supertype(itype, super_info)
+
+        if isinstance(node.node, Var):
+            assert isuper is not None
+            object_type = get_proper_type(mx.self_type)
+            # Check if original variable type has type variables. For example:
+            #     class C(Generic[T]):
+            #         x: T
+            #     C.x  # Error, ambiguous access
+            #     C[int].x  # Also an error, since C[int] is same as C at runtime
+            # Exception is Self type wrapped in ClassVar, that is safe.
+            prohibit_self = not node.node.is_classvar
+            def_vars = set(node.node.info.defn.type_vars)
+            if prohibit_self and node.node.info.self_type:
+                def_vars.add(node.node.info.self_type)
+            # Exception: access on Type[...], including first argument of class methods is OK.
+            prohibit_generic = not isinstance(object_type, TypeType) or node.implicit
+            if prohibit_generic and def_vars & set(get_all_type_vars(t)):
+                if node.node.is_classvar:
+                    message = message_registry.GENERIC_CLASS_VAR_ACCESS
+                else:
+                    message = message_registry.GENERIC_INSTANCE_VAR_CLASS_ACCESS
+                mx.fail(message)
+            t = expand_self_type_if_needed(t, mx, node.node, itype, is_class=True)
+            t = expand_type_by_instance(t, isuper)
+            # Erase non-mapped variables, but keep mapped ones, even if there is an error.
+            # In the above example this means that we infer following types:
+            #     C.x -> Any
+            #     C[int].x -> int
+            if prohibit_generic:
+                erase_vars = set(itype.type.defn.type_vars)
+                if prohibit_self and itype.type.self_type:
+                    erase_vars.add(itype.type.self_type)
+                t = erase_typevars(t, {tv.id for tv in erase_vars})
+
+        is_classmethod = (
+            (is_decorated and cast(Decorator, node.node).func.is_class)
+            or (isinstance(node.node, SYMBOL_FUNCBASE_TYPES) and node.node.is_class)
+            or isinstance(node.node, Var)
+            and node.node.is_classmethod
+        )
+        t = get_proper_type(t)
+        is_trivial_self = False
+        if isinstance(node.node, Decorator):
+            # Use fast path if there are trivial decorators like @classmethod or @property
+            is_trivial_self = node.node.func.is_trivial_self and not node.node.decorators
+        elif isinstance(node.node, (FuncDef, OverloadedFuncDef)):
+            is_trivial_self = node.node.is_trivial_self
+        if (
+            isinstance(t, FunctionLike)
+            and is_classmethod
+            and not is_trivial_self
+            and not t.bound()
+        ):
+            t = check_self_arg(t, mx.self_type, False, mx.context, name, mx.msg)
+        t = add_class_tvars(
+            t,
+            isuper,
+            is_classmethod,
+            mx,
+            original_vars=original_vars,
+            is_trivial_self=is_trivial_self,
+        )
+        if is_decorated:
+            t = expand_self_type_if_needed(
+                t, mx, cast(Decorator, node.node).var, itype, is_class=is_classmethod
+            )
+
+        result = t
+        # __set__ is not called on class objects.
+        if not mx.is_lvalue:
+            result = analyze_descriptor_access(result, mx)
+
+        return apply_class_attr_hook(mx, hook, result)
+    elif isinstance(node.node, Var):
+        mx.not_ready_callback(name, mx.context)
+        return AnyType(TypeOfAny.special_form)
+
+    if isinstance(node.node, (TypeInfo, TypeAlias, MypyFile, TypeVarLikeExpr)):
+        # TODO: should we apply class plugin here (similar to instance access)?
+        return mx.chk.expr_checker.analyze_static_reference(node.node, mx.context, mx.is_lvalue)
+
+    if is_decorated:
+        assert isinstance(node.node, Decorator)
+        if node.node.type:
+            return apply_class_attr_hook(mx, hook, node.node.type)
+        else:
+            mx.not_ready_callback(name, mx.context)
+            return AnyType(TypeOfAny.from_error)
+    else:
+        assert isinstance(node.node, SYMBOL_FUNCBASE_TYPES)
+        typ = function_type(node.node, mx.named_type("builtins.function"))
+        # Note: if we are accessing class method on class object, the cls argument is bound.
+        # Annotated and/or explicit class methods go through other code paths above, for
+        # unannotated implicit class methods we do this here.
+        if node.node.is_class:
+            typ = bind_self_fast(typ)
+        return apply_class_attr_hook(mx, hook, typ)
+
+
+def apply_class_attr_hook(
+    mx: MemberContext, hook: Callable[[AttributeContext], Type] | None, result: Type
+) -> Type | None:
+    if hook:
+        result = hook(
+            AttributeContext(
+                get_proper_type(mx.original_type), result, mx.is_lvalue, mx.context, mx.chk
+            )
+        )
+    return result
+
+
+def analyze_enum_class_attribute_access(
+    itype: Instance, name: str, mx: MemberContext
+) -> Type | None:
+    # Skip these since Enum will remove it
+    if name in EXCLUDED_ENUM_ATTRIBUTES:
+        return report_missing_attribute(mx.original_type, itype, name, mx)
+
+    node = itype.type.get(name)
+    if node and node.type:
+        proper = get_proper_type(node.type)
+        # Support `A = nonmember(1)` function call and decorator.
+        if (
+            isinstance(proper, Instance)
+            and proper.type.fullname == "enum.nonmember"
+            and proper.args
+        ):
+            return proper.args[0]
+
+    if name not in itype.type.enum_members:
+        return None
+
+    enum_literal = LiteralType(name, fallback=itype)
+    return itype.copy_modified(last_known_value=enum_literal)
+
+
+def analyze_typeddict_access(
+    name: str, typ: TypedDictType, mx: MemberContext, override_info: TypeInfo | None
+) -> Type:
+    if name == "__setitem__":
+        if isinstance(mx.context, IndexExpr):
+            # Since we can get this during `a['key'] = ...`
+            # it is safe to assume that the context is `IndexExpr`.
+            item_type, key_names = mx.chk.expr_checker.visit_typeddict_index_expr(
+                typ, mx.context.index, setitem=True
+            )
+            assigned_readonly_keys = typ.readonly_keys & key_names
+            if assigned_readonly_keys and not mx.suppress_errors:
+                mx.msg.readonly_keys_mutated(assigned_readonly_keys, context=mx.context)
+        else:
+            # It can also be `a.__setitem__(...)` direct call.
+            # In this case `item_type` can be `Any`,
+            # because we don't have args available yet.
+            # TODO: check in `default` plugin that `__setitem__` is correct.
+            item_type = AnyType(TypeOfAny.implementation_artifact)
+        return CallableType(
+            arg_types=[mx.chk.named_type("builtins.str"), item_type],
+            arg_kinds=[ARG_POS, ARG_POS],
+            arg_names=[None, None],
+            ret_type=NoneType(),
+            fallback=mx.chk.named_type("builtins.function"),
+            name=name,
+        )
+    elif name == "__delitem__":
+        return CallableType(
+            arg_types=[mx.chk.named_type("builtins.str")],
+            arg_kinds=[ARG_POS],
+            arg_names=[None],
+            ret_type=NoneType(),
+            fallback=mx.chk.named_type("builtins.function"),
+            name=name,
+        )
+    return _analyze_member_access(name, typ.fallback, mx, override_info)
+
+
+def add_class_tvars(
+    t: ProperType,
+    isuper: Instance | None,
+    is_classmethod: bool,
+    mx: MemberContext,
+    original_vars: Sequence[TypeVarLikeType] | None = None,
+    is_trivial_self: bool = False,
+) -> Type:
+    """Instantiate type variables during analyze_class_attribute_access,
+    e.g T and Q in the following:
+
+    class A(Generic[T]):
+        @classmethod
+        def foo(cls: Type[Q]) -> Tuple[T, Q]: ...
+
+    class B(A[str]): pass
+    B.foo()
+
+    Args:
+        t: Declared type of the method (or property)
+        isuper: Current instance mapped to the superclass where method was defined, this
+            is usually done by map_instance_to_supertype()
+        is_classmethod: True if this method is decorated with @classmethod
+        original_vars: Type variables of the class callable on which the method was accessed
+        is_trivial_self: if True, we can use fast path for bind_self().
+    Returns:
+        Expanded method type with added type variables (when needed).
+    """
+    # TODO: verify consistency between Q and T
+
+    # We add class type variables if the class method is accessed on class object
+    # without applied type arguments, this matches the behavior of __init__().
+    # For example (continuing the example in docstring):
+    #     A       # The type of callable is def [T] () -> A[T], _not_ def () -> A[Any]
+    #     A[int]  # The type of callable is def () -> A[int]
+    # and
+    #     A.foo       # The type is generic def [T] () -> Tuple[T, A[T]]
+    #     A[int].foo  # The type is non-generic def () -> Tuple[int, A[int]]
+    #
+    # This behaviour is useful for defining alternative constructors for generic classes.
+    # To achieve such behaviour, we add the class type variables that are still free
+    # (i.e. appear in the return type of the class object on which the method was accessed).
+    if isinstance(t, CallableType):
+        tvars = original_vars if original_vars is not None else []
+        if not mx.preserve_type_var_ids:
+            t = freshen_all_functions_type_vars(t)
+        if is_classmethod and not t.is_bound:
+            if is_trivial_self:
+                t = bind_self_fast(t, mx.self_type)
+            else:
+                t = bind_self(t, mx.self_type, is_classmethod=True)
+        if isuper is not None:
+            t = expand_type_by_instance(t, isuper)
+        freeze_all_type_vars(t)
+        return t.copy_modified(variables=list(tvars) + list(t.variables))
+    elif isinstance(t, Overloaded):
+        return Overloaded(
+            [
+                cast(
+                    CallableType,
+                    add_class_tvars(item, isuper, is_classmethod, mx, original_vars=original_vars),
+                )
+                for item in t.items
+            ]
+        )
+    if isuper is not None:
+        t = expand_type_by_instance(t, isuper)
+    return t
+
+
+def analyze_decorator_or_funcbase_access(
+    defn: Decorator | FuncBase, itype: Instance, name: str, mx: MemberContext
+) -> Type:
+    """Analyzes the type behind method access.
+
+    The function itself can possibly be decorated.
+    See: https://github.com/python/mypy/issues/10409
+    """
+    if isinstance(defn, Decorator):
+        return analyze_var(name, defn.var, itype, mx)
+    typ = function_type(defn, mx.chk.named_type("builtins.function"))
+    if isinstance(defn, (FuncDef, OverloadedFuncDef)) and defn.is_trivial_self:
+        return bind_self_fast(typ, mx.self_type)
+    typ = check_self_arg(typ, mx.self_type, defn.is_class, mx.context, name, mx.msg)
+    return bind_self(typ, original_type=mx.self_type, is_classmethod=defn.is_class)
+
+
+F = TypeVar("F", bound=FunctionLike)
+
+
+def bind_self_fast(method: F, original_type: Type | None = None) -> F:
+    """Return a copy of `method`, with the type of its first parameter (usually
+    self or cls) bound to original_type.
+
+    This is a faster version of mypy.typeops.bind_self() that can be used for methods
+    with trivial self/cls annotations.
+    """
+    if isinstance(method, Overloaded):
+        items = [bind_self_fast(c, original_type) for c in method.items]
+        return cast(F, Overloaded(items))
+    assert isinstance(method, CallableType)
+    if not method.arg_types:
+        # Invalid method, return something.
+        return method
+    if method.arg_kinds[0] in (ARG_STAR, ARG_STAR2):
+        # See typeops.py for details.
+        return method
+    return method.copy_modified(
+        arg_types=method.arg_types[1:],
+        arg_kinds=method.arg_kinds[1:],
+        arg_names=method.arg_names[1:],
+        is_bound=True,
+    )
+
+
+def has_operator(typ: Type, op_method: str, named_type: Callable[[str], Instance]) -> bool:
+    """Does type have operator with the given name?
+
+    Note: this follows the rules for operator access, in particular:
+    * __getattr__ is not considered
+    * for class objects we only look in metaclass
+    * instance level attributes (i.e. extra_attrs) are not considered
+    """
+    # This is much faster than analyze_member_access, and so using
+    # it first as a filter is important for performance. This is mostly relevant
+    # in situations where we can't expect that method is likely present,
+    # e.g. for __OP__ vs __rOP__.
+    typ = get_proper_type(typ)
+
+    if isinstance(typ, TypeVarLikeType):
+        typ = typ.values_or_bound()
+    if isinstance(typ, AnyType):
+        return True
+    if isinstance(typ, UnionType):
+        return all(has_operator(x, op_method, named_type) for x in typ.relevant_items())
+    if isinstance(typ, FunctionLike) and typ.is_type_obj():
+        return typ.fallback.type.has_readable_member(op_method)
+    if isinstance(typ, TypeType):
+        # Type[Union[X, ...]] is always normalized to Union[Type[X], ...],
+        # so we don't need to care about unions here, but we need to care about
+        # Type[T], where upper bound of T is a union.
+        item = typ.item
+        if isinstance(item, TypeVarType):
+            item = item.values_or_bound()
+        if isinstance(item, UnionType):
+            return all(meta_has_operator(x, op_method, named_type) for x in item.relevant_items())
+        return meta_has_operator(item, op_method, named_type)
+    return instance_fallback(typ, named_type).type.has_readable_member(op_method)
+
+
+def instance_fallback(typ: ProperType, named_type: Callable[[str], Instance]) -> Instance:
+    if isinstance(typ, Instance):
+        return typ
+    if isinstance(typ, TupleType):
+        return tuple_fallback(typ)
+    if isinstance(typ, (LiteralType, TypedDictType)):
+        return typ.fallback
+    return named_type("builtins.object")
+
+
+def meta_has_operator(item: Type, op_method: str, named_type: Callable[[str], Instance]) -> bool:
+    item = get_proper_type(item)
+    if isinstance(item, AnyType):
+        return True
+    item = instance_fallback(item, named_type)
+    meta = item.type.metaclass_type or named_type("builtins.type")
+    return meta.type.has_readable_member(op_method)
+
+
+def defined_in_superclass(info: TypeInfo, name: str) -> bool:
+    """Check if a variable has an explicit value at class level in any of superclasses."""
+    for base in info.mro[1:]:
+        if (node := base.names.get(name)) is not None:
+            if not node.implicit and isinstance(node.node, Var) and node.node.has_explicit_value:
+                return True
+    return False

micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/mypy-1.20.2-py314h5a2d7ad_0/Lib/site-packages/mypy/checkpattern.py

@@ -0,0 +1,885 @@
+"""Pattern checker. This file is conceptually part of TypeChecker."""
+
+from __future__ import annotations
+
+from collections import defaultdict
+from typing import Final, NamedTuple
+
+from mypy import message_registry
+from mypy.checker_shared import TypeCheckerSharedApi, TypeRange
+from mypy.checkmember import analyze_member_access
+from mypy.expandtype import expand_type_by_instance
+from mypy.join import join_types
+from mypy.literals import literal_hash
+from mypy.maptype import map_instance_to_supertype
+from mypy.meet import narrow_declared_type
+from mypy.messages import MessageBuilder
+from mypy.nodes import ARG_POS, Expression, NameExpr, TempNode, TypeAlias, Var
+from mypy.options import Options
+from mypy.patterns import (
+    AsPattern,
+    ClassPattern,
+    MappingPattern,
+    OrPattern,
+    Pattern,
+    SequencePattern,
+    SingletonPattern,
+    StarredPattern,
+    ValuePattern,
+)
+from mypy.plugin import Plugin
+from mypy.subtypes import is_subtype
+from mypy.typeops import (
+    coerce_to_literal,
+    make_simplified_union,
+    try_getting_str_literals_from_type,
+    tuple_fallback,
+)
+from mypy.types import (
+    AnyType,
+    FunctionLike,
+    Instance,
+    NoneType,
+    ProperType,
+    TupleType,
+    Type,
+    TypedDictType,
+    TypeOfAny,
+    TypeType,
+    TypeVarTupleType,
+    TypeVarType,
+    UninhabitedType,
+    UnionType,
+    UnpackType,
+    callable_with_ellipsis,
+    find_unpack_in_list,
+    get_proper_type,
+    split_with_prefix_and_suffix,
+)
+from mypy.typevars import fill_typevars, fill_typevars_with_any
+from mypy.visitor import PatternVisitor
+
+self_match_type_names: Final = [
+    "builtins.bool",
+    "builtins.bytearray",
+    "builtins.bytes",
+    "builtins.dict",
+    "builtins.float",
+    "builtins.frozenset",
+    "builtins.int",
+    "builtins.list",
+    "builtins.set",
+    "builtins.str",
+    "builtins.tuple",
+]
+
+non_sequence_match_type_names: Final = ["builtins.str", "builtins.bytes", "builtins.bytearray"]
+
+
+# For every Pattern a PatternType can be calculated. This requires recursively calculating
+# the PatternTypes of the sub-patterns first.
+# Using the data in the PatternType the match subject and captured names can be narrowed/inferred.
+class PatternType(NamedTuple):
+    type: Type  # The type the match subject can be narrowed to
+    rest_type: Type  # The remaining type if the pattern didn't match
+    captures: dict[Expression, Type]  # The variables captured by the pattern
+
+
+class PatternChecker(PatternVisitor[PatternType]):
+    """Pattern checker.
+
+    This class checks if a pattern can match a type, what the type can be narrowed to, and what
+    type capture patterns should be inferred as.
+    """
+
+    # Some services are provided by a TypeChecker instance.
+    chk: TypeCheckerSharedApi
+    # This is shared with TypeChecker, but stored also here for convenience.
+    msg: MessageBuilder
+    # Currently unused
+    plugin: Plugin
+    # The expression being matched against the pattern
+    subject: Expression
+
+    subject_type: Type
+    # Type of the subject to check the (sub)pattern against
+    type_context: list[Type]
+    # Types that match against self instead of their __match_args__ if used as a class pattern
+    # Filled in from self_match_type_names
+    self_match_types: list[Type]
+    # Types that are sequences, but don't match sequence patterns. Filled in from
+    # non_sequence_match_type_names
+    non_sequence_match_types: list[Type]
+
+    options: Options
+
+    def __init__(
+        self, chk: TypeCheckerSharedApi, msg: MessageBuilder, plugin: Plugin, options: Options
+    ) -> None:
+        self.chk = chk
+        self.msg = msg
+        self.plugin = plugin
+
+        self.type_context = []
+        self.self_match_types = self.generate_types_from_names(self_match_type_names)
+        self.non_sequence_match_types = self.generate_types_from_names(
+            non_sequence_match_type_names
+        )
+        self.options = options
+
+    def accept(self, o: Pattern, type_context: Type) -> PatternType:
+        self.type_context.append(type_context)
+        result = o.accept(self)
+        self.type_context.pop()
+
+        return result
+
+    def visit_as_pattern(self, o: AsPattern) -> PatternType:
+        current_type = self.type_context[-1]
+        if o.pattern is not None:
+            pattern_type = self.accept(o.pattern, current_type)
+            typ, rest_type, type_map = pattern_type
+        else:
+            typ, rest_type, type_map = current_type, UninhabitedType(), {}
+
+        if not is_uninhabited(typ) and o.name is not None:
+            typ, _ = self.chk.conditional_types_with_intersection(
+                current_type, [get_type_range(typ)], o, default=current_type
+            )
+            if not is_uninhabited(typ):
+                type_map[o.name] = typ
+
+        return PatternType(typ, rest_type, type_map)
+
+    def visit_or_pattern(self, o: OrPattern) -> PatternType:
+        current_type = self.type_context[-1]
+
+        #
+        # Check all the subpatterns
+        #
+        pattern_types = []
+        for pattern in o.patterns:
+            pattern_type = self.accept(pattern, current_type)
+            pattern_types.append(pattern_type)
+            if not is_uninhabited(pattern_type.type):
+                current_type = pattern_type.rest_type
+
+        #
+        # Collect the final type
+        #
+        types = []
+        for pattern_type in pattern_types:
+            if not is_uninhabited(pattern_type.type):
+                types.append(pattern_type.type)
+
+        #
+        # Check the capture types
+        #
+        capture_types: dict[Var, list[tuple[Expression, Type]]] = defaultdict(list)
+        # Collect captures from the first subpattern
+        for expr, typ in pattern_types[0].captures.items():
+            node = get_var(expr)
+            capture_types[node].append((expr, typ))
+
+        # Check if other subpatterns capture the same names
+        for i, pattern_type in enumerate(pattern_types[1:]):
+            vars = {get_var(expr) for expr, _ in pattern_type.captures.items()}
+            if capture_types.keys() != vars:
+                self.msg.fail(message_registry.OR_PATTERN_ALTERNATIVE_NAMES, o.patterns[i])
+            for expr, typ in pattern_type.captures.items():
+                node = get_var(expr)
+                capture_types[node].append((expr, typ))
+
+        captures: dict[Expression, Type] = {}
+        for capture_list in capture_types.values():
+            typ = UninhabitedType()
+            for _, other in capture_list:
+                typ = make_simplified_union([typ, other])
+
+            captures[capture_list[0][0]] = typ
+
+        union_type = make_simplified_union(types)
+        return PatternType(union_type, current_type, captures)
+
+    def visit_value_pattern(self, o: ValuePattern) -> PatternType:
+        current_type = self.type_context[-1]
+        typ = self.chk.expr_checker.accept(o.expr)
+        typ = coerce_to_literal(typ)
+        node = TempNode(current_type)
+        # Value patterns are essentially a syntactic sugar on top of `if x == Value`.
+        # They should be treated equivalently.
+        ok_map, rest_map = self.chk.narrow_type_by_identity_equality(
+            "==", [node, TempNode(typ)], [current_type, typ], [0, 1], {0}
+        )
+        ok_type = ok_map.get(node, current_type) if ok_map is not None else UninhabitedType()
+        rest_type = rest_map.get(node, current_type) if rest_map is not None else UninhabitedType()
+        return PatternType(ok_type, rest_type, {})
+
+    def visit_singleton_pattern(self, o: SingletonPattern) -> PatternType:
+        current_type = self.type_context[-1]
+        value: bool | None = o.value
+        if isinstance(value, bool):
+            typ = self.chk.expr_checker.infer_literal_expr_type(value, "builtins.bool")
+        elif value is None:
+            typ = NoneType()
+        else:
+            assert False
+
+        narrowed_type, rest_type = self.chk.conditional_types_with_intersection(
+            current_type, [get_type_range(typ)], o, default=current_type
+        )
+        return PatternType(narrowed_type, rest_type, {})
+
+    def visit_sequence_pattern(self, o: SequencePattern) -> PatternType:
+        #
+        # Step 1. Check for existence of a starred pattern
+        #
+        current_type = get_proper_type(self.type_context[-1])
+        if not self.can_match_sequence(current_type):
+            return self.early_non_match()
+
+        star_positions = [i for i, p in enumerate(o.patterns) if isinstance(p, StarredPattern)]
+        star_position: int | None = None
+        if len(star_positions) == 1:
+            star_position = star_positions[0]
+        elif len(star_positions) >= 2:
+            assert False, "Parser should prevent multiple starred patterns"
+        required_patterns = len(o.patterns)
+        if star_position is not None:
+            required_patterns -= 1
+
+        #
+        # Step 2. If we have a union, recurse and return the combined result
+        #
+        if isinstance(current_type, UnionType):
+            match_types: list[Type] = []
+            rest_types: list[Type] = []
+            captures_list: dict[Expression, list[Type]] = {}
+
+            if star_position is not None:
+                star_pattern = o.patterns[star_position]
+                assert isinstance(star_pattern, StarredPattern)
+                star_expr = star_pattern.capture
+            else:
+                star_expr = None
+
+            for t in current_type.items:
+                match_type, rest_type, captures = self.accept(o, t)
+                match_types.append(match_type)
+                rest_types.append(rest_type)
+                if not is_uninhabited(match_type):
+                    for expr, typ in captures.items():
+                        p_typ = get_proper_type(typ)
+                        if expr not in captures_list:
+                            captures_list[expr] = []
+                        # Avoid adding in a list[Never] for empty list captures
+                        if (
+                            expr == star_expr
+                            and isinstance(p_typ, Instance)
+                            and p_typ.type.fullname == "builtins.list"
+                            and is_uninhabited(p_typ.args[0])
+                        ):
+                            continue
+                        captures_list[expr].append(typ)
+
+            return PatternType(
+                make_simplified_union(match_types),
+                make_simplified_union(rest_types),
+                {expr: make_simplified_union(types) for expr, types in captures_list.items()},
+            )
+
+        #
+        # Step 3. Get inner types of original type
+        #
+        unpack_index = None
+        if isinstance(current_type, TupleType):
+            inner_types: list[Type] = current_type.items
+            unpack_index = find_unpack_in_list(inner_types)
+            if unpack_index is None:
+                size_diff = len(inner_types) - required_patterns
+                if size_diff < 0:
+                    return self.early_non_match()
+                elif size_diff > 0 and star_position is None:
+                    return self.early_non_match()
+            else:
+                normalized_inner_types = []
+                for it in inner_types:
+                    # Unfortunately, it is not possible to "split" the TypeVarTuple
+                    # into individual items, so we just use its upper bound for the whole
+                    # analysis instead.
+                    if isinstance(it, UnpackType) and isinstance(it.type, TypeVarTupleType):
+                        it = UnpackType(it.type.upper_bound)
+                    normalized_inner_types.append(it)
+                inner_types = normalized_inner_types
+                current_type = current_type.copy_modified(items=normalized_inner_types)
+                if len(inner_types) - 1 > required_patterns and star_position is None:
+                    return self.early_non_match()
+        elif isinstance(current_type, AnyType):
+            inner_type = AnyType(TypeOfAny.from_another_any, current_type)
+            inner_types = [inner_type] * len(o.patterns)
+        elif isinstance(current_type, Instance) and self.chk.type_is_iterable(current_type):
+            inner_type = self.chk.iterable_item_type(current_type, o)
+            inner_types = [inner_type] * len(o.patterns)
+        else:
+            inner_type = self.chk.named_type("builtins.object")
+            inner_types = [inner_type] * len(o.patterns)
+
+        #
+        # Step 4. Match inner patterns
+        #
+        contracted_new_inner_types: list[Type] = []
+        contracted_rest_inner_types: list[Type] = []
+        captures = {}  # dict[Expression, Type]
+
+        contracted_inner_types = self.contract_starred_pattern_types(
+            inner_types, star_position, required_patterns
+        )
+        for p, t in zip(o.patterns, contracted_inner_types):
+            pattern_type = self.accept(p, t)
+            typ, rest, type_map = pattern_type
+            contracted_new_inner_types.append(typ)
+            contracted_rest_inner_types.append(rest)
+            self.update_type_map(captures, type_map)
+
+        new_inner_types = self.expand_starred_pattern_types(
+            contracted_new_inner_types, star_position, len(inner_types), unpack_index is not None
+        )
+        rest_inner_types = self.expand_starred_pattern_types(
+            contracted_rest_inner_types, star_position, len(inner_types), unpack_index is not None
+        )
+
+        #
+        # Step 5. Calculate new type
+        #
+        new_type: Type
+        rest_type = current_type
+        if isinstance(current_type, TupleType) and unpack_index is None:
+            if any(is_uninhabited(typ) for typ in new_inner_types):
+                new_type = UninhabitedType()
+            else:
+                new_type = TupleType(new_inner_types, current_type.partial_fallback)
+
+            num_always_match = sum(is_uninhabited(typ) for typ in rest_inner_types)
+            if num_always_match == len(rest_inner_types):
+                # All subpatterns always match, so we can apply negative narrowing
+                rest_type = UninhabitedType()
+            elif num_always_match == len(rest_inner_types) - 1:
+                # Exactly one subpattern may conditionally match, the rest always match.
+                # We can apply negative narrowing to this one position.
+                rest_type = TupleType(
+                    [
+                        curr if is_uninhabited(rest) else rest
+                        for curr, rest in zip(inner_types, rest_inner_types)
+                    ],
+                    current_type.partial_fallback,
+                )
+        elif isinstance(current_type, TupleType):
+            # For variadic tuples it is too tricky to match individual items like for fixed
+            # tuples, so we instead try to narrow the entire type.
+            # TODO: use more precise narrowing when possible (e.g. for identical shapes).
+            new_tuple_type = TupleType(new_inner_types, current_type.partial_fallback)
+            new_type, _ = self.chk.conditional_types_with_intersection(
+                new_tuple_type, [get_type_range(current_type)], o, default=new_tuple_type
+            )
+            if (
+                star_position is not None
+                and required_patterns <= len(inner_types) - 1
+                and all(is_uninhabited(rest) for rest in rest_inner_types)
+            ):
+                rest_type = UninhabitedType()
+        else:
+            new_inner_type = UninhabitedType()
+            for typ in new_inner_types:
+                new_inner_type = join_types(new_inner_type, typ)
+            new_type = self.construct_sequence_child(current_type, new_inner_type)
+            new_type, possible_rest_type = self.chk.conditional_types_with_intersection(
+                current_type, [get_type_range(new_type)], o, default=current_type
+            )
+            if star_position is not None and len(o.patterns) == 1:
+                # Match cannot be refuted, so narrow the remaining type
+                rest_type = possible_rest_type
+
+        return PatternType(new_type, rest_type, captures)
+
+    def contract_starred_pattern_types(
+        self, types: list[Type], star_pos: int | None, num_patterns: int
+    ) -> list[Type]:
+        """
+        Contracts a list of types in a sequence pattern depending on the position of a starred
+        capture pattern.
+
+        For example if the sequence pattern [a, *b, c] is matched against types [bool, int, str,
+        bytes] the contracted types are [bool, Union[int, str], bytes].
+
+        If star_pos in None the types are returned unchanged.
+        """
+        unpack_index = find_unpack_in_list(types)
+        if unpack_index is not None:
+            # Variadic tuples require "re-shaping" to match the requested pattern.
+            unpack = types[unpack_index]
+            assert isinstance(unpack, UnpackType)
+            unpacked = get_proper_type(unpack.type)
+            # This should be guaranteed by the normalization in the caller.
+            assert isinstance(unpacked, Instance) and unpacked.type.fullname == "builtins.tuple"
+            if star_pos is None:
+                missing = num_patterns - len(types) + 1
+                new_types = types[:unpack_index]
+                new_types += [unpacked.args[0]] * missing
+                new_types += types[unpack_index + 1 :]
+                return new_types
+            prefix, middle, suffix = split_with_prefix_and_suffix(
+                tuple([UnpackType(unpacked) if isinstance(t, UnpackType) else t for t in types]),
+                star_pos,
+                num_patterns - star_pos,
+            )
+            new_middle = []
+            for m in middle:
+                # The existing code expects the star item type, rather than the type of
+                # the whole tuple "slice".
+                if isinstance(m, UnpackType):
+                    new_middle.append(unpacked.args[0])
+                else:
+                    new_middle.append(m)
+            return list(prefix) + [make_simplified_union(new_middle)] + list(suffix)
+        else:
+            if star_pos is None:
+                return types
+            new_types = types[:star_pos]
+            star_length = len(types) - num_patterns
+            new_types.append(make_simplified_union(types[star_pos : star_pos + star_length]))
+            new_types += types[star_pos + star_length :]
+            return new_types
+
+    def expand_starred_pattern_types(
+        self, types: list[Type], star_pos: int | None, num_types: int, original_unpack: bool
+    ) -> list[Type]:
+        """Undoes the contraction done by contract_starred_pattern_types.
+
+        For example if the sequence pattern is [a, *b, c] and types [bool, int, str] are extended
+        to length 4 the result is [bool, int, int, str].
+        """
+        if star_pos is None:
+            return types
+        if original_unpack:
+            # In the case where original tuple type has an unpack item, it is not practical
+            # to coerce pattern type back to the original shape (and may not even be possible),
+            # so we only restore the type of the star item.
+            res = []
+            for i, t in enumerate(types):
+                if i != star_pos or is_uninhabited(t):
+                    res.append(t)
+                else:
+                    res.append(UnpackType(self.chk.named_generic_type("builtins.tuple", [t])))
+            return res
+        new_types = types[:star_pos]
+        star_length = num_types - len(types) + 1
+        new_types += [types[star_pos]] * star_length
+        new_types += types[star_pos + 1 :]
+
+        return new_types
+
+    def visit_starred_pattern(self, o: StarredPattern) -> PatternType:
+        captures: dict[Expression, Type] = {}
+        if o.capture is not None:
+            list_type = self.chk.named_generic_type("builtins.list", [self.type_context[-1]])
+            captures[o.capture] = list_type
+        return PatternType(self.type_context[-1], UninhabitedType(), captures)
+
+    def visit_mapping_pattern(self, o: MappingPattern) -> PatternType:
+        current_type = get_proper_type(self.type_context[-1])
+        can_match = True
+        captures: dict[Expression, Type] = {}
+        for key, value in zip(o.keys, o.values):
+            inner_type = self.get_mapping_item_type(o, current_type, key)
+            if inner_type is None:
+                can_match = False
+                inner_type = self.chk.named_type("builtins.object")
+            pattern_type = self.accept(value, inner_type)
+            if is_uninhabited(pattern_type.type):
+                can_match = False
+            else:
+                self.update_type_map(captures, pattern_type.captures)
+
+        if o.rest is not None:
+            mapping = self.chk.named_type("typing.Mapping")
+            if is_subtype(current_type, mapping) and isinstance(current_type, Instance):
+                mapping_inst = map_instance_to_supertype(current_type, mapping.type)
+                dict_typeinfo = self.chk.lookup_typeinfo("builtins.dict")
+                rest_type = Instance(dict_typeinfo, mapping_inst.args)
+            else:
+                object_type = self.chk.named_type("builtins.object")
+                rest_type = self.chk.named_generic_type(
+                    "builtins.dict", [object_type, object_type]
+                )
+
+            captures[o.rest] = rest_type
+
+        else_type = current_type
+        if can_match:
+            # We can't narrow the type here, as Mapping key is invariant.
+            new_type = self.type_context[-1]
+            if not o.keys:
+                # Match cannot be refuted, so narrow the remaining type
+                mapping = self.chk.named_type("typing.Mapping")
+                if_type, else_type = self.chk.conditional_types_with_intersection(
+                    current_type,
+                    [TypeRange(mapping, is_upper_bound=False)],
+                    o,
+                    default=current_type,
+                )
+                if not isinstance(current_type, AnyType):
+                    new_type = if_type
+        else:
+            new_type = UninhabitedType()
+        return PatternType(new_type, else_type, captures)
+
+    def get_mapping_item_type(
+        self, pattern: MappingPattern, mapping_type: Type, key: Expression
+    ) -> Type | None:
+        mapping_type = get_proper_type(mapping_type)
+        if isinstance(mapping_type, TypedDictType):
+            with self.msg.filter_errors() as local_errors:
+                result: Type | None = self.chk.expr_checker.visit_typeddict_index_expr(
+                    mapping_type, key
+                )[0]
+                has_local_errors = local_errors.has_new_errors()
+            # If we can't determine the type statically fall back to treating it as a normal
+            # mapping
+            if has_local_errors:
+                with self.msg.filter_errors() as local_errors:
+                    result = self.get_simple_mapping_item_type(pattern, mapping_type, key)
+
+                    if local_errors.has_new_errors():
+                        result = None
+        else:
+            with self.msg.filter_errors():
+                result = self.get_simple_mapping_item_type(pattern, mapping_type, key)
+        return result
+
+    def get_simple_mapping_item_type(
+        self, pattern: MappingPattern, mapping_type: Type, key: Expression
+    ) -> Type:
+        result, _ = self.chk.expr_checker.check_method_call_by_name(
+            "__getitem__", mapping_type, [key], [ARG_POS], pattern
+        )
+        return result
+
+    def visit_class_pattern(self, o: ClassPattern) -> PatternType:
+        current_type = get_proper_type(self.type_context[-1])
+
+        #
+        # Check class type
+        #
+        type_info = o.class_ref.node
+        if isinstance(type_info, TypeAlias) and not type_info.no_args:
+            self.msg.fail(message_registry.CLASS_PATTERN_GENERIC_TYPE_ALIAS, o)
+            return self.early_non_match()
+
+        typ = self.chk.expr_checker.accept(o.class_ref)
+        type_ranges = self.get_class_pattern_type_ranges(typ, o)
+        if type_ranges is None:
+            return self.early_non_match()
+        typ = UnionType.make_union([t.item for t in type_ranges])
+
+        new_type, rest_type = self.chk.conditional_types_with_intersection(
+            current_type, type_ranges, o, default=current_type
+        )
+        if is_uninhabited(new_type):
+            return self.early_non_match()
+        # TODO: Do I need this?
+        narrowed_type = narrow_declared_type(current_type, new_type)
+
+        #
+        # Convert positional to keyword patterns
+        #
+        keyword_pairs: list[tuple[str | None, Pattern]] = []
+        match_arg_set: set[str] = set()
+
+        captures: dict[Expression, Type] = {}
+
+        if len(o.positionals) != 0:
+            if self.should_self_match(typ):
+                if len(o.positionals) > 1:
+                    self.msg.fail(message_registry.CLASS_PATTERN_TOO_MANY_POSITIONAL_ARGS, o)
+                pattern_type = self.accept(o.positionals[0], narrowed_type)
+                if not is_uninhabited(pattern_type.type):
+                    return PatternType(
+                        pattern_type.type,
+                        join_types(rest_type, pattern_type.rest_type),
+                        pattern_type.captures,
+                    )
+                captures = pattern_type.captures
+            else:
+                with self.msg.filter_errors() as local_errors:
+                    match_args_type = analyze_member_access(
+                        "__match_args__",
+                        typ,
+                        o,
+                        is_lvalue=False,
+                        is_super=False,
+                        is_operator=False,
+                        original_type=typ,
+                        chk=self.chk,
+                    )
+                    has_local_errors = local_errors.has_new_errors()
+                if has_local_errors:
+                    self.msg.fail(
+                        message_registry.MISSING_MATCH_ARGS.format(
+                            typ.str_with_options(self.options)
+                        ),
+                        o,
+                    )
+                    return self.early_non_match()
+
+                proper_match_args_type = get_proper_type(match_args_type)
+                if isinstance(proper_match_args_type, TupleType):
+                    match_arg_names = get_match_arg_names(proper_match_args_type)
+
+                    if len(o.positionals) > len(match_arg_names):
+                        self.msg.fail(message_registry.CLASS_PATTERN_TOO_MANY_POSITIONAL_ARGS, o)
+                        return self.early_non_match()
+                else:
+                    match_arg_names = [None] * len(o.positionals)
+
+                for arg_name, pos in zip(match_arg_names, o.positionals):
+                    keyword_pairs.append((arg_name, pos))
+                    if arg_name is not None:
+                        match_arg_set.add(arg_name)
+
+        #
+        # Check for duplicate patterns
+        #
+        keyword_arg_set = set()
+        has_duplicates = False
+        for key, value in zip(o.keyword_keys, o.keyword_values):
+            keyword_pairs.append((key, value))
+            if key in match_arg_set:
+                self.msg.fail(
+                    message_registry.CLASS_PATTERN_KEYWORD_MATCHES_POSITIONAL.format(key), value
+                )
+                has_duplicates = True
+            elif key in keyword_arg_set:
+                self.msg.fail(
+                    message_registry.CLASS_PATTERN_DUPLICATE_KEYWORD_PATTERN.format(key), value
+                )
+                has_duplicates = True
+            keyword_arg_set.add(key)
+
+        if has_duplicates:
+            return self.early_non_match()
+
+        #
+        # Check keyword patterns
+        #
+        can_match = True
+        for keyword, pattern in keyword_pairs:
+            key_type: Type | None = None
+            with self.msg.filter_errors() as local_errors:
+                if keyword is not None:
+                    key_type = analyze_member_access(
+                        keyword,
+                        narrowed_type,
+                        pattern,
+                        is_lvalue=False,
+                        is_super=False,
+                        is_operator=False,
+                        original_type=new_type,
+                        chk=self.chk,
+                    )
+                else:
+                    key_type = AnyType(TypeOfAny.from_error)
+                has_local_errors = local_errors.has_new_errors()
+            if has_local_errors or key_type is None:
+                key_type = AnyType(TypeOfAny.from_error)
+                if not (type_info and type_info.fullname == "builtins.object"):
+                    self.msg.fail(
+                        message_registry.CLASS_PATTERN_UNKNOWN_KEYWORD.format(
+                            typ.str_with_options(self.options), keyword
+                        ),
+                        pattern,
+                    )
+                elif keyword is not None:
+                    new_type = self.chk.add_any_attribute_to_type(new_type, keyword)
+
+            inner_type, inner_rest_type, inner_captures = self.accept(pattern, key_type)
+            if is_uninhabited(inner_type):
+                can_match = False
+            else:
+                self.update_type_map(captures, inner_captures)
+                if not is_uninhabited(inner_rest_type):
+                    rest_type = current_type
+
+        if not can_match:
+            new_type = UninhabitedType()
+        return PatternType(new_type, rest_type, captures)
+
+    def get_class_pattern_type_ranges(self, typ: Type, o: ClassPattern) -> list[TypeRange] | None:
+        p_typ = get_proper_type(typ)
+
+        if isinstance(p_typ, UnionType):
+            type_ranges = []
+            for item in p_typ.items:
+                type_range = self.get_class_pattern_type_ranges(item, o)
+                if type_range is not None:
+                    type_ranges.extend(type_range)
+            if not type_ranges:
+                return None
+            return type_ranges
+
+        if isinstance(p_typ, FunctionLike) and p_typ.is_type_obj():
+            typ = fill_typevars_with_any(p_typ.type_object())
+            return [TypeRange(typ, is_upper_bound=False)]
+        if (
+            isinstance(o.class_ref.node, Var)
+            and o.class_ref.node.type is not None
+            and o.class_ref.node.fullname == "typing.Callable"
+        ):
+            # Create a `Callable[..., Any]`
+            fallback = self.chk.named_type("builtins.function")
+            any_type = AnyType(TypeOfAny.unannotated)
+            typ = callable_with_ellipsis(any_type, ret_type=any_type, fallback=fallback)
+            return [TypeRange(typ, is_upper_bound=False)]
+        if isinstance(p_typ, TypeType):
+            typ = p_typ.item
+            return [TypeRange(p_typ.item, is_upper_bound=True)]
+        if isinstance(p_typ, AnyType):
+            return [TypeRange(p_typ, is_upper_bound=False)]
+
+        self.msg.fail(
+            message_registry.CLASS_PATTERN_TYPE_REQUIRED.format(
+                typ.str_with_options(self.options)
+            ),
+            o,
+        )
+        return None
+
+    def should_self_match(self, typ: Type) -> bool:
+        typ = get_proper_type(typ)
+        if isinstance(typ, TupleType):
+            typ = typ.partial_fallback
+        if isinstance(typ, AnyType):
+            return False
+        if isinstance(typ, Instance) and typ.type.get("__match_args__") is not None:
+            # Named tuples and other subtypes of builtins that define __match_args__
+            # should not self match.
+            return False
+        for other in self.self_match_types:
+            if is_subtype(typ, other):
+                return True
+        return False
+
+    def can_match_sequence(self, typ: ProperType) -> bool:
+        if isinstance(typ, AnyType):
+            return True
+        if isinstance(typ, UnionType):
+            return any(self.can_match_sequence(get_proper_type(item)) for item in typ.items)
+        for other in self.non_sequence_match_types:
+            # We have to ignore promotions, as memoryview should match, but bytes,
+            # which it can be promoted to, shouldn't
+            if is_subtype(typ, other, ignore_promotions=True):
+                return False
+        sequence = self.chk.named_type("typing.Sequence")
+        # If the static type is more general than sequence the actual type could still match
+        return is_subtype(typ, sequence) or is_subtype(sequence, typ)
+
+    def generate_types_from_names(self, type_names: list[str]) -> list[Type]:
+        types: list[Type] = []
+        for name in type_names:
+            try:
+                types.append(self.chk.named_type(name))
+            except KeyError as e:
+                # Some built in types are not defined in all test cases
+                if not name.startswith("builtins."):
+                    raise e
+        return types
+
+    def update_type_map(
+        self, original_type_map: dict[Expression, Type], extra_type_map: dict[Expression, Type]
+    ) -> None:
+        # Calculating this would not be needed if TypeMap directly used literal hashes instead of
+        # expressions, as suggested in the TODO above it's definition
+        already_captured = {literal_hash(expr) for expr in original_type_map}
+        for expr, typ in extra_type_map.items():
+            if literal_hash(expr) in already_captured:
+                node = get_var(expr)
+                self.msg.fail(
+                    message_registry.MULTIPLE_ASSIGNMENTS_IN_PATTERN.format(node.name), expr
+                )
+            else:
+                original_type_map[expr] = typ
+
+    def construct_sequence_child(self, outer_type: Type, inner_type: Type) -> Type:
+        """
+        If outer_type is a child class of typing.Sequence returns a new instance of
+        outer_type, that is a Sequence of inner_type. If outer_type is not a child class of
+        typing.Sequence just returns a Sequence of inner_type
+
+        For example:
+        construct_sequence_child(List[int], str) = List[str]
+
+        TODO: this doesn't make sense. For example if one has class S(Sequence[int], Generic[T])
+        or class T(Sequence[Tuple[T, T]]), there is no way any of those can map to Sequence[str].
+        """
+        proper_type = get_proper_type(outer_type)
+        if isinstance(proper_type, TypeVarType):
+            new_bound = self.construct_sequence_child(proper_type.upper_bound, inner_type)
+            return proper_type.copy_modified(upper_bound=new_bound)
+        if isinstance(proper_type, AnyType):
+            return outer_type
+        if isinstance(proper_type, UnionType):
+            types = [
+                self.construct_sequence_child(item, inner_type)
+                for item in proper_type.items
+                if self.can_match_sequence(get_proper_type(item))
+            ]
+            return make_simplified_union(types)
+        sequence = self.chk.named_generic_type("typing.Sequence", [inner_type])
+        if is_subtype(outer_type, self.chk.named_type("typing.Sequence")):
+            if isinstance(proper_type, TupleType):
+                proper_type = tuple_fallback(proper_type)
+            assert isinstance(proper_type, Instance)
+            empty_type = fill_typevars(proper_type.type)
+            partial_type = expand_type_by_instance(empty_type, sequence)
+            return expand_type_by_instance(partial_type, proper_type)
+        else:
+            return sequence
+
+    def early_non_match(self) -> PatternType:
+        return PatternType(UninhabitedType(), self.type_context[-1], {})
+
+
+def get_match_arg_names(typ: TupleType) -> list[str | None]:
+    args: list[str | None] = []
+    for item in typ.items:
+        values = try_getting_str_literals_from_type(item)
+        if values is None or len(values) != 1:
+            args.append(None)
+        else:
+            args.append(values[0])
+    return args
+
+
+def get_var(expr: Expression) -> Var:
+    """
+    Warning: this in only true for expressions captured by a match statement.
+    Don't call it from anywhere else
+    """
+    assert isinstance(expr, NameExpr), expr
+    node = expr.node
+    assert isinstance(node, Var), node
+    return node
+
+
+def get_type_range(typ: Type) -> TypeRange:
+    typ = get_proper_type(typ)
+    if (
+        isinstance(typ, Instance)
+        and typ.last_known_value
+        and isinstance(typ.last_known_value.value, bool)
+    ):
+        typ = typ.last_known_value
+    return TypeRange(typ, is_upper_bound=False)
+
+
+def is_uninhabited(typ: Type) -> bool:
+    return isinstance(get_proper_type(typ), UninhabitedType)

micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/mypy-1.20.2-py314h5a2d7ad_0/Lib/site-packages/mypy/checkstrformat.py

@@ -0,0 +1,1099 @@
+"""
+Format expression type checker.
+
+This file is conceptually part of ExpressionChecker and TypeChecker. Main functionality
+is located in StringFormatterChecker.check_str_format_call() for '{}'.format(), and in
+StringFormatterChecker.check_str_interpolation() for printf-style % interpolation.
+
+Note that although at runtime format strings are parsed using custom parsers,
+here we use a regexp-based approach. This way we 99% match runtime behaviour while keeping
+implementation simple.
+"""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Callable
+from re import Match, Pattern
+from typing import Final, TypeAlias as _TypeAlias, cast
+
+import mypy.errorcodes as codes
+from mypy import message_registry
+from mypy.checker_shared import TypeCheckerSharedApi
+from mypy.errors import Errors
+from mypy.maptype import map_instance_to_supertype
+from mypy.messages import MessageBuilder
+from mypy.nodes import (
+    ARG_NAMED,
+    ARG_POS,
+    ARG_STAR,
+    ARG_STAR2,
+    BytesExpr,
+    CallExpr,
+    Context,
+    DictExpr,
+    Expression,
+    ExpressionStmt,
+    IndexExpr,
+    IntExpr,
+    MemberExpr,
+    MypyFile,
+    NameExpr,
+    Node,
+    StarExpr,
+    StrExpr,
+    TempNode,
+    TupleExpr,
+)
+from mypy.parse import parse
+from mypy.subtypes import is_subtype
+from mypy.typeops import custom_special_method
+from mypy.types import (
+    AnyType,
+    Instance,
+    LiteralType,
+    TupleType,
+    Type,
+    TypeOfAny,
+    TypeVarTupleType,
+    TypeVarType,
+    UnionType,
+    UnpackType,
+    find_unpack_in_list,
+    get_proper_type,
+    get_proper_types,
+)
+
+FormatStringExpr: _TypeAlias = StrExpr | BytesExpr
+Checkers: _TypeAlias = tuple[Callable[[Expression], None], Callable[[Type], bool]]
+MatchMap: _TypeAlias = dict[tuple[int, int], Match[str]]  # span -> match
+
+
+def compile_format_re() -> Pattern[str]:
+    """Construct regexp to match format conversion specifiers in % interpolation.
+
+    See https://docs.python.org/3/library/stdtypes.html#printf-style-string-formatting
+    The regexp is intentionally a bit wider to report better errors.
+    """
+    key_re = r"(\((?P<key>[^)]*)\))?"  # (optional) parenthesised sequence of characters.
+    flags_re = r"(?P<flags>[#0\-+ ]*)"  # (optional) sequence of flags.
+    width_re = r"(?P<width>[1-9][0-9]*|\*)?"  # (optional) minimum field width (* or numbers).
+    precision_re = r"(?:\.(?P<precision>\*|[0-9]+)?)?"  # (optional) . followed by * of numbers.
+    length_mod_re = r"[hlL]?"  # (optional) length modifier (unused).
+    type_re = r"(?P<type>.)?"  # conversion type.
+    format_re = "%" + key_re + flags_re + width_re + precision_re + length_mod_re + type_re
+    return re.compile(format_re)
+
+
+def compile_new_format_re(custom_spec: bool) -> Pattern[str]:
+    """Construct regexps to match format conversion specifiers in str.format() calls.
+
+    See After https://docs.python.org/3/library/string.html#formatspec for
+    specifications. The regexps are intentionally wider, to report better errors,
+    instead of just not matching.
+    """
+
+    # Field (optional) is an integer/identifier possibly followed by several .attr and [index].
+    field = r"(?P<field>(?P<key>[^.[!:]*)([^:!]+)?)"
+
+    # Conversion (optional) is ! followed by one of letters for forced repr(), str(), or ascii().
+    conversion = r"(?P<conversion>![^:])?"
+
+    # Format specification (optional) follows its own mini-language:
+    if not custom_spec:
+        # Fill and align is valid for all builtin types.
+        fill_align = r"(?P<fill_align>.?[<>=^])?"
+        # Number formatting options are only valid for int, float, complex, and Decimal,
+        # except if only width is given (it is valid for all types).
+        # This contains sign, flags (sign, # and/or 0), width, grouping (_ or ,) and precision.
+        num_spec = r"(?P<flags>[+\- ]?#?0?)(?P<width>\d+)?[_,]?(?P<precision>\.\d+)?"
+        # The last element is type.
+        conv_type = r"(?P<type>.)?"  # only some are supported, but we want to give a better error
+        format_spec = r"(?P<format_spec>:" + fill_align + num_spec + conv_type + r")?"
+    else:
+        # Custom types can define their own form_spec using __format__().
+        format_spec = r"(?P<format_spec>:.*)?"
+
+    return re.compile(field + conversion + format_spec)
+
+
+FORMAT_RE: Final = compile_format_re()
+FORMAT_RE_NEW: Final = compile_new_format_re(False)
+FORMAT_RE_NEW_CUSTOM: Final = compile_new_format_re(True)
+DUMMY_FIELD_NAME: Final = "__dummy_name__"
+
+# Types that require either int or float.
+NUMERIC_TYPES_OLD: Final = {"d", "i", "o", "u", "x", "X", "e", "E", "f", "F", "g", "G"}
+NUMERIC_TYPES_NEW: Final = {"b", "d", "o", "e", "E", "f", "F", "g", "G", "n", "x", "X", "%"}
+
+# These types accept _only_ int.
+REQUIRE_INT_OLD: Final = {"o", "x", "X"}
+REQUIRE_INT_NEW: Final = {"b", "d", "o", "x", "X"}
+
+# These types fall back to SupportsFloat with % (other fall back to SupportsInt)
+FLOAT_TYPES: Final = {"e", "E", "f", "F", "g", "G"}
+
+
+class ConversionSpecifier:
+    def __init__(
+        self, match: Match[str], start_pos: int = -1, non_standard_format_spec: bool = False
+    ) -> None:
+        self.whole_seq = match.group()
+        self.start_pos = start_pos
+
+        m_dict = match.groupdict()
+        self.key = m_dict.get("key")
+
+        # Replace unmatched optional groups with empty matches (for convenience).
+        self.conv_type = m_dict.get("type") or ""
+        self.flags = m_dict.get("flags") or ""
+        self.width = m_dict.get("width") or ""
+        self.precision = m_dict.get("precision") or ""
+
+        # Used only for str.format() calls (it may be custom for types with __format__()).
+        self.format_spec = m_dict.get("format_spec")
+        self.non_standard_format_spec = non_standard_format_spec
+        # Used only for str.format() calls.
+        self.conversion = m_dict.get("conversion")
+        # Full formatted expression (i.e. key plus following attributes and/or indexes).
+        # Used only for str.format() calls.
+        self.field = m_dict.get("field")
+
+    def has_key(self) -> bool:
+        return self.key is not None
+
+    def has_star(self) -> bool:
+        return self.width == "*" or self.precision == "*"
+
+
+def parse_conversion_specifiers(format_str: str) -> list[ConversionSpecifier]:
+    """Parse c-printf-style format string into list of conversion specifiers."""
+    specifiers: list[ConversionSpecifier] = []
+    for m in re.finditer(FORMAT_RE, format_str):
+        specifiers.append(ConversionSpecifier(m, start_pos=m.start()))
+    return specifiers
+
+
+def parse_format_value(
+    format_value: str, ctx: Context, msg: MessageBuilder, nested: bool = False
+) -> list[ConversionSpecifier] | None:
+    """Parse format string into list of conversion specifiers.
+
+    The specifiers may be nested (two levels maximum), in this case they are ordered as
+    '{0:{1}}, {2:{3}{4}}'. Return None in case of an error.
+    """
+    top_targets = find_non_escaped_targets(format_value, ctx, msg)
+    if top_targets is None:
+        return None
+
+    result: list[ConversionSpecifier] = []
+    for target, start_pos in top_targets:
+        match = FORMAT_RE_NEW.fullmatch(target)
+        if match:
+            conv_spec = ConversionSpecifier(match, start_pos=start_pos)
+        else:
+            custom_match = FORMAT_RE_NEW_CUSTOM.fullmatch(target)
+            if custom_match:
+                conv_spec = ConversionSpecifier(
+                    custom_match, start_pos=start_pos, non_standard_format_spec=True
+                )
+            else:
+                msg.fail(
+                    "Invalid conversion specifier in format string",
+                    ctx,
+                    code=codes.STRING_FORMATTING,
+                )
+                return None
+
+        if conv_spec.key and ("{" in conv_spec.key or "}" in conv_spec.key):
+            msg.fail("Conversion value must not contain { or }", ctx, code=codes.STRING_FORMATTING)
+            return None
+        result.append(conv_spec)
+
+        # Parse nested conversions that are allowed in format specifier.
+        if (
+            conv_spec.format_spec
+            and conv_spec.non_standard_format_spec
+            and ("{" in conv_spec.format_spec or "}" in conv_spec.format_spec)
+        ):
+            if nested:
+                msg.fail(
+                    "Formatting nesting must be at most two levels deep",
+                    ctx,
+                    code=codes.STRING_FORMATTING,
+                )
+                return None
+            sub_conv_specs = parse_format_value(conv_spec.format_spec, ctx, msg, nested=True)
+            if sub_conv_specs is None:
+                return None
+            result.extend(sub_conv_specs)
+    return result
+
+
+def find_non_escaped_targets(
+    format_value: str, ctx: Context, msg: MessageBuilder
+) -> list[tuple[str, int]] | None:
+    """Return list of raw (un-parsed) format specifiers in format string.
+
+    Format specifiers don't include enclosing braces. We don't use regexp for
+    this because they don't work well with nested/repeated patterns
+    (both greedy and non-greedy), and these are heavily used internally for
+    representation of f-strings.
+
+    Return None in case of an error.
+    """
+    result = []
+    next_spec = ""
+    pos = 0
+    nesting = 0
+    while pos < len(format_value):
+        c = format_value[pos]
+        if not nesting:
+            # Skip any paired '{{' and '}}', enter nesting on '{', report error on '}'.
+            if c == "{":
+                if pos < len(format_value) - 1 and format_value[pos + 1] == "{":
+                    pos += 1
+                else:
+                    nesting = 1
+            if c == "}":
+                if pos < len(format_value) - 1 and format_value[pos + 1] == "}":
+                    pos += 1
+                else:
+                    msg.fail(
+                        "Invalid conversion specifier in format string: unexpected }",
+                        ctx,
+                        code=codes.STRING_FORMATTING,
+                    )
+                    return None
+        else:
+            # Adjust nesting level, then either continue adding chars or move on.
+            if c == "{":
+                nesting += 1
+            if c == "}":
+                nesting -= 1
+            if nesting:
+                next_spec += c
+            else:
+                result.append((next_spec, pos - len(next_spec)))
+                next_spec = ""
+        pos += 1
+    if nesting:
+        msg.fail(
+            "Invalid conversion specifier in format string: unmatched {",
+            ctx,
+            code=codes.STRING_FORMATTING,
+        )
+        return None
+    return result
+
+
+class StringFormatterChecker:
+    """String interpolation/formatter type checker.
+
+    This class works closely together with checker.ExpressionChecker.
+    """
+
+    # Some services are provided by a TypeChecker instance.
+    chk: TypeCheckerSharedApi
+    # This is shared with TypeChecker, but stored also here for convenience.
+    msg: MessageBuilder
+
+    def __init__(self, chk: TypeCheckerSharedApi, msg: MessageBuilder) -> None:
+        """Construct an expression type checker."""
+        self.chk = chk
+        self.msg = msg
+
+    def check_str_format_call(self, call: CallExpr, format_value: str) -> None:
+        """Perform more precise checks for str.format() calls when possible.
+
+        Currently the checks are performed for:
+          * Actual string literals
+          * Literal types with string values
+          * Final names with string values
+
+        The checks that we currently perform:
+          * Check generic validity (e.g. unmatched { or }, and {} in invalid positions)
+          * Check consistency of specifiers' auto-numbering
+          * Verify that replacements can be found for all conversion specifiers,
+            and all arguments were used
+          * Non-standard format specs are only allowed for types with custom __format__
+          * Type check replacements with accessors applied (if any).
+          * Verify that specifier type is known and matches replacement type
+          * Perform special checks for some specifier types:
+            - 'c' requires a single character string
+            - 's' must not accept bytes
+            - non-empty flags are only allowed for numeric types
+        """
+        conv_specs = parse_format_value(format_value, call, self.msg)
+        if conv_specs is None:
+            return
+        if not self.auto_generate_keys(conv_specs, call):
+            return
+        self.check_specs_in_format_call(call, conv_specs, format_value)
+
+    def check_specs_in_format_call(
+        self, call: CallExpr, specs: list[ConversionSpecifier], format_value: str
+    ) -> None:
+        """Perform pairwise checks for conversion specifiers vs their replacements.
+
+        The core logic for format checking is implemented in this method.
+        """
+        assert all(s.key for s in specs), "Keys must be auto-generated first!"
+        replacements = self.find_replacements_in_call(call, [cast(str, s.key) for s in specs])
+        assert len(replacements) == len(specs)
+        for spec, repl in zip(specs, replacements):
+            repl = self.apply_field_accessors(spec, repl, ctx=call)
+            actual_type = repl.type if isinstance(repl, TempNode) else self.chk.lookup_type(repl)
+            assert actual_type is not None
+
+            # Special case custom formatting.
+            if (
+                spec.format_spec
+                and spec.non_standard_format_spec
+                and
+                # Exclude "dynamic" specifiers (i.e. containing nested formatting).
+                not ("{" in spec.format_spec or "}" in spec.format_spec)
+            ):
+                if (
+                    not custom_special_method(actual_type, "__format__", check_all=True)
+                    or spec.conversion
+                ):
+                    # TODO: add support for some custom specs like datetime?
+                    self.msg.fail(
+                        f'Unrecognized format specification "{spec.format_spec[1:]}"',
+                        call,
+                        code=codes.STRING_FORMATTING,
+                    )
+                    continue
+            # Adjust expected and actual types.
+            if not spec.conv_type:
+                expected_type: Type | None = AnyType(TypeOfAny.special_form)
+            else:
+                assert isinstance(call.callee, MemberExpr)
+                if isinstance(call.callee.expr, StrExpr):
+                    format_str = call.callee.expr
+                else:
+                    format_str = StrExpr(format_value)
+                expected_type = self.conversion_type(
+                    spec.conv_type, call, format_str, format_call=True
+                )
+            if spec.conversion is not None:
+                # If the explicit conversion is given, then explicit conversion is called _first_.
+                if spec.conversion[1] not in "rsa":
+                    self.msg.fail(
+                        (
+                            f'Invalid conversion type "{spec.conversion[1]}", '
+                            f'must be one of "r", "s" or "a"'
+                        ),
+                        call,
+                        code=codes.STRING_FORMATTING,
+                    )
+                actual_type = self.named_type("builtins.str")
+
+            # Perform the checks for given types.
+            if expected_type is None:
+                continue
+
+            a_type = get_proper_type(actual_type)
+            actual_items = (
+                get_proper_types(a_type.items) if isinstance(a_type, UnionType) else [a_type]
+            )
+            for a_type in actual_items:
+                if custom_special_method(a_type, "__format__"):
+                    continue
+                self.check_placeholder_type(a_type, expected_type, call)
+                self.perform_special_format_checks(spec, call, repl, a_type, expected_type)
+
+    def perform_special_format_checks(
+        self,
+        spec: ConversionSpecifier,
+        call: CallExpr,
+        repl: Expression,
+        actual_type: Type,
+        expected_type: Type,
+    ) -> None:
+        # TODO: try refactoring to combine this logic with % formatting.
+        if spec.conv_type == "c":
+            if isinstance(repl, (StrExpr, BytesExpr)) and len(repl.value) != 1:
+                self.msg.requires_int_or_char(call, format_call=True)
+            c_typ = get_proper_type(self.chk.lookup_type(repl))
+            if isinstance(c_typ, Instance) and c_typ.last_known_value:
+                c_typ = c_typ.last_known_value
+            if isinstance(c_typ, LiteralType) and isinstance(c_typ.value, str):
+                if len(c_typ.value) != 1:
+                    self.msg.requires_int_or_char(call, format_call=True)
+        if (not spec.conv_type or spec.conv_type == "s") and not spec.conversion:
+            if has_type_component(actual_type, "builtins.bytes") and not custom_special_method(
+                actual_type, "__str__"
+            ):
+                self.msg.fail(
+                    'If x = b\'abc\' then f"{x}" or "{}".format(x) produces "b\'abc\'", '
+                    'not "abc". If this is desired behavior, use f"{x!r}" or "{!r}".format(x). '
+                    "Otherwise, decode the bytes",
+                    call,
+                    code=codes.STR_BYTES_PY3,
+                )
+        if spec.flags:
+            numeric_types = UnionType(
+                [self.named_type("builtins.int"), self.named_type("builtins.float")]
+            )
+            if (
+                spec.conv_type
+                and spec.conv_type not in NUMERIC_TYPES_NEW
+                or not spec.conv_type
+                and not is_subtype(actual_type, numeric_types)
+                and not custom_special_method(actual_type, "__format__")
+            ):
+                self.msg.fail(
+                    "Numeric flags are only allowed for numeric types",
+                    call,
+                    code=codes.STRING_FORMATTING,
+                )
+
+    def find_replacements_in_call(self, call: CallExpr, keys: list[str]) -> list[Expression]:
+        """Find replacement expression for every specifier in str.format() call.
+
+        In case of an error use TempNode(AnyType).
+        """
+        result: list[Expression] = []
+        used: set[Expression] = set()
+        for key in keys:
+            if key.isdecimal():
+                expr = self.get_expr_by_position(int(key), call)
+                if not expr:
+                    self.msg.fail(
+                        f"Cannot find replacement for positional format specifier {key}",
+                        call,
+                        code=codes.STRING_FORMATTING,
+                    )
+                    expr = TempNode(AnyType(TypeOfAny.from_error))
+            else:
+                expr = self.get_expr_by_name(key, call)
+                if not expr:
+                    self.msg.fail(
+                        f'Cannot find replacement for named format specifier "{key}"',
+                        call,
+                        code=codes.STRING_FORMATTING,
+                    )
+                    expr = TempNode(AnyType(TypeOfAny.from_error))
+            result.append(expr)
+            if not isinstance(expr, TempNode):
+                used.add(expr)
+        # Strictly speaking not using all replacements is not a type error, but most likely
+        # a typo in user code, so we show an error like we do for % formatting.
+        total_explicit = len([kind for kind in call.arg_kinds if kind in (ARG_POS, ARG_NAMED)])
+        if len(used) < total_explicit:
+            self.msg.too_many_string_formatting_arguments(call)
+        return result
+
+    def get_expr_by_position(self, pos: int, call: CallExpr) -> Expression | None:
+        """Get positional replacement expression from '{0}, {1}'.format(x, y, ...) call.
+
+        If the type is from *args, return TempNode(<item type>). Return None in case of
+        an error.
+        """
+        pos_args = [arg for arg, kind in zip(call.args, call.arg_kinds) if kind == ARG_POS]
+        if pos < len(pos_args):
+            return pos_args[pos]
+        star_args = [arg for arg, kind in zip(call.args, call.arg_kinds) if kind == ARG_STAR]
+        if not star_args:
+            return None
+
+        # Fall back to *args when present in call.
+        star_arg = star_args[0]
+        varargs_type = get_proper_type(self.chk.lookup_type(star_arg))
+        if not isinstance(varargs_type, Instance) or not varargs_type.type.has_base(
+            "typing.Sequence"
+        ):
+            # Error should be already reported.
+            return TempNode(AnyType(TypeOfAny.special_form))
+        iter_info = self.chk.named_generic_type(
+            "typing.Sequence", [AnyType(TypeOfAny.special_form)]
+        ).type
+        return TempNode(map_instance_to_supertype(varargs_type, iter_info).args[0])
+
+    def get_expr_by_name(self, key: str, call: CallExpr) -> Expression | None:
+        """Get named replacement expression from '{name}'.format(name=...) call.
+
+        If the type is from **kwargs, return TempNode(<item type>). Return None in case of
+        an error.
+        """
+        named_args = [
+            arg
+            for arg, kind, name in zip(call.args, call.arg_kinds, call.arg_names)
+            if kind == ARG_NAMED and name == key
+        ]
+        if named_args:
+            return named_args[0]
+        star_args_2 = [arg for arg, kind in zip(call.args, call.arg_kinds) if kind == ARG_STAR2]
+        if not star_args_2:
+            return None
+        star_arg_2 = star_args_2[0]
+        kwargs_type = get_proper_type(self.chk.lookup_type(star_arg_2))
+        if not isinstance(kwargs_type, Instance) or not kwargs_type.type.has_base(
+            "typing.Mapping"
+        ):
+            # Error should be already reported.
+            return TempNode(AnyType(TypeOfAny.special_form))
+        any_type = AnyType(TypeOfAny.special_form)
+        mapping_info = self.chk.named_generic_type("typing.Mapping", [any_type, any_type]).type
+        return TempNode(map_instance_to_supertype(kwargs_type, mapping_info).args[1])
+
+    def auto_generate_keys(self, all_specs: list[ConversionSpecifier], ctx: Context) -> bool:
+        """Translate '{} {name} {}' to '{0} {name} {1}'.
+
+        Return True if generation was successful, otherwise report an error and return false.
+        """
+        some_defined = any(s.key and s.key.isdecimal() for s in all_specs)
+        all_defined = all(bool(s.key) for s in all_specs)
+        if some_defined and not all_defined:
+            self.msg.fail(
+                "Cannot combine automatic field numbering and manual field specification",
+                ctx,
+                code=codes.STRING_FORMATTING,
+            )
+            return False
+        if all_defined:
+            return True
+        next_index = 0
+        for spec in all_specs:
+            if not spec.key:
+                str_index = str(next_index)
+                spec.key = str_index
+                # Update also the full field (i.e. turn {.x} into {0.x}).
+                if not spec.field:
+                    spec.field = str_index
+                else:
+                    spec.field = str_index + spec.field
+                next_index += 1
+        return True
+
+    def apply_field_accessors(
+        self, spec: ConversionSpecifier, repl: Expression, ctx: Context
+    ) -> Expression:
+        """Transform and validate expr in '{.attr[item]}'.format(expr) into expr.attr['item'].
+
+        If validation fails, return TempNode(AnyType).
+        """
+        assert spec.key, "Keys must be auto-generated first!"
+        if spec.field == spec.key:
+            return repl
+        assert spec.field
+
+        temp_errors = Errors(self.chk.options)
+        dummy = DUMMY_FIELD_NAME + spec.field[len(spec.key) :]
+        temp_ast: Node = parse(
+            dummy, fnam="<format>", module=None, options=self.chk.options, errors=temp_errors
+        )
+        if temp_errors.is_errors():
+            self.msg.fail(
+                f'Syntax error in format specifier "{spec.field}"',
+                ctx,
+                code=codes.STRING_FORMATTING,
+            )
+            return TempNode(AnyType(TypeOfAny.from_error))
+
+        # These asserts are guaranteed by the original regexp.
+        assert isinstance(temp_ast, MypyFile)
+        temp_ast = temp_ast.defs[0]
+        assert isinstance(temp_ast, ExpressionStmt)
+        temp_ast = temp_ast.expr
+        if not self.validate_and_transform_accessors(temp_ast, repl, spec, ctx=ctx):
+            return TempNode(AnyType(TypeOfAny.from_error))
+
+        # Check if there are any other errors (like missing members).
+        # TODO: fix column to point to actual start of the format specifier _within_ string.
+        temp_ast.line = ctx.line
+        temp_ast.column = ctx.column
+        self.chk.expr_checker.accept(temp_ast)
+        return temp_ast
+
+    def validate_and_transform_accessors(
+        self,
+        temp_ast: Expression,
+        original_repl: Expression,
+        spec: ConversionSpecifier,
+        ctx: Context,
+    ) -> bool:
+        """Validate and transform (in-place) format field accessors.
+
+        On error, report it and return False. The transformations include replacing the dummy
+        variable with actual replacement expression and translating any name expressions in an
+        index into strings, so that this will work:
+
+            class User(TypedDict):
+                name: str
+                id: int
+            u: User
+            '{[id]:d} -> {[name]}'.format(u)
+        """
+        if not isinstance(temp_ast, (MemberExpr, IndexExpr)):
+            self.msg.fail(
+                "Only index and member expressions are allowed in"
+                ' format field accessors; got "{}"'.format(spec.field),
+                ctx,
+                code=codes.STRING_FORMATTING,
+            )
+            return False
+        if isinstance(temp_ast, MemberExpr):
+            node = temp_ast.expr
+        else:
+            node = temp_ast.base
+            if not isinstance(temp_ast.index, (NameExpr, IntExpr)):
+                assert spec.key, "Call this method only after auto-generating keys!"
+                assert spec.field
+                self.msg.fail(
+                    'Invalid index expression in format field accessor "{}"'.format(
+                        spec.field[len(spec.key) :]
+                    ),
+                    ctx,
+                    code=codes.STRING_FORMATTING,
+                )
+                return False
+            if isinstance(temp_ast.index, NameExpr):
+                temp_ast.index = StrExpr(temp_ast.index.name)
+        if isinstance(node, NameExpr) and node.name == DUMMY_FIELD_NAME:
+            # Replace it with the actual replacement expression.
+            assert isinstance(temp_ast, (IndexExpr, MemberExpr))  # XXX: this is redundant
+            if isinstance(temp_ast, IndexExpr):
+                temp_ast.base = original_repl
+            else:
+                temp_ast.expr = original_repl
+            return True
+        node.line = ctx.line
+        node.column = ctx.column
+        return self.validate_and_transform_accessors(
+            node, original_repl=original_repl, spec=spec, ctx=ctx
+        )
+
+    # TODO: In Python 3, the bytes formatting has a more restricted set of options
+    #       compared to string formatting.
+    def check_str_interpolation(self, expr: FormatStringExpr, replacements: Expression) -> Type:
+        """Check the types of the 'replacements' in a string interpolation
+        expression: str % replacements.
+        """
+        self.chk.expr_checker.accept(expr)
+        specifiers = parse_conversion_specifiers(expr.value)
+        has_mapping_keys = self.analyze_conversion_specifiers(specifiers, expr)
+        if has_mapping_keys is None:
+            pass  # Error was reported
+        elif has_mapping_keys:
+            self.check_mapping_str_interpolation(specifiers, replacements, expr)
+        else:
+            self.check_simple_str_interpolation(specifiers, replacements, expr)
+
+        if isinstance(expr, BytesExpr):
+            return self.named_type("builtins.bytes")
+        elif isinstance(expr, StrExpr):
+            return self.named_type("builtins.str")
+        else:
+            assert False
+
+    def analyze_conversion_specifiers(
+        self, specifiers: list[ConversionSpecifier], context: Context
+    ) -> bool | None:
+        has_star = any(specifier.has_star() for specifier in specifiers)
+        has_key = any(specifier.has_key() for specifier in specifiers)
+        all_have_keys = all(
+            specifier.has_key() or specifier.conv_type == "%" for specifier in specifiers
+        )
+
+        if has_key and has_star:
+            self.msg.string_interpolation_with_star_and_key(context)
+            return None
+        if has_key and not all_have_keys:
+            self.msg.string_interpolation_mixing_key_and_non_keys(context)
+            return None
+        return has_key
+
+    def check_simple_str_interpolation(
+        self,
+        specifiers: list[ConversionSpecifier],
+        replacements: Expression,
+        expr: FormatStringExpr,
+    ) -> None:
+        """Check % string interpolation with positional specifiers '%s, %d' % ('yes, 42')."""
+        checkers = self.build_replacement_checkers(specifiers, replacements, expr)
+        if checkers is None:
+            return
+
+        rhs_type = get_proper_type(self.accept(replacements))
+        rep_types: list[Type] = []
+        if isinstance(rhs_type, TupleType):
+            rep_types = rhs_type.items
+            unpack_index = find_unpack_in_list(rep_types)
+            if unpack_index is not None:
+                # TODO: we should probably warn about potentially short tuple.
+                # However, without special-casing for tuple(f(i) for in other_tuple)
+                # this causes false positive on mypy self-check in report.py.
+                extras = max(0, len(checkers) - len(rep_types) + 1)
+                unpacked = rep_types[unpack_index]
+                assert isinstance(unpacked, UnpackType)
+                unpacked = get_proper_type(unpacked.type)
+                if isinstance(unpacked, TypeVarTupleType):
+                    unpacked = get_proper_type(unpacked.upper_bound)
+                assert (
+                    isinstance(unpacked, Instance) and unpacked.type.fullname == "builtins.tuple"
+                )
+                unpack_items = [unpacked.args[0]] * extras
+                rep_types = rep_types[:unpack_index] + unpack_items + rep_types[unpack_index + 1 :]
+        elif isinstance(rhs_type, AnyType):
+            return
+        elif isinstance(rhs_type, Instance) and rhs_type.type.fullname == "builtins.tuple":
+            # Assume that an arbitrary-length tuple has the right number of items.
+            rep_types = [rhs_type.args[0]] * len(checkers)
+        elif isinstance(rhs_type, UnionType):
+            for typ in rhs_type.relevant_items():
+                temp_node = TempNode(typ)
+                temp_node.line = replacements.line
+                self.check_simple_str_interpolation(specifiers, temp_node, expr)
+            return
+        else:
+            rep_types = [rhs_type]
+
+        if len(checkers) > len(rep_types):
+            # Only check the fix-length Tuple type. Other Iterable types would skip.
+            if is_subtype(rhs_type, self.chk.named_type("typing.Iterable")) and not isinstance(
+                rhs_type, TupleType
+            ):
+                return
+            else:
+                self.msg.too_few_string_formatting_arguments(replacements)
+        elif len(checkers) < len(rep_types):
+            self.msg.too_many_string_formatting_arguments(replacements)
+        else:
+            if len(checkers) == 1:
+                check_node, check_type = checkers[0]
+                if isinstance(rhs_type, TupleType) and len(rhs_type.items) == 1:
+                    check_type(rhs_type.items[0])
+                else:
+                    check_node(replacements)
+            elif isinstance(replacements, TupleExpr) and not any(
+                isinstance(item, StarExpr) for item in replacements.items
+            ):
+                for checks, rep_node in zip(checkers, replacements.items):
+                    check_node, check_type = checks
+                    check_node(rep_node)
+            else:
+                for checks, rep_type in zip(checkers, rep_types):
+                    check_node, check_type = checks
+                    check_type(rep_type)
+
+    def check_mapping_str_interpolation(
+        self,
+        specifiers: list[ConversionSpecifier],
+        replacements: Expression,
+        expr: FormatStringExpr,
+    ) -> None:
+        """Check % string interpolation with names specifiers '%(name)s' % {'name': 'John'}."""
+        if isinstance(replacements, DictExpr) and all(
+            isinstance(k, (StrExpr, BytesExpr)) for k, v in replacements.items
+        ):
+            mapping: dict[str, Type] = {}
+            for k, v in replacements.items:
+                if isinstance(expr, BytesExpr):
+                    # Special case: for bytes formatting keys must be bytes.
+                    if not isinstance(k, BytesExpr):
+                        self.msg.fail(
+                            "Dictionary keys in bytes formatting must be bytes, not strings",
+                            expr,
+                            code=codes.STRING_FORMATTING,
+                        )
+                key_str = cast(FormatStringExpr, k).value
+                mapping[key_str] = self.accept(v)
+
+            for specifier in specifiers:
+                if specifier.conv_type == "%":
+                    # %% is allowed in mappings, no checking is required
+                    continue
+                assert specifier.key is not None
+                if specifier.key not in mapping:
+                    self.msg.key_not_in_mapping(specifier.key, replacements)
+                    return
+                rep_type = mapping[specifier.key]
+                assert specifier.conv_type is not None
+                expected_type = self.conversion_type(specifier.conv_type, replacements, expr)
+                if expected_type is None:
+                    return
+                self.chk.check_subtype(
+                    rep_type,
+                    expected_type,
+                    replacements,
+                    message_registry.INCOMPATIBLE_TYPES_IN_STR_INTERPOLATION,
+                    "expression has type",
+                    f"placeholder with key '{specifier.key}' has type",
+                    code=codes.STRING_FORMATTING,
+                )
+                if specifier.conv_type == "s":
+                    self.check_s_special_cases(expr, rep_type, expr)
+        else:
+            rep_type = self.accept(replacements)
+            dict_type = self.build_dict_type(expr)
+            self.chk.check_subtype(
+                rep_type,
+                dict_type,
+                replacements,
+                message_registry.FORMAT_REQUIRES_MAPPING,
+                "expression has type",
+                "expected type for mapping is",
+                code=codes.STRING_FORMATTING,
+            )
+
+    def build_dict_type(self, expr: FormatStringExpr) -> Type:
+        """Build expected mapping type for right operand in % formatting."""
+        any_type = AnyType(TypeOfAny.special_form)
+        if isinstance(expr, BytesExpr):
+            bytes_type = self.chk.named_generic_type("builtins.bytes", [])
+            return self.chk.named_generic_type(
+                "_typeshed.SupportsKeysAndGetItem", [bytes_type, any_type]
+            )
+        elif isinstance(expr, StrExpr):
+            str_type = self.chk.named_generic_type("builtins.str", [])
+            return self.chk.named_generic_type(
+                "_typeshed.SupportsKeysAndGetItem", [str_type, any_type]
+            )
+        else:
+            assert False, "Unreachable"
+
+    def build_replacement_checkers(
+        self, specifiers: list[ConversionSpecifier], context: Context, expr: FormatStringExpr
+    ) -> list[Checkers] | None:
+        checkers: list[Checkers] = []
+        for specifier in specifiers:
+            checker = self.replacement_checkers(specifier, context, expr)
+            if checker is None:
+                return None
+            checkers.extend(checker)
+        return checkers
+
+    def replacement_checkers(
+        self, specifier: ConversionSpecifier, context: Context, expr: FormatStringExpr
+    ) -> list[Checkers] | None:
+        """Returns a list of tuples of two functions that check whether a replacement is
+        of the right type for the specifier. The first function takes a node and checks
+        its type in the right type context. The second function just checks a type.
+        """
+        checkers: list[Checkers] = []
+
+        if specifier.width == "*":
+            checkers.append(self.checkers_for_star(context))
+        if specifier.precision == "*":
+            checkers.append(self.checkers_for_star(context))
+
+        if specifier.conv_type == "c":
+            c = self.checkers_for_c_type(specifier.conv_type, context, expr)
+            if c is None:
+                return None
+            checkers.append(c)
+        elif specifier.conv_type is not None and specifier.conv_type != "%":
+            c = self.checkers_for_regular_type(specifier.conv_type, context, expr)
+            if c is None:
+                return None
+            checkers.append(c)
+        return checkers
+
+    def checkers_for_star(self, context: Context) -> Checkers:
+        """Returns a tuple of check functions that check whether, respectively,
+        a node or a type is compatible with a star in a conversion specifier.
+        """
+        expected = self.named_type("builtins.int")
+
+        def check_type(type: Type) -> bool:
+            expected = self.named_type("builtins.int")
+            return self.chk.check_subtype(
+                type, expected, context, "* wants int", code=codes.STRING_FORMATTING
+            )
+
+        def check_expr(expr: Expression) -> None:
+            type = self.accept(expr, expected)
+            check_type(type)
+
+        return check_expr, check_type
+
+    def check_placeholder_type(self, typ: Type, expected_type: Type, context: Context) -> bool:
+        return self.chk.check_subtype(
+            typ,
+            expected_type,
+            context,
+            message_registry.INCOMPATIBLE_TYPES_IN_STR_INTERPOLATION,
+            "expression has type",
+            "placeholder has type",
+            code=codes.STRING_FORMATTING,
+        )
+
+    def checkers_for_regular_type(
+        self, conv_type: str, context: Context, expr: FormatStringExpr
+    ) -> Checkers | None:
+        """Returns a tuple of check functions that check whether, respectively,
+        a node or a type is compatible with 'type'. Return None in case of an error.
+        """
+        expected_type = self.conversion_type(conv_type, context, expr)
+        if expected_type is None:
+            return None
+
+        def check_type(typ: Type) -> bool:
+            assert expected_type is not None
+            ret = self.check_placeholder_type(typ, expected_type, context)
+            if ret and conv_type == "s":
+                ret = self.check_s_special_cases(expr, typ, context)
+            return ret
+
+        def check_expr(expr: Expression) -> None:
+            type = self.accept(expr, expected_type)
+            check_type(type)
+
+        return check_expr, check_type
+
+    def check_s_special_cases(self, expr: FormatStringExpr, typ: Type, context: Context) -> bool:
+        """Additional special cases for %s in bytes vs string context."""
+        if isinstance(expr, StrExpr):
+            # Couple special cases for string formatting.
+            if has_type_component(typ, "builtins.bytes"):
+                self.msg.fail(
+                    'If x = b\'abc\' then "%s" % x produces "b\'abc\'", not "abc". '
+                    'If this is desired behavior use "%r" % x. Otherwise, decode the bytes',
+                    context,
+                    code=codes.STR_BYTES_PY3,
+                )
+                return False
+        if isinstance(expr, BytesExpr):
+            # A special case for bytes formatting: b'%s' actually requires bytes on Python 3.
+            if has_type_component(typ, "builtins.str"):
+                self.msg.fail(
+                    "On Python 3 b'%s' requires bytes, not string",
+                    context,
+                    code=codes.STRING_FORMATTING,
+                )
+                return False
+        return True
+
+    def checkers_for_c_type(
+        self, type: str, context: Context, format_expr: FormatStringExpr
+    ) -> Checkers | None:
+        """Returns a tuple of check functions that check whether, respectively,
+        a node or a type is compatible with 'type' that is a character type.
+        """
+        expected_type = self.conversion_type(type, context, format_expr)
+        if expected_type is None:
+            return None
+
+        def check_type(type: Type) -> bool:
+            assert expected_type is not None
+            if isinstance(format_expr, BytesExpr):
+                err_msg = '"%c" requires an integer in range(256) or a single byte'
+            else:
+                err_msg = '"%c" requires int or char'
+            return self.chk.check_subtype(
+                type,
+                expected_type,
+                context,
+                err_msg,
+                "expression has type",
+                code=codes.STRING_FORMATTING,
+            )
+
+        def check_expr(expr: Expression) -> None:
+            """int, or str with length 1"""
+            type = self.accept(expr, expected_type)
+            # We need further check with expr to make sure that
+            # it has exact one char or one single byte.
+            if check_type(type):
+                # Python 3 doesn't support b'%c' % str
+                if (
+                    isinstance(format_expr, BytesExpr)
+                    and isinstance(expr, BytesExpr)
+                    and len(expr.value) != 1
+                ):
+                    self.msg.requires_int_or_single_byte(context)
+                elif isinstance(expr, (StrExpr, BytesExpr)) and len(expr.value) != 1:
+                    self.msg.requires_int_or_char(context)
+
+        return check_expr, check_type
+
+    def conversion_type(
+        self, p: str, context: Context, expr: FormatStringExpr, format_call: bool = False
+    ) -> Type | None:
+        """Return the type that is accepted for a string interpolation conversion specifier type.
+
+        Note that both Python's float (e.g. %f) and integer (e.g. %d)
+        specifier types accept both float and integers.
+
+        The 'format_call' argument indicates whether this type came from % interpolation or from
+        a str.format() call, the meaning of few formatting types are different.
+        """
+        NUMERIC_TYPES = NUMERIC_TYPES_NEW if format_call else NUMERIC_TYPES_OLD
+        INT_TYPES = REQUIRE_INT_NEW if format_call else REQUIRE_INT_OLD
+        if p == "b" and not format_call:
+            if not isinstance(expr, BytesExpr):
+                self.msg.fail(
+                    'Format character "b" is only supported on bytes patterns',
+                    context,
+                    code=codes.STRING_FORMATTING,
+                )
+                return None
+            return self.named_type("builtins.bytes")
+        elif p == "a":
+            # TODO: return type object?
+            return AnyType(TypeOfAny.special_form)
+        elif p in ["s", "r"]:
+            return AnyType(TypeOfAny.special_form)
+        elif p in NUMERIC_TYPES:
+            if p in INT_TYPES:
+                numeric_types = [self.named_type("builtins.int")]
+            else:
+                numeric_types = [
+                    self.named_type("builtins.int"),
+                    self.named_type("builtins.float"),
+                ]
+                if not format_call:
+                    if p in FLOAT_TYPES:
+                        numeric_types.append(self.named_type("typing.SupportsFloat"))
+                    else:
+                        numeric_types.append(self.named_type("typing.SupportsInt"))
+            return UnionType.make_union(numeric_types)
+        elif p in ["c"]:
+            if isinstance(expr, BytesExpr):
+                return UnionType(
+                    [self.named_type("builtins.int"), self.named_type("builtins.bytes")]
+                )
+            else:
+                return UnionType(
+                    [self.named_type("builtins.int"), self.named_type("builtins.str")]
+                )
+        else:
+            self.msg.unsupported_placeholder(p, context)
+            return None
+
+    #
+    # Helpers
+    #
+
+    def named_type(self, name: str) -> Instance:
+        """Return an instance type with type given by the name and no type
+        arguments. Alias for TypeChecker.named_type.
+        """
+        return self.chk.named_type(name)
+
+    def accept(self, expr: Expression, context: Type | None = None) -> Type:
+        """Type check a node. Alias for TypeChecker.accept."""
+        return self.chk.expr_checker.accept(expr, context)
+
+
+def has_type_component(typ: Type, fullname: str) -> bool:
+    """Is this a specific instance type, or a union that contains it?
+
+    We use this ad-hoc function instead of a proper visitor or subtype check
+    because some str vs bytes errors are strictly speaking not runtime errors,
+    but rather highly counter-intuitive behavior. This is similar to what is used for
+    --strict-equality.
+    """
+    typ = get_proper_type(typ)
+    if isinstance(typ, Instance):
+        return typ.type.has_base(fullname)
+    elif isinstance(typ, TypeVarType):
+        return has_type_component(typ.upper_bound, fullname) or any(
+            has_type_component(v, fullname) for v in typ.values
+        )
+    elif isinstance(typ, UnionType):
+        return any(has_type_component(t, fullname) for t in typ.relevant_items())
+    return False

micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/mypy-1.20.2-py314h5a2d7ad_0/Lib/site-packages/mypy/config_parser.py

@@ -0,0 +1,734 @@
+from __future__ import annotations
+
+import argparse
+import configparser
+import glob as fileglob
+import os
+import re
+import sys
+from io import StringIO
+
+if sys.version_info >= (3, 11):
+    import tomllib
+else:
+    import tomli as tomllib
+
+from collections.abc import Callable, Mapping, MutableMapping, Sequence
+from typing import Any, Final, TextIO, TypeAlias
+from typing_extensions import Never
+
+from mypy import defaults
+from mypy.options import PER_MODULE_OPTIONS, Options
+
+_CONFIG_VALUE_TYPES: TypeAlias = (
+    str | bool | int | float | dict[str, str] | list[str] | tuple[int, int]
+)
+_INI_PARSER_CALLABLE: TypeAlias = Callable[[Any], _CONFIG_VALUE_TYPES]
+
+
+class VersionTypeError(argparse.ArgumentTypeError):
+    """Provide a fallback value if the Python version is unsupported."""
+
+    def __init__(self, *args: Any, fallback: tuple[int, int]) -> None:
+        self.fallback = fallback
+        super().__init__(*args)
+
+
+def parse_version(v: str | float) -> tuple[int, int]:
+    m = re.match(r"\A(\d)\.(\d+)\Z", str(v))
+    if not m:
+        raise argparse.ArgumentTypeError(f"Invalid python version '{v}' (expected format: 'x.y')")
+    major, minor = int(m.group(1)), int(m.group(2))
+    if major == 2 and minor == 7:
+        pass  # Error raised elsewhere
+    elif major == 3:
+        if minor < defaults.PYTHON3_VERSION_MIN[1]:
+            msg = "Python 3.{} is not supported (must be {}.{} or higher)".format(
+                minor, *defaults.PYTHON3_VERSION_MIN
+            )
+
+            if isinstance(v, float):
+                msg += ". You may need to put quotes around your Python version"
+
+            raise VersionTypeError(msg, fallback=defaults.PYTHON3_VERSION_MIN)
+    else:
+        raise argparse.ArgumentTypeError(
+            f"Python major version '{major}' out of range (must be 3)"
+        )
+    return major, minor
+
+
+def try_split(v: str | Sequence[str] | object, split_regex: str = ",") -> list[str]:
+    """Split and trim a str or sequence (eg: list) of str into a list of str.
+    If an element of the input is not str, a type error will be raised."""
+
+    def complain(x: object, additional_info: str = "") -> Never:
+        raise argparse.ArgumentTypeError(
+            f"Expected a list or a stringified version thereof, but got: '{x}', of type {type(x).__name__}.{additional_info}"
+        )
+
+    if isinstance(v, str):
+        items = [p.strip() for p in re.split(split_regex, v)]
+        if items and items[-1] == "":
+            items.pop(-1)
+        return items
+    elif isinstance(v, Sequence):
+        return [
+            (
+                p.strip()
+                if isinstance(p, str)
+                else complain(p, additional_info=" (As an element of the list.)")
+            )
+            for p in v
+        ]
+    else:
+        complain(v)
+
+
+def validate_package_allow_list(allow_list: list[str]) -> list[str]:
+    for p in allow_list:
+        msg = f"Invalid allow list entry: {p}"
+        if "*" in p:
+            raise argparse.ArgumentTypeError(
+                f"{msg} (entries are already prefixes so must not contain *)"
+            )
+        if "\\" in p or "/" in p:
+            raise argparse.ArgumentTypeError(
+                f"{msg} (entries must be packages like foo.bar not directories or files)"
+            )
+    return allow_list
+
+
+def expand_path(path: str) -> str:
+    """Expand the user home directory and any environment variables contained within
+    the provided path.
+    """
+
+    return os.path.expandvars(os.path.expanduser(path))
+
+
+def str_or_array_as_list(v: str | Sequence[str]) -> list[str]:
+    if isinstance(v, str):
+        return [v.strip()] if v.strip() else []
+    return [p.strip() for p in v if p.strip()]
+
+
+def split_and_match_files_list(paths: Sequence[str]) -> list[str]:
+    """Take a list of files/directories (with support for globbing through the glob library).
+
+    Where a path/glob matches no file, we still include the raw path in the resulting list.
+
+    Returns a list of file paths
+    """
+    expanded_paths = []
+
+    for path in paths:
+        path = expand_path(path.strip())
+        globbed_files = fileglob.glob(path, recursive=True)
+        if globbed_files:
+            expanded_paths.extend(globbed_files)
+        else:
+            expanded_paths.append(path)
+
+    return expanded_paths
+
+
+def split_and_match_files(paths: str) -> list[str]:
+    """Take a string representing a list of files/directories (with support for globbing
+    through the glob library).
+
+    Where a path/glob matches no file, we still include the raw path in the resulting list.
+
+    Returns a list of file paths
+    """
+
+    return split_and_match_files_list(split_commas(paths))
+
+
+def check_follow_imports(choice: str) -> str:
+    choices = ["normal", "silent", "skip", "error"]
+    if choice not in choices:
+        raise argparse.ArgumentTypeError(
+            "invalid choice '{}' (choose from {})".format(
+                choice, ", ".join(f"'{x}'" for x in choices)
+            )
+        )
+    return choice
+
+
+def check_junit_format(choice: str) -> str:
+    choices = ["global", "per_file"]
+    if choice not in choices:
+        raise argparse.ArgumentTypeError(
+            "invalid choice '{}' (choose from {})".format(
+                choice, ", ".join(f"'{x}'" for x in choices)
+            )
+        )
+    return choice
+
+
+def split_commas(value: str) -> list[str]:
+    # Uses a bit smarter technique to allow last trailing comma
+    # and to remove last `""` item from the split.
+    items = value.split(",")
+    if items and items[-1] == "":
+        items.pop(-1)
+    return items
+
+
+# For most options, the type of the default value set in options.py is
+# sufficient, and we don't have to do anything here.  This table
+# exists to specify types for values initialized to None or container
+# types.
+ini_config_types: Final[dict[str, _INI_PARSER_CALLABLE]] = {
+    "python_version": parse_version,
+    "custom_typing_module": str,
+    "custom_typeshed_dir": expand_path,
+    "mypy_path": lambda s: [expand_path(p.strip()) for p in re.split("[,:]", s)],
+    "files": split_and_match_files,
+    "quickstart_file": expand_path,
+    "junit_xml": expand_path,
+    "junit_format": check_junit_format,
+    "follow_imports": check_follow_imports,
+    "no_site_packages": bool,
+    "plugins": lambda s: [p.strip() for p in split_commas(s)],
+    "always_true": lambda s: [p.strip() for p in split_commas(s)],
+    "always_false": lambda s: [p.strip() for p in split_commas(s)],
+    "untyped_calls_exclude": lambda s: validate_package_allow_list(
+        [p.strip() for p in split_commas(s)]
+    ),
+    "enable_incomplete_feature": lambda s: [p.strip() for p in split_commas(s)],
+    "disable_error_code": lambda s: [p.strip() for p in split_commas(s)],
+    "enable_error_code": lambda s: [p.strip() for p in split_commas(s)],
+    "package_root": lambda s: [p.strip() for p in split_commas(s)],
+    "cache_dir": expand_path,
+    "python_executable": expand_path,
+    "strict": bool,
+    "exclude": lambda s: [s.strip()],
+    "packages": try_split,
+    "modules": try_split,
+}
+
+# Reuse the ini_config_types and overwrite the diff
+toml_config_types: Final[dict[str, _INI_PARSER_CALLABLE]] = ini_config_types.copy()
+toml_config_types.update(
+    {
+        "python_version": parse_version,
+        "mypy_path": lambda s: [expand_path(p) for p in try_split(s, "[,:]")],
+        "files": lambda s: split_and_match_files_list(try_split(s)),
+        "junit_format": lambda s: check_junit_format(str(s)),
+        "follow_imports": lambda s: check_follow_imports(str(s)),
+        "plugins": try_split,
+        "always_true": try_split,
+        "always_false": try_split,
+        "untyped_calls_exclude": lambda s: validate_package_allow_list(try_split(s)),
+        "enable_incomplete_feature": try_split,
+        "disable_error_code": lambda s: try_split(s),
+        "enable_error_code": lambda s: try_split(s),
+        "package_root": try_split,
+        "exclude": str_or_array_as_list,
+        "packages": try_split,
+        "modules": try_split,
+    }
+)
+
+
+def _parse_individual_file(
+    config_file: str, stderr: TextIO | None = None
+) -> tuple[MutableMapping[str, Any], dict[str, _INI_PARSER_CALLABLE], str] | None:
+
+    if not os.path.exists(config_file):
+        return None
+
+    parser: MutableMapping[str, Any]
+    try:
+        if is_toml(config_file):
+            with open(config_file, "rb") as f:
+                toml_data = tomllib.load(f)
+            # Filter down to just mypy relevant toml keys
+            toml_data = toml_data.get("tool", {})
+            if "mypy" not in toml_data:
+                return None
+            toml_data = {"mypy": toml_data["mypy"]}
+            parser = destructure_overrides(toml_data)
+            config_types = toml_config_types
+        else:
+            parser = configparser.RawConfigParser()
+            parser.read(config_file)
+            config_types = ini_config_types
+
+    except (tomllib.TOMLDecodeError, configparser.Error, ConfigTOMLValueError) as err:
+        print(f"{config_file}: {err}", file=stderr)
+        return None
+
+    if os.path.basename(config_file) in defaults.SHARED_CONFIG_NAMES and "mypy" not in parser:
+        return None
+
+    return parser, config_types, config_file
+
+
+def _find_config_file(
+    stderr: TextIO | None = None,
+) -> tuple[MutableMapping[str, Any], dict[str, _INI_PARSER_CALLABLE], str] | None:
+
+    current_dir = os.path.abspath(os.getcwd())
+
+    while True:
+        for name in defaults.CONFIG_NAMES + defaults.SHARED_CONFIG_NAMES:
+            config_file = os.path.relpath(os.path.join(current_dir, name))
+            ret = _parse_individual_file(config_file, stderr)
+            if ret is None:
+                continue
+            return ret
+
+        if any(
+            os.path.exists(os.path.join(current_dir, cvs_root)) for cvs_root in (".git", ".hg")
+        ):
+            break
+        parent_dir = os.path.dirname(current_dir)
+        if parent_dir == current_dir:
+            break
+        current_dir = parent_dir
+
+    for config_file in defaults.USER_CONFIG_FILES:
+        ret = _parse_individual_file(config_file, stderr)
+        if ret is None:
+            continue
+        return ret
+
+    return None
+
+
+def parse_config_file(
+    options: Options,
+    set_strict_flags: Callable[[], None],
+    filename: str | None,
+    stdout: TextIO | None = None,
+    stderr: TextIO | None = None,
+) -> None:
+    """Parse a config file into an Options object.
+
+    Errors are written to stderr but are not fatal.
+
+    If filename is None, fall back to default config files.
+    """
+    stdout = stdout or sys.stdout
+    stderr = stderr or sys.stderr
+
+    ret = (
+        _parse_individual_file(filename, stderr)
+        if filename is not None
+        else _find_config_file(stderr)
+    )
+    if ret is None:
+        return
+    parser, config_types, file_read = ret
+
+    options.config_file = file_read
+    os.environ["MYPY_CONFIG_FILE_DIR"] = os.path.dirname(os.path.abspath(file_read))
+
+    if "mypy" not in parser:
+        if filename or os.path.basename(file_read) not in defaults.SHARED_CONFIG_NAMES:
+            print(f"{file_read}: No [mypy] section in config file", file=stderr)
+    else:
+        section = parser["mypy"]
+        prefix = f"{file_read}: [mypy]: "
+        updates, report_dirs = parse_section(
+            prefix, options, set_strict_flags, section, config_types, stderr
+        )
+        for k, v in updates.items():
+            setattr(options, k, v)
+        options.report_dirs.update(report_dirs)
+
+    for name, section in parser.items():
+        if name.startswith("mypy-"):
+            prefix = get_prefix(file_read, name)
+            updates, report_dirs = parse_section(
+                prefix, options, set_strict_flags, section, config_types, stderr
+            )
+            if report_dirs:
+                print(
+                    prefix,
+                    "Per-module sections should not specify reports ({})".format(
+                        ", ".join(s + "_report" for s in sorted(report_dirs))
+                    ),
+                    file=stderr,
+                )
+            if set(updates) - PER_MODULE_OPTIONS:
+                print(
+                    prefix,
+                    "Per-module sections should only specify per-module flags ({})".format(
+                        ", ".join(sorted(set(updates) - PER_MODULE_OPTIONS))
+                    ),
+                    file=stderr,
+                )
+                updates = {k: v for k, v in updates.items() if k in PER_MODULE_OPTIONS}
+
+            globs = name[5:]
+            for glob in globs.split(","):
+                # For backwards compatibility, replace (back)slashes with dots.
+                glob = glob.replace(os.sep, ".")
+                if os.altsep:
+                    glob = glob.replace(os.altsep, ".")
+
+                if any(c in glob for c in "?[]!") or any(
+                    "*" in x and x != "*" for x in glob.split(".")
+                ):
+                    print(
+                        prefix,
+                        "Patterns must be fully-qualified module names, optionally "
+                        "with '*' in some components (e.g spam.*.eggs.*)",
+                        file=stderr,
+                    )
+                else:
+                    options.per_module_options[glob] = updates
+
+
+def get_prefix(file_read: str, name: str) -> str:
+    if is_toml(file_read):
+        module_name_str = 'module = "%s"' % "-".join(name.split("-")[1:])
+    else:
+        module_name_str = name
+
+    return f"{file_read}: [{module_name_str}]:"
+
+
+def is_toml(filename: str) -> bool:
+    return filename.lower().endswith(".toml")
+
+
+def destructure_overrides(toml_data: dict[str, Any]) -> dict[str, Any]:
+    """Take the new [[tool.mypy.overrides]] section array in the pyproject.toml file,
+    and convert it back to a flatter structure that the existing config_parser can handle.
+
+    E.g. the following pyproject.toml file:
+
+        [[tool.mypy.overrides]]
+        module = [
+            "a.b",
+            "b.*"
+        ]
+        disallow_untyped_defs = true
+
+        [[tool.mypy.overrides]]
+        module = 'c'
+        disallow_untyped_defs = false
+
+    Would map to the following config dict that it would have gotten from parsing an equivalent
+    ini file:
+
+        {
+            "mypy-a.b": {
+                disallow_untyped_defs = true,
+            },
+            "mypy-b.*": {
+                disallow_untyped_defs = true,
+            },
+            "mypy-c": {
+                disallow_untyped_defs: false,
+            },
+        }
+    """
+    if "overrides" not in toml_data["mypy"]:
+        return toml_data
+
+    if not isinstance(toml_data["mypy"]["overrides"], list):
+        raise ConfigTOMLValueError(
+            "tool.mypy.overrides sections must be an array. Please make "
+            "sure you are using double brackets like so: [[tool.mypy.overrides]]"
+        )
+
+    result = toml_data.copy()
+    for override in result["mypy"]["overrides"]:
+        if "module" not in override:
+            raise ConfigTOMLValueError(
+                "toml config file contains a [[tool.mypy.overrides]] "
+                "section, but no module to override was specified."
+            )
+
+        if isinstance(override["module"], str):
+            modules = [override["module"]]
+        elif isinstance(override["module"], list):
+            modules = override["module"]
+        else:
+            raise ConfigTOMLValueError(
+                "toml config file contains a [[tool.mypy.overrides]] "
+                "section with a module value that is not a string or a list of "
+                "strings"
+            )
+
+        for module in modules:
+            module_overrides = override.copy()
+            del module_overrides["module"]
+            old_config_name = f"mypy-{module}"
+            if old_config_name not in result:
+                result[old_config_name] = module_overrides
+            else:
+                for new_key, new_value in module_overrides.items():
+                    if (
+                        new_key in result[old_config_name]
+                        and result[old_config_name][new_key] != new_value
+                    ):
+                        raise ConfigTOMLValueError(
+                            "toml config file contains "
+                            "[[tool.mypy.overrides]] sections with conflicting "
+                            f"values. Module '{module}' has two different values for '{new_key}'"
+                        )
+                    result[old_config_name][new_key] = new_value
+
+    del result["mypy"]["overrides"]
+    return result
+
+
+def parse_section(
+    prefix: str,
+    template: Options,
+    set_strict_flags: Callable[[], None],
+    section: Mapping[str, Any],
+    config_types: dict[str, Any],
+    stderr: TextIO = sys.stderr,
+) -> tuple[dict[str, object], dict[str, str]]:
+    """Parse one section of a config file.
+
+    Returns a dict of option values encountered, and a dict of report directories.
+    """
+    results: dict[str, object] = {}
+    report_dirs: dict[str, str] = {}
+
+    # Because these fields exist on Options, without proactive checking, we would accept them
+    # and crash later
+    invalid_options = {
+        "enabled_error_codes": "enable_error_code",
+        "disabled_error_codes": "disable_error_code",
+    }
+
+    for key in section:
+        invert = False
+        # Here we use `key` for original config section key, and `options_key` for
+        # the corresponding Options attribute.
+        options_key = key
+        # Match aliasing for command line flag.
+        if key.endswith("allow_redefinition"):
+            options_key += "_old"
+        if key in config_types:
+            ct = config_types[key]
+        elif key in invalid_options:
+            print(
+                f"{prefix}Unrecognized option: {key} = {section[key]}"
+                f" (did you mean {invalid_options[key]}?)",
+                file=stderr,
+            )
+            continue
+        else:
+            dv = getattr(template, options_key, None)
+            if dv is None:
+                if key.endswith("_report"):
+                    report_type = key[:-7].replace("_", "-")
+                    if report_type in defaults.REPORTER_NAMES:
+                        report_dirs[report_type] = str(section[key])
+                    else:
+                        print(f"{prefix}Unrecognized report type: {key}", file=stderr)
+                    continue
+                if key.startswith("x_"):
+                    pass  # Don't complain about `x_blah` flags
+                elif key.startswith("no_") and hasattr(template, options_key[3:]):
+                    options_key = options_key[3:]
+                    invert = True
+                elif key.startswith("allow") and hasattr(template, "dis" + options_key):
+                    options_key = "dis" + options_key
+                    invert = True
+                elif key.startswith("disallow") and hasattr(template, options_key[3:]):
+                    options_key = options_key[3:]
+                    invert = True
+                elif key.startswith("show_") and hasattr(template, "hide_" + options_key[5:]):
+                    options_key = "hide_" + options_key[5:]
+                    invert = True
+                elif key == "strict":
+                    pass  # Special handling below
+                else:
+                    print(f"{prefix}Unrecognized option: {key} = {section[key]}", file=stderr)
+                if invert:
+                    dv = getattr(template, options_key, None)
+                else:
+                    continue
+            ct = type(dv) if dv is not None else None
+        v: Any = None
+        try:
+            if ct is bool:
+                if isinstance(section, dict):
+                    v = convert_to_boolean(section.get(key))
+                else:
+                    v = section.getboolean(key)  # type: ignore[attr-defined]  # Until better stub
+                if invert:
+                    v = not v
+            elif callable(ct):
+                if invert:
+                    print(f"{prefix}Can not invert non-boolean key {options_key}", file=stderr)
+                    continue
+                try:
+                    v = ct(section.get(key))
+                except VersionTypeError as err_version:
+                    print(f"{prefix}{key}: {err_version}", file=stderr)
+                    v = err_version.fallback
+                except argparse.ArgumentTypeError as err:
+                    print(f"{prefix}{key}: {err}", file=stderr)
+                    continue
+            else:
+                print(f"{prefix}Don't know what type {key} should have", file=stderr)
+                continue
+        except ValueError as err:
+            print(f"{prefix}{key}: {err}", file=stderr)
+            continue
+        if key == "strict":
+            if v:
+                set_strict_flags()
+            continue
+        results[options_key] = v
+
+    # These two flags act as per-module overrides, so store the empty defaults.
+    if "disable_error_code" not in results:
+        results["disable_error_code"] = []
+    if "enable_error_code" not in results:
+        results["enable_error_code"] = []
+
+    return results, report_dirs
+
+
+def convert_to_boolean(value: Any | None) -> bool:
+    """Return a boolean value translating from other types if necessary."""
+    if isinstance(value, bool):
+        return value
+    if not isinstance(value, str):
+        value = str(value)
+    if value.lower() not in configparser.RawConfigParser.BOOLEAN_STATES:
+        raise ValueError(f"Not a boolean: {value}")
+    return configparser.RawConfigParser.BOOLEAN_STATES[value.lower()]
+
+
+def split_directive(s: str) -> tuple[list[str], list[str]]:
+    """Split s on commas, except during quoted sections.
+
+    Returns the parts and a list of error messages."""
+    parts = []
+    cur: list[str] = []
+    errors = []
+    i = 0
+    while i < len(s):
+        if s[i] == ",":
+            parts.append("".join(cur).strip())
+            cur = []
+        elif s[i] == '"':
+            i += 1
+            while i < len(s) and s[i] != '"':
+                cur.append(s[i])
+                i += 1
+            if i == len(s):
+                errors.append("Unterminated quote in configuration comment")
+                cur.clear()
+        else:
+            cur.append(s[i])
+        i += 1
+    if cur:
+        parts.append("".join(cur).strip())
+
+    return parts, errors
+
+
+def mypy_comments_to_config_map(line: str, template: Options) -> tuple[dict[str, str], list[str]]:
+    """Rewrite the mypy comment syntax into ini file syntax."""
+    options = {}
+    entries, errors = split_directive(line)
+    for entry in entries:
+        if "=" not in entry:
+            name = entry
+            value = None
+        else:
+            name, value = (x.strip() for x in entry.split("=", 1))
+
+        name = name.replace("-", "_")
+        if value is None:
+            value = "True"
+        options[name] = value
+
+    return options, errors
+
+
+def parse_mypy_comments(
+    args: list[tuple[int, str]], template: Options
+) -> tuple[dict[str, object], list[tuple[int, str]]]:
+    """Parse a collection of inline mypy: configuration comments.
+
+    Returns a dictionary of options to be applied and a list of error messages
+    generated.
+    """
+    errors: list[tuple[int, str]] = []
+    sections: dict[str, object] = {"enable_error_code": [], "disable_error_code": []}
+
+    for lineno, line in args:
+        # In order to easily match the behavior for bools, we abuse configparser.
+        # Oddly, the only way to get the SectionProxy object with the getboolean
+        # method is to create a config parser.
+        parser = configparser.RawConfigParser()
+        options, parse_errors = mypy_comments_to_config_map(line, template)
+        if "python_version" in options:
+            errors.append((lineno, "python_version not supported in inline configuration"))
+            del options["python_version"]
+
+        parser["dummy"] = options
+        errors.extend((lineno, x) for x in parse_errors)
+
+        stderr = StringIO()
+        strict_found = False
+
+        def set_strict_flags() -> None:
+            nonlocal strict_found
+            strict_found = True
+
+        new_sections, reports = parse_section(
+            "", template, set_strict_flags, parser["dummy"], ini_config_types, stderr=stderr
+        )
+        errors.extend((lineno, x) for x in stderr.getvalue().strip().split("\n") if x)
+        if reports:
+            errors.append((lineno, "Reports not supported in inline configuration"))
+        if strict_found:
+            errors.append(
+                (
+                    lineno,
+                    'Setting "strict" not supported in inline configuration: specify it in '
+                    "a configuration file instead, or set individual inline flags "
+                    '(see "mypy -h" for the list of flags enabled in strict mode)',
+                )
+            )
+        # Because this is currently special-cased
+        # (the new_sections for an inline config *always* includes 'disable_error_code' and
+        # 'enable_error_code' fields, usually empty, which overwrite the old ones),
+        # we have to manipulate them specially.
+        # This could use a refactor, but so could the whole subsystem.
+        if (
+            "enable_error_code" in new_sections
+            and isinstance(neec := new_sections["enable_error_code"], list)
+            and isinstance(eec := sections.get("enable_error_code", []), list)
+        ):
+            new_sections["enable_error_code"] = sorted(set(neec + eec))
+        if (
+            "disable_error_code" in new_sections
+            and isinstance(ndec := new_sections["disable_error_code"], list)
+            and isinstance(dec := sections.get("disable_error_code", []), list)
+        ):
+            new_sections["disable_error_code"] = sorted(set(ndec + dec))
+        sections.update(new_sections)
+    return sections, errors
+
+
+def get_config_module_names(filename: str | None, modules: list[str]) -> str:
+    if not filename or not modules:
+        return ""
+
+    if not is_toml(filename):
+        return ", ".join(f"[mypy-{module}]" for module in modules)
+
+    return "module = ['%s']" % ("', '".join(sorted(modules)))
+
+
+class ConfigTOMLValueError(ValueError):
+    pass

micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/mypy-1.20.2-py314h5a2d7ad_0/Lib/site-packages/mypy/constant_fold.py

@@ -0,0 +1,187 @@
+"""Constant folding of expressions.
+
+For example, 3 + 5 can be constant folded into 8.
+"""
+
+from __future__ import annotations
+
+from typing import Final
+
+from mypy.nodes import (
+    ComplexExpr,
+    Expression,
+    FloatExpr,
+    IntExpr,
+    NameExpr,
+    OpExpr,
+    StrExpr,
+    UnaryExpr,
+    Var,
+)
+
+# All possible result types of constant folding
+ConstantValue = int | bool | float | complex | str
+CONST_TYPES: Final = (int, bool, float, complex, str)
+
+
+def constant_fold_expr(expr: Expression, cur_mod_id: str) -> ConstantValue | None:
+    """Return the constant value of an expression for supported operations.
+
+    Among other things, support int arithmetic and string
+    concatenation. For example, the expression 3 + 5 has the constant
+    value 8.
+
+    Also bind simple references to final constants defined in the
+    current module (cur_mod_id). Binding to references is best effort
+    -- we don't bind references to other modules. Mypyc trusts these
+    to be correct in compiled modules, so that it can replace a
+    constant expression (or a reference to one) with the statically
+    computed value. We don't want to infer constant values based on
+    stubs, in particular, as these might not match the implementation
+    (due to version skew, for example).
+
+    Return None if unsuccessful.
+    """
+    if isinstance(expr, IntExpr):
+        return expr.value
+    if isinstance(expr, StrExpr):
+        return expr.value
+    if isinstance(expr, FloatExpr):
+        return expr.value
+    if isinstance(expr, ComplexExpr):
+        return expr.value
+    elif isinstance(expr, NameExpr):
+        if expr.name == "True":
+            return True
+        elif expr.name == "False":
+            return False
+        node = expr.node
+        if (
+            isinstance(node, Var)
+            and node.is_final
+            and node.fullname.rsplit(".", 1)[0] == cur_mod_id
+        ):
+            value = node.final_value
+            if isinstance(value, (CONST_TYPES)):
+                return value
+    elif isinstance(expr, OpExpr):
+        left = constant_fold_expr(expr.left, cur_mod_id)
+        right = constant_fold_expr(expr.right, cur_mod_id)
+        if left is not None and right is not None:
+            return constant_fold_binary_op(expr.op, left, right)
+    elif isinstance(expr, UnaryExpr):
+        value = constant_fold_expr(expr.expr, cur_mod_id)
+        if value is not None:
+            return constant_fold_unary_op(expr.op, value)
+    return None
+
+
+def constant_fold_binary_op(
+    op: str, left: ConstantValue, right: ConstantValue
+) -> ConstantValue | None:
+    if isinstance(left, int) and isinstance(right, int):
+        return constant_fold_binary_int_op(op, left, right)
+
+    # Float and mixed int/float arithmetic.
+    if isinstance(left, float) and isinstance(right, float):
+        return constant_fold_binary_float_op(op, left, right)
+    elif isinstance(left, float) and isinstance(right, int):
+        return constant_fold_binary_float_op(op, left, right)
+    elif isinstance(left, int) and isinstance(right, float):
+        return constant_fold_binary_float_op(op, left, right)
+
+    # String concatenation and multiplication.
+    if op == "+" and isinstance(left, str) and isinstance(right, str):
+        return left + right
+    elif op == "*" and isinstance(left, str) and isinstance(right, int):
+        return left * right
+    elif op == "*" and isinstance(left, int) and isinstance(right, str):
+        return left * right
+
+    # Complex construction.
+    if op == "+" and isinstance(left, (int, float)) and isinstance(right, complex):
+        return left + right
+    elif op == "+" and isinstance(left, complex) and isinstance(right, (int, float)):
+        return left + right
+    elif op == "-" and isinstance(left, (int, float)) and isinstance(right, complex):
+        return left - right
+    elif op == "-" and isinstance(left, complex) and isinstance(right, (int, float)):
+        return left - right
+
+    return None
+
+
+def constant_fold_binary_int_op(op: str, left: int, right: int) -> int | float | None:
+    if op == "+":
+        return left + right
+    if op == "-":
+        return left - right
+    elif op == "*":
+        return left * right
+    elif op == "/":
+        if right != 0:
+            return left / right
+    elif op == "//":
+        if right != 0:
+            return left // right
+    elif op == "%":
+        if right != 0:
+            return left % right
+    elif op == "&":
+        return left & right
+    elif op == "|":
+        return left | right
+    elif op == "^":
+        return left ^ right
+    elif op == "<<":
+        if right >= 0:
+            return left << right
+    elif op == ">>":
+        if right >= 0:
+            return left >> right
+    elif op == "**":
+        if right >= 0:
+            ret = left**right
+            assert isinstance(ret, int)
+            return ret
+    return None
+
+
+def constant_fold_binary_float_op(op: str, left: int | float, right: int | float) -> float | None:
+    assert not (isinstance(left, int) and isinstance(right, int)), (op, left, right)
+    if op == "+":
+        return left + right
+    elif op == "-":
+        return left - right
+    elif op == "*":
+        return left * right
+    elif op == "/":
+        if right != 0:
+            return left / right
+    elif op == "//":
+        if right != 0:
+            return left // right
+    elif op == "%":
+        if right != 0:
+            return left % right
+    elif op == "**":
+        if (left < 0 and isinstance(right, int)) or left > 0:
+            try:
+                ret = left**right
+            except OverflowError:
+                return None
+            else:
+                assert isinstance(ret, float), ret
+                return ret
+
+    return None
+
+
+def constant_fold_unary_op(op: str, value: ConstantValue) -> int | float | None:
+    if op == "-" and isinstance(value, (int, float)):
+        return -value
+    elif op == "~" and isinstance(value, int):
+        return ~value
+    elif op == "+" and isinstance(value, (int, float)):
+        return value
+    return None

micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/mypy-1.20.2-py314h5a2d7ad_0/Lib/site-packages/mypy/constraints.py

@@ -0,0 +1,1687 @@
+"""Type inference constraints."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable, Sequence
+from typing import TYPE_CHECKING, Final, TypeGuard, cast
+
+import mypy.subtypes
+import mypy.typeops
+from mypy.argmap import ArgTypeExpander
+from mypy.erasetype import erase_typevars
+from mypy.maptype import map_instance_to_supertype
+from mypy.nodes import (
+    ARG_OPT,
+    ARG_POS,
+    ARG_STAR,
+    ARG_STAR2,
+    CONTRAVARIANT,
+    COVARIANT,
+    ArgKind,
+    TypeInfo,
+)
+from mypy.types import (
+    TUPLE_LIKE_INSTANCE_NAMES,
+    AnyType,
+    CallableType,
+    DeletedType,
+    ErasedType,
+    Instance,
+    LiteralType,
+    NoneType,
+    NormalizedCallableType,
+    Overloaded,
+    Parameters,
+    ParamSpecType,
+    PartialType,
+    ProperType,
+    TupleType,
+    Type,
+    TypeAliasType,
+    TypedDictType,
+    TypeOfAny,
+    TypeType,
+    TypeVarId,
+    TypeVarLikeType,
+    TypeVarTupleType,
+    TypeVarType,
+    TypeVisitor,
+    UnboundType,
+    UninhabitedType,
+    UnionType,
+    UnpackType,
+    find_unpack_in_list,
+    flatten_nested_tuples,
+    get_proper_type,
+    has_recursive_types,
+    has_type_vars,
+    is_named_instance,
+    split_with_prefix_and_suffix,
+)
+from mypy.types_utils import is_union_with_any
+from mypy.typestate import type_state
+
+if TYPE_CHECKING:
+    from mypy.infer import ArgumentInferContext
+
+SUBTYPE_OF: Final = 0
+SUPERTYPE_OF: Final = 1
+
+
+class Constraint:
+    """A representation of a type constraint.
+
+    It can be either T <: type or T :> type (T is a type variable).
+    """
+
+    type_var: TypeVarId
+    op = 0  # SUBTYPE_OF or SUPERTYPE_OF
+    target: Type
+
+    def __init__(self, type_var: TypeVarLikeType, op: int, target: Type) -> None:
+        self.type_var = type_var.id
+        self.op = op
+        # TODO: should we add "assert not isinstance(target, UnpackType)"?
+        # UnpackType is a synthetic type, and is never valid as a constraint target.
+        self.target = target
+        self.origin_type_var = type_var
+        # These are additional type variables that should be solved for together with type_var.
+        # TODO: A cleaner solution may be to modify the return type of infer_constraints()
+        # to include these instead, but this is a rather big refactoring.
+        self.extra_tvars: list[TypeVarLikeType] = []
+
+    def __repr__(self) -> str:
+        op_str = "<:"
+        if self.op == SUPERTYPE_OF:
+            op_str = ":>"
+        return f"{self.type_var} {op_str} {self.target}"
+
+    def __hash__(self) -> int:
+        return hash((self.type_var, self.op, self.target))
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, Constraint):
+            return False
+        return (self.type_var, self.op, self.target) == (other.type_var, other.op, other.target)
+
+
+def infer_constraints_for_callable(
+    callee: CallableType,
+    arg_types: Sequence[Type | None],
+    arg_kinds: list[ArgKind],
+    arg_names: Sequence[str | None] | None,
+    formal_to_actual: list[list[int]],
+    context: ArgumentInferContext,
+) -> list[Constraint]:
+    """Infer type variable constraints for a callable and actual arguments.
+
+    Return a list of constraints.
+    """
+    constraints: list[Constraint] = []
+    mapper = ArgTypeExpander(context)
+
+    param_spec = callee.param_spec()
+    param_spec_arg_types = []
+    param_spec_arg_names = []
+    param_spec_arg_kinds: list[ArgKind] = []
+
+    incomplete_star_mapping = False
+    for i, actuals in enumerate(formal_to_actual):  # TODO: isn't this `enumerate(arg_types)`?
+        for actual in actuals:
+            if actual is None and callee.arg_kinds[i] in (ARG_STAR, ARG_STAR2):  # type: ignore[unreachable]
+                # We can't use arguments to infer ParamSpec constraint, if only some
+                # are present in the current inference pass.
+                incomplete_star_mapping = True  # type: ignore[unreachable]
+                break
+
+    for i, actuals in enumerate(formal_to_actual):
+        if isinstance(callee.arg_types[i], UnpackType):
+            unpack_type = callee.arg_types[i]
+            assert isinstance(unpack_type, UnpackType)
+
+            # In this case we are binding all the actuals to *args,
+            # and we want a constraint that the typevar tuple being unpacked
+            # is equal to a type list of all the actuals.
+            actual_types = []
+
+            unpacked_type = get_proper_type(unpack_type.type)
+            if isinstance(unpacked_type, TypeVarTupleType):
+                tuple_instance = unpacked_type.tuple_fallback
+            elif isinstance(unpacked_type, TupleType):
+                tuple_instance = unpacked_type.partial_fallback
+            else:
+                assert False, "mypy bug: unhandled constraint inference case"
+
+            for actual in actuals:
+                actual_arg_type = arg_types[actual]
+                if actual_arg_type is None:
+                    continue
+
+                expanded_actual = mapper.expand_actual_type(
+                    actual_arg_type,
+                    arg_kinds[actual],
+                    callee.arg_names[i],
+                    callee.arg_kinds[i],
+                    allow_unpack=True,
+                )
+
+                if arg_kinds[actual] != ARG_STAR or isinstance(
+                    get_proper_type(actual_arg_type), TupleType
+                ):
+                    actual_types.append(expanded_actual)
+                else:
+                    # If we are expanding an iterable inside * actual, append a homogeneous item instead
+                    actual_types.append(
+                        UnpackType(tuple_instance.copy_modified(args=[expanded_actual]))
+                    )
+
+            if isinstance(unpacked_type, TypeVarTupleType):
+                constraints.append(
+                    Constraint(
+                        unpacked_type,
+                        SUPERTYPE_OF,
+                        TupleType(actual_types, unpacked_type.tuple_fallback),
+                    )
+                )
+            elif isinstance(unpacked_type, TupleType):
+                # Prefixes get converted to positional args, so technically the only case we
+                # should have here is like Tuple[Unpack[Ts], Y1, Y2, Y3]. If this turns out
+                # not to hold we can always handle the prefixes too.
+                inner_unpack = unpacked_type.items[0]
+                assert isinstance(inner_unpack, UnpackType)
+                inner_unpacked_type = get_proper_type(inner_unpack.type)
+                suffix_len = len(unpacked_type.items) - 1
+                if isinstance(inner_unpacked_type, TypeVarTupleType):
+                    # Variadic item can be either *Ts...
+                    constraints.append(
+                        Constraint(
+                            inner_unpacked_type,
+                            SUPERTYPE_OF,
+                            TupleType(
+                                actual_types[:-suffix_len], inner_unpacked_type.tuple_fallback
+                            ),
+                        )
+                    )
+                else:
+                    # ...or it can be a homogeneous tuple.
+                    assert (
+                        isinstance(inner_unpacked_type, Instance)
+                        and inner_unpacked_type.type.fullname == "builtins.tuple"
+                    )
+                    for at in actual_types[:-suffix_len]:
+                        constraints.extend(
+                            infer_constraints(inner_unpacked_type.args[0], at, SUPERTYPE_OF)
+                        )
+                # Now handle the suffix (if any).
+                if suffix_len:
+                    for tt, at in zip(unpacked_type.items[1:], actual_types[-suffix_len:]):
+                        constraints.extend(infer_constraints(tt, at, SUPERTYPE_OF))
+            else:
+                assert False, "mypy bug: unhandled constraint inference case"
+        else:
+            for actual in actuals:
+                actual_arg_type = arg_types[actual]
+                if actual_arg_type is None:
+                    continue
+
+                if param_spec and callee.arg_kinds[i] in (ARG_STAR, ARG_STAR2):
+                    # If actual arguments are mapped to ParamSpec type, we can't infer individual
+                    # constraints, instead store them and infer single constraint at the end.
+                    # It is impossible to map actual kind to formal kind, so use some heuristic.
+                    # This inference is used as a fallback, so relying on heuristic should be OK.
+                    if not incomplete_star_mapping:
+                        param_spec_arg_types.append(
+                            mapper.expand_actual_type(
+                                actual_arg_type, arg_kinds[actual], None, arg_kinds[actual]
+                            )
+                        )
+                        actual_kind = arg_kinds[actual]
+                        param_spec_arg_kinds.append(
+                            ARG_POS if actual_kind not in (ARG_STAR, ARG_STAR2) else actual_kind
+                        )
+                        param_spec_arg_names.append(arg_names[actual] if arg_names else None)
+                else:
+                    actual_type = mapper.expand_actual_type(
+                        actual_arg_type,
+                        arg_kinds[actual],
+                        callee.arg_names[i],
+                        callee.arg_kinds[i],
+                    )
+                    c = infer_constraints(callee.arg_types[i], actual_type, SUPERTYPE_OF)
+                    constraints.extend(c)
+    if (
+        param_spec
+        and not any(c.type_var == param_spec.id for c in constraints)
+        and not incomplete_star_mapping
+    ):
+        # Use ParamSpec constraint from arguments only if there are no other constraints,
+        # since as explained above it is quite ad-hoc.
+        constraints.append(
+            Constraint(
+                param_spec,
+                SUPERTYPE_OF,
+                Parameters(
+                    arg_types=param_spec_arg_types,
+                    arg_kinds=param_spec_arg_kinds,
+                    arg_names=param_spec_arg_names,
+                    imprecise_arg_kinds=True,
+                ),
+            )
+        )
+    if any(isinstance(v, ParamSpecType) for v in callee.variables):
+        # As a perf optimization filter imprecise constraints only when we can have them.
+        constraints = filter_imprecise_kinds(constraints)
+    return constraints
+
+
+def infer_constraints(
+    template: Type, actual: Type, direction: int, skip_neg_op: bool = False
+) -> list[Constraint]:
+    """Infer type constraints.
+
+    Match a template type, which may contain type variable references,
+    recursively against a type which does not contain (the same) type
+    variable references. The result is a list of type constrains of
+    form 'T is a supertype/subtype of x', where T is a type variable
+    present in the template and x is a type without reference to type
+    variables present in the template.
+
+    Assume T and S are type variables. Now the following results can be
+    calculated (read as '(template, actual) --> result'):
+
+      (T, X)            -->  T :> X
+      (X[T], X[Y])      -->  T <: Y and T :> Y
+      ((T, T), (X, Y))  -->  T :> X and T :> Y
+      ((T, S), (X, Y))  -->  T :> X and S :> Y
+      (X[T], Any)       -->  T <: Any and T :> Any
+
+    The constraints are represented as Constraint objects. If skip_neg_op == True,
+    then skip adding reverse (polymorphic) constraints (since this is already a call
+    to infer such constraints).
+    """
+    if any(
+        get_proper_type(template) == get_proper_type(t)
+        and get_proper_type(actual) == get_proper_type(a)
+        for (t, a) in reversed(type_state.inferring)
+    ):
+        return []
+    if has_recursive_types(template) or isinstance(get_proper_type(template), Instance):
+        # This case requires special care because it may cause infinite recursion.
+        # Note that we include Instances because the may be recursive as str(Sequence[str]).
+        if not has_type_vars(template):
+            # Return early on an empty branch.
+            return []
+        type_state.inferring.append((template, actual))
+        res = _infer_constraints(template, actual, direction, skip_neg_op)
+        type_state.inferring.pop()
+        return res
+    return _infer_constraints(template, actual, direction, skip_neg_op)
+
+
+def _infer_constraints(
+    template: Type, actual: Type, direction: int, skip_neg_op: bool
+) -> list[Constraint]:
+    orig_template = template
+    template = get_proper_type(template)
+    actual = get_proper_type(actual)
+
+    # Type inference shouldn't be affected by whether union types have been simplified.
+    # We however keep any ErasedType items, so that the caller will see it when using
+    # checkexpr.has_erased_component().
+    if isinstance(template, UnionType):
+        template = mypy.typeops.make_simplified_union(template.items, keep_erased=True)
+    if isinstance(actual, UnionType):
+        actual = mypy.typeops.make_simplified_union(actual.items, keep_erased=True)
+
+    # Ignore Any types from the type suggestion engine to avoid them
+    # causing us to infer Any in situations where a better job could
+    # be done otherwise. (This can produce false positives but that
+    # doesn't really matter because it is all heuristic anyway.)
+    if isinstance(actual, AnyType) and actual.type_of_any == TypeOfAny.suggestion_engine:
+        return []
+
+    # type[A | B] is always represented as type[A] | type[B] internally.
+    # This makes our constraint solver choke on type[T] <: type[A] | type[B],
+    # solving T as generic meet(A, B) which is often `object`. Force unwrap such unions
+    # if both sides are type[...] or unions thereof. See `testTypeVarType` test
+    type_type_unwrapped = False
+    if _is_type_type(template) and _is_type_type(actual):
+        type_type_unwrapped = True
+        template = _unwrap_type_type(template)
+        actual = _unwrap_type_type(actual)
+
+    # If the template is simply a type variable, emit a Constraint directly.
+    # We need to handle this case before handling Unions for two reasons:
+    #  1. "T <: Union[U1, U2]" is not equivalent to "T <: U1 or T <: U2",
+    #     because T can itself be a union (notably, Union[U1, U2] itself).
+    #  2. "T :> Union[U1, U2]" is logically equivalent to "T :> U1 and
+    #     T :> U2", but they are not equivalent to the constraint solver,
+    #     which never introduces new Union types (it uses join() instead).
+    if isinstance(template, TypeVarType):
+        return [Constraint(template, direction, actual)]
+
+    if (
+        isinstance(actual, TypeVarType)
+        and not actual.id.is_meta_var()
+        and direction == SUPERTYPE_OF
+    ):
+        # Unless template is also a type variable (or a union that contains one), using the upper
+        # bound for inference will usually give better result for actual that is a type variable.
+        if not isinstance(template, UnionType) or not any(
+            isinstance(t, TypeVarType) for t in template.items
+        ):
+            actual = get_proper_type(actual.upper_bound)
+
+    # Now handle the case of either template or actual being a Union.
+    # For a Union to be a subtype of another type, every item of the Union
+    # must be a subtype of that type, so concatenate the constraints.
+    if direction == SUBTYPE_OF and isinstance(template, UnionType):
+        res = []
+        for t_item in template.items:
+            res.extend(infer_constraints(t_item, actual, direction))
+        return res
+    if direction == SUPERTYPE_OF and isinstance(actual, UnionType):
+        res = []
+        for a_item in actual.items:
+            # `orig_template` has to be preserved intact in case it's recursive.
+            # If we unwrapped ``type[...]`` previously, wrap the item back again,
+            # as ``type[...]`` can't be removed from `orig_template`.
+            if type_type_unwrapped:
+                a_item = TypeType.make_normalized(a_item)
+            res.extend(infer_constraints(orig_template, a_item, direction))
+        return res
+
+    # Now the potential subtype is known not to be a Union or a type
+    # variable that we are solving for. In that case, for a Union to
+    # be a supertype of the potential subtype, some item of the Union
+    # must be a supertype of it.
+    if direction == SUBTYPE_OF and isinstance(actual, UnionType):
+        # We infer constraints eagerly -- try to find constraints for a type
+        # variable if possible. This seems to help with some real-world
+        # use cases.
+        return any_constraints(
+            [
+                infer_constraints_if_possible(template, a_item, direction)
+                for a_item in actual.items
+            ],
+            eager=True,
+        )
+    if direction == SUPERTYPE_OF and isinstance(template, UnionType):
+        # When the template is a union, we are okay with leaving some
+        # type variables indeterminate. This helps with some special
+        # cases, though this isn't very principled.
+        result = any_constraints(
+            [
+                infer_constraints_if_possible(t_item, actual, direction)
+                for t_item in template.items
+            ],
+            eager=isinstance(actual, AnyType),
+        )
+        if result:
+            return result
+        elif has_recursive_types(template) and not has_recursive_types(actual):
+            return handle_recursive_union(template, actual, direction)
+        return []
+
+    # Remaining cases are handled by ConstraintBuilderVisitor.
+    return template.accept(ConstraintBuilderVisitor(actual, direction, skip_neg_op))
+
+
+def _is_type_type(tp: ProperType) -> TypeGuard[TypeType | UnionType]:
+    """Is ``tp`` a ``type[...]`` or a union thereof?
+
+    ``Type[A | B]`` is internally represented as ``type[A] | type[B]``, and this
+    troubles the solver sometimes.
+    """
+    return (
+        isinstance(tp, TypeType)
+        or isinstance(tp, UnionType)
+        and all(isinstance(get_proper_type(o), TypeType) for o in tp.items)
+    )
+
+
+def _unwrap_type_type(tp: TypeType | UnionType) -> ProperType:
+    """Extract the inner type from ``type[...]`` expression or a union thereof."""
+    if isinstance(tp, TypeType):
+        return tp.item
+    return UnionType.make_union([cast(TypeType, get_proper_type(o)).item for o in tp.items])
+
+
+def infer_constraints_if_possible(
+    template: Type, actual: Type, direction: int
+) -> list[Constraint] | None:
+    """Like infer_constraints, but return None if the input relation is
+    known to be unsatisfiable, for example if template=List[T] and actual=int.
+    (In this case infer_constraints would return [], just like it would for
+    an automatically satisfied relation like template=List[T] and actual=object.)
+    """
+    if direction == SUBTYPE_OF and not mypy.subtypes.is_subtype(erase_typevars(template), actual):
+        return None
+    if direction == SUPERTYPE_OF and not mypy.subtypes.is_subtype(
+        actual, erase_typevars(template)
+    ):
+        return None
+    if (
+        direction == SUPERTYPE_OF
+        and isinstance(template, TypeVarType)
+        and not mypy.subtypes.is_subtype(actual, erase_typevars(template.upper_bound))
+    ):
+        # This is not caught by the above branch because of the erase_typevars() call,
+        # that would return 'Any' for a type variable.
+        return None
+    return infer_constraints(template, actual, direction)
+
+
+def select_trivial(options: Sequence[list[Constraint] | None]) -> list[list[Constraint]]:
+    """Select only those lists where each item is a constraint against Any."""
+    res = []
+    for option in options:
+        if option is None:
+            continue
+        if all(isinstance(get_proper_type(c.target), AnyType) for c in option):
+            res.append(option)
+    return res
+
+
+def merge_with_any(constraint: Constraint) -> Constraint:
+    """Transform a constraint target into a union with given Any type."""
+    target = constraint.target
+    if is_union_with_any(target):
+        # Do not produce redundant unions.
+        return constraint
+    # TODO: if we will support multiple sources Any, use this here instead.
+    any_type = AnyType(TypeOfAny.implementation_artifact)
+    return Constraint(
+        constraint.origin_type_var,
+        constraint.op,
+        UnionType.make_union([target, any_type], target.line, target.column),
+    )
+
+
+def handle_recursive_union(template: UnionType, actual: Type, direction: int) -> list[Constraint]:
+    # This is a hack to special-case things like Union[T, Inst[T]] in recursive types. Although
+    # it is quite arbitrary, it is a relatively common pattern, so we should handle it well.
+    # This function may be called when inferring against such union resulted in different
+    # constraints for each item. Normally we give up in such case, but here we instead split
+    # the union in two parts, and try inferring sequentially.
+    non_type_var_items = [t for t in template.items if not isinstance(t, TypeVarType)]
+    type_var_items = [t for t in template.items if isinstance(t, TypeVarType)]
+    return infer_constraints(
+        UnionType.make_union(non_type_var_items), actual, direction
+    ) or infer_constraints(UnionType.make_union(type_var_items), actual, direction)
+
+
+def any_constraints(options: list[list[Constraint] | None], *, eager: bool) -> list[Constraint]:
+    """Deduce what we can from a collection of constraint lists.
+
+    It's a given that at least one of the lists must be satisfied. A
+    None element in the list of options represents an unsatisfiable
+    constraint and is ignored.  Ignore empty constraint lists if eager
+    is true -- they are always trivially satisfiable.
+    """
+    if eager:
+        valid_options = [option for option in options if option]
+    else:
+        valid_options = [option for option in options if option is not None]
+
+    if not valid_options:
+        return []
+
+    if len(valid_options) == 1:
+        return valid_options[0]
+
+    if all(is_same_constraints(valid_options[0], c) for c in valid_options[1:]):
+        # Multiple sets of constraints that are all the same. Just pick any one of them.
+        return valid_options[0]
+
+    if all(is_similar_constraints(valid_options[0], c) for c in valid_options[1:]):
+        # All options have same structure. In this case we can merge-in trivial
+        # options (i.e. those that only have Any) and try again.
+        # TODO: More generally, if a given (variable, direction) pair appears in
+        # every option, combine the bounds with meet/join always, not just for Any.
+        trivial_options = select_trivial(valid_options)
+        if trivial_options and len(trivial_options) < len(valid_options):
+            merged_options = []
+            for option in valid_options:
+                if option in trivial_options:
+                    continue
+                merged_options.append([merge_with_any(c) for c in option])
+            return any_constraints(list(merged_options), eager=eager)
+
+    # If normal logic didn't work, try excluding trivially unsatisfiable constraint (due to
+    # upper bounds) from each option, and comparing them again.
+    filtered_options = [filter_satisfiable(o) for o in options]
+    if filtered_options != options:
+        return any_constraints(filtered_options, eager=eager)
+
+    # Try harder: if that didn't work, try to strip typevars that aren't meta vars.
+    # Note this is what we would always do, but unfortunately some callers may not
+    # set the meta var status correctly (for historical reasons), so we use this as
+    # a fallback only.
+    filtered_options = [exclude_non_meta_vars(o) for o in options]
+    if filtered_options != options:
+        return any_constraints(filtered_options, eager=eager)
+
+    # Otherwise, there are either no valid options or multiple, inconsistent valid
+    # options. Give up and deduce nothing.
+    return []
+
+
+def filter_satisfiable(option: list[Constraint] | None) -> list[Constraint] | None:
+    """Keep only constraints that can possibly be satisfied.
+
+    Currently, we filter out constraints where target is not a subtype of the upper bound.
+    Since those can be never satisfied. We may add more cases in future if it improves type
+    inference.
+    """
+    if not option:
+        return option
+
+    satisfiable = []
+    for c in option:
+        if isinstance(c.origin_type_var, TypeVarType) and c.origin_type_var.values:
+            if any(
+                mypy.subtypes.is_subtype(c.target, value) for value in c.origin_type_var.values
+            ):
+                satisfiable.append(c)
+        elif mypy.subtypes.is_subtype(c.target, c.origin_type_var.upper_bound):
+            satisfiable.append(c)
+    if not satisfiable:
+        return None
+    return satisfiable
+
+
+def exclude_non_meta_vars(option: list[Constraint] | None) -> list[Constraint] | None:
+    # If we had an empty list, keep it intact
+    if not option:
+        return option
+    # However, if none of the options actually references meta vars, better remove
+    # this constraint entirely.
+    return [c for c in option if c.type_var.is_meta_var()] or None
+
+
+def is_same_constraints(x: list[Constraint], y: list[Constraint]) -> bool:
+    for c1 in x:
+        if not any(is_same_constraint(c1, c2) for c2 in y):
+            return False
+    for c1 in y:
+        if not any(is_same_constraint(c1, c2) for c2 in x):
+            return False
+    return True
+
+
+def is_same_constraint(c1: Constraint, c2: Constraint) -> bool:
+    # Ignore direction when comparing constraints against Any.
+    skip_op_check = isinstance(get_proper_type(c1.target), AnyType) and isinstance(
+        get_proper_type(c2.target), AnyType
+    )
+    return (
+        c1.type_var == c2.type_var
+        and (c1.op == c2.op or skip_op_check)
+        and mypy.subtypes.is_same_type(c1.target, c2.target)
+    )
+
+
+def is_similar_constraints(x: list[Constraint], y: list[Constraint]) -> bool:
+    """Check that two lists of constraints have similar structure.
+
+    This means that each list has same type variable plus direction pairs (i.e we
+    ignore the target). Except for constraints where target is Any type, there
+    we ignore direction as well.
+    """
+    return _is_similar_constraints(x, y) and _is_similar_constraints(y, x)
+
+
+def _is_similar_constraints(x: list[Constraint], y: list[Constraint]) -> bool:
+    """Check that every constraint in the first list has a similar one in the second.
+
+    See docstring above for definition of similarity.
+    """
+    for c1 in x:
+        has_similar = False
+        for c2 in y:
+            # Ignore direction when either constraint is against Any.
+            skip_op_check = isinstance(get_proper_type(c1.target), AnyType) or isinstance(
+                get_proper_type(c2.target), AnyType
+            )
+            if c1.type_var == c2.type_var and (c1.op == c2.op or skip_op_check):
+                has_similar = True
+                break
+        if not has_similar:
+            return False
+    return True
+
+
+class ConstraintBuilderVisitor(TypeVisitor[list[Constraint]]):
+    """Visitor class for inferring type constraints."""
+
+    # The type that is compared against a template
+    # TODO: The value may be None. Is that actually correct?
+    actual: ProperType
+
+    def __init__(self, actual: ProperType, direction: int, skip_neg_op: bool) -> None:
+        # Direction must be SUBTYPE_OF or SUPERTYPE_OF.
+        self.actual = actual
+        self.direction = direction
+        # Whether to skip polymorphic inference (involves inference in opposite direction)
+        # this is used to prevent infinite recursion when both template and actual are
+        # generic callables.
+        self.skip_neg_op = skip_neg_op
+
+    # Trivial leaf types
+
+    def visit_unbound_type(self, template: UnboundType) -> list[Constraint]:
+        return []
+
+    def visit_any(self, template: AnyType) -> list[Constraint]:
+        return []
+
+    def visit_none_type(self, template: NoneType) -> list[Constraint]:
+        return []
+
+    def visit_uninhabited_type(self, template: UninhabitedType) -> list[Constraint]:
+        return []
+
+    def visit_erased_type(self, template: ErasedType) -> list[Constraint]:
+        return []
+
+    def visit_deleted_type(self, template: DeletedType) -> list[Constraint]:
+        return []
+
+    def visit_literal_type(self, template: LiteralType) -> list[Constraint]:
+        return []
+
+    # Errors
+
+    def visit_partial_type(self, template: PartialType) -> list[Constraint]:
+        # We can't do anything useful with a partial type here.
+        assert False, "Internal error"
+
+    # Non-trivial leaf type
+
+    def visit_type_var(self, template: TypeVarType) -> list[Constraint]:
+        assert False, (
+            "Unexpected TypeVarType in ConstraintBuilderVisitor"
+            " (should have been handled in infer_constraints)"
+        )
+
+    def visit_param_spec(self, template: ParamSpecType) -> list[Constraint]:
+        # Can't infer ParamSpecs from component values (only via Callable[P, T]).
+        return []
+
+    def visit_type_var_tuple(self, template: TypeVarTupleType) -> list[Constraint]:
+        raise NotImplementedError
+
+    def visit_unpack_type(self, template: UnpackType) -> list[Constraint]:
+        raise RuntimeError("Mypy bug: unpack should be handled at a higher level.")
+
+    def visit_parameters(self, template: Parameters) -> list[Constraint]:
+        # Constraining Any against C[P] turns into infer_against_any([P], Any)
+        if isinstance(self.actual, AnyType):
+            return self.infer_against_any(template.arg_types, self.actual)
+        if type_state.infer_polymorphic and isinstance(self.actual, Parameters):
+            # For polymorphic inference we need to be able to infer secondary constraints
+            # in situations like [x: T] <: P <: [x: int].
+            return infer_callable_arguments_constraints(template, self.actual, self.direction)
+        if type_state.infer_polymorphic and isinstance(self.actual, ParamSpecType):
+            # Similar for [x: T] <: Q <: Concatenate[int, P].
+            return infer_callable_arguments_constraints(
+                template, self.actual.prefix, self.direction
+            )
+        # There also may be unpatched types after a user error, simply ignore them.
+        return []
+
+    # Non-leaf types
+
+    def visit_instance(self, template: Instance) -> list[Constraint]:
+        original_actual = actual = self.actual
+        res: list[Constraint] = []
+        if isinstance(actual, (CallableType, Overloaded)) and template.type.is_protocol:
+            if "__call__" in template.type.protocol_members:
+                # Special case: a generic callback protocol
+                if not any(template == t for t in template.type.inferring):
+                    template.type.inferring.append(template)
+                    call = mypy.subtypes.find_member(
+                        "__call__", template, actual, is_operator=True
+                    )
+                    assert call is not None
+                    if (
+                        self.direction == SUPERTYPE_OF
+                        and mypy.subtypes.is_subtype(actual, erase_typevars(call))
+                        or self.direction == SUBTYPE_OF
+                        and mypy.subtypes.is_subtype(erase_typevars(call), actual)
+                    ):
+                        res.extend(infer_constraints(call, actual, self.direction))
+                    template.type.inferring.pop()
+        if isinstance(actual, CallableType) and actual.fallback is not None:
+            if (
+                actual.is_type_obj()
+                and template.type.is_protocol
+                and self.direction == SUPERTYPE_OF
+            ):
+                ret_type = get_proper_type(actual.ret_type)
+                if isinstance(ret_type, TupleType):
+                    ret_type = mypy.typeops.tuple_fallback(ret_type)
+                if isinstance(ret_type, Instance):
+                    res.extend(
+                        self.infer_constraints_from_protocol_members(
+                            ret_type, template, ret_type, template, class_obj=True
+                        )
+                    )
+            actual = actual.fallback
+        if isinstance(actual, TypeType) and template.type.is_protocol:
+            if self.direction == SUPERTYPE_OF:
+                a_item = actual.item
+                if isinstance(a_item, Instance):
+                    res.extend(
+                        self.infer_constraints_from_protocol_members(
+                            a_item, template, a_item, template, class_obj=True
+                        )
+                    )
+                # Infer constraints for Type[T] via metaclass of T when it makes sense.
+                if isinstance(a_item, TypeVarType):
+                    a_item = get_proper_type(a_item.upper_bound)
+                if isinstance(a_item, Instance) and a_item.type.metaclass_type:
+                    res.extend(
+                        self.infer_constraints_from_protocol_members(
+                            a_item.type.metaclass_type, template, actual, template
+                        )
+                    )
+
+        if isinstance(actual, Overloaded) and actual.fallback is not None:
+            actual = actual.fallback
+        if isinstance(actual, TypedDictType):
+            actual = actual.create_anonymous_fallback()
+        if isinstance(actual, LiteralType):
+            actual = actual.fallback
+        if isinstance(actual, Instance):
+            instance = actual
+            erased = erase_typevars(template)
+            assert isinstance(erased, Instance)  # type: ignore[misc]
+            # We always try nominal inference if possible,
+            # it is much faster than the structural one.
+            if self.direction == SUBTYPE_OF and template.type.has_base(instance.type.fullname):
+                mapped = map_instance_to_supertype(template, instance.type)
+                tvars = mapped.type.defn.type_vars
+
+                if instance.type.has_type_var_tuple_type:
+                    # Variadic types need special handling to map each type argument to
+                    # the correct corresponding type variable.
+                    assert instance.type.type_var_tuple_prefix is not None
+                    assert instance.type.type_var_tuple_suffix is not None
+                    prefix_len = instance.type.type_var_tuple_prefix
+                    suffix_len = instance.type.type_var_tuple_suffix
+                    tvt = instance.type.defn.type_vars[prefix_len]
+                    assert isinstance(tvt, TypeVarTupleType)
+                    fallback = tvt.tuple_fallback
+                    i_prefix, i_middle, i_suffix = split_with_prefix_and_suffix(
+                        instance.args, prefix_len, suffix_len
+                    )
+                    m_prefix, m_middle, m_suffix = split_with_prefix_and_suffix(
+                        mapped.args, prefix_len, suffix_len
+                    )
+                    instance_args = i_prefix + (TupleType(list(i_middle), fallback),) + i_suffix
+                    mapped_args = m_prefix + (TupleType(list(m_middle), fallback),) + m_suffix
+                else:
+                    mapped_args = mapped.args
+                    instance_args = instance.args
+
+                # N.B: We use zip instead of indexing because the lengths might have
+                # mismatches during daemon reprocessing.
+                for tvar, mapped_arg, instance_arg in zip(tvars, mapped_args, instance_args):
+                    if isinstance(tvar, TypeVarType):
+                        # The constraints for generic type parameters depend on variance.
+                        # Include constraints from both directions if invariant.
+                        if tvar.variance != CONTRAVARIANT:
+                            res.extend(infer_constraints(mapped_arg, instance_arg, self.direction))
+                        if tvar.variance != COVARIANT:
+                            res.extend(
+                                infer_constraints(mapped_arg, instance_arg, neg_op(self.direction))
+                            )
+                    elif isinstance(tvar, ParamSpecType) and isinstance(mapped_arg, ParamSpecType):
+                        prefix = mapped_arg.prefix
+                        if isinstance(instance_arg, Parameters):
+                            # No such thing as variance for ParamSpecs, consider them invariant
+                            # TODO: constraints between prefixes using
+                            # infer_callable_arguments_constraints()
+                            suffix: Type = instance_arg.copy_modified(
+                                instance_arg.arg_types[len(prefix.arg_types) :],
+                                instance_arg.arg_kinds[len(prefix.arg_kinds) :],
+                                instance_arg.arg_names[len(prefix.arg_names) :],
+                            )
+                            res.append(Constraint(mapped_arg, SUBTYPE_OF, suffix))
+                            res.append(Constraint(mapped_arg, SUPERTYPE_OF, suffix))
+                        elif isinstance(instance_arg, ParamSpecType):
+                            suffix = instance_arg.copy_modified(
+                                prefix=Parameters(
+                                    instance_arg.prefix.arg_types[len(prefix.arg_types) :],
+                                    instance_arg.prefix.arg_kinds[len(prefix.arg_kinds) :],
+                                    instance_arg.prefix.arg_names[len(prefix.arg_names) :],
+                                )
+                            )
+                            res.append(Constraint(mapped_arg, SUBTYPE_OF, suffix))
+                            res.append(Constraint(mapped_arg, SUPERTYPE_OF, suffix))
+                    elif isinstance(tvar, TypeVarTupleType):
+                        # Handle variadic type variables covariantly for consistency.
+                        res.extend(infer_constraints(mapped_arg, instance_arg, self.direction))
+
+                return res
+            elif self.direction == SUPERTYPE_OF and instance.type.has_base(template.type.fullname):
+                mapped = map_instance_to_supertype(instance, template.type)
+                tvars = template.type.defn.type_vars
+                if template.type.has_type_var_tuple_type:
+                    # Variadic types need special handling to map each type argument to
+                    # the correct corresponding type variable.
+                    assert template.type.type_var_tuple_prefix is not None
+                    assert template.type.type_var_tuple_suffix is not None
+                    prefix_len = template.type.type_var_tuple_prefix
+                    suffix_len = template.type.type_var_tuple_suffix
+                    tvt = template.type.defn.type_vars[prefix_len]
+                    assert isinstance(tvt, TypeVarTupleType)
+                    fallback = tvt.tuple_fallback
+                    t_prefix, t_middle, t_suffix = split_with_prefix_and_suffix(
+                        template.args, prefix_len, suffix_len
+                    )
+                    m_prefix, m_middle, m_suffix = split_with_prefix_and_suffix(
+                        mapped.args, prefix_len, suffix_len
+                    )
+                    template_args = t_prefix + (TupleType(list(t_middle), fallback),) + t_suffix
+                    mapped_args = m_prefix + (TupleType(list(m_middle), fallback),) + m_suffix
+                else:
+                    mapped_args = mapped.args
+                    template_args = template.args
+                # N.B: We use zip instead of indexing because the lengths might have
+                # mismatches during daemon reprocessing.
+                for tvar, mapped_arg, template_arg in zip(tvars, mapped_args, template_args):
+                    if isinstance(tvar, TypeVarType):
+                        # The constraints for generic type parameters depend on variance.
+                        # Include constraints from both directions if invariant.
+                        if tvar.variance != CONTRAVARIANT:
+                            res.extend(infer_constraints(template_arg, mapped_arg, self.direction))
+                        if tvar.variance != COVARIANT:
+                            res.extend(
+                                infer_constraints(template_arg, mapped_arg, neg_op(self.direction))
+                            )
+                    elif isinstance(tvar, ParamSpecType) and isinstance(
+                        template_arg, ParamSpecType
+                    ):
+                        prefix = template_arg.prefix
+                        if isinstance(mapped_arg, Parameters):
+                            # No such thing as variance for ParamSpecs, consider them invariant
+                            # TODO: constraints between prefixes using
+                            # infer_callable_arguments_constraints()
+                            suffix = mapped_arg.copy_modified(
+                                mapped_arg.arg_types[len(prefix.arg_types) :],
+                                mapped_arg.arg_kinds[len(prefix.arg_kinds) :],
+                                mapped_arg.arg_names[len(prefix.arg_names) :],
+                            )
+                            res.append(Constraint(template_arg, SUBTYPE_OF, suffix))
+                            res.append(Constraint(template_arg, SUPERTYPE_OF, suffix))
+                        elif isinstance(mapped_arg, ParamSpecType):
+                            suffix = mapped_arg.copy_modified(
+                                prefix=Parameters(
+                                    mapped_arg.prefix.arg_types[len(prefix.arg_types) :],
+                                    mapped_arg.prefix.arg_kinds[len(prefix.arg_kinds) :],
+                                    mapped_arg.prefix.arg_names[len(prefix.arg_names) :],
+                                )
+                            )
+                            res.append(Constraint(template_arg, SUBTYPE_OF, suffix))
+                            res.append(Constraint(template_arg, SUPERTYPE_OF, suffix))
+                    elif isinstance(tvar, TypeVarTupleType):
+                        # Consider variadic type variables to be invariant.
+                        res.extend(infer_constraints(template_arg, mapped_arg, SUBTYPE_OF))
+                        res.extend(infer_constraints(template_arg, mapped_arg, SUPERTYPE_OF))
+                return res
+            if (
+                template.type.is_protocol
+                and self.direction == SUPERTYPE_OF
+                and
+                # We avoid infinite recursion for structural subtypes by checking
+                # whether this type already appeared in the inference chain.
+                # This is a conservative way to break the inference cycles.
+                # It never produces any "false" constraints but gives up soon
+                # on purely structural inference cycles, see #3829.
+                # Note that we use is_protocol_implementation instead of is_subtype
+                # because some type may be considered a subtype of a protocol
+                # due to _promote, but still not implement the protocol.
+                not any(template == t for t in reversed(template.type.inferring))
+                and mypy.subtypes.is_protocol_implementation(instance, erased, skip=["__call__"])
+            ):
+                template.type.inferring.append(template)
+                res.extend(
+                    self.infer_constraints_from_protocol_members(
+                        instance, template, original_actual, template
+                    )
+                )
+                template.type.inferring.pop()
+                return res
+            elif (
+                instance.type.is_protocol
+                and self.direction == SUBTYPE_OF
+                and
+                # We avoid infinite recursion for structural subtypes also here.
+                not any(instance == i for i in reversed(instance.type.inferring))
+                and mypy.subtypes.is_protocol_implementation(erased, instance, skip=["__call__"])
+            ):
+                instance.type.inferring.append(instance)
+                res.extend(
+                    self.infer_constraints_from_protocol_members(
+                        instance, template, template, instance
+                    )
+                )
+                instance.type.inferring.pop()
+                return res
+        if res:
+            return res
+
+        if isinstance(actual, AnyType):
+            return self.infer_against_any(template.args, actual)
+        if (
+            isinstance(actual, TupleType)
+            and is_named_instance(template, TUPLE_LIKE_INSTANCE_NAMES)
+            and self.direction == SUPERTYPE_OF
+        ):
+            for item in actual.items:
+                if isinstance(item, UnpackType):
+                    unpacked = get_proper_type(item.type)
+                    if isinstance(unpacked, TypeVarTupleType):
+                        # Cannot infer anything for T from [T, ...] <: *Ts
+                        continue
+                    assert (
+                        isinstance(unpacked, Instance)
+                        and unpacked.type.fullname == "builtins.tuple"
+                    )
+                    item = unpacked.args[0]
+                cb = infer_constraints(template.args[0], item, SUPERTYPE_OF)
+                res.extend(cb)
+            return res
+        elif isinstance(actual, TupleType) and self.direction == SUPERTYPE_OF:
+            return infer_constraints(template, mypy.typeops.tuple_fallback(actual), self.direction)
+        elif isinstance(actual, TypeVarType):
+            if not actual.values and not actual.id.is_meta_var():
+                return infer_constraints(template, actual.upper_bound, self.direction)
+            return []
+        elif isinstance(actual, ParamSpecType):
+            return infer_constraints(template, actual.upper_bound, self.direction)
+        elif isinstance(actual, TypeVarTupleType):
+            raise NotImplementedError
+        else:
+            return []
+
+    def infer_constraints_from_protocol_members(
+        self,
+        instance: Instance,
+        template: Instance,
+        subtype: Type,
+        protocol: Instance,
+        class_obj: bool = False,
+    ) -> list[Constraint]:
+        """Infer constraints for situations where either 'template' or 'instance' is a protocol.
+
+        The 'protocol' is the one of two that is an instance of protocol type, 'subtype'
+        is the type used to bind self during inference. Currently, we just infer constrains for
+        every protocol member type (both ways for settable members).
+        """
+        res = []
+        for member in protocol.type.protocol_members:
+            inst = mypy.subtypes.find_member(member, instance, subtype, class_obj=class_obj)
+            temp = mypy.subtypes.find_member(member, template, subtype)
+            if inst is None or temp is None:
+                if member == "__call__":
+                    continue
+                return []  # See #11020
+            # The above is safe since at this point we know that 'instance' is a subtype
+            # of (erased) 'template', therefore it defines all protocol members
+            if class_obj:
+                # For class objects we must only infer constraints if possible, otherwise it
+                # can lead to confusion between class and instance, for example StrEnum is
+                # Iterable[str] for an instance, but Iterable[StrEnum] for a class object.
+                if not mypy.subtypes.is_subtype(
+                    inst, erase_typevars(temp), ignore_pos_arg_names=True
+                ):
+                    continue
+            # This exception matches the one in typeops.py, see PR #14121 for context.
+            if member == "__call__" and instance.type.is_metaclass(precise=True):
+                continue
+            res.extend(infer_constraints(temp, inst, self.direction))
+            if mypy.subtypes.IS_SETTABLE in mypy.subtypes.get_member_flags(member, protocol):
+                # Settable members are invariant, add opposite constraints
+                res.extend(infer_constraints(temp, inst, neg_op(self.direction)))
+        return res
+
+    def visit_callable_type(self, template: CallableType) -> list[Constraint]:
+        # Normalize callables before matching against each other.
+        # Note that non-normalized callables can be created in annotations
+        # using e.g. callback protocols.
+        # TODO: check that callables match? Ideally we should not infer constraints
+        # callables that can never be subtypes of one another in given direction.
+        template = template.with_unpacked_kwargs().with_normalized_var_args()
+        extra_tvars = False
+        if isinstance(self.actual, CallableType):
+            res: list[Constraint] = []
+            cactual = self.actual.with_unpacked_kwargs().with_normalized_var_args()
+            param_spec = template.param_spec()
+
+            template_ret_type, cactual_ret_type = template.ret_type, cactual.ret_type
+            if template.type_guard is not None and cactual.type_guard is not None:
+                template_ret_type = template.type_guard
+                cactual_ret_type = cactual.type_guard
+
+            if template.type_is is not None and cactual.type_is is not None:
+                template_ret_type = template.type_is
+                cactual_ret_type = cactual.type_is
+
+            res.extend(infer_constraints(template_ret_type, cactual_ret_type, self.direction))
+
+            if param_spec is None:
+                # TODO: Erase template variables if it is generic?
+                if (
+                    type_state.infer_polymorphic
+                    and cactual.variables
+                    and not self.skip_neg_op
+                    # Technically, the correct inferred type for application of e.g.
+                    # Callable[..., T] -> Callable[..., T] (with literal ellipsis), to a generic
+                    # like U -> U, should be Callable[..., Any], but if U is a self-type, we can
+                    # allow it to leak, to be later bound to self. A bunch of existing code
+                    # depends on this old behaviour.
+                    and not (
+                        any(tv.id.is_self() for tv in cactual.variables)
+                        and template.is_ellipsis_args
+                    )
+                ):
+                    # If the actual callable is generic, infer constraints in the opposite
+                    # direction, and indicate to the solver there are extra type variables
+                    # to solve for (see more details in mypy/solve.py).
+                    res.extend(
+                        infer_constraints(
+                            cactual, template, neg_op(self.direction), skip_neg_op=True
+                        )
+                    )
+                    extra_tvars = True
+
+                # We can't infer constraints from arguments if the template is Callable[..., T]
+                # (with literal '...').
+                if not template.is_ellipsis_args:
+                    unpack_present = find_unpack_in_list(template.arg_types)
+                    # When both ParamSpec and TypeVarTuple are present, things become messy
+                    # quickly. For now, we only allow ParamSpec to "capture" TypeVarTuple,
+                    # but not vice versa.
+                    # TODO: infer more from prefixes when possible.
+                    if unpack_present is not None and not cactual.param_spec():
+                        # We need to re-normalize args to the form they appear in tuples,
+                        # for callables we always pack the suffix inside another tuple.
+                        unpack = template.arg_types[unpack_present]
+                        assert isinstance(unpack, UnpackType)
+                        tuple_type = get_tuple_fallback_from_unpack(unpack)
+                        template_types = repack_callable_args(template, tuple_type)
+                        actual_types = repack_callable_args(cactual, tuple_type)
+                        # Now we can use the same general helper as for tuple types.
+                        unpack_constraints = build_constraints_for_simple_unpack(
+                            template_types, actual_types, neg_op(self.direction)
+                        )
+                        res.extend(unpack_constraints)
+                    else:
+                        # TODO: do we need some special-casing when unpack is present in actual
+                        # callable but not in template callable?
+                        res.extend(
+                            infer_callable_arguments_constraints(template, cactual, self.direction)
+                        )
+            else:
+                prefix = param_spec.prefix
+                prefix_len = len(prefix.arg_types)
+                cactual_ps = cactual.param_spec()
+
+                if type_state.infer_polymorphic and cactual.variables and not self.skip_neg_op:
+                    # Similar logic to the branch above.
+                    res.extend(
+                        infer_constraints(
+                            cactual, template, neg_op(self.direction), skip_neg_op=True
+                        )
+                    )
+                    extra_tvars = True
+
+                # Compare prefixes as well
+                cactual_prefix = cactual.copy_modified(
+                    arg_types=cactual.arg_types[:prefix_len],
+                    arg_kinds=cactual.arg_kinds[:prefix_len],
+                    arg_names=cactual.arg_names[:prefix_len],
+                )
+                res.extend(
+                    infer_callable_arguments_constraints(prefix, cactual_prefix, self.direction)
+                )
+
+                param_spec_target: Type | None = None
+                if not cactual_ps:
+                    max_prefix_len = len([k for k in cactual.arg_kinds if k in (ARG_POS, ARG_OPT)])
+                    prefix_len = min(prefix_len, max_prefix_len)
+                    param_spec_target = Parameters(
+                        arg_types=cactual.arg_types[prefix_len:],
+                        arg_kinds=cactual.arg_kinds[prefix_len:],
+                        arg_names=cactual.arg_names[prefix_len:],
+                        variables=cactual.variables if not type_state.infer_polymorphic else [],
+                        imprecise_arg_kinds=cactual.imprecise_arg_kinds,
+                    )
+                else:
+                    if len(param_spec.prefix.arg_types) <= len(cactual_ps.prefix.arg_types):
+                        param_spec_target = cactual_ps.copy_modified(
+                            prefix=Parameters(
+                                arg_types=cactual_ps.prefix.arg_types[prefix_len:],
+                                arg_kinds=cactual_ps.prefix.arg_kinds[prefix_len:],
+                                arg_names=cactual_ps.prefix.arg_names[prefix_len:],
+                                imprecise_arg_kinds=cactual_ps.prefix.imprecise_arg_kinds,
+                            )
+                        )
+                if param_spec_target is not None:
+                    res.append(Constraint(param_spec, self.direction, param_spec_target))
+            if extra_tvars:
+                for c in res:
+                    c.extra_tvars += cactual.variables
+            return res
+        elif isinstance(self.actual, AnyType):
+            param_spec = template.param_spec()
+            any_type = AnyType(TypeOfAny.from_another_any, source_any=self.actual)
+            if param_spec is None:
+                # FIX what if generic
+                res = self.infer_against_any(template.arg_types, self.actual)
+            else:
+                res = [
+                    Constraint(
+                        param_spec,
+                        SUBTYPE_OF,
+                        Parameters([any_type, any_type], [ARG_STAR, ARG_STAR2], [None, None]),
+                    )
+                ]
+            res.extend(infer_constraints(template.ret_type, any_type, self.direction))
+            return res
+        elif isinstance(self.actual, Overloaded):
+            return self.infer_against_overloaded(self.actual, template)
+        elif isinstance(self.actual, TypeType):
+            return infer_constraints(template.ret_type, self.actual.item, self.direction)
+        elif isinstance(self.actual, Instance):
+            # Instances with __call__ method defined are considered structural
+            # subtypes of Callable with a compatible signature.
+            call = mypy.subtypes.find_member(
+                "__call__", self.actual, self.actual, is_operator=True
+            )
+            if call:
+                return infer_constraints(template, call, self.direction)
+            else:
+                return []
+        else:
+            return []
+
+    def infer_against_overloaded(
+        self, overloaded: Overloaded, template: CallableType
+    ) -> list[Constraint]:
+        # Create constraints by matching an overloaded type against a template.
+        # This is tricky to do in general. We cheat by only matching against
+        # the first overload item that is callable compatible. This
+        # seems to work somewhat well, but we should really use a more
+        # reliable technique.
+        item = find_matching_overload_item(overloaded, template)
+        return infer_constraints(template, item, self.direction)
+
+    def visit_tuple_type(self, template: TupleType) -> list[Constraint]:
+        actual = self.actual
+        unpack_index = find_unpack_in_list(template.items)
+        is_varlength_tuple = (
+            isinstance(actual, Instance) and actual.type.fullname == "builtins.tuple"
+        )
+
+        if isinstance(actual, TupleType) or is_varlength_tuple:
+            res: list[Constraint] = []
+            if unpack_index is not None:
+                if is_varlength_tuple:
+                    # Variadic tuple can be only a supertype of a tuple type, but even if
+                    # direction is opposite, inferring something may give better error messages.
+                    unpack_type = template.items[unpack_index]
+                    assert isinstance(unpack_type, UnpackType)
+                    unpacked_type = get_proper_type(unpack_type.type)
+                    if isinstance(unpacked_type, TypeVarTupleType):
+                        res = [
+                            Constraint(type_var=unpacked_type, op=self.direction, target=actual)
+                        ]
+                    else:
+                        assert (
+                            isinstance(unpacked_type, Instance)
+                            and unpacked_type.type.fullname == "builtins.tuple"
+                        )
+                        res = infer_constraints(unpacked_type, actual, self.direction)
+                    assert isinstance(actual, Instance)  # ensured by is_varlength_tuple == True
+                    for i, ti in enumerate(template.items):
+                        if i == unpack_index:
+                            # This one we just handled above.
+                            continue
+                        # For Tuple[T, *Ts, S] <: tuple[X, ...] infer also T <: X and S <: X.
+                        res.extend(infer_constraints(ti, actual.args[0], self.direction))
+                    return res
+                else:
+                    assert isinstance(actual, TupleType)
+                    unpack_constraints = build_constraints_for_simple_unpack(
+                        template.items, actual.items, self.direction
+                    )
+                    actual_items: tuple[Type, ...] = ()
+                    template_items: tuple[Type, ...] = ()
+                    res.extend(unpack_constraints)
+            elif isinstance(actual, TupleType):
+                a_unpack_index = find_unpack_in_list(actual.items)
+                if a_unpack_index is not None:
+                    # The case where template tuple doesn't have an unpack, but actual tuple
+                    # has an unpack. We can infer something if actual unpack is a variadic tuple.
+                    # Tuple[T, S, U] <: tuple[X, *tuple[Y, ...], Z] => T <: X, S <: Y, U <: Z.
+                    a_unpack = actual.items[a_unpack_index]
+                    assert isinstance(a_unpack, UnpackType)
+                    a_unpacked = get_proper_type(a_unpack.type)
+                    if len(actual.items) + 1 <= len(template.items):
+                        a_prefix_len = a_unpack_index
+                        a_suffix_len = len(actual.items) - a_unpack_index - 1
+                        t_prefix, t_middle, t_suffix = split_with_prefix_and_suffix(
+                            tuple(template.items), a_prefix_len, a_suffix_len
+                        )
+                        actual_items = tuple(actual.items[:a_prefix_len])
+                        if a_suffix_len:
+                            actual_items += tuple(actual.items[-a_suffix_len:])
+                        template_items = t_prefix + t_suffix
+                        if isinstance(a_unpacked, Instance):
+                            assert a_unpacked.type.fullname == "builtins.tuple"
+                            for tm in t_middle:
+                                res.extend(
+                                    infer_constraints(tm, a_unpacked.args[0], self.direction)
+                                )
+                    else:
+                        actual_items = ()
+                        template_items = ()
+                else:
+                    actual_items = tuple(actual.items)
+                    template_items = tuple(template.items)
+            else:
+                return res
+
+            # Cases above will return if actual wasn't a TupleType.
+            assert isinstance(actual, TupleType)
+            if len(actual_items) == len(template_items):
+                if (
+                    actual.partial_fallback.type.is_named_tuple
+                    and template.partial_fallback.type.is_named_tuple
+                ):
+                    # For named tuples using just the fallbacks usually gives better results.
+                    return res + infer_constraints(
+                        template.partial_fallback, actual.partial_fallback, self.direction
+                    )
+                for i in range(len(template_items)):
+                    res.extend(
+                        infer_constraints(template_items[i], actual_items[i], self.direction)
+                    )
+            res.extend(
+                infer_constraints(
+                    template.partial_fallback, actual.partial_fallback, self.direction
+                )
+            )
+            return res
+        elif isinstance(actual, AnyType):
+            return self.infer_against_any(template.items, actual)
+        else:
+            return []
+
+    def visit_typeddict_type(self, template: TypedDictType) -> list[Constraint]:
+        actual = self.actual
+        if isinstance(actual, TypedDictType):
+            res: list[Constraint] = []
+            # NOTE: Non-matching keys are ignored. Compatibility is checked
+            #       elsewhere so this shouldn't be unsafe.
+            for item_name, template_item_type, actual_item_type in template.zip(actual):
+                res.extend(infer_constraints(template_item_type, actual_item_type, self.direction))
+            return res
+        elif isinstance(actual, AnyType):
+            return self.infer_against_any(template.items.values(), actual)
+        else:
+            return []
+
+    def visit_union_type(self, template: UnionType) -> list[Constraint]:
+        assert False, (
+            "Unexpected UnionType in ConstraintBuilderVisitor"
+            " (should have been handled in infer_constraints)"
+        )
+
+    def visit_type_alias_type(self, template: TypeAliasType) -> list[Constraint]:
+        assert False, f"This should be never called, got {template}"
+
+    def infer_against_any(self, types: Iterable[Type], any_type: AnyType) -> list[Constraint]:
+        res: list[Constraint] = []
+        # Some items may be things like `*Tuple[*Ts, T]` for example from callable types with
+        # suffix after *arg, so flatten them.
+        for t in flatten_nested_tuples(types):
+            if isinstance(t, UnpackType):
+                if isinstance(t.type, TypeVarTupleType):
+                    res.append(Constraint(t.type, self.direction, any_type))
+                else:
+                    unpacked = get_proper_type(t.type)
+                    assert isinstance(unpacked, Instance)
+                    res.extend(infer_constraints(unpacked, any_type, self.direction))
+            else:
+                # Note that we ignore variance and simply always use the
+                # original direction. This is because for Any targets direction is
+                # irrelevant in most cases, see e.g. is_same_constraint().
+                res.extend(infer_constraints(t, any_type, self.direction))
+        return res
+
+    def visit_overloaded(self, template: Overloaded) -> list[Constraint]:
+        if isinstance(self.actual, CallableType):
+            items = find_matching_overload_items(template, self.actual)
+        else:
+            items = template.items
+        res: list[Constraint] = []
+        for t in items:
+            res.extend(infer_constraints(t, self.actual, self.direction))
+        return res
+
+    def visit_type_type(self, template: TypeType) -> list[Constraint]:
+        if isinstance(self.actual, CallableType):
+            return infer_constraints(template.item, self.actual.ret_type, self.direction)
+        elif isinstance(self.actual, Overloaded):
+            return infer_constraints(template.item, self.actual.items[0].ret_type, self.direction)
+        elif isinstance(self.actual, TypeType):
+            return infer_constraints(template.item, self.actual.item, self.direction)
+        elif isinstance(self.actual, AnyType):
+            return infer_constraints(template.item, self.actual, self.direction)
+        else:
+            return []
+
+
+def neg_op(op: int) -> int:
+    """Map SubtypeOf to SupertypeOf and vice versa."""
+
+    if op == SUBTYPE_OF:
+        return SUPERTYPE_OF
+    elif op == SUPERTYPE_OF:
+        return SUBTYPE_OF
+    else:
+        raise ValueError(f"Invalid operator {op}")
+
+
+def find_matching_overload_item(overloaded: Overloaded, template: CallableType) -> CallableType:
+    """Disambiguate overload item against a template."""
+    items = overloaded.items
+    for item in items:
+        # Return type may be indeterminate in the template, so ignore it when performing a
+        # subtype check.
+        if mypy.subtypes.is_callable_compatible(
+            item,
+            template,
+            is_compat=mypy.subtypes.is_subtype,
+            is_proper_subtype=False,
+            ignore_return=True,
+        ):
+            return item
+    # Fall back to the first item if we can't find a match. This is totally arbitrary --
+    # maybe we should just bail out at this point.
+    return items[0]
+
+
+def find_matching_overload_items(
+    overloaded: Overloaded, template: CallableType
+) -> list[CallableType]:
+    """Like find_matching_overload_item, but return all matches, not just the first."""
+    items = overloaded.items
+    res = []
+    for item in items:
+        # Return type may be indeterminate in the template, so ignore it when performing a
+        # subtype check.
+        if mypy.subtypes.is_callable_compatible(
+            item,
+            template,
+            is_compat=mypy.subtypes.is_subtype,
+            is_proper_subtype=False,
+            ignore_return=True,
+        ):
+            res.append(item)
+    if not res:
+        # Falling back to all items if we can't find a match is pretty arbitrary, but
+        # it maintains backward compatibility.
+        res = items.copy()
+    return res
+
+
+def get_tuple_fallback_from_unpack(unpack: UnpackType) -> TypeInfo:
+    """Get builtins.tuple type from available types to construct homogeneous tuples."""
+    tp = get_proper_type(unpack.type)
+    if isinstance(tp, Instance) and tp.type.fullname == "builtins.tuple":
+        return tp.type
+    if isinstance(tp, TypeVarTupleType):
+        return tp.tuple_fallback.type
+    if isinstance(tp, TupleType):
+        for base in tp.partial_fallback.type.mro:
+            if base.fullname == "builtins.tuple":
+                return base
+    assert False, "Invalid unpack type"
+
+
+def repack_callable_args(callable: CallableType, tuple_type: TypeInfo) -> list[Type]:
+    """Present callable with star unpack in a normalized form.
+
+    Since positional arguments cannot follow star argument, they are packed in a suffix,
+    while prefix is represented as individual positional args. We want to put all in a single
+    list with unpack in the middle, and prefix/suffix on the sides (as they would appear
+    in e.g. a TupleType).
+    """
+    if ARG_STAR not in callable.arg_kinds:
+        return callable.arg_types
+    star_index = callable.arg_kinds.index(ARG_STAR)
+    arg_types = callable.arg_types[:star_index]
+    star_type = callable.arg_types[star_index]
+    suffix_types = []
+    if not isinstance(star_type, UnpackType):
+        # Re-normalize *args: X -> *args: *tuple[X, ...]
+        star_type = UnpackType(Instance(tuple_type, [star_type]))
+    else:
+        tp = get_proper_type(star_type.type)
+        if isinstance(tp, TupleType):
+            assert isinstance(tp.items[0], UnpackType)
+            star_type = tp.items[0]
+            suffix_types = tp.items[1:]
+    return arg_types + [star_type] + suffix_types
+
+
+def build_constraints_for_simple_unpack(
+    template_args: list[Type], actual_args: list[Type], direction: int
+) -> list[Constraint]:
+    """Infer constraints between two lists of types with variadic items.
+
+    This function is only supposed to be called when a variadic item is present in templates.
+    If there is no variadic item the actuals, we simply use split_with_prefix_and_suffix()
+    and infer prefix <: prefix, suffix <: suffix, variadic <: middle. If there is a variadic
+    item in the actuals we need to be more careful, only common prefix/suffix can generate
+    constraints, also we can only infer constraints for variadic template item, if template
+    prefix/suffix are shorter that actual ones, otherwise there may be partial overlap
+    between variadic items, for example if template prefix is longer:
+
+        templates: T1, T2, Ts, Ts, Ts, ...
+        actuals:   A1, As, As, As, ...
+
+    Note: this function can only be called for builtin variadic constructors: Tuple and Callable.
+    For instances, you should first find correct type argument mapping.
+    """
+    template_unpack = find_unpack_in_list(template_args)
+    assert template_unpack is not None
+    template_prefix = template_unpack
+    template_suffix = len(template_args) - template_prefix - 1
+
+    t_unpack = None
+    res = []
+
+    actual_unpack = find_unpack_in_list(actual_args)
+    if actual_unpack is None:
+        t_unpack = template_args[template_unpack]
+        if template_prefix + template_suffix > len(actual_args):
+            # These can't be subtypes of each-other, return fast.
+            assert isinstance(t_unpack, UnpackType)
+            if isinstance(t_unpack.type, TypeVarTupleType):
+                # Set TypeVarTuple to empty to improve error messages.
+                return [
+                    Constraint(
+                        t_unpack.type, direction, TupleType([], t_unpack.type.tuple_fallback)
+                    )
+                ]
+            else:
+                return []
+        common_prefix = template_prefix
+        common_suffix = template_suffix
+    else:
+        actual_prefix = actual_unpack
+        actual_suffix = len(actual_args) - actual_prefix - 1
+        common_prefix = min(template_prefix, actual_prefix)
+        common_suffix = min(template_suffix, actual_suffix)
+        if actual_prefix >= template_prefix and actual_suffix >= template_suffix:
+            # This is the only case where we can guarantee there will be no partial overlap
+            # (note however partial overlap is OK for variadic tuples, it is handled below).
+            t_unpack = template_args[template_unpack]
+
+    # Handle constraints from prefixes/suffixes first.
+    start, middle, end = split_with_prefix_and_suffix(
+        tuple(actual_args), common_prefix, common_suffix
+    )
+    for t, a in zip(template_args[:common_prefix], start):
+        res.extend(infer_constraints(t, a, direction))
+    if common_suffix:
+        for t, a in zip(template_args[-common_suffix:], end):
+            res.extend(infer_constraints(t, a, direction))
+
+    if t_unpack is not None:
+        # Add constraint(s) for variadic item when possible.
+        assert isinstance(t_unpack, UnpackType)
+        tp = get_proper_type(t_unpack.type)
+        if isinstance(tp, Instance) and tp.type.fullname == "builtins.tuple":
+            # Homogeneous case *tuple[T, ...] <: [X, Y, Z, ...].
+            for a in middle:
+                # TODO: should we use union instead of join here?
+                if not isinstance(a, UnpackType):
+                    res.extend(infer_constraints(tp.args[0], a, direction))
+                else:
+                    a_tp = get_proper_type(a.type)
+                    # This is the case *tuple[T, ...] <: *tuple[A, ...].
+                    if isinstance(a_tp, Instance) and a_tp.type.fullname == "builtins.tuple":
+                        res.extend(infer_constraints(tp.args[0], a_tp.args[0], direction))
+        elif isinstance(tp, TypeVarTupleType):
+            res.append(Constraint(tp, direction, TupleType(list(middle), tp.tuple_fallback)))
+    elif actual_unpack is not None:
+        # A special case for a variadic tuple unpack, we simply infer T <: X from
+        # Tuple[..., *tuple[T, ...], ...] <: Tuple[..., *tuple[X, ...], ...].
+        actual_unpack_type = actual_args[actual_unpack]
+        assert isinstance(actual_unpack_type, UnpackType)
+        a_unpacked = get_proper_type(actual_unpack_type.type)
+        if isinstance(a_unpacked, Instance) and a_unpacked.type.fullname == "builtins.tuple":
+            t_unpack = template_args[template_unpack]
+            assert isinstance(t_unpack, UnpackType)
+            tp = get_proper_type(t_unpack.type)
+            if isinstance(tp, Instance) and tp.type.fullname == "builtins.tuple":
+                res.extend(infer_constraints(tp.args[0], a_unpacked.args[0], direction))
+    return res
+
+
+def infer_directed_arg_constraints(left: Type, right: Type, direction: int) -> list[Constraint]:
+    """Infer constraints between two arguments using direction between original callables."""
+    if isinstance(left, (ParamSpecType, UnpackType)) or isinstance(
+        right, (ParamSpecType, UnpackType)
+    ):
+        # This avoids bogus constraints like T <: P.args
+        # TODO: can we infer something useful for *T vs P?
+        return []
+    if direction == SUBTYPE_OF:
+        # We invert direction to account for argument contravariance.
+        return infer_constraints(left, right, neg_op(direction))
+    else:
+        return infer_constraints(right, left, neg_op(direction))
+
+
+def infer_callable_arguments_constraints(
+    template: NormalizedCallableType | Parameters,
+    actual: NormalizedCallableType | Parameters,
+    direction: int,
+) -> list[Constraint]:
+    """Infer constraints between argument types of two callables.
+
+    This function essentially extracts four steps from are_parameters_compatible() in
+    subtypes.py that involve subtype checks between argument types. We keep the argument
+    matching logic, but ignore various strictness flags present there, and checks that
+    do not involve subtyping. Then in place of every subtype check we put an infer_constraints()
+    call for the same types.
+    """
+    res = []
+    if direction == SUBTYPE_OF:
+        left, right = template, actual
+    else:
+        left, right = actual, template
+    left_star = left.var_arg()
+    left_star2 = left.kw_arg()
+    right_star = right.var_arg()
+    right_star2 = right.kw_arg()
+
+    # Numbering of steps below matches the one in are_parameters_compatible() for convenience.
+    # Phase 1a: compare star vs star arguments.
+    if left_star is not None and right_star is not None:
+        res.extend(infer_directed_arg_constraints(left_star.typ, right_star.typ, direction))
+    if left_star2 is not None and right_star2 is not None:
+        res.extend(infer_directed_arg_constraints(left_star2.typ, right_star2.typ, direction))
+
+    # Phase 1b: compare left args with corresponding non-star right arguments.
+    for right_arg in right.formal_arguments():
+        left_arg = mypy.typeops.callable_corresponding_argument(left, right_arg)
+        if left_arg is None:
+            continue
+        res.extend(infer_directed_arg_constraints(left_arg.typ, right_arg.typ, direction))
+
+    # Phase 1c: compare left args with right *args.
+    if right_star is not None:
+        right_by_position = right.try_synthesizing_arg_from_vararg(None)
+        assert right_by_position is not None
+        i = right_star.pos
+        assert i is not None
+        while i < len(left.arg_kinds) and left.arg_kinds[i].is_positional():
+            left_by_position = left.argument_by_position(i)
+            assert left_by_position is not None
+            res.extend(
+                infer_directed_arg_constraints(
+                    left_by_position.typ, right_by_position.typ, direction
+                )
+            )
+            i += 1
+
+    # Phase 1d: compare left args with right **kwargs.
+    if right_star2 is not None:
+        right_names = {name for name in right.arg_names if name is not None}
+        left_only_names = set()
+        for name, kind in zip(left.arg_names, left.arg_kinds):
+            if name is None or kind.is_star() or name in right_names:
+                continue
+            left_only_names.add(name)
+
+        right_by_name = right.try_synthesizing_arg_from_kwarg(None)
+        assert right_by_name is not None
+        for name in left_only_names:
+            left_by_name = left.argument_by_name(name)
+            assert left_by_name is not None
+            res.extend(
+                infer_directed_arg_constraints(left_by_name.typ, right_by_name.typ, direction)
+            )
+    return res
+
+
+def filter_imprecise_kinds(cs: list[Constraint]) -> list[Constraint]:
+    """For each ParamSpec remove all imprecise constraints, if at least one precise available."""
+    have_precise = set()
+    for c in cs:
+        if not isinstance(c.origin_type_var, ParamSpecType):
+            continue
+        if (
+            isinstance(c.target, ParamSpecType)
+            or isinstance(c.target, Parameters)
+            and not c.target.imprecise_arg_kinds
+        ):
+            have_precise.add(c.type_var)
+    new_cs = []
+    for c in cs:
+        if not isinstance(c.origin_type_var, ParamSpecType) or c.type_var not in have_precise:
+            new_cs.append(c)
+        if not isinstance(c.target, Parameters) or not c.target.imprecise_arg_kinds:
+            new_cs.append(c)
+    return new_cs

micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/mypy-1.20.2-py314h5a2d7ad_0/Lib/site-packages/mypy/copytype.py

@@ -0,0 +1,134 @@
+from __future__ import annotations
+
+from typing import Any, cast
+
+from mypy.types import (
+    AnyType,
+    CallableType,
+    DeletedType,
+    ErasedType,
+    Instance,
+    LiteralType,
+    NoneType,
+    Overloaded,
+    Parameters,
+    ParamSpecType,
+    PartialType,
+    ProperType,
+    TupleType,
+    TypeAliasType,
+    TypedDictType,
+    TypeType,
+    TypeVarTupleType,
+    TypeVarType,
+    UnboundType,
+    UninhabitedType,
+    UnionType,
+    UnpackType,
+)
+
+# type_visitor needs to be imported after types
+from mypy.type_visitor import TypeVisitor  # ruff: isort: skip
+
+
+def copy_type(t: ProperType) -> ProperType:
+    """Create a shallow copy of a type.
+
+    This can be used to mutate the copy with truthiness information.
+
+    Classes compiled with mypyc don't support copy.copy(), so we need
+    a custom implementation.
+    """
+    return t.accept(TypeShallowCopier())
+
+
+class TypeShallowCopier(TypeVisitor[ProperType]):
+    def visit_unbound_type(self, t: UnboundType) -> ProperType:
+        return t
+
+    def visit_any(self, t: AnyType) -> ProperType:
+        return self.copy_common(t, AnyType(t.type_of_any, t.source_any, t.missing_import_name))
+
+    def visit_none_type(self, t: NoneType) -> ProperType:
+        return self.copy_common(t, NoneType())
+
+    def visit_uninhabited_type(self, t: UninhabitedType) -> ProperType:
+        dup = UninhabitedType()
+        dup.ambiguous = t.ambiguous
+        return self.copy_common(t, dup)
+
+    def visit_erased_type(self, t: ErasedType) -> ProperType:
+        return self.copy_common(t, ErasedType())
+
+    def visit_deleted_type(self, t: DeletedType) -> ProperType:
+        return self.copy_common(t, DeletedType(t.source))
+
+    def visit_instance(self, t: Instance) -> ProperType:
+        dup = Instance(t.type, t.args, last_known_value=t.last_known_value)
+        return self.copy_common(t, dup)
+
+    def visit_type_var(self, t: TypeVarType) -> ProperType:
+        return self.copy_common(t, t.copy_modified())
+
+    def visit_param_spec(self, t: ParamSpecType) -> ProperType:
+        dup = ParamSpecType(
+            t.name, t.fullname, t.id, t.flavor, t.upper_bound, t.default, prefix=t.prefix
+        )
+        return self.copy_common(t, dup)
+
+    def visit_parameters(self, t: Parameters) -> ProperType:
+        dup = Parameters(
+            t.arg_types,
+            t.arg_kinds,
+            t.arg_names,
+            variables=t.variables,
+            is_ellipsis_args=t.is_ellipsis_args,
+        )
+        return self.copy_common(t, dup)
+
+    def visit_type_var_tuple(self, t: TypeVarTupleType) -> ProperType:
+        dup = TypeVarTupleType(
+            t.name, t.fullname, t.id, t.upper_bound, t.tuple_fallback, t.default
+        )
+        return self.copy_common(t, dup)
+
+    def visit_unpack_type(self, t: UnpackType) -> ProperType:
+        dup = UnpackType(t.type)
+        return self.copy_common(t, dup)
+
+    def visit_partial_type(self, t: PartialType) -> ProperType:
+        return self.copy_common(t, PartialType(t.type, t.var, t.value_type))
+
+    def visit_callable_type(self, t: CallableType) -> ProperType:
+        return self.copy_common(t, t.copy_modified())
+
+    def visit_tuple_type(self, t: TupleType) -> ProperType:
+        return self.copy_common(t, TupleType(t.items, t.partial_fallback, implicit=t.implicit))
+
+    def visit_typeddict_type(self, t: TypedDictType) -> ProperType:
+        return self.copy_common(
+            t, TypedDictType(t.items, t.required_keys, t.readonly_keys, t.fallback)
+        )
+
+    def visit_literal_type(self, t: LiteralType) -> ProperType:
+        return self.copy_common(t, LiteralType(value=t.value, fallback=t.fallback))
+
+    def visit_union_type(self, t: UnionType) -> ProperType:
+        return self.copy_common(t, UnionType(t.items))
+
+    def visit_overloaded(self, t: Overloaded) -> ProperType:
+        return self.copy_common(t, Overloaded(items=t.items))
+
+    def visit_type_type(self, t: TypeType) -> ProperType:
+        # Use cast since the type annotations in TypeType are imprecise.
+        return self.copy_common(t, TypeType(cast(Any, t.item), is_type_form=t.is_type_form))
+
+    def visit_type_alias_type(self, t: TypeAliasType) -> ProperType:
+        assert False, "only ProperTypes supported"
+
+    def copy_common(self, t: ProperType, t2: ProperType) -> ProperType:
+        t2.line = t.line
+        t2.column = t.column
+        t2.can_be_false = t.can_be_false
+        t2.can_be_true = t.can_be_true
+        return t2

micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/mypy-1.20.2-py314h5a2d7ad_0/Lib/site-packages/mypy/defaults.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+import os
+from typing import Final
+
+# Earliest fully supported Python 3.x version. Used as the default Python
+# version in tests. Mypy wheels should be built starting with this version,
+# and CI tests should be run on this version (and later versions).
+PYTHON3_VERSION: Final = (3, 10)
+
+# Earliest Python 3.x version supported via --python-version 3.x. To run
+# mypy, at least version PYTHON3_VERSION is needed.
+PYTHON3_VERSION_MIN: Final = (3, 9)  # Keep in sync with typeshed's python support
+
+CACHE_DIR: Final = ".mypy_cache"
+
+CONFIG_NAMES: Final = ["mypy.ini", ".mypy.ini"]
+SHARED_CONFIG_NAMES: Final = ["pyproject.toml", "setup.cfg"]
+
+USER_CONFIG_FILES: list[str] = ["~/.config/mypy/config", "~/.mypy.ini"]
+if os.environ.get("XDG_CONFIG_HOME"):
+    USER_CONFIG_FILES.insert(0, os.path.join(os.environ["XDG_CONFIG_HOME"], "mypy/config"))
+USER_CONFIG_FILES = [os.path.expanduser(f) for f in USER_CONFIG_FILES]
+
+# This must include all reporters defined in mypy.report. This is defined here
+# to make reporter names available without importing mypy.report -- this speeds
+# up startup.
+REPORTER_NAMES: Final = [
+    "linecount",
+    "any-exprs",
+    "linecoverage",
+    "memory-xml",
+    "cobertura-xml",
+    "xml",
+    "xslt-html",
+    "xslt-txt",
+    "html",
+    "txt",
+    "lineprecision",
+]
+
+# Threshold after which we sometimes filter out most errors to avoid very
+# verbose output. The default is to show all errors.
+MANY_ERRORS_THRESHOLD: Final = -1
+
+RECURSION_LIMIT: Final = 2**14
+
+WORKER_START_INTERVAL: Final = 0.01
+WORKER_START_TIMEOUT: Final = 3
+WORKER_CONNECTION_TIMEOUT: Final = 10
+WORKER_DONE_TIMEOUT: Final = 600

micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/mypy-1.20.2-py314h5a2d7ad_0/Lib/site-packages/mypy/dmypy_os.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+import sys
+from collections.abc import Callable
+from typing import Any
+
+if sys.platform == "win32":
+    import ctypes
+    import subprocess
+    from ctypes.wintypes import DWORD, HANDLE
+
+    PROCESS_QUERY_LIMITED_INFORMATION = ctypes.c_ulong(0x1000)
+
+    kernel32 = ctypes.windll.kernel32
+    OpenProcess: Callable[[DWORD, int, int], HANDLE] = kernel32.OpenProcess
+    GetExitCodeProcess: Callable[[HANDLE, Any], int] = kernel32.GetExitCodeProcess
+else:
+    import os
+    import signal
+
+
+def alive(pid: int) -> bool:
+    """Is the process alive?"""
+    if sys.platform == "win32":
+        # why can't anything be easy...
+        status = DWORD()
+        handle = OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, 0, pid)
+        GetExitCodeProcess(handle, ctypes.byref(status))
+        return status.value == 259  # STILL_ACTIVE
+    else:
+        try:
+            os.kill(pid, 0)
+        except OSError:
+            return False
+        return True
+
+
+def kill(pid: int) -> None:
+    """Kill the process."""
+    if sys.platform == "win32":
+        subprocess.check_output(f"taskkill /pid {pid} /f /t")
+    else:
+        os.kill(pid, signal.SIGKILL)