Move function_type and callable_type

Author: msullivan

mypy/checker.py

@@ -34,7 +34,7 @@
     Type, AnyType, CallableType, FunctionLike, Overloaded, TupleType, TypedDictType,
     Instance, NoneType, strip_type, TypeType, TypeOfAny,
     UnionType, TypeVarId, TypeVarType, PartialType, DeletedType, UninhabitedType, TypeVarDef,
-    function_type, is_named_instance, union_items, TypeQuery, LiteralType,
+    is_named_instance, union_items, TypeQuery, LiteralType,
     is_optional, remove_optional, TypeTranslator, StarType, get_proper_type, ProperType,
     get_proper_types, is_literal_type
 )
@@ -50,7 +50,7 @@
 from mypy.typeops import (
     map_type_from_supertype, bind_self, erase_to_bound, make_simplified_union,
     erase_def_to_union_or_bound, erase_to_union_or_bound,
-    true_only, false_only,
+    true_only, false_only, function_type,
 )
 from mypy import message_registry
 from mypy.subtypes import (

mypy/checkexpr.py

@@ -17,7 +17,7 @@
     Type, AnyType, CallableType, Overloaded, NoneType, TypeVarDef,
     TupleType, TypedDictType, Instance, TypeVarType, ErasedType, UnionType,
     PartialType, DeletedType, UninhabitedType, TypeType, TypeOfAny, LiteralType, LiteralValue,
-    is_named_instance, function_type, callable_type, FunctionLike,
+    is_named_instance, FunctionLike,
     StarType, is_optional, remove_optional, is_generic_instance, get_proper_type, ProperType,
     get_proper_types
 )
@@ -59,6 +59,7 @@
 from mypy.plugin import Plugin, MethodContext, MethodSigContext, FunctionContext
 from mypy.typeops import (
     tuple_fallback, make_simplified_union, true_only, false_only, erase_to_union_or_bound,
+    function_type, callable_type,
 )
 import mypy.errorcodes as codes
 

mypy/checkmember.py

