check if current_type is AnyType

Author: randolf-scholz

mypy/checker.py

@@ -7994,11 +7994,13 @@ def conditional_types(
 ) -> tuple[Type | None, Type | None]:
     """Takes in the current type and a proposed type of an expression.
 
-    Returns a 2-tuple: The first element is the proposed type, if the expression
-    can be the proposed type. The second element is the type it would hold
-    if it was not the proposed type, if any. UninhabitedType means unreachable.
-    None means no new information can be inferred. If default is set it is returned
-    instead."""
+    Returns a 2-tuple:
+        The first element is the proposed type, if the expression can be the proposed type.
+        The second element is the type it would hold if it was not the proposed type, if any.
+        UninhabitedType means unreachable.
+        None means no new information can be inferred.
+        If default is set it is returned instead.
+    """
     if proposed_type_ranges:
         if len(proposed_type_ranges) == 1:
             target = proposed_type_ranges[0].item
@@ -8010,24 +8012,26 @@ def conditional_types(
                 current_type = try_expanding_sum_type_to_union(current_type, enum_name)
         proposed_items = [type_range.item for type_range in proposed_type_ranges]
         proposed_type = make_simplified_union(proposed_items)
-        if isinstance(proposed_type, AnyType):
+        current_type = get_proper_type(current_type)
+        if isinstance(proposed_type, AnyType) or isinstance(current_type, AnyType):
             # We don't really know much about the proposed type, so we shouldn't
             # attempt to narrow anything. Instead, we broaden the expr to Any to
             # avoid false positives
             return proposed_type, default
-        elif not any(
+        elif not any(  #  handle concrete subtypes
             type_range.is_upper_bound for type_range in proposed_type_ranges
-        ) and (  # concrete subtypes
-            is_proper_subtype(current_type, proposed_type, ignore_promotions=True)
-            or (  # structural subtypes
-                is_subtype(current_type, proposed_type, ignore_promotions=True)
-                and (
-                    isinstance(proposed_type, CallableType)
-                    or (isinstance(proposed_type, Instance) and proposed_type.type.is_protocol)
-                )
+        ) and is_proper_subtype(current_type, proposed_type, ignore_promotions=True):
+            # Expression is always of one of the types in proposed_type_ranges
+            return default, UninhabitedType()
+        elif not any(  # handle structural subtypes
+            type_range.is_upper_bound for type_range in proposed_type_ranges
+        ) and (
+            is_subtype(current_type, proposed_type, ignore_promotions=True)
+            and (
+                isinstance(proposed_type, CallableType)
+                or (isinstance(proposed_type, Instance) and proposed_type.type.is_protocol)
             )
         ):
-            # Expression is always of one of the types in proposed_type_ranges
             return default, UninhabitedType()
         elif not is_overlapping_types(current_type, proposed_type, ignore_promotions=True):
             # Expression is never of any type in proposed_type_ranges

test-data/unit/check-generic-alias.test

@@ -149,6 +149,38 @@ t23: collections.abc.ValuesView[str]
 # reveal_type(t23)  # Nx Revealed type is "collections.abc.ValuesView[builtins.str]"
 [builtins fixtures/tuple.pyi]
 
+[case testGenericAliasIsinstanceUnreachable]
+# flags: --warn-unreachable --python-version 3.10
+from collections.abc import Iterable
+
+class A: ...
+
+def test(dependencies: list[A] | None) -> None:
+    if dependencies is None:
+        dependencies = []
+    elif not isinstance(dependencies, Iterable):
+        dependencies = [dependencies]  # E: Statement is unreachable
+
+[builtins fixtures/isinstancelist.pyi]
+[typing fixtures/typing-full.pyi]
+
+[case testGenericAliasRedundantExprCompoundIfExpr]
+# flags: --warn-unreachable --enable-error-code=redundant-expr --python-version 3.10
+
+from typing import Any, reveal_type
+from collections.abc import Iterable
+
+def test_example(x: Iterable[Any]) -> None:
+    if isinstance(x, Iterable) and not isinstance(x, str):  # E: Left operand of "and" is always true
+        reveal_type(x)  # N: Revealed type is "typing.Iterable[Any]"
+
+def test_counterexample(x: Any) -> None:
+    if isinstance(x, Iterable) and not isinstance(x, str):
+        reveal_type(x)  # N: Revealed type is "typing.Iterable[Any]"
+
+[builtins fixtures/isinstancelist.pyi]
+[typing fixtures/typing-full.pyi]
+
 
 [case testGenericBuiltinTupleTyping]
 from typing import Tuple

test-data/unit/check-isinstance.test

@@ -1086,21 +1086,6 @@ while bool():
     x + 'a'
 [builtins fixtures/isinstance.pyi]
 
-[case testUnreachableCode3]
-# flags: --warn-unreachable --python-version 3.10
-from collections.abc import Iterable
-
-class A: ...
-
-def test(dependencies: list[A] | None) -> None:
-    if dependencies is None:
-        dependencies = []
-    elif not isinstance(dependencies, Iterable):
-        dependencies = [dependencies]  # E: Statement is unreachable
-
-[builtins fixtures/isinstancelist.pyi]
-[typing fixtures/typing-full.pyi]
-
 [case testUnreachableWhileTrue]
 def f(x: int) -> None:
     while True: