Deleted types

Add DeletedType.

Support local try/except variables.

Improvements to error messages for deleted types.

Also remove some useless code. I wrote this code during hack week, but
I don't think it serves any purpose: I was just confused.

Author: ecprice

mypy/checker.py

@@ -29,7 +29,7 @@
 from mypy.types import (
     Type, AnyType, CallableType, Void, FunctionLike, Overloaded, TupleType,
     Instance, NoneTyp, UnboundType, ErrorType, TypeTranslator, strip_type,
-    UnionType, TypeVarType, PartialType
+    UnionType, TypeVarType, PartialType, DeletedType
 )
 from mypy.sametypes import is_same_type
 from mypy.messages import MessageBuilder
@@ -126,6 +126,13 @@ def push(self, expr: Node, type: Type) -> None:
     def get(self, expr: Node) -> Type:
         return self._get(expr.literal_hash)
 
+    def cleanse(self, expr: Node) -> None:
+        """Remove all references to a Node from the binder."""
+        key = expr.literal_hash
+        for frame in self.frames:
+            if key in frame:
+                del frame[key]
+
     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.
@@ -973,16 +980,10 @@ def check_import(self, node: ImportBase) -> Type:
     def visit_block(self, b: Block) -> Type:
         if b.is_unreachable:
             return None
-        n_frames_added = 0
         for s in b.body:
-            if self.typing_mode_weak() and isinstance(s, AssignmentStmt):
-                self.binder.push_frame()
-                n_frames_added += 1
             self.accept(s)
             if self.breaking_out:
                 break
