Merge branch 'conditional-definition'

Work towards #649. Still only addresses a subset of
issues.

Author: JukkaL

mypy/checker.py

@@ -21,7 +21,8 @@
     LITERAL_TYPE, BreakStmt, ContinueStmt, ComparisonExpr, StarExpr,
     YieldFromExpr, YieldFromStmt, NamedTupleExpr, SetComprehension,
     DictionaryComprehension, ComplexExpr, EllipsisExpr, TypeAliasExpr,
-    RefExpr, YieldExpr, BackquoteExpr, CONTRAVARIANT, COVARIANT
+    RefExpr, YieldExpr, BackquoteExpr, ImportFrom, ImportAll, ImportBase,
+    CONTRAVARIANT, COVARIANT
 )
 from mypy.nodes import function_type, method_type, method_type_with_fallback
 from mypy import nodes
@@ -933,6 +934,25 @@ def check_compatibility(self, name: str, base1: TypeInfo,
             self.msg.base_class_definitions_incompatible(name, base1, base2,
                                                          ctx)
 
+    def visit_import_from(self, node: ImportFrom) -> Type:
+        self.check_import(node)
+
+    def visit_import_all(self, node: ImportAll) -> Type:
+        self.check_import(node)
+
+    def check_import(self, node: ImportBase) -> Type:
+        for assign in node.assignments:
+            lvalue = assign.lvalues[0]
+            lvalue_type, _, __ = self.check_lvalue(lvalue)
+            if lvalue_type is None:
+                # TODO: This is broken.
+                lvalue_type = AnyType()
+            message = '{} "{}"'.format(messages.INCOMPATIBLE_IMPORT_OF,
+                                       cast(NameExpr, assign.rvalue).name)
+            self.check_simple_assignment(lvalue_type, assign.rvalue, node,
+                                         msg=message, lvalue_name='local name',
+                                         rvalue_name='imported name')
+
     #
     # Statements
     #
@@ -1040,9 +1060,7 @@ def check_multi_assignment(self, lvalues: List[Node],
                                context: Context,
                                infer_lvalue_type: bool = True,
                                msg: str = None) -> None:
-        """Check the assignment of one rvalue to a number of lvalues
-        for example from a ListExpr or TupleExpr.
-        """
+        """Check the assignment of one rvalue to a number of lvalues."""
 
         if not msg:
             msg = messages.INCOMPATIBLE_TYPES_IN_ASSIGNMENT
@@ -1284,7 +1302,9 @@ 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:
+                                msg: str = messages.INCOMPATIBLE_TYPES_IN_ASSIGNMENT,
+                                lvalue_name: str = 'variable',
+                                rvalue_name: str = 'expression') -> Type:
         if self.is_stub and isinstance(rvalue, EllipsisExpr):
             # '...' is always a valid initializer in a stub.
             return AnyType()
