WIP (Debugging code and files)

Author: MichaelLeeDBX

bar.py

@@ -0,0 +1,2 @@
+from mod1 import A
+val = A().foo()

baz.py

@@ -0,0 +1,3 @@
+from mod3 import A
+myB = A().makeB()
+val = myB.foo()

foo.py

@@ -0,0 +1,4 @@
+import os
+import parent
+
+parent.a.b.value

mod1.py

@@ -0,0 +1 @@
+from mod2 import A

mod2.py

@@ -0,0 +1,3 @@
+class A:
+    def foo(self) -> int:
+        return 42

mod3.py

@@ -0,0 +1,4 @@
+from mod4 import B
+class A:
+    def makeB(self) -> B:
+        return B()

mod4.py

@@ -0,0 +1,3 @@
+class B:
+    def foo(self) -> int:
+        return 42

mypy/build.py

@@ -305,6 +305,7 @@ def default_lib_path(data_dir: str, pyversion: Tuple[int, int]) -> List[str]:
 PRI_HIGH = 5  # top-level "from X import blah"
 PRI_MED = 10  # top-level "import X"
 PRI_LOW = 20  # either form inside a function
+PRI_INDIRECT = 30  # an indirect dependency
 PRI_ALL = 99  # include all priorities
 
 
@@ -1268,7 +1269,7 @@ def load_tree(self) -> None:
         self.manager.modules[self.id] = self.tree
 
     def fix_cross_refs(self) -> None:
-        fixup_module_pass_one(self.tree, self.manager.modules)
+        fixup_module_pass_one(self.tree, self.manager.modules, self.valid_references())
 
     def calculate_mros(self) -> None:
         fixup_module_pass_two(self.tree, self.manager.modules)
@@ -1417,13 +1418,26 @@ def type_check(self) -> None:
         if manager.options.semantic_analysis_only:
             return
         with self.wrap_context():
-            encountered_deps = self.dependencies + self.suppressed + self.ancestors
-            manager.type_checker.visit_file(self.tree, self.xpath, encountered_deps)
+            manager.type_checker.visit_file(self.tree, self.xpath, self.valid_references())
+            encountered = manager.type_checker.get_encountered()
+            #for dep in encountered - self.valid_references():
+            #    self.dependencies.append(dep)
+            #    self.priorities[dep] = PRI_INDIRECT
+
             if manager.options.dump_inference_stats:
                 dump_type_stats(self.tree, self.xpath, inferred=True,
                                 typemap=manager.type_checker.type_map)
             manager.report_file(self.tree)
 
+    def valid_references(self) -> Set[str]:
+        valid_refs = set(self.dependencies + self.suppressed + self.ancestors)
+        valid_refs .add(self.id)
+
+        if "os" in valid_refs:
+            valid_refs.add("os.path")
+
+        return valid_refs 
+
     def write_cache(self) -> None:
         if self.path and self.manager.options.incremental and not self.manager.errors.is_errors():
             dep_prios = [self.priorities.get(dep, PRI_HIGH) for dep in self.dependencies]

mypy/checker.py

