Merge branch 'import-as-in-stubs'

Closes #453.

Author: JukkaL

mypy/git.py

@@ -114,7 +114,7 @@ def verify_git_integrity_or_abort(datadir: str) -> None:
     Potentially output warnings/errors (to stderr), and exit with status 1
     if we detected a severe problem.
     """
-
+    datadir = datadir or '.'
     if not is_git_repo(datadir):
         return
     if not have_git():

mypy/nodes.py

@@ -176,21 +176,21 @@ class ImportBase(Node):
 class Import(ImportBase):
     """import m [as n]"""
 
-    ids = None  # type: List[Tuple[str, str]]     # (module id, as id)
+    ids = None  # type: List[Tuple[str, Optional[str]]]     # (module id, as id)
 
-    def __init__(self, ids: List[Tuple[str, str]]) -> None:
+    def __init__(self, ids: List[Tuple[str, Optional[str]]]) -> None:
         self.ids = ids
 
     def accept(self, visitor: NodeVisitor[T]) -> T:
         return visitor.visit_import(self)
 
 
 class ImportFrom(ImportBase):
-    """from m import x, ..."""
+    """from m import x [as y], ..."""
 
-    names = None  # type: List[Tuple[str, str]]  # Tuples (name, as name)
+    names = None  # type: List[Tuple[str, Optional[str]]]  # Tuples (name, as name)
 
-    def __init__(self, id: str, relative: int, names: List[Tuple[str, str]]) -> None:
+    def __init__(self, id: str, relative: int, names: List[Tuple[str, Optional[str]]]) -> None:
         self.id = id
         self.names = names
         self.relative = relative
@@ -1629,14 +1629,19 @@ class SymbolTableNode:
     mod_id = ''
     # If this not None, override the type of the 'node' attribute.
     type_override = None  # type: mypy.types.Type
+    # If False, this name won't be imported via 'from <module> import *'.
+    # This has no effect on names within classes.
+    module_public = True
 
     def __init__(self, kind: int, node: SymbolNode, mod_id: str = None,
-                 typ: 'mypy.types.Type' = None, tvar_id: int = 0) -> None:
+                 typ: 'mypy.types.Type' = None, tvar_id: int = 0,
+                 module_public: bool = True) -> None:
         self.kind = kind
         self.node = node
         self.type_override = typ
         self.mod_id = mod_id
         self.tvar_id = tvar_id
+        self.module_public = module_public
 
     @property
     def fullname(self) -> str:

mypy/parse.py

@@ -203,7 +203,7 @@ def parse_import(self) -> Import:
             id = self.parse_qualified_name()
             if id == self.custom_typing_module:
                 id = 'typing'
-            as_id = id
+            as_id = None  # type: Optional[str]
             if self.current_str() == 'as':
                 self.expect('as')
                 name_tok = self.expect_type(Name)
@@ -227,7 +227,7 @@ def parse_import_from(self) -> Node:
 
         # Parse qualified name to actually import from.
         if self.current_str() == "import":
-            # Empty/defualt values.
+            # Empty/default values.
             name = ""
         else:
             name = self.parse_qualified_name()
@@ -274,15 +274,15 @@ def parse_import_from(self) -> Node:
             self.future_options.extend(target[0] for target in targets)
         return node
 
-    def parse_import_name(self) -> Tuple[str, str]:
+    def parse_import_name(self) -> Tuple[str, Optional[str]]:
         tok = self.expect_type(Name)
         name = tok.string
         if self.current_str() == 'as':
             self.skip()
             as_name = self.expect_type(Name)
             return name, as_name.string
         else:
-            return name, name
+            return name, None
 
     def parse_qualified_name(self) -> str:
         """Parse a name with an optional module qualifier.

mypy/semanal.py

@@ -161,6 +161,7 @@ class SemanticAnalyzer(NodeVisitor):
 
     loop_depth = 0         # Depth of breakable loops
     cur_mod_id = ''        # Current module id (or None) (phase 2)
+    is_stub_file = False   # Are we analyzing a stub file?
     imports = None  # type: Set[str]  # Imported modules (during phase 2 analysis)
     errors = None  # type: Errors     # Keeps track of generated errors
 
