Cut the attribute ClassDef.base_types (#1694)

This seems to be always equivalent to `bases` on the corresponding
TypeInfo, so keep the information in just one place.

This is part of clearing out the old branches I've had lying around
on my local clone of the repo -- back in December I was studying how
we handle the MRO, found this confusing, and had a note that this
attribute seemed to be redundant.  Further investigation bears that
out: in particular, the fact that the tests pass after this change
which cuts it out entirely.

Author: gnprice

mypy/nodes.py

@@ -627,8 +627,6 @@ class ClassDef(Node):
     type_vars = None  # type: List[mypy.types.TypeVarDef]
     # Base class expressions (not semantically analyzed -- can be arbitrary expressions)
     base_type_exprs = None  # type: List[Node]
-    # Semantically analyzed base types, derived from base_type_exprs during semantic analysis
-    base_types = None  # type: List[mypy.types.Instance]
     info = None  # type: TypeInfo  # Related TypeInfo
     metaclass = ''
     decorators = None  # type: List[Node]
@@ -645,7 +643,6 @@ def __init__(self,
         self.defs = defs
         self.type_vars = type_vars or []
         self.base_type_exprs = base_type_exprs or []
-        self.base_types = []  # Not yet semantically analyzed --> don't know base types
         self.metaclass = metaclass
         self.decorators = []
 
@@ -661,7 +658,6 @@ def serialize(self) -> JsonDict:
                 'name': self.name,
                 'fullname': self.fullname,
                 'type_vars': [v.serialize() for v in self.type_vars],
-                'base_types': [t.serialize() for t in self.base_types],
                 'metaclass': self.metaclass,
                 'is_builtinclass': self.is_builtinclass,
                 }
@@ -675,7 +671,6 @@ def deserialize(self, data: JsonDict) -> 'ClassDef':
                        metaclass=data['metaclass'],
                        )
         res.fullname = data['fullname']
-        res.base_types = [mypy.types.Instance.deserialize(t) for t in data['base_types']]
         res.is_builtinclass = data['is_builtinclass']
         return res
 

mypy/semanal.py

@@ -732,7 +732,13 @@ def setup_class_def_analysis(self, defn: ClassDef) -> None:
             self.add_symbol(defn.name, SymbolTableNode(kind, defn.info), defn)
 
     def analyze_base_classes(self, defn: ClassDef) -> None:
-        """Analyze and set up base classes."""
+        """Analyze and set up base classes.
+
+        This computes several attributes on the corresponding TypeInfo defn.info
+        related to the base classes: defn.info.bases, defn.info.mro, and
+        miscellaneous others (at least tuple_type, fallback_to_any, and is_enum.)
+        """
+        base_types = []
         for base_expr in defn.base_type_exprs:
             # The base class is originally an expression; convert it to a type.
             try:
@@ -750,7 +756,7 @@ def analyze_base_classes(self, defn: ClassDef) -> None:
                         base.type.fullname() == 'builtins.tuple'):
                     self.fail("Tuple[...] not supported as a base class outside a stub file", defn)
             if isinstance(base, Instance):
-                defn.base_types.append(base)
+                base_types.append(base)
             elif isinstance(base, TupleType):
                 assert False, "Internal error: Unexpected TupleType base class"
             elif isinstance(base, AnyType):
@@ -760,10 +766,10 @@ def analyze_base_classes(self, defn: ClassDef) -> None:
             elif not isinstance(base, UnboundType):
                 self.fail('Invalid base class', base_expr)
         # Add 'object' as implicit base if there is no other base class.
-        if (not defn.base_types and defn.fullname != 'builtins.object'):
+        if (not base_types and defn.fullname != 'builtins.object'):
             obj = self.object_type()
-            defn.base_types.insert(0, obj)
-        defn.info.bases = defn.base_types
+            base_types.insert(0, obj)
+        defn.info.bases = base_types
         # Calculate the MRO. It might be incomplete at this point if
         # the bases of defn include classes imported from other
         # modules in an import loop. We'll recompute it in ThirdPass.

mypy/strconv.py

@@ -130,10 +130,11 @@ def visit_class_def(self, o):
         a = [o.name, o.defs.body]
         # Display base types unless they are implicitly just builtins.object
         # (in this case base_type_exprs is empty).
-        if o.base_types and o.base_type_exprs:
-            a.insert(1, ('BaseType', o.base_types))
-        elif len(o.base_type_exprs) > 0:
-            a.insert(1, ('BaseTypeExpr', o.base_type_exprs))
+        if o.base_type_exprs:
+            if o.info and o.info.bases:
+                a.insert(1, ('BaseType', o.info.bases))
+            else:
+                a.insert(1, ('BaseTypeExpr', o.base_type_exprs))
         if o.type_vars:
             a.insert(1, ('TypeVars', o.type_vars))
         if o.metaclass:

mypy/treetransform.py

@@ -160,9 +160,6 @@ def visit_class_def(self, node: ClassDef) -> Node:
                        node.metaclass)
         new.fullname = node.fullname
         new.info = node.info
-        new.base_types = []
-        for base in node.base_types:
-            new.base_types.append(cast(Instance, self.type(base)))
         new.decorators = [decorator.accept(self)
                           for decorator in node.decorators]
         new.is_builtinclass = node.is_builtinclass