@@ -143,8 +143,12 @@ def __init__(self, errors: Errors, modules: Dict[str, MypyFile], options: Option
         self.deferred_nodes = []
         self.pass_num = 0
         self.current_node_deferred = False
+        self.encountered = set()  # type: Set[str]
 
-    def visit_file(self, file_node: MypyFile, path: str, current_dependencies: List[str]) -> None:
+    def get_encountered(self) -> Set[str]:
+        return self.encountered
+
+    def visit_file(self, file_node: MypyFile, path: str, valid_refs: Set[str]) -> None:
         """Type check a mypy file with the given path."""
         self.pass_num = 0
         self.is_stub = file_node.is_stub
@@ -153,11 +157,8 @@ def visit_file(self, file_node: MypyFile, path: str, current_dependencies: List[
         self.weak_opts = file_node.weak_opts
         self.enter_partial_types()
         self.is_typeshed_stub = self.errors.is_typeshed_file(path)
-        self.valid_module_references = set(current_dependencies)
-        self.valid_module_references.add(file_node.fullname())
-
-        if "os" in self.valid_module_references:
-            self.valid_module_references.add("os.path")
+        self.valid_module_references = valid_refs
+        self.encountered = set()
 
         for d in file_node.defs:
             self.accept(d)

mypy/checkexpr.py

@@ -76,6 +76,7 @@ def visit_name_expr(self, e: NameExpr) -> Type:
         It can be of any kind: local, member or global.
         """
         if e.kind == MODULE_REF and e.fullname not in self.chk.valid_module_references:
+            self.chk.encountered.add(e.fullname)
             self.chk.msg.indirect_import(e.fullname, e)
         result = self.analyze_ref_expr(e)
         return self.chk.narrow_type_from_binder(e, result)
@@ -862,8 +863,10 @@ def visit_member_expr(self, e: MemberExpr) -> Type:
         """Visit member expression (of form e.id)."""
         base = e.expr
         if isinstance(base, RefExpr) and base.kind == MODULE_REF:
+            self.chk.encountered.add(base.fullname)
             if base.fullname not in self.chk.valid_module_references:
-                self.chk.msg.indirect_import(base.fullname, e)
+                pass
+                #self.chk.msg.indirect_import(base.fullname, e)
         result = self.analyze_ordinary_member_access(e, False)
         return self.chk.narrow_type_from_binder(e, result)
 

mypy/fixup.py

@@ -1,6 +1,6 @@
 """Fix up various things after deserialization."""
 
-from typing import Any, Dict, Optional, cast
+from typing import Any, Dict, Optional, Set, cast
 
 from mypy.nodes import (MypyFile, SymbolNode, SymbolTable, SymbolTableNode,
                         TypeInfo, FuncDef, OverloadedFuncDef, Decorator, Var,
@@ -12,8 +12,8 @@
 from mypy.visitor import NodeVisitor
 
 
-def fixup_module_pass_one(tree: MypyFile, modules: Dict[str, MypyFile]) -> None:
-    node_fixer = NodeFixer(modules)
+def fixup_module_pass_one(tree: MypyFile, modules: Dict[str, MypyFile], valid_references: Optional[Set[str]] = None) -> None:
+    node_fixer = NodeFixer(modules, valid_refs=valid_references, name=tree.fullname())
     node_fixer.visit_symbol_table(tree.names)
 
 
@@ -34,10 +34,12 @@ def compute_all_mros(symtab: SymbolTable, modules: Dict[str, MypyFile]) -> None:
 class NodeFixer(NodeVisitor[None]):
     current_info = None  # type: Optional[TypeInfo]
 
-    def __init__(self, modules: Dict[str, MypyFile], type_fixer: 'TypeFixer' = None) -> None:
+    def __init__(self, modules: Dict[str, MypyFile], type_fixer: 'TypeFixer' = None, valid_refs: Set[str] = None, name: str = None) -> None:
         self.modules = modules
+        self.valid_references = valid_refs
+        self.name = name
         if type_fixer is None:
-            type_fixer = TypeFixer(self.modules)
+            type_fixer = TypeFixer(self.modules, self.valid_references, self.name)
         self.type_fixer = type_fixer
 
     # NOTE: This method isn't (yet) part of the NodeVisitor API.
@@ -68,6 +70,12 @@ def visit_symbol_table(self, symtab: SymbolTable) -> None:
         for key, value in list(symtab.items()):
             cross_ref = value.cross_ref
             if cross_ref is not None:  # Fix up cross-reference.
+                original_module = value.cross_ref.rsplit(".", 1)[0]
+                if original_module not in self.valid_references:
+                    if self.name is not None:
+                        print(self.name)
+                        self.name = None
+                    print('    ', cross_ref)
                 del value.cross_ref
                 if cross_ref in self.modules:
                     value.node = self.modules[cross_ref]
@@ -131,14 +139,22 @@ def visit_var(self, v: Var) -> None:
 
 
 class TypeFixer(TypeVisitor[None]):
-    def __init__(self, modules: Dict[str, MypyFile]) -> None:
+    def __init__(self, modules: Dict[str, MypyFile], valid_refs: Set[str] = None, name: str = None) -> None:
         self.modules = modules
+        self.valid_references = valid_refs
+        self.name = name
 
     def visit_instance(self, inst: Instance) -> None:
         # TODO: Combine Instances that are exactly the same?
         type_ref = inst.type_ref
         if type_ref is None:
             return  # We've already been here.
+        original = type_ref.rsplit('.', 1)[0]
+        if original not in self.valid_references:
+            if self.name is not None:
+                print(self.name + ' (type ref)')
+                self.name = None
+            print('    ', type_ref + ' (type ref)')
         del inst.type_ref
         node = lookup_qualified(self.modules, type_ref)
         if isinstance(node, TypeInfo):

parent/__init__.py

@@ -0,0 +1,5 @@
+from parent import a
+
+class TestClass:
+    def pipe(self) -> a.TestClassA:
+        return a.TestClassA()

parent/a/__init__.py

@@ -0,0 +1,5 @@
+from parent.a import b
+
+class TestClassA:
+    def pipe(self) -> b.TestClassB:
+        return b.TestClassB()

parent/a/b.py

@@ -0,0 +1,4 @@
+value = 3
+class TestClassB:
+    def pipe(self) -> int:
+        return 3