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

mypy/typeops.py

@@ -0,0 +1,1082 @@
+"""Miscellaneous type operations and helpers for use during type checking.
+
+NOTE: These must not be accessed from mypy.nodes or mypy.types to avoid import
+      cycles. These must not be called from the semantic analysis main pass
+      since these may assume that MROs are ready.
+"""
+
+from __future__ import annotations
+
+import itertools
+from typing import Any, Iterable, List, Sequence, TypeVar, cast
+
+from mypy.copytype import copy_type
+from mypy.expandtype import expand_type, expand_type_by_instance
+from mypy.maptype import map_instance_to_supertype
+from mypy.nodes import (
+    ARG_POS,
+    ARG_STAR,
+    ARG_STAR2,
+    SYMBOL_FUNCBASE_TYPES,
+    Decorator,
+    Expression,
+    FuncBase,
+    FuncDef,
+    FuncItem,
+    OverloadedFuncDef,
+    StrExpr,
+    TypeInfo,
+    Var,
+)
+from mypy.state import state
+from mypy.types import (
+    ENUM_REMOVED_PROPS,
+    AnyType,
+    CallableType,
+    ExtraAttrs,
+    FormalArgument,
+    FunctionLike,
+    Instance,
+    LiteralType,
+    NoneType,
+    NormalizedCallableType,
+    Overloaded,
+    Parameters,
+    ParamSpecType,
+    PartialType,
+    ProperType,
+    TupleType,
+    Type,
+    TypeAliasType,
+    TypedDictType,
+    TypeOfAny,
+    TypeQuery,
+    TypeType,
+    TypeVarLikeType,
+    TypeVarTupleType,
+    TypeVarType,
+    UninhabitedType,
+    UnionType,
+    UnpackType,
+    flatten_nested_unions,
+    get_proper_type,
+    get_proper_types,
+)
+from mypy.typevars import fill_typevars
+
+
+def is_recursive_pair(s: Type, t: Type) -> bool:
+    """Is this a pair of recursive types?
+
+    There may be more cases, and we may be forced to use e.g. has_recursive_types()
+    here, but this function is called in very hot code, so we try to keep it simple
+    and return True only in cases we know may have problems.
+    """
+    if isinstance(s, TypeAliasType) and s.is_recursive:
+        return (
+            isinstance(get_proper_type(t), (Instance, UnionType))
+            or isinstance(t, TypeAliasType)
+            and t.is_recursive
+            # Tuple types are special, they can cause an infinite recursion even if
+            # the other type is not recursive, because of the tuple fallback that is
+            # calculated "on the fly".
+            or isinstance(get_proper_type(s), TupleType)
+        )
+    if isinstance(t, TypeAliasType) and t.is_recursive:
+        return (
+            isinstance(get_proper_type(s), (Instance, UnionType))
+            or isinstance(s, TypeAliasType)
+            and s.is_recursive
+            # Same as above.
+            or isinstance(get_proper_type(t), TupleType)
+        )
+    return False
+
+
+def tuple_fallback(typ: TupleType) -> Instance:
+    """Return fallback type for a tuple."""
+    from mypy.join import join_type_list
+
+    info = typ.partial_fallback.type
+    if info.fullname != "builtins.tuple":
+        return typ.partial_fallback
+    items = []
+    for item in typ.items:
+        if isinstance(item, UnpackType):
+            unpacked_type = get_proper_type(item.type)
+            if isinstance(unpacked_type, TypeVarTupleType):
+                unpacked_type = get_proper_type(unpacked_type.upper_bound)
+            if (
+                isinstance(unpacked_type, Instance)
+                and unpacked_type.type.fullname == "builtins.tuple"
+            ):
+                items.append(unpacked_type.args[0])
+            else:
+                raise NotImplementedError
+        else:
+            items.append(item)
+    # TODO: we should really use a union here, tuple types are special.
+    return Instance(info, [join_type_list(items)], extra_attrs=typ.partial_fallback.extra_attrs)
+
+
+def get_self_type(func: CallableType, default_self: Instance | TupleType) -> Type | None:
+    if isinstance(get_proper_type(func.ret_type), UninhabitedType):
+        return func.ret_type
+    elif func.arg_types and func.arg_types[0] != default_self and func.arg_kinds[0] == ARG_POS:
+        return func.arg_types[0]
+    else:
+        return None
+
+
+def type_object_type_from_function(
+    signature: FunctionLike, info: TypeInfo, def_info: TypeInfo, fallback: Instance, is_new: bool
+) -> FunctionLike:
+    # We first need to record all non-trivial (explicit) self types in __init__,
+    # since they will not be available after we bind them. Note, we use explicit
+    # self-types only in the defining class, similar to __new__ (but not exactly the same,
+    # see comment in class_callable below). This is mostly useful for annotating library
+    # classes such as subprocess.Popen.
+    default_self = fill_typevars(info)
+    if not is_new and not info.is_newtype:
+        orig_self_types = [get_self_type(it, default_self) for it in signature.items]
+    else:
+        orig_self_types = [None] * len(signature.items)
+
+    # The __init__ method might come from a generic superclass 'def_info'
+    # with type variables that do not map identically to the type variables of
+    # the class 'info' being constructed. For example:
+    #
+    #   class A(Generic[T]):
+    #       def __init__(self, x: T) -> None: ...
+    #   class B(A[List[T]]):
+    #      ...
+    #
+    # We need to map B's __init__ to the type (List[T]) -> None.
+    signature = bind_self(signature, original_type=default_self, is_classmethod=is_new)
+    signature = cast(FunctionLike, map_type_from_supertype(signature, info, def_info))
+
+    special_sig: str | None = None
+    if def_info.fullname == "builtins.dict":
+        # Special signature!
+        special_sig = "dict"
+
+    if isinstance(signature, CallableType):
+        return class_callable(signature, info, fallback, special_sig, is_new, orig_self_types[0])
+    else:
+        # Overloaded __init__/__new__.
+        assert isinstance(signature, Overloaded)
+        items: list[CallableType] = []
+        for item, orig_self in zip(signature.items, orig_self_types):
+            items.append(class_callable(item, info, fallback, special_sig, is_new, orig_self))
+        return Overloaded(items)
+
+
+def class_callable(
+    init_type: CallableType,
+    info: TypeInfo,
+    type_type: Instance,
+    special_sig: str | None,
+    is_new: bool,
+    orig_self_type: Type | None = None,
+) -> CallableType:
+    """Create a type object type based on the signature of __init__."""
+    variables: list[TypeVarLikeType] = []
+    variables.extend(info.defn.type_vars)
+    variables.extend(init_type.variables)
+
+    from mypy.subtypes import is_subtype
+
+    init_ret_type = get_proper_type(init_type.ret_type)
+    orig_self_type = get_proper_type(orig_self_type)
+    default_ret_type = fill_typevars(info)
+    explicit_type = init_ret_type if is_new else orig_self_type
+    if (
+        isinstance(explicit_type, (Instance, TupleType, UninhabitedType))
+        # We have to skip protocols, because it can be a subtype of a return type
+        # by accident. Like `Hashable` is a subtype of `object`. See #11799
+        and isinstance(default_ret_type, Instance)
+        and not default_ret_type.type.is_protocol
+        # Only use the declared return type from __new__ or declared self in __init__
+        # if it is actually returning a subtype of what we would return otherwise.
+        and is_subtype(explicit_type, default_ret_type, ignore_type_params=True)
+    ):
+        ret_type: Type = explicit_type
+    else:
+        ret_type = default_ret_type
+
+    callable_type = init_type.copy_modified(
+        ret_type=ret_type,
+        fallback=type_type,
+        name=None,
+        variables=variables,
+        special_sig=special_sig,
+    )
+    c = callable_type.with_name(info.name)
+    return c
+
+
+def map_type_from_supertype(typ: Type, sub_info: TypeInfo, super_info: TypeInfo) -> Type:
+    """Map type variables in a type defined in a supertype context to be valid
+    in the subtype context. Assume that the result is unique; if more than
+    one type is possible, return one of the alternatives.
+
+    For example, assume
+
+      class D(Generic[S]): ...
+      class C(D[E[T]], Generic[T]): ...
+
+    Now S in the context of D would be mapped to E[T] in the context of C.
+    """
+    # Create the type of self in subtype, of form t[a1, ...].
+    inst_type = fill_typevars(sub_info)
+    if isinstance(inst_type, TupleType):
+        inst_type = tuple_fallback(inst_type)
+    # Map the type of self to supertype. This gets us a description of the
+    # supertype type variables in terms of subtype variables, i.e. t[t1, ...]
+    # so that any type variables in tN are to be interpreted in subtype
+    # context.
+    inst_type = map_instance_to_supertype(inst_type, super_info)
+    # Finally expand the type variables in type with those in the previously
+    # constructed type. Note that both type and inst_type may have type
+    # variables, but in type they are interpreted in supertype context while
+    # in inst_type they are interpreted in subtype context. This works even if
+    # the names of type variables in supertype and subtype overlap.
+    return expand_type_by_instance(typ, inst_type)
+
+
+def supported_self_type(typ: ProperType, allow_callable: bool = True) -> bool:
+    """Is this a supported kind of explicit self-types?
+
+    Currently, this means an X or Type[X], where X is an instance or
+    a type variable with an instance upper bound.
+    """
+    if isinstance(typ, TypeType):
+        return supported_self_type(typ.item)
+    if allow_callable and isinstance(typ, CallableType):
+        # Special case: allow class callable instead of Type[...] as cls annotation,
+        # as well as callable self for callback protocols.
+        return True
+    return isinstance(typ, TypeVarType) or (
+        isinstance(typ, Instance) and typ != fill_typevars(typ.type)
+    )
+
+
+F = TypeVar("F", bound=FunctionLike)
+
+
+def bind_self(method: F, original_type: Type | None = None, is_classmethod: bool = False) -> F:
+    """Return a copy of `method`, with the type of its first parameter (usually
+    self or cls) bound to original_type.
+
+    If the type of `self` is a generic type (T, or Type[T] for classmethods),
+    instantiate every occurrence of type with original_type in the rest of the
+    signature and in the return type.
+
+    original_type is the type of E in the expression E.copy(). It is None in
+    compatibility checks. In this case we treat it as the erasure of the
+    declared type of self.
+
+    This way we can express "the type of self". For example:
+
+    T = TypeVar('T', bound='A')
+    class A:
+        def copy(self: T) -> T: ...
+
+    class B(A): pass
+
+    b = B().copy()  # type: B
+
+    """
+    if isinstance(method, Overloaded):
+        return cast(
+            F, Overloaded([bind_self(c, original_type, is_classmethod) for c in method.items])
+        )
+    assert isinstance(method, CallableType)
+    func = method
+    if not func.arg_types:
+        # Invalid method, return something.
+        return cast(F, func)
+    if func.arg_kinds[0] == ARG_STAR:
+        # The signature is of the form 'def foo(*args, ...)'.
+        # In this case we shouldn't drop the first arg,
+        # since func will be absorbed by the *args.
+
+        # TODO: infer bounds on the type of *args?
+        return cast(F, func)
+    self_param_type = get_proper_type(func.arg_types[0])
+
+    variables: Sequence[TypeVarLikeType]
+    # Having a def __call__(self: Callable[...], ...) can cause infinite recursion. Although
+    # this special-casing looks not very principled, there is nothing meaningful we can infer
+    # from such definition, since it is inherently indefinitely recursive.
+    allow_callable = func.name is None or not func.name.startswith("__call__ of")
+    if func.variables and supported_self_type(self_param_type, allow_callable=allow_callable):
+        from mypy.infer import infer_type_arguments
+
+        if original_type is None:
+            # TODO: type check method override (see #7861).
+            original_type = erase_to_bound(self_param_type)
+        original_type = get_proper_type(original_type)
+
+        # Find which of method type variables appear in the type of "self".
+        self_ids = {tv.id for tv in get_all_type_vars(self_param_type)}
+        self_vars = [tv for tv in func.variables if tv.id in self_ids]
+
+        # Solve for these type arguments using the actual class or instance type.
+        typeargs = infer_type_arguments(
+            self_vars, self_param_type, original_type, is_supertype=True
+        )
+        if (
+            is_classmethod
+            and any(isinstance(get_proper_type(t), UninhabitedType) for t in typeargs)
+            and isinstance(original_type, (Instance, TypeVarType, TupleType))
+        ):
+            # In case we call a classmethod through an instance x, fallback to type(x).
+            typeargs = infer_type_arguments(
+                self_vars, self_param_type, TypeType(original_type), is_supertype=True
+            )
+
+        # Update the method signature with the solutions found.
+        # Technically, some constraints might be unsolvable, make them Never.
+        to_apply = [t if t is not None else UninhabitedType() for t in typeargs]
+        func = expand_type(func, {tv.id: arg for tv, arg in zip(self_vars, to_apply)})
+        variables = [v for v in func.variables if v not in self_vars]
+    else:
+        variables = func.variables
+
+    original_type = get_proper_type(original_type)
+    if isinstance(original_type, CallableType) and original_type.is_type_obj():
+        original_type = TypeType.make_normalized(original_type.ret_type)
+    res = func.copy_modified(
+        arg_types=func.arg_types[1:],
+        arg_kinds=func.arg_kinds[1:],
+        arg_names=func.arg_names[1:],
+        variables=variables,
+        bound_args=[original_type],
+    )
+    return cast(F, res)
+
+
+def erase_to_bound(t: Type) -> Type:
+    # TODO: use value restrictions to produce a union?
+    t = get_proper_type(t)
+    if isinstance(t, TypeVarType):
+        return t.upper_bound
+    if isinstance(t, TypeType):
+        if isinstance(t.item, TypeVarType):
+            return TypeType.make_normalized(t.item.upper_bound)
+    return t
+
+
+def callable_corresponding_argument(
+    typ: NormalizedCallableType | Parameters, model: FormalArgument
+) -> FormalArgument | None:
+    """Return the argument a function that corresponds to `model`"""
+
+    by_name = typ.argument_by_name(model.name)
+    by_pos = typ.argument_by_position(model.pos)
+    if by_name is None and by_pos is None:
+        return None
+    if by_name is not None and by_pos is not None:
+        if by_name == by_pos:
+            return by_name
+        # If we're dealing with an optional pos-only and an optional
+        # name-only arg, merge them.  This is the case for all functions
+        # taking both *args and **args, or a pair of functions like so:
+
+        # def right(a: int = ...) -> None: ...
+        # def left(__a: int = ..., *, a: int = ...) -> None: ...
+        from mypy.subtypes import is_equivalent
+
+        if (
+            not (by_name.required or by_pos.required)
+            and by_pos.name is None
+            and by_name.pos is None
+            and is_equivalent(by_name.typ, by_pos.typ)
+        ):
+            return FormalArgument(by_name.name, by_pos.pos, by_name.typ, False)
+    return by_name if by_name is not None else by_pos
+
+
+def simple_literal_type(t: ProperType | None) -> Instance | None:
+    """Extract the underlying fallback Instance type for a simple Literal"""
+    if isinstance(t, Instance) and t.last_known_value is not None:
+        t = t.last_known_value
+    if isinstance(t, LiteralType):
+        return t.fallback
+    return None
+
+
+def is_simple_literal(t: ProperType) -> bool:
+    if isinstance(t, LiteralType):
+        return t.fallback.type.is_enum or t.fallback.type.fullname == "builtins.str"
+    if isinstance(t, Instance):
+        return t.last_known_value is not None and isinstance(t.last_known_value.value, str)
+    return False
+
+
+def make_simplified_union(
+    items: Sequence[Type],
+    line: int = -1,
+    column: int = -1,
+    *,
+    keep_erased: bool = False,
+    contract_literals: bool = True,
+) -> ProperType:
+    """Build union type with redundant union items removed.
+
+    If only a single item remains, this may return a non-union type.
+
+    Examples:
+
+    * [int, str] -> Union[int, str]
+    * [int, object] -> object
+    * [int, int] -> int
+    * [int, Any] -> Union[int, Any] (Any types are not simplified away!)
+    * [Any, Any] -> Any
+    * [int, Union[bytes, str]] -> Union[int, bytes, str]
+
+    Note: This must NOT be used during semantic analysis, since TypeInfos may not
+          be fully initialized.
+
+    The keep_erased flag is used for type inference against union types
+    containing type variables. If set to True, keep all ErasedType items.
+
+    The contract_literals flag indicates whether we need to contract literal types
+    back into a sum type. Set it to False when called by try_expanding_sum_type_
+    to_union().
+    """
+    # Step 1: expand all nested unions
+    items = flatten_nested_unions(items)
+
+    # Step 2: fast path for single item
+    if len(items) == 1:
+        return get_proper_type(items[0])
+
+    # Step 3: remove redundant unions
+    simplified_set: Sequence[Type] = _remove_redundant_union_items(items, keep_erased)
+
+    # Step 4: If more than one literal exists in the union, try to simplify
+    if (
+        contract_literals
+        and sum(isinstance(get_proper_type(item), LiteralType) for item in simplified_set) > 1
+    ):
+        simplified_set = try_contracting_literals_in_union(simplified_set)
+
+    result = get_proper_type(UnionType.make_union(simplified_set, line, column))
+
+    nitems = len(items)
+    if nitems > 1 and (
+        nitems > 2 or not (type(items[0]) is NoneType or type(items[1]) is NoneType)
+    ):
+        # Step 5: At last, we erase any (inconsistent) extra attributes on instances.
+
+        # Initialize with None instead of an empty set as a micro-optimization. The set
+        # is needed very rarely, so we try to avoid constructing it.
+        extra_attrs_set: set[ExtraAttrs] | None = None
+        for item in items:
+            instance = try_getting_instance_fallback(item)
+            if instance and instance.extra_attrs:
+                if extra_attrs_set is None:
+                    extra_attrs_set = {instance.extra_attrs}
+                else:
+                    extra_attrs_set.add(instance.extra_attrs)
+
+        if extra_attrs_set is not None and len(extra_attrs_set) > 1:
+            fallback = try_getting_instance_fallback(result)
+            if fallback:
+                fallback.extra_attrs = None
+
+    return result
+
+
+def _remove_redundant_union_items(items: list[Type], keep_erased: bool) -> list[Type]:
+    from mypy.subtypes import is_proper_subtype
+
+    # The first pass through this loop, we check if later items are subtypes of earlier items.
+    # The second pass through this loop, we check if earlier items are subtypes of later items
+    # (by reversing the remaining items)
+    for _direction in range(2):
+        new_items: list[Type] = []
+        # seen is a map from a type to its index in new_items
+        seen: dict[ProperType, int] = {}
+        unduplicated_literal_fallbacks: set[Instance] | None = None
+        for ti in items:
+            proper_ti = get_proper_type(ti)
+
+            # UninhabitedType is always redundant
+            if isinstance(proper_ti, UninhabitedType):
+                continue
+
+            duplicate_index = -1
+            # Quickly check if we've seen this type
+            if proper_ti in seen:
+                duplicate_index = seen[proper_ti]
+            elif (
+                isinstance(proper_ti, LiteralType)
+                and unduplicated_literal_fallbacks is not None
+                and proper_ti.fallback in unduplicated_literal_fallbacks
+            ):
+                # This is an optimisation for unions with many LiteralType
+                # We've already checked for exact duplicates. This means that any super type of
+                # the LiteralType must be a super type of its fallback. If we've gone through
+                # the expensive loop below and found no super type for a previous LiteralType
+                # with the same fallback, we can skip doing that work again and just add the type
+                # to new_items
+                pass
+            else:
+                # If not, check if we've seen a supertype of this type
+                for j, tj in enumerate(new_items):
+                    tj = get_proper_type(tj)
+                    # If tj is an Instance with a last_known_value, do not remove proper_ti
+                    # (unless it's an instance with the same last_known_value)
+                    if (
+                        isinstance(tj, Instance)
+                        and tj.last_known_value is not None
+                        and not (
+                            isinstance(proper_ti, Instance)
+                            and tj.last_known_value == proper_ti.last_known_value
+                        )
+                    ):
+                        continue
+
+                    if is_proper_subtype(
+                        ti, tj, keep_erased_types=keep_erased, ignore_promotions=True
+                    ):
+                        duplicate_index = j
+                        break
+            if duplicate_index != -1:
+                # If deleted subtypes had more general truthiness, use that
+                orig_item = new_items[duplicate_index]
+                if not orig_item.can_be_true and ti.can_be_true:
+                    new_items[duplicate_index] = true_or_false(orig_item)
+                elif not orig_item.can_be_false and ti.can_be_false:
+                    new_items[duplicate_index] = true_or_false(orig_item)
+            else:
+                # We have a non-duplicate item, add it to new_items
+                seen[proper_ti] = len(new_items)
+                new_items.append(ti)
+                if isinstance(proper_ti, LiteralType):
+                    if unduplicated_literal_fallbacks is None:
+                        unduplicated_literal_fallbacks = set()
+                    unduplicated_literal_fallbacks.add(proper_ti.fallback)
+
+        items = new_items
+        if len(items) <= 1:
+            break
+        items.reverse()
+
+    return items
+
+
+def _get_type_method_ret_type(t: Type, *, name: str) -> Type | None:
+    t = get_proper_type(t)
+
+    if isinstance(t, Instance):
+        sym = t.type.get(name)
+        if sym:
+            sym_type = get_proper_type(sym.type)
+            if isinstance(sym_type, CallableType):
+                return sym_type.ret_type
+
+    return None
+
+
+def true_only(t: Type) -> ProperType:
+    """
+    Restricted version of t with only True-ish values
+    """
+    t = get_proper_type(t)
+
+    if not t.can_be_true:
+        # All values of t are False-ish, so there are no true values in it
+        return UninhabitedType(line=t.line, column=t.column)
+    elif not t.can_be_false:
+        # All values of t are already True-ish, so true_only is idempotent in this case
+        return t
+    elif isinstance(t, UnionType):
+        # The true version of a union type is the union of the true versions of its components
+        new_items = [true_only(item) for item in t.items]
+        can_be_true_items = [item for item in new_items if item.can_be_true]
+        return make_simplified_union(can_be_true_items, line=t.line, column=t.column)
+    else:
+        ret_type = _get_type_method_ret_type(t, name="__bool__") or _get_type_method_ret_type(
+            t, name="__len__"
+        )
+
+        if ret_type and not ret_type.can_be_true:
+            return UninhabitedType(line=t.line, column=t.column)
+
+        new_t = copy_type(t)
+        new_t.can_be_false = False
+        return new_t
+
+
+def false_only(t: Type) -> ProperType:
+    """
+    Restricted version of t with only False-ish values
+    """
+    t = get_proper_type(t)
+
+    if not t.can_be_false:
+        if state.strict_optional:
+            # All values of t are True-ish, so there are no false values in it
+            return UninhabitedType(line=t.line)
+        else:
+            # When strict optional checking is disabled, everything can be
+            # False-ish since anything can be None
+            return NoneType(line=t.line)
+    elif not t.can_be_true:
+        # All values of t are already False-ish, so false_only is idempotent in this case
+        return t
+    elif isinstance(t, UnionType):
+        # The false version of a union type is the union of the false versions of its components
+        new_items = [false_only(item) for item in t.items]
+        can_be_false_items = [item for item in new_items if item.can_be_false]
+        return make_simplified_union(can_be_false_items, line=t.line, column=t.column)
+    else:
+        ret_type = _get_type_method_ret_type(t, name="__bool__") or _get_type_method_ret_type(
+            t, name="__len__"
+        )
+
+        if ret_type:
+            if not ret_type.can_be_false:
+                return UninhabitedType(line=t.line)
+        elif isinstance(t, Instance) and t.type.is_final:
+            return UninhabitedType(line=t.line)
+
+        new_t = copy_type(t)
+        new_t.can_be_true = False
+        return new_t
+
+
+def true_or_false(t: Type) -> ProperType:
+    """
+    Unrestricted version of t with both True-ish and False-ish values
+    """
+    t = get_proper_type(t)
+
+    if isinstance(t, UnionType):
+        new_items = [true_or_false(item) for item in t.items]
+        return make_simplified_union(new_items, line=t.line, column=t.column)
+
+    new_t = copy_type(t)
+    new_t.can_be_true = new_t.can_be_true_default()
+    new_t.can_be_false = new_t.can_be_false_default()
+    return new_t
+
+
+def erase_def_to_union_or_bound(tdef: TypeVarLikeType) -> Type:
+    # TODO(PEP612): fix for ParamSpecType
+    if isinstance(tdef, ParamSpecType):
+        return AnyType(TypeOfAny.from_error)
+    if isinstance(tdef, TypeVarType) and tdef.values:
+        return make_simplified_union(tdef.values)
+    else:
+        return tdef.upper_bound
+
+
+def erase_to_union_or_bound(typ: TypeVarType) -> ProperType:
+    if typ.values:
+        return make_simplified_union(typ.values)
+    else:
+        return get_proper_type(typ.upper_bound)
+
+
+def function_type(func: FuncBase, fallback: Instance) -> FunctionLike:
+    if func.type:
+        assert isinstance(func.type, FunctionLike)
+        return func.type
+    else:
+        # Implicit type signature with dynamic types.
+        if isinstance(func, FuncItem):
+            return callable_type(func, fallback)
+        else:
+            # Broken overloads can have self.type set to None.
+            # TODO: should we instead always set the type in semantic analyzer?
+            assert isinstance(func, OverloadedFuncDef)
+            any_type = AnyType(TypeOfAny.from_error)
+            dummy = CallableType(
+                [any_type, any_type],
+                [ARG_STAR, ARG_STAR2],
+                [None, None],
+                any_type,
+                fallback,
+                line=func.line,
+                is_ellipsis_args=True,
+            )
+            # Return an Overloaded, because some callers may expect that
+            # an OverloadedFuncDef has an Overloaded type.
+            return Overloaded([dummy])
+
+
+def callable_type(
+    fdef: FuncItem, fallback: Instance, ret_type: Type | None = None
+) -> CallableType:
+    # TODO: somewhat unfortunate duplication with prepare_method_signature in semanal
+    if fdef.info and (not fdef.is_static or fdef.name == "__new__") and fdef.arg_names:
+        self_type: Type = fill_typevars(fdef.info)
+        if fdef.is_class or fdef.name == "__new__":
+            self_type = TypeType.make_normalized(self_type)
+        args = [self_type] + [AnyType(TypeOfAny.unannotated)] * (len(fdef.arg_names) - 1)
+    else:
+        args = [AnyType(TypeOfAny.unannotated)] * len(fdef.arg_names)
+
+    return CallableType(
+        args,
+        fdef.arg_kinds,
+        fdef.arg_names,
+        ret_type or AnyType(TypeOfAny.unannotated),
+        fallback,
+        name=fdef.name,
+        line=fdef.line,
+        column=fdef.column,
+        implicit=True,
+        # We need this for better error messages, like missing `self` note:
+        definition=fdef if isinstance(fdef, FuncDef) else None,
+    )
+
+
+def try_getting_str_literals(expr: Expression, typ: Type) -> list[str] | None:
+    """If the given expression or type corresponds to a string literal
+    or a union of string literals, returns a list of the underlying strings.
+    Otherwise, returns None.
+
+    Specifically, this function is guaranteed to return a list with
+    one or more strings if one of the following is true:
+
+    1. 'expr' is a StrExpr
+    2. 'typ' is a LiteralType containing a string
+    3. 'typ' is a UnionType containing only LiteralType of strings
+    """
+    if isinstance(expr, StrExpr):
+        return [expr.value]
+
+    # TODO: See if we can eliminate this function and call the below one directly
+    return try_getting_str_literals_from_type(typ)
+
+
+def try_getting_str_literals_from_type(typ: Type) -> list[str] | None:
+    """If the given expression or type corresponds to a string Literal
+    or a union of string Literals, returns a list of the underlying strings.
+    Otherwise, returns None.
+
+    For example, if we had the type 'Literal["foo", "bar"]' as input, this function
+    would return a list of strings ["foo", "bar"].
+    """
+    return try_getting_literals_from_type(typ, str, "builtins.str")
+
+
+def try_getting_int_literals_from_type(typ: Type) -> list[int] | None:
+    """If the given expression or type corresponds to an int Literal
+    or a union of int Literals, returns a list of the underlying ints.
+    Otherwise, returns None.
+
+    For example, if we had the type 'Literal[1, 2, 3]' as input, this function
+    would return a list of ints [1, 2, 3].
+    """
+    return try_getting_literals_from_type(typ, int, "builtins.int")
+
+
+T = TypeVar("T")
+
+
+def try_getting_literals_from_type(
+    typ: Type, target_literal_type: type[T], target_fullname: str
+) -> list[T] | None:
+    """If the given expression or type corresponds to a Literal or
+    union of Literals where the underlying values correspond to the given
+    target type, returns a list of those underlying values. Otherwise,
+    returns None.
+    """
+    typ = get_proper_type(typ)
+
+    if isinstance(typ, Instance) and typ.last_known_value is not None:
+        possible_literals: list[Type] = [typ.last_known_value]
+    elif isinstance(typ, UnionType):
+        possible_literals = list(typ.items)
+    else:
+        possible_literals = [typ]
+
+    literals: list[T] = []
+    for lit in get_proper_types(possible_literals):
+        if isinstance(lit, LiteralType) and lit.fallback.type.fullname == target_fullname:
+            val = lit.value
+            if isinstance(val, target_literal_type):
+                literals.append(val)
+            else:
+                return None
+        else:
+            return None
+    return literals
+
+
+def is_literal_type_like(t: Type | None) -> bool:
+    """Returns 'true' if the given type context is potentially either a LiteralType,
+    a Union of LiteralType, or something similar.
+    """
+    t = get_proper_type(t)
+    if t is None:
+        return False
+    elif isinstance(t, LiteralType):
+        return True
+    elif isinstance(t, UnionType):
+        return any(is_literal_type_like(item) for item in t.items)
+    elif isinstance(t, TypeVarType):
+        return is_literal_type_like(t.upper_bound) or any(
+            is_literal_type_like(item) for item in t.values
+        )
+    else:
+        return False
+
+
+def is_singleton_type(typ: Type) -> bool:
+    """Returns 'true' if this type is a "singleton type" -- if there exists
+    exactly only one runtime value associated with this type.
+
+    That is, given two values 'a' and 'b' that have the same type 't',
+    'is_singleton_type(t)' returns True if and only if the expression 'a is b' is
+    always true.
+
+    Currently, this returns True when given NoneTypes, enum LiteralTypes,
+    enum types with a single value and ... (Ellipses).
+
+    Note that other kinds of LiteralTypes cannot count as singleton types. For
+    example, suppose we do 'a = 100000 + 1' and 'b = 100001'. It is not guaranteed
+    that 'a is b' will always be true -- some implementations of Python will end up
+    constructing two distinct instances of 100001.
+    """
+    typ = get_proper_type(typ)
+    return typ.is_singleton_type()
+
+
+def try_expanding_sum_type_to_union(typ: Type, target_fullname: str) -> ProperType:
+    """Attempts to recursively expand any enum Instances with the given target_fullname
+    into a Union of all of its component LiteralTypes.
+
+    For example, if we have:
+
+        class Color(Enum):
+            RED = 1
+            BLUE = 2
+            YELLOW = 3
+
+        class Status(Enum):
+            SUCCESS = 1
+            FAILURE = 2
+            UNKNOWN = 3
+
+    ...and if we call `try_expanding_enum_to_union(Union[Color, Status], 'module.Color')`,
+    this function will return Literal[Color.RED, Color.BLUE, Color.YELLOW, Status].
+    """
+    typ = get_proper_type(typ)
+
+    if isinstance(typ, UnionType):
+        items = [
+            try_expanding_sum_type_to_union(item, target_fullname) for item in typ.relevant_items()
+        ]
+        return make_simplified_union(items, contract_literals=False)
+    elif isinstance(typ, Instance) and typ.type.fullname == target_fullname:
+        if typ.type.is_enum:
+            new_items = []
+            for name, symbol in typ.type.names.items():
+                if not isinstance(symbol.node, Var):
+                    continue
+                # Skip these since Enum will remove it
+                if name in ENUM_REMOVED_PROPS:
+                    continue
+                new_items.append(LiteralType(name, typ))
+            return make_simplified_union(new_items, contract_literals=False)
+        elif typ.type.fullname == "builtins.bool":
+            return make_simplified_union(
+                [LiteralType(True, typ), LiteralType(False, typ)], contract_literals=False
+            )
+
+    return typ
+
+
+def try_contracting_literals_in_union(types: Sequence[Type]) -> list[ProperType]:
+    """Contracts any literal types back into a sum type if possible.
+
+    Will replace the first instance of the literal with the sum type and
+    remove all others.
+
+    If we call `try_contracting_union(Literal[Color.RED, Color.BLUE, Color.YELLOW])`,
+    this function will return Color.
+
+    We also treat `Literal[True, False]` as `bool`.
+    """
+    proper_types = [get_proper_type(typ) for typ in types]
+    sum_types: dict[str, tuple[set[Any], list[int]]] = {}
+    marked_for_deletion = set()
+    for idx, typ in enumerate(proper_types):
+        if isinstance(typ, LiteralType):
+            fullname = typ.fallback.type.fullname
+            if typ.fallback.type.is_enum or isinstance(typ.value, bool):
+                if fullname not in sum_types:
+                    sum_types[fullname] = (
+                        (
+                            set(typ.fallback.get_enum_values())
+                            if typ.fallback.type.is_enum
+                            else {True, False}
+                        ),
+                        [],
+                    )
+                literals, indexes = sum_types[fullname]
+                literals.discard(typ.value)
+                indexes.append(idx)
+                if not literals:
+                    first, *rest = indexes
+                    proper_types[first] = typ.fallback
+                    marked_for_deletion |= set(rest)
+    return list(
+        itertools.compress(
+            proper_types, [(i not in marked_for_deletion) for i in range(len(proper_types))]
+        )
+    )
+
+
+def coerce_to_literal(typ: Type) -> Type:
+    """Recursively converts any Instances that have a last_known_value or are
+    instances of enum types with a single value into the corresponding LiteralType.
+    """
+    original_type = typ
+    typ = get_proper_type(typ)
+    if isinstance(typ, UnionType):
+        new_items = [coerce_to_literal(item) for item in typ.items]
+        return UnionType.make_union(new_items)
+    elif isinstance(typ, Instance):
+        if typ.last_known_value:
+            return typ.last_known_value
+        elif typ.type.is_enum:
+            enum_values = typ.get_enum_values()
+            if len(enum_values) == 1:
+                return LiteralType(value=enum_values[0], fallback=typ)
+    return original_type
+
+
+def get_type_vars(tp: Type) -> list[TypeVarType]:
+    return cast("list[TypeVarType]", tp.accept(TypeVarExtractor()))
+
+
+def get_all_type_vars(tp: Type) -> list[TypeVarLikeType]:
+    # TODO: should we always use this function instead of get_type_vars() above?
+    return tp.accept(TypeVarExtractor(include_all=True))
+
+
+class TypeVarExtractor(TypeQuery[List[TypeVarLikeType]]):
+    def __init__(self, include_all: bool = False) -> None:
+        super().__init__(self._merge)
+        self.include_all = include_all
+
+    def _merge(self, iter: Iterable[list[TypeVarLikeType]]) -> list[TypeVarLikeType]:
+        out = []
+        for item in iter:
+            out.extend(item)
+        return out
+
+    def visit_type_var(self, t: TypeVarType) -> list[TypeVarLikeType]:
+        return [t]
+
+    def visit_param_spec(self, t: ParamSpecType) -> list[TypeVarLikeType]:
+        return [t] if self.include_all else []
+
+    def visit_type_var_tuple(self, t: TypeVarTupleType) -> list[TypeVarLikeType]:
+        return [t] if self.include_all else []
+
+
+def custom_special_method(typ: Type, name: str, check_all: bool = False) -> bool:
+    """Does this type have a custom special method such as __format__() or __eq__()?
+
+    If check_all is True ensure all items of a union have a custom method, not just some.
+    """
+    typ = get_proper_type(typ)
+    if isinstance(typ, Instance):
+        method = typ.type.get(name)
+        if method and isinstance(method.node, (SYMBOL_FUNCBASE_TYPES, Decorator, Var)):
+            if method.node.info:
+                return not method.node.info.fullname.startswith(("builtins.", "typing."))
+        return False
+    if isinstance(typ, UnionType):
+        if check_all:
+            return all(custom_special_method(t, name, check_all) for t in typ.items)
+        return any(custom_special_method(t, name) for t in typ.items)
+    if isinstance(typ, TupleType):
+        return custom_special_method(tuple_fallback(typ), name, check_all)
+    if isinstance(typ, FunctionLike) and typ.is_type_obj():
+        # Look up __method__ on the metaclass for class objects.
+        return custom_special_method(typ.fallback, name, check_all)
+    if isinstance(typ, AnyType):
+        # Avoid false positives in uncertain cases.
+        return True
+    # TODO: support other types (see ExpressionChecker.has_member())?
+    return False
+
+
+def separate_union_literals(t: UnionType) -> tuple[Sequence[LiteralType], Sequence[Type]]:
+    """Separate literals from other members in a union type."""
+    literal_items = []
+    union_items = []
+
+    for item in t.items:
+        proper = get_proper_type(item)
+        if isinstance(proper, LiteralType):
+            literal_items.append(proper)
+        else:
+            union_items.append(item)
+
+    return literal_items, union_items
+
+
+def try_getting_instance_fallback(typ: Type) -> Instance | None:
+    """Returns the Instance fallback for this type if one exists or None."""
+    typ = get_proper_type(typ)
+    if isinstance(typ, Instance):
+        return typ
+    elif isinstance(typ, LiteralType):
+        return typ.fallback
+    elif isinstance(typ, NoneType):
+        return None  # Fast path for None, which is common
+    elif isinstance(typ, FunctionLike):
+        return typ.fallback
+    elif isinstance(typ, TupleType):
+        return typ.partial_fallback
+    elif isinstance(typ, TypedDictType):
+        return typ.fallback
+    elif isinstance(typ, TypeVarType):
+        return try_getting_instance_fallback(typ.upper_bound)
+    return None
+
+
+def fixup_partial_type(typ: Type) -> Type:
+    """Convert a partial type that we couldn't resolve into something concrete.
+
+    This means, for None we make it Optional[Any], and for anything else we
+    fill in all of the type arguments with Any.
+    """
+    if not isinstance(typ, PartialType):
+        return typ
+    if typ.type is None:
+        return UnionType.make_union([AnyType(TypeOfAny.unannotated), NoneType()])
+    else:
+        return Instance(typ.type, [AnyType(TypeOfAny.unannotated)] * len(typ.type.type_vars))
+
+
+def get_protocol_member(left: Instance, member: str, class_obj: bool) -> ProperType | None:
+    if member == "__call__" and class_obj:
+        # Special case: class objects always have __call__ that is just the constructor.
+        from mypy.checkmember import type_object_type
+
+        def named_type(fullname: str) -> Instance:
+            return Instance(left.type.mro[-1], [])
+
+        return type_object_type(left.type, named_type)
+
+    if member == "__call__" and left.type.is_metaclass():
+        # Special case: we want to avoid falling back to metaclass __call__
+        # if constructor signature didn't match, this can cause many false negatives.
+        return None
+
+    from mypy.subtypes import find_member
+
+    return get_proper_type(find_member(member, left, left, class_obj=class_obj))