binder experiment

Author: hauntsaninja

mypy/binder.py

@@ -28,7 +28,6 @@
     ProperType,
     TupleType,
     Type,
-    TypeOfAny,
     TypeType,
     TypeVarType,
     UnionType,
@@ -73,6 +72,7 @@ class Frame:
     def __init__(self, id: int, conditional_frame: bool = False) -> None:
         self.id = id
         self.types: dict[Key, CurrentType] = {}
+        self.conditionally_narrowed_keys: set[Key] = set()
         self.unreachable = False
         self.conditional_frame = conditional_frame
         self.suppress_unreachable_warnings = False
@@ -301,8 +301,6 @@ def update_from_options(self, frames: list[Frame]) -> bool:
         """Update the frame to reflect that each key will be updated
         as in one of the frames.  Return whether any item changes.
 
-        If a key is declared as AnyType, only update it if all the
-        options are the same.
         """
         all_reachable = all(not f.unreachable for f in frames)
         if not all_reachable:
@@ -328,9 +326,9 @@ def update_from_options(self, frames: list[Frame]) -> bool:
                 # know anything about key in at least one possible frame.
                 continue
 
-            resulting_values = [x for x in resulting_values if x is not None]
+            filtered_resulting_values = [x for x in resulting_values if x is not None]
 
-            if all_reachable and all(not x.from_assignment for x in resulting_values):
+            if all_reachable and all(not x.from_assignment for x in filtered_resulting_values):
                 # Do not synthesize a new type if we encountered a conditional block
                 # (if, while or match-case) without assignments.
                 # See check-isinstance.test::testNoneCheckDoesNotMakeTypeVarOptional
@@ -342,57 +340,43 @@ def update_from_options(self, frames: list[Frame]) -> bool:
             # a micro-optimization for --allow-redefinition-new.
             seen_types = set()
             resulting_types = []
-            for rv in resulting_values:
-                assert rv is not None
+            for rv in filtered_resulting_values:
                 if rv.type in seen_types:
                     continue
                 resulting_types.append(rv.type)
                 seen_types.add(rv.type)
 
-            type = resulting_types[0]
-            declaration_type = get_proper_type(self.declarations.get(key))
-            if isinstance(declaration_type, AnyType):
-                # At this point resulting values can't contain None, see continue above
-                if not all(is_same_type(type, t) for t in resulting_types[1:]):
-                    type = AnyType(TypeOfAny.from_another_any, source_any=declaration_type)
+            declaration_type = self.declarations.get(key)
+            if len(resulting_types) == 1:
+                # This is to avoid calling get_proper_type() unless needed, as this may
+                # interfere with our (hacky) TypeGuard support.
+                type = resulting_types[0]
             else:
