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

mypy/__init__.py

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

mypy/__main__.py

@@ -0,0 +1,37 @@
+"""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)
+
+
+if __name__ == "__main__":
+    console_entry()

mypy/api.py

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

mypy/applytype.py

@@ -0,0 +1,156 @@
+from __future__ import annotations
+
+from typing import Callable, Sequence
+
+import mypy.subtypes
+from mypy.erasetype import erase_typevars
+from mypy.expandtype import expand_type
+from mypy.nodes import Context
+from mypy.types import (
+    AnyType,
+    CallableType,
+    ParamSpecType,
+    PartialType,
+    Type,
+    TypeVarId,
+    TypeVarLikeType,
+    TypeVarTupleType,
+    TypeVarType,
+    UninhabitedType,
+    UnpackType,
+    get_proper_type,
+)
+
+
+def get_target_type(
+    tvar: TypeVarLikeType,
+    type: Type,
+    callable: CallableType,
+    report_incompatible_typevar_value: Callable[[CallableType, Type, str, Context], None],
+    context: Context,
+    skip_unsatisfied: bool,
+) -> Type | None:
+    p_type = get_proper_type(type)
+    if isinstance(p_type, UninhabitedType) and tvar.has_default():
+        return tvar.default
+    if isinstance(tvar, ParamSpecType):
+        return type
+    if isinstance(tvar, TypeVarTupleType):
+        return type
+    assert isinstance(tvar, TypeVarType)
+    values = tvar.values
+    if values:
+        if isinstance(p_type, AnyType):
+            return type
+        if isinstance(p_type, TypeVarType) and p_type.values:
+            # Allow substituting T1 for T if every allowed value of T1
+            # is also a legal value of T.
+            if all(any(mypy.subtypes.is_same_type(v, v1) for v in values) for v1 in p_type.values):
+                return type
+        matching = []
+        for value in values:
+            if mypy.subtypes.is_subtype(type, value):
+                matching.append(value)
+        if matching:
+            best = matching[0]
+            # If there are more than one matching value, we select the narrowest
+            for match in matching[1:]:
+                if mypy.subtypes.is_subtype(match, best):
+                    best = match
+            return best
+        if skip_unsatisfied:
+            return None
+        report_incompatible_typevar_value(callable, type, tvar.name, context)
+    else:
+        upper_bound = tvar.upper_bound
+        if tvar.name == "Self":
+            # Internally constructed Self-types contain class type variables in upper bound,
+            # so we need to erase them to avoid false positives. This is safe because we do
+            # not support type variables in upper bounds of user defined types.
+            upper_bound = erase_typevars(upper_bound)
+        if not mypy.subtypes.is_subtype(type, upper_bound):
+            if skip_unsatisfied:
+                return None
+            report_incompatible_typevar_value(callable, type, tvar.name, context)
+    return type
+
+
+def apply_generic_arguments(
+    callable: CallableType,
+    orig_types: Sequence[Type | None],
+    report_incompatible_typevar_value: Callable[[CallableType, Type, str, Context], None],
+    context: Context,
+    skip_unsatisfied: bool = False,
+) -> CallableType:
+    """Apply generic type arguments to a callable type.
+
+    For example, applying [int] to 'def [T] (T) -> T' results in
+    'def (int) -> int'.
+
+    Note that each type can be None; in this case, it will not be applied.
+
+    If `skip_unsatisfied` is True, then just skip the types that don't satisfy type variable
+    bound or constraints, instead of giving an error.
+    """
+    tvars = callable.variables
+    min_arg_count = sum(not tv.has_default() for tv in tvars)
+    assert min_arg_count <= len(orig_types) <= len(tvars)
+    # Check that inferred type variable values are compatible with allowed
+    # values and bounds.  Also, promote subtype values to allowed values.
+    # Create a map from type variable id to target type.
+    id_to_type: dict[TypeVarId, Type] = {}
+
+    for tvar, type in zip(tvars, orig_types):
+        assert not isinstance(type, PartialType), "Internal error: must never apply partial type"
+        if type is None:
+            continue
+
+        target_type = get_target_type(
+            tvar, type, callable, report_incompatible_typevar_value, context, skip_unsatisfied
+        )
+        if target_type is not None:
+            id_to_type[tvar.id] = target_type
+
+    # TODO: validate arg_kinds/arg_names for ParamSpec and TypeVarTuple replacements,
+    # not just type variable bounds above.
+    param_spec = callable.param_spec()
+    if param_spec is not None:
+        nt = id_to_type.get(param_spec.id)
+        if nt is not None:
+            # ParamSpec expansion is special-cased, so we need to always expand callable
+            # as a whole, not expanding arguments individually.
+            callable = expand_type(callable, id_to_type)
+            assert isinstance(callable, CallableType)
+            return callable.copy_modified(
+                variables=[tv for tv in tvars if tv.id not in id_to_type]
+            )
+
+    # Apply arguments to argument types.
+    var_arg = callable.var_arg()
+    if var_arg is not None and isinstance(var_arg.typ, UnpackType):
+        # Same as for ParamSpec, callable with variadic types needs to be expanded as a whole.
+        callable = expand_type(callable, id_to_type)
+        assert isinstance(callable, CallableType)
+        return callable.copy_modified(variables=[tv for tv in tvars if tv.id not in id_to_type])
+    else:
+        callable = callable.copy_modified(
+            arg_types=[expand_type(at, id_to_type) for at in callable.arg_types]
+        )
+
+    # Apply arguments to TypeGuard if any.
+    if callable.type_guard is not None:
+        type_guard = expand_type(callable.type_guard, id_to_type)
+    else:
+        type_guard = None
+
+    # The callable may retain some type vars if only some were applied.
+    # TODO: move apply_poly() logic from checkexpr.py here when new inference
+    # becomes universally used (i.e. in all passes + in unification).
+    # With this new logic we can actually *add* some new free variables.
+    remaining_tvars = [tv for tv in tvars if tv.id not in id_to_type]
+
+    return callable.copy_modified(
+        ret_type=expand_type(callable.ret_type, id_to_type),
+        variables=remaining_tvars,
+        type_guard=type_guard,
+    )

mypy/argmap.py

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