Add files using upload-large-folder tool

micromamba_root/Lib/site-packages/mypy-1.20.2.dist-info/INSTALLER

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

micromamba_root/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/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/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/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/Lib/site-packages/mypy-1.20.2.dist-info/top_level.txt

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

micromamba_root/Lib/site-packages/mypy/__init__.py

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

micromamba_root/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/Lib/site-packages/mypy/error_formatter.py

@@ -0,0 +1,39 @@
+"""Defines the different custom formats in which mypy can output."""
+
+import json
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from mypy.errors import MypyError
+
+
+class ErrorFormatter(ABC):
+    """Base class to define how errors are formatted before being printed."""
+
+    @abstractmethod
+    def report_error(self, error: "MypyError") -> str:
+        raise NotImplementedError
+
+
+class JSONFormatter(ErrorFormatter):
+    """Formatter for basic JSON output format."""
+
+    def report_error(self, error: "MypyError") -> str:
+        """Prints out the errors as simple, static JSON lines."""
+        return json.dumps(
+            {
+                "file": error.file_path,
+                "line": error.line,
+                "column": error.column,
+                "end_line": error.end_line,
+                "end_column": error.end_column,
+                "message": error.message,
+                "hint": None if len(error.hints) == 0 else "\n".join(error.hints),
+                "code": error.errorcode,
+                "severity": error.severity,
+            }
+        )
+
+
+OUTPUT_CHOICES = {"json": JSONFormatter()}

micromamba_root/Lib/site-packages/mypy/evalexpr.py

@@ -0,0 +1,211 @@
+"""
+
+Evaluate an expression.
+
+Used by stubtest; in a separate file because things break if we don't
+put it in a mypyc-compiled file.
+
+"""
+
+import ast
+from typing import Final
+
+import mypy.nodes
+from mypy.visitor import ExpressionVisitor
+
+UNKNOWN = object()
+
+
+class _NodeEvaluator(ExpressionVisitor[object]):
+    def visit_int_expr(self, o: mypy.nodes.IntExpr) -> int:
+        return o.value
+
+    def visit_str_expr(self, o: mypy.nodes.StrExpr) -> str:
+        return o.value
+
+    def visit_bytes_expr(self, o: mypy.nodes.BytesExpr) -> object:
+        # The value of a BytesExpr is a string created from the repr()
+        # of the bytes object. Get the original bytes back.
+        try:
+            return ast.literal_eval(f"b'{o.value}'")
+        except SyntaxError:
+            return ast.literal_eval(f'b"{o.value}"')
+
+    def visit_float_expr(self, o: mypy.nodes.FloatExpr) -> float:
+        return o.value
+
+    def visit_complex_expr(self, o: mypy.nodes.ComplexExpr) -> object:
+        return o.value
+
+    def visit_ellipsis(self, o: mypy.nodes.EllipsisExpr) -> object:
+        return Ellipsis
+
+    def visit_star_expr(self, o: mypy.nodes.StarExpr) -> object:
+        return UNKNOWN
+
+    def visit_name_expr(self, o: mypy.nodes.NameExpr) -> object:
+        if o.name == "True":
+            return True
+        elif o.name == "False":
+            return False
+        elif o.name == "None":
+            return None
+        # TODO: Handle more names by figuring out a way to hook into the
+        # symbol table.
+        return UNKNOWN
+
+    def visit_member_expr(self, o: mypy.nodes.MemberExpr) -> object:
+        return UNKNOWN
+
+    def visit_yield_from_expr(self, o: mypy.nodes.YieldFromExpr) -> object:
+        return UNKNOWN
+
+    def visit_yield_expr(self, o: mypy.nodes.YieldExpr) -> object:
+        return UNKNOWN
+
+    def visit_call_expr(self, o: mypy.nodes.CallExpr) -> object:
+        return UNKNOWN
+
+    def visit_op_expr(self, o: mypy.nodes.OpExpr) -> object:
+        return UNKNOWN
+
+    def visit_comparison_expr(self, o: mypy.nodes.ComparisonExpr) -> object:
+        return UNKNOWN
+
+    def visit_cast_expr(self, o: mypy.nodes.CastExpr) -> object:
+        return o.expr.accept(self)
+
+    def visit_type_form_expr(self, o: mypy.nodes.TypeFormExpr) -> object:
+        return UNKNOWN
+
+    def visit_assert_type_expr(self, o: mypy.nodes.AssertTypeExpr) -> object:
+        return o.expr.accept(self)
+
+    def visit_reveal_expr(self, o: mypy.nodes.RevealExpr) -> object:
+        return UNKNOWN
+
+    def visit_super_expr(self, o: mypy.nodes.SuperExpr) -> object:
+        return UNKNOWN
+
+    def visit_unary_expr(self, o: mypy.nodes.UnaryExpr) -> object:
+        operand = o.expr.accept(self)
+        if operand is UNKNOWN:
+            return UNKNOWN
+        if o.op == "-":
+            if isinstance(operand, (int, float, complex)):
+                return -operand
+        elif o.op == "+":
+            if isinstance(operand, (int, float, complex)):
+                return +operand
+        elif o.op == "~":
+            if isinstance(operand, int):
+                return ~operand
+        elif o.op == "not":
+            if isinstance(operand, (bool, int, float, str, bytes)):
+                return not operand
+        return UNKNOWN
+
+    def visit_assignment_expr(self, o: mypy.nodes.AssignmentExpr) -> object:
+        return o.value.accept(self)
+
+    def visit_list_expr(self, o: mypy.nodes.ListExpr) -> object:
+        items = [item.accept(self) for item in o.items]
+        if all(item is not UNKNOWN for item in items):
+            return items
+        return UNKNOWN
+
+    def visit_dict_expr(self, o: mypy.nodes.DictExpr) -> object:
+        items = [
+            (UNKNOWN if key is None else key.accept(self), value.accept(self))
+            for key, value in o.items
+        ]
+        if all(key is not UNKNOWN and value is not None for key, value in items):
+            return dict(items)
+        return UNKNOWN
+
+    def visit_tuple_expr(self, o: mypy.nodes.TupleExpr) -> object:
+        items = [item.accept(self) for item in o.items]
+        if all(item is not UNKNOWN for item in items):
+            return tuple(items)
+        return UNKNOWN
+
+    def visit_set_expr(self, o: mypy.nodes.SetExpr) -> object:
+        items = [item.accept(self) for item in o.items]
+        if all(item is not UNKNOWN for item in items):
+            return set(items)
+        return UNKNOWN
+
+    def visit_index_expr(self, o: mypy.nodes.IndexExpr) -> object:
+        return UNKNOWN
+
+    def visit_type_application(self, o: mypy.nodes.TypeApplication) -> object:
+        return UNKNOWN
+
+    def visit_lambda_expr(self, o: mypy.nodes.LambdaExpr) -> object:
+        return UNKNOWN
+
+    def visit_list_comprehension(self, o: mypy.nodes.ListComprehension) -> object:
+        return UNKNOWN
+
+    def visit_set_comprehension(self, o: mypy.nodes.SetComprehension) -> object:
+        return UNKNOWN
+
+    def visit_dictionary_comprehension(self, o: mypy.nodes.DictionaryComprehension) -> object:
+        return UNKNOWN
+
+    def visit_generator_expr(self, o: mypy.nodes.GeneratorExpr) -> object:
+        return UNKNOWN
+
+    def visit_slice_expr(self, o: mypy.nodes.SliceExpr) -> object:
+        return UNKNOWN
+
+    def visit_conditional_expr(self, o: mypy.nodes.ConditionalExpr) -> object:
+        return UNKNOWN
+
+    def visit_type_var_expr(self, o: mypy.nodes.TypeVarExpr) -> object:
+        return UNKNOWN
+
+    def visit_paramspec_expr(self, o: mypy.nodes.ParamSpecExpr) -> object:
+        return UNKNOWN
+
+    def visit_type_var_tuple_expr(self, o: mypy.nodes.TypeVarTupleExpr) -> object:
+        return UNKNOWN
+
+    def visit_type_alias_expr(self, o: mypy.nodes.TypeAliasExpr) -> object:
+        return UNKNOWN
+
+    def visit_namedtuple_expr(self, o: mypy.nodes.NamedTupleExpr) -> object:
+        return UNKNOWN
+
+    def visit_enum_call_expr(self, o: mypy.nodes.EnumCallExpr) -> object:
+        return UNKNOWN
+
+    def visit_typeddict_expr(self, o: mypy.nodes.TypedDictExpr) -> object:
+        return UNKNOWN
+
+    def visit_newtype_expr(self, o: mypy.nodes.NewTypeExpr) -> object:
+        return UNKNOWN
+
+    def visit__promote_expr(self, o: mypy.nodes.PromoteExpr) -> object:
+        return UNKNOWN
+
+    def visit_await_expr(self, o: mypy.nodes.AwaitExpr) -> object:
+        return UNKNOWN
+
+    def visit_template_str_expr(self, o: mypy.nodes.TemplateStrExpr) -> object:
+        return UNKNOWN
+
+    def visit_temp_node(self, o: mypy.nodes.TempNode) -> object:
+        return UNKNOWN
+
+
+_evaluator: Final = _NodeEvaluator()
+
+
+def evaluate_expression(expr: mypy.nodes.Expression) -> object:
+    """Evaluate an expression at runtime.
+
+    Return the result of the expression, or UNKNOWN if the expression cannot be
+    evaluated.
+    """
+    return expr.accept(_evaluator)

micromamba_root/Lib/site-packages/mypy/expandtype.py

@@ -0,0 +1,662 @@
+from __future__ import annotations
+
+from collections.abc import Iterable, Mapping
+from typing import Final, TypeVar, cast, overload
+
+from mypy.nodes import ARG_STAR, ArgKind, FakeInfo, Var
+from mypy.state import state
+from mypy.types import (
+    ANY_STRATEGY,
+    AnyType,
+    BoolTypeQuery,
+    CallableType,
+    DeletedType,
+    ErasedType,
+    FunctionLike,
+    Instance,
+    LiteralType,
+    NoneType,
+    Overloaded,
+    Parameters,
+    ParamSpecFlavor,
+    ParamSpecType,
+    PartialType,
+    ProperType,
+    TrivialSyntheticTypeTranslator,
+    TupleType,
+    Type,
+    TypeAliasType,
+    TypedDictType,
+    TypeOfAny,
+    TypeType,
+    TypeVarId,
+    TypeVarLikeType,
+    TypeVarTupleType,
+    TypeVarType,
+    UnboundType,
+    UninhabitedType,
+    UnionType,
+    UnpackType,
+    flatten_nested_unions,
+    get_proper_type,
+    split_with_prefix_and_suffix,
+)
+from mypy.typevartuples import split_with_instance
+
+# Solving the import cycle:
+import mypy.type_visitor  # ruff: isort: skip
+
+# WARNING: these functions should never (directly or indirectly) depend on
+# is_subtype(), meet_types(), join_types() etc.
+# TODO: add a static dependency test for this.
+
+
+@overload
+def expand_type(typ: CallableType, env: Mapping[TypeVarId, Type]) -> CallableType: ...
+
+
+@overload
+def expand_type(typ: ProperType, env: Mapping[TypeVarId, Type]) -> ProperType: ...
+
+
+@overload
+def expand_type(typ: Type, env: Mapping[TypeVarId, Type]) -> Type: ...
+
+
+def expand_type(typ: Type, env: Mapping[TypeVarId, Type]) -> Type:
+    """Substitute any type variable references in a type given by a type
+    environment.
+    """
+    return typ.accept(ExpandTypeVisitor(env))
+
+
+@overload
+def expand_type_by_instance(typ: CallableType, instance: Instance) -> CallableType: ...
+
+
+@overload
+def expand_type_by_instance(typ: ProperType, instance: Instance) -> ProperType: ...
+
+
+@overload
+def expand_type_by_instance(typ: Type, instance: Instance) -> Type: ...
+
+
+def expand_type_by_instance(typ: Type, instance: Instance) -> Type:
+    """Substitute type variables in type using values from an Instance.
+    Type variables are considered to be bound by the class declaration."""
+    if not instance.args and not instance.type.has_type_var_tuple_type:
+        return typ
+    else:
+        variables: dict[TypeVarId, Type] = {}
+        if instance.type.has_type_var_tuple_type:
+            assert instance.type.type_var_tuple_prefix is not None
+            assert instance.type.type_var_tuple_suffix is not None
+
+            args_prefix, args_middle, args_suffix = split_with_instance(instance)
+            tvars_prefix, tvars_middle, tvars_suffix = split_with_prefix_and_suffix(
+                tuple(instance.type.defn.type_vars),
+                instance.type.type_var_tuple_prefix,
+                instance.type.type_var_tuple_suffix,
+            )
+            tvar = tvars_middle[0]
+            assert isinstance(tvar, TypeVarTupleType)
+            variables = {tvar.id: TupleType(list(args_middle), tvar.tuple_fallback)}
+            instance_args = args_prefix + args_suffix
+            tvars = tvars_prefix + tvars_suffix
+        else:
+            tvars = tuple(instance.type.defn.type_vars)
+            instance_args = instance.args
+
+        for binder, arg in zip(tvars, instance_args):
+            assert isinstance(binder, TypeVarLikeType)
+            variables[binder.id] = arg
+
+        return expand_type(typ, variables)
+
+
+F = TypeVar("F", bound=FunctionLike)
+
+
+def freshen_function_type_vars(callee: F) -> F:
+    """Substitute fresh type variables for generic function type variables."""
+    if isinstance(callee, CallableType):
+        if not callee.is_generic():
+            return callee
+        tvs = []
+        tvmap: dict[TypeVarId, Type] = {}
+        for v in callee.variables:
+            tv = v.new_unification_variable(v)
+            tvs.append(tv)
+            tvmap[v.id] = tv
+        fresh = expand_type(callee, tvmap).copy_modified(variables=tvs)
+        return cast(F, fresh)
+    else:
+        assert isinstance(callee, Overloaded)
+        fresh_overload = Overloaded([freshen_function_type_vars(item) for item in callee.items])
+        return cast(F, fresh_overload)
+
+
+class HasGenericCallable(BoolTypeQuery):
+    def __init__(self) -> None:
+        super().__init__(ANY_STRATEGY)
+
+    def visit_callable_type(self, t: CallableType) -> bool:
+        return t.is_generic() or super().visit_callable_type(t)
+
+
+# Share a singleton since this is performance sensitive
+has_generic_callable: Final = HasGenericCallable()
+
+
+T = TypeVar("T", bound=Type)
+
+
+def freshen_all_functions_type_vars(t: T) -> T:
+    result: Type
+    has_generic_callable.reset()
+    if not t.accept(has_generic_callable):
+        return t  # Fast path to avoid expensive freshening
+    else:
+        result = t.accept(FreshenCallableVisitor())
+        assert isinstance(result, type(t))
+        return result
+
+
+class FreshenCallableVisitor(mypy.type_visitor.TypeTranslator):
+    def visit_callable_type(self, t: CallableType) -> Type:
+        result = super().visit_callable_type(t)
+        assert isinstance(result, ProperType) and isinstance(result, CallableType)
+        return freshen_function_type_vars(result)
+
+    def visit_type_alias_type(self, t: TypeAliasType) -> Type:
+        # Same as for ExpandTypeVisitor
+        return t.copy_modified(args=[arg.accept(self) for arg in t.args])
+
+
+class ExpandTypeVisitor(TrivialSyntheticTypeTranslator):
+    """Visitor that substitutes type variables with values."""
+
+    variables: Mapping[TypeVarId, Type]  # TypeVar id -> TypeVar value
+
+    def __init__(self, variables: Mapping[TypeVarId, Type]) -> None:
+        super().__init__()
+        self.variables = variables
+        self.recursive_tvar_guard: dict[TypeVarId, Type | None] | None = None
+
+    def visit_unbound_type(self, t: UnboundType) -> Type:
+        return t
+
+    def visit_any(self, t: AnyType) -> Type:
+        return t
+
+    def visit_none_type(self, t: NoneType) -> Type:
+        return t
+
+    def visit_uninhabited_type(self, t: UninhabitedType) -> Type:
+        return t
+
+    def visit_deleted_type(self, t: DeletedType) -> Type:
+        return t
+
+    def visit_erased_type(self, t: ErasedType) -> Type:
+        # This may happen during type inference if some function argument
+        # type is a generic callable, and its erased form will appear in inferred
+        # constraints, then solver may check subtyping between them, which will trigger
+        # unify_generic_callables(), this is why we can get here. Another example is
+        # when inferring type of lambda in generic context, the lambda body contains
+        # a generic method in generic class.
+        return t
+
+    def visit_instance(self, t: Instance) -> Type:
+        if len(t.args) == 0:
+            return t
+
+        args = self.expand_type_tuple_with_unpack(t.args)
+
+        if isinstance(t.type, FakeInfo):
+            # The type checker expands function definitions and bodies
+            # if they depend on constrained type variables but the body
+            # might contain a tuple type comment (e.g., # type: (int, float)),
+            # in which case 't.type' is not yet available.
+            #
+            # See: https://github.com/python/mypy/issues/16649
+            return t.copy_modified(args=args)
+
+        if t.type.fullname == "builtins.tuple":
+            # Normalize Tuple[*Tuple[X, ...], ...] -> Tuple[X, ...]
+            arg = args[0]
+            if isinstance(arg, UnpackType):
+                unpacked = get_proper_type(arg.type)
+                if isinstance(unpacked, Instance):
+                    # TODO: this and similar asserts below may be unsafe because get_proper_type()
+                    # may be called during semantic analysis before all invalid types are removed.
+                    assert unpacked.type.fullname == "builtins.tuple"
+                    args = list(unpacked.args)
+        return t.copy_modified(args=args)
+
+    def visit_type_var(self, t: TypeVarType) -> Type:
+        # Normally upper bounds can't contain other type variables, the only exception is
+        # special type variable Self`0 <: C[T, S], where C is the class where Self is used.
+        if t.id.is_self():
+            t = t.copy_modified(upper_bound=t.upper_bound.accept(self))
+        repl = self.variables.get(t.id, t)
+        if isinstance(repl, ProperType) and isinstance(repl, Instance):
+            # TODO: do we really need to do this?
+            # If I try to remove this special-casing ~40 tests fail on reveal_type().
+            return repl.copy_modified(last_known_value=None)
+        if isinstance(repl, TypeVarType) and repl.has_default():
+            if self.recursive_tvar_guard is None:
+                self.recursive_tvar_guard = {}
+            if (tvar_id := repl.id) in self.recursive_tvar_guard:
+                return self.recursive_tvar_guard[tvar_id] or repl
+            self.recursive_tvar_guard[tvar_id] = None
+            repl.default = repl.default.accept(self)
+            expanded = repl.accept(self)  # Note: `expanded is repl` may be true.
+            repl = repl if isinstance(expanded, TypeVarType) else expanded
+            self.recursive_tvar_guard[tvar_id] = repl
+        return repl
+
+    def visit_param_spec(self, t: ParamSpecType) -> Type:
+        # Set prefix to something empty, so we don't duplicate it below.
+        repl = self.variables.get(t.id, t.copy_modified(prefix=Parameters([], [], [])))
+        if isinstance(repl, ParamSpecType):
+            return repl.copy_modified(
+                flavor=t.flavor,
+                prefix=t.prefix.copy_modified(
+                    arg_types=self.expand_types(t.prefix.arg_types) + repl.prefix.arg_types,
+                    arg_kinds=t.prefix.arg_kinds + repl.prefix.arg_kinds,
+                    arg_names=t.prefix.arg_names + repl.prefix.arg_names,
+                ),
+            )
+        elif isinstance(repl, Parameters):
+            assert isinstance(t.upper_bound, ProperType) and isinstance(t.upper_bound, Instance)
+            if t.flavor == ParamSpecFlavor.BARE:
+                return Parameters(
+                    self.expand_types(t.prefix.arg_types) + repl.arg_types,
+                    t.prefix.arg_kinds + repl.arg_kinds,
+                    t.prefix.arg_names + repl.arg_names,
+                    variables=[*t.prefix.variables, *repl.variables],
+                    imprecise_arg_kinds=repl.imprecise_arg_kinds,
+                )
+            elif t.flavor == ParamSpecFlavor.ARGS:
+                assert all(k.is_positional() for k in t.prefix.arg_kinds)
+                return self._possible_callable_varargs(
+                    repl, list(t.prefix.arg_types), t.upper_bound
+                )
+            else:
+                assert t.flavor == ParamSpecFlavor.KWARGS
+                return self._possible_callable_kwargs(repl, t.upper_bound)
+        else:
+            # We could encode Any as trivial parameters etc., but it would be too verbose.
+            # TODO: assert this is a trivial type, like Any, Never, or object.
+            return repl
+
+    @classmethod
+    def _possible_callable_varargs(
+        cls, repl: Parameters, required_prefix: list[Type], tuple_type: Instance
+    ) -> ProperType:
+        """Given a callable, extract all parameters that can be passed as `*args`.
+
+        This builds a union of all (possibly variadic) tuples representing all possible
+        argument sequences that can be passed positionally. Each such tuple starts with
+        all required (pos-only without a default) arguments, followed by some prefix
+        of other arguments that can be passed positionally.
+        """
+        required_posargs = required_prefix
+        if repl.variables:
+            # We will tear the callable apart, do not leak type variables
+            return tuple_type
+        optional_posargs: list[Type] = []
+        for kind, name, type in zip(repl.arg_kinds, repl.arg_names, repl.arg_types):
+            if kind == ArgKind.ARG_POS and name is None:
+                if optional_posargs:
+                    # May happen following Unpack expansion without kinds correction
+                    required_posargs += optional_posargs
+                    optional_posargs = []
+                required_posargs.append(type)
+            elif kind.is_positional():
+                optional_posargs.append(type)
+            elif kind == ArgKind.ARG_STAR:
+                if isinstance(type, UnpackType):
+                    optional_posargs.append(type)
+                else:
+                    optional_posargs.append(UnpackType(Instance(tuple_type.type, [type])))
+                break
+        return UnionType.make_union(
+            [
+                TupleType(required_posargs + optional_posargs[:i], fallback=tuple_type)
+                for i in range(len(optional_posargs) + 1)
+            ]
+        )
+
+    @classmethod
+    def _possible_callable_kwargs(cls, repl: Parameters, dict_type: Instance) -> ProperType:
+        """Given a callable, extract all parameters that can be passed as `**kwargs`.
+
+        If the function only accepts **kwargs, this will be a `dict[str, KwargsValueType]`.
+        Otherwise, this will be a `TypedDict` containing all explicit args and ignoring
+        `**kwargs` (until PEP 728 `extra_items` is supported). TypedDict entries will
+        be required iff the corresponding argument is kw-only and has no default.
+        """
+        if repl.variables:
+            # We will tear the callable apart, do not leak type variables
+            return dict_type
+        kwargs = {}
+        required_names = set()
+        extra_items: Type = UninhabitedType()
+        for kind, name, type in zip(repl.arg_kinds, repl.arg_names, repl.arg_types):
+            if kind == ArgKind.ARG_NAMED and name is not None:
+                kwargs[name] = type
+                required_names.add(name)
+            elif kind == ArgKind.ARG_STAR2:
+                # Unpack[TypedDict] is normalized early, it isn't stored as Unpack
+                extra_items = type
+            elif not kind.is_star() and name is not None:
+                kwargs[name] = type
+        if not kwargs:
+            return Instance(dict_type.type, [dict_type.args[0], extra_items])
+        # TODO: when PEP 728 is implemented, pass extra_items below.
+        return TypedDictType(kwargs, required_names, set(), fallback=dict_type)
+
+    def visit_type_var_tuple(self, t: TypeVarTupleType) -> Type:
+        # Sometimes solver may need to expand a type variable with (a copy of) itself
+        # (usually together with other TypeVars, but it is hard to filter out TypeVarTuples).
+        repl = self.variables.get(t.id, t)
+        if isinstance(repl, TypeVarTupleType):
+            return repl
+        elif isinstance(repl, ProperType) and isinstance(repl, (AnyType, UninhabitedType)):
+            # Some failed inference scenarios will try to set all type variables to Never.
+            # Instead of being picky and require all the callers to wrap them,
+            # do this here instead.
+            # Note: most cases when this happens are handled in expand unpack below, but
+            # in rare cases (e.g. ParamSpec containing Unpack star args) it may be skipped.
+            return t.tuple_fallback.copy_modified(args=[repl])
+        raise NotImplementedError
+
+    def visit_unpack_type(self, t: UnpackType) -> Type:
+        # It is impossible to reasonably implement visit_unpack_type, because
+        # unpacking inherently expands to something more like a list of types.
+        #
+        # Relevant sections that can call unpack should call expand_unpack()
+        # instead.
+        # However, if the item is a variadic tuple, we can simply carry it over.
+        # In particular, if we expand A[*tuple[T, ...]] with substitutions {T: str},
+        # it is hard to assert this without getting proper type. Another important
+        # example is non-normalized types when called from semanal.py.
+        return UnpackType(t.type.accept(self))
+
+    def expand_unpack(self, t: UnpackType) -> list[Type]:
+        assert isinstance(t.type, TypeVarTupleType)
+        repl = get_proper_type(self.variables.get(t.type.id, t.type))
+        if isinstance(repl, UnpackType):
+            repl = get_proper_type(repl.type)
+        if isinstance(repl, TupleType):
+            return repl.items
+        elif (
+            isinstance(repl, Instance)
+            and repl.type.fullname == "builtins.tuple"
+            or isinstance(repl, TypeVarTupleType)
+        ):
+            return [UnpackType(typ=repl)]
+        elif isinstance(repl, (AnyType, UninhabitedType)):
+            # Replace *Ts = Any with *Ts = *tuple[Any, ...] and same for Never.
+            # These types may appear here as a result of user error or failed inference.
+            return [UnpackType(t.type.tuple_fallback.copy_modified(args=[repl]))]
+        else:
+            raise RuntimeError(f"Invalid type replacement to expand: {repl}")
+
+    def visit_parameters(self, t: Parameters) -> Type:
+        return t.copy_modified(arg_types=self.expand_types(t.arg_types))
+
+    def interpolate_args_for_unpack(self, t: CallableType, var_arg: UnpackType) -> list[Type]:
+        star_index = t.arg_kinds.index(ARG_STAR)
+        prefix = self.expand_types(t.arg_types[:star_index])
+        suffix = self.expand_types(t.arg_types[star_index + 1 :])
+
+        var_arg_type = get_proper_type(var_arg.type)
+        new_unpack: Type
+        if isinstance(var_arg_type, TupleType):
+            # We have something like Unpack[Tuple[Unpack[Ts], X1, X2]]
+            expanded_tuple = var_arg_type.accept(self)
+            assert isinstance(expanded_tuple, ProperType) and isinstance(expanded_tuple, TupleType)
+            expanded_items = expanded_tuple.items
+            fallback = var_arg_type.partial_fallback
+            new_unpack = UnpackType(TupleType(expanded_items, fallback))
+        elif isinstance(var_arg_type, TypeVarTupleType):
+            # We have plain Unpack[Ts]
+            fallback = var_arg_type.tuple_fallback
+            expanded_items = self.expand_unpack(var_arg)
+            new_unpack = UnpackType(TupleType(expanded_items, fallback))
+        # Since get_proper_type() may be called in semanal.py before callable
+        # normalization happens, we need to also handle non-normal cases here.
+        elif isinstance(var_arg_type, Instance):
+            # we have something like Unpack[Tuple[Any, ...]]
+            new_unpack = UnpackType(var_arg.type.accept(self))
+        else:
+            # We have invalid type in Unpack. This can happen when expanding aliases
+            # to Callable[[*Invalid], Ret]
+            new_unpack = AnyType(TypeOfAny.from_error, line=var_arg.line, column=var_arg.column)
+        return prefix + [new_unpack] + suffix
+
+    def visit_callable_type(self, t: CallableType) -> CallableType:
+        param_spec = t.param_spec()
+        if param_spec is not None:
+            repl = self.variables.get(param_spec.id)
+            # If a ParamSpec in a callable type is substituted with a
+            # callable type, we can't use normal substitution logic,
+            # since ParamSpec is actually split into two components
+            # *P.args and **P.kwargs in the original type. Instead, we
+            # must expand both of them with all the argument types,
+            # kinds and names in the replacement. The return type in
+            # the replacement is ignored.
+            if isinstance(repl, Parameters):
+                # We need to expand both the types in the prefix and the ParamSpec itself
+                expanded = t.copy_modified(
+                    arg_types=self.expand_types(t.arg_types[:-2]) + repl.arg_types,
+                    arg_kinds=t.arg_kinds[:-2] + repl.arg_kinds,
+                    arg_names=t.arg_names[:-2] + repl.arg_names,
+                    ret_type=t.ret_type.accept(self),
+                    type_guard=(t.type_guard.accept(self) if t.type_guard is not None else None),
+                    type_is=(t.type_is.accept(self) if t.type_is is not None else None),
+                    imprecise_arg_kinds=(t.imprecise_arg_kinds or repl.imprecise_arg_kinds),
+                    variables=[*repl.variables, *t.variables],
+                )
+                var_arg = expanded.var_arg()
+                if var_arg is not None and isinstance(var_arg.typ, UnpackType):
+                    # Sometimes we get new unpacks after expanding ParamSpec.
+                    expanded.normalize_trivial_unpack()
+                return expanded
+            elif isinstance(repl, ParamSpecType):
+                # We're substituting one ParamSpec for another; this can mean that the prefix
+                # changes, e.g. substitute Concatenate[int, P] in place of Q.
+                prefix = repl.prefix
+                clean_repl = repl.copy_modified(prefix=Parameters([], [], []))
+                return t.copy_modified(
+                    arg_types=self.expand_types(t.arg_types[:-2])
+                    + prefix.arg_types
+                    + [
+                        clean_repl.with_flavor(ParamSpecFlavor.ARGS),
+                        clean_repl.with_flavor(ParamSpecFlavor.KWARGS),
+                    ],
+                    arg_kinds=t.arg_kinds[:-2] + prefix.arg_kinds + t.arg_kinds[-2:],
+                    arg_names=t.arg_names[:-2] + prefix.arg_names + t.arg_names[-2:],
+                    ret_type=t.ret_type.accept(self),
+                    from_concatenate=t.from_concatenate or bool(repl.prefix.arg_types),
+                    imprecise_arg_kinds=(t.imprecise_arg_kinds or prefix.imprecise_arg_kinds),
+                )
+
+        var_arg = t.var_arg()
+        needs_normalization = False
+        if var_arg is not None and isinstance(var_arg.typ, UnpackType):
+            needs_normalization = True
+            arg_types = self.interpolate_args_for_unpack(t, var_arg.typ)
+        else:
+            arg_types = self.expand_types(t.arg_types)
+        expanded = t.copy_modified(
+            arg_types=arg_types,
+            ret_type=t.ret_type.accept(self),
+            type_guard=(t.type_guard.accept(self) if t.type_guard is not None else None),
+            type_is=(t.type_is.accept(self) if t.type_is is not None else None),
+        )
+        if needs_normalization:
+            return expanded.with_normalized_var_args()
+        return expanded
+
+    def visit_overloaded(self, t: Overloaded) -> Type:
+        items: list[CallableType] = []
+        for item in t.items:
+            new_item = item.accept(self)
+            assert isinstance(new_item, ProperType)
+            assert isinstance(new_item, CallableType)
+            items.append(new_item)
+        return Overloaded(items)
+
+    def expand_type_list_with_unpack(self, typs: list[Type]) -> list[Type]:
+        """Expands a list of types that has an unpack."""
+        items: list[Type] = []
+        for item in typs:
+            if isinstance(item, UnpackType) and isinstance(item.type, TypeVarTupleType):
+                items.extend(self.expand_unpack(item))
+            else:
+                items.append(item.accept(self))
+        return items
+
+    def expand_type_tuple_with_unpack(self, typs: tuple[Type, ...]) -> list[Type]:
+        """Expands a tuple of types that has an unpack."""
+        # Micro-optimization: Specialized variant of expand_type_list_with_unpack
+        items: list[Type] = []
+        for item in typs:
+            if isinstance(item, UnpackType) and isinstance(item.type, TypeVarTupleType):
+                items.extend(self.expand_unpack(item))
+            else:
+                items.append(item.accept(self))
+        return items
+
+    def visit_tuple_type(self, t: TupleType) -> Type:
+        items = self.expand_type_list_with_unpack(t.items)
+        if len(items) == 1:
+            # Normalize Tuple[*Tuple[X, ...]] -> Tuple[X, ...]
+            item = items[0]
+            if isinstance(item, UnpackType):
+                unpacked = get_proper_type(item.type)
+                if isinstance(unpacked, Instance):
+                    # expand_type() may be called during semantic analysis, before invalid unpacks are fixed.
+                    if unpacked.type.fullname != "builtins.tuple":
+                        return t.partial_fallback.accept(self)
+                    if t.partial_fallback.type.fullname != "builtins.tuple":
+                        # If it is a subtype (like named tuple) we need to preserve it,
+                        # this essentially mimics the logic in tuple_fallback().
+                        return t.partial_fallback.accept(self)
+                    return unpacked
+        fallback = t.partial_fallback.accept(self)
+        assert isinstance(fallback, ProperType) and isinstance(fallback, Instance)
+        return t.copy_modified(items=items, fallback=fallback)
+
+    def visit_typeddict_type(self, t: TypedDictType) -> Type:
+        if cached := self.get_cached(t):
+            return cached
+        fallback = t.fallback.accept(self)
+        assert isinstance(fallback, ProperType) and isinstance(fallback, Instance)
+        result = t.copy_modified(item_types=self.expand_types(t.items.values()), fallback=fallback)
+        self.set_cached(t, result)
+        return result
+
+    def visit_literal_type(self, t: LiteralType) -> Type:
+        # TODO: Verify this implementation is correct
+        return t
+
+    def visit_union_type(self, t: UnionType) -> Type:
+        # Use cache to avoid O(n**2) or worse expansion of types during translation
+        # (only for large unions, since caching adds overhead)
+        use_cache = len(t.items) > 3
+        if use_cache and (cached := self.get_cached(t)):
+            return cached
+
+        expanded = self.expand_types(t.items)
+        # After substituting for type variables in t.items, some resulting types
+        # might be subtypes of others, however calling  make_simplified_union()
+        # can cause recursion, so we just remove strict duplicates.
+        simplified = UnionType.make_union(
+            remove_trivial(flatten_nested_unions(expanded)), t.line, t.column
+        )
+        # This call to get_proper_type() is unfortunate but is required to preserve
+        # the invariant that ProperType will stay ProperType after applying expand_type(),
+        # otherwise a single item union of a type alias will break it. Note this should not
+        # cause infinite recursion since pathological aliases like A = Union[A, B] are
+        # banned at the semantic analysis level.
+        result = get_proper_type(simplified)
+
+        if use_cache:
+            self.set_cached(t, result)
+        return result
+
+    def visit_partial_type(self, t: PartialType) -> Type:
+        return t
+
+    def visit_type_type(self, t: TypeType) -> Type:
+        # TODO: Verify that the new item type is valid (instance or
+        # union of instances or Any).  Sadly we can't report errors
+        # here yet.
+        item = t.item.accept(self)
+        return TypeType.make_normalized(item, is_type_form=t.is_type_form)
+
+    def visit_type_alias_type(self, t: TypeAliasType) -> Type:
+        # Target of the type alias cannot contain type variables (not bound by the type
+        # alias itself), so we just expand the arguments.
+        if len(t.args) == 0:
+            return t
+        args = self.expand_type_list_with_unpack(t.args)
+        # TODO: normalize if target is Tuple, and args are [*tuple[X, ...]]?
+        return t.copy_modified(args=args)
+
+    def expand_types(self, types: Iterable[Type]) -> list[Type]:
+        a: list[Type] = []
+        for t in types:
+            a.append(t.accept(self))
+        return a
+
+
+@overload
+def expand_self_type(var: Var, typ: ProperType, replacement: ProperType) -> ProperType: ...
+
+
+@overload
+def expand_self_type(var: Var, typ: Type, replacement: Type) -> Type: ...
+
+
+def expand_self_type(var: Var, typ: Type, replacement: Type) -> Type:
+    """Expand appearances of Self type in a variable type."""
+    if var.info.self_type is not None and not var.is_property:
+        return expand_type(typ, {var.info.self_type.id: replacement})
+    return typ
+
+
+def remove_trivial(types: Iterable[Type]) -> list[Type]:
+    """Make trivial simplifications on a list of types without calling is_subtype().
+
+    This makes following simplifications:
+        * Remove bottom types (taking into account strict optional setting)
+        * Remove everything else if there is an `object`
+        * Remove strict duplicate types
+    """
+    removed_none = False
+    new_types = []
+    all_types = set()
+    for t in types:
+        p_t = get_proper_type(t)
+        if isinstance(p_t, UninhabitedType):
+            continue
+        if isinstance(p_t, NoneType) and not state.strict_optional:
+            removed_none = True
+            continue
+        if isinstance(p_t, Instance) and p_t.type.fullname == "builtins.object":
+            return [p_t]
+        if p_t not in all_types:
+            new_types.append(t)
+            all_types.add(p_t)
+    if new_types:
+        return new_types
+    if removed_none:
+        return [NoneType()]
+    return [UninhabitedType()]

