Minor fixes

Author: JukkaL

mypy/nodes.py

@@ -1958,7 +1958,7 @@ def __init__(self, names: 'SymbolTable', defn: ClassDef, module_name: str) -> No
 
     def add_type_vars(self) -> None:
         if self.defn.type_vars:
-            for vd in defn.type_vars:
+            for vd in self.defn.type_vars:
                 self.type_vars.append(vd.name)
 
     def name(self) -> str:

mypy/semanal.py

@@ -282,12 +282,13 @@ def refresh_top_level(self, file_node: MypyFile) -> None:
                 self.accept(d)
 
     def refresh_class_def(self, defn: ClassDef) -> None:
-        with self.analyze_class_body(defn):
-            for d in defn.defs.body:
-                if isinstance(d, ClassDef):
-                    self.refresh_class_def(d)
-                elif not isinstance(d, FuncItem):
-                    self.accept(d)
+        with self.analyze_class_body(defn) as should_continue:
+            if should_continue:
+                for d in defn.defs.body:
+                    if isinstance(d, ClassDef):
+                        self.refresh_class_def(d)
+                    elif not isinstance(d, FuncItem):
+                        self.accept(d)
 
     @contextmanager
     def file_context(self, file_node: MypyFile, fnam: str, options: Options,
@@ -617,16 +618,19 @@ def check_function_signature(self, fdef: FuncItem) -> None:
             self.fail('Type signature has too many arguments', fdef, blocker=True)
 
     def visit_class_def(self, defn: ClassDef) -> None:
-        with self.analyze_class_body(defn):
-            # Analyze class body.
-            defn.defs.accept(self)
+        with self.analyze_class_body(defn) as should_continue:
+            if should_continue:
+                # Analyze class body.
+                defn.defs.accept(self)
 
     @contextmanager
-    def analyze_class_body(self, defn: ClassDef) -> Iterator[None]:
+    def analyze_class_body(self, defn: ClassDef) -> Iterator[bool]:
         self.clean_up_bases_and_infer_type_variables(defn)
         if self.analyze_typeddict_classdef(defn):
+            yield False
             return
         if self.analyze_namedtuple_classdef(defn):
+            yield False
             return
         self.setup_class_def_analysis(defn)
 
@@ -640,7 +644,7 @@ def analyze_class_body(self, defn: ClassDef) -> Iterator[None]:
 
         self.enter_class(defn)
 
-        yield
+        yield True
 
         self.calculate_abstract_status(defn.info)
         self.setup_type_promotion(defn)

mypy/server/aststrip.py

@@ -5,7 +5,7 @@
 
 from mypy.nodes import (
     Node, FuncDef, NameExpr, MemberExpr, RefExpr, MypyFile, FuncItem, ClassDef, AssignmentStmt,
-    TypeInfo
+    TypeInfo, Var
 )
 from mypy.traverser import TraverserVisitor
 
@@ -84,7 +84,6 @@ def strip_ref_expr(self, node: RefExpr) -> None:
     # TODO: handle more node types
 
 
-
 def is_self_member_ref(memberexpr: MemberExpr) -> bool:
     """Does memberexpr refer to an attribute of self?"""
     # TODO: Merge with is_self_member_ref in semanal.py.

mypy/server/target.py

@@ -1,12 +1,12 @@
-from typing import Iterable, Tuple
+from typing import Iterable, Tuple, List
 
 
 def module_prefix(modules: Iterable[str], target: str) -> str:
     return split_target(modules, target)[0]
 
 
 def split_target(modules: Iterable[str], target: str) -> Tuple[str, str]:
-    remaining = []
+    remaining = []  # type: List[str]
     while True:
         if target in modules:
             return target, '.'.join(remaining)

mypy/server/update.py

@@ -393,17 +393,18 @@ def lookup_target(modules: Dict[str, MypyFile], target: str) -> List[DeferredNod
             active_class = node
             active_class_name = node.name()
         # TODO: Is it possible for the assertion to fail?
-        assert isinstance(node, (MypyFile, TypeInfo))
         if isinstance(node, MypyFile):
             file = node
+        assert isinstance(node, (MypyFile, TypeInfo))
         node = node.names[c].node
     if isinstance(node, TypeInfo):
         # A ClassDef target covers the body of the class and everything defined
         # within it.  To get the body we include the entire surrounding target,
         # typically a module top-level, since we don't support processing class
         # bodies as separate entitites for simplicity.
         result = [DeferredNode(file, None, None)]
-        for name, node in node.names.items():
+        for name, symnode in node.names.items():
+            node = symnode.node
             if isinstance(node, FuncDef):
                 result.extend(lookup_target(modules, target + '.' + name))
         return result

test-data/unit/semanal-typeinfo.test

@@ -9,6 +9,7 @@ TypeInfoMap(
   __main__.c : TypeInfo(
     Name(__main__.c)
     Bases(builtins.object)
+    Mro(__main__.c, builtins.object)
     Names()))
 
 [case testClassWithMethod]
@@ -19,6 +20,7 @@ TypeInfoMap(
   __main__.c : TypeInfo(
     Name(__main__.c)
     Bases(builtins.object)
+    Mro(__main__.c, builtins.object)
     Names(
       f)))
 
@@ -32,6 +34,7 @@ TypeInfoMap(
   __main__.c : TypeInfo(
     Name(__main__.c)
     Bases(builtins.object)
+    Mro(__main__.c, builtins.object)
     Names(
       __init__
       y
@@ -45,10 +48,12 @@ TypeInfoMap(
   __main__.base : TypeInfo(
     Name(__main__.base)
     Bases(builtins.object)
+    Mro(__main__.base, builtins.object)
     Names())
   __main__.c : TypeInfo(
     Name(__main__.c)
     Bases(__main__.base)
+    Mro(__main__.c, __main__.base, builtins.object)
     Names()))
 
 [case testClassAndAbstractClass]
@@ -62,10 +67,12 @@ TypeInfoMap(
   __main__.c : TypeInfo(
     Name(__main__.c)
     Bases(__main__.i)
+    Mro(__main__.c, __main__.i, builtins.object)
     Names())
   __main__.i : TypeInfo(
     Name(__main__.i)
     Bases(builtins.object)
+    Mro(__main__.i, builtins.object)
     Names()))
 
 [case testAttributeWithoutType]
@@ -76,5 +83,6 @@ TypeInfoMap(
   __main__.A : TypeInfo(
     Name(__main__.A)
     Bases(builtins.object)
+    Mro(__main__.A, builtins.object)
     Names(
       a)))