More tweaks to support mypyc (#5487)

Author: msullivan

mypy/checkstrformat.py

@@ -36,7 +36,8 @@ def compile_format_re() -> Pattern[str]:
 
 
 class ConversionSpecifier:
-    def __init__(self, key: str, flags: str, width: str, precision: str, type: str) -> None:
+    def __init__(self, key: Optional[str],
+                 flags: str, width: str, precision: str, type: str) -> None:
         self.key = key
         self.flags = flags
         self.width = width
@@ -179,6 +180,7 @@ def check_mapping_str_interpolation(self, specifiers: List[ConversionSpecifier],
                 if specifier.type == '%':
                     # %% is allowed in mappings, no checking is required
                     continue
+                assert specifier.key is not None
                 if specifier.key not in mapping:
                     self.msg.key_not_in_mapping(specifier.key, replacements)
                     return

mypy/errors.py

@@ -106,10 +106,10 @@ class Errors:
     import_ctx = None  # type: List[Tuple[str, int]]
 
     # Path name prefix that is removed from all paths, if set.
-    ignore_prefix = None  # type: str
+    ignore_prefix = None  # type: Optional[str]
 
     # Path to current file.
-    file = None  # type: str
+    file = ''  # type: str
 
     # Ignore errors on these lines of each file.
     ignored_lines = None  # type: Dict[str, Set[int]]
@@ -548,7 +548,7 @@ def __init__(self,
         self.module_with_blocker = module_with_blocker
 
 
-def remove_path_prefix(path: str, prefix: str) -> str:
+def remove_path_prefix(path: str, prefix: Optional[str]) -> str:
     """If path starts with prefix, return copy of path with the prefix removed.
     Otherwise, return path. If path is None, return None.
     """

mypy/indirection.py

@@ -1,4 +1,4 @@
-from typing import Dict, Iterable, List, Optional, Set
+from typing import Dict, Iterable, List, Optional, Set, Union
 
 from mypy.types import SyntheticTypeVisitor
 import mypy.types as types
@@ -22,9 +22,10 @@ def __init__(self) -> None:
         self.cache = {}  # type: Dict[types.Type, Set[str]]
 
     def find_modules(self, typs: Iterable[types.Type]) -> Set[str]:
-        return self._visit(*typs)
+        return self._visit(typs)
 
-    def _visit(self, *typs: types.Type) -> Set[str]:
+    def _visit(self, typ_or_typs: Union[types.Type, Iterable[types.Type]]) -> Set[str]:
+        typs = [typ_or_typs] if isinstance(typ_or_typs, types.Type) else typ_or_typs
         output = set()  # type: Set[str]
         for typ in typs:
             if typ in self.cache:
@@ -36,10 +37,10 @@ def _visit(self, *typs: types.Type) -> Set[str]:
         return output
 
     def visit_unbound_type(self, t: types.UnboundType) -> Set[str]:
-        return self._visit(*t.args)
+        return self._visit(t.args)
 
     def visit_type_list(self, t: types.TypeList) -> Set[str]:
-        return self._visit(*t.items)
+        return self._visit(t.items)
 
     def visit_callable_argument(self, t: types.CallableArgument) -> Set[str]:
         return self._visit(t.typ)
@@ -60,10 +61,10 @@ def visit_deleted_type(self, t: types.DeletedType) -> Set[str]:
         return set()
 
     def visit_type_var(self, t: types.TypeVarType) -> Set[str]:
-        return self._visit(*t.values) | self._visit(t.upper_bound)
+        return self._visit(t.values) | self._visit(t.upper_bound)
 
     def visit_instance(self, t: types.Instance) -> Set[str]:
-        out = self._visit(*t.args)
+        out = self._visit(t.args)
         if t.type:
             # Uses of a class depend on everything in the MRO,
             # as changes to classes in the MRO can add types to methods,
@@ -75,25 +76,25 @@ def visit_instance(self, t: types.Instance) -> Set[str]:
         return out
 
     def visit_callable_type(self, t: types.CallableType) -> Set[str]:
-        out = self._visit(*t.arg_types) | self._visit(t.ret_type)
+        out = self._visit(t.arg_types) | self._visit(t.ret_type)
         if t.definition is not None:
             out.update(extract_module_names(t.definition.fullname()))
         return out
 
     def visit_overloaded(self, t: types.Overloaded) -> Set[str]:
-        return self._visit(*t.items()) | self._visit(t.fallback)
+        return self._visit(t.items()) | self._visit(t.fallback)
 
     def visit_tuple_type(self, t: types.TupleType) -> Set[str]:
-        return self._visit(*t.items) | self._visit(t.fallback)
+        return self._visit(t.items) | self._visit(t.fallback)
 
     def visit_typeddict_type(self, t: types.TypedDictType) -> Set[str]:
-        return self._visit(*t.items.values()) | self._visit(t.fallback)
+        return self._visit(t.items.values()) | self._visit(t.fallback)
 
     def visit_star_type(self, t: types.StarType) -> Set[str]:
         return set()
 
     def visit_union_type(self, t: types.UnionType) -> Set[str]:
-        return self._visit(*t.items)
+        return self._visit(t.items)
 
     def visit_partial_type(self, t: types.PartialType) -> Set[str]:
         return set()

mypy/server/subexpr.py

@@ -21,24 +21,50 @@ class SubexpressionFinder(TraverserVisitor):
     def __init__(self) -> None:
         self.expressions = []  # type: List[Expression]
 
-    def _visit_leaf(self, o: Expression) -> None:
+    def visit_int_expr(self, o: Expression) -> None:
         self.add(o)
 
-    visit_int_expr = _visit_leaf
-    visit_name_expr = _visit_leaf
-    visit_float_expr = _visit_leaf
-    visit_str_expr = _visit_leaf
-    visit_bytes_expr = _visit_leaf
-    visit_unicode_expr = _visit_leaf
-    visit_complex_expr = _visit_leaf
-    visit_ellipsis = _visit_leaf
-    visit_super_expr = _visit_leaf
-    visit_type_var_expr = _visit_leaf
-    visit_type_alias_expr = _visit_leaf
-    visit_namedtuple_expr = _visit_leaf
-    visit_typeddict_expr = _visit_leaf
-    visit__promote_expr = _visit_leaf
-    visit_newtype_expr = _visit_leaf
+    def visit_name_expr(self, o: Expression) -> None:
+        self.add(o)
+
+    def visit_float_expr(self, o: Expression) -> None:
+        self.add(o)
+
+    def visit_str_expr(self, o: Expression) -> None:
+        self.add(o)
+
+    def visit_bytes_expr(self, o: Expression) -> None:
+        self.add(o)
+
+    def visit_unicode_expr(self, o: Expression) -> None:
+        self.add(o)
+
+    def visit_complex_expr(self, o: Expression) -> None:
+        self.add(o)
+
+    def visit_ellipsis(self, o: Expression) -> None:
+        self.add(o)
+
+    def visit_super_expr(self, o: Expression) -> None:
+        self.add(o)
+
+    def visit_type_var_expr(self, o: Expression) -> None:
+        self.add(o)
+
+    def visit_type_alias_expr(self, o: Expression) -> None:
+        self.add(o)
+
+    def visit_namedtuple_expr(self, o: Expression) -> None:
+        self.add(o)
+
+    def visit_typeddict_expr(self, o: Expression) -> None:
+        self.add(o)
+
+    def visit__promote_expr(self, o: Expression) -> None:
+        self.add(o)
+
+    def visit_newtype_expr(self, o: Expression) -> None:
+        self.add(o)
 
     def visit_member_expr(self, e: MemberExpr) -> None:
         self.add(e)

mypy/typestate.py

@@ -51,29 +51,29 @@ class TypeState:
     # A blocking error will be generated in this case, since we can't proceed safely.
     # For the description of kinds of protocol dependencies and corresponding examples,
     # see _snapshot_protocol_deps.
-    proto_deps = {}  # type: Optional[Dict[str, Set[str]]]
+    proto_deps = {}  # type: ClassVar[Optional[Dict[str, Set[str]]]]
 
     # Protocols (full names) a given class attempted to implement.
     # Used to calculate fine grained protocol dependencies and optimize protocol
     # subtype cache invalidation in fine grained mode. For example, if we pass a value
     # of type a.A to a function expecting something compatible with protocol p.P,
     # we'd have 'a.A' -> {'p.P', ...} in the map. This map is flushed after every incremental
     # update.
-    _attempted_protocols = {}  # type: Dict[str, Set[str]]
+    _attempted_protocols = {}  # type: ClassVar[Dict[str, Set[str]]]
     # We also snapshot protocol members of the above protocols. For example, if we pass
     # a value of type a.A to a function expecting something compatible with Iterable, we'd have
     # 'a.A' -> {'__iter__', ...} in the map. This map is also flushed after every incremental
     # update. This map is needed to only generate dependencies like <a.A.__iter__> -> <a.A>
     # instead of a wildcard to avoid unnecessarily invalidating classes.
-    _checked_against_members = {}  # type: Dict[str, Set[str]]
+    _checked_against_members = {}  # type: ClassVar[Dict[str, Set[str]]]
     # TypeInfos that appeared as a left type (subtype) in a subtype check since latest
     # dependency snapshot update. This is an optimisation for fine grained mode; during a full
     # run we only take a dependency snapshot at the very end, so this set will contain all
     # subtype-checked TypeInfos. After a fine grained update however, we can gather only new
     # dependencies generated from (typically) few TypeInfos that were subtype-checked
     # (i.e. appeared as r.h.s. in an assignment or an argument in a function call in
     # a re-checked target) during the update.
-    _rechecked_types = set()  # type: Set[TypeInfo]
+    _rechecked_types = set()  # type: ClassVar[Set[TypeInfo]]
 
     @classmethod
     def reset_all_subtype_caches(cls) -> None: