Jun 19, 2024 · Jun 16, 2024 · Jun 16, 2024 · Jun 17, 2024 · Jun 17, 2024 · Jun 17, 2024
diff --git a/mypy/checker.py b/mypy/checker.py

        current_class = self.scope.active_class()
        type_vars = current_class.defn.type_vars if current_class else []
        return is_unsafe_overlapping_overload_signatures(first, second, type_vars)
        return is_unsafe_overlapping_overload_signatures(first, second, type_vars, partial_only=False)

    def check_inplace_operator_method(self, defn: FuncBase) -> None:
        """Check an inplace operator method such as __iadd__.


 def is_unsafe_overlapping_overload_signatures(
    signature: CallableType, other: CallableType, class_type_vars: list[TypeVarLikeType]
    signature: CallableType, other: CallableType, class_type_vars: list[TypeVarLikeType],
    partial_only: bool = True
 ) -> bool:
    """Check if two overloaded signatures are unsafely overlapping or partially overlapping.


    for sig_variant in expand_callable_variants(signature):
        for other_variant in expand_callable_variants(other):
            if is_callable_compatible(
            if is_subset_no_promote(sig_variant.ret_type, other_variant.ret_type):
                continue
            if not (
                is_callable_compatible(
                    sig_variant,
                    other_variant,
                    is_compat=is_overlapping_types_for_overload,
                    check_args_covariantly=False,
                    is_proper_subtype=False,
                    is_compat_return=lambda l, r: not is_subset_no_promote(l, r),
                    allow_partial_overlap=True,
                ) or is_callable_compatible(
                    other_variant,
                    sig_variant,
                    is_compat=is_overlapping_types_for_overload,
                    check_args_covariantly=True,
                    is_proper_subtype=False,
                    is_compat_return=lambda l, r: not is_subset_no_promote(r, l),
                    allow_partial_overlap=True,
                )
            ):
                continue
            if not partial_only or (not is_callable_compatible(
                sig_variant,
                other_variant,
                is_compat=is_overlapping_types_for_overload,
                is_compat=is_subset_no_promote,
                check_args_covariantly=False,
                is_proper_subtype=False,
 is_compat_return=lambda l, r: not is_subset_no_promote(l, r),
 ignore_return=True,
                allow_partial_overlap=True,
            ) or is_callable_compatible(
            ) ornotis_callable_compatible(
                other_variant,
                sig_variant,
                is_compat=is_overlapping_types_for_overload,
                is_compat=is_subset_no_promote,
                check_args_covariantly=True,
                is_proper_subtype=False,
 is_compat_return=lambda l, r: not is_subset_no_promote(r, l),
 ignore_return=True,
                allow_partial_overlap=True,
            ):
            )):
                return True
    return False



 def is_overlapping_types_for_overload(left: Type, right: Type) -> bool:
    # For the purpose of unsafe overload checks we consider list[Never] and list[int]
    # non-overlapping. This is consistent with how we treat list[int] and list[str] as
    # non-overlapping, despite [] belongs to both. Also this will prevent false positives
    # for failed type inference during unification.
    return is_overlapping_types(
        left,
        right,
diff --git a/test-data/unit/check-overloading.test b/test-data/unit/check-overloading.test
    def f(self, *args, **kwargs):
        pass
 [builtins fixtures/tuple.pyi]

 [case testSafeOverlapAllowed]
 from lib import *
 [file lib.pyi]
 from typing import overload

 @overload
 def bar(x: object) -> object: ...
 @overload
 def bar(x: int = ...) -> int: ...
Original file line number	Diff line number	Diff line change
Expand Up		@@ -1788,7 +1788,7 @@ def is_unsafe_overlapping_op(

		current_class = self.scope.active_class()
		type_vars = current_class.defn.type_vars if current_class else []
		return is_unsafe_overlapping_overload_signatures(first, second, type_vars)
		return is_unsafe_overlapping_overload_signatures(first, second, type_vars, partial_only=False)

		def check_inplace_operator_method(self, defn: FuncBase) -> None:
		"""Check an inplace operator method such as __iadd__.
Expand DownExpand Up		@@ -7848,7 +7848,8 @@ def expand_callable_variants(c: CallableType) -> list[CallableType]:


		def is_unsafe_overlapping_overload_signatures(
		signature: CallableType, other: CallableType, class_type_vars: list[TypeVarLikeType]
		signature: CallableType, other: CallableType, class_type_vars: list[TypeVarLikeType],
		partial_only: bool = True
		) -> bool:
		"""Check if two overloaded signatures are unsafely overlapping or partially overlapping.

Expand DownExpand Up		@@ -7880,21 +7881,45 @@ def is_unsafe_overlapping_overload_signatures(

		for sig_variant in expand_callable_variants(signature):
		for other_variant in expand_callable_variants(other):
		if is_callable_compatible(
		if is_subset_no_promote(sig_variant.ret_type, other_variant.ret_type):
		continue
		if not (
		is_callable_compatible(
		sig_variant,
		other_variant,
		is_compat=is_overlapping_types_for_overload,
		check_args_covariantly=False,
		is_proper_subtype=False,
		is_compat_return=lambda l, r: not is_subset_no_promote(l, r),
		allow_partial_overlap=True,
		) or is_callable_compatible(
		other_variant,
		sig_variant,
		is_compat=is_overlapping_types_for_overload,
		check_args_covariantly=True,
		is_proper_subtype=False,
		is_compat_return=lambda l, r: not is_subset_no_promote(r, l),
		allow_partial_overlap=True,
		)
		):
		continue
		if not partial_only or (not is_callable_compatible(
		sig_variant,
		other_variant,
		is_compat=is_overlapping_types_for_overload,
		is_compat=is_subset_no_promote,
		check_args_covariantly=False,
		is_proper_subtype=False,
		is_compat_return=lambda l, r: not is_subset_no_promote(l, r),
		ignore_return=True,
		allow_partial_overlap=True,
		) or is_callable_compatible(
		) ornotis_callable_compatible(
		other_variant,
		sig_variant,
		is_compat=is_overlapping_types_for_overload,
		is_compat=is_subset_no_promote,
		check_args_covariantly=True,
		is_proper_subtype=False,
		is_compat_return=lambda l, r: not is_subset_no_promote(r, l),
		ignore_return=True,
		allow_partial_overlap=True,
		):
		)):
		return True
		return False

Expand DownExpand Up		@@ -8391,10 +8416,6 @@ def is_subset_no_promote(left: Type, right: Type) -> bool:


		def is_overlapping_types_for_overload(left: Type, right: Type) -> bool:
		# For the purpose of unsafe overload checks we consider list[Never] and list[int]
		# non-overlapping. This is consistent with how we treat list[int] and list[str] as
		# non-overlapping, despite [] belongs to both. Also this will prevent false positives
		# for failed type inference during unification.
		return is_overlapping_types(
		left,
		right,
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -6705,3 +6705,13 @@ class B:
		def f(self, args, *kwargs):
		pass
		[builtins fixtures/tuple.pyi]

		[case testSafeOverlapAllowed]
		from lib import *
		[file lib.pyi]
		from typing import overload

		@overload
		def bar(x: object) -> object: ...
		@overload
		def bar(x: int = ...) -> int: ...