Support for import inside class (#2077)

Tentatively fix #1839.

Author: gvanrossum

mypy/checkmember.py

@@ -7,7 +7,7 @@
     Overloaded, TypeVarType, TypeTranslator, UnionType, PartialType,
     DeletedType, NoneTyp, TypeType
 )
-from mypy.nodes import TypeInfo, FuncBase, Var, FuncDef, SymbolNode, Context
+from mypy.nodes import TypeInfo, FuncBase, Var, FuncDef, SymbolNode, Context, MypyFile
 from mypy.nodes import ARG_POS, ARG_STAR, ARG_STAR2, OpExpr, ComparisonExpr
 from mypy.nodes import function_type, Decorator, OverloadedFuncDef
 from mypy.messages import MessageBuilder
@@ -351,6 +351,10 @@ def analyze_class_attribute_access(itype: Instance,
     if isinstance(node.node, TypeInfo):
         return type_object_type(node.node, builtin_type)
 
+    if isinstance(node.node, MypyFile):
+        # Reference to a module object.
+        return builtin_type('builtins.module')
+
     if is_decorated:
         # TODO: Return type of decorated function. This is quick hack to work around #998.
         return AnyType()

mypy/semanal.py

@@ -2133,6 +2133,9 @@ def visit_member_expr(self, expr: MemberExpr) -> None:
         base.accept(self)
         # Bind references to module attributes.
         if isinstance(base, RefExpr) and base.kind == MODULE_REF:
+            # This branch handles the case foo.bar where foo is a module.
+            # In this case base.node is the module's MypyFile and we look up
+            # bar in its namespace.  This must be done for all types of bar.
             file = cast(MypyFile, base.node)
             n = file.names.get(expr.name, None) if file is not None else None
             if n:
@@ -2154,6 +2157,21 @@ def visit_member_expr(self, expr: MemberExpr) -> None:
                 if full_name in obsolete_name_mapping:
                     self.fail("Module has no attribute %r (it's now called %r)" % (
                         expr.name, obsolete_name_mapping[full_name]), expr)
+        elif isinstance(base, RefExpr) and isinstance(base.node, TypeInfo):
+            # This branch handles the case C.bar where C is a class
+            # and bar is a module resulting from `import bar` inside
+            # class C.  Here base.node is a TypeInfo, and again we
+            # look up the name in its namespace.  This is done only
+            # when bar is a module; other things (e.g. methods)
+            # are handled by other code in checkmember.
+            n = base.node.names.get(expr.name)
+            if n is not None and n.kind == MODULE_REF:
+                n = self.normalize_type_alias(n, expr)
+                if not n:
+                    return
+                expr.kind = n.kind
+                expr.fullname = n.fullname
+                expr.node = n.node
 
     def visit_op_expr(self, expr: OpExpr) -> None:
         expr.left.accept(self)

test-data/unit/check-modules.test

@@ -974,6 +974,15 @@ from a import x
 x = 0
 [out]
 
+[case testImportInClass]
+class C:
+    import foo
+reveal_type(C.foo.bar)  # E: Revealed type is 'builtins.int'
+[file foo.py]
+bar = 0
+[builtins fixtures/module.pyi]
+[out]
+
 
 -- Test stability under import cycles
 -- ----------------------------------