Allow del to clear type info for local inferred variables (fixes #10005)

Author: brxno3107

mypy/checker.py

@@ -5225,9 +5225,22 @@ def visit_del_stmt(self, s: DelStmt) -> None:
             s.expr.accept(self.expr_checker)
             for elt in flatten(s.expr):
                 if isinstance(elt, NameExpr):
-                    self.binder.assign_type(
-                        elt, DeletedType(source=elt.name), get_declaration(elt)
-                    )
+                    # For local variables, completely remove type binding to allow reuse
+                    if (isinstance(elt.node, Var) and 
+                        elt.node.is_inferred and 
+                        not elt.node.is_property and
+                        not elt.node.is_classvar and
+                        elt.node.is_local):
+                        # Completely remove the variable from type tracking
+                        self.binder.cleanse(elt)
+                        # Also remove from type map if present
+                        if hasattr(self, 'type_map') and elt in self.type_map:
+                            del self.type_map[elt]
+                    else:
+                        # For non-local variables, use the existing DeletedType behavior
+                        self.binder.assign_type(
+                            elt, DeletedType(source=elt.name), get_declaration(elt)
+                        )
 
     def visit_decorator(self, e: Decorator) -> None:
         for d in e.decorators:
@@ -5306,7 +5319,7 @@ def visit_decorator_inner(
                 self.fail(message_registry.BAD_CONSTRUCTOR_TYPE, e)
 
         if e.func.original_def and isinstance(sig, FunctionLike):
-            # Function definition overrides function definition.
+            # Function signature processing continues herection definition overrides function definition.
             self.check_func_def_override(e.func, sig)
 
     def check_for_untyped_decorator(

test-data/unit/check-del-reuse.test

@@ -0,0 +1,37 @@
+[case testDelVariableReuse]
+def test_del_reuse() -> None:
+    x = 1
+    reveal_type(x)  # N: Revealed type is "builtins.int"
+    del x
+    x = "hello"
+    reveal_type(x)  # N: Revealed type is "builtins.str"
+
+[case testDelVariableReuseConditional]
+def test_del_conditional() -> None:
+    x = 1
+    if True:
+        del x
+        x = "hello"
+        reveal_type(x)  # N: Revealed type is "builtins.str"
+
+[case testDelVariableNotLocal]
+x = 1
+def test_del_global() -> None:
+    global x
+    del x
+    x = "hello"  # E: Incompatible types in assignment (expression has type "str", variable has type "int")
+
+[case testDelIndexExpr]
+def test_del_index() -> None:
+    d = {"key": 1}
+    del d["key"]
+    d["key"] = "hello"  # OK - this should work normally
+
+[case testDelAttribute]
+class C:
+    attr: int = 1
+
+def test_del_attr() -> None:
+    c = C()
+    del c.attr
+    c.attr = "hello"  # E: Incompatible types in assignment (expression has type "str", target has type "int")

test-data/unit/check-del-variable-type.test

@@ -0,0 +1,42 @@
+[case testDelVariableResetsType]
+def test_del_resets_type() -> None:
+    x = 42  # x: int
+    del x
+    x = "hello"  # Should not error - x can now be str
+    reveal_type(x)  # N: Revealed type is "builtins.str"
+
+[case testDelVariableInBranch]
+def test_del_in_branch(cond: bool) -> None:
+    x = 42  # x: int
+    if cond:
+        del x
+        x = "hello"  # Should not error in this branch
+    else:
+        reveal_type(x)  # N: Revealed type is "builtins.int"
+
+[case testDelVariableNotLocal]
+class C:
+    attr: int = 42
+
+def test_del_not_local() -> None:
+    c = C()
+    del c.attr  # Should use DeletedType behavior, not reset
+    # This should still be treated as deleted, not reset
+
+[case testDelVariableExplicitType]
+def test_del_explicit_type() -> None:
+    x: int = 42
+    del x
+    x = "hello"  # Should still error - explicit type annotation
+    [out]
+main:4: error: Incompatible types in assignment (expression has type "str", variable has type "int")
+
+[case testDelVariableMultiple]
+def test_del_multiple() -> None:
+    x = 42
+    y = "hello"
+    del x, y
+    x = "world"  # Should not error
+    y = 123     # Should not error
+    reveal_type(x)  # N: Revealed type is "builtins.str"
+    reveal_type(y)  # N: Revealed type is "builtins.int"