Move global data to nodes.TypeInfo

python · JukkaL · Aug 16, 2017 · Mar 26, 2017 · Mar 26, 2017 · Mar 26, 2017
commit d012e387f9c7a341839250183d1afb612a3af17d
diff --git a/mypy/constraints.py b/mypy/constraints.py
@@ -261,9 +261,6 @@ def visit_uninhabited_type(self, t: UninhabitedType) -> bool:
         return False
 
 
-INFERRING = []  # type: List[nodes.TypeInfo]
-
-
 class ConstraintBuilderVisitor(TypeVisitor[List[Constraint]]):
     """Visitor class for inferring type constraints."""
 
@@ -311,32 +308,32 @@ def visit_type_var(self, template: TypeVarType) -> List[Constraint]:
     # Non-leaf types
 
     def visit_instance(self, template: Instance) -> List[Constraint]:
-        global INFERRING
+        inferring = nodes.TypeInfo.inferring
         actual = self.actual
         res = []  # type: List[Constraint]
         if isinstance(actual, CallableType) and actual.fallback is not None:
             actual = actual.fallback
         if isinstance(actual, Instance):
             instance = actual
             if (template.type.is_protocol and self.direction == SUPERTYPE_OF and
-                    template.type not in INFERRING and
+                    template.type not in inferring and
                     mypy.subtypes.is_subtype(instance, erase_typevars(template))):
-                INFERRING.append(template.type)
+                inferring.append(template.type)
                 for member in template.type.protocol_members:
                     inst = mypy.subtypes.find_member(member, instance, instance)
                     temp = mypy.subtypes.find_member(member, template, template)
                     res.extend(infer_constraints(temp, inst, self.direction))
-                INFERRING.pop()
+                inferring.pop()
                 return res
             elif (instance.type.is_protocol and self.direction == SUBTYPE_OF and
-                  instance.type not in INFERRING and
+                  instance.type not in inferring and
                   mypy.subtypes.is_subtype(erase_typevars(template), instance)):
-                INFERRING.append(instance.type)
+                inferring.append(instance.type)
                 for member in instance.type.protocol_members:
                     inst = mypy.subtypes.find_member(member, instance, instance)
                     temp = mypy.subtypes.find_member(member, template, template)
                     res.extend(infer_constraints(temp, inst, self.direction))
-                INFERRING.pop()
+                inferring.pop()
                 return res
             if (self.direction == SUBTYPE_OF and
                     template.type.has_base(instance.type.fullname())):

diff --git a/mypy/nodes.py b/mypy/nodes.py
@@ -4,7 +4,7 @@
 from abc import abstractmethod
 
 from typing import (
-    Any, TypeVar, List, Tuple, cast, Set, Dict, Union, Optional
+    Any, TypeVar, List, Tuple, cast, Set, Dict, Union, Optional, ClassVar
 )
 
 import mypy.strconv
@@ -1925,6 +1925,16 @@ class is generic then it will be a type constructor of higher kind.
     runtime_protocol = False               # Does this protocol support isinstance checks?
     abstract_attributes = None  # type: List[str]
     protocol_members = None  # type: List[str]
+
+    # These represent global structural subtype matrices.
+    # If concurrent/parallel type checking will be added in future,
+    # then there should be one matrix per thread/process to avoid false negatives
+    # during the type checking phase.
+    assuming = []  # type: ClassVar[List[Tuple[Instance, Instance]]]
+    assuming_proper = []  # type: ClassVar[List[Tuple[Instance, Instance]]]
+    # Ditto for temporary stack of recursive constraint inference.
+    inferring = []  # type: ClassVar[List[TypeInfo]]
+
     # Classes inheriting from Enum shadow their true members with a __getattr__, so we
     # have to treat them as a special case.
     is_enum = False

diff --git a/mypy/subtypes.py b/mypy/subtypes.py
@@ -13,7 +13,7 @@
 from mypy import messages, sametypes
 from mypy.nodes import (
     CONTRAVARIANT, COVARIANT, FuncBase, Var, Decorator, OverloadedFuncDef,
-    ARG_POS, ARG_OPT, ARG_NAMED, ARG_NAMED_OPT, ARG_STAR, ARG_STAR2,
+    ARG_POS, ARG_OPT, ARG_NAMED, ARG_NAMED_OPT, ARG_STAR, ARG_STAR2, TypeInfo
 )
 from mypy.maptype import map_instance_to_supertype
 from mypy.expandtype import expand_type_by_instance
@@ -287,18 +287,14 @@ def visit_type_type(self, left: TypeType) -> bool:
         return False
 
 
-ASSUMING = []  # type: List[Tuple[Instance, Instance]]
-ASSUMING_PROPER = []  # type: List[Tuple[Instance, Instance]]
-
-
 def is_protocol_implementation(left: Instance, right: Instance, allow_any: bool = True) -> bool:
     assert right.type.is_protocol
     is_compat = None  # type: Callable[[Type, Type], bool]
     if allow_any:
         is_compat = is_subtype
     else:
         is_compat = is_proper_subtype
-    assuming = ASSUMING if allow_any else ASSUMING_PROPER
+    assuming = TypeInfo.assuming if allow_any else TypeInfo.assuming_proper
     for (l, r) in reversed(assuming):
         if sametypes.is_same_type(l, left) and sametypes.is_same_type(r, right):
             return True