@@ -1293,7 +1313,8 @@ def check_simple_assignment(self, lvalue_type: Type, rvalue: Node,
             if self.typing_mode_weak():
                 return rvalue_type
             self.check_subtype(rvalue_type, lvalue_type, context, msg,
-                               'expression has type', 'variable has type')
+                               '{} has type'.format(rvalue_name),
+                               '{} has type'.format(lvalue_name))
             return rvalue_type
 
     def check_indexed_assignment(self, lvalue: IndexExpr,

mypy/messages.py

@@ -68,6 +68,7 @@
     "Generic type not valid as an expression any more (use '# type:' comment instead)"
 RETURN_TYPE_CANNOT_BE_CONTRAVARIANT = "Cannot use a contravariant type variable as return type"
 FUNCTION_PARAMETER_CANNOT_BE_COVARIANT = "Cannot use a covariant type variable as a parameter"
+INCOMPATIBLE_IMPORT_OF = "Incompatible import of"
 
 
 class MessageBuilder:

mypy/nodes.py

@@ -43,6 +43,10 @@ def get_line(self) -> int: pass
 UNBOUND_TVAR = 4  # type: int
 BOUND_TVAR = 5  # type: int
 TYPE_ALIAS = 6  # type: int
+# Placeholder for a name imported via 'from ... import'. Second phase of
+# semantic will replace this the actual imported reference. This is
+# needed so that we can detect whether a name has been imported during
+UNBOUND_IMPORTED = 7  # type: int
 
 
 LITERAL_YES = 2
@@ -171,6 +175,16 @@ def is_package_init_file(self) -> bool:
 class ImportBase(Node):
     """Base class for all import statements."""
     is_unreachable = False
+    # If an import replaces existing definitions, we construct dummy assignment
+    # statements that assign the imported names to the names in the current scope,
+    # for type checking purposes. Example:
+    #
+    #     x = 1
+    #     from m import x   <-- add assignment representing "x = m.x"
+    assignments = None  # type: List[AssignmentStmt]
+
+    def __init__(self) -> None:
+        self.assignments = []
 
 
 class Import(ImportBase):
@@ -179,6 +193,7 @@ class Import(ImportBase):
     ids = None  # type: List[Tuple[str, Optional[str]]]     # (module id, as id)
 
     def __init__(self, ids: List[Tuple[str, Optional[str]]]) -> None:
+        super().__init__()
         self.ids = ids
 
     def accept(self, visitor: NodeVisitor[T]) -> T:
@@ -191,6 +206,7 @@ class ImportFrom(ImportBase):
     names = None  # type: List[Tuple[str, Optional[str]]]  # Tuples (name, as name)
 
     def __init__(self, id: str, relative: int, names: List[Tuple[str, Optional[str]]]) -> None:
+        super().__init__()
         self.id = id
         self.names = names
         self.relative = relative
@@ -203,6 +219,7 @@ class ImportAll(ImportBase):
     """from m import *"""
 
     def __init__(self, id: str, relative: int) -> None:
+        super().__init__()
         self.id = id
         self.relative = relative
 
@@ -219,12 +236,13 @@ class FuncBase(SymbolNode):
     # If method, reference to TypeInfo
     info = None  # type: TypeInfo
     is_property = False
+    _fullname = None  # type: str       # Name with module prefix
 
     @abstractmethod
     def name(self) -> str: pass
 
     def fullname(self) -> str:
-        return self.name()
+        return self._fullname
 
     def is_method(self) -> bool:
         return bool(self.info)
@@ -238,7 +256,6 @@ class OverloadedFuncDef(FuncBase):
     """
 
     items = None  # type: List[Decorator]
-    _fullname = None  # type: str
 
     def __init__(self, items: List['Decorator']) -> None:
         self.items = items
@@ -247,9 +264,6 @@ def __init__(self, items: List['Decorator']) -> None:
     def name(self) -> str:
         return self.items[1].func.name()
 
-    def fullname(self) -> str:
-        return self._fullname
-
     def accept(self, visitor: NodeVisitor[T]) -> T:
         return visitor.visit_overloaded_func_def(self)
 
@@ -345,7 +359,6 @@ class FuncDef(FuncItem):
     This is a non-lambda function defined using 'def'.
     """
 
-    _fullname = None  # type: str       # Name with module prefix
     is_decorated = False
     is_conditional = False             # Defined conditionally (within block)?
     is_abstract = False
@@ -363,9 +376,6 @@ def __init__(self,
     def name(self) -> str:
         return self._name
 
-    def fullname(self) -> str:
-        return self._fullname
-
     def accept(self, visitor: NodeVisitor[T]) -> T:
         return visitor.visit_func_def(self)
 
@@ -1650,11 +1660,19 @@ def __str__(self) -> str:
 
 
 class SymbolTableNode:
-    # LDEF/GDEF/MDEF/UNBOUND_TVAR/TVAR/...
+    # Kind of node. Possible values:
+    #  - LDEF: local definition (of any kind)
+    #  - GDEF: global (module-level) definition
+    #  - MDEF: class member definition
+    #  - UNBOUND_TVAR: TypeVar(...) definition, not bound
+    #  - TVAR: type variable in a bound scope (generic function / generic clas)
+    #  - MODULE_REF: reference to a module
+    #  - TYPE_ALIAS: type alias
+    #  - UNBOUND_IMPORTED: temporary kind for imported names
     kind = None  # type: int
     # AST node of definition (FuncDef/Var/TypeInfo/Decorator/TypeVarExpr,
     # or None for a bound type variable).
-    node = None  # type: SymbolNode
+    node = None  # type: Optional[SymbolNode]
     # Type variable id (for bound type variables only)
     tvar_id = 0
     # Module id (e.g. "foo.bar") or None