Delete sametypes.py (#13311)

Fixes #7924

So this is not 100% refactor, I make several semantic changes. As discussed in the issue, current implementation is not very principled, so I replace old complex logic with two options:
* New `is_same_types()` is now located in `subtypes.py` and is doing two-way proper subtyping check.
* Type equality with `==` can be used when we are checking for representation equality (used rarely, mostly for internal things)

Btw this uncovered two actual bugs, one of which I fix here (two-line change), and leave a TODO for the second.

Author: ilevkivskyi

mypy/applytype.py

@@ -1,6 +1,5 @@
 from typing import Callable, Dict, Optional, Sequence
 
-import mypy.sametypes
 import mypy.subtypes
 from mypy.expandtype import expand_type
 from mypy.nodes import Context
@@ -41,7 +40,7 @@ def get_target_type(
         if isinstance(type, TypeVarType) and type.values:
             # Allow substituting T1 for T if every allowed value of T1
             # is also a legal value of T.
-            if all(any(mypy.sametypes.is_same_type(v, v1) for v in values) for v1 in type.values):
+            if all(any(mypy.subtypes.is_same_type(v, v1) for v in values) for v1 in type.values):
                 return type
         matching = []
         for value in values:

mypy/binder.py

@@ -8,8 +8,7 @@
 from mypy.join import join_simple
 from mypy.literals import Key, literal, literal_hash, subkeys
 from mypy.nodes import AssignmentExpr, Expression, IndexExpr, MemberExpr, NameExpr, RefExpr, Var
-from mypy.sametypes import is_same_type
-from mypy.subtypes import is_subtype
+from mypy.subtypes import is_same_type, is_subtype
 from mypy.types import AnyType, NoneType, PartialType, Type, TypeOfAny, UnionType, get_proper_type
 
 BindableExpression: _TypeAlias = Union[IndexExpr, MemberExpr, AssignmentExpr, NameExpr]

mypy/checker.py

@@ -133,7 +133,6 @@
 )
 from mypy.options import Options
 from mypy.plugin import CheckerPluginInterface, Plugin
-from mypy.sametypes import is_same_type
 from mypy.scope import Scope
 from mypy.semanal import is_trivial_body, refers_to_fullname, set_callable_name
 from mypy.semanal_enum import ENUM_BASES, ENUM_SPECIAL_PROPS
@@ -145,6 +144,7 @@
     is_equivalent,
     is_more_precise,
     is_proper_subtype,
+    is_same_type,
     is_subtype,
     restrict_subtype_away,
     unify_generic_callable,

mypy/checkexpr.py

@@ -95,10 +95,9 @@
     MethodSigContext,
     Plugin,
 )
-from mypy.sametypes import is_same_type
 from mypy.semanal_enum import ENUM_BASES
 from mypy.state import state
-from mypy.subtypes import is_equivalent, is_subtype, non_method_protocol_members
+from mypy.subtypes import is_equivalent, is_same_type, is_subtype, non_method_protocol_members
 from mypy.traverser import has_await_expression
 from mypy.typeanal import (
     check_for_explicit_any,
@@ -3561,7 +3560,7 @@ def visit_cast_expr(self, expr: CastExpr) -> Type:
         if (
             options.warn_redundant_casts
             and not isinstance(get_proper_type(target_type), AnyType)
-            and is_same_type(source_type, target_type)
+            and source_type == target_type
         ):
             self.msg.redundant_cast(target_type, expr)
         if options.disallow_any_unimported and has_any_from_unimported_type(target_type):

mypy/constraints.py

@@ -4,13 +4,12 @@
 
 from typing_extensions import Final
 
-import mypy.sametypes
 import mypy.subtypes
 import mypy.typeops
 from mypy.argmap import ArgTypeExpander
 from mypy.erasetype import erase_typevars
 from mypy.maptype import map_instance_to_supertype
-from mypy.nodes import CONTRAVARIANT, COVARIANT, ArgKind
+from mypy.nodes import ARG_OPT, ARG_POS, CONTRAVARIANT, COVARIANT, ArgKind
 from mypy.types import (
     TUPLE_LIKE_INSTANCE_NAMES,
     AnyType,
@@ -141,7 +140,9 @@ def infer_constraints(template: Type, actual: Type, direction: int) -> List[Cons
 
     The constraints are represented as Constraint objects.
     """
-    if any(get_proper_type(template) == get_proper_type(t) for t in TypeState._inferring):
+    if any(
+        get_proper_type(template) == get_proper_type(t) for t in reversed(TypeState._inferring)
+    ):
         return []
     if isinstance(template, TypeAliasType) and template.is_recursive:
         # This case requires special care because it may cause infinite recursion.
@@ -341,7 +342,7 @@ def is_same_constraint(c1: Constraint, c2: Constraint) -> bool:
     return (
         c1.type_var == c2.type_var
         and (c1.op == c2.op or skip_op_check)
-        and mypy.sametypes.is_same_type(c1.target, c2.target)
+        and mypy.subtypes.is_same_type(c1.target, c2.target)
     )
 
 
@@ -474,9 +475,7 @@ def visit_instance(self, template: Instance) -> List[Constraint]:
         if isinstance(actual, (CallableType, Overloaded)) and template.type.is_protocol:
             if template.type.protocol_members == ["__call__"]:
                 # Special case: a generic callback protocol
-                if not any(
-                    mypy.sametypes.is_same_type(template, t) for t in template.type.inferring
-                ):
+                if not any(template == t for t in template.type.inferring):
                     template.type.inferring.append(template)
                     call = mypy.subtypes.find_member(
                         "__call__", template, actual, is_operator=True
@@ -635,7 +634,7 @@ def visit_instance(self, template: Instance) -> List[Constraint]:
                 # Note that we use is_protocol_implementation instead of is_subtype
                 # because some type may be considered a subtype of a protocol
                 # due to _promote, but still not implement the protocol.
-                not any(mypy.sametypes.is_same_type(template, t) for t in template.type.inferring)
+                not any(template == t for t in reversed(template.type.inferring))
                 and mypy.subtypes.is_protocol_implementation(instance, erased)
             ):
                 template.type.inferring.append(template)
@@ -651,7 +650,7 @@ def visit_instance(self, template: Instance) -> List[Constraint]:
                 and self.direction == SUBTYPE_OF
                 and
                 # We avoid infinite recursion for structural subtypes also here.
-                not any(mypy.sametypes.is_same_type(instance, i) for i in instance.type.inferring)
+                not any(instance == i for i in reversed(instance.type.inferring))
                 and mypy.subtypes.is_protocol_implementation(erased, instance)
             ):
                 instance.type.inferring.append(instance)
@@ -734,6 +733,8 @@ def visit_callable_type(self, template: CallableType) -> List[Constraint]:
                 cactual_ps = cactual.param_spec()
 
                 if not cactual_ps:
+                    max_prefix_len = len([k for k in cactual.arg_kinds if k in (ARG_POS, ARG_OPT)])
+                    prefix_len = min(prefix_len, max_prefix_len)
                     res.append(
                         Constraint(
                             param_spec.id,

mypy/messages.py

@@ -62,13 +62,13 @@
     reverse_builtin_aliases,
 )
 from mypy.operators import op_methods, op_methods_to_symbols
-from mypy.sametypes import is_same_type
 from mypy.subtypes import (
     IS_CLASS_OR_STATIC,
     IS_CLASSVAR,
     IS_SETTABLE,
     find_member,
     get_member_flags,
+    is_same_type,
     is_subtype,
 )
 from mypy.typeops import separate_union_literals