-        for i in range(n_frames_added):
-            self.binder.pop_frame(False, True)
 
     def visit_assignment_stmt(self, s: AssignmentStmt) -> Type:
         """Type check an assignment statement.
@@ -1250,6 +1251,8 @@ def infer_variable_type(self, name: Var, lvalue: Node,
         elif isinstance(init_type, Void):
             self.check_not_void(init_type, context)
             self.set_inference_error_fallback_type(name, lvalue, init_type, context)
+        elif isinstance(init_type, DeletedType):
+            self.msg.deleted_as_rvalue(init_type, context)
         elif not is_valid_inferred_type(init_type):
             # We cannot use the type of the initialization expression for full type
             # inference (it's not specific enough), but we might be able to give
@@ -1324,11 +1327,16 @@ def check_simple_assignment(self, lvalue_type: Type, rvalue: Node,
             return AnyType()
         else:
             rvalue_type = self.accept(rvalue, lvalue_type)
+            if isinstance(rvalue_type, DeletedType):
+                self.msg.deleted_as_rvalue(rvalue_type, context)
             if self.typing_mode_weak():
                 return rvalue_type
-            self.check_subtype(rvalue_type, lvalue_type, context, msg,
-                               '{} has type'.format(rvalue_name),
-                               '{} has type'.format(lvalue_name))
+            if isinstance(lvalue_type, DeletedType):
+                self.msg.deleted_as_lvalue(lvalue_type, context)
+            else:
+                self.check_subtype(rvalue_type, lvalue_type, context, msg,
+                                   '{} has type'.format(rvalue_name),
+                                   '{} has type'.format(lvalue_name))
             return rvalue_type
 
     def check_indexed_assignment(self, lvalue: IndexExpr,
@@ -1638,13 +1646,31 @@ def visit_try_stmt(self, s: TryStmt) -> Type:
         completed_frames.append(frame_on_completion)
 
         for i in range(len(s.handlers)):
+            self.binder.push_frame()
             if s.types[i]:
                 t = self.exception_type(s.types[i])
                 if s.vars[i]:
-                    self.check_assignment(s.vars[i],
-                                          self.temp_node(t, s.vars[i]))
-            self.binder.push_frame()
+                    # To support local variables, we make this a definition line,
+                    # causing assignment to set the variable's type.
+                    s.vars[i].is_def = True
+                    self.check_assignment(s.vars[i], self.temp_node(t, s.vars[i]))
             self.accept(s.handlers[i])
+            if s.vars[i]:
+                # Exception variables are deleted in python 3 but not python 2.
+                # But, since it's bad form in python 2 and the type checking
+                # wouldn't work very well, we delete it anyway.
+
+                # Unfortunately, this doesn't let us detect usage before the
+                # try/except block.
+                if self.pyversion[0] >= 3:
+                    source = s.vars[i].name
+                else:
+                    source = ('(exception variable "{}", which we do not accept '
+                              'outside except: blocks even in python 2)'.format(s.vars[i].name))
+                var = cast(Var, s.vars[i].node)
+                var.type = DeletedType(source=source)
+                self.binder.cleanse(s.vars[i])
+
             self.breaking_out = False
             changed, frame_on_completion = self.binder.pop_frame()
             completed_frames.append(frame_on_completion)
@@ -1745,7 +1771,19 @@ def visit_del_stmt(self, s: DelStmt) -> Type:
             c.line = s.line
             return c.accept(self)
         else:
+            def flatten(t: Node) -> List[Node]:
+                """Flatten a nested sequence of tuples/lists into one list of nodes."""
+                if isinstance(t, TupleExpr) or isinstance(t, ListExpr):
+                    t = cast(Union[TupleExpr, ListExpr], t)
+                    return [b for a in t.items for b in flatten(a)]
+                else:
+                    return [t]
+
             s.expr.accept(self)
+            for elt in flatten(s.expr):
+                if isinstance(elt, NameExpr):
+                    self.binder.assign_type(elt, DeletedType(source=elt.name),
+                                            self.typing_mode_weak())
             return None
 
     def visit_decorator(self, e: Decorator) -> Type:

mypy/checkexpr.py

@@ -5,7 +5,7 @@
 from mypy.types import (
     Type, AnyType, CallableType, Overloaded, NoneTyp, Void, TypeVarDef,
     TupleType, Instance, TypeVarType, TypeTranslator, ErasedType, FunctionLike, UnionType,
-    PartialType
+    PartialType, DeletedType
 )
 from mypy.nodes import (
     NameExpr, RefExpr, Var, FuncDef, OverloadedFuncDef, TypeInfo, CallExpr,
@@ -568,6 +568,8 @@ def check_arg(self, caller_type: Type, original_caller_type: Type,
         """Check the type of a single argument in a call."""
         if isinstance(caller_type, Void):
             messages.does_not_return_value(caller_type, context)
+        elif isinstance(caller_type, DeletedType):
+            messages.deleted_as_rvalue(caller_type, context)
         elif not is_subtype(caller_type, callee_type):
             messages.incompatible_argument(n, m, callee, original_caller_type,
                                            context)

mypy/checkmember.py

@@ -4,7 +4,7 @@
 
 from mypy.types import (
     Type, Instance, AnyType, TupleType, CallableType, FunctionLike, TypeVarDef,
-    Overloaded, TypeVarType, TypeTranslator, UnionType, PartialType
+    Overloaded, TypeVarType, TypeTranslator, UnionType, PartialType, DeletedType
 )
 from mypy.nodes import TypeInfo, FuncBase, Var, FuncDef, SymbolNode, Context
 from mypy.nodes import ARG_POS, function_type, Decorator, OverloadedFuncDef
@@ -99,6 +99,9 @@ def analyze_member_access(name: str, typ: Type, node: Context, is_lvalue: bool,
     elif isinstance(typ, TypeVarType):
         return analyze_member_access(name, typ.upper_bound, node, is_lvalue, is_super,
                                      builtin_type, msg, report_type=report_type)
+    elif isinstance(typ, DeletedType):
+        msg.deleted_as_rvalue(typ, node)
+        return AnyType()
     return msg.has_no_attr(report_type, name, node)
 
 

mypy/constraints.py

@@ -4,7 +4,8 @@
 
 from mypy.types import (
     CallableType, Type, TypeVisitor, UnboundType, AnyType, Void, NoneTyp, TypeVarType,
-    Instance, TupleType, UnionType, Overloaded, ErasedType, PartialType, is_named_instance
+    Instance, TupleType, UnionType, Overloaded, ErasedType, PartialType, DeletedType,
+    is_named_instance
 )
 from mypy.expandtype import expand_caller_var_args
 from mypy.maptype import map_instance_to_supertype
@@ -151,6 +152,9 @@ def visit_none_type(self, template: NoneTyp) -> List[Constraint]:
     def visit_erased_type(self, template: ErasedType) -> List[Constraint]:
         return []
 
+    def visit_deleted_type(self, template: DeletedType) -> List[Constraint]:
+        return []
+
     # Errors
 
     def visit_partial_type(self, template: PartialType) -> List[Constraint]:

mypy/erasetype.py

@@ -3,7 +3,7 @@
 from mypy.types import (
     Type, TypeVisitor, UnboundType, ErrorType, AnyType, Void, NoneTyp,
     Instance, TypeVarType, CallableType, TupleType, UnionType, Overloaded, ErasedType,
-    TypeTranslator, TypeList, PartialType
+    PartialType, DeletedType, TypeTranslator, TypeList
 )
 
 
@@ -50,6 +50,9 @@ def visit_partial_type(self, t: PartialType) -> Type:
         # Should not get here.
         raise RuntimeError()
 
+    def visit_deleted_type(self, t: DeletedType) -> Type:
+        return t
+
     def visit_instance(self, t: Instance) -> Type:
         return Instance(t.type, [AnyType()] * len(t.args), t.line)
 

mypy/expandtype.py

@@ -3,7 +3,7 @@
 from mypy.types import (
     Type, Instance, CallableType, TypeVisitor, UnboundType, ErrorType, AnyType,
     Void, NoneTyp, TypeVarType, Overloaded, TupleType, UnionType, ErasedType, TypeList,
-    PartialType
+    PartialType, DeletedType
 )
 
 
@@ -61,6 +61,9 @@ def visit_void(self, t: Void) -> Type:
     def visit_none_type(self, t: NoneTyp) -> Type:
         return t
 
+    def visit_deleted_type(self, t: DeletedType) -> Type:
+        return t
+
     def visit_erased_type(self, t: ErasedType) -> Type:
         # Should not get here.
         raise RuntimeError()

mypy/join.py

@@ -5,7 +5,7 @@
 from mypy.types import (
     Type, AnyType, NoneTyp, Void, TypeVisitor, Instance, UnboundType,
     ErrorType, TypeVarType, CallableType, TupleType, ErasedType, TypeList,
-    UnionType, FunctionLike, Overloaded, PartialType
+    UnionType, FunctionLike, Overloaded, PartialType, DeletedType
 )
 from mypy.maptype import map_instance_to_supertype
 from mypy.subtypes import is_subtype, is_equivalent, is_subtype_ignoring_tvars
@@ -110,6 +110,12 @@ def visit_none_type(self, t: NoneTyp) -> Type:
         else:
             return self.default(self.s)
 
+    def visit_deleted_type(self, t: DeletedType) -> Type:
+        if not isinstance(self.s, Void):
+            return self.s
+        else:
+            return self.default(self.s)
+
     def visit_erased_type(self, t: ErasedType) -> Type:
         return self.s
 

mypy/meet.py

@@ -3,7 +3,7 @@
 from mypy.join import is_similar_callables, combine_similar_callables
 from mypy.types import (
     Type, AnyType, TypeVisitor, UnboundType, Void, ErrorType, NoneTyp, TypeVarType,
-    Instance, CallableType, TupleType, ErasedType, TypeList, UnionType, PartialType
+    Instance, CallableType, TupleType, ErasedType, TypeList, UnionType, PartialType, DeletedType
 )
 from mypy.sametypes import is_same_type
 from mypy.subtypes import is_subtype
@@ -118,6 +118,15 @@ def visit_none_type(self, t: NoneTyp) -> Type:
         else:
             return ErrorType()
 
+    def visit_deleted_type(self, t: DeletedType) -> Type:
+        if not isinstance(self.s, Void) and not isinstance(self.s, ErrorType):
+            if isinstance(self.s, NoneTyp):
+                return self.s
+            else:
+                return t
+        else:
+            return ErrorType()
+
     def visit_erased_type(self, t: ErasedType) -> Type:
         return self.s
 

mypy/messages.py

@@ -11,7 +11,7 @@
 from mypy.errors import Errors
 from mypy.types import (
     Type, CallableType, Instance, TypeVarType, TupleType, UnionType, Void, NoneTyp, AnyType,
-    Overloaded, FunctionLike
+    Overloaded, FunctionLike, DeletedType,
 )
 from mypy.nodes import TypeInfo, Context, MypyFile, op_methods, FuncDef, reverse_type_aliases
 
@@ -247,6 +247,8 @@ def format_simple(self, typ: Type, verbosity: int = 0) -> str:
             return 'None'
         elif isinstance(typ, AnyType):
             return '"Any"'
+        elif isinstance(typ, DeletedType):
+            return '<deleted>'
         elif typ is None:
             raise RuntimeError('Type is None')
         else:
@@ -520,6 +522,26 @@ def does_not_return_value(self, void_type: Type, context: Context) -> None:
             self.fail('{} does not return a value'.format(
                 capitalize((cast(Void, void_type)).source)), context)
 
+    def deleted_as_rvalue(self, typ: DeletedType, context: Context) -> None:
+        """Report an error about using an deleted type as an rvalue."""
+        if typ.source is None:
+            s = ""
+        else:
+            s = " '{}'".format(typ.source)
+        self.fail('Trying to read deleted variable{}'.format(s), context)
+
+    def deleted_as_lvalue(self, typ: DeletedType, context: Context) -> None:
+        """Report an error about using an deleted type as an lvalue.
+
+        Currently, this only occurs when trying to assign to an
+        exception variable outside the local except: blocks.
+        """
+        if typ.source is None:
+            s = ""
+        else:
+            s = " '{}'".format(typ.source)
+        self.fail('Assignment to variable{} outside except: block'.format(s), context)
+
     def no_variant_matches_arguments(self, overload: Overloaded, arg_types: List[Type],
                                      context: Context) -> None:
         if overload.name():

mypy/sametypes.py

@@ -2,7 +2,7 @@
 
 from mypy.types import (
     Type, UnboundType, ErrorType, AnyType, NoneTyp, Void, TupleType, UnionType, CallableType,
-    TypeVarType, Instance, TypeVisitor, ErasedType, TypeList, Overloaded, PartialType
+    TypeVarType, Instance, TypeVisitor, ErasedType, TypeList, Overloaded, PartialType, DeletedType
 )
 
 
@@ -57,6 +57,9 @@ def visit_erased_type(self, left: ErasedType) -> bool:
         # Should not get here.
         raise RuntimeError()
 
+    def visit_deleted_type(self, left: DeletedType) -> bool:
+        return isinstance(self.right, DeletedType)
+
     def visit_instance(self, left: Instance) -> bool:
         return (isinstance(self.right, Instance) and
                 left.type == (cast(Instance, self.right)).type and

mypy/subtypes.py

@@ -3,7 +3,7 @@
 from mypy.types import (
     Type, AnyType, UnboundType, TypeVisitor, ErrorType, Void, NoneTyp,
     Instance, TypeVarType, CallableType, TupleType, UnionType, Overloaded, ErasedType, TypeList,
-    PartialType, is_named_instance
+    PartialType, DeletedType, is_named_instance
 )
 import mypy.applytype
 import mypy.constraints
@@ -91,6 +91,9 @@ def visit_none_type(self, left: NoneTyp) -> bool:
     def visit_erased_type(self, left: ErasedType) -> bool:
         return True
 
+    def visit_deleted_type(self, left: DeletedType) -> bool:
+        return True
+
     def visit_instance(self, left: Instance) -> bool:
         right = self.right
         if isinstance(right, Instance):