Remove Undefined and UndefinedExpr from mypy

closes #680

Author: JamesGuthrie

mypy/checker.py

@@ -15,7 +15,7 @@
     BytesExpr, UnicodeExpr, FloatExpr, OpExpr, UnaryExpr, CastExpr, SuperExpr,
     TypeApplication, DictExpr, SliceExpr, FuncExpr, TempNode, SymbolTableNode,
     Context, ListComprehension, ConditionalExpr, GeneratorExpr,
-    Decorator, SetExpr, PassStmt, TypeVarExpr, UndefinedExpr, PrintStmt,
+    Decorator, SetExpr, PassStmt, TypeVarExpr, PrintStmt,
     LITERAL_TYPE, BreakStmt, ContinueStmt, ComparisonExpr, StarExpr,
     YieldFromExpr, YieldFromStmt, NamedTupleExpr, SetComprehension,
     DictionaryComprehension, ComplexExpr, EllipsisNode, TypeAliasExpr,
@@ -1004,13 +1004,9 @@ def check_multi_assignment(self, lvalues: List[Node],
         if not msg:
             msg = messages.INCOMPATIBLE_TYPES_IN_ASSIGNMENT
 
-        # First handle case where rvalue is of form Undefined, ...
-        rvalue_type = get_undefined_tuple(rvalue, self.named_type('builtins.tuple'))
-        undefined_rvalue = True
-        if not rvalue_type:
-            # Infer the type of an ordinary rvalue expression.
-            rvalue_type = self.accept(rvalue)  # TODO maybe elsewhere; redundant
-            undefined_rvalue = False
+        # Infer the type of an ordinary rvalue expression.
+        rvalue_type = self.accept(rvalue)  # TODO maybe elsewhere; redundant
+        undefined_rvalue = False
 
         if isinstance(rvalue_type, AnyType):
             for lv in lvalues:
@@ -1243,13 +1239,7 @@ def narrow_type_from_binder(self, expr: Node, known_type: Type) -> Type:
     def check_simple_assignment(self, lvalue_type: Type, rvalue: Node,
                                 context: Node,
                                 msg: str = messages.INCOMPATIBLE_TYPES_IN_ASSIGNMENT) -> Type:
-        """Checks the assignment of rvalue to a lvalue of type lvalue_type."""
-        if refers_to_fullname(rvalue, 'typing.Undefined'):
-            # The rvalue is just 'Undefined'; this is always valid.
-            # Infer the type of 'Undefined' from the lvalue type.
-            self.store_type(rvalue, lvalue_type)
-            return None
-        elif self.is_stub and isinstance(rvalue, EllipsisNode):
+        if self.is_stub and isinstance(rvalue, EllipsisNode):
             # '...' is always a valid initializer in a stub.
             return AnyType()
         else:
@@ -1797,9 +1787,6 @@ def visit_generator_expr(self, e: GeneratorExpr) -> Type:
     def visit_dictionary_comprehension(self, e: DictionaryComprehension) -> Type:
         return self.expr_checker.visit_dictionary_comprehension(e)
 
-    def visit_undefined_expr(self, e: UndefinedExpr) -> Type:
-        return self.expr_checker.visit_undefined_expr(e)
-
     def visit_temp_node(self, e: TempNode) -> Type:
         return e.type
 
@@ -1981,21 +1968,6 @@ def map_type_from_supertype(typ: Type, sub_info: TypeInfo,
     return expand_type_by_instance(typ, inst_type)
 
 
-def get_undefined_tuple(rvalue: Node, tuple_type: Instance) -> Type:
-    """Get tuple type corresponding to a tuple of Undefined values.
-
-    The type is Tuple[Any, ...]. If rvalue is not of the right form, return
-    None.
-    """
-    if isinstance(rvalue, TupleExpr):
-        for item in rvalue.items:
-            if not refers_to_fullname(item, 'typing.Undefined'):
-                break
-        else:
-            return TupleType([AnyType()] * len(rvalue.items), tuple_type)
-    return None
-
-
 def find_isinstance_check(node: Node,
                           type_map: Dict[Node, Type]) -> Tuple[Node, Type, Type, int]:
     """Check if node is an isinstance(variable, type) check.

mypy/checkexpr.py

@@ -12,7 +12,7 @@
     OpExpr, UnaryExpr, IndexExpr, CastExpr, TypeApplication, ListExpr,
     TupleExpr, DictExpr, FuncExpr, SuperExpr, SliceExpr, Context,
     ListComprehension, GeneratorExpr, SetExpr, MypyFile, Decorator,
-    UndefinedExpr, ConditionalExpr, ComparisonExpr, TempNode, SetComprehension,
+    ConditionalExpr, ComparisonExpr, TempNode, SetComprehension,
     DictionaryComprehension, ComplexExpr, EllipsisNode, LITERAL_TYPE,
     TypeAliasExpr
 )
@@ -1197,9 +1197,6 @@ def check_for_comp(self, e: Union[GeneratorExpr, DictionaryComprehension]) -> No
                 self.accept(condition)
         self.chk.binder.pop_frame()
 
-    def visit_undefined_expr(self, e: UndefinedExpr) -> Type:
-        return e.type
-
     def visit_conditional_expr(self, e: ConditionalExpr) -> Type:
         cond_type = self.accept(e.cond)
         self.check_not_void(cond_type, e)

mypy/nodes.py

@@ -1278,22 +1278,6 @@ def accept(self, visitor: NodeVisitor[T]) -> T:
         return visitor.visit_conditional_expr(self)
 
 
-class UndefinedExpr(Node):
-    """Expression None  # type: type, used as an initializer.
-
-    This is used to declare the type of a variable without initializing with
-    a proper value. For example:
-
-      x = None  # type: List[int]
-    """
-
-    def __init__(self, type: 'mypy.types.Type') -> None:
-        self.type = type
-
-    def accept(self, visitor: NodeVisitor[T]) -> T:
-        return visitor.visit_undefined_expr(self)
-
-
 class TypeApplication(Node):
     """Type application expr[type, ...]"""
 

mypy/semanal.py

@@ -54,7 +54,7 @@
     GlobalDecl, SuperExpr, DictExpr, CallExpr, RefExpr, OpExpr, UnaryExpr,
     SliceExpr, CastExpr, TypeApplication, Context, SymbolTable,
     SymbolTableNode, BOUND_TVAR, UNBOUND_TVAR, ListComprehension, GeneratorExpr,
-    FuncExpr, MDEF, FuncBase, Decorator, SetExpr, UndefinedExpr, TypeVarExpr,
+    FuncExpr, MDEF, FuncBase, Decorator, SetExpr, TypeVarExpr,
     StrExpr, PrintStmt, ConditionalExpr, PromoteExpr,
     ComparisonExpr, StarExpr, ARG_POS, ARG_NAMED, MroError, type_aliases,
     YieldFromStmt, YieldFromExpr, NamedTupleExpr, NonlocalDecl,
@@ -821,7 +821,6 @@ def visit_assignment_stmt(self, s: AssignmentStmt) -> None:
         if s.type:
             s.type = self.anal_type(s.type)
         else:
-            s.type = self.infer_type_from_undefined(s.rvalue)
             # For simple assignments, allow binding type aliases.
             if (s.type is None and len(s.lvalues) == 1 and
                     isinstance(s.lvalues[0], NameExpr)):
@@ -988,13 +987,6 @@ def check_lvalue_validity(self, node: Node, ctx: Context) -> None:
         if isinstance(node, (FuncDef, TypeInfo, TypeVarExpr)):
             self.fail('Invalid assignment target', ctx)
 
-    def infer_type_from_undefined(self, rvalue: Node) -> Type:
-        if isinstance(rvalue, CallExpr):
-            if isinstance(rvalue.analyzed, UndefinedExpr):
-                undef = cast(UndefinedExpr, rvalue.analyzed)
-                return undef.type
-        return None
-
     def store_declared_types(self, lvalue: Node, typ: Type) -> None:
         if isinstance(typ, StarType) and not isinstance(lvalue, StarExpr):
             self.fail('Star type only allowed for starred expressions', lvalue)
@@ -1476,7 +1468,7 @@ def visit_call_expr(self, expr: CallExpr) -> None:
         """Analyze a call expression.
 
         Some call expressions are recognized as special forms, including
-        cast(...), Undefined(...) and Any(...).
+        cast(...) and Any(...).
         """
         expr.callee.accept(self)
         if refers_to_fullname(expr.callee, 'typing.cast'):
@@ -1501,18 +1493,6 @@ def visit_call_expr(self, expr: CallExpr) -> None:
             expr.analyzed = CastExpr(expr.args[0], AnyType())
             expr.analyzed.line = expr.line
             expr.analyzed.accept(self)
-        elif refers_to_fullname(expr.callee, 'typing.Undefined'):
-            # Special form Undefined(...).
-            if not self.check_fixed_args(expr, 1, 'Undefined'):
-                return
-            try:
-                type = expr_to_unanalyzed_type(expr.args[0])
-            except TypeTranslationError:
-                self.fail('Argument to Undefined is not a type', expr)
-                return
-            expr.analyzed = UndefinedExpr(type)
-            expr.analyzed.line = expr.line
-            expr.analyzed.accept(self)
         elif refers_to_fullname(expr.callee, 'typing._promote'):
             # Special form _promote(...).
             if not self.check_fixed_args(expr, 1, '_promote'):
@@ -1625,9 +1605,6 @@ def visit_cast_expr(self, expr: CastExpr) -> None:
         expr.expr.accept(self)
         expr.type = self.anal_type(expr.type)
 
-    def visit_undefined_expr(self, expr: UndefinedExpr) -> None:
-        expr.type = self.anal_type(expr.type)
-
     def visit_type_application(self, expr: TypeApplication) -> None:
         expr.expr.accept(self)
         for i in range(len(expr.types)):
@@ -2006,9 +1983,6 @@ def visit_assignment_stmt(self, s: AssignmentStmt) -> None:
         self.analyze(s.type)
         super().visit_assignment_stmt(s)
 
-    def visit_undefined_expr(self, e: UndefinedExpr) -> None:
-        self.analyze(e.type)
-
     def visit_cast_expr(self, e: CastExpr) -> None:
         self.analyze(e.type)
         super().visit_cast_expr(e)

mypy/strconv.py

@@ -378,9 +378,6 @@ def visit_index_expr(self, o):
     def visit_super_expr(self, o):
         return self.dump([o.name], o)
 
-    def visit_undefined_expr(self, o):
-        return 'UndefinedExpr:{}({})'.format(o.line, o.type)
-
     def visit_type_application(self, o):
         return self.dump([o.expr, ('Types', o.types)], o)
 

mypy/test/testtypegen.py

@@ -45,7 +45,7 @@ def run_test(self, testcase):
             nodes = map.keys()
 
             # Ignore NameExpr nodes of variables with explicit (trivial) types
-            # to simplify output. Also ignore 'Undefined' nodes.
+            # to simplify output.
             searcher = VariableDefinitionNodeSearcher()
             for file in result.files.values():
                 file.accept(searcher)
@@ -86,9 +86,6 @@ def visit_assignment_stmt(self, s):
             for lvalue in s.lvalues:
                 if isinstance(lvalue, NameExpr):
                     self.nodes.add(lvalue)
-            if (isinstance(s.rvalue, NameExpr)
-                    and s.rvalue.fullname == 'typing.Undefined'):
-                self.nodes.add(s.rvalue)
 
 
 def ignore_node(node):

mypy/treetransform.py

@@ -15,7 +15,7 @@
     ConditionalExpr, DictExpr, SetExpr, NameExpr, IntExpr, StrExpr, BytesExpr,
     UnicodeExpr, FloatExpr, CallExpr, SuperExpr, MemberExpr, IndexExpr,
     SliceExpr, OpExpr, UnaryExpr, FuncExpr, TypeApplication, PrintStmt,
-    SymbolTable, RefExpr, UndefinedExpr, TypeVarExpr, PromoteExpr,
+    SymbolTable, RefExpr, TypeVarExpr, PromoteExpr,
     ComparisonExpr, TempNode, StarExpr, YieldFromStmt,
     YieldFromExpr, NamedTupleExpr, NonlocalDecl, SetComprehension,
     DictionaryComprehension, ComplexExpr, TypeAliasExpr
@@ -367,9 +367,6 @@ def visit_index_expr(self, node: IndexExpr) -> Node:
             new.analyzed.set_line(node.analyzed.line)
         return new
 
-    def visit_undefined_expr(self, node: UndefinedExpr) -> Node:
-        return UndefinedExpr(self.type(node.type))
-
     def visit_type_application(self, node: TypeApplication) -> TypeApplication:
         return TypeApplication(self.node(node.expr),
                                self.types(node.types))

mypy/visitor.py

@@ -184,9 +184,6 @@ def visit_set_expr(self, o: 'mypy.nodes.SetExpr') -> T:
     def visit_index_expr(self, o: 'mypy.nodes.IndexExpr') -> T:
         pass
 
-    def visit_undefined_expr(self, o: 'mypy.nodes.UndefinedExpr') -> T:
-        pass
-
     def visit_type_application(self, o: 'mypy.nodes.TypeApplication') -> T:
         pass