Revert "Play with opposite order for funcitn args"

This reverts commit bd2f420.

Author: ilevkivskyi

mypy/checker.py

@@ -4706,8 +4706,15 @@ 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 is_valid_inferred_type(
-            rvalue_type, self.options
+        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()
         )
         # 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
@@ -4719,7 +4726,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
+        try_fallback = redefinition_fallback or union_fallback or argument_redefinition_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,
@@ -4734,6 +4741,7 @@ 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)
@@ -4782,7 +4790,9 @@ def check_simple_assignment(
                     rvalue, type_context=lvalue_type, always_allow_any=always_allow_any
                 )
             else:
-                if inferred is not None:
+                # 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:
                     preferred = None
                     fallback = lvalue_type
                 else:

test-data/unit/check-redefine2.test

@@ -1339,28 +1339,3 @@ 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,7 +18,6 @@ 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