micromamba_root/Lib/site-packages/mypy/exportjson.py

@@ -0,0 +1,612 @@
+"""Tool to convert binary mypy cache files (.ff) to JSON (.ff.json).
+
+Usage:
+   python -m mypy.exportjson .mypy_cache/.../my_module.data.ff
+
+The idea is to make caches introspectable once we've switched to a binary
+cache format and removed support for the older JSON cache format.
+
+This is primarily to support existing use cases that need to inspect
+cache files, and to support debugging mypy caching issues. This means that
+this doesn't necessarily need to be kept 1:1 up to date with changes in the
+binary cache format (to simplify maintenance -- we don't want this to slow
+down mypy development).
+"""
+
+import argparse
+import json
+import sys
+from typing import Any, TypeAlias as _TypeAlias
+
+from librt.internal import ReadBuffer, cache_version
+
+from mypy.cache import CACHE_VERSION, CacheMeta
+from mypy.nodes import (
+    FUNCBASE_FLAGS,
+    FUNCDEF_FLAGS,
+    VAR_FLAGS,
+    ClassDef,
+    DataclassTransformSpec,
+    Decorator,
+    FuncDef,
+    MypyFile,
+    OverloadedFuncDef,
+    OverloadPart,
+    ParamSpecExpr,
+    SymbolNode,
+    SymbolTable,
+    SymbolTableNode,
+    TypeAlias,
+    TypeInfo,
+    TypeVarExpr,
+    TypeVarTupleExpr,
+    Var,
+    get_flags,
+    node_kinds,
+)
+from mypy.types import (
+    NOT_READY,
+    AnyType,
+    CallableType,
+    ExtraAttrs,
+    Instance,
+    LiteralType,
+    NoneType,
+    Overloaded,
+    Parameters,
+    ParamSpecType,
+    TupleType,
+    Type,
+    TypeAliasType,
+    TypedDictType,
+    TypeType,
+    TypeVarTupleType,
+    TypeVarType,
+    UnboundType,
+    UninhabitedType,
+    UnionType,
+    UnpackType,
+    get_proper_type,
+)
+
+Json: _TypeAlias = dict[str, Any] | str
+
+
+class Config:
+    def __init__(self, *, implicit_names: bool = True) -> None:
+        self.implicit_names = implicit_names
+
+
+def convert_binary_cache_to_json(data: bytes, *, implicit_names: bool = True) -> Json:
+    tree = MypyFile.read(ReadBuffer(data))
+    return convert_mypy_file_to_json(tree, Config(implicit_names=implicit_names))
+
+
+def convert_mypy_file_to_json(self: MypyFile, cfg: Config) -> Json:
+    return {
+        ".class": "MypyFile",
+        "_fullname": self._fullname,
+        "names": convert_symbol_table(self.names, cfg),
+        "is_stub": self.is_stub,
+        "path": self.path,
+        "is_partial_stub_package": self.is_partial_stub_package,
+        "future_import_flags": sorted(self.future_import_flags),
+    }
+
+
+def convert_symbol_table(self: SymbolTable, cfg: Config) -> Json:
+    data: dict[str, Any] = {".class": "SymbolTable"}
+    for key, value in self.items():
+        # Skip __builtins__: it's a reference to the builtins
+        # module that gets added to every module by
+        # SemanticAnalyzerPass2.visit_file(), but it shouldn't be
+        # accessed by users of the module.
+        if key == "__builtins__" or value.no_serialize:
+            continue
+        if not cfg.implicit_names and key in {
+            "__spec__",
+            "__package__",
+            "__file__",
+            "__doc__",
+            "__annotations__",
+            "__name__",
+        }:
+            continue
+        data[key] = convert_symbol_table_node(value, cfg)
+    return data
+
+
+def convert_symbol_table_node(self: SymbolTableNode, cfg: Config) -> Json:
+    data: dict[str, Any] = {".class": "SymbolTableNode", "kind": node_kinds[self.kind]}
+    if self.module_hidden:
+        data["module_hidden"] = True
+    if not self.module_public:
+        data["module_public"] = False
+    if self.implicit:
+        data["implicit"] = True
+    if self.plugin_generated:
+        data["plugin_generated"] = True
+    if self.cross_ref:
+        data["cross_ref"] = self.cross_ref
+    elif self.node is not None:
+        data["node"] = convert_symbol_node(self.node, cfg)
+    return data
+
+
+def convert_symbol_node(self: SymbolNode, cfg: Config) -> Json:
+    if isinstance(self, FuncDef):
+        return convert_func_def(self)
+    elif isinstance(self, OverloadedFuncDef):
+        return convert_overloaded_func_def(self)
+    elif isinstance(self, Decorator):
+        return convert_decorator(self)
+    elif isinstance(self, Var):
+        return convert_var(self)
+    elif isinstance(self, TypeInfo):
+        return convert_type_info(self, cfg)
+    elif isinstance(self, TypeAlias):
+        return convert_type_alias(self)
+    elif isinstance(self, TypeVarExpr):
+        return convert_type_var_expr(self)
+    elif isinstance(self, ParamSpecExpr):
+        return convert_param_spec_expr(self)
+    elif isinstance(self, TypeVarTupleExpr):
+        return convert_type_var_tuple_expr(self)
+    return {"ERROR": f"{type(self)!r} unrecognized"}
+
+
+def convert_func_def(self: FuncDef) -> Json:
+    return {
+        ".class": "FuncDef",
+        "name": self._name,
+        "fullname": self._fullname,
+        "arg_names": self.arg_names,
+        "arg_kinds": [int(x.value) for x in self.arg_kinds],
+        "type": None if self.type is None else convert_type(self.type),
+        "flags": get_flags(self, FUNCDEF_FLAGS),
+        "abstract_status": self.abstract_status,
+        # TODO: Do we need expanded, original_def?
+        "dataclass_transform_spec": (
+            None
+            if self.dataclass_transform_spec is None
+            else convert_dataclass_transform_spec(self.dataclass_transform_spec)
+        ),
+        "deprecated": self.deprecated,
+        "original_first_arg": self.original_first_arg,
+    }
+
+
+def convert_dataclass_transform_spec(self: DataclassTransformSpec) -> Json:
+    return {
+        "eq_default": self.eq_default,
+        "order_default": self.order_default,
+        "kw_only_default": self.kw_only_default,
+        "frozen_default": self.frozen_default,
+        "field_specifiers": list(self.field_specifiers),
+    }
+
+
+def convert_overloaded_func_def(self: OverloadedFuncDef) -> Json:
+    return {
+        ".class": "OverloadedFuncDef",
+        "items": [convert_overload_part(i) for i in self.items],
+        "type": None if self.type is None else convert_type(self.type),
+        "fullname": self._fullname,
+        "impl": None if self.impl is None else convert_overload_part(self.impl),
+        "flags": get_flags(self, FUNCBASE_FLAGS),
+        "deprecated": self.deprecated,
+        "setter_index": self.setter_index,
+    }
+
+
+def convert_overload_part(self: OverloadPart) -> Json:
+    if isinstance(self, FuncDef):
+        return convert_func_def(self)
+    else:
+        return convert_decorator(self)
+
+
+def convert_decorator(self: Decorator) -> Json:
+    return {
+        ".class": "Decorator",
+        "func": convert_func_def(self.func),
+        "var": convert_var(self.var),
+        "is_overload": self.is_overload,
+    }
+
+
+def convert_var(self: Var) -> Json:
+    data: dict[str, Any] = {
+        ".class": "Var",
+        "name": self._name,
+        "fullname": self._fullname,
+        "type": None if self.type is None else convert_type(self.type),
+        "setter_type": None if self.setter_type is None else convert_type(self.setter_type),
+        "flags": get_flags(self, VAR_FLAGS),
+    }
+    if self.final_value is not None:
+        data["final_value"] = self.final_value
+    return data
+
+
+def convert_type_info(self: TypeInfo, cfg: Config) -> Json:
+    data = {
+        ".class": "TypeInfo",
+        "module_name": self.module_name,
+        "fullname": self.fullname,
+        "names": convert_symbol_table(self.names, cfg),
+        "defn": convert_class_def(self.defn),
+        "abstract_attributes": self.abstract_attributes,
+        "type_vars": self.type_vars,
+        "has_param_spec_type": self.has_param_spec_type,
+        "bases": [convert_type(b) for b in self.bases],
+        "mro": self._mro_refs,
+        "_promote": [convert_type(p) for p in self._promote],
+        "alt_promote": None if self.alt_promote is None else convert_type(self.alt_promote),
+        "declared_metaclass": (
+            None if self.declared_metaclass is None else convert_type(self.declared_metaclass)
+        ),
+        "metaclass_type": (
+            None if self.metaclass_type is None else convert_type(self.metaclass_type)
+        ),
+        "tuple_type": None if self.tuple_type is None else convert_type(self.tuple_type),
+        "typeddict_type": (
+            None if self.typeddict_type is None else convert_typeddict_type(self.typeddict_type)
+        ),
+        "flags": get_flags(self, TypeInfo.FLAGS),
+        "metadata": self.metadata,
+        "slots": sorted(self.slots) if self.slots is not None else None,
+        "deletable_attributes": self.deletable_attributes,
+        "self_type": convert_type(self.self_type) if self.self_type is not None else None,
+        "dataclass_transform_spec": (
+            convert_dataclass_transform_spec(self.dataclass_transform_spec)
+            if self.dataclass_transform_spec is not None
+            else None
+        ),
+        "deprecated": self.deprecated,
+    }
+    return data
+
+
+def convert_class_def(self: ClassDef) -> Json:
+    return {
+        ".class": "ClassDef",
+        "name": self.name,
+        "fullname": self.fullname,
+        "type_vars": [convert_type(v) for v in self.type_vars],
+    }
+
+
+def convert_type_alias(self: TypeAlias) -> Json:
+    data: Json = {
+        ".class": "TypeAlias",
+        "fullname": self._fullname,
+        "module": self.module,
+        "target": convert_type(self.target),
+        "alias_tvars": [convert_type(v) for v in self.alias_tvars],
+        "no_args": self.no_args,
+        "normalized": self.normalized,
+        "python_3_12_type_alias": self.python_3_12_type_alias,
+    }
+    return data
+
+
+def convert_type_var_expr(self: TypeVarExpr) -> Json:
+    return {
+        ".class": "TypeVarExpr",
+        "name": self._name,
+        "fullname": self._fullname,
+        "values": [convert_type(t) for t in self.values],
+        "upper_bound": convert_type(self.upper_bound),
+        "default": convert_type(self.default),
+        "variance": self.variance,
+    }
+
+
+def convert_param_spec_expr(self: ParamSpecExpr) -> Json:
+    return {
+        ".class": "ParamSpecExpr",
+        "name": self._name,
+        "fullname": self._fullname,
+        "upper_bound": convert_type(self.upper_bound),
+        "default": convert_type(self.default),
+        "variance": self.variance,
+    }
+
+
+def convert_type_var_tuple_expr(self: TypeVarTupleExpr) -> Json:
+    return {
+        ".class": "TypeVarTupleExpr",
+        "name": self._name,
+        "fullname": self._fullname,
+        "upper_bound": convert_type(self.upper_bound),
+        "tuple_fallback": convert_type(self.tuple_fallback),
+        "default": convert_type(self.default),
+        "variance": self.variance,
+    }
+
+
+def convert_type(typ: Type) -> Json:
+    if type(typ) is TypeAliasType:
+        return convert_type_alias_type(typ)
+    typ = get_proper_type(typ)
+    if isinstance(typ, Instance):
+        return convert_instance(typ)
+    elif isinstance(typ, AnyType):
+        return convert_any_type(typ)
+    elif isinstance(typ, NoneType):
+        return convert_none_type(typ)
+    elif isinstance(typ, UnionType):
+        return convert_union_type(typ)
+    elif isinstance(typ, TupleType):
+        return convert_tuple_type(typ)
+    elif isinstance(typ, CallableType):
+        return convert_callable_type(typ)
+    elif isinstance(typ, Overloaded):
+        return convert_overloaded(typ)
+    elif isinstance(typ, LiteralType):
+        return convert_literal_type(typ)
+    elif isinstance(typ, TypeVarType):
+        return convert_type_var_type(typ)
+    elif isinstance(typ, TypeType):
+        return convert_type_type(typ)
+    elif isinstance(typ, UninhabitedType):
+        return convert_uninhabited_type(typ)
+    elif isinstance(typ, UnpackType):
+        return convert_unpack_type(typ)
+    elif isinstance(typ, ParamSpecType):
+        return convert_param_spec_type(typ)
+    elif isinstance(typ, TypeVarTupleType):
+        return convert_type_var_tuple_type(typ)
+    elif isinstance(typ, Parameters):
+        return convert_parameters(typ)
+    elif isinstance(typ, TypedDictType):
+        return convert_typeddict_type(typ)
+    elif isinstance(typ, UnboundType):
+        return convert_unbound_type(typ)
+    return {"ERROR": f"{type(typ)!r} unrecognized"}
+
+
+def convert_instance(self: Instance) -> Json:
+    ready = self.type is not NOT_READY
+    if not self.args and not self.last_known_value and not self.extra_attrs:
+        if ready:
+            return self.type.fullname
+        elif self.type_ref:
+            return self.type_ref
+
+    data: dict[str, Any] = {
+        ".class": "Instance",
+        "type_ref": self.type.fullname if ready else self.type_ref,
+        "args": [convert_type(arg) for arg in self.args],
+    }
+    if self.last_known_value is not None:
+        data["last_known_value"] = convert_type(self.last_known_value)
+    data["extra_attrs"] = convert_extra_attrs(self.extra_attrs) if self.extra_attrs else None
+    return data
+
+
+def convert_extra_attrs(self: ExtraAttrs) -> Json:
+    return {
+        ".class": "ExtraAttrs",
+        "attrs": {k: convert_type(v) for k, v in self.attrs.items()},
+        "immutable": sorted(self.immutable),
+        "mod_name": self.mod_name,
+    }
+
+
+def convert_type_alias_type(self: TypeAliasType) -> Json:
+    data: Json = {
+        ".class": "TypeAliasType",
+        "type_ref": self.type_ref,
+        "args": [convert_type(arg) for arg in self.args],
+    }
+    return data
+
+
+def convert_any_type(self: AnyType) -> Json:
+    return {
+        ".class": "AnyType",
+        "type_of_any": self.type_of_any,
+        "source_any": convert_type(self.source_any) if self.source_any is not None else None,
+        "missing_import_name": self.missing_import_name,
+    }
+
+
+def convert_none_type(self: NoneType) -> Json:
+    return {".class": "NoneType"}
+
+
+def convert_union_type(self: UnionType) -> Json:
+    return {
+        ".class": "UnionType",
+        "items": [convert_type(t) for t in self.items],
+        "uses_pep604_syntax": self.uses_pep604_syntax,
+    }
+
+
+def convert_tuple_type(self: TupleType) -> Json:
+    return {
+        ".class": "TupleType",
+        "items": [convert_type(t) for t in self.items],
+        "partial_fallback": convert_type(self.partial_fallback),
+        "implicit": self.implicit,
+    }
+
+
+def convert_literal_type(self: LiteralType) -> Json:
+    return {".class": "LiteralType", "value": self.value, "fallback": convert_type(self.fallback)}
+
+
+def convert_type_var_type(self: TypeVarType) -> Json:
+    assert not self.id.is_meta_var()
+    return {
+        ".class": "TypeVarType",
+        "name": self.name,
+        "fullname": self.fullname,
+        "id": self.id.raw_id,
+        "namespace": self.id.namespace,
+        "values": [convert_type(v) for v in self.values],
+        "upper_bound": convert_type(self.upper_bound),
+        "default": convert_type(self.default),
+        "variance": self.variance,
+    }
+
+
+def convert_callable_type(self: CallableType) -> Json:
+    return {
+        ".class": "CallableType",
+        "arg_types": [convert_type(t) for t in self.arg_types],
+        "arg_kinds": [int(x.value) for x in self.arg_kinds],
+        "arg_names": self.arg_names,
+        "ret_type": convert_type(self.ret_type),
+        "fallback": convert_type(self.fallback),
+        "name": self.name,
+        # We don't serialize the definition (only used for error messages).
+        "variables": [convert_type(v) for v in self.variables],
+        "is_ellipsis_args": self.is_ellipsis_args,
+        "implicit": self.implicit,
+        "is_bound": self.is_bound,
+        "type_guard": convert_type(self.type_guard) if self.type_guard is not None else None,
+        "type_is": convert_type(self.type_is) if self.type_is is not None else None,
+        "from_concatenate": self.from_concatenate,
+        "imprecise_arg_kinds": self.imprecise_arg_kinds,
+        "unpack_kwargs": self.unpack_kwargs,
+    }
+
+
+def convert_overloaded(self: Overloaded) -> Json:
+    return {".class": "Overloaded", "items": [convert_type(t) for t in self.items]}
+
+
+def convert_type_type(self: TypeType) -> Json:
+    return {".class": "TypeType", "item": convert_type(self.item)}
+
+
+def convert_uninhabited_type(self: UninhabitedType) -> Json:
+    return {".class": "UninhabitedType"}
+
+
+def convert_unpack_type(self: UnpackType) -> Json:
+    return {".class": "UnpackType", "type": convert_type(self.type)}
+
+
+def convert_param_spec_type(self: ParamSpecType) -> Json:
+    assert not self.id.is_meta_var()
+    return {
+        ".class": "ParamSpecType",
+        "name": self.name,
+        "fullname": self.fullname,
+        "id": self.id.raw_id,
+        "namespace": self.id.namespace,
+        "flavor": self.flavor,
+        "upper_bound": convert_type(self.upper_bound),
+        "default": convert_type(self.default),
+        "prefix": convert_type(self.prefix),
+    }
+
+
+def convert_type_var_tuple_type(self: TypeVarTupleType) -> Json:
+    assert not self.id.is_meta_var()
+    return {
+        ".class": "TypeVarTupleType",
+        "name": self.name,
+        "fullname": self.fullname,
+        "id": self.id.raw_id,
+        "namespace": self.id.namespace,
+        "upper_bound": convert_type(self.upper_bound),
+        "tuple_fallback": convert_type(self.tuple_fallback),
+        "default": convert_type(self.default),
+        "min_len": self.min_len,
+    }
+
+
+def convert_parameters(self: Parameters) -> Json:
+    return {
+        ".class": "Parameters",
+        "arg_types": [convert_type(t) for t in self.arg_types],
+        "arg_kinds": [int(x.value) for x in self.arg_kinds],
+        "arg_names": self.arg_names,
+        "variables": [convert_type(tv) for tv in self.variables],
+        "imprecise_arg_kinds": self.imprecise_arg_kinds,
+    }
+
+
+def convert_typeddict_type(self: TypedDictType) -> Json:
+    return {
+        ".class": "TypedDictType",
+        "items": [[n, convert_type(t)] for (n, t) in self.items.items()],
+        "required_keys": sorted(self.required_keys),
+        "readonly_keys": sorted(self.readonly_keys),
+        "fallback": convert_type(self.fallback),
+    }
+
+
+def convert_unbound_type(self: UnboundType) -> Json:
+    return {
+        ".class": "UnboundType",
+        "name": self.name,
+        "args": [convert_type(a) for a in self.args],
+        "expr": self.original_str_expr,
+        "expr_fallback": self.original_str_fallback,
+    }
+
+
+def convert_binary_cache_meta_to_json(data: bytes, data_file: str) -> Json:
+    assert (
+        data[0] == cache_version() and data[1] == CACHE_VERSION
+    ), "Cache file created by an incompatible mypy version"
+    meta = CacheMeta.read(ReadBuffer(data[2:]), data_file)
+    assert meta is not None, f"Error reading meta cache file associated with {data_file}"
+    return {
+        "id": meta.id,
+        "path": meta.path,
+        "mtime": meta.mtime,
+        "size": meta.size,
+        "hash": meta.hash,
+        "data_mtime": meta.data_mtime,
+        "dependencies": meta.dependencies,
+        "suppressed": meta.suppressed,
+        "options": meta.options,
+        "dep_prios": meta.dep_prios,
+        "dep_lines": meta.dep_lines,
+        "dep_hashes": [dep.hex() for dep in meta.dep_hashes],
+        "interface_hash": meta.interface_hash.hex(),
+        "version_id": meta.version_id,
+        "ignore_all": meta.ignore_all,
+        "plugin_data": meta.plugin_data,
+    }
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Convert binary cache files to JSON. "
+        "Create files in the same directory with extra .json extension."
+    )
+    parser.add_argument(
+        "path", nargs="+", help="mypy cache data file to convert (.data.ff extension)"
+    )
+    args = parser.parse_args()
+    fnams: list[str] = args.path
+    for fnam in fnams:
+        if fnam.endswith(".data.ff"):
+            is_data = True
+        elif fnam.endswith(".meta.ff"):
+            is_data = False
+        else:
+            sys.exit(f"error: Expected .data.ff or .meta.ff extension, but got {fnam}")
+        with open(fnam, "rb") as f:
+            data = f.read()
+        if is_data:
+            json_data = convert_binary_cache_to_json(data)
+        else:
+            data_file = fnam.removesuffix(".meta.ff") + ".data.ff"
+            json_data = convert_binary_cache_meta_to_json(data, data_file)
+        new_fnam = fnam + ".json"
+        with open(new_fnam, "w") as f:
+            json.dump(json_data, f)
+        print(f"{fnam} -> {new_fnam}")
+
+
+if __name__ == "__main__":
+    main()

micromamba_root/Lib/site-packages/mypy/exprtotype.py

