Do not overuse current_node_deferred flag

Author: ilevkivskyi

mypy/checker.py

@@ -1512,11 +1512,7 @@ def check_func_def(
                 )
 
                 if self.options.warn_no_return:
-                    if (
-                        not self.current_node_deferred
-                        and not isinstance(return_type, (NoneType, AnyType))
-                        and show_error
-                    ):
+                    if not isinstance(return_type, (NoneType, AnyType)) and show_error:
                         # Control flow fell off the end of a function that was
                         # declared to return a non-None type.
                         if isinstance(return_type, UninhabitedType):
@@ -3128,7 +3124,6 @@ def should_report_unreachable_issues(self) -> bool:
         return (
             self.in_checked_function()
             and self.options.warn_unreachable
-            and not self.current_node_deferred
             and not self.binder.is_unreachable_warning_suppressed()
         )
 
@@ -5092,6 +5087,9 @@ def visit_try_without_finally(self, s: TryStmt, try_frame: bool) -> None:
                                 # To support local variables, we make this a definition line,
                                 # causing assignment to set the variable's type.
                                 var.is_inferred_def = True
+                                # In case current node was deferred, start from blank slate.
+                                if isinstance(var.node, Var):
+                                    var.node.type = None
                                 self.check_assignment(var, self.temp_node(t, var))
                         self.accept(s.handlers[i])
                         var = s.vars[i]

mypy/checkexpr.py

@@ -2865,7 +2865,7 @@ def infer_overload_return_type(
         matches: list[CallableType] = []
         return_types: list[Type] = []
         inferred_types: list[Type] = []
-        args_contain_any = any(map(has_any_type, arg_types))
+        args_contain_any = any(has_any_type(a, include_special_form=True) for a in arg_types)
         type_maps: list[dict[Expression, Type]] = []
 
         for typ in plausible_targets:
@@ -5977,7 +5977,7 @@ def accept(
         ):
             self.msg.disallowed_any_type(typ, node)
 
-        if not self.chk.in_checked_function() or self.chk.current_node_deferred:
+        if not self.chk.in_checked_function():
             result: Type = AnyType(TypeOfAny.unannotated)
         else:
             result = typ
@@ -6311,19 +6311,29 @@ def has_abstract_type(self, caller_type: ProperType, callee_type: ProperType) ->
         )
 
 
-def has_any_type(t: Type, ignore_in_type_obj: bool = False) -> bool:
+def has_any_type(
+    t: Type, ignore_in_type_obj: bool = False, include_special_form: bool = False
+) -> bool:
     """Whether t contains an Any type"""
-    return t.accept(HasAnyType(ignore_in_type_obj))
+    return t.accept(HasAnyType(ignore_in_type_obj, include_special_form))
 
 
 class HasAnyType(types.BoolTypeQuery):
-    def __init__(self, ignore_in_type_obj: bool) -> None:
+    def __init__(self, ignore_in_type_obj: bool, include_special_form: bool) -> None:
         super().__init__(types.ANY_STRATEGY)
         self.ignore_in_type_obj = ignore_in_type_obj
+        self.include_special_form = include_special_form
 
     def visit_any(self, t: AnyType) -> bool:
+        if self.include_special_form:
+            return True
         return t.type_of_any != TypeOfAny.special_form  # special forms are not real Any types
 
+    def visit_tuple_type(self, t: TupleType) -> bool:
+        # TODO: should we use tuple_fallback() in (Bool)TypeQuery itself?
+        # Using partial_fallback is error prone as it may be bogus (hence the name).
+        return self.query_types(t.items + [tuple_fallback(t)])
+
     def visit_callable_type(self, t: CallableType) -> bool:
         if self.ignore_in_type_obj and t.is_type_obj():
             return False
@@ -6547,7 +6557,7 @@ def any_causes_overload_ambiguity(
         # We ignore Anys in type object callables as ambiguity
         # creators, since that can lead to falsely claiming ambiguity
         # for overloads between Type and Callable.
-        if has_any_type(arg_type, ignore_in_type_obj=True):
+        if has_any_type(arg_type, ignore_in_type_obj=True, include_special_form=True):
             matching_formals_unfiltered = [
                 (item_idx, lookup[arg_idx])
                 for item_idx, lookup in enumerate(actual_to_formal)

mypy/plugins/proper_plugin.py

@@ -58,8 +58,9 @@ def isinstance_proper_hook(ctx: FunctionContext) -> Type:
 
     right = get_proper_type(ctx.arg_types[1][0])
     for arg in ctx.arg_types[0]:
+        p_arg = get_proper_type(arg)
         if (
-            is_improper_type(arg) or isinstance(get_proper_type(arg), AnyType)
+            is_improper_type(arg) or isinstance(p_arg, AnyType) and not p_arg.is_special_form
         ) and is_dangerous_target(right):
             if is_special_target(right):
                 return ctx.default_return_type

mypy/types.py

@@ -1160,6 +1160,15 @@ def __init__(
     def is_from_error(self) -> bool:
         return self.type_of_any == TypeOfAny.from_error
 
+    @property
+    def is_special_form(self) -> bool:
+        if self.type_of_any == TypeOfAny.special_form:
+            return True
+        if self.type_of_any == TypeOfAny.from_another_any:
+            assert self.source_any is not None
+            return self.source_any.type_of_any == TypeOfAny.special_form
+        return False
+
     def accept(self, visitor: TypeVisitor[T]) -> T:
         return visitor.visit_any(self)
 

test-data/unit/check-overloading.test

@@ -5219,7 +5219,7 @@ _R = TypeVar('_R')
 @overload
 def partial(__func: Callable[[_T], _S], __arg: _T) -> Callable[[], _S]: ...
 @overload
-def partial(__func: Callable[[_T, _S], _S], __arg: _T) -> Callable[[_S], _R]: ...
+def partial(__func: Callable[[_T, _S], _R], __arg: _T) -> Callable[[_S], _R]: ...
 def partial(*args: Any) -> Any:
     pass