Play with opposite order for funcitn args

Author: ilevkivskyi

mypy/checker.py

@@ -4706,15 +4706,8 @@ def infer_rvalue_with_fallback_context(
         # There are two cases where we want to try re-inferring r.h.s. in a fallback
         # type context. First case is when redefinitions are allowed, and we got
         # invalid type when using the preferred (empty) type context.
-        redefinition_fallback = (
-            inferred is not None
-            and not inferred.is_argument
-            and not is_valid_inferred_type(rvalue_type, self.options)
-        )
-        # For function arguments the preference order is opposite, and we use errors
-        # during type-checking as the fallback trigger.
-        argument_redefinition_fallback = (
-            inferred is not None and inferred.is_argument and local_errors.has_new_errors()
+        redefinition_fallback = inferred is not None and not is_valid_inferred_type(
+            rvalue_type, self.options
         )
         # Try re-inferring r.h.s. in empty context for union with explicit annotation,
         # and use it results in a narrower type. This helps with various practical
@@ -4726,7 +4719,7 @@ def infer_rvalue_with_fallback_context(
         )
 
         # Skip literal types, as they have special logic (for better errors).
-        try_fallback = redefinition_fallback or union_fallback or argument_redefinition_fallback
+        try_fallback = redefinition_fallback or union_fallback
         if try_fallback and not is_literal_type_like(rvalue_type):
             with (
                 self.msg.filter_errors(save_filtered_errors=True) as alt_local_errors,
@@ -4741,7 +4734,6 @@ def infer_rvalue_with_fallback_context(
                 and (
                     # For redefinition fallback we are fine getting not a subtype.
                     redefinition_fallback
-                    or argument_redefinition_fallback
                     # Skip Any type, since it is special cased in binder.
                     or not isinstance(get_proper_type(alt_rvalue_type), AnyType)
                     and is_proper_subtype(alt_rvalue_type, rvalue_type)
@@ -4790,9 +4782,7 @@ def check_simple_assignment(
                     rvalue, type_context=lvalue_type, always_allow_any=always_allow_any
                 )
             else:
-                # Prefer full type context for function arguments as this reduces
-                # false positives, see issue #19918 for discussion.
-                if inferred is not None and not inferred.is_argument:
+                if inferred is not None:
                     preferred = None
                     fallback = lvalue_type
                 else:

test-data/unit/check-redefine2.test

@@ -1339,3 +1339,28 @@ def process3(items: list[str]) -> None:
         reveal_type(items)  # N: Revealed type is "builtins.list[builtins.str]"
     reveal_type(items)  # N: Revealed type is "builtins.list[builtins.str]"
 [builtins fixtures/primitives.pyi]
+
+[case testNewRedefineHasAttr]
+# flags: --allow-redefinition-new --local-partial-types
+
+def test(lst: list[object]) -> None:
+    for cls in lst:
+        if not hasattr(cls, "module"):
+            break
+        reveal_type(cls.module)  # N: Revealed type is "Any"
+
+[case testNewRedefineOldAnySpecialCasing]
+# flags: --allow-redefinition-new --local-partial-types
+from typing import Any
+    a: Any
+    x = 1
+    if bool():
+        x = a
+    reveal_type(x)  # N: Revealed type is "builtins.int"
+
+    if bool():
+        y = a
+    else:
+        y = 1
+    reveal_type(y)  # N: Revealed type is "Any"
+[builtins fixtures/isinstancelist.pyi]

test-data/unit/fixtures/isinstancelist.pyi

@@ -18,6 +18,7 @@ Ellipsis = ellipsis()
 
 def isinstance(x: object, t: Union[type, Tuple]) -> bool: pass
 def issubclass(x: object, t: Union[type, Tuple]) -> bool: pass
+def hasattr(x: object, name: str) -> bool: pass
 
 class int:
     def __add__(self, x: int) -> int: pass