NewType+namedtuple: common method for typeinfo (#2089)

Author: elazarg

mypy/nodes.py

@@ -2037,16 +2037,6 @@ def deserialize(cls, data: JsonDict) -> 'TypeInfo':
         return ti
 
 
-def namedtuple_type_info(tup: 'mypy.types.TupleType', names: 'SymbolTable',
-                         defn: ClassDef, module_name: str) -> TypeInfo:
-    info = TypeInfo(names, defn, module_name)
-    info.tuple_type = tup
-    info.bases = [tup.fallback]
-    info.is_named_tuple = True
-    info.mro = [info] + tup.fallback.type.mro
-    return info
-
-
 class SymbolTableNode:
     # Kind of node. Possible values:
     #  - LDEF: local definition (of any kind)

mypy/semanal.py

@@ -63,8 +63,7 @@
     YieldFromExpr, NamedTupleExpr, NonlocalDecl,
     SetComprehension, DictionaryComprehension, TYPE_ALIAS, TypeAliasExpr,
     YieldExpr, ExecStmt, Argument, BackquoteExpr, ImportBase, AwaitExpr,
-    IntExpr, FloatExpr, UnicodeExpr,
-    Expression, EllipsisExpr, namedtuple_type_info,
+    IntExpr, FloatExpr, UnicodeExpr, EllipsisExpr,
     COVARIANT, CONTRAVARIANT, INVARIANT, UNBOUND_IMPORTED, LITERAL_YES,
 )
 from mypy.visitor import NodeVisitor
@@ -1413,13 +1412,7 @@ def check_newtype_args(self, name: str, call: CallExpr, context: Context) -> Opt
         return None if has_failed else old_type
 
     def build_newtype_typeinfo(self, name: str, old_type: Type, base_type: Instance) -> TypeInfo:
-        class_def = ClassDef(name, Block([]))
-        class_def.fullname = self.qualified_name(name)
-
-        symbols = SymbolTable()
-        info = TypeInfo(symbols, class_def, self.cur_mod_id)
-        info.mro = [info] + base_type.type.mro
-        info.bases = [base_type]
+        info = self.basic_new_typeinfo(name, base_type)
         info.is_newtype = True
 
         # Add __init__ method
@@ -1434,7 +1427,7 @@ def build_newtype_typeinfo(self, name: str, old_type: Type, base_type: Instance)
             name=name)
         init_func = FuncDef('__init__', args, Block([]), typ=signature)
         init_func.info = info
-        symbols['__init__'] = SymbolTableNode(MDEF, init_func)
+        info.names['__init__'] = SymbolTableNode(MDEF, init_func)
 
         return info
 
@@ -1690,6 +1683,15 @@ def fail_namedtuple_arg(self, message: str,
         self.fail(message, context)
         return [], [], False
 
+    def basic_new_typeinfo(self, name: str, basetype_or_fallback: Instance) -> TypeInfo:
+        class_def = ClassDef(name, Block([]))
+        class_def.fullname = self.qualified_name(name)
+
+        info = TypeInfo(SymbolTable(), class_def, self.cur_mod_id)
+        info.mro = [info] + basetype_or_fallback.type.mro
+        info.bases = [basetype_or_fallback]
+        return info
+
     def build_namedtuple_typeinfo(self, name: str, items: List[str],
                                   types: List[Type]) -> TypeInfo:
         strtype = self.named_type('__builtins__.str')  # type: Type
@@ -1704,20 +1706,17 @@ def build_namedtuple_typeinfo(self, name: str, items: List[str],
         # but it can't be expressed. 'new' and 'len' should be callable types.
         iterable_type = self.named_type_or_none('typing.Iterable', [AnyType()])
         function_type = self.named_type('__builtins__.function')
-        fullname = self.qualified_name(name)
 
-        symbols = SymbolTable()
-        class_def = ClassDef(name, Block([]))
-        class_def.fullname = fullname
-        info = namedtuple_type_info(TupleType(types, fallback), symbols,
-                class_def, self.cur_mod_id)
+        info = self.basic_new_typeinfo(name, fallback)
+        info.is_named_tuple = True
+        info.tuple_type = TupleType(types, fallback)
 
         def add_field(var: Var, is_initialized_in_class: bool = False,
                       is_property: bool = False) -> None:
             var.info = info
             var.is_initialized_in_class = is_initialized_in_class
             var.is_property = is_property
-            symbols[var.name()] = SymbolTableNode(MDEF, var)
+            info.names[var.name()] = SymbolTableNode(MDEF, var)
 
         vars = [Var(item, typ) for item, typ in zip(items, types)]
         for var in vars:
@@ -1744,7 +1743,7 @@ def add_method(funcname: str, ret: Type, args: List[Argument], name=None,
             func = FuncDef(funcname, args, Block([]), typ=signature)
             func.info = info
             func.is_class = is_classmethod
-            symbols[funcname] = SymbolTableNode(MDEF, func)
+            info.names[funcname] = SymbolTableNode(MDEF, func)
 
         add_method('_replace', ret=this_type,
                    args=[Argument(var, var.type, EllipsisExpr(), ARG_NAMED) for var in vars])