From e5e24305aa91ba3c619d8f8cd289bce3f9c0629e Mon Sep 17 00:00:00 2001
From: VallinZ <107499985+VallinZ@users.noreply.github.com>
Date: Wed, 30 Apr 2025 09:20:16 -0400
Subject: [PATCH] Revert "Attempt to fix distribute Tuple issue "

---
 mypy/subtypes.py | 42 +-----------------------------------------
 1 file changed, 1 insertion(+), 41 deletions(-)

diff --git a/mypy/subtypes.py b/mypy/subtypes.py
index 850853fc23ae..71b8b0ba59f5 100644
--- a/mypy/subtypes.py
+++ b/mypy/subtypes.py
@@ -185,8 +185,6 @@ def is_subtype(
         # steps we come back to initial call is_subtype(A, B) and immediately return True.
         with pop_on_exit(type_state.get_assumptions(is_proper=False), left, right):
             return _is_subtype(left, right, subtype_context, proper_subtype=False)
-    left = get_proper_type(left)
-    right = get_proper_type(right)
     return _is_subtype(left, right, subtype_context, proper_subtype=False)
 
 
@@ -284,21 +282,6 @@ def is_same_type(
     )
 
 
-# This is a helper function used to check for recursive type of distributed tuple
-def is_structurally_recursive(typ: Type, seen: set[Type] | None = None) -> bool:
-    if seen is None:
-        seen = set()
-    typ = get_proper_type(typ)
-    if typ in seen:
-        return True
-    seen.add(typ)
-    if isinstance(typ, UnionType):
-        return any(is_structurally_recursive(item, seen.copy()) for item in typ.items)
-    if isinstance(typ, TupleType):
-        return any(is_structurally_recursive(item, seen.copy()) for item in typ.items)
-    return False
-
-
 # This is a common entry point for subtyping checks (both proper and non-proper).
 # Never call this private function directly, use the public versions.
 def _is_subtype(
@@ -320,30 +303,7 @@ def _is_subtype(
         # TODO: should we consider all types proper subtypes of UnboundType and/or
         # ErasedType as we do for non-proper subtyping.
         return True
-    if isinstance(left, TupleType) and isinstance(right, UnionType):
-        # check only if not recursive type because if recursive type,
-        # test run into maximum recursive depth reached
-        if not is_structurally_recursive(left) and not is_structurally_recursive(right):
-            fallback = left.partial_fallback
-            tuple_items = left.items
-            if hasattr(left, "fallback") and left.fallback is not None:
-                fallback = left.fallback
-            for i in range(len(tuple_items)):
-                uitems = tuple_items[i]
-                uitems_type = get_proper_type(uitems)
-                if isinstance(uitems_type, UnionType):
-                    new_tuples = [
-                        TupleType(
-                            tuple_items[:i] + [uitem] + tuple_items[i + 1 :], fallback=fallback
-                        )
-                        for uitem in uitems_type.items
-                    ]
-                    result = [
-                        _is_subtype(t, right, subtype_context, proper_subtype=False)
-                        for t in new_tuples
-                    ]
-                    inverted_list = [not item for item in result]
-                    return not any(inverted_list)
+
     if isinstance(right, UnionType) and not isinstance(left, UnionType):
         # Normally, when 'left' is not itself a union, the only way
         # 'left' can be a subtype of the union 'right' is if it is a