Fixes to classes with fine-grained incremental

Author: JukkaL

mypy/nodes.py

@@ -1954,7 +1954,10 @@ def __init__(self, names: 'SymbolTable', defn: ClassDef, module_name: str) -> No
         self._fullname = defn.fullname
         self.is_abstract = False
         self.abstract_attributes = []
-        if defn.type_vars:
+        self.add_type_vars()
+
+    def add_type_vars(self) -> None:
+        if self.defn.type_vars:
             for vd in defn.type_vars:
                 self.type_vars.append(vd.name)
 

mypy/semanal.py

@@ -276,9 +276,19 @@ def refresh_partial(self, node: Union[MypyFile, FuncItem]) -> None:
     def refresh_top_level(self, file_node: MypyFile) -> None:
         """Reanalyze a stale module top-level in fine-grained incremental mode."""
         for d in file_node.defs:
-            if not isinstance(d, (FuncItem, ClassDef)):
+            if isinstance(d, ClassDef):
+                self.refresh_class_def(d)
+            elif not isinstance(d, FuncItem):
                 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)
+
     @contextmanager
     def file_context(self, file_node: MypyFile, fnam: str, options: Options,
                      active_type: Optional[TypeInfo]) -> Iterator[None]:
@@ -607,6 +617,12 @@ 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)
+
+    @contextmanager
+    def analyze_class_body(self, defn: ClassDef) -> Iterator[None]:
         self.clean_up_bases_and_infer_type_variables(defn)
         if self.analyze_typeddict_classdef(defn):
             return
@@ -624,8 +640,7 @@ def visit_class_def(self, defn: ClassDef) -> None:
 
         self.enter_class(defn)
 
-        # Analyze class body.
-        defn.defs.accept(self)
+        yield
 
         self.calculate_abstract_status(defn.info)
         self.setup_type_promotion(defn)

mypy/server/aststrip.py

@@ -30,6 +30,15 @@ def strip_top_level(self, file_node: MypyFile) -> None:
         for node in file_node.defs:
             if not isinstance(node, (FuncItem, ClassDef)):
                 node.accept(self)
+            elif isinstance(node, ClassDef):
+                self.strip_class_body(node)
+
+    def strip_class_body(self, node: ClassDef) -> None:
+        """Strip class body and type info, but don't strip methods."""
+        node.info.type_vars = []
+        node.info.bases = []
+        node.info.abstract_attributes = []
+        node.info.add_type_vars()
 
     def visit_func_def(self, node: FuncDef) -> None:
         node.expanded = []

mypy/server/update.py

@@ -385,7 +385,7 @@ def lookup_target(modules: Dict[str, MypyFile], target: str) -> List[DeferredNod
     else:
         components = []
     node = modules[module]  # type: SymbolNode
-    prev = None  # type: SymbolNode
+    file = None  # type: MypyFile
     active_class = None
     active_class_name = None
     for c in components:
@@ -394,14 +394,15 @@ def lookup_target(modules: Dict[str, MypyFile], target: str) -> List[DeferredNod
             active_class_name = node.name()
         # TODO: Is it possible for the assertion to fail?
         assert isinstance(node, (MypyFile, TypeInfo))
-        prev = node
+        if isinstance(node, MypyFile):
+            file = node
         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(prev, None, None)]  # TODO: Nested classes
+        result = [DeferredNode(file, None, None)]
         for name, node in node.names.items():
             if isinstance(node, FuncDef):
                 result.extend(lookup_target(modules, target + '.' + name))

test-data/unit/fine-grained.test

@@ -813,3 +813,38 @@ def f() -> str: pass
 [out]
 ==
 main:7: error: Incompatible types in assignment (expression has type "str", variable has type "int")
+
+[case testBaseClassDeleted]
+import m
+
+class A(m.C):
+    def f(self) -> None:
+        self.g()  # No error here because m.C becomes an Any base class
+    def g(self) -> None:
+        self.x
+[file m.py]
+class C:
+    def g(self) -> None: pass
+[file m.py.2]
+[out]
+main:7: error: "A" has no attribute "x"
+==
+main:3: error: Name 'm.C' is not defined
+
+[case testBaseClassOfNestedClassDeleted]
+import m
+
+class A:
+    class B(m.C):
+        def f(self) -> None:
+            self.g()  # No error here because m.C becomes an Any base class
+        def g(self) -> None:
+            self.x
+[file m.py]
+class C:
+    def g(self) -> None: pass
+[file m.py.2]
+[out]
+main:8: error: "B" has no attribute "x"
+==
+main:4: error: Name 'm.C' is not defined