@@ -736,16 +737,22 @@ def bind_class_type_variables_in_symbol_table(
 
     def visit_import(self, i: Import) -> None:
         for id, as_id in i.ids:
-            if as_id != id:
-                self.add_module_symbol(id, as_id, i)
+            if as_id is not None:
+                self.add_module_symbol(id, as_id, module_public=True, context=i)
             else:
+                # Modules imported in a stub file without using 'as x' won't get exported when
+                # doing 'from m import *'.
+                module_public = not self.is_stub_file
                 base = id.split('.')[0]
-                self.add_module_symbol(base, base, i)
+                self.add_module_symbol(base, base, module_public=module_public,
+                                       context=i)
 
-    def add_module_symbol(self, id: str, as_id: str, context: Context) -> None:
+    def add_module_symbol(self, id: str, as_id: str, module_public: bool,
+                          context: Context) -> None:
         if id in self.modules:
             m = self.modules[id]
-            self.add_symbol(as_id, SymbolTableNode(MODULE_REF, m, self.cur_mod_id), context)
+            self.add_symbol(as_id, SymbolTableNode(MODULE_REF, m, self.cur_mod_id,
+                                                   module_public=module_public), context)
         else:
             self.add_unknown_symbol(as_id, context)
 
@@ -759,10 +766,13 @@ def visit_import_from(self, i: ImportFrom) -> None:
                     node = self.normalize_type_alias(node, i)
                     if not node:
                         return
+                    module_public = not self.is_stub_file or as_id is not None
                     symbol = SymbolTableNode(node.kind, node.node,
                                              self.cur_mod_id,
-                                             node.type_override)
-                    self.add_symbol(as_id, symbol, i)
+                                             node.type_override,
+                                             module_public=module_public)
+                    imported_id = as_id or id
+                    self.add_symbol(imported_id, symbol, i)
                 else:
                     message = "Module has no attribute '{}'".format(id)
                     extra = self.undefined_name_extra_info('{}.{}'.format(i_id, id))
@@ -771,7 +781,7 @@ def visit_import_from(self, i: ImportFrom) -> None:
                     self.fail(message, i)
         else:
             for id, as_id in i.names:
-                self.add_unknown_symbol(as_id, i)
+                self.add_unknown_symbol(as_id or id, i)
 
     def normalize_type_alias(self, node: SymbolTableNode,
                              ctx: Context) -> SymbolTableNode:
@@ -803,7 +813,7 @@ def visit_import_all(self, i: ImportAll) -> None:
             m = self.modules[i_id]
             for name, node in m.names.items():
                 node = self.normalize_type_alias(node, i)
-                if not name.startswith('_'):
+                if not name.startswith('_') and node.module_public:
                     self.add_symbol(name, SymbolTableNode(node.kind, node.node,
                                                           self.cur_mod_id), i)
         else:

mypy/strconv.py

@@ -84,13 +84,19 @@ def visit_mypy_file(self, o):
     def visit_import(self, o):
         a = []
         for id, as_id in o.ids:
-            a.append('{} : {}'.format(id, as_id))
+            if as_id is not None:
+                a.append('{} : {}'.format(id, as_id))
+            else:
+                a.append(id)
         return 'Import:{}({})'.format(o.line, ', '.join(a))
 
     def visit_import_from(self, o):
         a = []
         for name, as_name in o.names:
-            a.append('{} : {}'.format(name, as_name))
+            if as_name is not None:
+                a.append('{} : {}'.format(name, as_name))
+            else:
+                a.append(name)
         return 'ImportFrom:{}({}, [{}])'.format(o.line, "." * o.relative + o.id, ', '.join(a))
 
     def visit_import_all(self, o):

mypy/stubgen.py

@@ -335,21 +335,21 @@ def visit_import_from(self, o):
         if self._all_:
             # Include import froms that import names defined in __all__.
             names = [name for name, alias in o.names
-                     if name in self._all_ and name == alias]
+                     if name in self._all_ and alias is None]
             self.import_and_export_names(o.id, o.relative, names)
         else:
             # Include import from targets that import from a submodule of a package.
             if o.relative:
                 names = [name for name, alias in o.names
-                         if name == alias]
+                         if alias is None]
                 self.import_and_export_names(o.id, o.relative, names)
         # Import names used as base classes.
         names = [(name, alias) for name, alias in o.names
-                 if alias in self._base_classes]
+                 if alias or name in self._base_classes]
         if names:
             imp_names = []
             for name, alias in names:
-                if alias != name:
+                if alias is not None and alias != name:
                     imp_names.append('%s as %s' % (name, alias))
                 else:
                     imp_names.append(name)

mypy/test/data/parse.test

@@ -1026,8 +1026,8 @@ import x
 import y.z.foo, __foo__.bar
 [out]
 MypyFile:1(
-  Import:1(x : x)
-  Import:2(y.z.foo : y.z.foo, __foo__.bar : __foo__.bar))
+  Import:1(x)
+  Import:2(y.z.foo, __foo__.bar))
 
 [case testVariableTypeWithQualifiedName]
 x = None # type: x.y
@@ -1053,16 +1053,16 @@ from m import x
 from m.n import x, y, z
 [out]
 MypyFile:1(
-  ImportFrom:1(m, [x : x])
-  ImportFrom:2(m.n, [x : x, y : y, z : z]))
+  ImportFrom:1(m, [x])
+  ImportFrom:2(m.n, [x, y, z]))
 
 [case testImportFromAs]
 from m import x as y