-                possible_types = []
-                for t in resulting_types:
-                    assert t is not None
-                    possible_types.append(t)
-                if len(possible_types) == 1:
-                    # This is to avoid calling get_proper_type() unless needed, as this may
-                    # interfere with our (hacky) TypeGuard support.
-                    type = possible_types[0]
-                else:
-                    type = make_simplified_union(possible_types)
-                    # Legacy guard for corner case when the original type is TypeVarType.
-                    if isinstance(declaration_type, TypeVarType) and not is_subtype(
-                        type, declaration_type
-                    ):
-                        type = declaration_type
-                    # Try simplifying resulting type for unions involving variadic tuples.
-                    # Technically, everything is still valid without this step, but if we do
-                    # not do this, this may create long unions after exiting an if check like:
-                    #     x: tuple[int, ...]
-                    #     if len(x) < 10:
-                    #         ...
-                    # We want the type of x to be tuple[int, ...] after this block (if it is
-                    # still equivalent to such type).
-                    if isinstance(type, UnionType):
-                        type = collapse_variadic_union(type)
-                    if (
-                        old_semantics
-                        and isinstance(type, ProperType)
-                        and isinstance(type, UnionType)
-                    ):
-                        # Simplify away any extra Any's that were added to the declared
-                        # type when popping a frame.
-                        simplified = UnionType.make_union(
-                            [t for t in type.items if not isinstance(get_proper_type(t), AnyType)]
-                        )
-                        if simplified == self.declarations[key]:
-                            type = simplified
+                type = make_simplified_union(resulting_types)
+                # Legacy guard for corner case when the original type is TypeVarType.
+                proper_declaration_type = get_proper_type(declaration_type)
+                if isinstance(proper_declaration_type, TypeVarType) and not is_subtype(
+                    type, proper_declaration_type
+                ):
+                    type = proper_declaration_type
+                # Try simplifying resulting type for unions involving variadic tuples.
+                # Technically, everything is still valid without this step, but if we do
+                # not do this, this may create long unions after exiting an if check like:
+                #     x: tuple[int, ...]
+                #     if len(x) < 10:
+                #         ...
+                # We want the type of x to be tuple[int, ...] after this block (if it is
+                # still equivalent to such type).
+                if isinstance(type, UnionType):
+                    type = collapse_variadic_union(type)
+                if old_semantics and isinstance(type, ProperType) and isinstance(type, UnionType):
+                    # Simplify away any extra Any's that were added to the declared
+                    # type when popping a frame.
+                    simplified = UnionType.make_union(
+                        [t for t in type.items if not isinstance(get_proper_type(t), AnyType)]
+                    )
+                    if simplified == self.declarations[key]:
+                        type = simplified
             if (
                 current_value is None
                 or not is_same_type(type, current_value.type)
@@ -482,6 +466,8 @@ def assign_type(self, expr: Expression, type: Type, declared_type: Type | None)
             return
         if not literal(expr):
             return
+        key = literal_hash(expr)
+        assert key is not None
         self.invalidate_dependencies(expr)
 
         if declared_type is None:
@@ -530,6 +516,8 @@ def assign_type(self, expr: Expression, type: Type, declared_type: Type | None)
             # has an explicit `Any` type annotation.
             if isinstance(expr, RefExpr) and isinstance(expr.node, Var) and expr.node.is_inferred:
                 self.put(expr, type)
+            elif any(key in f.conditionally_narrowed_keys for f in self.frames):
+                self.put(expr, type)
             else:
                 self.put(expr, declared_type)
         else:
@@ -553,6 +541,16 @@ def invalidate_dependencies(self, expr: BindableExpression) -> None:
         for dep in self.dependencies.get(key, set()):
             self._cleanse_key(dep)
 
+    def record_conditional_type_map(self, type_map: dict[Expression, Type] | None) -> None:
+        """Record expressions that are mentioned by the active conditional."""
+        if type_map is None:
+            return
+        for expr in type_map:
+            if self.can_put_directly(expr):
+                key = literal_hash(expr)
+                assert key is not None
+                self.frames[-1].conditionally_narrowed_keys.add(key)
+
     def allow_jump(self, index: int) -> None:
         # self.frames and self.options_on_return have different lengths
         # so make sure the index is positive

mypy/checker.py

@@ -5172,6 +5172,8 @@ def visit_if_stmt(self, s: IfStmt) -> None:
                     self.msg.deleted_as_rvalue(t, s)
 
                 if_map, else_map = self.find_isinstance_check(e)
+                self.binder.record_conditional_type_map(if_map)
+                self.binder.record_conditional_type_map(else_map)
 
                 s.unreachable_else = is_unreachable_map(else_map)
 

test-data/unit/check-isinstance.test

@@ -2102,7 +2102,7 @@ def narrow_any_to_str_then_reassign_to_int() -> None:
     if isinstance(v, str):
         reveal_type(v)  # N: Revealed type is "builtins.str"
         v = 2
-        reveal_type(v)  # N: Revealed type is "Any"
+        reveal_type(v)  # N: Revealed type is "builtins.int"
 [builtins fixtures/isinstance.pyi]
 
 [case testIsinstanceNarrowAnyImplicit]

test-data/unit/check-narrowing.test

@@ -3131,6 +3131,55 @@ def main(key: str):
         reveal_type(existing_value_type(Box2("str")))  # N: Revealed type is "__main__.TupleLike[builtins.str] | Any"
 [builtins fixtures/tuple.pyi]
 
+[case testNarrowingDynamicAnyMemberAssignment]
+from enum import Enum
+from typing import Any
+
+class Fruit(Enum):
+    APPLE = 1
+    ORANGE = 2
+
+def f(a: Any, x: Any, y: Any) -> None:
+    if x is not list:
+        x = []
+    reveal_type(x)  # N: Revealed type is "builtins.list[Any] | Overload(def [T] () -> builtins.list[T`1], def [T] (x: typing.Iterable[T`1]) -> builtins.list[T`1])"
+
+    if y is list:
+        pass
+    else:
+        y = []
+    reveal_type(y)  # N: Revealed type is "Overload(def [T] () -> builtins.list[T`1], def [T] (x: typing.Iterable[T`1]) -> builtins.list[T`1]) | builtins.list[Any]"
+
+    if a.foo is not list:
+        a.foo = []
+    reveal_type(a.foo)  # N: Revealed type is "builtins.list[Any] | Overload(def [T] () -> builtins.list[T`1], def [T] (x: typing.Iterable[T`1]) -> builtins.list[T`1])"
+    a.foo.append(x)  # E: Missing positional argument "self" in call to "append" of "list"
+
+    if a.baz is list:
+        pass
+    else:
+        a.baz = []
+    reveal_type(a.baz)  # N: Revealed type is "Overload(def [T] () -> builtins.list[T`1], def [T] (x: typing.Iterable[T`1]) -> builtins.list[T`1]) | builtins.list[Any]"
+
+    if a.bar is not Fruit.APPLE:
+        a.bar = []
+    reveal_type(a.bar)  # N: Revealed type is "builtins.list[Any] | Literal[__main__.Fruit.APPLE]"
+[builtins fixtures/list.pyi]
+
+[case testNarrowingExplicitAnyMemberAssignment]
+from typing import Any
+
+class A:
+    foo: Any
+
+def f(a: A) -> None:
+    if a.foo is not list:
+        a.foo = []
+    reveal_type(a.foo)  # N: Revealed type is "builtins.list[Any] | Overload(def [T] () -> builtins.list[T`1], def [T] (x: typing.Iterable[T`1]) -> builtins.list[T`1])"
+    a.foo.append(1)  # E: Missing positional argument "x" in call to "append" of "list" \
+                     # E: Argument 1 to "append" of "list" has incompatible type "int"; expected "list[Never]"
+[builtins fixtures/list.pyi]
+
 [case testNarrowingCollections]
 # flags: --strict-equality --warn-unreachable
 from typing import cast