@@ -0,0 +1,289 @@
+"""Translate an Expression to a Type value."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+
+from mypy.fastparse import parse_type_string
+from mypy.nodes import (
+    MISSING_FALLBACK,
+    BytesExpr,
+    CallExpr,
+    ComplexExpr,
+    Context,
+    DictExpr,
+    EllipsisExpr,
+    Expression,
+    FloatExpr,
+    IndexExpr,
+    IntExpr,
+    ListExpr,
+    MemberExpr,
+    NameExpr,
+    OpExpr,
+    RefExpr,
+    StarExpr,
+    StrExpr,
+    SymbolTableNode,
+    TupleExpr,
+    UnaryExpr,
+    get_member_expr_fullname,
+)
+from mypy.options import Options
+from mypy.types import (
+    ANNOTATED_TYPE_NAMES,
+    AnyType,
+    CallableArgument,
+    EllipsisType,
+    Instance,
+    ProperType,
+    RawExpressionType,
+    Type,
+    TypedDictType,
+    TypeList,
+    TypeOfAny,
+    UnboundType,
+    UnionType,
+    UnpackType,
+)
+
+
+class TypeTranslationError(Exception):
+    """Exception raised when an expression is not valid as a type."""
+
+
+def _extract_argument_name(expr: Expression) -> str | None:
+    if isinstance(expr, NameExpr) and expr.name == "None":
+        return None
+    elif isinstance(expr, StrExpr):
+        return expr.value
+    else:
+        raise TypeTranslationError()
+
+
+def expr_to_unanalyzed_type(
+    expr: Expression,
+    options: Options,
+    allow_new_syntax: bool = False,
+    _parent: Expression | None = None,
+    allow_unpack: bool = False,
+    lookup_qualified: Callable[[str, Context], SymbolTableNode | None] | None = None,
+) -> ProperType:
+    """Translate an expression to the corresponding type.
+
+    The result is not semantically analyzed. It can be UnboundType or TypeList.
+    Raise TypeTranslationError if the expression cannot represent a type.
+
+    If lookup_qualified is not provided, the expression is expected to be semantically
+    analyzed.
+
+    If allow_new_syntax is True, allow all type syntax independent of the target
+    Python version (used in stubs).
+
+    # TODO: a lot of code here is duplicated in fastparse.py, refactor this.
+    """
+    # The `parent` parameter is used in recursive calls to provide context for
+    # understanding whether an CallableArgument is ok.
+    name: str | None = None
+    if isinstance(expr, NameExpr):
+        name = expr.name
+        if name == "True":
+            return RawExpressionType(True, "builtins.bool", line=expr.line, column=expr.column)
+        elif name == "False":
+            return RawExpressionType(False, "builtins.bool", line=expr.line, column=expr.column)
+        else:
+            return UnboundType(name, line=expr.line, column=expr.column)
+    elif isinstance(expr, MemberExpr):
+        fullname = get_member_expr_fullname(expr)
+        if fullname:
+            return UnboundType(fullname, line=expr.line, column=expr.column)
+        else:
+            raise TypeTranslationError()
+    elif isinstance(expr, IndexExpr):
+        base = expr_to_unanalyzed_type(
+            expr.base, options, allow_new_syntax, expr, lookup_qualified=lookup_qualified
+        )
+        if isinstance(base, UnboundType):
+            if base.args:
+                raise TypeTranslationError()
+            if isinstance(expr.index, TupleExpr):
+                args = expr.index.items
+            else:
+                args = [expr.index]
+
+            if isinstance(expr.base, RefExpr):
+                # Check if the type is Annotated[...]. For this we need the fullname,
+                # which must be looked up if the expression hasn't been semantically analyzed.
+                base_fullname = None
+                if lookup_qualified is not None:
+                    sym = lookup_qualified(base.name, expr)
+                    if sym and sym.node:
+                        base_fullname = sym.node.fullname
+                else:
+                    base_fullname = expr.base.fullname
+
+                if base_fullname is not None and base_fullname in ANNOTATED_TYPE_NAMES:
+                    # TODO: this is not the optimal solution as we are basically getting rid
+                    # of the Annotation definition and only returning the type information,
+                    # losing all the annotations.
+                    return expr_to_unanalyzed_type(
+                        args[0], options, allow_new_syntax, expr, lookup_qualified=lookup_qualified
+                    )
+            base.args = tuple(
+                expr_to_unanalyzed_type(
+                    arg,
+                    options,
+                    allow_new_syntax,
+                    expr,
+                    allow_unpack=True,
+                    lookup_qualified=lookup_qualified,
+                )
+                for arg in args
+            )
+            if not base.args:
+                base.empty_tuple_index = True
+            return base
+        else:
+            raise TypeTranslationError()
+    elif (
+        isinstance(expr, OpExpr)
+        and expr.op == "|"
+        and ((options.python_version >= (3, 10)) or allow_new_syntax)
+    ):
+        return UnionType(
+            [
+                expr_to_unanalyzed_type(
+                    expr.left, options, allow_new_syntax, lookup_qualified=lookup_qualified
+                ),
+                expr_to_unanalyzed_type(
+                    expr.right, options, allow_new_syntax, lookup_qualified=lookup_qualified
+                ),
+            ],
+            uses_pep604_syntax=True,
+        )
+    elif isinstance(expr, CallExpr) and isinstance(_parent, ListExpr):
+        c = expr.callee
+        names = []
+        # Go through the dotted member expr chain to get the full arg
+        # constructor name to look up
+        while True:
+            if isinstance(c, NameExpr):
+                names.append(c.name)
+                break
+            elif isinstance(c, MemberExpr):
+                names.append(c.name)
+                c = c.expr
+            else:
+                raise TypeTranslationError()
+        arg_const = ".".join(reversed(names))
+
+        # Go through the constructor args to get its name and type.
+        name = None
+        default_type = AnyType(TypeOfAny.unannotated)
+        typ: Type = default_type
+        for i, arg in enumerate(expr.args):
+            if expr.arg_names[i] is not None:
+                if expr.arg_names[i] == "name":
+                    if name is not None:
+                        # Two names
+                        raise TypeTranslationError()
+                    name = _extract_argument_name(arg)
+                    continue
+                elif expr.arg_names[i] == "type":
+                    if typ is not default_type:
+                        # Two types
+                        raise TypeTranslationError()
+                    typ = expr_to_unanalyzed_type(
+                        arg, options, allow_new_syntax, expr, lookup_qualified=lookup_qualified
+                    )
+                    continue
+                else:
+                    raise TypeTranslationError()
+            elif i == 0:
+                typ = expr_to_unanalyzed_type(
+                    arg, options, allow_new_syntax, expr, lookup_qualified=lookup_qualified
+                )
+            elif i == 1:
+                name = _extract_argument_name(arg)
+            else:
+                raise TypeTranslationError()
+        return CallableArgument(typ, name, arg_const, expr.line, expr.column)
+    elif isinstance(expr, ListExpr):
+        return TypeList(
+            [
+                expr_to_unanalyzed_type(
+                    t,
+                    options,
+                    allow_new_syntax,
+                    expr,
+                    allow_unpack=True,
+                    lookup_qualified=lookup_qualified,
+                )
+                for t in expr.items
+            ],
+            line=expr.line,
+            column=expr.column,
+        )
+    elif isinstance(expr, StrExpr):
+        return parse_type_string(expr.value, "builtins.str", expr.line, expr.column)
+    elif isinstance(expr, BytesExpr):
+        return parse_type_string(expr.value, "builtins.bytes", expr.line, expr.column)
+    elif isinstance(expr, UnaryExpr):
+        typ = expr_to_unanalyzed_type(
+            expr.expr, options, allow_new_syntax, lookup_qualified=lookup_qualified
+        )
+        if isinstance(typ, RawExpressionType):
+            if isinstance(typ.literal_value, int):
+                if expr.op == "-":
+                    typ.literal_value *= -1
+                    return typ
+                elif expr.op == "+":
+                    return typ
+        raise TypeTranslationError()
+    elif isinstance(expr, IntExpr):
+        return RawExpressionType(expr.value, "builtins.int", line=expr.line, column=expr.column)
+    elif isinstance(expr, FloatExpr):
+        # Floats are not valid parameters for RawExpressionType , so we just
+        # pass in 'None' for now. We'll report the appropriate error at a later stage.
+        return RawExpressionType(None, "builtins.float", line=expr.line, column=expr.column)
+    elif isinstance(expr, ComplexExpr):
+        # Same thing as above with complex numbers.
+        return RawExpressionType(None, "builtins.complex", line=expr.line, column=expr.column)
+    elif isinstance(expr, EllipsisExpr):
+        return EllipsisType(expr.line)
+    elif allow_unpack and isinstance(expr, StarExpr):
+        return UnpackType(
+            expr_to_unanalyzed_type(
+                expr.expr, options, allow_new_syntax, lookup_qualified=lookup_qualified
+            ),
+            from_star_syntax=True,
+        )
+    elif isinstance(expr, DictExpr):
+        if not expr.items:
+            raise TypeTranslationError()
+        items: dict[str, Type] = {}
+        extra_items_from = []
+        for item_name, value in expr.items:
+            if not isinstance(item_name, StrExpr):
+                if item_name is None:
+                    extra_items_from.append(
+                        expr_to_unanalyzed_type(
+                            value,
+                            options,
+                            allow_new_syntax,
+                            expr,
+                            lookup_qualified=lookup_qualified,
+                        )
+                    )
+                    continue
+                raise TypeTranslationError()
+            items[item_name.value] = expr_to_unanalyzed_type(
+                value, options, allow_new_syntax, expr, lookup_qualified=lookup_qualified
+            )
+        result = TypedDictType(
+            items, set(), set(), Instance(MISSING_FALLBACK, ()), expr.line, expr.column
+        )
+        result.extra_items_from = extra_items_from
+        return result
+    else:
+        raise TypeTranslationError()

micromamba_root/Lib/site-packages/mypy/fastparse.py

@@ -0,0 +1,2256 @@
+from __future__ import annotations
+
+import re
+import sys
+import warnings
+from collections.abc import Callable, Sequence
+from typing import Any, Final, Literal, TypeVar, cast, overload
+
+from mypy import defaults, errorcodes as codes, message_registry
+from mypy.errors import Errors
+from mypy.message_registry import ErrorMessage
+from mypy.nodes import (
+    ARG_NAMED,
+    ARG_NAMED_OPT,
+    ARG_OPT,
+    ARG_POS,
+    ARG_STAR,
+    ARG_STAR2,
+    MISSING_FALLBACK,
+    PARAM_SPEC_KIND,
+    TYPE_VAR_KIND,
+    TYPE_VAR_TUPLE_KIND,
+    ArgKind,
+    Argument,
+    AssertStmt,
+    AssignmentExpr,
+    AssignmentStmt,
+    AwaitExpr,
+    Block,
+    BreakStmt,
+    BytesExpr,
+    CallExpr,
+    ClassDef,
+    ComparisonExpr,
+    ComplexExpr,
+    ConditionalExpr,
+    ContinueStmt,
+    Decorator,
+    DelStmt,
+    DictExpr,
+    DictionaryComprehension,
+    EllipsisExpr,
+    Expression,
+    ExpressionStmt,
+    FloatExpr,
+    ForStmt,
+    FuncDef,
+    GeneratorExpr,
+    GlobalDecl,
+    IfStmt,
+    Import,
+    ImportAll,
+    ImportBase,
+    ImportFrom,
+    IndexExpr,
+    IntExpr,
+    LambdaExpr,
+    ListComprehension,
+    ListExpr,
+    MatchStmt,
+    MemberExpr,
+    MypyFile,
+    NameExpr,
+    Node,
+    NonlocalDecl,
+    OperatorAssignmentStmt,
+    OpExpr,
+    OverloadedFuncDef,
+    OverloadPart,
+    PassStmt,
+    RaiseStmt,
+    RefExpr,
+    ReturnStmt,
+    SetComprehension,
+    SetExpr,
+    SliceExpr,
+    StarExpr,
+    Statement,
+    StrExpr,
+    SuperExpr,
+    TemplateStrExpr,
+    TempNode,
+    TryStmt,
+    TupleExpr,
+    TypeAliasStmt,
+    TypeParam,
+    UnaryExpr,
+    Var,
+    WhileStmt,
+    WithStmt,
+    YieldExpr,
+    YieldFromExpr,
+    check_param_names,
+)
+from mypy.options import Options
+from mypy.patterns import (
+    AsPattern,
+    ClassPattern,
+    MappingPattern,
+    OrPattern,
+    SequencePattern,
+    SingletonPattern,
+    StarredPattern,
+    ValuePattern,
+)
+from mypy.reachability import infer_reachability_of_if_statement, mark_block_unreachable
+from mypy.sharedparse import argument_elide_name, special_function_elide_names
+from mypy.traverser import TraverserVisitor
+from mypy.types import (
+    AnyType,
+    CallableArgument,
+    CallableType,
+    EllipsisType,
+    Instance,
+    ProperType,
+    RawExpressionType,
+    TupleType,
+    Type,
+    TypedDictType,
+    TypeList,
+    TypeOfAny,
+    UnboundType,
+    UnionType,
+    UnpackType,
+)
+from mypy.util import bytes_to_human_readable_repr, unnamed_function
+
+# pull this into a final variable to make mypyc be quiet about the
+# the default argument warning
+PY_MINOR_VERSION: Final = sys.version_info[1]
+
+import ast as ast3
+from ast import AST, Attribute, Call, FunctionType, Name, Starred, UAdd, UnaryOp, USub
+
+
+def ast3_parse(
+    source: str | bytes, filename: str, mode: str, feature_version: int = PY_MINOR_VERSION
+) -> AST:
+    # Ignore warnings that look like:
+    #     <type_comment>:1: SyntaxWarning: invalid escape sequence '\.'
+    # because `source` could be anything, including literals like r'(re\.match)'
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore", SyntaxWarning)
+        return ast3.parse(
+            source,
+            filename,
+            mode,
+            type_comments=True,  # This works the magic
+            feature_version=feature_version,
+        )
+
+
+AstNode = ast3.expr | ast3.stmt | ast3.pattern | ast3.ExceptHandler
+
+if sys.version_info >= (3, 11):
+    TryStar = ast3.TryStar
+else:
+    TryStar = Any
+
+if sys.version_info >= (3, 12):
+    ast_TypeAlias = ast3.TypeAlias
+    ast_ParamSpec = ast3.ParamSpec
+    ast_TypeVar = ast3.TypeVar
+    ast_TypeVarTuple = ast3.TypeVarTuple
+else:
+    ast_TypeAlias = Any
+    ast_ParamSpec = Any
+    ast_TypeVar = Any
+    ast_TypeVarTuple = Any
+
+if sys.version_info >= (3, 14):
+    ast_TemplateStr = ast3.TemplateStr
+    ast_Interpolation = ast3.Interpolation
+else:
+    ast_TemplateStr = Any
+    ast_Interpolation = Any
+
+N = TypeVar("N", bound=Node)
+
+# There is no way to create reasonable fallbacks at this stage,
+# they must be patched later.
+_dummy_fallback: Final = Instance(MISSING_FALLBACK, [], -1)
+
+TYPE_IGNORE_PATTERN: Final = re.compile(r"[^#]*#\s*type:\s*ignore\s*(.*)")
+
+
+def parse(
+    source: str | bytes,
+    fnam: str,
+    module: str | None,
+    errors: Errors,
+    options: Options | None = None,
+) -> MypyFile:
+    """Parse a source file, without doing any semantic analysis.
+
+    Return the parse tree. If errors is not provided, raise ParseError
+    on failure. Otherwise, use the errors object to report parse errors.
+    """
+    ignore_errors = (options is not None and options.ignore_errors) or (
+        fnam in errors.ignored_files
+    )
+    # If errors are ignored, we can drop many function bodies to speed up type checking.
+    strip_function_bodies = ignore_errors and (options is None or not options.preserve_asts)
+
+    if options is None:
+        options = Options()
+    errors.set_file(fnam, module, options=options)
+    is_stub_file = fnam.endswith(".pyi")
+    if is_stub_file:
+        feature_version = defaults.PYTHON3_VERSION[1]
+        if options.python_version[0] == 3 and options.python_version[1] > feature_version:
+            feature_version = options.python_version[1]
+    else:
+        assert options.python_version[0] >= 3
+        feature_version = options.python_version[1]
+    try:
+        # Disable
+        # - deprecation warnings for 'invalid escape sequence' (Python 3.11 and below)
+        # - syntax warnings for 'invalid escape sequence' (3.12+) and 'return in finally' (3.14+)
+        with warnings.catch_warnings():
+            warnings.filterwarnings("ignore", category=DeprecationWarning)
+            warnings.filterwarnings("ignore", category=SyntaxWarning)
+            ast = ast3_parse(source, fnam, "exec", feature_version=feature_version)
+
+        tree = ASTConverter(
+            options=options,
+            is_stub=is_stub_file,
+            errors=errors,
+            strip_function_bodies=strip_function_bodies,
+            path=fnam,
+        ).visit(ast)
+
+    except RecursionError as e:
+        # For very complex expressions it is possible to hit recursion limit
+        # before reaching a leaf node.
+        # Should reject at top level instead at bottom, since bottom would already
+        # be at the threshold of the recursion limit, and may fail again later.
+        # E.G. x1+x2+x3+...+xn -> BinOp(left=BinOp(left=BinOp(left=...
+        try:
+            # But to prove that is the cause of this particular recursion error,
+            # try to walk the tree using builtin visitor
+            ast3.NodeVisitor().visit(ast)
+        except RecursionError:
+            errors.report(
+                -1, -1, "Source expression too complex to parse", blocker=False, code=codes.MISC
+            )
+
+            tree = MypyFile([], [], False, {})
+
+        else:
+            # re-raise original recursion error if it *can* be unparsed,
+            # maybe this is some other issue that shouldn't be silenced/misdirected
+            raise e
+
+    except SyntaxError as e:
+        message = e.msg
+        if feature_version > sys.version_info.minor and message.startswith("invalid syntax"):
+            python_version_str = f"{options.python_version[0]}.{options.python_version[1]}"
+            message += f"; you likely need to run mypy using Python {python_version_str} or newer"
+        errors.report(
+            e.lineno if e.lineno is not None else -1,
+            e.offset,
+            re.sub(
+                r"^(\s*\w)", lambda m: m.group(1).upper(), message
+            ),  # Standardizing error message
+            blocker=True,
+            code=codes.SYNTAX,
+        )
+        tree = MypyFile([], [], False, {})
+
+    assert isinstance(tree, MypyFile)
+    return tree
+
+
+def parse_type_ignore_tag(tag: str | None) -> list[str] | None:
+    """Parse optional "[code, ...]" tag after "# type: ignore".
+
+    Return:
+     * [] if no tag was found (ignore all errors)
+     * list of ignored error codes if a tag was found
+     * None if the tag was invalid.
+    """
+    if not tag or tag.strip() == "" or tag.strip().startswith("#"):
+        # No tag -- ignore all errors.
+        return []
+    m = re.match(r"\s*\[([^]#]*)\]\s*(#.*)?$", tag)
+    if m is None:
+        # Invalid "# type: ignore" comment.
+        return None
+    return [stripped_code for code in m.group(1).split(",") if (stripped_code := code.strip())]
+
+
+def parse_type_comment(
+    type_comment: str, line: int, column: int, errors: Errors | None
+) -> tuple[list[str] | None, ProperType | None]:
+    """Parse type portion of a type comment (+ optional type ignore).
+
+    Return (ignore info, parsed type).
+    """
+    try:
+        typ = ast3_parse(type_comment, "<type_comment>", "eval")
+    except SyntaxError:
+        if errors is not None:
+            stripped_type = type_comment.split("#", 2)[0].strip()
+            err_msg = message_registry.TYPE_COMMENT_SYNTAX_ERROR_VALUE.format(stripped_type)
+            errors.report(line, column, err_msg.value, blocker=True, code=err_msg.code)
+            return None, None
+        else:
+            raise
+    else:
+        extra_ignore = TYPE_IGNORE_PATTERN.match(type_comment)
+        if extra_ignore:
+            tag: str | None = extra_ignore.group(1)
+            ignored: list[str] | None = parse_type_ignore_tag(tag)
+            if ignored is None:
+                if errors is not None:
+                    errors.report(
+                        line, column, message_registry.INVALID_TYPE_IGNORE.value, code=codes.SYNTAX
+                    )
+                else:
+                    raise SyntaxError
+        else:
+            ignored = None
+        assert isinstance(typ, ast3.Expression)
+        converted = TypeConverter(
+            errors, line=line, override_column=column, is_evaluated=False
+        ).visit(typ.body)
+        return ignored, converted
+
+
+def parse_type_string(
+    expr_string: str, expr_fallback_name: str, line: int, column: int
+) -> ProperType:
+    """Parses a type that was originally present inside of an explicit string.
+
+    For example, suppose we have the type `Foo["blah"]`. We should parse the
+    string expression "blah" using this function.
+    """
+    try:
+        _, node = parse_type_comment(f"({expr_string})", line=line, column=column, errors=None)
+        if isinstance(node, (UnboundType, UnionType)) and node.original_str_expr is None:
+            node.original_str_expr = expr_string
+            node.original_str_fallback = expr_fallback_name
+            return node
+        else:
+            return RawExpressionType(expr_string, expr_fallback_name, line, column)
+    except (SyntaxError, ValueError):
+        # Note: the parser will raise a `ValueError` instead of a SyntaxError if
+        # the string happens to contain things like \x00.
+        return RawExpressionType(expr_string, expr_fallback_name, line, column)
+
+
+def is_no_type_check_decorator(expr: ast3.expr) -> bool:
+    if isinstance(expr, Name):
+        return expr.id == "no_type_check"
+    elif isinstance(expr, Attribute):
+        if isinstance(expr.value, Name):
+            return expr.value.id == "typing" and expr.attr == "no_type_check"
+    return False
+
+
+def find_disallowed_expression_in_annotation_scope(expr: ast3.expr | None) -> ast3.expr | None:
+    if expr is None:
+        return None
+    for node in ast3.walk(expr):
+        if isinstance(node, (ast3.Yield, ast3.YieldFrom, ast3.NamedExpr, ast3.Await)):
+            return node
+    return None
+
+
+class ASTConverter:
+    def __init__(
+        self,
+        options: Options,
+        is_stub: bool,
+        errors: Errors,
+        *,
+        strip_function_bodies: bool,
+        path: str,
+    ) -> None:
+        # 'C' for class, 'D' for function signature, 'F' for function, 'L' for lambda
+        self.class_and_function_stack: list[Literal["C", "D", "F", "L"]] = []
+        self.imports: list[ImportBase] = []
+
+        self.options = options
+        self.is_stub = is_stub
+        self.errors = errors
+        self.strip_function_bodies = strip_function_bodies
+        self.path = path
+
+        self.type_ignores: dict[int, list[str]] = {}
+        self.uses_template_strings = False
+
+        # Cache of visit_X methods keyed by type of visited object
+        self.visitor_cache: dict[type, Callable[[AST | None], Any]] = {}
+
+    def note(self, msg: str, line: int, column: int) -> None:
+        self.errors.report(line, column, msg, severity="note", code=codes.SYNTAX)
+
+    def fail(self, msg: ErrorMessage, line: int, column: int, blocker: bool) -> None:
+        if blocker or not self.options.ignore_errors:
+            # Make sure self.errors reflects any type ignores that we have parsed
+            self.errors.set_file_ignored_lines(
+                self.path, self.type_ignores, self.options.ignore_errors
+            )
+            self.errors.report(line, column, msg.value, blocker=blocker, code=msg.code)
+
+    def fail_merge_overload(self, node: IfStmt) -> None:
+        self.fail(
+            message_registry.FAILED_TO_MERGE_OVERLOADS,
+            line=node.line,
+            column=node.column,
+            blocker=False,
+        )
+
+    def visit(self, node: AST | None) -> Any:
+        if node is None:
+            return None
+        typeobj = type(node)
+        visitor = self.visitor_cache.get(typeobj)
+        if visitor is None:
+            method = "visit_" + node.__class__.__name__
+            visitor = getattr(self, method)
+            self.visitor_cache[typeobj] = visitor
+
+        return visitor(node)
+
+    def set_line(self, node: N, n: AstNode) -> N:
+        node.line = n.lineno
+        node.column = n.col_offset
+        node.end_line = n.end_lineno
+        node.end_column = n.end_col_offset
+
+        return node
+
+    def translate_opt_expr_list(self, l: Sequence[AST | None]) -> list[Expression | None]:
+        res: list[Expression | None] = []
+        for e in l:
+            exp = self.visit(e)
+            res.append(exp)
+        return res
+
+    def translate_expr_list(self, l: Sequence[AST]) -> list[Expression]:
+        return cast(list[Expression], self.translate_opt_expr_list(l))
+
+    def get_lineno(self, node: ast3.expr | ast3.stmt) -> int:
+        if (
+            isinstance(node, (ast3.AsyncFunctionDef, ast3.ClassDef, ast3.FunctionDef))
+            and node.decorator_list
+        ):
+            return node.decorator_list[0].lineno
+        return node.lineno
+
+    def translate_stmt_list(
+        self,
+        stmts: Sequence[ast3.stmt],
+        *,
+        ismodule: bool = False,
+        can_strip: bool = False,
+        is_coroutine: bool = False,
+    ) -> list[Statement]:
+        # A "# type: ignore" comment before the first statement of a module
+        # ignores the whole module:
+        if (
+            ismodule
+            and stmts
+            and self.type_ignores
+            and (first := min(self.type_ignores)) < self.get_lineno(stmts[0])
+        ):
+            ignores = self.type_ignores.pop(first)
+            if ignores:
+                joined_ignores = ", ".join(ignores)
+                self.fail(
+                    message_registry.TYPE_IGNORE_WITH_ERRCODE_ON_MODULE.format(joined_ignores),
+                    line=first,
+                    column=0,
+                    blocker=False,
+                )
+            block = Block(self.fix_function_overloads(self.translate_stmt_list(stmts)))
+            self.set_block_lines(block, stmts)
+            mark_block_unreachable(block)
+            return [block]
+
+        stack = self.class_and_function_stack
+        # Fast case for stripping function bodies
+        if (
+            can_strip
+            and self.strip_function_bodies
+            and len(stack) == 1
+            and stack[0] == "F"
+            and not is_coroutine
+        ):
+            return []
+
+        res: list[Statement] = []
+        for stmt in stmts:
+            node = self.visit(stmt)
+            res.append(node)
+
+        # Slow case for stripping function bodies
+        if can_strip and self.strip_function_bodies:
+            if stack[-2:] == ["C", "F"]:
+                if is_possible_trivial_body(res):
+                    can_strip = False
+                else:
+                    # We only strip method bodies if they don't assign to an attribute, as
+                    # this may define an attribute which has an externally visible effect.
+                    visitor = FindAttributeAssign()
+                    for s in res:
+                        s.accept(visitor)
+                        if visitor.found:
+                            can_strip = False
+                            break
+
+            if can_strip and stack[-1] == "F" and is_coroutine:
+                # Yields inside an async function affect the return type and should not
+                # be stripped.
+                yield_visitor = FindYield()
+                for s in res:
+                    s.accept(yield_visitor)
+                    if yield_visitor.found:
+                        can_strip = False
+                        break
+
+            if can_strip:
+                return []
+        return res
+
+    def translate_type_comment(
+        self, n: ast3.stmt | ast3.arg, type_comment: str | None
+    ) -> ProperType | None:
+        if type_comment is None:
+            return None
+        else:
+            lineno = n.lineno
+            extra_ignore, typ = parse_type_comment(type_comment, lineno, n.col_offset, self.errors)
+            if extra_ignore is not None:
+                self.type_ignores[lineno] = extra_ignore
+            return typ
+
+    op_map: Final[dict[type[AST], str]] = {
+        ast3.Add: "+",
+        ast3.Sub: "-",
+        ast3.Mult: "*",
+        ast3.MatMult: "@",
+        ast3.Div: "/",
+        ast3.Mod: "%",
+        ast3.Pow: "**",
+        ast3.LShift: "<<",
+        ast3.RShift: ">>",
+        ast3.BitOr: "|",
+        ast3.BitXor: "^",
+        ast3.BitAnd: "&",
+        ast3.FloorDiv: "//",
+    }
+
+    def from_operator(self, op: ast3.operator) -> str:
+        op_name = ASTConverter.op_map.get(type(op))
+        if op_name is None:
+            raise RuntimeError("Unknown operator " + str(type(op)))
+        else:
+            return op_name
+
+    comp_op_map: Final[dict[type[AST], str]] = {
+        ast3.Gt: ">",
+        ast3.Lt: "<",
+        ast3.Eq: "==",
+        ast3.GtE: ">=",
+        ast3.LtE: "<=",
+        ast3.NotEq: "!=",
+        ast3.Is: "is",
+        ast3.IsNot: "is not",
+        ast3.In: "in",
+        ast3.NotIn: "not in",  # codespell:ignore notin
+    }
+
+    def from_comp_operator(self, op: ast3.cmpop) -> str:
+        op_name = ASTConverter.comp_op_map.get(type(op))
+        if op_name is None:
+            raise RuntimeError("Unknown comparison operator " + str(type(op)))
+        else:
+            return op_name
+
+    def set_block_lines(self, b: Block, stmts: Sequence[ast3.stmt]) -> None:
+        first, last = stmts[0], stmts[-1]
+        b.line = first.lineno
+        b.column = first.col_offset
+        b.end_line = last.end_lineno
+        b.end_column = last.end_col_offset
+        if not b.body:
+            return
+        new_first = b.body[0]
+        if isinstance(new_first, (Decorator, OverloadedFuncDef)):
+            # Decorated function lines are different between Python versions.
+            # copy the normalization we do for them to block first lines.
+            b.line = new_first.line
+            b.column = new_first.column
+
+    def as_block(self, stmts: list[ast3.stmt]) -> Block | None:
+        b = None
+        if stmts:
+            b = Block(self.fix_function_overloads(self.translate_stmt_list(stmts)))
+            self.set_block_lines(b, stmts)
+        return b
+
+    def as_required_block(
+        self, stmts: list[ast3.stmt], *, can_strip: bool = False, is_coroutine: bool = False
+    ) -> Block:
+        assert stmts  # must be non-empty
+        b = Block(
+            self.fix_function_overloads(
+                self.translate_stmt_list(stmts, can_strip=can_strip, is_coroutine=is_coroutine)
+            )
+        )
+        self.set_block_lines(b, stmts)
+        return b
+
+    def fix_function_overloads(self, stmts: list[Statement]) -> list[Statement]:
+        ret: list[Statement] = []
+        current_overload: list[OverloadPart] = []
+        current_overload_name: str | None = None
+        last_unconditional_func_def: str | None = None
+        last_if_stmt: IfStmt | None = None
+        last_if_overload: Decorator | FuncDef | OverloadedFuncDef | None = None
+        last_if_stmt_overload_name: str | None = None
+        last_if_unknown_truth_value: IfStmt | None = None
+        skipped_if_stmts: list[IfStmt] = []
+        for stmt in stmts:
+            if_overload_name: str | None = None
+            if_block_with_overload: Block | None = None
+            if_unknown_truth_value: IfStmt | None = None
+            if isinstance(stmt, IfStmt):
+                # Check IfStmt block to determine if function overloads can be merged
+                if_overload_name = self._check_ifstmt_for_overloads(stmt, current_overload_name)
+                if if_overload_name is not None:
+                    if_block_with_overload, if_unknown_truth_value = (
+                        self._get_executable_if_block_with_overloads(stmt)
+                    )
+
+            if (
+                current_overload_name is not None
+                and isinstance(stmt, (Decorator, FuncDef))
+                and stmt.name == current_overload_name
+            ):
+                if last_if_stmt is not None:
+                    skipped_if_stmts.append(last_if_stmt)
+                if last_if_overload is not None:
+                    # Last stmt was an IfStmt with same overload name
+                    # Add overloads to current_overload
+                    if isinstance(last_if_overload, OverloadedFuncDef):
+                        current_overload.extend(last_if_overload.items)
+                    else:
+                        current_overload.append(last_if_overload)
+                    last_if_stmt, last_if_overload = None, None
+                if last_if_unknown_truth_value:
+                    self.fail_merge_overload(last_if_unknown_truth_value)
+                    last_if_unknown_truth_value = None
+                current_overload.append(stmt)
+                if isinstance(stmt, FuncDef):
+                    # This is, strictly speaking, wrong: there might be a decorated
+                    # implementation. However, it only affects the error message we show:
+                    # ideally it's "already defined", but "implementation must come last"
+                    # is also reasonable.
+                    # TODO: can we get rid of this completely and just always emit
+                    # "implementation must come last" instead?
+                    last_unconditional_func_def = stmt.name
+            elif (
+                current_overload_name is not None
+                and isinstance(stmt, IfStmt)
+                and if_overload_name == current_overload_name
+                and last_unconditional_func_def != current_overload_name
+            ):
+                # IfStmt only contains stmts relevant to current_overload.
+                # Check if stmts are reachable and add them to current_overload,
+                # otherwise skip IfStmt to allow subsequent overload
+                # or function definitions.
+                skipped_if_stmts.append(stmt)
+                if if_block_with_overload is None:
+                    if if_unknown_truth_value is not None:
+                        self.fail_merge_overload(if_unknown_truth_value)
+                    continue
+                if last_if_overload is not None:
+                    # Last stmt was an IfStmt with same overload name
+                    # Add overloads to current_overload
+                    if isinstance(last_if_overload, OverloadedFuncDef):
+                        current_overload.extend(last_if_overload.items)
+                    else:
+                        current_overload.append(last_if_overload)
+                    last_if_stmt, last_if_overload = None, None
+                if isinstance(if_block_with_overload.body[-1], OverloadedFuncDef):
+                    skipped_if_stmts.extend(cast(list[IfStmt], if_block_with_overload.body[:-1]))
+                    current_overload.extend(if_block_with_overload.body[-1].items)
+                else:
+                    current_overload.append(
+                        cast(Decorator | FuncDef, if_block_with_overload.body[0])
+                    )
+            else:
+                if last_if_stmt is not None:
+                    ret.append(last_if_stmt)
+                    last_if_stmt_overload_name = current_overload_name
+                    last_if_stmt, last_if_overload = None, None
+                    last_if_unknown_truth_value = None
+
+                if current_overload and current_overload_name == last_if_stmt_overload_name:
+                    # Remove last stmt (IfStmt) from ret if the overload names matched
+                    # Only happens if no executable block had been found in IfStmt
+                    popped = ret.pop()
+                    assert isinstance(popped, IfStmt)
+                    skipped_if_stmts.append(popped)
+                if current_overload and skipped_if_stmts:
+                    # Add bare IfStmt (without overloads) to ret
+                    # Required for mypy to be able to still check conditions
+                    for if_stmt in skipped_if_stmts:
+                        self._strip_contents_from_if_stmt(if_stmt)
+                        ret.append(if_stmt)
+                    skipped_if_stmts = []
+                if len(current_overload) == 1:
+                    ret.append(current_overload[0])
+                elif len(current_overload) > 1:
+                    ret.append(OverloadedFuncDef(current_overload))
+
+                # If we have multiple decorated functions named "_" next to each, we want to treat
+                # them as a series of regular FuncDefs instead of one OverloadedFuncDef because
+                # most of mypy/mypyc assumes that all the functions in an OverloadedFuncDef are
+                # related, but multiple underscore functions next to each other aren't necessarily
+                # related
+                last_unconditional_func_def = None
+                if isinstance(stmt, Decorator) and not unnamed_function(stmt.name):
+                    current_overload = [stmt]
+                    current_overload_name = stmt.name
+                elif isinstance(stmt, IfStmt) and if_overload_name is not None:
+                    current_overload = []
+                    current_overload_name = if_overload_name
+                    last_if_stmt = stmt
+                    last_if_stmt_overload_name = None
+                    if if_block_with_overload is not None:
+                        skipped_if_stmts.extend(
+                            cast(list[IfStmt], if_block_with_overload.body[:-1])
+                        )
+                        last_if_overload = cast(
+                            Decorator | FuncDef | OverloadedFuncDef,
+                            if_block_with_overload.body[-1],
+                        )
+                    last_if_unknown_truth_value = if_unknown_truth_value
+                else:
+                    current_overload = []
+                    current_overload_name = None
+                    ret.append(stmt)
+
+        if current_overload and skipped_if_stmts:
+            # Add bare IfStmt (without overloads) to ret
+            # Required for mypy to be able to still check conditions
+            for if_stmt in skipped_if_stmts:
+                self._strip_contents_from_if_stmt(if_stmt)
+                ret.append(if_stmt)
+        if len(current_overload) == 1:
+            ret.append(current_overload[0])
+        elif len(current_overload) > 1:
+            ret.append(OverloadedFuncDef(current_overload))
+        elif last_if_overload is not None:
+            ret.append(last_if_overload)
+        elif last_if_stmt is not None:
+            ret.append(last_if_stmt)
+        return ret
+
+    def _check_ifstmt_for_overloads(
+        self, stmt: IfStmt, current_overload_name: str | None = None
+    ) -> str | None:
+        """Check if IfStmt contains only overloads with the same name.
+        Return overload_name if found, None otherwise.
+        """
+        # Check that block only contains a single Decorator, FuncDef, or OverloadedFuncDef.
+        # Multiple overloads have already been merged as OverloadedFuncDef.
+        if not (
+            len(stmt.body[0].body) == 1
+            and (
+                isinstance(stmt.body[0].body[0], (Decorator, OverloadedFuncDef))
+                or current_overload_name is not None
+                and isinstance(stmt.body[0].body[0], FuncDef)
+            )
+            or len(stmt.body[0].body) > 1
+            and isinstance(stmt.body[0].body[-1], OverloadedFuncDef)
+            and all(self._is_stripped_if_stmt(if_stmt) for if_stmt in stmt.body[0].body[:-1])
+        ):
+            return None
+
+        overload_name = cast(Decorator | FuncDef | OverloadedFuncDef, stmt.body[0].body[-1]).name
+        if stmt.else_body is None:
+            return overload_name
+
+        if len(stmt.else_body.body) == 1:
+            # For elif: else_body contains an IfStmt itself -> do a recursive check.
+            if (
+                isinstance(stmt.else_body.body[0], (Decorator, FuncDef, OverloadedFuncDef))
+                and stmt.else_body.body[0].name == overload_name
+            ):
+                return overload_name
+            if (
+                isinstance(stmt.else_body.body[0], IfStmt)
+                and self._check_ifstmt_for_overloads(stmt.else_body.body[0], current_overload_name)
+                == overload_name
+            ):
+                return overload_name
+
+        return None
+
+    def _get_executable_if_block_with_overloads(
+        self, stmt: IfStmt
+    ) -> tuple[Block | None, IfStmt | None]:
+        """Return block from IfStmt that will get executed.
+
+        Return
+            0 -> A block if sure that alternative blocks are unreachable.
+            1 -> An IfStmt if the reachability of it can't be inferred,
+                 i.e. the truth value is unknown.
+        """
+        infer_reachability_of_if_statement(stmt, self.options)
+        if stmt.else_body is None and stmt.body[0].is_unreachable is True:
+            # always False condition with no else
+            return None, None
+        if (
+            stmt.else_body is None
+            or stmt.body[0].is_unreachable is False
+            and stmt.else_body.is_unreachable is False
+        ):
+            # The truth value is unknown, thus not conclusive
+            return None, stmt
+        if stmt.else_body.is_unreachable is True:
+            # else_body will be set unreachable if condition is always True
+            return stmt.body[0], None
+        if stmt.body[0].is_unreachable is True:
+            # body will be set unreachable if condition is always False
+            # else_body can contain an IfStmt itself (for elif) -> do a recursive check
+            if isinstance(stmt.else_body.body[0], IfStmt):
+                return self._get_executable_if_block_with_overloads(stmt.else_body.body[0])
+            return stmt.else_body, None
+        return None, stmt
+
+    def _strip_contents_from_if_stmt(self, stmt: IfStmt) -> None:
+        """Remove contents from IfStmt.
+
+        Needed to still be able to check the conditions after the contents
+        have been merged with the surrounding function overloads.
+        """
+        if len(stmt.body) == 1:
+            stmt.body[0].body = []
+        if stmt.else_body and len(stmt.else_body.body) == 1:
+            if isinstance(stmt.else_body.body[0], IfStmt):
+                self._strip_contents_from_if_stmt(stmt.else_body.body[0])
+            else:
+                stmt.else_body.body = []
+
+    def _is_stripped_if_stmt(self, stmt: Statement) -> bool:
+        """Check stmt to make sure it is a stripped IfStmt.
+
+        See also: _strip_contents_from_if_stmt
+        """
+        if not isinstance(stmt, IfStmt):
+            return False
+
+        if not (len(stmt.body) == 1 and len(stmt.body[0].body) == 0):
+            # Body not empty
+            return False
+
+        if not stmt.else_body or len(stmt.else_body.body) == 0:
+            # No or empty else_body
+            return True
+
+        # For elif, IfStmt are stored recursively in else_body
+        return self._is_stripped_if_stmt(stmt.else_body.body[0])
+
+    def translate_module_id(self, id: str) -> str:
+        """Return the actual, internal module id for a source text id."""
+        if id == self.options.custom_typing_module:
+            return "typing"
+        return id
+
+    def visit_Module(self, mod: ast3.Module) -> MypyFile:
+        self.type_ignores = {}
+        self.uses_template_strings = False
+        for ti in mod.type_ignores:
+            parsed = parse_type_ignore_tag(ti.tag)
+            if parsed is not None:
+                self.type_ignores[ti.lineno] = parsed
+            else:
+                self.fail(message_registry.INVALID_TYPE_IGNORE, ti.lineno, -1, blocker=False)
+
+        body = self.fix_function_overloads(self.translate_stmt_list(mod.body, ismodule=True))
+
+        ret = MypyFile(body, self.imports, False, ignored_lines=self.type_ignores)
+        ret.is_stub = self.is_stub
+        ret.path = self.path
+        ret.uses_template_strings = self.uses_template_strings
+        return ret
+
+    # --- stmt ---
+    # FunctionDef(identifier name, arguments args,
+    #             stmt* body, expr* decorator_list, expr? returns, string? type_comment)
+    # arguments = (arg* args, arg? vararg, arg* kwonlyargs, expr* kw_defaults,
+    #              arg? kwarg, expr* defaults)
+    def visit_FunctionDef(self, n: ast3.FunctionDef) -> FuncDef | Decorator:
+        return self.do_func_def(n)
+
+    # AsyncFunctionDef(identifier name, arguments args,
+    #                  stmt* body, expr* decorator_list, expr? returns, string? type_comment)
+    def visit_AsyncFunctionDef(self, n: ast3.AsyncFunctionDef) -> FuncDef | Decorator:
+        return self.do_func_def(n, is_coroutine=True)
+
+    def do_func_def(
+        self, n: ast3.FunctionDef | ast3.AsyncFunctionDef, is_coroutine: bool = False
+    ) -> FuncDef | Decorator:
+        """Helper shared between visit_FunctionDef and visit_AsyncFunctionDef."""
+        self.class_and_function_stack.append("D")
+        no_type_check = bool(
+            n.decorator_list and any(is_no_type_check_decorator(d) for d in n.decorator_list)
+        )
+
+        lineno = n.lineno
+        args = self.transform_args(n.args, lineno, no_type_check=no_type_check)
+        if self.options.pos_only_special_methods and special_function_elide_names(n.name):
+            for arg in args:
+                arg.pos_only = True
+
+        arg_kinds = [arg.kind for arg in args]
+        arg_names = [None if arg.pos_only else arg.variable.name for arg in args]
+        # Type parameters, if using new syntax for generics (PEP 695)
+        explicit_type_params: list[TypeParam] | None = None
+
+        arg_types: list[Type | None] = []
+        if no_type_check:
+            arg_types = [None] * len(args)
+            return_type = None
+        elif n.type_comment is not None:
+            try:
+                func_type_ast = ast3_parse(n.type_comment, "<func_type>", "func_type")
+                assert isinstance(func_type_ast, FunctionType)
+                # for ellipsis arg
+                if (
+                    len(func_type_ast.argtypes) == 1
+                    and isinstance(func_type_ast.argtypes[0], ast3.Constant)
+                    and func_type_ast.argtypes[0].value is Ellipsis
+                ):
+                    if n.returns:
+                        # PEP 484 disallows both type annotations and type comments
+                        self.fail(
+                            message_registry.DUPLICATE_TYPE_SIGNATURES,
+                            lineno,
+                            n.col_offset,
+                            blocker=False,
+                        )
+                    arg_types = [
+                        (
+                            a.type_annotation
+                            if a.type_annotation is not None
+                            else AnyType(TypeOfAny.unannotated)
+                        )
+                        for a in args
+                    ]
+                else:
+                    # PEP 484 disallows both type annotations and type comments
+                    if n.returns or any(a.type_annotation is not None for a in args):
+                        self.fail(
+                            message_registry.DUPLICATE_TYPE_SIGNATURES,
+                            lineno,
+                            n.col_offset,
+                            blocker=False,
+                        )
+                    translated_args: list[Type] = TypeConverter(
+                        self.errors, line=lineno, override_column=n.col_offset
+                    ).translate_expr_list(func_type_ast.argtypes)
+                    # Use a cast to work around `list` invariance
+                    arg_types = cast(list[Type | None], translated_args)
+                return_type = TypeConverter(self.errors, line=lineno).visit(func_type_ast.returns)
+
+                # add implicit self type
+                in_method_scope = self.class_and_function_stack[-2:] == ["C", "D"]
+                if in_method_scope and len(arg_types) < len(args):
+                    arg_types.insert(0, AnyType(TypeOfAny.special_form))
+            except SyntaxError:
+                stripped_type = n.type_comment.split("#", 2)[0].strip()
+                err_msg = message_registry.TYPE_COMMENT_SYNTAX_ERROR_VALUE.format(stripped_type)
+                self.fail(err_msg, lineno, n.col_offset, blocker=False)
+                if n.type_comment and n.type_comment[0] not in ["(", "#"]:
+                    self.note(
+                        "Suggestion: wrap argument types in parentheses", lineno, n.col_offset
+                    )
+                arg_types = [AnyType(TypeOfAny.from_error)] * len(args)
+                return_type = AnyType(TypeOfAny.from_error)
+        else:
+            if sys.version_info >= (3, 12) and n.type_params:
+                explicit_type_params = self.translate_type_params(n.type_params)
+
+            arg_types = [a.type_annotation for a in args]
+            return_type = TypeConverter(
+                self.errors, line=n.returns.lineno if n.returns else lineno
+            ).visit(n.returns)
+
+        for arg, arg_type in zip(args, arg_types):
+            self.set_type_optional(arg_type, arg.initializer)
+
+        func_type = None
+        if any(arg_types) or return_type:
+            if len(arg_types) != 1 and any(isinstance(t, EllipsisType) for t in arg_types):
+                self.fail(
+                    message_registry.ELLIPSIS_WITH_OTHER_TYPEPARAMS,
+                    lineno,
+                    n.col_offset,
+                    blocker=False,
+                )
+            elif len(arg_types) > len(arg_kinds):
+                self.fail(
+                    message_registry.TYPE_SIGNATURE_TOO_MANY_PARAMS,
+                    lineno,
+                    n.col_offset,
+                    blocker=False,
+                )
+            elif len(arg_types) < len(arg_kinds):
+                self.fail(
+                    message_registry.TYPE_SIGNATURE_TOO_FEW_PARAMS,
+                    lineno,
+                    n.col_offset,
+                    blocker=False,
+                )
+            else:
+                func_type = CallableType(
+                    [a if a is not None else AnyType(TypeOfAny.unannotated) for a in arg_types],
+                    arg_kinds,
+                    arg_names,
+                    return_type if return_type is not None else AnyType(TypeOfAny.unannotated),
+                    _dummy_fallback,
+                )
+
+        # End position is always the same.
+        end_line = n.end_lineno
+        end_column = n.end_col_offset
+
+        self.class_and_function_stack.pop()
+        self.class_and_function_stack.append("F")
+        body = self.as_required_block(n.body, can_strip=True, is_coroutine=is_coroutine)
+        func_def = FuncDef(n.name, args, body, func_type, explicit_type_params)
+        if isinstance(func_def.type, CallableType):
+            # semanal.py does some in-place modifications we want to avoid
+            func_def.unanalyzed_type = func_def.type.copy_modified()
+        if is_coroutine:
+            func_def.is_coroutine = True
+        if func_type is not None:
+            func_type.definition = func_def
+            func_type.set_line(lineno)
+
+        if n.decorator_list:
+            var = Var(func_def.name)
+            var.is_ready = False
+            var.set_line(lineno)
+
+            func_def.is_decorated = True
+            self.set_line(func_def, n)
+
+            deco = Decorator(func_def, self.translate_expr_list(n.decorator_list), var)
+            first = n.decorator_list[0]
+            deco.set_line(first.lineno, first.col_offset, end_line, end_column)
+            retval: FuncDef | Decorator = deco
+        else:
+            self.set_line(func_def, n)
+            retval = func_def
+        if self.options.include_docstrings:
+            func_def.docstring = ast3.get_docstring(n, clean=False)
+        self.class_and_function_stack.pop()
+        return retval
+
+    def set_type_optional(self, type: Type | None, initializer: Expression | None) -> None:
+        if not self.options.implicit_optional:
+            return
+        # Indicate that type should be wrapped in an Optional if arg is initialized to None.
+        optional = isinstance(initializer, NameExpr) and initializer.name == "None"
+        if isinstance(type, UnboundType):
+            type.optional = optional
+
+    def transform_args(
+        self, args: ast3.arguments, line: int, no_type_check: bool = False
+    ) -> list[Argument]:
+        new_args = []
+        names: list[ast3.arg] = []
+        posonlyargs = args.posonlyargs
+        args_args = posonlyargs + args.args
+        args_defaults = args.defaults
+        num_no_defaults = len(args_args) - len(args_defaults)
+        # positional arguments without defaults
+        for i, a in enumerate(args_args[:num_no_defaults]):
+            pos_only = i < len(posonlyargs)
+            new_args.append(self.make_argument(a, None, ARG_POS, no_type_check, pos_only))
+            names.append(a)
+
+        # positional arguments with defaults
+        for i, (a, d) in enumerate(zip(args_args[num_no_defaults:], args_defaults)):
+            pos_only = num_no_defaults + i < len(posonlyargs)
+            new_args.append(self.make_argument(a, d, ARG_OPT, no_type_check, pos_only))
+            names.append(a)
+
+        # *arg
+        if args.vararg is not None:
+            new_args.append(self.make_argument(args.vararg, None, ARG_STAR, no_type_check))
+            names.append(args.vararg)
+
+        # keyword-only arguments with defaults
+        for a, kd in zip(args.kwonlyargs, args.kw_defaults):
+            new_args.append(
+                self.make_argument(
+                    a, kd, ARG_NAMED if kd is None else ARG_NAMED_OPT, no_type_check
+                )
+            )
+            names.append(a)
+
+        # **kwarg
+        if args.kwarg is not None:
+            new_args.append(self.make_argument(args.kwarg, None, ARG_STAR2, no_type_check))
+            names.append(args.kwarg)
+
+        check_param_names([arg.variable.name for arg in new_args], names, self.fail_arg)
+
+        return new_args
+
+    def make_argument(
+        self,
+        arg: ast3.arg,
+        default: ast3.expr | None,
+        kind: ArgKind,
+        no_type_check: bool,
+        pos_only: bool = False,
+    ) -> Argument:
+        if no_type_check:
+            arg_type = None
+        else:
+            annotation = arg.annotation
+            type_comment = arg.type_comment
+            if annotation is not None and type_comment is not None:
+                self.fail(
+                    message_registry.DUPLICATE_TYPE_SIGNATURES,
+                    arg.lineno,
+                    arg.col_offset,
+                    blocker=False,
+                )
+            arg_type = None
+            if annotation is not None:
+                arg_type = TypeConverter(self.errors, line=arg.lineno).visit(annotation)
+            else:
+                arg_type = self.translate_type_comment(arg, type_comment)
+        if argument_elide_name(arg.arg):
+            pos_only = True
+
+        var = Var(arg.arg, arg_type)
+        var.is_inferred = False
+        var.is_argument = True
+        argument = Argument(var, arg_type, self.visit(default), kind, pos_only)
+        argument.set_line(arg.lineno, arg.col_offset, arg.end_lineno, arg.end_col_offset)
+        return argument
+
+    def fail_arg(self, msg: str, arg: ast3.arg) -> None:
+        self.fail(ErrorMessage(msg), arg.lineno, arg.col_offset, blocker=True)
+
+    # ClassDef(identifier name,
+    #  expr* bases,
+    #  keyword* keywords,
+    #  stmt* body,
+    #  expr* decorator_list)
+    def visit_ClassDef(self, n: ast3.ClassDef) -> ClassDef:
+        self.class_and_function_stack.append("C")
+        keywords = [(kw.arg, self.visit(kw.value)) for kw in n.keywords if kw.arg]
+
+        # Type parameters, if using new syntax for generics (PEP 695)
+        explicit_type_params: list[TypeParam] | None = None
+
+        if sys.version_info >= (3, 12) and n.type_params:
+            explicit_type_params = self.translate_type_params(n.type_params)
+
+        cdef = ClassDef(
+            n.name,
+            self.as_required_block(n.body),
+            None,
+            self.translate_expr_list(n.bases),
+            metaclass=dict(keywords).get("metaclass"),
+            keywords=keywords,
+            type_args=explicit_type_params,
+        )
+        cdef.decorators = self.translate_expr_list(n.decorator_list)
+        self.set_line(cdef, n)
+
+        if self.options.include_docstrings:
+            cdef.docstring = ast3.get_docstring(n, clean=False)
+        cdef.column = n.col_offset
+        cdef.end_line = n.end_lineno
+        cdef.end_column = n.end_col_offset
+        self.class_and_function_stack.pop()
+        return cdef
+
+    def validate_type_param(self, type_param: ast_TypeVar) -> None:
+        incorrect_expr = find_disallowed_expression_in_annotation_scope(type_param.bound)
+        if incorrect_expr is None:
+            return
+        if isinstance(incorrect_expr, (ast3.Yield, ast3.YieldFrom)):
+            self.fail(
+                message_registry.TYPE_VAR_YIELD_EXPRESSION_IN_BOUND,
+                type_param.lineno,
+                type_param.col_offset,
+                blocker=True,
+            )
+        if isinstance(incorrect_expr, ast3.NamedExpr):
+            self.fail(
+                message_registry.TYPE_VAR_NAMED_EXPRESSION_IN_BOUND,
+                type_param.lineno,
+                type_param.col_offset,
+                blocker=True,
+            )
+        if isinstance(incorrect_expr, ast3.Await):
+            self.fail(
+                message_registry.TYPE_VAR_AWAIT_EXPRESSION_IN_BOUND,
+                type_param.lineno,
+                type_param.col_offset,
+                blocker=True,
+            )
+
+    def translate_type_params(self, type_params: list[Any]) -> list[TypeParam]:
+        explicit_type_params = []
+        for p in type_params:
+            bound: Type | None = None
+            values: list[Type] = []
+            default: Type | None = None
+            if sys.version_info >= (3, 13):
+                default = TypeConverter(self.errors, line=p.lineno).visit(p.default_value)
+            if isinstance(p, ast_ParamSpec):  # type: ignore[misc]
+                explicit_type_params.append(TypeParam(p.name, PARAM_SPEC_KIND, None, [], default))
+            elif isinstance(p, ast_TypeVarTuple):  # type: ignore[misc]
+                explicit_type_params.append(
+                    TypeParam(p.name, TYPE_VAR_TUPLE_KIND, None, [], default)
+                )
+            else:
+                if isinstance(p.bound, ast3.Tuple):
+                    if len(p.bound.elts) < 2:
+                        self.fail(
+                            message_registry.TYPE_VAR_TOO_FEW_CONSTRAINED_TYPES,
+                            p.lineno,
+                            p.col_offset,
+                            blocker=False,
+                        )
+                    else:
+                        conv = TypeConverter(self.errors, line=p.lineno)
+                        values = [conv.visit(t) for t in p.bound.elts]
+                elif p.bound is not None:
+                    self.validate_type_param(p)
+                    bound = TypeConverter(self.errors, line=p.lineno).visit(p.bound)
+                explicit_type_params.append(
+                    TypeParam(p.name, TYPE_VAR_KIND, bound, values, default)
+                )
+        return explicit_type_params
+
+    # Return(expr? value)
+    def visit_Return(self, n: ast3.Return) -> ReturnStmt:
+        node = ReturnStmt(self.visit(n.value))
+        return self.set_line(node, n)
+
+    # Delete(expr* targets)
+    def visit_Delete(self, n: ast3.Delete) -> DelStmt:
+        if len(n.targets) > 1:
+            tup = TupleExpr(self.translate_expr_list(n.targets))
+            tup.set_line(n.lineno)
+            node = DelStmt(tup)
+        else:
+            node = DelStmt(self.visit(n.targets[0]))
+        return self.set_line(node, n)
+
+    # Assign(expr* targets, expr? value, string? type_comment, expr? annotation)
+    def visit_Assign(self, n: ast3.Assign) -> AssignmentStmt:
+        lvalues = self.translate_expr_list(n.targets)
+        rvalue = self.visit(n.value)
+        typ = self.translate_type_comment(n, n.type_comment)
+        s = AssignmentStmt(lvalues, rvalue, type=typ, new_syntax=False)
+        return self.set_line(s, n)
+
+    # AnnAssign(expr target, expr annotation, expr? value, int simple)
+    def visit_AnnAssign(self, n: ast3.AnnAssign) -> AssignmentStmt:
+        line = n.lineno
+        if n.value is None:  # always allow 'x: int'
+            rvalue: Expression = TempNode(AnyType(TypeOfAny.special_form), no_rhs=True)
+            self.set_line(rvalue, n)
+        else:
+            rvalue = self.visit(n.value)
+        typ = TypeConverter(self.errors, line=line).visit(n.annotation)
+        assert typ is not None
+        typ.column = n.annotation.col_offset
+        s = AssignmentStmt([self.visit(n.target)], rvalue, type=typ, new_syntax=True)
+        return self.set_line(s, n)
+
+    # AugAssign(expr target, operator op, expr value)
+    def visit_AugAssign(self, n: ast3.AugAssign) -> OperatorAssignmentStmt:
+        s = OperatorAssignmentStmt(
+            self.from_operator(n.op), self.visit(n.target), self.visit(n.value)
+        )
+        return self.set_line(s, n)
+
+    # For(expr target, expr iter, stmt* body, stmt* orelse, string? type_comment)
+    def visit_For(self, n: ast3.For) -> ForStmt:
+        target_type = self.translate_type_comment(n, n.type_comment)
+        node = ForStmt(
+            self.visit(n.target),
+            self.visit(n.iter),
+            self.as_required_block(n.body),
+            self.as_block(n.orelse),
+            target_type,
+        )
+        return self.set_line(node, n)
+
+    # AsyncFor(expr target, expr iter, stmt* body, stmt* orelse, string? type_comment)
+    def visit_AsyncFor(self, n: ast3.AsyncFor) -> ForStmt:
+        target_type = self.translate_type_comment(n, n.type_comment)
+        node = ForStmt(
+            self.visit(n.target),
+            self.visit(n.iter),
+            self.as_required_block(n.body),
+            self.as_block(n.orelse),
+            target_type,
+        )
+        node.is_async = True
+        return self.set_line(node, n)
+
+    # While(expr test, stmt* body, stmt* orelse)
+    def visit_While(self, n: ast3.While) -> WhileStmt:
+        node = WhileStmt(
+            self.visit(n.test), self.as_required_block(n.body), self.as_block(n.orelse)
+        )
+        return self.set_line(node, n)
+
+    # If(expr test, stmt* body, stmt* orelse)
+    def visit_If(self, n: ast3.If) -> IfStmt:
+        node = IfStmt(
+            [self.visit(n.test)], [self.as_required_block(n.body)], self.as_block(n.orelse)
+        )
+        return self.set_line(node, n)
+
+    # With(withitem* items, stmt* body, string? type_comment)
+    def visit_With(self, n: ast3.With) -> WithStmt:
+        target_type = self.translate_type_comment(n, n.type_comment)
+        node = WithStmt(
+            [self.visit(i.context_expr) for i in n.items],
+            [self.visit(i.optional_vars) for i in n.items],
+            self.as_required_block(n.body),
+            target_type,
+        )
+        return self.set_line(node, n)
+
+    # AsyncWith(withitem* items, stmt* body, string? type_comment)
+    def visit_AsyncWith(self, n: ast3.AsyncWith) -> WithStmt:
+        target_type = self.translate_type_comment(n, n.type_comment)
+        s = WithStmt(
+            [self.visit(i.context_expr) for i in n.items],
+            [self.visit(i.optional_vars) for i in n.items],
+            self.as_required_block(n.body),
+            target_type,
+        )
+        s.is_async = True
+        return self.set_line(s, n)
+
+    # Raise(expr? exc, expr? cause)
+    def visit_Raise(self, n: ast3.Raise) -> RaiseStmt:
+        node = RaiseStmt(self.visit(n.exc), self.visit(n.cause))
+        return self.set_line(node, n)
+
+    # Try(stmt* body, excepthandler* handlers, stmt* orelse, stmt* finalbody)
+    def visit_Try(self, n: ast3.Try) -> TryStmt:
+        vs = [
+            self.set_line(NameExpr(h.name), h) if h.name is not None else None for h in n.handlers
+        ]
+        types = [self.visit(h.type) for h in n.handlers]
+        handlers = [self.as_required_block(h.body) for h in n.handlers]
+
+        node = TryStmt(
+            self.as_required_block(n.body),
+            vs,
+            types,
+            handlers,
+            self.as_block(n.orelse),
+            self.as_block(n.finalbody),
+        )
+        return self.set_line(node, n)
+
+    def visit_TryStar(self, n: TryStar) -> TryStmt:
+        vs = [
+            self.set_line(NameExpr(h.name), h) if h.name is not None else None for h in n.handlers
+        ]
+        types = [self.visit(h.type) for h in n.handlers]
+        handlers = [self.as_required_block(h.body) for h in n.handlers]
+
+        node = TryStmt(
+            self.as_required_block(n.body),
+            vs,
+            types,
+            handlers,
+            self.as_block(n.orelse),
+            self.as_block(n.finalbody),
+        )
+        node.is_star = True
+        return self.set_line(node, n)
+
+    # Assert(expr test, expr? msg)
+    def visit_Assert(self, n: ast3.Assert) -> AssertStmt:
+        node = AssertStmt(self.visit(n.test), self.visit(n.msg))
+        return self.set_line(node, n)
+
+    # Import(alias* names)
+    def visit_Import(self, n: ast3.Import) -> Import:
+        names: list[tuple[str, str | None]] = []
+        for alias in n.names:
+            name = self.translate_module_id(alias.name)
+            asname = alias.asname
+            if asname is None and name != alias.name:
+                # if the module name has been translated (and it's not already
+                # an explicit import-as), make it an implicit import-as the
+                # original name
+                asname = alias.name
+            names.append((name, asname))
+        i = Import(names)
+        self.imports.append(i)
+        return self.set_line(i, n)
+
+    # ImportFrom(identifier? module, alias* names, int? level)
+    def visit_ImportFrom(self, n: ast3.ImportFrom) -> ImportBase:
+        assert n.level is not None
+        if len(n.names) == 1 and n.names[0].name == "*":
+            mod = n.module if n.module is not None else ""
+            i: ImportBase = ImportAll(mod, n.level)
+        else:
+            i = ImportFrom(
+                self.translate_module_id(n.module) if n.module is not None else "",
+                n.level,
+                [(a.name, a.asname) for a in n.names],
+            )
+        self.imports.append(i)
+        return self.set_line(i, n)
+
+    # Global(identifier* names)
+    def visit_Global(self, n: ast3.Global) -> GlobalDecl:
+        g = GlobalDecl(n.names)
+        return self.set_line(g, n)
+
+    # Nonlocal(identifier* names)
+    def visit_Nonlocal(self, n: ast3.Nonlocal) -> NonlocalDecl:
+        d = NonlocalDecl(n.names)
+        return self.set_line(d, n)
+
+    # Expr(expr value)
+    def visit_Expr(self, n: ast3.Expr) -> ExpressionStmt:
+        value = self.visit(n.value)
+        node = ExpressionStmt(value)
+        return self.set_line(node, n)
+
+    # Pass
+    def visit_Pass(self, n: ast3.Pass) -> PassStmt:
+        s = PassStmt()
+        return self.set_line(s, n)
+
+    # Break
+    def visit_Break(self, n: ast3.Break) -> BreakStmt:
+        s = BreakStmt()
+        return self.set_line(s, n)
+
+    # Continue
+    def visit_Continue(self, n: ast3.Continue) -> ContinueStmt:
+        s = ContinueStmt()
+        return self.set_line(s, n)
+
+    # --- expr ---
+
+    def visit_NamedExpr(self, n: ast3.NamedExpr) -> AssignmentExpr:
+        s = AssignmentExpr(self.visit(n.target), self.visit(n.value))
+        return self.set_line(s, n)
+
+    # BoolOp(boolop op, expr* values)
+    def visit_BoolOp(self, n: ast3.BoolOp) -> OpExpr:
+        # mypy translates (1 and 2 and 3) as (1 and (2 and 3))
+        assert len(n.values) >= 2
+        op_node = n.op
+        if isinstance(op_node, ast3.And):
+            op = "and"
+        elif isinstance(op_node, ast3.Or):
+            op = "or"
+        else:
+            raise RuntimeError("unknown BoolOp " + str(type(n)))
+
+        # potentially inefficient!
+        return self.group(op, self.translate_expr_list(n.values), n)
+
+    def group(self, op: str, vals: list[Expression], n: ast3.expr) -> OpExpr:
+        if len(vals) == 2:
+            e = OpExpr(op, vals[0], vals[1])
+        else:
+            e = OpExpr(op, vals[0], self.group(op, vals[1:], n))
+        return self.set_line(e, n)
+
+    # BinOp(expr left, operator op, expr right)
+    def visit_BinOp(self, n: ast3.BinOp) -> OpExpr:
+        op = self.from_operator(n.op)
+
+        if op is None:
+            raise RuntimeError("cannot translate BinOp " + str(type(n.op)))
+
+        e = OpExpr(op, self.visit(n.left), self.visit(n.right))
+        return self.set_line(e, n)
+
+    # UnaryOp(unaryop op, expr operand)
+    def visit_UnaryOp(self, n: ast3.UnaryOp) -> UnaryExpr:
+        op = None
+        if isinstance(n.op, ast3.Invert):
+            op = "~"
+        elif isinstance(n.op, ast3.Not):
+            op = "not"
+        elif isinstance(n.op, ast3.UAdd):
+            op = "+"
+        elif isinstance(n.op, ast3.USub):
+            op = "-"
+
+        if op is None:
+            raise RuntimeError("cannot translate UnaryOp " + str(type(n.op)))
+
+        e = UnaryExpr(op, self.visit(n.operand))
+        return self.set_line(e, n)
+
+    # Lambda(arguments args, expr body)
+    def visit_Lambda(self, n: ast3.Lambda) -> LambdaExpr:
+        body = ast3.Return(n.body)
+        body.lineno = n.body.lineno
+        body.col_offset = n.body.col_offset
+
+        self.class_and_function_stack.append("L")
+        e = LambdaExpr(self.transform_args(n.args, n.lineno), self.as_required_block([body]))
+        self.class_and_function_stack.pop()
+        e.set_line(n.lineno, n.col_offset)  # Overrides set_line -- can't use self.set_line
+        return e
+
+    # IfExp(expr test, expr body, expr orelse)
+    def visit_IfExp(self, n: ast3.IfExp) -> ConditionalExpr:
+        e = ConditionalExpr(self.visit(n.test), self.visit(n.body), self.visit(n.orelse))
+        return self.set_line(e, n)
+
+    # Dict(expr* keys, expr* values)
+    def visit_Dict(self, n: ast3.Dict) -> DictExpr:
+        e = DictExpr(
+            list(zip(self.translate_opt_expr_list(n.keys), self.translate_expr_list(n.values)))
+        )
+        return self.set_line(e, n)
+
+    # Set(expr* elts)
+    def visit_Set(self, n: ast3.Set) -> SetExpr:
+        e = SetExpr(self.translate_expr_list(n.elts))
+        return self.set_line(e, n)
+
+    # ListComp(expr elt, comprehension* generators)
+    def visit_ListComp(self, n: ast3.ListComp) -> ListComprehension:
+        e = ListComprehension(self.visit_GeneratorExp(cast(ast3.GeneratorExp, n)))
+        return self.set_line(e, n)
+
+    # SetComp(expr elt, comprehension* generators)
+    def visit_SetComp(self, n: ast3.SetComp) -> SetComprehension:
+        e = SetComprehension(self.visit_GeneratorExp(cast(ast3.GeneratorExp, n)))
+        return self.set_line(e, n)
+
+    # DictComp(expr key, expr value, comprehension* generators)
+    def visit_DictComp(self, n: ast3.DictComp) -> DictionaryComprehension:
+        targets = [self.visit(c.target) for c in n.generators]
+        iters = [self.visit(c.iter) for c in n.generators]
+        ifs_list = [self.translate_expr_list(c.ifs) for c in n.generators]
+        is_async = [bool(c.is_async) for c in n.generators]
+        e = DictionaryComprehension(
+            self.visit(n.key), self.visit(n.value), targets, iters, ifs_list, is_async
+        )
+        return self.set_line(e, n)
+
+    # GeneratorExp(expr elt, comprehension* generators)
+    def visit_GeneratorExp(self, n: ast3.GeneratorExp) -> GeneratorExpr:
+        targets = [self.visit(c.target) for c in n.generators]
+        iters = [self.visit(c.iter) for c in n.generators]
+        ifs_list = [self.translate_expr_list(c.ifs) for c in n.generators]
+        is_async = [bool(c.is_async) for c in n.generators]
+        e = GeneratorExpr(self.visit(n.elt), targets, iters, ifs_list, is_async)
+        return self.set_line(e, n)
+
+    # Await(expr value)
+    def visit_Await(self, n: ast3.Await) -> AwaitExpr:
+        v = self.visit(n.value)
+        e = AwaitExpr(v)
+        return self.set_line(e, n)
+
+    # Yield(expr? value)
+    def visit_Yield(self, n: ast3.Yield) -> YieldExpr:
+        e = YieldExpr(self.visit(n.value))
+        return self.set_line(e, n)
+
+    # YieldFrom(expr value)
+    def visit_YieldFrom(self, n: ast3.YieldFrom) -> YieldFromExpr:
+        e = YieldFromExpr(self.visit(n.value))
+        return self.set_line(e, n)
+
+    # Compare(expr left, cmpop* ops, expr* comparators)
+    def visit_Compare(self, n: ast3.Compare) -> ComparisonExpr:
+        operators = [self.from_comp_operator(o) for o in n.ops]
+        operands = self.translate_expr_list([n.left] + n.comparators)
+        e = ComparisonExpr(operators, operands)
+        return self.set_line(e, n)
+
+    # Call(expr func, expr* args, keyword* keywords)
+    # keyword = (identifier? arg, expr value)
+    def visit_Call(self, n: Call) -> CallExpr:
+        args = n.args
+        keywords = n.keywords
+        keyword_names = [k.arg for k in keywords]
+        arg_types = self.translate_expr_list(
+            [a.value if isinstance(a, Starred) else a for a in args] + [k.value for k in keywords]
+        )
+        arg_kinds = [ARG_STAR if type(a) is Starred else ARG_POS for a in args] + [
+            ARG_STAR2 if arg is None else ARG_NAMED for arg in keyword_names
+        ]
+        e = CallExpr(
+            self.visit(n.func),
+            arg_types,
+            arg_kinds,
+            cast("list[str | None]", [None] * len(args)) + keyword_names,
+        )
+        return self.set_line(e, n)
+
+    # Constant(object value)
+    def visit_Constant(self, n: ast3.Constant) -> Any:
+        val = n.value
+        e: Any = None
+        if val is None:
+            e = NameExpr("None")
+        elif isinstance(val, str):
+            e = StrExpr(val)
+        elif isinstance(val, bytes):
+            e = BytesExpr(bytes_to_human_readable_repr(val))
+        elif isinstance(val, bool):  # Must check before int!
+            e = NameExpr(str(val))
+        elif isinstance(val, int):
+            e = IntExpr(val)
+        elif isinstance(val, float):
+            e = FloatExpr(val)
+        elif isinstance(val, complex):
+            e = ComplexExpr(val)
+        elif val is Ellipsis:
+            e = EllipsisExpr()
+        else:
+            raise RuntimeError("Constant not implemented for " + str(type(val)))
+        return self.set_line(e, n)
+
+    # JoinedStr(expr* values)
+    def visit_JoinedStr(self, n: ast3.JoinedStr) -> Expression:
+        # Each of n.values is a str or FormattedValue; we just concatenate
+        # them all using ''.join.
+        empty_string = StrExpr("")
+        empty_string.set_line(n.lineno, n.col_offset)
+        strs_to_join = ListExpr(self.translate_expr_list(n.values))
+        strs_to_join.set_line(empty_string)
+        # Don't make unnecessary join call if there is only one str to join
+        if len(strs_to_join.items) == 1:
+            return self.set_line(strs_to_join.items[0], n)
+        elif len(strs_to_join.items) > 1:
+            last = strs_to_join.items[-1]
+            if isinstance(last, StrExpr) and last.value == "":
+                # 3.12 can add an empty literal at the end. Delete it for consistency
+                # between Python versions.
+                del strs_to_join.items[-1:]
+        join_method = MemberExpr(empty_string, "join")
+        join_method.set_line(empty_string)
+        result_expression = CallExpr(join_method, [strs_to_join], [ARG_POS], [None])
+        return self.set_line(result_expression, n)
+
+    # FormattedValue(expr value)
+    def visit_FormattedValue(self, n: ast3.FormattedValue) -> Expression:
+        # A FormattedValue is a component of a JoinedStr, or it can exist
+        # on its own. We translate them to individual '{}'.format(value)
+        # calls. Format specifier and conversion information is passed along
+        # to allow mypyc to support f-strings with format specifiers and conversions.
+        val_exp = self.visit(n.value)
+        val_exp.set_line(n.lineno, n.col_offset)
+        conv_str = "" if n.conversion < 0 else "!" + chr(n.conversion)
+        format_string = StrExpr("{" + conv_str + ":{}}")
+        format_spec_exp = self.visit(n.format_spec) if n.format_spec is not None else StrExpr("")
+        format_string.set_line(n.lineno, n.col_offset)
+        format_method = MemberExpr(format_string, "format")
+        format_method.set_line(format_string)
+        result_expression = CallExpr(
+            format_method, [val_exp, format_spec_exp], [ARG_POS, ARG_POS], [None, None]
+        )
+        return self.set_line(result_expression, n)
+
+    # TemplateStr(expr* values)
+    def visit_TemplateStr(self, n: ast_TemplateStr) -> TemplateStrExpr:
+        self.uses_template_strings = True
+        items: list[Expression | tuple[Expression, str, str | None, Expression | None]] = []
+        for value in n.values:
+            if isinstance(value, ast_Interpolation):  # type: ignore[misc]
+                val_expr = self.visit(value.value)
+                val_expr.set_line(value.lineno, value.col_offset)
+                conversion = None if value.conversion < 0 else chr(value.conversion)
+                format_spec = (
+                    self.visit(value.format_spec) if value.format_spec is not None else None
+                )
+                items.append((val_expr, value.str, conversion, format_spec))
+            else:
+                items.append(self.visit(value))
+        e = TemplateStrExpr(items)
+        return self.set_line(e, n)
+
+    # Attribute(expr value, identifier attr, expr_context ctx)
+    def visit_Attribute(self, n: Attribute) -> MemberExpr | SuperExpr:
+        value = n.value
+        member_expr = MemberExpr(self.visit(value), n.attr)
+        obj = member_expr.expr
+        if (
+            isinstance(obj, CallExpr)
+            and isinstance(obj.callee, NameExpr)
+            and obj.callee.name == "super"
+        ):
+            e: MemberExpr | SuperExpr = SuperExpr(member_expr.name, obj)
+        else:
+            e = member_expr
+        return self.set_line(e, n)
+
+    # Subscript(expr value, slice slice, expr_context ctx)
+    def visit_Subscript(self, n: ast3.Subscript) -> IndexExpr:
+        e = IndexExpr(self.visit(n.value), self.visit(n.slice))
+        return self.set_line(e, n)
+
+    # Starred(expr value, expr_context ctx)
+    def visit_Starred(self, n: Starred) -> StarExpr:
+        e = StarExpr(self.visit(n.value))
+        return self.set_line(e, n)
+
+    # Name(identifier id, expr_context ctx)
+    def visit_Name(self, n: Name) -> NameExpr:
+        e = NameExpr(n.id)
+        return self.set_line(e, n)
+
+    # List(expr* elts, expr_context ctx)
+    def visit_List(self, n: ast3.List) -> ListExpr | TupleExpr:
+        expr_list: list[Expression] = [self.visit(e) for e in n.elts]
+        if isinstance(n.ctx, ast3.Store):
+            # [x, y] = z and (x, y) = z means exactly the same thing
+            e: ListExpr | TupleExpr = TupleExpr(expr_list)
+        else:
+            e = ListExpr(expr_list)
+        return self.set_line(e, n)
+
+    # Tuple(expr* elts, expr_context ctx)
+    def visit_Tuple(self, n: ast3.Tuple) -> TupleExpr:
+        e = TupleExpr(self.translate_expr_list(n.elts))
+        return self.set_line(e, n)
+
+    # Slice(expr? lower, expr? upper, expr? step)
+    def visit_Slice(self, n: ast3.Slice) -> SliceExpr:
+        e = SliceExpr(self.visit(n.lower), self.visit(n.upper), self.visit(n.step))
+        return self.set_line(e, n)
+
+    # Match(expr subject, match_case* cases) # python 3.10 and later
+    def visit_Match(self, n: ast3.Match) -> MatchStmt:
+        node = MatchStmt(
+            self.visit(n.subject),
+            [self.visit(c.pattern) for c in n.cases],
+            [self.visit(c.guard) for c in n.cases],
+            [self.as_required_block(c.body) for c in n.cases],
+        )
+        return self.set_line(node, n)
+
+    def visit_MatchValue(self, n: ast3.MatchValue) -> ValuePattern:
+        node = ValuePattern(self.visit(n.value))
+        return self.set_line(node, n)
+
+    def visit_MatchSingleton(self, n: ast3.MatchSingleton) -> SingletonPattern:
+        node = SingletonPattern(n.value)
+        return self.set_line(node, n)
+
+    def visit_MatchSequence(self, n: ast3.MatchSequence) -> SequencePattern:
+        patterns = [self.visit(p) for p in n.patterns]
+        stars = [p for p in patterns if isinstance(p, StarredPattern)]
+        assert len(stars) < 2
+
+        node = SequencePattern(patterns)
+        return self.set_line(node, n)
+
+    def visit_MatchStar(self, n: ast3.MatchStar) -> StarredPattern:
+        if n.name is None:
+            node = StarredPattern(None)
+        else:
+            name = self.set_line(NameExpr(n.name), n)
+            node = StarredPattern(name)
+
+        return self.set_line(node, n)
+
+    def visit_MatchMapping(self, n: ast3.MatchMapping) -> MappingPattern:
+        keys = [self.visit(k) for k in n.keys]
+        values = [self.visit(v) for v in n.patterns]
+
+        if n.rest is None:
+            rest = None
+        else:
+            rest = self.set_line(NameExpr(n.rest), n)
+
+        node = MappingPattern(keys, values, rest)
+        return self.set_line(node, n)
+
+    def visit_MatchClass(self, n: ast3.MatchClass) -> ClassPattern:
+        class_ref = self.visit(n.cls)
+        assert isinstance(class_ref, RefExpr)
+        positionals = [self.visit(p) for p in n.patterns]
+        keyword_keys = n.kwd_attrs
+        keyword_values = [self.visit(p) for p in n.kwd_patterns]
+
+        node = ClassPattern(class_ref, positionals, keyword_keys, keyword_values)
+        return self.set_line(node, n)
+
+    # MatchAs(expr pattern, identifier name)
+    def visit_MatchAs(self, n: ast3.MatchAs) -> AsPattern:
+        if n.name is None:
+            name = None
+        else:
+            name = NameExpr(n.name)
+            name = self.set_line(name, n)
+        node = AsPattern(self.visit(n.pattern), name)
+        return self.set_line(node, n)
+
+    # MatchOr(expr* pattern)
+    def visit_MatchOr(self, n: ast3.MatchOr) -> OrPattern:
+        node = OrPattern([self.visit(pattern) for pattern in n.patterns])
+        return self.set_line(node, n)
+
+    def validate_type_alias(self, n: ast_TypeAlias) -> None:
+        incorrect_expr = find_disallowed_expression_in_annotation_scope(n.value)
+        if incorrect_expr is None:
+            return
+        if isinstance(incorrect_expr, (ast3.Yield, ast3.YieldFrom)):
+            self.fail(
+                message_registry.TYPE_ALIAS_WITH_YIELD_EXPRESSION,
+                n.lineno,
+                n.col_offset,
+                blocker=True,
+            )
+        if isinstance(incorrect_expr, ast3.NamedExpr):
+            self.fail(
+                message_registry.TYPE_ALIAS_WITH_NAMED_EXPRESSION,
+                n.lineno,
+                n.col_offset,
+                blocker=True,
+            )
+        if isinstance(incorrect_expr, ast3.Await):
+            self.fail(
+                message_registry.TYPE_ALIAS_WITH_AWAIT_EXPRESSION,
+                n.lineno,
+                n.col_offset,
+                blocker=True,
+            )
+
+    # TypeAlias(identifier name, type_param* type_params, expr value)
+    def visit_TypeAlias(self, n: ast_TypeAlias) -> TypeAliasStmt | AssignmentStmt:
+        node: TypeAliasStmt | AssignmentStmt
+        type_params = self.translate_type_params(n.type_params)
+        self.validate_type_alias(n)
+        value = self.visit(n.value)
+        # Since the value is evaluated lazily, wrap the value inside a lambda.
+        # This helps mypyc.
+        ret = ReturnStmt(value)
+        self.set_line(ret, n.value)
+        value_func = LambdaExpr(body=Block([ret]))
+        self.set_line(value_func, n.value)
+        node = TypeAliasStmt(self.visit_Name(n.name), type_params, value_func)
+        return self.set_line(node, n)
+
+
+class TypeConverter:
+    def __init__(
+        self,
+        errors: Errors | None,
+        line: int = -1,
+        override_column: int = -1,
+        is_evaluated: bool = True,
+    ) -> None:
+        self.errors = errors
+        self.line = line
+        self.override_column = override_column
+        self.node_stack: list[AST] = []
+        self.is_evaluated = is_evaluated
+
+    def convert_column(self, column: int) -> int:
+        """Apply column override if defined; otherwise return column.
+
+        Column numbers are sometimes incorrect in the AST and the column
+        override can be used to work around that.
+        """
+        if self.override_column < 0:
+            return column
+        else:
+            return self.override_column
+
+    def invalid_type(self, node: AST, note: str | None = None) -> RawExpressionType:
+        """Constructs a type representing some expression that normally forms an invalid type.
+        For example, if we see a type hint that says "3 + 4", we would transform that
+        expression into a RawExpressionType.
+
+        The semantic analysis layer will report an "Invalid type" error when it
+        encounters this type, along with the given note if one is provided.
+
+        See RawExpressionType's docstring for more details on how it's used.
+        """
+        return RawExpressionType(
+            None, "typing.Any", line=self.line, column=getattr(node, "col_offset", -1), note=note
+        )
+
+    @overload
+    def visit(self, node: ast3.expr) -> ProperType: ...
+
+    @overload
+    def visit(self, node: AST | None) -> ProperType | None: ...
+
+    def visit(self, node: AST | None) -> ProperType | None:
+        """Modified visit -- keep track of the stack of nodes"""
+        if node is None:
+            return None
+        self.node_stack.append(node)
+        try:
+            method = "visit_" + node.__class__.__name__
+            visitor = getattr(self, method, None)
+            if visitor is not None:
+                typ = visitor(node)
+                assert isinstance(typ, ProperType)
+                return typ
+            else:
+                return self.invalid_type(node)
+        finally:
+            self.node_stack.pop()
+
+    def parent(self) -> AST | None:
+        """Return the AST node above the one we are processing"""
+        if len(self.node_stack) < 2:
+            return None
+        return self.node_stack[-2]
+
+    def fail(self, msg: ErrorMessage, line: int, column: int) -> None:
+        if self.errors:
+            self.errors.report(line, column, msg.value, blocker=True, code=msg.code)
+
+    def note(self, msg: str, line: int, column: int) -> None:
+        if self.errors:
+            self.errors.report(line, column, msg, severity="note", code=codes.SYNTAX)
+
+    def translate_expr_list(self, l: Sequence[ast3.expr]) -> list[Type]:
+        return [self.visit(e) for e in l]
+
+    def visit_Call(self, e: Call) -> Type:
+        # Parse the arg constructor
+        f = e.func
+        constructor = stringify_name(f)
+
+        if not isinstance(self.parent(), ast3.List):
+            note = None
+            if constructor:
+                note = "Suggestion: use {0}[...] instead of {0}(...)".format(constructor)
+            return self.invalid_type(e, note=note)
+        if not constructor:
+            self.fail(message_registry.ARG_CONSTRUCTOR_NAME_EXPECTED, e.lineno, e.col_offset)
+
+        name: str | None = None
+        default_type = AnyType(TypeOfAny.special_form)
+        typ: Type = default_type
+        for i, arg in enumerate(e.args):
+            if i == 0:
+                converted = self.visit(arg)
+                assert converted is not None
+                typ = converted
+            elif i == 1:
+                name = self._extract_argument_name(arg)
+            else:
+                self.fail(message_registry.ARG_CONSTRUCTOR_TOO_MANY_ARGS, f.lineno, f.col_offset)
+        for k in e.keywords:
+            value = k.value
+            if k.arg == "name":
+                if name is not None:
+                    self.fail(
+                        message_registry.MULTIPLE_VALUES_FOR_NAME_KWARG.format(constructor),
+                        f.lineno,
+                        f.col_offset,
+                    )
+                name = self._extract_argument_name(value)
+            elif k.arg == "type":
+                if typ is not default_type:
+                    self.fail(
+                        message_registry.MULTIPLE_VALUES_FOR_TYPE_KWARG.format(constructor),
+                        f.lineno,
+                        f.col_offset,
+                    )
+                converted = self.visit(value)
+                assert converted is not None
+                typ = converted
+            else:
+                self.fail(
+                    message_registry.ARG_CONSTRUCTOR_UNEXPECTED_ARG.format(k.arg),
+                    value.lineno,
+                    value.col_offset,
+                )
+        return CallableArgument(typ, name, constructor, e.lineno, e.col_offset)
+
+    def translate_argument_list(self, l: Sequence[ast3.expr]) -> TypeList:
+        return TypeList([self.visit(e) for e in l], line=self.line)
+
+    def _extract_argument_name(self, n: ast3.expr) -> str | None:
+        if isinstance(n, ast3.Constant) and isinstance(n.value, str):
+            return n.value.strip()
+        elif isinstance(n, ast3.Constant) and n.value is None:
+            return None
+        self.fail(
+            message_registry.ARG_NAME_EXPECTED_STRING_LITERAL.format(type(n).__name__),
+            self.line,
+            0,
+        )
+        return None
+
+    def visit_Name(self, n: Name) -> Type:
+        return UnboundType(n.id, line=self.line, column=self.convert_column(n.col_offset))
+
+    def visit_BinOp(self, n: ast3.BinOp) -> Type:
+        if not isinstance(n.op, ast3.BitOr):
+            return self.invalid_type(n)
+
+        left = self.visit(n.left)
+        right = self.visit(n.right)
+        return UnionType(
+            [left, right],
+            line=self.line,
+            column=self.convert_column(n.col_offset),
+            is_evaluated=self.is_evaluated,
+            uses_pep604_syntax=True,
+        )
+
+    def visit_Constant(self, n: ast3.Constant) -> Type:
+        val = n.value
+        if val is None:
+            # None is a type.
+            return UnboundType("None", line=self.line)
+        if isinstance(val, str):
+            # Parse forward reference.
+            return parse_type_string(val, "builtins.str", self.line, n.col_offset)
+        if val is Ellipsis:
+            # '...' is valid in some types.
+            return EllipsisType(line=self.line)
+        if isinstance(val, bool):
+            # Special case for True/False.
+            return RawExpressionType(val, "builtins.bool", line=self.line)
+        if isinstance(val, (int, float, complex)):
+            return self.numeric_type(val, n)
+        if isinstance(val, bytes):
+            contents = bytes_to_human_readable_repr(val)
+            return RawExpressionType(contents, "builtins.bytes", self.line, column=n.col_offset)
+        # Everything else is invalid.
+
+    # UnaryOp(op, operand)
+    def visit_UnaryOp(self, n: UnaryOp) -> Type:
+        # We support specifically Literal[-4], Literal[+4], and nothing else.
+        # For example, Literal[~6] or Literal[not False] is not supported.
+        typ = self.visit(n.operand)
+        if (
+            isinstance(typ, RawExpressionType)
+            # Use type() because we do not want to allow bools.
+            and type(typ.literal_value) is int
+        ):
+            if isinstance(n.op, USub):
+                typ.literal_value *= -1
+                return typ
+            if isinstance(n.op, UAdd):
+                return typ
+        return self.invalid_type(n)
+
+    def numeric_type(self, value: object, n: AST) -> Type:
+        # The node's field has the type complex, but complex isn't *really*
+        # a parent of int and float, and this causes isinstance below
+        # to think that the complex branch is always picked. Avoid
+        # this by throwing away the type.
+        if isinstance(value, int):
+            numeric_value: int | None = value
+            type_name = "builtins.int"
+        else:
+            # Other kinds of numbers (floats, complex) are not valid parameters for
+            # RawExpressionType so we just pass in 'None' for now. We'll report the
+            # appropriate error at a later stage.
+            numeric_value = None
+            type_name = f"builtins.{type(value).__name__}"
+        return RawExpressionType(
+            numeric_value, type_name, line=self.line, column=getattr(n, "col_offset", -1)
+        )
+
+    def visit_Slice(self, n: ast3.Slice) -> Type:
+        return self.invalid_type(n, note="did you mean to use ',' instead of ':' ?")
+
+    # Subscript(expr value, expr slice, expr_context ctx)
+    def visit_Subscript(self, n: ast3.Subscript) -> Type:
+        empty_tuple_index = False
+        if isinstance(n.slice, ast3.Tuple):
+            params = self.translate_expr_list(n.slice.elts)
+            if len(n.slice.elts) == 0:
+                empty_tuple_index = True
+        else:
+            params = [self.visit(n.slice)]
+
+        value = self.visit(n.value)
+        if isinstance(value, UnboundType) and not value.args:
+            result = UnboundType(
+                value.name,
+                params,
+                line=self.line,
+                column=value.column,
+                empty_tuple_index=empty_tuple_index,
+            )
+            result.end_column = n.end_col_offset
+            result.end_line = n.end_lineno
+            return result
+        else:
+            return self.invalid_type(n)
+
+    def visit_Tuple(self, n: ast3.Tuple) -> Type:
+        return TupleType(
+            self.translate_expr_list(n.elts),
+            _dummy_fallback,
+            implicit=True,
+            line=self.line,
+            column=self.convert_column(n.col_offset),
+        )
+
+    def visit_Dict(self, n: ast3.Dict) -> Type:
+        if not n.keys:
+            return self.invalid_type(n)
+        items: dict[str, Type] = {}
+        extra_items_from = []
+        for item_name, value in zip(n.keys, n.values):
+            if not isinstance(item_name, ast3.Constant) or not isinstance(item_name.value, str):
+                if item_name is None:
+                    extra_items_from.append(self.visit(value))
+                    continue
+                return self.invalid_type(n)
+            items[item_name.value] = self.visit(value)
+        result = TypedDictType(items, set(), set(), _dummy_fallback, n.lineno, n.col_offset)
+        result.extra_items_from = extra_items_from
+        return result
+
+    # Attribute(expr value, identifier attr, expr_context ctx)
+    def visit_Attribute(self, n: Attribute) -> Type:
+        before_dot = self.visit(n.value)
+
+        if isinstance(before_dot, UnboundType) and not before_dot.args:
+            return UnboundType(f"{before_dot.name}.{n.attr}", line=self.line, column=n.col_offset)
+        else:
+            return self.invalid_type(n)
+
+    # Used for Callable[[X *Ys, Z], R] etc.
+    def visit_Starred(self, n: ast3.Starred) -> Type:
+        return UnpackType(self.visit(n.value), from_star_syntax=True)
+
+    # List(expr* elts, expr_context ctx)
+    def visit_List(self, n: ast3.List) -> Type:
+        assert isinstance(n.ctx, ast3.Load)
+        result = self.translate_argument_list(n.elts)
+        return result
+
+
+def stringify_name(n: AST) -> str | None:
+    if isinstance(n, Name):
+        return n.id
+    elif isinstance(n, Attribute):
+        sv = stringify_name(n.value)
+        if sv is not None:
+            return f"{sv}.{n.attr}"
+    return None  # Can't do it.
+
+
+class FindAttributeAssign(TraverserVisitor):
+    """Check if an AST contains attribute assignments (e.g. self.x = 0)."""
+
+    def __init__(self) -> None:
+        self.lvalue = False
+        self.found = False
+
+    def visit_assignment_stmt(self, s: AssignmentStmt) -> None:
+        self.lvalue = True
+        for lv in s.lvalues:
+            lv.accept(self)
+        self.lvalue = False
+
+    def visit_with_stmt(self, s: WithStmt) -> None:
+        self.lvalue = True
+        for lv in s.target:
+            if lv is not None:
+                lv.accept(self)
+        self.lvalue = False
+        s.body.accept(self)
+
+    def visit_for_stmt(self, s: ForStmt) -> None:
+        self.lvalue = True
+        s.index.accept(self)
+        self.lvalue = False
+        s.body.accept(self)
+        if s.else_body:
+            s.else_body.accept(self)
+
+    def visit_expression_stmt(self, s: ExpressionStmt) -> None:
+        # No need to look inside these
+        pass
+
+    def visit_call_expr(self, e: CallExpr) -> None:
+        # No need to look inside these
+        pass
+
+    def visit_index_expr(self, e: IndexExpr) -> None:
+        # No need to look inside these
+        pass
+
+    def visit_member_expr(self, e: MemberExpr) -> None:
+        if self.lvalue and isinstance(e.expr, NameExpr):
+            self.found = True
+
+
+class FindYield(TraverserVisitor):
+    """Check if an AST contains yields or yield froms."""  # codespell:ignore froms
+
+    def __init__(self) -> None:
+        self.found = False
+
+    def visit_yield_expr(self, e: YieldExpr) -> None:
+        self.found = True
+
+    def visit_yield_from_expr(self, e: YieldFromExpr) -> None:
+        self.found = True
+
+
+def is_possible_trivial_body(s: list[Statement]) -> bool:
+    """Could the statements form a "trivial" function body, such as 'pass'?
+
+    This mimics mypy.semanal.is_trivial_body, but this runs before
+    semantic analysis so some checks must be conservative.
+    """
+    l = len(s)
+    if l == 0:
+        return False
+    i = 0
+    if isinstance(s[0], ExpressionStmt) and isinstance(s[0].expr, StrExpr):
+        # Skip docstring
+        i += 1
+    if i == l:
+        return True
+    if l > i + 1:
+        return False
+    stmt = s[i]
+    return isinstance(stmt, (PassStmt, RaiseStmt)) or (
+        isinstance(stmt, ExpressionStmt) and isinstance(stmt.expr, EllipsisExpr)
+    )

micromamba_root/Lib/site-packages/mypy/find_sources.py

@@ -0,0 +1,257 @@
+"""Routines for finding the sources that mypy will check"""
+
+from __future__ import annotations
+
+import functools
+import os
+from collections.abc import Sequence
+from typing import Final
+
+from mypy.fscache import FileSystemCache
+from mypy.modulefinder import (
+    PYTHON_EXTENSIONS,
+    BuildSource,
+    matches_exclude,
+    matches_gitignore,
+    mypy_path,
+)
+from mypy.options import Options
+
+PY_EXTENSIONS: Final = tuple(PYTHON_EXTENSIONS)
+
+
+class InvalidSourceList(Exception):
+    """Exception indicating a problem in the list of sources given to mypy."""
+
+
+def create_source_list(
+    paths: Sequence[str],
+    options: Options,
+    fscache: FileSystemCache | None = None,
+    allow_empty_dir: bool = False,
+) -> list[BuildSource]:
+    """From a list of source files/directories, makes a list of BuildSources.
+
+    Raises InvalidSourceList on errors.
+    """
+    fscache = fscache or FileSystemCache()
+    finder = SourceFinder(fscache, options)
+
+    sources = []
+    for path in paths:
+        path = os.path.normpath(path)
+        if path.endswith(PY_EXTENSIONS):
+            # Can raise InvalidSourceList if a directory doesn't have a valid module name.
+            name, base_dir = finder.crawl_up(path)
+            sources.append(BuildSource(path, name, None, base_dir))
+        elif fscache.isdir(path):
+            sub_sources = finder.find_sources_in_dir(path)
+            if not sub_sources and not allow_empty_dir:
+                raise InvalidSourceList(f"There are no .py[i] files in directory '{path}'")
+            sources.extend(sub_sources)
+        else:
+            mod = os.path.basename(path) if options.scripts_are_modules else None
+            sources.append(BuildSource(path, mod, None))
+    return sources
+
+
+def keyfunc(name: str) -> tuple[bool, int, str]:
+    """Determines sort order for directory listing.
+
+    The desirable properties are:
+    1) foo < foo.pyi < foo.py
+    2) __init__.py[i] < foo
+    """
+    base, suffix = os.path.splitext(name)
+    for i, ext in enumerate(PY_EXTENSIONS):
+        if suffix == ext:
+            return (base != "__init__", i, base)
+    return (base != "__init__", -1, name)
+
+
+def normalise_package_base(root: str) -> str:
+    if not root:
+        root = os.curdir
+    root = os.path.abspath(root)
+    if root.endswith(os.sep):
+        root = root[:-1]
+    return root
+
+
+def get_explicit_package_bases(options: Options) -> list[str] | None:
+    """Returns explicit package bases to use if the option is enabled, or None if disabled.
+
+    We currently use MYPYPATH and the current directory as the package bases. In the future,
+    when --namespace-packages is the default could also use the values passed with the
+    --package-root flag, see #9632.
+
+    Values returned are normalised so we can use simple string comparisons in
+    SourceFinder.is_explicit_package_base
+    """
+    if not options.explicit_package_bases:
+        return None
+    roots = mypy_path() + options.mypy_path + [os.getcwd()]
+    return [normalise_package_base(root) for root in roots]
+
+
+class SourceFinder:
+    def __init__(self, fscache: FileSystemCache, options: Options) -> None:
+        self.fscache = fscache
+        self.explicit_package_bases = get_explicit_package_bases(options)
+        self.namespace_packages = options.namespace_packages
+        self.exclude = options.exclude
+        self.exclude_gitignore = options.exclude_gitignore
+        self.verbosity = options.verbosity
+
+    def is_explicit_package_base(self, path: str) -> bool:
+        assert self.explicit_package_bases
+        return normalise_package_base(path) in self.explicit_package_bases
+
+    def find_sources_in_dir(self, path: str) -> list[BuildSource]:
+        sources = []
+
+        seen: set[str] = set()
+        names = sorted(self.fscache.listdir(path), key=keyfunc)
+        for name in names:
+            # Skip certain names altogether
+            if name in ("__pycache__", "site-packages", "node_modules") or name.startswith("."):
+                continue
+            subpath = os.path.join(path, name)
+
+            if matches_exclude(subpath, self.exclude, self.fscache, self.verbosity >= 2):
+                continue
+            if self.exclude_gitignore and matches_gitignore(
+                subpath, self.fscache, self.verbosity >= 2
+            ):
+                continue
+
+            if self.fscache.isdir(subpath):
+                sub_sources = self.find_sources_in_dir(subpath)
+                if sub_sources:
+                    seen.add(name)
+                    sources.extend(sub_sources)
+            else:
+                stem, suffix = os.path.splitext(name)
+                if stem not in seen and suffix in PY_EXTENSIONS:
+                    seen.add(stem)
+                    module, base_dir = self.crawl_up(subpath)
+                    sources.append(BuildSource(subpath, module, None, base_dir))
+
+        return sources
+
+    def crawl_up(self, path: str) -> tuple[str, str]:
+        """Given a .py[i] filename, return module and base directory.
+
+        For example, given "xxx/yyy/foo/bar.py", we might return something like:
+        ("foo.bar", "xxx/yyy")
+
+        If namespace packages is off, we crawl upwards until we find a directory without
+        an __init__.py
+
+        If namespace packages is on, we crawl upwards until the nearest explicit base directory.
+        Failing that, we return one past the highest directory containing an __init__.py
+
+        We won't crawl past directories with invalid package names.
+        The base directory returned is an absolute path.
+        """
+        path = os.path.abspath(path)
+        parent, filename = os.path.split(path)
+
+        module_name = strip_py(filename) or filename
+
+        parent_module, base_dir = self.crawl_up_dir(parent)
+        if module_name == "__init__":
+            return parent_module, base_dir
+
+        # Note that module_name might not actually be a valid identifier, but that's okay
+        # Ignoring this possibility sidesteps some search path confusion
+        module = module_join(parent_module, module_name)
+        return module, base_dir
+
+    def crawl_up_dir(self, dir: str) -> tuple[str, str]:
+        return self._crawl_up_helper(dir) or ("", dir)
+
+    @functools.lru_cache  # noqa: B019
+    def _crawl_up_helper(self, dir: str) -> tuple[str, str] | None:
+        """Given a directory, maybe returns module and base directory.
+
+        We return a non-None value if we were able to find something clearly intended as a base
+        directory (as adjudicated by being an explicit base directory or by containing a package
+        with __init__.py).
+
+        This distinction is necessary for namespace packages, so that we know when to treat
+        ourselves as a subpackage.
+        """
+        # stop crawling if we're an explicit base directory
+        if self.explicit_package_bases is not None and self.is_explicit_package_base(dir):
+            return "", dir
+
+        parent, name = os.path.split(dir)
+        name = name.removesuffix("-stubs")  # PEP-561 stub-only directory
+
+        # recurse if there's an __init__.py
+        init_file = self.get_init_file(dir)
+        if init_file is not None:
+            if not name.isidentifier():
+                # in most cases the directory name is invalid, we'll just stop crawling upwards
+                # but if there's an __init__.py in the directory, something is messed up
+                raise InvalidSourceList(
+                    f"{name} contains {os.path.basename(init_file)} "
+                    "but is not a valid Python package name"
+                )
+            # we're definitely a package, so we always return a non-None value
+            mod_prefix, base_dir = self.crawl_up_dir(parent)
+            return module_join(mod_prefix, name), base_dir
+
+        # stop crawling if we're out of path components or our name is an invalid identifier
+        if not name or not parent or not name.isidentifier():
+            return None
+
+        # stop crawling if namespace packages is off (since we don't have an __init__.py)
+        if not self.namespace_packages:
+            return None
+
+        # at this point: namespace packages is on, we don't have an __init__.py and we're not an
+        # explicit base directory
+        result = self._crawl_up_helper(parent)
+        if result is None:
+            # we're not an explicit base directory and we don't have an __init__.py
+            # and none of our parents are either, so return
+            return None
+        # one of our parents was an explicit base directory or had an __init__.py, so we're
+        # definitely a subpackage! chain our name to the module.
+        mod_prefix, base_dir = result
+        return module_join(mod_prefix, name), base_dir
+
+    def get_init_file(self, dir: str) -> str | None:
+        """Check whether a directory contains a file named __init__.py[i].
+
+        If so, return the file's name (with dir prefixed).  If not, return None.
+
+        This prefers .pyi over .py (because of the ordering of PY_EXTENSIONS).
+        """
+        for ext in PY_EXTENSIONS:
+            f = os.path.join(dir, "__init__" + ext)
+            if self.fscache.isfile(f):
+                return f
+            if ext == ".py" and self.fscache.init_under_package_root(f):
+                return f
+        return None
+
+
+def module_join(parent: str, child: str) -> str:
+    """Join module ids, accounting for a possibly empty parent."""
+    if parent:
+        return parent + "." + child
+    return child
+
+
+def strip_py(arg: str) -> str | None:
+    """Strip a trailing .py or .pyi suffix.
+
+    Return None if no such suffix is found.
+    """
+    for ext in PY_EXTENSIONS:
+        if arg.endswith(ext):
+            return arg[: -len(ext)]
+    return None

micromamba_root/Lib/site-packages/mypy/fixup.py

@@ -0,0 +1,444 @@
+"""Fix up various things after deserialization."""
+
+from __future__ import annotations
+
+from typing import Any, Final
+
+from mypy.lookup import lookup_fully_qualified
+from mypy.nodes import (
+    Block,
+    ClassDef,
+    Decorator,
+    FuncDef,
+    MypyFile,
+    OverloadedFuncDef,
+    ParamSpecExpr,
+    SymbolTable,
+    TypeAlias,
+    TypeInfo,
+    TypeVarExpr,
+    TypeVarTupleExpr,
+    Var,
+)
+from mypy.types import (
+    NOT_READY,
+    AnyType,
+    CallableType,
+    Instance,
+    LiteralType,
+    Overloaded,
+    Parameters,
+    ParamSpecType,
+    ProperType,
+    TupleType,
+    TypeAliasType,
+    TypedDictType,
+    TypeOfAny,
+    TypeType,
+    TypeVarTupleType,
+    TypeVarType,
+    TypeVisitor,
+    UnboundType,
+    UnionType,
+    UnpackType,
+)
+from mypy.visitor import NodeVisitor
+
+
+# N.B: we do a allow_missing fixup when fixing up a fine-grained
+# incremental cache load (since there may be cross-refs into deleted
+# modules)
+def fixup_module(tree: MypyFile, modules: dict[str, MypyFile], allow_missing: bool) -> None:
+    node_fixer = NodeFixer(modules, allow_missing)
+    node_fixer.visit_symbol_table(tree.names, tree.fullname)
+
+
+# TODO: Fix up .info when deserializing, i.e. much earlier.
+class NodeFixer(NodeVisitor[None]):
+    current_info: TypeInfo | None = None
+
+    def __init__(self, modules: dict[str, MypyFile], allow_missing: bool) -> None:
+        self.modules = modules
+        self.allow_missing = allow_missing
+        self.type_fixer = TypeFixer(self.modules, allow_missing)
+
+    # NOTE: This method isn't (yet) part of the NodeVisitor API.
+    def visit_type_info(self, info: TypeInfo) -> None:
+        save_info = self.current_info
+        try:
+            self.current_info = info
+            if info.defn:
+                info.defn.accept(self)
+            if info.names:
+                self.visit_symbol_table(info.names, info.fullname)
+            if info.bases:
+                for base in info.bases:
+                    base.accept(self.type_fixer)
+            if info._promote:
+                for p in info._promote:
+                    p.accept(self.type_fixer)
+            if info.tuple_type:
+                info.tuple_type.accept(self.type_fixer)
+                info.update_tuple_type(info.tuple_type)
+                if info.special_alias:
+                    info.special_alias.alias_tvars = list(info.defn.type_vars)
+                    for i, t in enumerate(info.defn.type_vars):
+                        if isinstance(t, TypeVarTupleType):
+                            info.special_alias.tvar_tuple_index = i
+            if info.typeddict_type:
+                info.typeddict_type.accept(self.type_fixer)
+                info.update_typeddict_type(info.typeddict_type)
+                if info.special_alias:
+                    info.special_alias.alias_tvars = list(info.defn.type_vars)
+                    for i, t in enumerate(info.defn.type_vars):
+                        if isinstance(t, TypeVarTupleType):
+                            info.special_alias.tvar_tuple_index = i
+            if info.declared_metaclass:
+                info.declared_metaclass.accept(self.type_fixer)
+            if info.metaclass_type:
+                info.metaclass_type.accept(self.type_fixer)
+            if info.self_type:
+                info.self_type.accept(self.type_fixer)
+            if info.alt_promote:
+                info.alt_promote.accept(self.type_fixer)
+                instance = Instance(info, [])
+                # Hack: We may also need to add a backwards promotion (from int to native int),
+                # since it might not be serialized.
+                if instance not in info.alt_promote.type._promote:
+                    info.alt_promote.type._promote.append(instance)
+            if info._mro_refs:
+                info.mro = [
+                    lookup_fully_qualified_typeinfo(
+                        self.modules, name, allow_missing=self.allow_missing
+                    )
+                    for name in info._mro_refs
+                ]
+                info._mro_refs = None
+        finally:
+            self.current_info = save_info
+
+    # NOTE: This method *definitely* isn't part of the NodeVisitor API.
+    def visit_symbol_table(self, symtab: SymbolTable, table_fullname: str) -> None:
+        # Copy the items because we may mutate symtab.
+        for key in list(symtab):
+            value = symtab[key]
+            cross_ref = value.cross_ref
+            if cross_ref is not None:  # Fix up cross-reference.
+                value.cross_ref = None
+                if cross_ref in self.modules:
+                    value.node = self.modules[cross_ref]
+                else:
+                    stnode = lookup_fully_qualified(
+                        cross_ref, self.modules, raise_on_missing=not self.allow_missing
+                    )
+                    if stnode is not None:
+                        if stnode is value:
+                            # The node seems to refer to itself, which can mean that
+                            # the target is a deleted submodule of the current module,
+                            # and thus lookup falls back to the symbol table of the parent
+                            # package. Here's how this may happen:
+                            #
+                            #   pkg/__init__.py:
+                            #     from pkg import sub
+                            #
+                            # Now if pkg.sub is deleted, the pkg.sub symbol table entry
+                            # appears to refer to itself. Replace the entry with a
+                            # placeholder to avoid a crash. We can't delete the entry,
+                            # as it would stop dependency propagation.
+                            value.node = Var(key + "@deleted")
+                        else:
+                            assert stnode.node is not None, (table_fullname + "." + key, cross_ref)
+                            value.node = stnode.node
+                    elif not self.allow_missing:
+                        assert False, f"Could not find cross-ref {cross_ref}"
+                    else:
+                        # We have a missing crossref in allow missing mode, need to put something
+                        value.node = missing_info(self.modules)
+            else:
+                if isinstance(value.node, TypeInfo):
+                    # TypeInfo has no accept().  TODO: Add it?
+                    self.visit_type_info(value.node)
+                elif value.node is not None:
+                    value.node.accept(self)
+                else:
+                    assert False, f"Unexpected empty node {key!r}: {value}"
+
+    def visit_func_def(self, func: FuncDef) -> None:
+        if self.current_info is not None:
+            func.info = self.current_info
+        if func.type is not None:
+            func.type.accept(self.type_fixer)
+            if isinstance(func.type, CallableType):
+                func.type.definition = func
+
+    def visit_overloaded_func_def(self, o: OverloadedFuncDef) -> None:
+        if self.current_info is not None:
+            o.info = self.current_info
+        if o.type:
+            o.type.accept(self.type_fixer)
+        for item in o.items:
+            item.accept(self)
+        if o.impl:
+            o.impl.accept(self)
+        if isinstance(o.type, Overloaded):
+            # For error messages we link the original definition for each item.
+            for typ, item in zip(o.type.items, o.items):
+                typ.definition = item
+
+    def visit_decorator(self, d: Decorator) -> None:
+        if self.current_info is not None:
+            d.var.info = self.current_info
+        if d.func:
+            d.func.accept(self)
+        if d.var:
+            d.var.accept(self)
+        for node in d.decorators:
+            node.accept(self)
+        typ = d.var.type
+        if isinstance(typ, ProperType) and isinstance(typ, CallableType):
+            typ.definition = d.func
+
+    def visit_class_def(self, c: ClassDef) -> None:
+        for v in c.type_vars:
+            v.accept(self.type_fixer)
+
+    def visit_type_var_expr(self, tv: TypeVarExpr) -> None:
+        for value in tv.values:
+            value.accept(self.type_fixer)
+        tv.upper_bound.accept(self.type_fixer)
+        tv.default.accept(self.type_fixer)
+
+    def visit_paramspec_expr(self, p: ParamSpecExpr) -> None:
+        p.upper_bound.accept(self.type_fixer)
+        p.default.accept(self.type_fixer)
+
+    def visit_type_var_tuple_expr(self, tv: TypeVarTupleExpr) -> None:
+        tv.upper_bound.accept(self.type_fixer)
+        tv.tuple_fallback.accept(self.type_fixer)
+        tv.default.accept(self.type_fixer)
+
+    def visit_var(self, v: Var) -> None:
+        if self.current_info is not None:
+            v.info = self.current_info
+        if v.type is not None:
+            v.type.accept(self.type_fixer)
+        if v.setter_type is not None:
+            v.setter_type.accept(self.type_fixer)
+
+    def visit_type_alias(self, a: TypeAlias) -> None:
+        a.target.accept(self.type_fixer)
+        for v in a.alias_tvars:
+            v.accept(self.type_fixer)
+
+
+class TypeFixer(TypeVisitor[None]):
+    def __init__(self, modules: dict[str, MypyFile], allow_missing: bool) -> None:
+        self.modules = modules
+        self.allow_missing = allow_missing
+
+    def visit_instance(self, inst: Instance) -> None:
+        # TODO: Combine Instances that are exactly the same?
+        type_ref = inst.type_ref
+        if type_ref is None:
+            return  # We've already been here.
+        inst.type_ref = None
+        inst.type = lookup_fully_qualified_typeinfo(
+            self.modules, type_ref, allow_missing=self.allow_missing
+        )
+        # TODO: Is this needed or redundant?
+        # Also fix up the bases, just in case.
+        for base in inst.type.bases:
+            if base.type is NOT_READY:
+                base.accept(self)
+        for a in inst.args:
+            a.accept(self)
+        if inst.last_known_value is not None:
+            inst.last_known_value.accept(self)
+        if inst.extra_attrs:
+            for v in inst.extra_attrs.attrs.values():
+                v.accept(self)
+
+    def visit_type_alias_type(self, t: TypeAliasType) -> None:
+        type_ref = t.type_ref
+        if type_ref is None:
+            return  # We've already been here.
+        t.type_ref = None
+        t.alias = lookup_fully_qualified_alias(
+            self.modules, type_ref, allow_missing=self.allow_missing
+        )
+        for a in t.args:
+            a.accept(self)
+
+    def visit_any(self, o: Any) -> None:
+        pass  # Nothing to descend into.
+
+    def visit_callable_type(self, ct: CallableType) -> None:
+        if ct.fallback:
+            ct.fallback.accept(self)
+        for argt in ct.arg_types:
+            # argt may be None, e.g. for __self in NamedTuple constructors.
+            if argt is not None:
+                argt.accept(self)
+        if ct.ret_type is not None:
+            ct.ret_type.accept(self)
+        for v in ct.variables:
+            v.accept(self)
+        if ct.type_guard is not None:
+            ct.type_guard.accept(self)
+        if ct.type_is is not None:
+            ct.type_is.accept(self)
+
+    def visit_overloaded(self, t: Overloaded) -> None:
+        for ct in t.items:
+            ct.accept(self)
+
+    def visit_erased_type(self, o: Any) -> None:
+        # This type should exist only temporarily during type inference
+        raise RuntimeError("Shouldn't get here", o)
+
+    def visit_deleted_type(self, o: Any) -> None:
+        pass  # Nothing to descend into.
+
+    def visit_none_type(self, o: Any) -> None:
+        pass  # Nothing to descend into.
+
+    def visit_uninhabited_type(self, o: Any) -> None:
+        pass  # Nothing to descend into.
+
+    def visit_partial_type(self, o: Any) -> None:
+        raise RuntimeError("Shouldn't get here", o)
+
+    def visit_tuple_type(self, tt: TupleType) -> None:
+        if tt.items:
+            for it in tt.items:
+                it.accept(self)
+        if tt.partial_fallback is not None:
+            tt.partial_fallback.accept(self)
+
+    def visit_typeddict_type(self, tdt: TypedDictType) -> None:
+        if tdt.items:
+            for it in tdt.items.values():
+                it.accept(self)
+        if tdt.fallback is not None:
+            if tdt.fallback.type_ref is not None:
+                if (
+                    lookup_fully_qualified(
+                        tdt.fallback.type_ref,
+                        self.modules,
+                        raise_on_missing=not self.allow_missing,
+                    )
+                    is None
+                ):
+                    # We reject fake TypeInfos for TypedDict fallbacks because
+                    # the latter are used in type checking and must be valid.
+                    tdt.fallback.type_ref = "typing._TypedDict"
+            tdt.fallback.accept(self)
+
+    def visit_literal_type(self, lt: LiteralType) -> None:
+        lt.fallback.accept(self)
+
+    def visit_type_var(self, tvt: TypeVarType) -> None:
+        if tvt.values:
+            for vt in tvt.values:
+                vt.accept(self)
+        tvt.upper_bound.accept(self)
+        tvt.default.accept(self)
+
+    def visit_param_spec(self, p: ParamSpecType) -> None:
+        p.upper_bound.accept(self)
+        p.default.accept(self)
+        p.prefix.accept(self)
+
+    def visit_type_var_tuple(self, t: TypeVarTupleType) -> None:
+        t.tuple_fallback.accept(self)
+        t.upper_bound.accept(self)
+        t.default.accept(self)
+
+    def visit_unpack_type(self, u: UnpackType) -> None:
+        u.type.accept(self)
+
+    def visit_parameters(self, p: Parameters) -> None:
+        for argt in p.arg_types:
+            if argt is not None:
+                argt.accept(self)
+        for var in p.variables:
+            var.accept(self)
+
+    def visit_unbound_type(self, o: UnboundType) -> None:
+        for a in o.args:
+            a.accept(self)
+
+    def visit_union_type(self, ut: UnionType) -> None:
+        if ut.items:
+            for it in ut.items:
+                it.accept(self)
+
+    def visit_type_type(self, t: TypeType) -> None:
+        t.item.accept(self)
+
+
+def lookup_fully_qualified_typeinfo(
+    modules: dict[str, MypyFile], name: str, *, allow_missing: bool
+) -> TypeInfo:
+    stnode = lookup_fully_qualified(name, modules, raise_on_missing=not allow_missing)
+    node = stnode.node if stnode else None
+    if isinstance(node, TypeInfo):
+        return node
+    else:
+        # Looks like a missing TypeInfo during an initial daemon load, put something there
+        assert (
+            allow_missing
+        ), "Should never get here in normal mode, got {}:{} instead of TypeInfo".format(
+            type(node).__name__, node.fullname if node else ""
+        )
+        return missing_info(modules)
+
+
+def lookup_fully_qualified_alias(
+    modules: dict[str, MypyFile], name: str, *, allow_missing: bool
+) -> TypeAlias:
+    stnode = lookup_fully_qualified(name, modules, raise_on_missing=not allow_missing)
+    node = stnode.node if stnode else None
+    if isinstance(node, TypeAlias):
+        return node
+    elif isinstance(node, TypeInfo):
+        if node.special_alias:
+            # Already fixed up.
+            return node.special_alias
+        if node.tuple_type:
+            alias = TypeAlias.from_tuple_type(node)
+        elif node.typeddict_type:
+            alias = TypeAlias.from_typeddict_type(node)
+        else:
+            assert allow_missing
+            return missing_alias()
+        node.special_alias = alias
+        return alias
+    else:
+        # Looks like a missing TypeAlias during an initial daemon load, put something there
+        assert (
+            allow_missing
+        ), "Should never get here in normal mode, got {}:{} instead of TypeAlias".format(
+            type(node).__name__, node.fullname if node else ""
+        )
+        return missing_alias()
+
+
+_SUGGESTION: Final = "<missing {}: *should* have gone away during fine-grained update>"
+
+
+def missing_info(modules: dict[str, MypyFile]) -> TypeInfo:
+    suggestion = _SUGGESTION.format("info")
+    dummy_def = ClassDef(suggestion, Block([]))
+    dummy_def.fullname = suggestion
+
+    info = TypeInfo(SymbolTable(), dummy_def, "<missing>")
+    obj_type = lookup_fully_qualified_typeinfo(modules, "builtins.object", allow_missing=False)
+    info.bases = [Instance(obj_type, [])]
+    info.mro = [info, obj_type]
+    return info
+
+
+def missing_alias() -> TypeAlias:
+    suggestion = _SUGGESTION.format("alias")
+    return TypeAlias(AnyType(TypeOfAny.special_form), suggestion, "<missing>", line=-1, column=-1)

micromamba_root/Lib/site-packages/mypy/freetree.py

@@ -0,0 +1,23 @@
+"""Generic node traverser visitor"""
+
+from __future__ import annotations
+
+from mypy.nodes import Block, MypyFile
+from mypy.traverser import TraverserVisitor
+
+
+class TreeFreer(TraverserVisitor):
+    def visit_block(self, block: Block) -> None:
+        super().visit_block(block)
+        block.body.clear()
+
+
+def free_tree(tree: MypyFile) -> None:
+    """Free all the ASTs associated with a module.
+
+    This needs to be done recursively, since symbol tables contain
+    references to definitions, so those won't be freed but we want their
+    contents to be.
+    """
+    tree.accept(TreeFreer())
+    tree.defs.clear()

micromamba_root/Lib/site-packages/mypy/fscache.py

@@ -0,0 +1,307 @@
+"""Interface for accessing the file system with automatic caching.
+
+The idea is to cache the results of any file system state reads during
+a single transaction. This has two main benefits:
+
+* This avoids redundant syscalls, as we won't perform the same OS
+  operations multiple times.
+
+* This makes it easier to reason about concurrent FS updates, as different
+  operations targeting the same paths can't report different state during
+  a transaction.
+
+Note that this only deals with reading state, not writing.
+
+Properties maintained by the API:
+
+* The contents of the file are always from the same or later time compared
+  to the reported mtime of the file, even if mtime is queried after reading
+  a file.
+
+* Repeating an operation produces the same result as the first one during
+  a transaction.
+
+* Call flush() to start a new transaction (flush the caches).
+
+The API is a bit limited. It's easy to add new cached operations, however.
+You should perform all file system reads through the API to actually take
+advantage of the benefits.
+"""
+
+from __future__ import annotations
+
+import os
+import stat
+
+from mypy_extensions import mypyc_attr
+
+from mypy.util import hash_digest
+
+
+@mypyc_attr(allow_interpreted_subclasses=True)  # for tests
+class FileSystemCache:
+    def __init__(self) -> None:
+        # The package root is not flushed with the caches.
+        # It is set by set_package_root() below.
+        self.package_root: list[str] = []
+        self.flush()
+
+    def set_package_root(self, package_root: list[str]) -> None:
+        self.package_root = package_root
+
+    def flush(self) -> None:
+        """Start another transaction and empty all caches."""
+        self.stat_or_none_cache: dict[str, os.stat_result | None] = {}
+
+        self.listdir_cache: dict[str, list[str]] = {}
+        self.listdir_error_cache: dict[str, OSError] = {}
+        self.isfile_case_cache: dict[str, bool] = {}
+        self.exists_case_cache: dict[str, bool] = {}
+        self.read_cache: dict[str, bytes] = {}
+        self.read_error_cache: dict[str, Exception] = {}
+        self.hash_cache: dict[str, str] = {}
+        self.fake_package_cache: set[str] = set()
+
+    def stat_or_none(self, path: str) -> os.stat_result | None:
+        if path in self.stat_or_none_cache:
+            return self.stat_or_none_cache[path]
+
+        st = None
+        try:
+            st = os.stat(path)
+        except OSError:
+            if self.init_under_package_root(path):
+                try:
+                    st = self._fake_init(path)
+                except OSError:
+                    pass
+
+        self.stat_or_none_cache[path] = st
+        return st
+
+    def init_under_package_root(self, path: str) -> bool:
+        """Is this path an __init__.py under a package root?
+
+        This is used to detect packages that don't contain __init__.py
+        files, which is needed to support Bazel.  The function should
+        only be called for non-existing files.
+
+        It will return True if it refers to a __init__.py file that
+        Bazel would create, so that at runtime Python would think the
+        directory containing it is a package.  For this to work you
+        must pass one or more package roots using the --package-root
+        flag.
+
+        As an exceptional case, any directory that is a package root
+        itself will not be considered to contain a __init__.py file.
+        This is different from the rules Bazel itself applies, but is
+        necessary for mypy to properly distinguish packages from other
+        directories.
+
+        See https://docs.bazel.build/versions/master/be/python.html,
+        where this behavior is described under legacy_create_init.
+        """
+        if not self.package_root:
+            return False
+        dirname, basename = os.path.split(path)
+        if basename != "__init__.py":
+            return False
+        if not os.path.basename(dirname).isidentifier():
+            # Can't put an __init__.py in a place that's not an identifier
+            return False
+
+        st = self.stat_or_none(dirname)
+        if st is None:
+            return False
+        else:
+            if not stat.S_ISDIR(st.st_mode):
+                return False
+        ok = False
+
+        # skip if on a different drive
+        current_drive, _ = os.path.splitdrive(os.getcwd())
+        drive, _ = os.path.splitdrive(path)
+        if drive != current_drive:
+            return False
+        if os.path.isabs(path):
+            path = os.path.relpath(path)
+        path = os.path.normpath(path)
+        for root in self.package_root:
+            if path.startswith(root):
+                if path == root + basename:
+                    # A package root itself is never a package.
+                    ok = False
+                    break
+                else:
+                    ok = True
+        return ok
+
+    def _fake_init(self, path: str) -> os.stat_result:
+        """Prime the cache with a fake __init__.py file.
+
+        This makes code that looks for path believe an empty file by
+        that name exists.  Should only be called after
+        init_under_package_root() returns True.
+        """
+        dirname, basename = os.path.split(path)
+        assert basename == "__init__.py", path
+        assert not os.path.exists(path), path  # Not cached!
+        dirname = os.path.normpath(dirname)
+        st = os.stat(dirname)  # May raise OSError
+        # Get stat result as a list so we can modify it.
+        seq: list[float] = list(st)
+        seq[stat.ST_MODE] = stat.S_IFREG | 0o444
+        seq[stat.ST_INO] = 1
+        seq[stat.ST_NLINK] = 1
+        seq[stat.ST_SIZE] = 0
+        st = os.stat_result(seq)
+        # Make listdir() and read() also pretend this file exists.
+        self.fake_package_cache.add(dirname)
+        return st
+
+    def listdir(self, path: str) -> list[str]:
+        path = os.path.normpath(path)
+        if path in self.listdir_cache:
+            res = self.listdir_cache[path]
+            # Check the fake cache.
+            if path in self.fake_package_cache and "__init__.py" not in res:
+                res.append("__init__.py")  # Updates the result as well as the cache
+            return res
+        if path in self.listdir_error_cache:
+            raise copy_os_error(self.listdir_error_cache[path])
+        try:
+            results = os.listdir(path)
+        except OSError as err:
+            # Like above, take a copy to reduce memory use.
+            self.listdir_error_cache[path] = copy_os_error(err)
+            raise err
+        self.listdir_cache[path] = results
+        # Check the fake cache.
+        if path in self.fake_package_cache and "__init__.py" not in results:
+            results.append("__init__.py")
+        return results
+
+    def isfile(self, path: str) -> bool:
+        st = self.stat_or_none(path)
+        if st is None:
+            return False
+        return stat.S_ISREG(st.st_mode)
+
+    def isfile_case(self, path: str, prefix: str) -> bool:
+        """Return whether path exists and is a file.
+
+        On case-insensitive filesystems (like Mac or Windows) this returns
+        False if the case of path's last component does not exactly match
+        the case found in the filesystem.
+
+        We check also the case of other path components up to prefix.
+        For example, if path is 'user-stubs/pack/mod.pyi' and prefix is 'user-stubs',
+        we check that the case of 'pack' and 'mod.py' matches exactly, 'user-stubs' will be
+        case insensitive on case insensitive filesystems.
+
+        The caller must ensure that prefix is a valid file system prefix of path.
+        """
+        if not self.isfile(path):
+            # Fast path
+            return False
+        if path in self.isfile_case_cache:
+            return self.isfile_case_cache[path]
+        head, tail = os.path.split(path)
+        if not tail:
+            self.isfile_case_cache[path] = False
+            return False
+        try:
+            names = self.listdir(head)
+            # This allows one to check file name case sensitively in
+            # case-insensitive filesystems.
+            res = tail in names
+        except OSError:
+            res = False
+        if res:
+            # Also recursively check the other path components in case sensitive way.
+            res = self.exists_case(head, prefix)
+        self.isfile_case_cache[path] = res
+        return res
+
+    def exists_case(self, path: str, prefix: str) -> bool:
+        """Return whether path exists - checking path components in case sensitive
+        fashion, up to prefix.
+        """
+        if path in self.exists_case_cache:
+            return self.exists_case_cache[path]
+        head, tail = os.path.split(path)
+        if not head.startswith(prefix) or not tail:
+            # Only perform the check for paths under prefix.
+            self.exists_case_cache[path] = True
+            return True
+        try:
+            names = self.listdir(head)
+            # This allows one to check file name case sensitively in
+            # case-insensitive filesystems.
+            res = tail in names
+        except OSError:
+            res = False
+        if res:
+            # Also recursively check other path components.
+            res = self.exists_case(head, prefix)
+        self.exists_case_cache[path] = res
+        return res
+
+    def isdir(self, path: str) -> bool:
+        st = self.stat_or_none(path)
+        if st is None:
+            return False
+        return stat.S_ISDIR(st.st_mode)
+
+    def exists(self, path: str) -> bool:
+        st = self.stat_or_none(path)
+        return st is not None
+
+    def read(self, path: str) -> bytes:
+        if path in self.read_cache:
+            return self.read_cache[path]
+        if path in self.read_error_cache:
+            raise self.read_error_cache[path]
+
+        # Need to stat first so that the contents of file are from no
+        # earlier instant than the mtime reported by self.stat().
+        self.stat_or_none(path)
+
+        dirname, basename = os.path.split(path)
+        dirname = os.path.normpath(dirname)
+        # Check the fake cache.
+        if basename == "__init__.py" and dirname in self.fake_package_cache:
+            data = b""
+        else:
+            try:
+                with open(path, "rb") as f:
+                    data = f.read()
+            except OSError as err:
+                self.read_error_cache[path] = err
+                raise
+
+        self.read_cache[path] = data
+        self.hash_cache[path] = hash_digest(data)
+        return data
+
+    def hash_digest(self, path: str) -> str:
+        if path not in self.hash_cache:
+            self.read(path)
+        return self.hash_cache[path]
+
+    def samefile(self, f1: str, f2: str) -> bool:
+        s1 = self.stat_or_none(f1)
+        s2 = self.stat_or_none(f2)
+        if s1 is None or s2 is None:
+            return False
+        return os.path.samestat(s1, s2)
+
+
+def copy_os_error(e: OSError) -> OSError:
+    new = OSError(*e.args)
+    new.errno = e.errno
+    new.strerror = e.strerror
+    new.filename = e.filename
+    if e.filename2:
+        new.filename2 = e.filename2
+    return new

micromamba_root/Lib/site-packages/mypy/fswatcher.py

@@ -0,0 +1,106 @@
+"""Watch parts of the file system for changes."""
+
+from __future__ import annotations
+
+import os
+from collections.abc import Iterable, Set as AbstractSet
+from typing import NamedTuple
+
+from mypy.fscache import FileSystemCache
+
+
+class FileData(NamedTuple):
+    st_mtime: float
+    st_size: int
+    hash: str
+
+
+class FileSystemWatcher:
+    """Watcher for file system changes among specific paths.
+
+    All file system access is performed using FileSystemCache. We
+    detect changed files by stat()ing them all and comparing hashes
+    of potentially changed files. If a file has both size and mtime
+    unmodified, the file is assumed to be unchanged.
+
+    An important goal of this class is to make it easier to eventually
+    use file system events to detect file changes.
+
+    Note: This class doesn't flush the file system cache. If you don't
+    manually flush it, changes won't be seen.
+    """
+
+    # TODO: Watching directories?
+    # TODO: Handle non-files
+
+    def __init__(self, fs: FileSystemCache) -> None:
+        self.fs = fs
+        self._paths: set[str] = set()
+        self._file_data: dict[str, FileData | None] = {}
+
+    def dump_file_data(self) -> dict[str, tuple[float, int, str]]:
+        return {k: v for k, v in self._file_data.items() if v is not None}
+
+    def set_file_data(self, path: str, data: FileData) -> None:
+        self._file_data[path] = data
+
+    def add_watched_paths(self, paths: Iterable[str]) -> None:
+        for path in paths:
+            if path not in self._paths:
+                # By storing None this path will get reported as changed by
+                # find_changed if it exists.
+                self._file_data[path] = None
+        self._paths |= set(paths)
+
+    def remove_watched_paths(self, paths: Iterable[str]) -> None:
+        for path in paths:
+            if path in self._file_data:
+                del self._file_data[path]
+        self._paths -= set(paths)
+
+    def _update(self, path: str, st: os.stat_result) -> None:
+        hash_digest = self.fs.hash_digest(path)
+        self._file_data[path] = FileData(st.st_mtime, st.st_size, hash_digest)
+
+    def _find_changed(self, paths: Iterable[str]) -> AbstractSet[str]:
+        changed = set()
+        for path in paths:
+            old = self._file_data[path]
+            st = self.fs.stat_or_none(path)
+            if st is None:
+                if old is not None:
+                    # File was deleted.
+                    changed.add(path)
+                    self._file_data[path] = None
+            else:
+                if old is None:
+                    # File is new.
+                    changed.add(path)
+                    self._update(path, st)
+                # Round mtimes down, to match the mtimes we write to meta files
+                elif st.st_size != old.st_size or int(st.st_mtime) != int(old.st_mtime):
+                    # Only look for changes if size or mtime has changed as an
+                    # optimization, since calculating hash is expensive.
+                    new_hash = self.fs.hash_digest(path)
+                    self._update(path, st)
+                    if st.st_size != old.st_size or new_hash != old.hash:
+                        # Changed file.
+                        changed.add(path)
+        return changed
+
+    def find_changed(self) -> AbstractSet[str]:
+        """Return paths that have changes since the last call, in the watched set."""
+        return self._find_changed(self._paths)
+
+    def update_changed(self, remove: list[str], update: list[str]) -> AbstractSet[str]:
+        """Alternative to find_changed() given explicit changes.
+
+        This only calls self.fs.stat() on added or updated files, not
+        on all files.  It believes all other files are unchanged!
+
+        Implies add_watched_paths() for add and update, and
+        remove_watched_paths() for remove.
+        """
+        self.remove_watched_paths(remove)
+        self.add_watched_paths(update)
+        return self._find_changed(update)

micromamba_root/Lib/site-packages/mypy/gclogger.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+import gc
+import time
+from collections.abc import Mapping
+
+
+class GcLogger:
+    """Context manager to log GC stats and overall time."""
+
+    def __enter__(self) -> GcLogger:
+        self.gc_start_time: float | None = None
+        self.gc_time = 0.0
+        self.gc_calls = 0
+        self.gc_collected = 0
+        self.gc_uncollectable = 0
+        gc.callbacks.append(self.gc_callback)
+        self.start_time = time.time()
+        return self
+
+    def gc_callback(self, phase: str, info: Mapping[str, int]) -> None:
+        if phase == "start":
+            assert self.gc_start_time is None, "Start phase out of sequence"
+            self.gc_start_time = time.time()
+        elif phase == "stop":
+            assert self.gc_start_time is not None, "Stop phase out of sequence"
+            self.gc_calls += 1
+            self.gc_time += time.time() - self.gc_start_time
+            self.gc_start_time = None
+            self.gc_collected += info["collected"]
+            self.gc_uncollectable += info["uncollectable"]
+        else:
+            assert False, f"Unrecognized gc phase ({phase!r})"
+
+    def __exit__(self, *args: object) -> None:
+        while self.gc_callback in gc.callbacks:
+            gc.callbacks.remove(self.gc_callback)
+
+    def get_stats(self) -> Mapping[str, float]:
+        end_time = time.time()
+        result = {
+            "gc_time": self.gc_time,
+            "gc_calls": self.gc_calls,
+            "gc_collected": self.gc_collected,
+            "gc_uncollectable": self.gc_uncollectable,
+            "build_time": end_time - self.start_time,
+        }
+        return result

micromamba_root/Lib/site-packages/mypy/git.py

@@ -0,0 +1,34 @@
+"""Git utilities."""
+
+# Used also from setup.py, so don't pull in anything additional here (like mypy or typing):
+from __future__ import annotations
+
+import os
+import subprocess
+
+
+def is_git_repo(dir: str) -> bool:
+    """Is the given directory version-controlled with git?"""
+    return os.path.exists(os.path.join(dir, ".git"))
+
+
+def have_git() -> bool:
+    """Can we run the git executable?"""
+    try:
+        subprocess.check_output(["git", "--help"])
+        return True
+    except subprocess.CalledProcessError:
+        return False
+    except OSError:
+        return False
+
+
+def git_revision(dir: str) -> bytes:
+    """Get the SHA-1 of the HEAD of a git repository."""
+    return subprocess.check_output(["git", "rev-parse", "HEAD"], cwd=dir).strip()
+
+
+def is_dirty(dir: str) -> bool:
+    """Check whether a git repository has uncommitted changes."""
+    output = subprocess.check_output(["git", "status", "-uno", "--porcelain"], cwd=dir)
+    return output.strip() != b""

micromamba_root/Lib/site-packages/mypy/graph_utils.py

@@ -0,0 +1,161 @@
+"""Helpers for manipulations with graphs."""
+
+from __future__ import annotations
+
+from collections.abc import Iterator, Set as AbstractSet
+from typing import TypeVar
+
+T = TypeVar("T")
+
+
+def strongly_connected_components(
+    vertices: AbstractSet[T], edges: dict[T, list[T]]
+) -> Iterator[set[T]]:
+    """Compute Strongly Connected Components of a directed graph.
+
+    Args:
+      vertices: the labels for the vertices
+      edges: for each vertex, gives the target vertices of its outgoing edges
+
+    Returns:
+      An iterator yielding strongly connected components, each
+      represented as a set of vertices.  Each input vertex will occur
+      exactly once; vertices not part of a SCC are returned as
+      singleton sets.
+
+    From https://code.activestate.com/recipes/578507/.
+    """
+    identified: set[T] = set()
+    stack: list[T] = []
+    index: dict[T, int] = {}
+    boundaries: list[int] = []
+
+    def dfs(v: T) -> Iterator[set[T]]:
+        index[v] = len(stack)
+        stack.append(v)
+        boundaries.append(index[v])
+
+        for w in edges[v]:
+            if w not in index:
+                yield from dfs(w)
+            elif w not in identified:
+                while index[w] < boundaries[-1]:
+                    boundaries.pop()
+
+        if boundaries[-1] == index[v]:
+            boundaries.pop()
+            scc = set(stack[index[v] :])
+            del stack[index[v] :]
+            identified.update(scc)
+            yield scc
+
+    for v in vertices:
+        if v not in index:
+            yield from dfs(v)
+
+
+def prepare_sccs(
+    sccs: list[set[T]], edges: dict[T, list[T]]
+) -> dict[AbstractSet[T], set[AbstractSet[T]]]:
+    """Use original edges to organize SCCs in a graph by dependencies between them."""
+    sccsmap = {}
+    for scc in sccs:
+        scc_frozen = frozenset(scc)
+        for v in scc:
+            sccsmap[v] = scc_frozen
+    data: dict[AbstractSet[T], set[AbstractSet[T]]] = {}
+    for scc in sccs:
+        deps: set[AbstractSet[T]] = set()
+        for v in scc:
+            deps.update(sccsmap[x] for x in edges[v])
+        data[frozenset(scc)] = deps
+    return data
+
+
+class topsort(Iterator[set[T]]):  # noqa: N801
+    """Topological sort using Kahn's algorithm.
+
+    Uses in-degree counters and a reverse adjacency list, so the total work
+    is O(V + E).
+
+    Implemented as a class rather than a generator for better mypyc
+    compilation.
+
+    Args:
+      data: A map from vertices to all vertices that it has an edge
+            connecting it to. NOTE: dependency sets in this data
+            structure are modified in place to remove self-dependencies.
+            Orphans are handled internally and are not added to `data`.
+
+    Returns:
+      An iterator yielding sets of vertices that have an equivalent
+      ordering.
+
+    Example:
+      Suppose the input has the following structure:
+
+        {A: {B, C}, B: {D}, C: {D}}
+
+      The algorithm treats orphan dependencies as if normalized to:
+
+        {A: {B, C}, B: {D}, C: {D}, D: {}}
+
+      It will yield the following values:
+
+        {D}
+        {B, C}
+        {A}
+    """
+
+    def __init__(self, data: dict[T, set[T]]) -> None:
+        # Single pass: remove self-deps, build reverse adjacency list,
+        # compute in-degree counts, detect orphans, and find initial ready set.
+        in_degree: dict[T, int] = {}
+        rev: dict[T, list[T]] = {}
+        ready: set[T] = set()
+        for item, deps in data.items():
+            deps.discard(item)  # Ignore self dependencies.
+            deg = len(deps)
+            in_degree[item] = deg
+            if deg == 0:
+                ready.add(item)
+            if item not in rev:
+                rev[item] = []
+            for dep in deps:
+                if dep in rev:
+                    rev[dep].append(item)
+                else:
+                    rev[dep] = [item]
+                    if dep not in data:
+                        # Orphan: appears as dependency but has no entry in data.
+                        in_degree[dep] = 0
+                        ready.add(dep)
+
+        self.in_degree = in_degree
+        self.rev = rev
+        self.ready = ready
+        self.remaining = len(in_degree) - len(ready)
+
+    def __iter__(self) -> Iterator[set[T]]:
+        return self
+
+    def __next__(self) -> set[T]:
+        ready = self.ready
+        if not ready:
+            assert self.remaining == 0, (
+                f"A cyclic dependency exists amongst "
+                f"{[k for k, deg in self.in_degree.items() if deg > 0]!r}"
+            )
+            raise StopIteration
+        in_degree = self.in_degree
+        rev = self.rev
+        new_ready: set[T] = set()
+        for item in ready:
+            for dependent in rev[item]:
+                new_deg = in_degree[dependent] - 1
+                in_degree[dependent] = new_deg
+                if new_deg == 0:
+                    new_ready.add(dependent)
+        self.remaining -= len(new_ready)
+        self.ready = new_ready
+        return ready

micromamba_root/Lib/site-packages/mypy/indirection.py

@@ -0,0 +1,170 @@
+from __future__ import annotations
+
+from collections.abc import Iterable
+
+import mypy.types as types
+from mypy.types import TypeVisitor
+
+
+class TypeIndirectionVisitor(TypeVisitor[None]):
+    """Returns all module references within a particular type."""
+
+    def __init__(self) -> None:
+        # Module references are collected here
+        self.modules: set[str] = set()
+        # User to avoid infinite recursion with recursive types
+        self.seen_types: set[types.TypeAliasType | types.Instance] = set()
+
+    def find_modules(self, typs: Iterable[types.Type]) -> set[str]:
+        self.modules = set()
+        self.seen_types = set()
+        for typ in typs:
+            self._visit(typ)
+        return self.modules
+
+    def _visit(self, typ: types.Type) -> None:
+        # Note: instances are needed for `class str(Sequence[str]): ...`
+        if (
+            isinstance(typ, types.TypeAliasType)
+            or isinstance(typ, types.ProperType)
+            and isinstance(typ, types.Instance)
+        ):
+            # Avoid infinite recursion for recursive types.
+            if typ in self.seen_types:
+                return
+            self.seen_types.add(typ)
+        typ.accept(self)
+
+    def _visit_type_tuple(self, typs: tuple[types.Type, ...]) -> None:
+        # Micro-optimization: Specialized version of _visit for lists
+        for typ in typs:
+            if (
+                isinstance(typ, types.TypeAliasType)
+                or isinstance(typ, types.ProperType)
+                and isinstance(typ, types.Instance)
+            ):
+                # Avoid infinite recursion for recursive types.
+                if typ in self.seen_types:
+                    continue
+                self.seen_types.add(typ)
+            typ.accept(self)
+
+    def _visit_type_list(self, typs: list[types.Type]) -> None:
+        # Micro-optimization: Specialized version of _visit for tuples
+        for typ in typs:
+            if (
+                isinstance(typ, types.TypeAliasType)
+                or isinstance(typ, types.ProperType)
+                and isinstance(typ, types.Instance)
+            ):
+                # Avoid infinite recursion for recursive types.
+                if typ in self.seen_types:
+                    continue
+                self.seen_types.add(typ)
+            typ.accept(self)
+
+    def visit_unbound_type(self, t: types.UnboundType) -> None:
+        self._visit_type_tuple(t.args)
+
+    def visit_any(self, t: types.AnyType) -> None:
+        pass
+
+    def visit_none_type(self, t: types.NoneType) -> None:
+        pass
+
+    def visit_uninhabited_type(self, t: types.UninhabitedType) -> None:
+        pass
+
+    def visit_erased_type(self, t: types.ErasedType) -> None:
+        pass
+
+    def visit_deleted_type(self, t: types.DeletedType) -> None:
+        pass
+
+    def visit_type_var(self, t: types.TypeVarType) -> None:
+        self._visit_type_list(t.values)
+        self._visit(t.upper_bound)
+        self._visit(t.default)
+
+    def visit_param_spec(self, t: types.ParamSpecType) -> None:
+        self._visit(t.upper_bound)
+        self._visit(t.default)
+        self._visit(t.prefix)
+
+    def visit_type_var_tuple(self, t: types.TypeVarTupleType) -> None:
+        self._visit(t.upper_bound)
+        self._visit(t.default)
+
+    def visit_unpack_type(self, t: types.UnpackType) -> None:
+        t.type.accept(self)
+
+    def visit_parameters(self, t: types.Parameters) -> None:
+        self._visit_type_list(t.arg_types)
+
+    def visit_instance(self, t: types.Instance) -> None:
+        # Instance is named, record its definition and continue digging into
+        # components that constitute semantic meaning of this type: bases, metaclass,
+        # tuple type, and typeddict type.
+        # Note: we cannot simply record the MRO, in case an intermediate base contains
+        # a reference to type alias, this affects meaning of map_instance_to_supertype(),
+        # see e.g. testDoubleReexportGenericUpdated.
+        self._visit_type_tuple(t.args)
+        if t.type:
+            # Important optimization: instead of simply recording the definition and
+            # recursing into bases, record the MRO and only traverse generic bases.
+            for s in t.type.mro:
+                self.modules.add(s.module_name)
+                for base in s.bases:
+                    if base.args:
+                        self._visit_type_tuple(base.args)
+            if t.type.metaclass_type:
+                self._visit(t.type.metaclass_type)
+            if t.type.typeddict_type:
+                self._visit(t.type.typeddict_type)
+            if t.type.tuple_type:
+                self._visit(t.type.tuple_type)
+            if t.type.is_protocol:
+                # For protocols, member types constitute the semantic meaning of the type.
+                # TODO: this doesn't cover some edge cases, like setter types and exotic nodes.
+                for m in t.type.protocol_members:
+                    node = t.type.names.get(m)
+                    if node and node.type:
+                        self._visit(node.type)
+
+    def visit_callable_type(self, t: types.CallableType) -> None:
+        self._visit_type_list(t.arg_types)
+        self._visit(t.ret_type)
+        self._visit_type_tuple(t.variables)
+
+    def visit_overloaded(self, t: types.Overloaded) -> None:
+        for item in t.items:
+            self._visit(item)
+        self._visit(t.fallback)
+
+    def visit_tuple_type(self, t: types.TupleType) -> None:
+        self._visit_type_list(t.items)
+        self._visit(t.partial_fallback)
+
+    def visit_typeddict_type(self, t: types.TypedDictType) -> None:
+        self._visit_type_list(list(t.items.values()))
+        self._visit(t.fallback)
+
+    def visit_literal_type(self, t: types.LiteralType) -> None:
+        self._visit(t.fallback)
+
+    def visit_union_type(self, t: types.UnionType) -> None:
+        self._visit_type_list(t.items)
+
+    def visit_partial_type(self, t: types.PartialType) -> None:
+        pass
+
+    def visit_type_type(self, t: types.TypeType) -> None:
+        self._visit(t.item)
+
+    def visit_type_alias_type(self, t: types.TypeAliasType) -> None:
+        # Type alias is named, record its definition and continue digging into
+        # components that constitute semantic meaning of this type: target and args.
+        if t.alias:
+            self.modules.add(t.alias.module)
+            self._visit(t.alias.target)
+        self._visit_type_list(t.args)

micromamba_root/Lib/site-packages/mypy/infer.py

@@ -0,0 +1,76 @@
+"""Utilities for type argument inference."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import NamedTuple
+
+from mypy.constraints import (
+    SUBTYPE_OF,
+    SUPERTYPE_OF,
+    infer_constraints,
+    infer_constraints_for_callable,
+)
+from mypy.nodes import ArgKind
+from mypy.solve import solve_constraints
+from mypy.types import CallableType, Instance, Type, TypeVarLikeType
+
+
+class ArgumentInferContext(NamedTuple):
+    """Type argument inference context.
+
+    We need this because we pass around ``Mapping`` and ``Iterable`` types.
+    These types are only known by ``TypeChecker`` itself.
+    It is required for ``*`` and ``**`` argument inference.
+
+    https://github.com/python/mypy/issues/11144
+    """
+
+    mapping_type: Instance
+    iterable_type: Instance
+
+
+def infer_function_type_arguments(
+    callee_type: CallableType,
+    arg_types: Sequence[Type | None],
+    arg_kinds: list[ArgKind],
+    arg_names: Sequence[str | None] | None,
+    formal_to_actual: list[list[int]],
+    context: ArgumentInferContext,
+    strict: bool = True,
+    allow_polymorphic: bool = False,
+) -> tuple[list[Type | None], list[TypeVarLikeType]]:
+    """Infer the type arguments of a generic function.
+
+    Return an array of lower bound types for the type variables -1 (at
+    index 0), -2 (at index 1), etc. A lower bound is None if a value
+    could not be inferred.
+
+    Arguments:
+      callee_type: the target generic function
+      arg_types: argument types at the call site (each optional; if None,
+                 we are not considering this argument in the current pass)
+      arg_kinds: nodes.ARG_* values for arg_types
+      formal_to_actual: mapping from formal to actual variable indices
+    """
+    # Infer constraints.
+    constraints = infer_constraints_for_callable(
+        callee_type, arg_types, arg_kinds, arg_names, formal_to_actual, context
+    )
+
+    # Solve constraints.
+    type_vars = callee_type.variables
+    return solve_constraints(type_vars, constraints, strict, allow_polymorphic)
+
+
+def infer_type_arguments(
+    type_vars: Sequence[TypeVarLikeType],
+    template: Type,
+    actual: Type,
+    is_supertype: bool = False,
+    skip_unsatisfied: bool = False,
+) -> list[Type | None]:
+    # Like infer_function_type_arguments, but only match a single type
+    # against a generic type.
+    constraints = infer_constraints(template, actual, SUPERTYPE_OF if is_supertype else SUBTYPE_OF)
+    return solve_constraints(type_vars, constraints, skip_unsatisfied=skip_unsatisfied)[0]