-from x import y, z as a, c
+from x import y, z as a, c as c
 [out]
 MypyFile:1(
   ImportFrom:1(m, [x : y])
-  ImportFrom:2(x, [y : y, z : a, c : c]))
+  ImportFrom:2(x, [y, z : a, c : c]))
 
 [case testImportStar]
 from x import *
@@ -1080,18 +1080,18 @@ def f():
 MypyFile:1(
   ExpressionStmt:1(
     IntExpr(1))
-  Import:2(x : x)
+  Import:2(x)
   FuncDef:3(
     f
     Block:3(
-      ImportFrom:4(x, [y : y])
+      ImportFrom:4(x, [y])
       ImportAll:5(z))))
 
 [case testImportWithExtraComma]
 from x import (y, z,)
 [out]
 MypyFile:1(
-  ImportFrom:1(x, [y : y, z : z]))
+  ImportFrom:1(x, [y, z]))
 
 [case testDefaultArgs]
 def f(x=1):
@@ -1700,8 +1700,8 @@ from x import (y,
                z)
 [out]
 MypyFile:1(
-  ImportFrom:1(x, [y : y])
-  ImportFrom:2(x, [y : y, z : z]))
+  ImportFrom:1(x, [y])
+  ImportFrom:2(x, [y, z]))
 
 [case testContinueStmt]
 while 1:
@@ -2142,11 +2142,11 @@ MypyFile:1(
 
 [case testImportAs]
 import x as y
-import x, z as y, a.b as c
+import x, z as y, a.b as c, d as d
 [out]
 MypyFile:1(
   Import:1(x : y)
-  Import:2(x : x, z : y, a.b : c))
+  Import:2(x, z : y, a.b : c, d : d))
 
 [case testForAndElse]
 for x in y:
@@ -3171,13 +3171,13 @@ MypyFile:1(
 from ... import x
 [out]
 MypyFile:1(
-  ImportFrom:1(..., [x : x]))
+  ImportFrom:1(..., [x]))
 
 [case testRelativeImportWithEllipsis2]
 from .... import x
 [out]
 MypyFile:1(
-  ImportFrom:1(...., [x : x]))
+  ImportFrom:1(...., [x]))
 
 [case testParseExtendedSlicing]
 a[:, :]
@@ -3242,7 +3242,7 @@ MypyFile:1(
 import x # type: ignore
 [out]
 MypyFile:1(
-  Import:1(x : x)
+  Import:1(x)
   IgnoredLines(1))
 
 [case testIgnore2Lines]
@@ -3317,7 +3317,7 @@ from m import ( # type: ignore
 )
 [out]
 MypyFile:1(
-  ImportFrom:1(m, [x : x, y : y])
+  ImportFrom:1(m, [x, y])
   IgnoredLines(1))
 
 [case testYieldExpression]

mypy/test/data/semanal-abstractclasses.test

@@ -9,8 +9,8 @@ class A(metaclass=ABCMeta):
   def f(self) -> 'A': return self
 [out]
 MypyFile:1(
-  ImportFrom:1(abc, [abstractmethod : abstractmethod, ABCMeta : ABCMeta])
-  Import:2(typing : typing)
+  ImportFrom:1(abc, [abstractmethod, ABCMeta])
+  Import:2(typing)
   ClassDef:4(
     A
     Metaclass(ABCMeta)
@@ -45,8 +45,8 @@ class B(metaclass=ABCMeta): pass
 class C(A, B): pass
 [out]
 MypyFile:1(
-  ImportFrom:1(abc, [abstractmethod : abstractmethod, ABCMeta : ABCMeta])
-  Import:2(typing : typing)
+  ImportFrom:1(abc, [abstractmethod, ABCMeta])
+  Import:2(typing)
   ClassDef:4(
     A
     Metaclass(ABCMeta)
@@ -71,8 +71,8 @@ class A(Generic[T]):
   def f(self) -> 'A[T]': pass
 [out]
 MypyFile:1(
-  ImportFrom:1(abc, [abstractmethod : abstractmethod])
-  ImportFrom:2(typing, [Generic : Generic, TypeVar : TypeVar])
+  ImportFrom:1(abc, [abstractmethod])
+  ImportFrom:2(typing, [Generic, TypeVar])
   AssignmentStmt:3(
     NameExpr(T* [__main__.T])
     TypeVarExpr:3())
@@ -101,9 +101,9 @@ class A(metaclass=ABCMeta):
   def g(self) -> 'A': pass
 [out]
 MypyFile:1(
-  Import:1(abc : abc)
-  ImportFrom:2(abc, [ABCMeta : ABCMeta])
-  Import:3(typing : typing)
+  Import:1(abc)
+  ImportFrom:2(abc, [ABCMeta])
+  Import:3(typing)
   ClassDef:5(
     A
     Metaclass(ABCMeta)