Record module name in TypeInfo

This commit modifies TypeInfo so it records the name of the module in
which the class (or NewType or namedtuple) was defined in. This does not
modify the behavior of mypy, but will make it easier to perform
introspection and analysis at later stages.

This information is also a part of the TypeInfo's fullname, but is
difficult to extract in the case of nested classes. For example, if we
have a fully qualified name of a.b.c.d, it's not always obvious whether
or not c is a module name or is a class name, and so forth.

Author: MichaelLeeDBX

mypy/nodes.py

@@ -1777,6 +1777,10 @@ class is generic then it will be a type constructor of higher kind.
     """
 
     _fullname = None  # type: str          # Fully qualified name
+    # Fully qualified name for the module this type was defined in. This
+    # information is also in the fullname, but is harder to extract in the
+    # case of nested class definitions.
+    module_name = None  # type: str
     defn = None  # type: ClassDef          # Corresponding ClassDef
     # Method Resolution Order: the order of looking up attributes. The first
     # value always to refers to this class.
@@ -1828,10 +1832,11 @@ class is generic then it will be a type constructor of higher kind.
     # Alternative to fullname() for 'anonymous' classes.
     alt_fullname = None  # type: Optional[str]
 
-    def __init__(self, names: 'SymbolTable', defn: ClassDef) -> None:
+    def __init__(self, names: 'SymbolTable', defn: ClassDef, module_name: str) -> None:
         """Initialize a TypeInfo."""
         self.names = names
         self.defn = defn
+        self.module_name = module_name
         self.subtypes = set()
         self.type_vars = []
         self.bases = []
@@ -1985,6 +1990,7 @@ def __str__(self) -> str:
     def serialize(self) -> Union[str, JsonDict]:
         # NOTE: This is where all ClassDefs originate, so there shouldn't be duplicates.
         data = {'.class': 'TypeInfo',
+                'module_name': self.module_name,
                 'fullname': self.fullname(),
                 'alt_fullname': self.alt_fullname,
                 'names': self.names.serialize(self.alt_fullname or self.fullname()),
@@ -2006,7 +2012,8 @@ def serialize(self) -> Union[str, JsonDict]:
     def deserialize(cls, data: JsonDict) -> 'TypeInfo':
         names = SymbolTable.deserialize(data['names'])
         defn = ClassDef.deserialize(data['defn'])
-        ti = TypeInfo(names, defn)
+        module_name = data['module_name']
+        ti = TypeInfo(names, defn, module_name)
         ti._fullname = data['fullname']
         ti.alt_fullname = data['alt_fullname']
         # TODO: Is there a reason to reconstruct ti.subtypes?

mypy/semanal.py

@@ -734,7 +734,7 @@ def analyze_unbound_tvar(self, t: Type) -> Tuple[str, TypeVarExpr]:
     def setup_class_def_analysis(self, defn: ClassDef) -> None:
         """Prepare for the analysis of a class definition."""
         if not defn.info:
-            defn.info = TypeInfo(SymbolTable(), defn)
+            defn.info = TypeInfo(SymbolTable(), defn, self.cur_mod_id)
             defn.info._fullname = defn.info.name()
         if self.is_func_scope() or self.type:
             kind = MDEF
@@ -1410,7 +1410,7 @@ def build_newtype_typeinfo(self, name: str, old_type: Type, base_type: Instance)
         class_def.fullname = self.qualified_name(name)
 
         symbols = SymbolTable()
-        info = TypeInfo(symbols, class_def)
+        info = TypeInfo(symbols, class_def, self.cur_mod_id)
         info.mro = [info] + base_type.type.mro
         info.bases = [base_type]
         info.is_newtype = True
@@ -1683,7 +1683,7 @@ def build_namedtuple_typeinfo(self, name: str, items: List[str],
         symbols = SymbolTable()
         class_def = ClassDef(name, Block([]))
         class_def.fullname = self.qualified_name(name)
-        info = TypeInfo(symbols, class_def)
+        info = TypeInfo(symbols, class_def, self.cur_mod_id)
         # Add named tuple items as attributes.
         # TODO: Make them read-only.
         for item, typ in zip(items, types):
@@ -2606,7 +2606,7 @@ def visit_overloaded_func_def(self, func: OverloadedFuncDef) -> None:
     def visit_class_def(self, cdef: ClassDef) -> None:
         self.sem.check_no_global(cdef.name, cdef)
         cdef.fullname = self.sem.qualified_name(cdef.name)
-        info = TypeInfo(SymbolTable(), cdef)
+        info = TypeInfo(SymbolTable(), cdef, self.sem.cur_mod_id)
         info.set_line(cdef.line)
         cdef.info = info
         self.sem.globals[cdef.name] = SymbolTableNode(GDEF, info,
@@ -2616,11 +2616,12 @@ def visit_class_def(self, cdef: ClassDef) -> None:
     def process_nested_classes(self, outer_def: ClassDef) -> None:
         for node in outer_def.defs.body:
             if isinstance(node, ClassDef):
-                node.info = TypeInfo(SymbolTable(), node)
+                node.info = TypeInfo(SymbolTable(), node, self.sem.cur_mod_id)
                 if outer_def.fullname:
                     node.info._fullname = outer_def.fullname + '.' + node.info.name()
                 else:
                     node.info._fullname = node.info.name()
+                node.fullname = node.info._fullname
                 symbol = SymbolTableNode(MDEF, node.info)
                 outer_def.info.names[node.name] = symbol
                 self.process_nested_classes(node)

mypy/typefixture.py

@@ -193,6 +193,7 @@ def callable_var_arg(self, min_args, *a):
                             a[-1], self.function)
 
     def make_type_info(self, name: str,
+                       module_name: str = None,
                        is_abstract: bool = False,
                        mro: List[TypeInfo] = None,
                        bases: List[Instance] = None,
@@ -203,6 +204,12 @@ def make_type_info(self, name: str,
         class_def = ClassDef(name, Block([]), None, [])
         class_def.fullname = name
 
+        if module_name is None:
+            if '.' in name:
+                module_name = name.rsplit('.', 1)[0]
+            else:
+                module_name = '__main__'
+
         if typevars:
             v = []  # type: List[TypeVarDef]
             for id, n in enumerate(typevars, 1):
@@ -213,7 +220,7 @@ def make_type_info(self, name: str,
                 v.append(TypeVarDef(n, id, None, self.o, variance=variance))
             class_def.type_vars = v
 
-        info = TypeInfo(SymbolTable(), class_def)
+        info = TypeInfo(SymbolTable(), class_def, module_name)
         if mro is None:
             mro = []
             if name != 'builtins.object':