micromamba_root/Lib/site-packages/mypy/inspections.py

@@ -0,0 +1,626 @@
+from __future__ import annotations
+
+import os
+from collections import defaultdict
+from collections.abc import Callable
+from functools import cmp_to_key
+
+from mypy.build import State
+from mypy.messages import format_type
+from mypy.modulefinder import PYTHON_EXTENSIONS
+from mypy.nodes import (
+    LDEF,
+    Decorator,
+    Expression,
+    FuncBase,
+    MemberExpr,
+    MypyFile,
+    Node,
+    OverloadedFuncDef,
+    RefExpr,
+    SymbolNode,
+    TypeInfo,
+    Var,
+)
+from mypy.server.update import FineGrainedBuildManager
+from mypy.traverser import ExtendedTraverserVisitor
+from mypy.typeops import tuple_fallback
+from mypy.types import (
+    FunctionLike,
+    Instance,
+    LiteralType,
+    ProperType,
+    TupleType,
+    TypedDictType,
+    TypeVarType,
+    UnionType,
+    get_proper_type,
+)
+from mypy.typevars import fill_typevars_with_any
+
+
+def node_starts_after(o: Node, line: int, column: int) -> bool:
+    return o.line > line or o.line == line and o.column > column
+
+
+def node_ends_before(o: Node, line: int, column: int) -> bool:
+    # Unfortunately, end positions for some statements are a mess,
+    # e.g. overloaded functions, so we return False when we don't know.
+    if o.end_line is not None and o.end_column is not None:
+        if o.end_line < line or o.end_line == line and o.end_column < column:
+            return True
+    return False
+
+
+def expr_span(expr: Expression) -> str:
+    """Format expression span as in mypy error messages."""
+    return f"{expr.line}:{expr.column + 1}:{expr.end_line}:{expr.end_column}"
+
+
+def get_instance_fallback(typ: ProperType) -> list[Instance]:
+    """Returns the Instance fallback for this type if one exists or None."""
+    if isinstance(typ, Instance):
+        return [typ]
+    elif isinstance(typ, TupleType):
+        return [tuple_fallback(typ)]
+    elif isinstance(typ, TypedDictType):
+        return [typ.fallback]
+    elif isinstance(typ, FunctionLike):
+        return [typ.fallback]
+    elif isinstance(typ, LiteralType):
+        return [typ.fallback]
+    elif isinstance(typ, TypeVarType):
+        if typ.values:
+            res = []
+            for t in typ.values:
+                res.extend(get_instance_fallback(get_proper_type(t)))
+            return res
+        return get_instance_fallback(get_proper_type(typ.upper_bound))
+    elif isinstance(typ, UnionType):
+        res = []
+        for t in typ.items:
+            res.extend(get_instance_fallback(get_proper_type(t)))
+        return res
+    return []
+
+
+def find_node(name: str, info: TypeInfo) -> Var | FuncBase | None:
+    """Find the node defining member 'name' in given TypeInfo."""
+    # TODO: this code shares some logic with checkmember.py
+    method = info.get_method(name)
+    if method:
+        if isinstance(method, Decorator):
+            return method.var
+        if method.is_property:
+            assert isinstance(method, OverloadedFuncDef)
+            dec = method.items[0]
+            assert isinstance(dec, Decorator)
+            return dec.var
+        return method
+    else:
+        # don't have such method, maybe variable?
+        node = info.get(name)
+        v = node.node if node else None
+        if isinstance(v, Var):
+            return v
+    return None
+
+
+def find_module_by_fullname(fullname: str, modules: dict[str, State]) -> State | None:
+    """Find module by a node fullname.
+
+    This logic mimics the one we use in fixup, so should be good enough.
+    """
+    head = fullname
+    # Special case: a module symbol is considered to be defined in itself, not in enclosing
+    # package, since this is what users want when clicking go to definition on a module.
+    if head in modules:
+        return modules[head]
+    while True:
+        if "." not in head:
+            return None
+        head, tail = head.rsplit(".", maxsplit=1)
+        mod = modules.get(head)
+        if mod is not None:
+            return mod
+
+
+class SearchVisitor(ExtendedTraverserVisitor):
+    """Visitor looking for an expression whose span matches given one exactly."""
+
+    def __init__(self, line: int, column: int, end_line: int, end_column: int) -> None:
+        self.line = line
+        self.column = column
+        self.end_line = end_line
+        self.end_column = end_column
+        self.result: Expression | None = None
+
+    def visit(self, o: Node) -> bool:
+        if node_starts_after(o, self.line, self.column):
+            return False
+        if node_ends_before(o, self.end_line, self.end_column):
+            return False
+        if (
+            o.line == self.line
+            and o.end_line == self.end_line
+            and o.column == self.column
+            and o.end_column == self.end_column
+        ):
+            if isinstance(o, Expression):
+                self.result = o
+        return self.result is None
+
+
+def find_by_location(
+    tree: MypyFile, line: int, column: int, end_line: int, end_column: int
+) -> Expression | None:
+    """Find an expression matching given span, or None if not found."""
+    if end_line < line:
+        raise ValueError('"end_line" must not be before "line"')
+    if end_line == line and end_column <= column:
+        raise ValueError('"end_column" must be after "column"')
+    visitor = SearchVisitor(line, column, end_line, end_column)
+    tree.accept(visitor)
+    return visitor.result
+
+
+class SearchAllVisitor(ExtendedTraverserVisitor):
+    """Visitor looking for all expressions whose spans enclose given position."""
+
+    def __init__(self, line: int, column: int) -> None:
+        self.line = line
+        self.column = column
+        self.result: list[Expression] = []
+
+    def visit(self, o: Node) -> bool:
+        if node_starts_after(o, self.line, self.column):
+            return False
+        if node_ends_before(o, self.line, self.column):
+            return False
+        if isinstance(o, Expression):
+            self.result.append(o)
+        return True
+
+
+def find_all_by_location(tree: MypyFile, line: int, column: int) -> list[Expression]:
+    """Find all expressions enclosing given position starting from innermost."""
+    visitor = SearchAllVisitor(line, column)
+    tree.accept(visitor)
+    return list(reversed(visitor.result))
+
+
+class InspectionEngine:
+    """Engine for locating and statically inspecting expressions."""
+
+    def __init__(
+        self,
+        fg_manager: FineGrainedBuildManager,
+        *,
+        verbosity: int = 0,
+        limit: int = 0,
+        include_span: bool = False,
+        include_kind: bool = False,
+        include_object_attrs: bool = False,
+        union_attrs: bool = False,
+        force_reload: bool = False,
+    ) -> None:
+        self.fg_manager = fg_manager
+        self.verbosity = verbosity
+        self.limit = limit
+        self.include_span = include_span
+        self.include_kind = include_kind
+        self.include_object_attrs = include_object_attrs
+        self.union_attrs = union_attrs
+        self.force_reload = force_reload
+        # Module for which inspection was requested.
+        self.module: State | None = None
+
+    def reload_module(self, state: State) -> None:
+        """Reload given module while temporary exporting types."""
+        old = self.fg_manager.manager.options.export_types
+        self.fg_manager.manager.options.export_types = True
+        try:
+            self.fg_manager.flush_cache()
+            assert state.path is not None
+            self.fg_manager.update([(state.id, state.path)], [])
+        finally:
+            self.fg_manager.manager.options.export_types = old
+
+    def expr_type(self, expression: Expression) -> tuple[str, bool]:
+        """Format type for an expression using current options.
+
+        If type is known, second item returned is True. If type is not known, an error
+        message is returned instead, and second item returned is False.
+        """
+        expr_type = self.fg_manager.manager.all_types.get(expression)
+        if expr_type is None:
+            return self.missing_type(expression), False
+
+        type_str = format_type(
+            expr_type, self.fg_manager.manager.options, verbosity=self.verbosity
+        )
+        return self.add_prefixes(type_str, expression), True
+
+    def object_type(self) -> Instance:
+        builtins = self.fg_manager.graph["builtins"].tree
+        assert builtins is not None
+        object_node = builtins.names["object"].node
+        assert isinstance(object_node, TypeInfo)
+        return Instance(object_node, [])
+
+    def collect_attrs(self, instances: list[Instance]) -> dict[TypeInfo, list[str]]:
+        """Collect attributes from all union/typevar variants."""
+
+        def item_attrs(attr_dict: dict[TypeInfo, list[str]]) -> set[str]:
+            attrs = set()
+            for base in attr_dict:
+                attrs |= set(attr_dict[base])
+            return attrs
+
+        def cmp_types(x: TypeInfo, y: TypeInfo) -> int:
+            if x in y.mro:
+                return 1
+            if y in x.mro:
+                return -1
+            return 0
+
+        # First gather all attributes for every union variant.
+        assert instances
+        all_attrs = []
+        for instance in instances:
+            attrs = {}
+            mro = instance.type.mro
+            if not self.include_object_attrs:
+                mro = mro[:-1]
+            for base in mro:
+                attrs[base] = sorted(base.names)
+            all_attrs.append(attrs)
+
+        # Find attributes valid for all variants in a union or type variable.
+        intersection = item_attrs(all_attrs[0])
+        for item in all_attrs[1:]:
+            intersection &= item_attrs(item)
+
+        # Combine attributes from all variants into a single dict while
+        # also removing invalid attributes (unless using --union-attrs).
+        combined_attrs = defaultdict(list)
+        for item in all_attrs:
+            for base in item:
+                if base in combined_attrs:
+                    continue
+                for name in item[base]:
+                    if self.union_attrs or name in intersection:
+                        combined_attrs[base].append(name)
+
+        # Sort bases by MRO, unrelated will appear in the order they appeared as union variants.
+        sorted_bases = sorted(combined_attrs.keys(), key=cmp_to_key(cmp_types))
+        result = {}
+        for base in sorted_bases:
+            if not combined_attrs[base]:
+                # Skip bases where everytihng was filtered out.
+                continue
+            result[base] = combined_attrs[base]
+        return result
+
+    def _fill_from_dict(
+        self, attrs_strs: list[str], attrs_dict: dict[TypeInfo, list[str]]
+    ) -> None:
+        for base in attrs_dict:
+            cls_name = base.name if self.verbosity < 1 else base.fullname
+            attrs = [f'"{attr}"' for attr in attrs_dict[base]]
+            attrs_strs.append(f'"{cls_name}": [{", ".join(attrs)}]')
+
+    def expr_attrs(self, expression: Expression) -> tuple[str, bool]:
+        """Format attributes that are valid for a given expression.
+
+        If expression type is not an Instance, try using fallback. Attributes are
+        returned as a JSON (ordered by MRO) that maps base class name to list of
+        attributes. Attributes may appear in multiple bases if overridden (we simply
+        follow usual mypy logic for creating new Vars etc).
+        """
+        expr_type = self.fg_manager.manager.all_types.get(expression)
+        if expr_type is None:
+            return self.missing_type(expression), False
+
+        expr_type = get_proper_type(expr_type)
+        instances = get_instance_fallback(expr_type)
+        if not instances:
+            # Everything is an object in Python.
+            instances = [self.object_type()]
+
+        attrs_dict = self.collect_attrs(instances)
+
+        # Special case: modules have names apart from those from ModuleType.
+        if isinstance(expression, RefExpr) and isinstance(expression.node, MypyFile):
+            node = expression.node
+            names = sorted(node.names)
+            if "__builtins__" in names:
+                # This is just to make tests stable. No one will really need this name.
+                names.remove("__builtins__")
+            mod_dict = {f'"<{node.fullname}>"': [f'"{name}"' for name in names]}
+        else:
+            mod_dict = {}
+
+        # Special case: for class callables, prepend with the class attributes.
+        # TODO: also handle cases when such callable appears in a union.
+        if isinstance(expr_type, FunctionLike) and expr_type.is_type_obj():
+            template = fill_typevars_with_any(expr_type.type_object())
+            class_dict = self.collect_attrs(get_instance_fallback(template))
+        else:
+            class_dict = {}
+
+        # We don't use JSON dump to be sure keys order is always preserved.
+        base_attrs = []
+        if mod_dict:
+            for mod in mod_dict:
+                base_attrs.append(f'{mod}: [{", ".join(mod_dict[mod])}]')
+        self._fill_from_dict(base_attrs, class_dict)
+        self._fill_from_dict(base_attrs, attrs_dict)
+        return self.add_prefixes(f'{{{", ".join(base_attrs)}}}', expression), True
+
+    def format_node(self, module: State, node: FuncBase | SymbolNode) -> str:
+        return f"{module.path}:{node.line}:{node.column + 1}:{node.name}"
+
+    def collect_nodes(self, expression: RefExpr) -> list[FuncBase | SymbolNode]:
+        """Collect nodes that can be referred to by an expression.
+
+        Note: it can be more than one for example in case of a union attribute.
+        """
+        node: FuncBase | SymbolNode | None = expression.node
+        nodes: list[FuncBase | SymbolNode]
+        if node is None:
+            # Tricky case: instance attribute
+            if isinstance(expression, MemberExpr) and expression.kind is None:
+                base_type = self.fg_manager.manager.all_types.get(expression.expr)
+                if base_type is None:
+                    return []
+
+                # Now we use the base type to figure out where the attribute is defined.
+                base_type = get_proper_type(base_type)
+                instances = get_instance_fallback(base_type)
+                nodes = []
+                for instance in instances:
+                    node = find_node(expression.name, instance.type)
+                    if node:
+                        nodes.append(node)
+                if not nodes:
+                    # Try checking class namespace if attribute is on a class object.
+                    if isinstance(base_type, FunctionLike) and base_type.is_type_obj():
+                        instances = get_instance_fallback(
+                            fill_typevars_with_any(base_type.type_object())
+                        )
+                        for instance in instances:
+                            node = find_node(expression.name, instance.type)
+                            if node:
+                                nodes.append(node)
+                    else:
+                        # Still no luck, give up.
+                        return []
+            else:
+                return []
+        else:
+            # Easy case: a module-level definition
+            nodes = [node]
+        return nodes
+
+    def modules_for_nodes(
+        self, nodes: list[FuncBase | SymbolNode], expression: RefExpr
+    ) -> tuple[dict[FuncBase | SymbolNode, State], bool]:
+        """Gather modules where given nodes where defined.
+
+        Also check if they need to be refreshed (cached nodes may have
+        lines/columns missing).
+        """
+        modules = {}
+        reload_needed = False
+        for node in nodes:
+            module = find_module_by_fullname(node.fullname, self.fg_manager.graph)
+            if not module:
+                if expression.kind == LDEF and self.module:
+                    module = self.module
+                else:
+                    continue
+            modules[node] = module
+            if not module.tree or module.tree.is_cache_skeleton or self.force_reload:
+                reload_needed |= not module.tree or module.tree.is_cache_skeleton
+                self.reload_module(module)
+        return modules, reload_needed
+
+    def expression_def(self, expression: Expression) -> tuple[str, bool]:
+        """Find and format definition location for an expression.
+
+        If it is not a RefExpr, it is effectively skipped by returning an
+        empty result.
+        """
+        if not isinstance(expression, RefExpr):
+            # If there are no suitable matches at all, we return error later.
+            return "", True
+
+        nodes = self.collect_nodes(expression)
+
+        if not nodes:
+            return self.missing_node(expression), False
+
+        modules, reload_needed = self.modules_for_nodes(nodes, expression)
+        if reload_needed:
+            # TODO: line/column are not stored in cache for vast majority of symbol nodes.
+            # Adding them will make thing faster, but will have visible memory impact.
+            nodes = self.collect_nodes(expression)
+            modules, reload_needed = self.modules_for_nodes(nodes, expression)
+            assert not reload_needed
+
+        result = []
+        for node in modules:
+            result.append(self.format_node(modules[node], node))
+
+        if not result:
+            return self.missing_node(expression), False
+
+        return self.add_prefixes(", ".join(result), expression), True
+
+    def missing_type(self, expression: Expression) -> str:
+        alt_suggestion = ""
+        if not self.force_reload:
+            alt_suggestion = " or try --force-reload"
+        return (
+            f'No known type available for "{type(expression).__name__}"'
+            f" (maybe unreachable{alt_suggestion})"
+        )
+
+    def missing_node(self, expression: Expression) -> str:
+        return (
+            f'Cannot find definition for "{type(expression).__name__}" at {expr_span(expression)}'
+        )
+
+    def add_prefixes(self, result: str, expression: Expression) -> str:
+        prefixes = []
+        if self.include_kind:
+            prefixes.append(f"{type(expression).__name__}")
+        if self.include_span:
+            prefixes.append(expr_span(expression))
+        if prefixes:
+            prefix = ":".join(prefixes) + " -> "
+        else:
+            prefix = ""
+        return prefix + result
+
+    def run_inspection_by_exact_location(
+        self,
+        tree: MypyFile,
+        line: int,
+        column: int,
+        end_line: int,
+        end_column: int,
+        method: Callable[[Expression], tuple[str, bool]],
+    ) -> dict[str, object]:
+        """Get type of an expression matching a span.
+
+        Type or error is returned as a standard daemon response dict.
+        """
+        try:
+            expression = find_by_location(tree, line, column - 1, end_line, end_column)
+        except ValueError as err:
+            return {"error": str(err)}
+
+        if expression is None:
+            span = f"{line}:{column}:{end_line}:{end_column}"
+            return {"out": f"Can't find expression at span {span}", "err": "", "status": 1}
+
+        inspection_str, success = method(expression)
+        return {"out": inspection_str, "err": "", "status": 0 if success else 1}
+
+    def run_inspection_by_position(
+        self,
+        tree: MypyFile,
+        line: int,
+        column: int,
+        method: Callable[[Expression], tuple[str, bool]],
+    ) -> dict[str, object]:
+        """Get types of all expressions enclosing a position.
+
+        Types and/or errors are returned as a standard daemon response dict.
+        """
+        expressions = find_all_by_location(tree, line, column - 1)
+        if not expressions:
+            position = f"{line}:{column}"
+            return {
+                "out": f"Can't find any expressions at position {position}",
+                "err": "",
+                "status": 1,
+            }
+
+        inspection_strs = []
+        status = 0
+        for expression in expressions:
+            inspection_str, success = method(expression)
+            if not success:
+                status = 1
+            if inspection_str:
+                inspection_strs.append(inspection_str)
+        if self.limit:
+            inspection_strs = inspection_strs[: self.limit]
+        return {"out": "\n".join(inspection_strs), "err": "", "status": status}
+
+    def find_module(self, file: str) -> tuple[State | None, dict[str, object]]:
+        """Find module by path, or return a suitable error message.
+
+        Note we don't use exceptions to simplify handling 1 vs 2 statuses.
+        """
+        if not any(file.endswith(ext) for ext in PYTHON_EXTENSIONS):
+            return None, {"error": "Source file is not a Python file"}
+
+        # We are using a bit slower but robust way to find a module by path,
+        # to be sure that namespace packages are handled properly.
+        abs_path = os.path.abspath(file)
+        state = next((s for s in self.fg_manager.graph.values() if s.abspath == abs_path), None)
+        self.module = state
+        return (
+            state,
+            {"out": f"Unknown module: {file}", "err": "", "status": 1} if state is None else {},
+        )
+
+    def run_inspection(
+        self, location: str, method: Callable[[Expression], tuple[str, bool]]
+    ) -> dict[str, object]:
+        """Top-level logic to inspect expression(s) at a location.
+
+        This can be reused by various simple inspections.
+        """
+        try:
+            file, pos = parse_location(location)
+        except ValueError as err:
+            return {"error": str(err)}
+
+        state, err_dict = self.find_module(file)
+        if state is None:
+            assert err_dict
+            return err_dict
+
+        # Force reloading to load from cache, account for any edits, etc.
+        if not state.tree or state.tree.is_cache_skeleton or self.force_reload:
+            self.reload_module(state)
+        assert state.tree is not None
+
+        if len(pos) == 4:
+            # Full span, return an exact match only.
+            line, column, end_line, end_column = pos
+            return self.run_inspection_by_exact_location(
+                state.tree, line, column, end_line, end_column, method
+            )
+        assert len(pos) == 2
+        # Inexact location, return all expressions.
+        line, column = pos
+        return self.run_inspection_by_position(state.tree, line, column, method)
+
+    def get_type(self, location: str) -> dict[str, object]:
+        """Get types of expression(s) at a location."""
+        return self.run_inspection(location, self.expr_type)
+
+    def get_attrs(self, location: str) -> dict[str, object]:
+        """Get attributes of expression(s) at a location."""
+        return self.run_inspection(location, self.expr_attrs)
+
+    def get_definition(self, location: str) -> dict[str, object]:
+        """Get symbol definitions of expression(s) at a location."""
+        result = self.run_inspection(location, self.expression_def)
+        if "out" in result and not result["out"]:
+            # None of the expressions found turns out to be a RefExpr.
+            _, location = location.split(":", maxsplit=1)
+            result["out"] = f"No name or member expressions at {location}"
+            result["status"] = 1
+        return result
+
+
+def parse_location(location: str) -> tuple[str, list[int]]:
+    if location.count(":") < 2:
+        raise ValueError("Format should be file:line:column[:end_line:end_column]")
+    parts = location.rsplit(":", maxsplit=2)
+    start, *rest = parts
+    # Note: we must allow drive prefix like `C:` on Windows.
+    if start.count(":") < 2:
+        return start, [int(p) for p in rest]
+    parts = start.rsplit(":", maxsplit=2)
+    start, *start_rest = parts
+    if start.count(":") < 2:
+        return start, [int(p) for p in start_rest + rest]
+    raise ValueError("Format should be file:line:column[:end_line:end_column]")