@@ -6,7 +6,7 @@
 from mypy.types import (
     Type, Instance, AnyType, TupleType, TypedDictType, CallableType, FunctionLike, TypeVarDef,
     Overloaded, TypeVarType, UnionType, PartialType, TypeOfAny, LiteralType,
-    DeletedType, NoneType, TypeType, function_type, get_type_vars, get_proper_type, ProperType
+    DeletedType, NoneType, TypeType, get_type_vars, get_proper_type, ProperType
 )
 from mypy.nodes import (
     TypeInfo, FuncBase, Var, FuncDef, SymbolNode, Context, MypyFile, TypeVarExpr,
@@ -24,7 +24,7 @@
 from mypy import meet
 from mypy.typeops import (
     tuple_fallback, bind_self, erase_to_bound, class_callable, type_object_type_from_function,
-    make_simplified_union,
+    make_simplified_union, function_type,
 )
 
 if TYPE_CHECKING:  # import for forward declaration only

mypy/semanal.py

@@ -84,11 +84,12 @@
 from mypy.errorcodes import ErrorCode
 from mypy import message_registry, errorcodes as codes
 from mypy.types import (
-    FunctionLike, UnboundType, TypeVarDef, TupleType, UnionType, StarType, function_type,
+    FunctionLike, UnboundType, TypeVarDef, TupleType, UnionType, StarType,
     CallableType, Overloaded, Instance, Type, AnyType, LiteralType, LiteralValue,
     TypeTranslator, TypeOfAny, TypeType, NoneType, PlaceholderType, TPDICT_NAMES, ProperType,
     get_proper_type, get_proper_types
 )
+from mypy.typeops import function_type
 from mypy.type_visitor import TypeQuery
 from mypy.nodes import implicit_module_attrs
 from mypy.typeanal import (

mypy/semanal_infer.py

@@ -4,8 +4,9 @@
 
 from mypy.nodes import Expression, Decorator, CallExpr, FuncDef, RefExpr, Var, ARG_POS
 from mypy.types import (
-    Type, CallableType, AnyType, TypeOfAny, TypeVarType, function_type, ProperType, get_proper_type
+    Type, CallableType, AnyType, TypeOfAny, TypeVarType, ProperType, get_proper_type
 )
+from mypy.typeops import function_type
 from mypy.typevars import has_no_typevars
 from mypy.semanal_shared import SemanticAnalyzerInterface
 

mypy/subtypes.py

@@ -4,7 +4,7 @@
 from typing_extensions import Final
 
 from mypy.types import (
-    Type, AnyType, UnboundType, TypeVisitor, FormalArgument, NoneType, function_type,
+    Type, AnyType, UnboundType, TypeVisitor, FormalArgument, NoneType,
     Instance, TypeVarType, CallableType, TupleType, TypedDictType, UnionType, Overloaded,
     ErasedType, PartialType, DeletedType, UninhabitedType, TypeType, is_named_instance,
     FunctionLike, TypeOfAny, LiteralType, ProperType, get_proper_type
@@ -616,8 +616,8 @@ def find_node_type(node: Union[Var, FuncBase], itype: Instance, subtype: Type) -
     from mypy.typeops import bind_self
 
     if isinstance(node, FuncBase):
-        typ = function_type(node,
-                            fallback=Instance(itype.type.mro[-1], []))  # type: Optional[Type]
+        typ = mypy.typeops.function_type(
+            node, fallback=Instance(itype.type.mro[-1], []))  # type: Optional[Type]
     else:
         typ = node.type
     typ = get_proper_type(typ)

mypy/typeops.py

@@ -10,13 +10,14 @@
 from mypy.types import (
     TupleType, Instance, FunctionLike, Type, CallableType, TypeVarDef, Overloaded,
     TypeVarType, TypeType, UninhabitedType, FormalArgument, UnionType, NoneType,
-    ProperType, get_proper_type, get_proper_types, copy_type
+    AnyType, TypeOfAny, ProperType, get_proper_type, get_proper_types, copy_type
 )
 from mypy.nodes import (
-    TypeInfo, TypeVar, ARG_STAR,
+    FuncBase, FuncItem, OverloadedFuncDef, TypeInfo, TypeVar, ARG_STAR, ARG_STAR2,
 )
 from mypy.maptype import map_instance_to_supertype
 from mypy.expandtype import expand_type_by_instance, expand_type
+from mypy.sharedparse import argument_elide_name
 
 from mypy.typevars import fill_typevars
 
@@ -369,3 +370,41 @@ def erase_to_union_or_bound(typ: TypeVarType) -> ProperType:
         return make_simplified_union(typ.values)
     else:
         return get_proper_type(typ.upper_bound)
+
+
+def function_type(func: FuncBase, fallback: Instance) -> FunctionLike:
+    if func.type:
+        assert isinstance(func.type, FunctionLike)
+        return func.type
+    else:
+        # Implicit type signature with dynamic types.
+        if isinstance(func, FuncItem):
+            return callable_type(func, fallback)
+        else:
+            # Broken overloads can have self.type set to None.
+            # TODO: should we instead always set the type in semantic analyzer?
+            assert isinstance(func, OverloadedFuncDef)
+            any_type = AnyType(TypeOfAny.from_error)
+            dummy = CallableType([any_type, any_type],
+                                 [ARG_STAR, ARG_STAR2],
+                                 [None, None], any_type,
+                                 fallback,
+                                 line=func.line, is_ellipsis_args=True)
+            # Return an Overloaded, because some callers may expect that
+            # an OverloadedFuncDef has an Overloaded type.
+            return Overloaded([dummy])
+
+
+def callable_type(fdef: FuncItem, fallback: Instance,
+                  ret_type: Optional[Type] = None) -> CallableType:
+    return CallableType(
+        [AnyType(TypeOfAny.unannotated)] * len(fdef.arg_names),
+        fdef.arg_kinds,
+        [None if argument_elide_name(n) else n for n in fdef.arg_names],
+        ret_type or AnyType(TypeOfAny.unannotated),
+        fallback,
+        name=fdef.name(),
+        line=fdef.line,
+        column=fdef.column,
+        implicit=True,
+    )

mypy/types.py

@@ -17,7 +17,6 @@
     INVARIANT, SymbolNode, ARG_POS, ARG_OPT, ARG_STAR, ARG_STAR2, ARG_NAMED, ARG_NAMED_OPT,
     FuncDef,
 )
-from mypy.sharedparse import argument_elide_name
 from mypy.util import IdMapper
 from mypy.bogus_type import Bogus
 
@@ -2081,44 +2080,6 @@ def copy_type(t: TP) -> TP:
     return copy.copy(t)
 
 
-def function_type(func: mypy.nodes.FuncBase, fallback: Instance) -> FunctionLike:
-    if func.type:
-        assert isinstance(func.type, FunctionLike)
-        return func.type
-    else:
-        # Implicit type signature with dynamic types.
-        if isinstance(func, mypy.nodes.FuncItem):
-            return callable_type(func, fallback)
-        else:
-            # Broken overloads can have self.type set to None.
-            # TODO: should we instead always set the type in semantic analyzer?
-            assert isinstance(func, mypy.nodes.OverloadedFuncDef)
-            any_type = AnyType(TypeOfAny.from_error)
-            dummy = CallableType([any_type, any_type],
-                                 [ARG_STAR, ARG_STAR2],
-                                 [None, None], any_type,
-                                 fallback,
-                                 line=func.line, is_ellipsis_args=True)
-            # Return an Overloaded, because some callers may expect that
-            # an OverloadedFuncDef has an Overloaded type.
-            return Overloaded([dummy])
-
-
-def callable_type(fdef: mypy.nodes.FuncItem, fallback: Instance,
-                  ret_type: Optional[Type] = None) -> CallableType:
-    return CallableType(
-        [AnyType(TypeOfAny.unannotated)] * len(fdef.arg_names),
-        fdef.arg_kinds,
-        [None if argument_elide_name(n) else n for n in fdef.arg_names],
-        ret_type or AnyType(TypeOfAny.unannotated),
-        fallback,
-        name=fdef.name(),
-        line=fdef.line,
-        column=fdef.column,
-        implicit=True,
-    )
-
-
 def replace_alias_tvars(tp: Type, vars: List[str], subs: List[Type],
                         newline: int, newcolumn: int) -> ProperType:
     """Replace type variables in a generic type alias tp with substitutions subs