Make FakeInfo a more general-purpose TypeInfo placeholder (#5469)

There are a lot of places in mypy currently that shove None into
fields expecting TypeInfo. Since mypyc does not appreciate this kind
of behavior, use FakeInfo instances instead of None. FakeInfo is
generalized to allow different assertion messages and to override
`__bool__` so that it can be conveniently checked against.

Author: msullivan

mypy/checker.py

@@ -435,7 +435,7 @@ def check_overlapping_overloads(self, defn: OverloadedFuncDef) -> None:
                 assert isinstance(inner_type, CallableType)
                 impl_type = inner_type
 
-        is_descriptor_get = defn.info is not None and defn.name() == "__get__"
+        is_descriptor_get = defn.info and defn.name() == "__get__"
         for i, item in enumerate(defn.items):
             # TODO overloads involving decorators
             assert isinstance(item, Decorator)
@@ -979,7 +979,7 @@ def check_reverse_op_method(self, defn: FuncItem,
         # just decides whether it's worth calling
         # check_overlapping_op_methods().
 
-        assert defn.info is not None
+        assert defn.info
 
         # First check for a valid signature
         method_type = CallableType([AnyType(TypeOfAny.special_form),
@@ -2765,7 +2765,7 @@ def check_for_untyped_decorator(self,
             self.msg.typed_function_untyped_decorator(func.name(), dec_expr)
 
     def check_incompatible_property_override(self, e: Decorator) -> None:
-        if not e.var.is_settable_property and e.func.info is not None:
+        if not e.var.is_settable_property and e.func.info:
             name = e.func.name()
             for base in e.func.info.mro[1:]:
                 base_attr = base.names.get(name)
@@ -3322,7 +3322,7 @@ def enter_partial_types(self, *, is_function: bool = False,
                     var.type = AnyType(TypeOfAny.from_error)
 
     def is_defined_in_base_class(self, var: Var) -> bool:
-        if var.info is not None:
+        if var.info:
             for base in var.info.mro[1:]:
                 if base.get(var.name()) is not None:
                     return True

mypy/fastparse.py

@@ -23,10 +23,11 @@
     AwaitExpr, TempNode, Expression, Statement,
     ARG_POS, ARG_OPT, ARG_STAR, ARG_NAMED, ARG_NAMED_OPT, ARG_STAR2,
     check_arg_names,
+    FakeInfo,
 )
 from mypy.types import (
     Type, CallableType, AnyType, UnboundType, TupleType, TypeList, EllipsisType, CallableArgument,
-    TypeOfAny
+    TypeOfAny, Instance,
 )
 from mypy import defaults
 from mypy import messages
@@ -59,7 +60,8 @@
 
 # There is no way to create reasonable fallbacks at this stage,
 # they must be patched later.
-_dummy_fallback = None  # type: Any
+MISSING_FALLBACK = FakeInfo("fallback can't be filled out until semanal")
+_dummy_fallback = Instance(MISSING_FALLBACK, [], -1)
 
 TYPE_COMMENT_SYNTAX_ERROR = 'syntax error in type comment'
 TYPE_COMMENT_AST_ERROR = 'invalid type comment or annotation'

mypy/fastparse2.py

@@ -34,9 +34,10 @@
     SetComprehension, ComplexExpr, EllipsisExpr, YieldExpr, Argument,
     Expression, Statement, BackquoteExpr, PrintStmt, ExecStmt,
     ARG_POS, ARG_OPT, ARG_STAR, ARG_NAMED, ARG_STAR2, OverloadPart, check_arg_names,
+    FakeInfo,
 )
 from mypy.types import (
-    Type, CallableType, AnyType, UnboundType, EllipsisType, TypeOfAny
+    Type, CallableType, AnyType, UnboundType, EllipsisType, TypeOfAny, Instance,
 )
 from mypy import messages
 from mypy.errors import Errors
@@ -70,7 +71,8 @@
 
 # There is no way to create reasonable fallbacks at this stage,
 # they must be patched later.
-_dummy_fallback = None  # type: Any
+MISSING_FALLBACK = FakeInfo("fallback can't be filled out until semanal")
+_dummy_fallback = Instance(MISSING_FALLBACK, [], -1)
 
 TYPE_COMMENT_SYNTAX_ERROR = 'syntax error in type comment'
 TYPE_COMMENT_AST_ERROR = 'invalid type comment'

mypy/indirection.py

@@ -64,7 +64,7 @@ def visit_type_var(self, t: types.TypeVarType) -> Set[str]:
 
     def visit_instance(self, t: types.Instance) -> Set[str]:
         out = self._visit(*t.args)
-        if t.type is not None:
+        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,
             # change property types, change the MRO itself, etc.

mypy/nodes.py

@@ -399,7 +399,7 @@ def __init__(self) -> None:
         self.unanalyzed_type = None  # type: Optional[mypy.types.Type]
         # If method, reference to TypeInfo
         # TODO: Type should be Optional[TypeInfo]
-        self.info = cast(TypeInfo, None)
+        self.info = FUNC_NO_INFO
         self.is_property = False
         self.is_class = False
         self.is_static = False
@@ -727,7 +727,7 @@ def __init__(self, name: str, type: 'Optional[mypy.types.Type]' = None) -> None:
         # TODO: Should be Optional[str]
         self._fullname = cast(str, None)  # Name with module prefix
         # TODO: Should be Optional[TypeInfo]
-        self.info = cast(TypeInfo, None)  # Defining class (for member variables)
+        self.info = VAR_NO_INFO
         self.type = type  # type: Optional[mypy.types.Type] # Declared or inferred type, or None
         # Is this the first argument to an ordinary method (usually "self")?
         self.is_self = False
@@ -807,6 +807,7 @@ def __init__(self,
         self.type_vars = type_vars or []
         self.base_type_exprs = base_type_exprs or []
         self.removed_base_type_exprs = []
+        self.info = CLASSDEF_NO_INFO
         self.metaclass = metaclass
         self.decorators = []
         self.keywords = OrderedDict(keywords or [])
@@ -1412,7 +1413,7 @@ class IndexExpr(Expression):
     base = None  # type: Expression
     index = None  # type: Expression
     # Inferred __getitem__ method type
-    method_type = None  # type: mypy.types.Type
+    method_type = None  # type: Optional[mypy.types.Type]
     # If not None, this is actually semantically a type application
     # Class[type, ...] or a type alias initializer.
     analyzed = None  # type: Union[TypeApplication, TypeAliasExpr, None]
@@ -2154,7 +2155,7 @@ class is generic then it will be a type constructor of higher kind.
     # type (NamedTuple or TypedDict) was generated, store the corresponding
     # TypeInfo here. (This attribute does not need to be serialized, it is only
     # needed during the semantic passes.)
-    replaced = None  # type: TypeInfo
+    replaced = None  # type: Optional[TypeInfo]
 
     # This is a dictionary that will be serialized and un-serialized as is.
     # It is useful for plugins to add their data to save in the cache.
@@ -2414,11 +2415,27 @@ class FakeInfo(TypeInfo):
     #    pass cleanly.
     # 2. If NOT_READY value is accidentally used somewhere, it will be obvious where the value
     #    is from, whereas a 'None' value could come from anywhere.
-    def __init__(self, *args: Any, **kwargs: Any) -> None:
-        pass
+    #
+    # Additionally, this serves as a more general-purpose placeholder
+    # for missing TypeInfos in a number of places where the excuses
+    # for not being Optional are a little weaker.
+    #
+    # It defines a __bool__ method so that it can be conveniently
+    # tested against in the same way that it would be if things were
+    # properly optional.
+    def __init__(self, msg: str) -> None:
+        self.msg = msg
+
+    def __bool__(self) -> bool:
+        return False
 
     def __getattribute__(self, attr: str) -> None:
-        raise AssertionError('De-serialization failure: TypeInfo not fixed')
+        raise AssertionError(object.__getattribute__(self, 'msg'))
+
+
+VAR_NO_INFO = FakeInfo('Var is lacking info')  # type: TypeInfo
+CLASSDEF_NO_INFO = FakeInfo('ClassDef is lacking info')  # type: TypeInfo
+FUNC_NO_INFO = FakeInfo('FuncBase for non-methods lack info')  # type: TypeInfo
 
 
 class TypeAlias(SymbolNode):
@@ -2658,8 +2675,10 @@ def fullname(self) -> Optional[str]:
     @property
     def type(self) -> 'Optional[mypy.types.Type]':
         node = self.node
-        if ((isinstance(node, Var) or isinstance(node, FuncBase))
-                and node.type is not None):
+        if (isinstance(node, Var) and node.type is not None):
+            return node.type
+        # mypy thinks this branch is unreachable but it is wrong (#3603)
+        elif (isinstance(node, FuncBase) and node.type is not None):
             return node.type
         elif isinstance(node, Decorator):
             return node.var.type
@@ -2764,7 +2783,8 @@ def get_member_expr_fullname(expr: MemberExpr) -> Optional[str]:
 deserialize_map = {
     key: obj.deserialize  # type: ignore
     for key, obj in globals().items()
-    if isinstance(obj, type) and issubclass(obj, SymbolNode) and obj is not SymbolNode
+    if type(obj) is not FakeInfo
+    and isinstance(obj, type) and issubclass(obj, SymbolNode) and obj is not SymbolNode
 }
 
 

mypy/semanal_pass3.py

@@ -251,7 +251,7 @@ def visit_assignment_stmt(self, s: AssignmentStmt) -> None:
         if (isinstance(s.lvalues[0], NameExpr) and s.lvalues[0].kind == MDEF
                 and isinstance(s.lvalues[0].node, Var)):
             var = s.lvalues[0].node
-            if var.info is not None and var.is_inferred and not var.is_classvar:
+            if var.info and var.is_inferred and not var.is_classvar:
                 for base in var.info.mro[1:]:
                     tnode = base.names.get(var.name())
                     if (tnode is not None and isinstance(tnode.node, Var)

mypy/server/astmerge.py

@@ -300,7 +300,8 @@ def process_type_info(self, info: Optional[TypeInfo]) -> None:
         self.fixup_type(info.tuple_type)
         self.fixup_type(info.typeddict_type)
         info.defn.info = self.fixup(info)
-        info.replaced = self.fixup(info.replaced)
+        if info.replaced:
+            info.replaced = self.fixup(info.replaced)
         replace_nodes_in_symbol_table(info.names, self.replacements)
         for i, item in enumerate(info.mro):
             info.mro[i] = self.fixup(info.mro[i])

mypy/server/update.py

@@ -1070,7 +1070,7 @@ def target_from_node(module: str,
             return None
         return module
     elif isinstance(node, (OverloadedFuncDef, FuncDef)):
-        if node.info is not None:
+        if node.info:
             return '%s.%s' % (node.info.fullname(), node.name())
         else:
             return '%s.%s' % (module, node.name())

mypy/typeanal.py

@@ -413,7 +413,10 @@ def visit_callable_type(self, t: CallableType, nested: bool = True) -> Type:
                 variables = self.bind_function_type_variables(t, t)
             ret = t.copy_modified(arg_types=self.anal_array(t.arg_types, nested=nested),
                                   ret_type=self.anal_type(t.ret_type, nested=nested),
-                                  fallback=t.fallback or self.named_type('builtins.function'),
+                                  # If the fallback isn't filled in yet,
+                                  # its type will be the falsey FakeInfo
+                                  fallback=(t.fallback if t.fallback.type
+                                            else self.named_type('builtins.function')),
                                   variables=self.anal_var_defs(variables))
         return ret
 
@@ -437,7 +440,9 @@ def visit_tuple_type(self, t: TupleType) -> Type:
             else:
                 return AnyType(TypeOfAny.from_error)
         any_type = AnyType(TypeOfAny.special_form)
-        fallback = t.fallback if t.fallback else self.named_type('builtins.tuple', [any_type])
+        # If the fallback isn't filled in yet, its type will be the falsey FakeInfo
+        fallback = (t.fallback if t.fallback.type
+                    else self.named_type('builtins.tuple', [any_type]))
         return TupleType(self.anal_array(t.items), fallback, t.line)
 
     def visit_typeddict_type(self, t: TypedDictType) -> Type:

mypy/types.py

@@ -469,9 +469,7 @@ def deserialize(cls, data: JsonDict) -> 'DeletedType':
 
 
 # Fake TypeInfo to be used as a placeholder during Instance de-serialization.
-NOT_READY = mypy.nodes.FakeInfo(mypy.nodes.SymbolTable(),
-                                mypy.nodes.ClassDef('<NOT READY>', mypy.nodes.Block([])),
-                                '<NOT READY>')
+NOT_READY = mypy.nodes.FakeInfo('De-serialization failure: TypeInfo not fixed')
 
 
 class Instance(Type):
@@ -485,7 +483,7 @@ class Instance(Type):
     def __init__(self, typ: mypy.nodes.TypeInfo, args: List[Type],
                  line: int = -1, column: int = -1, erased: bool = False) -> None:
         super().__init__(line, column)
-        assert typ is NOT_READY or typ.fullname() not in ["builtins.Any", "typing.Any"]
+        assert not typ or typ.fullname() not in ["builtins.Any", "typing.Any"]
         self.type = typ
         self.args = args
         self.erased = erased  # True if result of type variable substitution