micromamba_root/Lib/site-packages/mypy/ipc.py

@@ -0,0 +1,457 @@
+"""Cross-platform abstractions for inter-process communication
+
+On Unix, this uses AF_UNIX sockets.
+On Windows, this uses NamedPipes.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import struct
+import sys
+import tempfile
+from abc import abstractmethod
+from collections.abc import Callable
+from select import select
+from types import TracebackType
+from typing import Final
+from typing_extensions import Self
+
+from librt.base64 import urlsafe_b64encode
+from librt.internal import ReadBuffer, WriteBuffer
+
+if sys.platform == "win32":
+    # This may be private, but it is needed for IPC on Windows, and is basically stable
+    import _winapi
+    import ctypes
+
+    _IPCHandle = int
+
+    kernel32 = ctypes.windll.kernel32
+    DisconnectNamedPipe: Callable[[_IPCHandle], int] = kernel32.DisconnectNamedPipe
+    FlushFileBuffers: Callable[[_IPCHandle], int] = kernel32.FlushFileBuffers
+else:
+    import socket
+
+    _IPCHandle = socket.socket
+
+# Size of the message packed as !L, i.e. 4 bytes in network order (big-endian).
+HEADER_SIZE = 4
+
+
+# TODO: we should make sure consistent exceptions are raised on different platforms.
+# Currently we raise either IPCException or OSError for equivalent conditions.
+class IPCException(Exception):
+    """Exception for IPC issues."""
+
+
+class IPCBase:
+    """Base class for communication between the dmypy client and server.
+
+    This contains logic shared between the client and server, such as reading
+    and writing.
+    We want to be able to send multiple "messages" over a single connection and
+    to be able to separate the messages. We do this by prefixing each message
+    with its size in a fixed format.
+    """
+
+    connection: _IPCHandle
+
+    def __init__(self, name: str, timeout: float | None) -> None:
+        self.name = name
+        self.timeout = timeout
+        self.message_size: int | None = None
+        self.buffer = bytearray()
+
+    def frame_from_buffer(self) -> bytes | None:
+        """Return a full frame from the bytes we have in the buffer."""
+        size = len(self.buffer)
+        if size < HEADER_SIZE:
+            return None
+        if self.message_size is None:
+            self.message_size = struct.unpack("!L", self.buffer[:HEADER_SIZE])[0]
+        if size < self.message_size + HEADER_SIZE:
+            return None
+        # We have a full frame, avoid extra copy in case we get a large frame.
+        bdata = memoryview(self.buffer)[HEADER_SIZE : HEADER_SIZE + self.message_size]
+        self.buffer = self.buffer[HEADER_SIZE + self.message_size :]
+        self.message_size = None
+        return bytes(bdata)
+
+    def read(self, size: int = 100000) -> str:
+        return self.read_bytes(size).decode("utf-8")
+
+    def read_bytes(self, size: int = 100000) -> bytes:
+        """Read bytes from an IPC connection until we have a full frame."""
+        if sys.platform == "win32":
+            while True:
+                # Check if we already have a message in the buffer before
+                # receiving any more data from the socket.
+                bdata = self.frame_from_buffer()
+                if bdata is not None:
+                    break
+
+                # Receive more data into the buffer.
+                ov, err = _winapi.ReadFile(self.connection, size, overlapped=True)
+                try:
+                    if err == _winapi.ERROR_IO_PENDING:
+                        timeout = int(self.timeout * 1000) if self.timeout else _winapi.INFINITE
+                        res = _winapi.WaitForSingleObject(ov.event, timeout)
+                        if res != _winapi.WAIT_OBJECT_0:
+                            raise IPCException(f"Bad result from I/O wait: {res}")
+                except BaseException:
+                    ov.cancel()
+                    raise
+                _, err = ov.GetOverlappedResult(True)
+                more = ov.getbuffer()
+                if more:
+                    self.buffer.extend(more)
+                    bdata = self.frame_from_buffer()
+                    if bdata is not None:
+                        break
+                if err == 0:
+                    # we are done!
+                    break
+                elif err == _winapi.ERROR_MORE_DATA:
+                    # read again
+                    continue
+                elif err == _winapi.ERROR_OPERATION_ABORTED:
+                    raise IPCException("ReadFile operation aborted.")
+        else:
+            while True:
+                # Check if we already have a message in the buffer before
+                # receiving any more data from the socket.
+                bdata = self.frame_from_buffer()
+                if bdata is not None:
+                    break
+
+                # Receive more data into the buffer.
+                more = self.connection.recv(size)
+                if not more:
+                    # Connection closed
+                    break
+                self.buffer.extend(more)
+
+        if not bdata:
+            # Socket was empty, and we didn't get any frame.
+            # This should only happen if the socket was closed.
+            return b""
+        return bdata
+
+    def write(self, data: str) -> None:
+        self.write_bytes(data.encode("utf-8"))
+
+    def write_bytes(self, data: bytes) -> None:
+        """Write to an IPC connection."""
+
+        # Frame the data by adding fixed size header.
+        encoded_data = struct.pack("!L", len(data)) + data
+
+        if sys.platform == "win32":
+            try:
+                ov, err = _winapi.WriteFile(self.connection, encoded_data, overlapped=True)
+                try:
+                    if err == _winapi.ERROR_IO_PENDING:
+                        timeout = int(self.timeout * 1000) if self.timeout else _winapi.INFINITE
+                        res = _winapi.WaitForSingleObject(ov.event, timeout)
+                        if res != _winapi.WAIT_OBJECT_0:
+                            raise IPCException(f"Bad result from I/O wait: {res}")
+                    elif err != 0:
+                        raise IPCException(f"Failed writing to pipe with error: {err}")
+                except BaseException:
+                    ov.cancel()
+                    raise
+                bytes_written, err = ov.GetOverlappedResult(True)
+                assert err == 0, err
+                assert bytes_written == len(encoded_data)
+            except OSError as e:
+                raise IPCException(f"Failed to write with error: {e.winerror}") from e
+        else:
+            self.connection.sendall(encoded_data)
+
+    def close(self) -> None:
+        if sys.platform == "win32":
+            if self.connection != _winapi.NULL:
+                _winapi.CloseHandle(self.connection)
+        else:
+            self.connection.close()
+
+
+class IPCClient(IPCBase):
+    """The client side of an IPC connection."""
+
+    def __init__(self, name: str, timeout: float | None) -> None:
+        super().__init__(name, timeout)
+        if sys.platform == "win32":
+            timeout = int(self.timeout * 1000) if self.timeout else _winapi.NMPWAIT_WAIT_FOREVER
+            try:
+                _winapi.WaitNamedPipe(self.name, timeout)
+            except FileNotFoundError as e:
+                raise IPCException(f"The NamedPipe at {self.name} was not found.") from e
+            except OSError as e:
+                if e.winerror == _winapi.ERROR_SEM_TIMEOUT:
+                    raise IPCException("Timed out waiting for connection.") from e
+                else:
+                    raise
+            try:
+                self.connection = _winapi.CreateFile(
+                    self.name,
+                    _winapi.GENERIC_READ | _winapi.GENERIC_WRITE,
+                    0,
+                    _winapi.NULL,
+                    _winapi.OPEN_EXISTING,
+                    _winapi.FILE_FLAG_OVERLAPPED,
+                    _winapi.NULL,
+                )
+            except OSError as e:
+                if e.winerror == _winapi.ERROR_PIPE_BUSY:
+                    raise IPCException("The connection is busy.") from e
+                else:
+                    raise
+            _winapi.SetNamedPipeHandleState(
+                self.connection, _winapi.PIPE_READMODE_MESSAGE, None, None
+            )
+        else:
+            self.connection = socket.socket(socket.AF_UNIX)
+            self.connection.settimeout(timeout)
+            self.connection.connect(name)
+
+    def __enter__(self) -> IPCClient:
+        return self
+
+    def __exit__(
+        self,
+        exc_ty: type[BaseException] | None = None,
+        exc_val: BaseException | None = None,
+        exc_tb: TracebackType | None = None,
+    ) -> None:
+        self.close()
+
+
+class IPCServer(IPCBase):
+    BUFFER_SIZE: Final = 2**16
+
+    def __init__(self, name: str, timeout: float | None = None) -> None:
+        if sys.platform == "win32":
+            name = r"\\.\pipe\{}-{}.pipe".format(name, urlsafe_b64encode(os.urandom(6)).decode())
+        else:
+            name = f"{name}.sock"
+        super().__init__(name, timeout)
+        if sys.platform == "win32":
+            self.connection = _winapi.CreateNamedPipe(
+                self.name,
+                _winapi.PIPE_ACCESS_DUPLEX
+                | _winapi.FILE_FLAG_FIRST_PIPE_INSTANCE
+                | _winapi.FILE_FLAG_OVERLAPPED,
+                _winapi.PIPE_READMODE_MESSAGE
+                | _winapi.PIPE_TYPE_MESSAGE
+                | _winapi.PIPE_WAIT
+                | 0x8,  # PIPE_REJECT_REMOTE_CLIENTS
+                1,  # one instance
+                self.BUFFER_SIZE,
+                self.BUFFER_SIZE,
+                _winapi.NMPWAIT_WAIT_FOREVER,
+                0,  # Use default security descriptor
+            )
+            if self.connection == -1:  # INVALID_HANDLE_VALUE
+                err = _winapi.GetLastError()
+                raise IPCException(f"Invalid handle to pipe: {err}")
+        else:
+            self.sock_directory = tempfile.mkdtemp()
+            sockfile = os.path.join(self.sock_directory, self.name)
+            self.sock = socket.socket(socket.AF_UNIX)
+            self.sock.bind(sockfile)
+            self.sock.listen(1)
+            if timeout is not None:
+                self.sock.settimeout(timeout)
+
+    def __enter__(self) -> IPCServer:
+        if sys.platform == "win32":
+            # NOTE: It is theoretically possible that this will hang forever if the
+            # client never connects, though this can be "solved" by killing the server
+            try:
+                ov = _winapi.ConnectNamedPipe(self.connection, overlapped=True)
+            except OSError as e:
+                # Don't raise if the client already exists, or the client already connected
+                if e.winerror not in (_winapi.ERROR_PIPE_CONNECTED, _winapi.ERROR_NO_DATA):
+                    raise
+            else:
+                try:
+                    timeout = int(self.timeout * 1000) if self.timeout else _winapi.INFINITE
+                    res = _winapi.WaitForSingleObject(ov.event, timeout)
+                    assert res == _winapi.WAIT_OBJECT_0
+                except BaseException:
+                    ov.cancel()
+                    _winapi.CloseHandle(self.connection)
+                    raise
+                _, err = ov.GetOverlappedResult(True)
+                assert err == 0
+        else:
+            try:
+                self.connection, _ = self.sock.accept()
+            except TimeoutError as e:
+                raise IPCException("The socket timed out") from e
+        return self
+
+    def __exit__(
+        self,
+        exc_ty: type[BaseException] | None = None,
+        exc_val: BaseException | None = None,
+        exc_tb: TracebackType | None = None,
+    ) -> None:
+        if sys.platform == "win32":
+            try:
+                # Wait for the client to finish reading the last write before disconnecting
+                if not FlushFileBuffers(self.connection):
+                    raise IPCException(
+                        "Failed to flush NamedPipe buffer, maybe the client hung up?"
+                    )
+            finally:
+                DisconnectNamedPipe(self.connection)
+        else:
+            self.close()
+
+    def cleanup(self) -> None:
+        if sys.platform == "win32":
+            self.close()
+        else:
+            shutil.rmtree(self.sock_directory)
+
+    @property
+    def connection_name(self) -> str:
+        if sys.platform == "win32":
+            return self.name
+        elif sys.platform == "gnu0":
+            # GNU/Hurd returns empty string from getsockname()
+            # for AF_UNIX sockets
+            return os.path.join(self.sock_directory, self.name)
+        else:
+            name = self.sock.getsockname()
+            assert isinstance(name, str)
+            return name
+
+
+class BadStatus(Exception):
+    """Exception raised when there is something wrong with the status file.
+
+    For example:
+    - No status file found
+    - Status file malformed
+    - Process whose pid is in the status file does not exist
+    """
+
+
+def read_status(status_file: str) -> dict[str, object]:
+    """Read status file.
+
+    Raise BadStatus if the status file doesn't exist or contains
+    invalid JSON or the JSON is not a dict.
+    """
+    if not os.path.isfile(status_file):
+        raise BadStatus("No status file found")
+    with open(status_file) as f:
+        try:
+            data = json.load(f)
+        except Exception as e:
+            raise BadStatus(f"Malformed status file: {str(e)}") from e
+    if not isinstance(data, dict):
+        raise BadStatus(f"Invalid status file (not a dict): {data}")
+    return data
+
+
+def ready_to_read(conns: list[IPCClient], timeout: float | None = None) -> list[int]:
+    """Wait until some connections are readable.
+
+    Return index of each readable connection in the original list.
+    """
+    if sys.platform == "win32":
+        # Windows doesn't support select() on named pipes. Instead, start an overlapped
+        # ReadFile on each pipe (which internally creates an event via CreateEventW),
+        # then WaitForMultipleObjects on those events for efficient OS-level waiting.
+        # Any data consumed by the probe reads is stored into each connection's buffer
+        # so the subsequent read_bytes() call will find it via frame_from_buffer().
+        WAIT_FAILED = 0xFFFFFFFF
+        pending: list[tuple[int, _winapi.Overlapped]] = []
+        events: list[int] = []
+        ready: list[int] = []
+
+        for i, conn in enumerate(conns):
+            try:
+                ov, err = _winapi.ReadFile(conn.connection, 1, overlapped=True)
+            except OSError:
+                # Broken/closed pipe. Mimic Linux behavior here, caller will get
+                # the exception when trying to read from this socket.
+                ready.append(i)
+                continue
+            if err == _winapi.ERROR_IO_PENDING:
+                events.append(ov.event)
+                pending.append((i, ov))
+            else:
+                # Data was immediately available (err == 0 or ERROR_MORE_DATA)
+                _, err = ov.GetOverlappedResult(True)
+                data = ov.getbuffer()
+                if data:
+                    conn.buffer.extend(data)
+                ready.append(i)
+
+        # Wait only if nothing is immediately ready and there are pending operations
+        if not ready and events:
+            timeout_ms = int(timeout * 1000) if timeout is not None else _winapi.INFINITE
+            res = _winapi.WaitForMultipleObjects(events, False, timeout_ms)
+            if res == WAIT_FAILED:
+                for _, ov in pending:
+                    ov.cancel()
+                raise IPCException(f"Failed to wait for connections: {_winapi.GetLastError()}")
+
+        # Check which pending operations completed, cancel the rest
+        for i, ov in pending:
+            if _winapi.WaitForSingleObject(ov.event, 0) == _winapi.WAIT_OBJECT_0:
+                _, err = ov.GetOverlappedResult(True)
+                data = ov.getbuffer()
+                if data:
+                    conns[i].buffer.extend(data)
+                ready.append(i)
+            else:
+                ov.cancel()
+
+        return ready
+
+    else:
+        connections = [conn.connection for conn in conns]
+        ready, _, _ = select(connections, [], [], timeout)
+        return [connections.index(r) for r in ready]
+
+
+def send(connection: IPCBase, data: IPCMessage) -> None:
+    """Send data to a connection encoded and framed.
+
+    The data must be a non-abstract IPCMessage. We assume that a single send call is a
+    single frame to be sent.
+    """
+    buf = WriteBuffer()
+    data.write(buf)
+    connection.write_bytes(buf.getvalue())
+
+
+def receive(connection: IPCBase) -> ReadBuffer:
+    """Receive single encoded IPCMessage frame from a connection.
+
+    Raise OSError if the data received is not valid.
+    """
+    bdata = connection.read_bytes()
+    if not bdata:
+        raise OSError("No data received")
+    return ReadBuffer(bdata)
+
+
+class IPCMessage:
+    @classmethod
+    @abstractmethod
+    def read(cls, buf: ReadBuffer) -> Self:
+        raise NotImplementedError
+
+    @abstractmethod
+    def write(self, buf: WriteBuffer) -> None:
+        raise NotImplementedError

micromamba_root/Lib/site-packages/mypy/join.py

@@ -0,0 +1,916 @@
+"""Calculation of the least upper bound types (joins)."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import overload
+
+import mypy.typeops
+from mypy.expandtype import expand_type
+from mypy.maptype import map_instance_to_supertype
+from mypy.nodes import CONTRAVARIANT, COVARIANT, INVARIANT, VARIANCE_NOT_READY, TypeInfo
+from mypy.state import state
+from mypy.subtypes import (
+    SubtypeContext,
+    find_member,
+    is_equivalent,
+    is_proper_subtype,
+    is_protocol_implementation,
+    is_subtype,
+)
+from mypy.types import (
+    AnyType,
+    CallableType,
+    DeletedType,
+    ErasedType,
+    FunctionLike,
+    Instance,
+    LiteralType,
+    NoneType,
+    Overloaded,
+    Parameters,
+    ParamSpecType,
+    PartialType,
+    ProperType,
+    TupleType,
+    Type,
+    TypeAliasType,
+    TypedDictType,
+    TypeOfAny,
+    TypeType,
+    TypeVarId,
+    TypeVarLikeType,
+    TypeVarTupleType,
+    TypeVarType,
+    TypeVisitor,
+    UnboundType,
+    UninhabitedType,
+    UnionType,
+    UnpackType,
+    find_unpack_in_list,
+    get_proper_type,
+    get_proper_types,
+    split_with_prefix_and_suffix,
+)
+
+
+class InstanceJoiner:
+    def __init__(self) -> None:
+        self.seen_instances: list[tuple[Instance, Instance]] = []
+
+    def join_instances(self, t: Instance, s: Instance) -> ProperType:
+        if (t, s) in self.seen_instances or (s, t) in self.seen_instances:
+            return object_from_instance(t)
+
+        self.seen_instances.append((t, s))
+
+        # Calculate the join of two instance types
+        if t.type == s.type:
+            # Simplest case: join two types with the same base type (but
+            # potentially different arguments).
+
+            # Combine type arguments.
+            args: list[Type] = []
+            # N.B: We use zip instead of indexing because the lengths might have
+            # mismatches during daemon reprocessing.
+            if t.type.has_type_var_tuple_type:
+                # We handle joins of variadic instances by simply creating correct mapping
+                # for type arguments and compute the individual joins same as for regular
+                # instances. All the heavy lifting is done in the join of tuple types.
+                assert s.type.type_var_tuple_prefix is not None
+                assert s.type.type_var_tuple_suffix is not None
+                prefix = s.type.type_var_tuple_prefix
+                suffix = s.type.type_var_tuple_suffix
+                tvt = s.type.defn.type_vars[prefix]
+                assert isinstance(tvt, TypeVarTupleType)
+                fallback = tvt.tuple_fallback
+                s_prefix, s_middle, s_suffix = split_with_prefix_and_suffix(s.args, prefix, suffix)
+                t_prefix, t_middle, t_suffix = split_with_prefix_and_suffix(t.args, prefix, suffix)
+                s_args = s_prefix + (TupleType(list(s_middle), fallback),) + s_suffix
+                t_args = t_prefix + (TupleType(list(t_middle), fallback),) + t_suffix
+            else:
+                t_args = t.args
+                s_args = s.args
+            for ta, sa, type_var in zip(t_args, s_args, t.type.defn.type_vars):
+                ta_proper = get_proper_type(ta)
+                sa_proper = get_proper_type(sa)
+                new_type: Type | None = None
+                if isinstance(ta_proper, AnyType):
+                    new_type = AnyType(TypeOfAny.from_another_any, ta_proper)
+                elif isinstance(sa_proper, AnyType):
+                    new_type = AnyType(TypeOfAny.from_another_any, sa_proper)
+                elif isinstance(type_var, TypeVarType):
+                    if type_var.variance in (COVARIANT, VARIANCE_NOT_READY):
+                        new_type = join_types(ta, sa, self)
+                        if len(type_var.values) != 0 and new_type not in type_var.values:
+                            self.seen_instances.pop()
+                            return object_from_instance(t)
+                        if not is_subtype(new_type, type_var.upper_bound):
+                            self.seen_instances.pop()
+                            return object_from_instance(t)
+                    # TODO: contravariant case should use meet but pass seen instances as
+                    # an argument to keep track of recursive checks.
+                    elif type_var.variance in (INVARIANT, CONTRAVARIANT):
+                        if isinstance(ta_proper, UninhabitedType) and ta_proper.ambiguous:
+                            new_type = sa
+                        elif isinstance(sa_proper, UninhabitedType) and sa_proper.ambiguous:
+                            new_type = ta
+                        elif not is_equivalent(ta, sa):
+                            self.seen_instances.pop()
+                            return object_from_instance(t)
+                        else:
+                            # If the types are different but equivalent, then an Any is involved
+                            # so using a join in the contravariant case is also OK.
+                            new_type = join_types(ta, sa, self)
+                elif isinstance(type_var, TypeVarTupleType):
+                    new_type = get_proper_type(join_types(ta, sa, self))
+                    # Put the joined arguments back into instance in the normal form:
+                    #   a) Tuple[X, Y, Z] -> [X, Y, Z]
+                    #   b) tuple[X, ...] -> [*tuple[X, ...]]
+                    if isinstance(new_type, Instance):
+                        assert new_type.type.fullname == "builtins.tuple"
+                        new_type = UnpackType(new_type)
+                    else:
+                        assert isinstance(new_type, TupleType)
+                        args.extend(new_type.items)
+                        continue
+                else:
+                    # ParamSpec type variables behave the same, independent of variance
+                    if not is_equivalent(ta, sa):
+                        return get_proper_type(type_var.upper_bound)
+                    new_type = join_types(ta, sa, self)
+                assert new_type is not None
+                args.append(new_type)
+            result: ProperType = Instance(t.type, args)
+        elif t.type.bases and is_proper_subtype(
+            t, s, subtype_context=SubtypeContext(ignore_type_params=True)
+        ):
+            result = self.join_instances_via_supertype(t, s)
+        else:
+            # Now t is not a subtype of s, and t != s. Now s could be a subtype
+            # of t; alternatively, we need to find a common supertype. This works
+            # in of the both cases.
+            result = self.join_instances_via_supertype(s, t)
+
+        self.seen_instances.pop()
+        return result
+
+    def join_instances_via_supertype(self, t: Instance, s: Instance) -> ProperType:
+        # Give preference to joins via duck typing relationship, so that
+        # join(int, float) == float, for example.
+        for p in t.type._promote:
+            if is_subtype(p, s):
+                return join_types(p, s, self)
+        for p in s.type._promote:
+            if is_subtype(p, t):
+                return join_types(t, p, self)
+
+        # Compute the "best" supertype of t when joined with s.
+        # The definition of "best" may evolve; for now it is the one with
+        # the longest MRO.  Ties are broken by using the earlier base.
+
+        # Go over both sets of bases in case there's an explicit Protocol base. This is important
+        # to ensure commutativity of join (although in cases where both classes have relevant
+        # Protocol bases this maybe might still not be commutative)
+        base_types: dict[TypeInfo, None] = {}  # dict to deduplicate but preserve order
+        for base in t.type.bases:
+            base_types[base.type] = None
+        for base in s.type.bases:
+            if base.type.is_protocol and is_subtype(t, base):
+                base_types[base.type] = None
+
+        best: ProperType | None = None
+        for base_type in base_types:
+            mapped = map_instance_to_supertype(t, base_type)
+            res = self.join_instances(mapped, s)
+            if best is None or is_better(res, best):
+                best = res
+        assert best is not None
+        for promote in t.type._promote:
+            if isinstance(promote, Instance):
+                res = self.join_instances(promote, s)
+                if is_better(res, best):
+                    best = res
+        return best
+
+
+def trivial_join(s: Type, t: Type) -> Type:
+    """Return one of types (expanded) if it is a supertype of other, otherwise top type."""
+    if is_subtype(s, t):
+        return t
+    elif is_subtype(t, s):
+        return s
+    else:
+        return object_or_any_from_type(get_proper_type(t))
+
+
+@overload
+def join_types(
+    s: ProperType, t: ProperType, instance_joiner: InstanceJoiner | None = None
+) -> ProperType: ...
+
+
+@overload
+def join_types(s: Type, t: Type, instance_joiner: InstanceJoiner | None = None) -> Type: ...
+
+
+def join_types(s: Type, t: Type, instance_joiner: InstanceJoiner | None = None) -> Type:
+    """Return the least upper bound of s and t.
+
+    For example, the join of 'int' and 'object' is 'object'.
+    """
+    if mypy.typeops.is_recursive_pair(s, t):
+        # This case can trigger an infinite recursion, general support for this will be
+        # tricky so we use a trivial join (like for protocols).
+        return trivial_join(s, t)
+    s = get_proper_type(s)
+    t = get_proper_type(t)
+
+    if (s.can_be_true, s.can_be_false) != (t.can_be_true, t.can_be_false):
+        # if types are restricted in different ways, use the more general versions
+        s = mypy.typeops.true_or_false(s)
+        t = mypy.typeops.true_or_false(t)
+
+    if isinstance(s, UnionType) and not isinstance(t, UnionType):
+        s, t = t, s
+
+    if isinstance(s, AnyType):
+        return s
+
+    if isinstance(s, ErasedType):
+        return t
+
+    if isinstance(s, NoneType) and not isinstance(t, NoneType):
+        s, t = t, s
+
+    if isinstance(s, UninhabitedType) and not isinstance(t, UninhabitedType):
+        s, t = t, s
+
+    # Meets/joins require callable type normalization.
+    s, t = normalize_callables(s, t)
+
+    # Use a visitor to handle non-trivial cases.
+    return t.accept(TypeJoinVisitor(s, instance_joiner))
+
+
+class TypeJoinVisitor(TypeVisitor[ProperType]):
+    """Implementation of the least upper bound algorithm.
+
+    Attributes:
+      s: The other (left) type operand.
+    """
+
+    def __init__(self, s: ProperType, instance_joiner: InstanceJoiner | None = None) -> None:
+        self.s = s
+        self.instance_joiner = instance_joiner
+
+    def visit_unbound_type(self, t: UnboundType) -> ProperType:
+        return AnyType(TypeOfAny.special_form)
+
+    def visit_union_type(self, t: UnionType) -> ProperType:
+        if is_proper_subtype(self.s, t):
+            return t
+        else:
+            return mypy.typeops.make_simplified_union([self.s, t])
+
+    def visit_any(self, t: AnyType) -> ProperType:
+        return t
+
+    def visit_none_type(self, t: NoneType) -> ProperType:
+        if state.strict_optional:
+            if isinstance(self.s, (NoneType, UninhabitedType)):
+                return t
+            elif isinstance(self.s, (UnboundType, AnyType)):
+                return AnyType(TypeOfAny.special_form)
+            else:
+                return mypy.typeops.make_simplified_union([self.s, t])
+        else:
+            return self.s
+
+    def visit_uninhabited_type(self, t: UninhabitedType) -> ProperType:
+        return self.s
+
+    def visit_deleted_type(self, t: DeletedType) -> ProperType:
+        return self.s
+
+    def visit_erased_type(self, t: ErasedType) -> ProperType:
+        return self.s
+
+    def visit_type_var(self, t: TypeVarType) -> ProperType:
+        if isinstance(self.s, TypeVarType):
+            if self.s.id == t.id:
+                if self.s.upper_bound == t.upper_bound:
+                    return self.s
+                return self.s.copy_modified(
+                    upper_bound=join_types(self.s.upper_bound, t.upper_bound)
+                )
+            # Fix non-commutative joins
+            return get_proper_type(join_types(self.s.upper_bound, t.upper_bound))
+        else:
+            return self.default(self.s)
+
+    def visit_param_spec(self, t: ParamSpecType) -> ProperType:
+        if self.s == t:
+            return t
+        return self.default(self.s)
+
+    def visit_type_var_tuple(self, t: TypeVarTupleType) -> ProperType:
+        if self.s == t:
+            return t
+        if isinstance(self.s, Instance) and is_subtype(t.upper_bound, self.s):
+            # TODO: should we do this more generally and for all TypeVarLikeTypes?
+            return self.s
+        return self.default(self.s)
+
+    def visit_unpack_type(self, t: UnpackType) -> UnpackType:
+        raise NotImplementedError
+
+    def visit_parameters(self, t: Parameters) -> ProperType:
+        if isinstance(self.s, Parameters):
+            if not is_similar_params(t, self.s):
+                # TODO: it would be prudent to return [*object, **object] instead of Any.
+                return self.default(self.s)
+            from mypy.meet import meet_types
+
+            return t.copy_modified(
+                arg_types=[
+                    meet_types(s_a, t_a) for s_a, t_a in zip(self.s.arg_types, t.arg_types)
+                ],
+                arg_names=combine_arg_names(self.s, t),
+            )
+        else:
+            return self.default(self.s)
+
+    def visit_instance(self, t: Instance) -> ProperType:
+        if isinstance(self.s, Instance):
+            if self.instance_joiner is None:
+                self.instance_joiner = InstanceJoiner()
+            nominal = self.instance_joiner.join_instances(t, self.s)
+            structural: Instance | None = None
+            if t.type.is_protocol and is_protocol_implementation(self.s, t):
+                structural = t
+            elif self.s.type.is_protocol and is_protocol_implementation(t, self.s):
+                structural = self.s
+            # Structural join is preferred in the case where we have found both
+            # structural and nominal and they have same MRO length (see two comments
+            # in join_instances_via_supertype). Otherwise, just return the nominal join.
+            if not structural or is_better(nominal, structural):
+                return nominal
+            return structural
+        elif isinstance(self.s, FunctionLike):
+            if t.type.is_protocol:
+                call = unpack_callback_protocol(t)
+                if call:
+                    return join_types(call, self.s)
+            return join_types(t, self.s.fallback)
+        elif isinstance(self.s, TypeType):
+            return join_types(t, self.s)
+        elif isinstance(self.s, TypedDictType):
+            return join_types(t, self.s)
+        elif isinstance(self.s, TupleType):
+            return join_types(t, self.s)
+        elif isinstance(self.s, LiteralType):
+            return join_types(t, self.s)
+        elif isinstance(self.s, TypeVarTupleType) and is_subtype(self.s.upper_bound, t):
+            return t
+        else:
+            return self.default(self.s)
+
+    def visit_callable_type(self, t: CallableType) -> ProperType:
+        if isinstance(self.s, CallableType):
+            if is_similar_callables(t, self.s):
+                if is_equivalent(t, self.s):
+                    return combine_similar_callables(t, self.s)
+                result = join_similar_callables(t, self.s)
+                if any(
+                    isinstance(tp, (NoneType, UninhabitedType))
+                    for tp in get_proper_types(result.arg_types)
+                ):
+                    # We don't want to return unusable Callable, attempt fallback instead.
+                    return join_types(t.fallback, self.s)
+                # We set the from_type_type flag to suppress error when a collection of
+                # concrete class objects gets inferred as their common abstract superclass.
+                if not (
+                    (t.is_type_obj() and t.type_object().is_abstract)
+                    or (self.s.is_type_obj() and self.s.type_object().is_abstract)
+                ):
+                    result.from_type_type = True
+                return result
+            else:
+                s2, t2 = self.s, t
+                if t2.is_var_arg:
+                    s2, t2 = t2, s2
+                if is_subtype(s2, t2):
+                    return t2.copy_modified()
+                elif is_subtype(t2, s2):
+                    return s2.copy_modified()
+                return join_types(t.fallback, self.s)
+        elif isinstance(self.s, Overloaded):
+            # Switch the order of arguments to that we'll get to visit_overloaded.
+            return join_types(t, self.s)
+        elif isinstance(self.s, Instance) and self.s.type.is_protocol:
+            call = unpack_callback_protocol(self.s)
+            if call:
+                return join_types(t, call)
+        return join_types(t.fallback, self.s)
+
+    def visit_overloaded(self, t: Overloaded) -> ProperType:
+        # This is more complex than most other cases. Here are some
+        # examples that illustrate how this works.
+        #
+        # First let's define a concise notation:
+        #  - Cn are callable types (for n in 1, 2, ...)
+        #  - Ov(C1, C2, ...) is an overloaded type with items C1, C2, ...
+        #  - Callable[[T, ...], S] is written as [T, ...] -> S.
+        #
+        # We want some basic properties to hold (assume Cn are all
+        # unrelated via Any-similarity):
+        #
+        #   join(Ov(C1, C2), C1) == C1
+        #   join(Ov(C1, C2), Ov(C1, C2)) == Ov(C1, C2)
+        #   join(Ov(C1, C2), Ov(C1, C3)) == C1
+        #   join(Ov(C2, C2), C3) == join of fallback types
+        #
+        # The presence of Any types makes things more interesting. The join is the
+        # most general type we can get with respect to Any:
+        #
+        #   join(Ov([int] -> int, [str] -> str), [Any] -> str) == Any -> str
+        #
+        # We could use a simplification step that removes redundancies, but that's not
+        # implemented right now. Consider this example, where we get a redundancy:
+        #
+        #   join(Ov([int, Any] -> Any, [str, Any] -> Any), [Any, int] -> Any) ==
+        #       Ov([Any, int] -> Any, [Any, int] -> Any)
+        #
+        # TODO: Consider more cases of callable subtyping.
+        result: list[CallableType] = []
+        s = self.s
+        if isinstance(s, FunctionLike):
+            # The interesting case where both types are function types.
+            for t_item in t.items:
+                for s_item in s.items:
+                    if is_similar_callables(t_item, s_item):
+                        if is_equivalent(t_item, s_item):
+                            result.append(combine_similar_callables(t_item, s_item))
+                        elif is_subtype(t_item, s_item):
+                            result.append(s_item)
+            if result:
+                # TODO: Simplify redundancies from the result.
+                if len(result) == 1:
+                    return result[0]
+                else:
+                    return Overloaded(result)
+            return join_types(t.fallback, s.fallback)
+        elif isinstance(s, Instance) and s.type.is_protocol:
+            call = unpack_callback_protocol(s)
+            if call:
+                return join_types(t, call)
+        return join_types(t.fallback, s)
+
+    def join_tuples(self, s: TupleType, t: TupleType) -> list[Type] | None:
+        """Join two tuple types while handling variadic entries.
+
+        This is surprisingly tricky, and we don't handle some tricky corner cases.
+        Most of the trickiness comes from the variadic tuple items like *tuple[X, ...]
+        since they can have arbitrary partial overlaps (while *Ts can't be split).
+        """
+        s_unpack_index = find_unpack_in_list(s.items)
+        t_unpack_index = find_unpack_in_list(t.items)
+        if s_unpack_index is None and t_unpack_index is None:
+            if s.length() == t.length():
+                items: list[Type] = []
+                for i in range(t.length()):
+                    items.append(join_types(t.items[i], s.items[i]))
+                return items
+            return None
+        if s_unpack_index is not None and t_unpack_index is not None:
+            # The most complex case: both tuples have an unpack item.
+            s_unpack = s.items[s_unpack_index]
+            assert isinstance(s_unpack, UnpackType)
+            s_unpacked = get_proper_type(s_unpack.type)
+            t_unpack = t.items[t_unpack_index]
+            assert isinstance(t_unpack, UnpackType)
+            t_unpacked = get_proper_type(t_unpack.type)
+            if s.length() == t.length() and s_unpack_index == t_unpack_index:
+                # We can handle a case where arity is perfectly aligned, e.g.
+                # join(Tuple[X1, *tuple[Y1, ...], Z1], Tuple[X2, *tuple[Y2, ...], Z2]).
+                # We can essentially perform the join elementwise.
+                prefix_len = t_unpack_index
+                suffix_len = t.length() - t_unpack_index - 1
+                items = []
+                for si, ti in zip(s.items[:prefix_len], t.items[:prefix_len]):
+                    items.append(join_types(si, ti))
+                joined = join_types(s_unpacked, t_unpacked)
+                if isinstance(joined, TypeVarTupleType):
+                    items.append(UnpackType(joined))
+                elif isinstance(joined, Instance) and joined.type.fullname == "builtins.tuple":
+                    items.append(UnpackType(joined))
+                else:
+                    if isinstance(t_unpacked, Instance):
+                        assert t_unpacked.type.fullname == "builtins.tuple"
+                        tuple_instance = t_unpacked
+                    else:
+                        assert isinstance(t_unpacked, TypeVarTupleType)
+                        tuple_instance = t_unpacked.tuple_fallback
+                    items.append(
+                        UnpackType(
+                            tuple_instance.copy_modified(
+                                args=[object_from_instance(tuple_instance)]
+                            )
+                        )
+                    )
+                if suffix_len:
+                    for si, ti in zip(s.items[-suffix_len:], t.items[-suffix_len:]):
+                        items.append(join_types(si, ti))
+                return items
+            if s.length() == 1 or t.length() == 1:
+                # Another case we can handle is when one of tuple is purely variadic
+                # (i.e. a non-normalized form of tuple[X, ...]), in this case the join
+                # will be again purely variadic.
+                if not (isinstance(s_unpacked, Instance) and isinstance(t_unpacked, Instance)):
+                    return None
+                assert s_unpacked.type.fullname == "builtins.tuple"
+                assert t_unpacked.type.fullname == "builtins.tuple"
+                mid_joined = join_types(s_unpacked.args[0], t_unpacked.args[0])
+                t_other = [a for i, a in enumerate(t.items) if i != t_unpack_index]
+                s_other = [a for i, a in enumerate(s.items) if i != s_unpack_index]
+                other_joined = join_type_list(s_other + t_other)
+                mid_joined = join_types(mid_joined, other_joined)
+                return [UnpackType(s_unpacked.copy_modified(args=[mid_joined]))]
+            # TODO: are there other case we can handle (e.g. both prefix/suffix are shorter)?
+            return None
+        if s_unpack_index is not None:
+            variadic = s
+            unpack_index = s_unpack_index
+            fixed = t
+        else:
+            assert t_unpack_index is not None
+            variadic = t
+            unpack_index = t_unpack_index
+            fixed = s
+        # Case where one tuple has variadic item and the other one doesn't. The join will
+        # be variadic, since fixed tuple is a subtype of variadic, but not vice versa.
+        unpack = variadic.items[unpack_index]
+        assert isinstance(unpack, UnpackType)
+        unpacked = get_proper_type(unpack.type)
+        if not isinstance(unpacked, Instance):
+            return None
+        if fixed.length() < variadic.length() - 1:
+            # There are no non-trivial types that are supertype of both.
+            return None
+        prefix_len = unpack_index
+        suffix_len = variadic.length() - prefix_len - 1
+        prefix, middle, suffix = split_with_prefix_and_suffix(
+            tuple(fixed.items), prefix_len, suffix_len
+        )
+        items = []
+        for fi, vi in zip(prefix, variadic.items[:prefix_len]):
+            items.append(join_types(fi, vi))
+        mid_joined = join_type_list(list(middle))
+        mid_joined = join_types(mid_joined, unpacked.args[0])
+        items.append(UnpackType(unpacked.copy_modified(args=[mid_joined])))
+        if suffix_len:
+            for fi, vi in zip(suffix, variadic.items[-suffix_len:]):
+                items.append(join_types(fi, vi))
+        return items
+
+    def visit_tuple_type(self, t: TupleType) -> ProperType:
+        # When given two fixed-length tuples:
+        # * If they have the same length, join their subtypes item-wise:
+        #   Tuple[int, bool] + Tuple[bool, bool] becomes Tuple[int, bool]
+        # * If lengths do not match, return a variadic tuple:
+        #   Tuple[bool, int] + Tuple[bool] becomes Tuple[int, ...]
+        #
+        # Otherwise, `t` is a fixed-length tuple but `self.s` is NOT:
+        # * Joining with a variadic tuple returns variadic tuple:
+        #   Tuple[int, bool] + Tuple[bool, ...] becomes Tuple[int, ...]
+        # * Joining with any Sequence also returns a Sequence:
+        #   Tuple[int, bool] + List[bool] becomes Sequence[int]
+        if isinstance(self.s, TupleType):
+            if self.instance_joiner is None:
+                self.instance_joiner = InstanceJoiner()
+            fallback = self.instance_joiner.join_instances(
+                mypy.typeops.tuple_fallback(self.s), mypy.typeops.tuple_fallback(t)
+            )
+            assert isinstance(fallback, Instance)
+            items = self.join_tuples(self.s, t)
+            if items is not None:
+                if len(items) == 1 and isinstance(item := items[0], UnpackType):
+                    if isinstance(unpacked := get_proper_type(item.type), Instance):
+                        # Avoid double-wrapping tuple[*tuple[X, ...]]
+                        return unpacked
+                return TupleType(items, fallback)
+            else:
+                # TODO: should this be a default fallback behaviour like for meet?
+                if is_proper_subtype(self.s, t):
+                    return t
+                if is_proper_subtype(t, self.s):
+                    return self.s
+                return fallback
+        else:
+            return join_types(self.s, mypy.typeops.tuple_fallback(t))
+
+    def visit_typeddict_type(self, t: TypedDictType) -> ProperType:
+        if isinstance(self.s, TypedDictType):
+            items = {
+                item_name: s_item_type
+                for (item_name, s_item_type, t_item_type) in self.s.zip(t)
+                if (
+                    is_equivalent(s_item_type, t_item_type)
+                    and (item_name in t.required_keys) == (item_name in self.s.required_keys)
+                )
+            }
+            fallback = self.s.create_anonymous_fallback()
+            all_keys = set(items.keys())
+            # We need to filter by items.keys() since some required keys present in both t and
+            # self.s might be missing from the join if the types are incompatible.
+            required_keys = all_keys & t.required_keys & self.s.required_keys
+            # If one type has a key as readonly, we mark it as readonly for both:
+            readonly_keys = (t.readonly_keys | t.readonly_keys) & all_keys
+            return TypedDictType(items, required_keys, readonly_keys, fallback)
+        elif isinstance(self.s, Instance):
+            return join_types(self.s, t.fallback)
+        else:
+            return self.default(self.s)
+
+    def visit_literal_type(self, t: LiteralType) -> ProperType:
+        if isinstance(self.s, LiteralType):
+            if t == self.s:
+                return t
+            if self.s.fallback.type.is_enum and t.fallback.type.is_enum:
+                return mypy.typeops.make_simplified_union([self.s, t])
+            return join_types(self.s.fallback, t.fallback)
+        elif isinstance(self.s, Instance) and self.s.last_known_value == t:
+            return t
+        else:
+            return join_types(self.s, t.fallback)
+
+    def visit_partial_type(self, t: PartialType) -> ProperType:
+        # We only have partial information so we can't decide the join result. We should
+        # never get here.
+        assert False, "Internal error"
+
+    def visit_type_type(self, t: TypeType) -> ProperType:
+        if isinstance(self.s, TypeType):
+            return TypeType.make_normalized(
+                join_types(t.item, self.s.item),
+                line=t.line,
+                is_type_form=self.s.is_type_form or t.is_type_form,
+            )
+        elif isinstance(self.s, Instance) and self.s.type.fullname == "builtins.type":
+            return self.s
+        else:
+            return self.default(self.s)
+
+    def visit_type_alias_type(self, t: TypeAliasType) -> ProperType:
+        assert False, f"This should be never called, got {t}"
+
+    def default(self, typ: Type) -> ProperType:
+        typ = get_proper_type(typ)
+        if isinstance(typ, Instance):
+            return object_from_instance(typ)
+        elif isinstance(typ, TypeType):
+            return self.default(typ.item)
+        elif isinstance(typ, UnboundType):
+            return AnyType(TypeOfAny.special_form)
+        elif isinstance(typ, TupleType):
+            return self.default(mypy.typeops.tuple_fallback(typ))
+        elif isinstance(typ, TypedDictType):
+            return self.default(typ.fallback)
+        elif isinstance(typ, FunctionLike):
+            return self.default(typ.fallback)
+        elif isinstance(typ, TypeVarType):
+            return self.default(typ.upper_bound)
+        elif isinstance(typ, ParamSpecType):
+            return self.default(typ.upper_bound)
+        else:
+            return AnyType(TypeOfAny.special_form)
+
+
+def is_better(t: Type, s: Type) -> bool:
+    # Given two possible results from join_instances_via_supertype(),
+    # indicate whether t is the better one.
+    t = get_proper_type(t)
+    s = get_proper_type(s)
+
+    if isinstance(t, Instance):
+        if not isinstance(s, Instance):
+            return True
+        if t.type.is_protocol != s.type.is_protocol:
+            if t.type.fullname != "builtins.object" and s.type.fullname != "builtins.object":
+                # mro of protocol is not really relevant
+                return not t.type.is_protocol
+        # Use len(mro) as a proxy for the better choice.
+        if len(t.type.mro) > len(s.type.mro):
+            return True
+    return False
+
+
+def normalize_callables(s: ProperType, t: ProperType) -> tuple[ProperType, ProperType]:
+    if isinstance(s, (CallableType, Overloaded)):
+        s = s.with_unpacked_kwargs()
+    if isinstance(t, (CallableType, Overloaded)):
+        t = t.with_unpacked_kwargs()
+    return s, t
+
+
+def is_similar_callables(t: CallableType, s: CallableType) -> bool:
+    """Return True if t and s have identical numbers of
+    arguments, default arguments and varargs.
+    """
+    return (
+        len(t.arg_types) == len(s.arg_types)
+        and t.min_args == s.min_args
+        and t.is_var_arg == s.is_var_arg
+    )
+
+
+def is_similar_params(t: Parameters, s: Parameters) -> bool:
+    # This matches the logic in is_similar_callables() above.
+    return (
+        len(t.arg_types) == len(s.arg_types)
+        and t.min_args == s.min_args
+        and (t.var_arg() is not None) == (s.var_arg() is not None)
+    )
+
+
+def update_callable_ids(c: CallableType, ids: list[TypeVarId]) -> CallableType:
+    tv_map = {}
+    tvs = []
+    for tv, new_id in zip(c.variables, ids):
+        new_tv = tv.copy_modified(id=new_id)
+        tvs.append(new_tv)
+        tv_map[tv.id] = new_tv
+    return expand_type(c, tv_map).copy_modified(variables=tvs)
+
+
+def match_generic_callables(t: CallableType, s: CallableType) -> tuple[CallableType, CallableType]:
+    # The case where we combine/join/meet similar callables, situation where both are generic
+    # requires special care. A more principled solution may involve unify_generic_callable(),
+    # but it would have two problems:
+    #   * This adds risk of infinite recursion: e.g. join -> unification -> solver -> join
+    #   * Using unification is an incorrect thing for meets, as it "widens" the types
+    # Finally, this effectively falls back to an old behaviour before namespaces were added to
+    # type variables, and it worked relatively well.
+    max_len = max(len(t.variables), len(s.variables))
+    min_len = min(len(t.variables), len(s.variables))
+    if min_len == 0:
+        return t, s
+    new_ids = [TypeVarId.new(meta_level=0) for _ in range(max_len)]
+    # Note: this relies on variables being in order they appear in function definition.
+    return update_callable_ids(t, new_ids), update_callable_ids(s, new_ids)
+
+
+def join_similar_callables(t: CallableType, s: CallableType) -> CallableType:
+    t, s = match_generic_callables(t, s)
+    arg_types: list[Type] = []
+    for i in range(len(t.arg_types)):
+        arg_types.append(safe_meet(t.arg_types[i], s.arg_types[i]))
+    # TODO in combine_similar_callables also applies here (names and kinds; user metaclasses)
+    # The fallback type can be either 'function', 'type', or some user-provided metaclass.
+    # The result should always use 'function' as a fallback if either operands are using it.
+    if t.fallback.type.fullname == "builtins.function":
+        fallback = t.fallback
+    else:
+        fallback = s.fallback
+    return t.copy_modified(
+        arg_types=arg_types,
+        arg_names=combine_arg_names(t, s),
+        ret_type=join_types(t.ret_type, s.ret_type),
+        fallback=fallback,
+        name=None,
+    )
+
+
+def safe_join(t: Type, s: Type) -> Type:
+    # This is a temporary solution to prevent crashes in combine_similar_callables() etc.,
+    # until relevant TODOs on handling arg_kinds will be addressed there.
+    if not isinstance(t, UnpackType) and not isinstance(s, UnpackType):
+        return join_types(t, s)
+    if isinstance(t, UnpackType) and isinstance(s, UnpackType):
+        return UnpackType(join_types(t.type, s.type))
+    return object_or_any_from_type(get_proper_type(t))
+
+
+def safe_meet(t: Type, s: Type) -> Type:
+    # Similar to above but for meet_types().
+    from mypy.meet import meet_types
+
+    if not isinstance(t, UnpackType) and not isinstance(s, UnpackType):
+        return meet_types(t, s)
+    if isinstance(t, UnpackType) and isinstance(s, UnpackType):
+        unpacked = get_proper_type(t.type)
+        if isinstance(unpacked, TypeVarTupleType):
+            fallback_type = unpacked.tuple_fallback.type
+        elif isinstance(unpacked, TupleType):
+            fallback_type = unpacked.partial_fallback.type
+        else:
+            assert isinstance(unpacked, Instance) and unpacked.type.fullname == "builtins.tuple"
+            fallback_type = unpacked.type
+        res = meet_types(t.type, s.type)
+        if isinstance(res, UninhabitedType):
+            res = Instance(fallback_type, [res])
+        return UnpackType(res)
+    return UninhabitedType()
+
+
+def combine_similar_callables(t: CallableType, s: CallableType) -> CallableType:
+    t, s = match_generic_callables(t, s)
+    arg_types: list[Type] = []
+    for i in range(len(t.arg_types)):
+        arg_types.append(safe_join(t.arg_types[i], s.arg_types[i]))
+    # TODO kinds and argument names
+    # TODO what should happen if one fallback is 'type' and the other is a user-provided metaclass?
+    # The fallback type can be either 'function', 'type', or some user-provided metaclass.
+    # The result should always use 'function' as a fallback if either operands are using it.
+    if t.fallback.type.fullname == "builtins.function":
+        fallback = t.fallback
+    else:
+        fallback = s.fallback
+    return t.copy_modified(
+        arg_types=arg_types,
+        arg_names=combine_arg_names(t, s),
+        ret_type=join_types(t.ret_type, s.ret_type),
+        fallback=fallback,
+        name=None,
+    )
+
+
+def combine_arg_names(
+    t: CallableType | Parameters, s: CallableType | Parameters
+) -> list[str | None]:
+    """Produces a list of argument names compatible with both callables.
+
+    For example, suppose 't' and 's' have the following signatures:
+
+    - t: (a: int, b: str, X: str) -> None
+    - s: (a: int, b: str, Y: str) -> None
+
+    This function would return ["a", "b", None]. This information
+    is then used above to compute the join of t and s, which results
+    in a signature of (a: int, b: str, str) -> None.
+
+    Note that the third argument's name is omitted and 't' and 's'
+    are both valid subtypes of this inferred signature.
+
+    Precondition: is_similar_types(t, s) is true.
+    """
+    num_args = len(t.arg_types)
+    new_names = []
+    for i in range(num_args):
+        t_name = t.arg_names[i]
+        s_name = s.arg_names[i]
+        if t_name == s_name or t.arg_kinds[i].is_named() or s.arg_kinds[i].is_named():
+            new_names.append(t_name)
+        else:
+            new_names.append(None)
+    return new_names
+
+
+def object_from_instance(instance: Instance) -> Instance:
+    """Construct the type 'builtins.object' from an instance type."""
+    # Use the fact that 'object' is always the last class in the mro.
+    res = Instance(instance.type.mro[-1], [])
+    return res
+
+
+def object_or_any_from_type(typ: ProperType) -> ProperType:
+    # Similar to object_from_instance() but tries hard for all types.
+    # TODO: find a better way to get object, or make this more reliable.
+    if isinstance(typ, Instance):
+        return object_from_instance(typ)
+    elif isinstance(typ, (CallableType, TypedDictType, LiteralType)):
+        return object_from_instance(typ.fallback)
+    elif isinstance(typ, TupleType):
+        return object_from_instance(typ.partial_fallback)
+    elif isinstance(typ, TypeType):
+        return object_or_any_from_type(typ.item)
+    elif isinstance(typ, TypeVarLikeType) and isinstance(typ.upper_bound, ProperType):
+        return object_or_any_from_type(typ.upper_bound)
+    elif isinstance(typ, UnionType):
+        for item in typ.items:
+            if isinstance(item, ProperType):
+                candidate = object_or_any_from_type(item)
+                if isinstance(candidate, Instance):
+                    return candidate
+    elif isinstance(typ, UnpackType):
+        object_or_any_from_type(get_proper_type(typ.type))
+    return AnyType(TypeOfAny.implementation_artifact)
+
+
+def join_type_list(types: Sequence[Type]) -> Type:
+    if not types:
+        # This is a little arbitrary but reasonable. Any empty tuple should be compatible
+        # with all variable length tuples, and this makes it possible.
+        return UninhabitedType()
+    joined = types[0]
+    for t in types[1:]:
+        joined = join_types(joined, t)
+    return joined
+
+
+def unpack_callback_protocol(t: Instance) -> ProperType | None:
+    assert t.type.is_protocol
+    if t.type.protocol_members == ["__call__"]:
+        return get_proper_type(find_member("__call__", t, t, is_operator=True))
+    return None

