Move check for six.with_metaclass to clean_up_bases_and_infer_type_variables (per Ivan L's review)

Author: Guido van Rossum

mypy/semanal.py

@@ -758,8 +758,12 @@ def clean_up_bases_and_infer_type_variables(self, defn: ClassDef) -> None:
         Now we will remove Generic[T] from bases of Foo and infer that the
         type variable 'T' is a type argument of Foo.
 
+        We also process six.with_metaclass() here.
+
         Note that this is performed *before* semantic analysis.
         """
+        # First process six.with_metaclass if present and well-formed
+        defn.base_type_exprs, defn.metaclass = self.check_with_metaclass(defn)
         removed = []  # type: List[int]
         declared_tvars = []  # type: TypeVarList
         for i, base_expr in enumerate(defn.base_type_exprs):
@@ -939,8 +943,7 @@ def analyze_base_classes(self, defn: ClassDef) -> None:
         base_types = []  # type: List[Instance]
         info = defn.info
 
-        base_type_exprs = self.check_with_metaclass(defn)
-        for base_expr in base_type_exprs:
+        for base_expr in defn.base_type_exprs:
             try:
                 base = self.expr_to_analyzed_type(base_expr)
             except TypeTranslationError:
@@ -991,27 +994,26 @@ def analyze_base_classes(self, defn: ClassDef) -> None:
         if defn.info.is_enum and defn.type_vars:
             self.fail("Enum class cannot be generic", defn)
 
-    def check_with_metaclass(self, defn: ClassDef) -> List[Expression]:
+    def check_with_metaclass(self, defn: ClassDef) -> Tuple[List[Expression], Optional[str]]:
         # Special-case six.with_metaclass(M, B1, B2, ...).
-        # May update defn.metaclass.
-        base_type_exprs = defn.base_type_exprs
-        if defn.metaclass is None and len(base_type_exprs) == 1:
+        base_type_exprs, metaclass = defn.base_type_exprs, defn.metaclass
+        if metaclass is None and len(base_type_exprs) == 1:
             base_expr = base_type_exprs[0]
             if isinstance(base_expr, CallExpr) and isinstance(base_expr.callee, RefExpr):
-                base_expr.accept(self)
+                base_expr.callee.accept(self)
                 if (base_expr.callee.fullname == 'six.with_metaclass'
                         and len(base_expr.args) >= 1
                         and all(kind == ARG_POS for kind in base_expr.arg_kinds)):
-                    metaclass = base_expr.args[0]
-                    if isinstance(metaclass, NameExpr):
-                        defn.metaclass = metaclass.name
-                    elif isinstance(metaclass, MemberExpr):
-                        defn.metaclass = get_member_expr_fullname(metaclass)
+                    metaclass_expr = base_expr.args[0]
+                    if isinstance(metaclass_expr, NameExpr):
+                        metaclass = metaclass_expr.name
+                    elif isinstance(metaclass_expr, MemberExpr):
+                        metaclass = get_member_expr_fullname(metaclass_expr)
                     else:
                         self.fail("Dynamic metaclass not supported for '%s'" % defn.name,
-                                  metaclass)
-                    return base_expr.args[1:]
-        return base_type_exprs
+                                  metaclass_expr)
+                    return (base_expr.args[1:], metaclass)
+        return (base_type_exprs, metaclass)
 
     def expr_to_analyzed_type(self, expr: Expression) -> Type:
         if isinstance(expr, CallExpr):