micromamba_root/Lib/site-packages/mypy/literals.py

@@ -0,0 +1,327 @@
+from __future__ import annotations
+
+from collections.abc import Iterable
+from typing import Any, Final, TypeAlias as _TypeAlias
+
+from mypy.nodes import (
+    LITERAL_NO,
+    LITERAL_TYPE,
+    LITERAL_YES,
+    AssertTypeExpr,
+    AssignmentExpr,
+    AwaitExpr,
+    BytesExpr,
+    CallExpr,
+    CastExpr,
+    ComparisonExpr,
+    ComplexExpr,
+    ConditionalExpr,
+    DictExpr,
+    DictionaryComprehension,
+    EllipsisExpr,
+    EnumCallExpr,
+    Expression,
+    FloatExpr,
+    GeneratorExpr,
+    IndexExpr,
+    IntExpr,
+    LambdaExpr,
+    ListComprehension,
+    ListExpr,
+    MemberExpr,
+    NamedTupleExpr,
+    NameExpr,
+    NewTypeExpr,
+    OpExpr,
+    ParamSpecExpr,
+    PromoteExpr,
+    RevealExpr,
+    SetComprehension,
+    SetExpr,
+    SliceExpr,
+    StarExpr,
+    StrExpr,
+    SuperExpr,
+    TemplateStrExpr,
+    TempNode,
+    TupleExpr,
+    TypeAliasExpr,
+    TypeApplication,
+    TypedDictExpr,
+    TypeFormExpr,
+    TypeVarExpr,
+    TypeVarTupleExpr,
+    UnaryExpr,
+    Var,
+    YieldExpr,
+    YieldFromExpr,
+)
+from mypy.visitor import ExpressionVisitor
+
+# [Note Literals and literal_hash]
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+# Mypy uses the term "literal" to refer to any expression built out of
+# the following:
+#
+# * Plain literal expressions, like `1` (integer, float, string, etc.)
+#
+# * Compound literal expressions, like `(lit1, lit2)` (list, dict,
+#   set, or tuple)
+#
+# * Operator expressions, like `lit1 + lit2`
+#
+# * Variable references, like `x`
+#
+# * Member references, like `lit.m`
+#
+# * Index expressions, like `lit[0]`
+#
+# A typical "literal" looks like `x[(i,j+1)].m`.
+#
+# An expression that is a literal has a `literal_hash`, with the
+# following properties.
+#
+# * `literal_hash` is a Key: a tuple containing basic data types and
+#   possibly other Keys. So it can be used as a key in a dictionary
+#   that will be compared by value (as opposed to the Node itself,
+#   which is compared by identity).
+#
+# * Two expressions have equal `literal_hash`es if and only if they
+#   are syntactically equal expressions. (NB: Actually, we also
+#   identify as equal expressions like `3` and `3.0`; is this a good
+#   idea?)
+#
+# * The elements of `literal_hash` that are tuples are exactly the
+#   subexpressions of the original expression (e.g. the base and index
+#   of an index expression, or the operands of an operator expression).
+
+
+Key: _TypeAlias = tuple[Any, ...]
+
+
+def literal_hash(e: Expression) -> Key | None:
+    """Generate a hashable, (mostly) opaque key for expressions supported by the binder.
+
+    These allow using expressions as dictionary keys based on structural/value
+    matching (instead of based on expression identity).
+
+    Return None if the expression type is not supported (it cannot be narrowed).
+
+    See the comment above for more information.
+
+    NOTE: This is not directly related to literal types.
+    """
+    return e.accept(_hasher)
+
+
+def literal(e: Expression) -> int:
+    """Return the literal kind for an expression."""
+
+    if isinstance(e, ComparisonExpr):
+        return min(literal(o) for o in e.operands)
+
+    elif isinstance(e, OpExpr):
+        return min(literal(e.left), literal(e.right))
+
+    elif isinstance(e, (MemberExpr, UnaryExpr, StarExpr)):
+        return literal(e.expr)
+
+    elif isinstance(e, AssignmentExpr):
+        return literal(e.target)
+
+    elif isinstance(e, IndexExpr):
+        if literal(e.index) == LITERAL_YES:
+            return literal(e.base)
+        else:
+            return LITERAL_NO
+
+    elif isinstance(e, NameExpr):
+        if isinstance(e.node, Var) and e.node.is_final and e.node.final_value is not None:
+            return LITERAL_YES
+        return LITERAL_TYPE
+
+    if isinstance(e, (IntExpr, FloatExpr, ComplexExpr, StrExpr, BytesExpr)):
+        return LITERAL_YES
+
+    if literal_hash(e):
+        return LITERAL_YES
+
+    return LITERAL_NO
+
+
+def subkeys(key: Key) -> Iterable[Key]:
+    return [elt for elt in key if isinstance(elt, tuple)]
+
+
+def extract_var_from_literal_hash(key: Key) -> Var | None:
+    """If key refers to a Var node, return it.
+
+    Return None otherwise.
+    """
+    if len(key) == 2 and key[0] == "Var" and isinstance(key[1], Var):
+        return key[1]
+    return None
+
+
+class _Hasher(ExpressionVisitor[Key | None]):
+    def visit_int_expr(self, e: IntExpr) -> Key:
+        return ("Literal", e.value)
+
+    def visit_str_expr(self, e: StrExpr) -> Key:
+        return ("Literal", e.value)
+
+    def visit_bytes_expr(self, e: BytesExpr) -> Key:
+        return ("Literal", e.value)
+
+    def visit_float_expr(self, e: FloatExpr) -> Key:
+        return ("Literal", e.value)
+
+    def visit_complex_expr(self, e: ComplexExpr) -> Key:
+        return ("Literal", e.value)
+
+    def visit_star_expr(self, e: StarExpr) -> Key:
+        return ("Star", literal_hash(e.expr))
+
+    def visit_name_expr(self, e: NameExpr) -> Key:
+        if isinstance(e.node, Var) and e.node.is_final and e.node.final_value is not None:
+            return ("Literal", e.node.final_value)
+        # N.B: We use the node itself as the key, and not the name,
+        # because using the name causes issues when there is shadowing
+        # (for example, in list comprehensions).
+        return ("Var", e.node)
+
+    def visit_member_expr(self, e: MemberExpr) -> Key:
+        return ("Member", literal_hash(e.expr), e.name)
+
+    def visit_op_expr(self, e: OpExpr) -> Key:
+        return ("Binary", e.op, literal_hash(e.left), literal_hash(e.right))
+
+    def visit_comparison_expr(self, e: ComparisonExpr) -> Key:
+        rest: tuple[str | Key | None, ...] = tuple(e.operators)
+        rest += tuple(literal_hash(o) for o in e.operands)
+        return ("Comparison",) + rest
+
+    def visit_unary_expr(self, e: UnaryExpr) -> Key:
+        return ("Unary", e.op, literal_hash(e.expr))
+
+    def seq_expr(self, e: ListExpr | TupleExpr | SetExpr, name: str) -> Key | None:
+        if all(literal(x) == LITERAL_YES for x in e.items):
+            rest: tuple[Key | None, ...] = tuple(literal_hash(x) for x in e.items)
+            return (name,) + rest
+        return None
+
+    def visit_list_expr(self, e: ListExpr) -> Key | None:
+        return self.seq_expr(e, "List")
+
+    def visit_dict_expr(self, e: DictExpr) -> Key | None:
+        if all(a and literal(a) == literal(b) == LITERAL_YES for a, b in e.items):
+            rest: tuple[Key | None, ...] = tuple(
+                (literal_hash(a) if a else None, literal_hash(b)) for a, b in e.items
+            )
+            return ("Dict",) + rest
+        return None
+
+    def visit_tuple_expr(self, e: TupleExpr) -> Key | None:
+        return self.seq_expr(e, "Tuple")
+
+    def visit_set_expr(self, e: SetExpr) -> Key | None:
+        return self.seq_expr(e, "Set")
+
+    def visit_index_expr(self, e: IndexExpr) -> Key | None:
+        if literal(e.index) == LITERAL_YES:
+            return ("Index", literal_hash(e.base), literal_hash(e.index))
+        return None
+
+    def visit_assignment_expr(self, e: AssignmentExpr) -> Key | None:
+        return literal_hash(e.target)
+
+    def visit_call_expr(self, e: CallExpr) -> None:
+        return None
+
+    def visit_slice_expr(self, e: SliceExpr) -> None:
+        return None
+
+    def visit_cast_expr(self, e: CastExpr) -> None:
+        return None
+
+    def visit_type_form_expr(self, e: TypeFormExpr) -> None:
+        return None
+
+    def visit_assert_type_expr(self, e: AssertTypeExpr) -> None:
+        return None
+
+    def visit_conditional_expr(self, e: ConditionalExpr) -> None:
+        return None
+
+    def visit_ellipsis(self, e: EllipsisExpr) -> None:
+        return None
+
+    def visit_yield_from_expr(self, e: YieldFromExpr) -> None:
+        return None
+
+    def visit_yield_expr(self, e: YieldExpr) -> None:
+        return None
+
+    def visit_reveal_expr(self, e: RevealExpr) -> None:
+        return None
+
+    def visit_super_expr(self, e: SuperExpr) -> None:
+        return None
+
+    def visit_type_application(self, e: TypeApplication) -> None:
+        return None
+
+    def visit_lambda_expr(self, e: LambdaExpr) -> None:
+        return None
+
+    def visit_list_comprehension(self, e: ListComprehension) -> None:
+        return None
+
+    def visit_set_comprehension(self, e: SetComprehension) -> None:
+        return None
+
+    def visit_dictionary_comprehension(self, e: DictionaryComprehension) -> None:
+        return None
+
+    def visit_generator_expr(self, e: GeneratorExpr) -> None:
+        return None
+
+    def visit_type_var_expr(self, e: TypeVarExpr) -> None:
+        return None
+
+    def visit_paramspec_expr(self, e: ParamSpecExpr) -> None:
+        return None
+
+    def visit_type_var_tuple_expr(self, e: TypeVarTupleExpr) -> None:
+        return None
+
+    def visit_type_alias_expr(self, e: TypeAliasExpr) -> None:
+        return None
+
+    def visit_namedtuple_expr(self, e: NamedTupleExpr) -> None:
+        return None
+
+    def visit_enum_call_expr(self, e: EnumCallExpr) -> None:
+        return None
+
+    def visit_typeddict_expr(self, e: TypedDictExpr) -> None:
+        return None
+
+    def visit_newtype_expr(self, e: NewTypeExpr) -> None:
+        return None
+
+    def visit__promote_expr(self, e: PromoteExpr) -> None:
+        return None
+
+    def visit_await_expr(self, e: AwaitExpr) -> None:
+        return None
+
+    def visit_template_str_expr(self, e: TemplateStrExpr) -> None:
+        return None
+
+    def visit_temp_node(self, e: TempNode) -> None:
+        return None
+
+
+_hasher: Final = _Hasher()