Fix explicit type for partial

mypy/plugins/functools.py

@@ -24,6 +24,8 @@
 
 _ORDERING_METHODS: Final = {"__lt__", "__le__", "__gt__", "__ge__"}
 
+PARTIAL = "functools.partial"
+
 
 class _MethodInfo(NamedTuple):
     is_static: bool
@@ -142,7 +144,8 @@ def partial_new_callback(ctx: mypy.plugin.FunctionContext) -> Type:
                 else (ArgKind.ARG_NAMED_OPT if k == ArgKind.ARG_NAMED else k)
             )
             for k in fn_type.arg_kinds
-        ]
+        ],
+        ret_type=ctx.api.named_generic_type(PARTIAL, [fn_type.ret_type]),
     )
     if defaulted.line < 0:
         # Make up a line number if we don't have one
@@ -188,6 +191,10 @@ def partial_new_callback(ctx: mypy.plugin.FunctionContext) -> Type:
     bound = get_proper_type(bound)
     if not isinstance(bound, CallableType):
         return ctx.default_return_type
+    wrapped_ret_type = get_proper_type(bound.ret_type)
+    if not isinstance(wrapped_ret_type, Instance) or wrapped_ret_type.type.fullname != PARTIAL:
+        return ctx.default_return_type
+    bound = bound.copy_modified(ret_type=wrapped_ret_type.args[0])
 
     formal_to_actual = map_actuals_to_formals(
         actual_kinds=actual_arg_kinds,
@@ -237,7 +244,7 @@ def partial_new_callback(ctx: mypy.plugin.FunctionContext) -> Type:
         ret_type=ret_type,
     )
 
-    ret = ctx.api.named_generic_type("functools.partial", [ret_type])
+    ret = ctx.api.named_generic_type(PARTIAL, [ret_type])
     ret = ret.copy_with_extra_attr("__mypy_partial", partially_applied)
     return ret
 
@@ -247,7 +254,7 @@ def partial_call_callback(ctx: mypy.plugin.MethodContext) -> Type:
     if (
         not isinstance(ctx.api, mypy.checker.TypeChecker)  # use internals
         or not isinstance(ctx.type, Instance)
-        or ctx.type.type.fullname != "functools.partial"
+        or ctx.type.type.fullname != PARTIAL
         or not ctx.type.extra_attrs
         or "__mypy_partial" not in ctx.type.extra_attrs.attrs
     ):

test-data/unit/check-functools.test

@@ -347,6 +347,21 @@ reveal_type(functools.partial(fn3, 2)())  # E: "str" not callable \
                                           # E: Argument 1 to "partial" has incompatible type "Union[Callable[[int], int], str]"; expected "Callable[..., int]"
 [builtins fixtures/tuple.pyi]
 
+[case testFunctoolsPartialExplicitType]
+from functools import partial
+from typing import Type, TypeVar, Callable
+
+T = TypeVar("T")
+def generic(string: str, integer: int, resulting_type: Type[T]) -> T: ...
+
+p: partial[str] = partial(generic, resulting_type=str)
+q: partial[bool] = partial(generic, resulting_type=str)  # E: Argument "resulting_type" to "generic" has incompatible type "Type[str]"; expected "Type[bool]"
+
+pc: Callable[..., str] = partial(generic, resulting_type=str)
+qc: Callable[..., bool] = partial(generic, resulting_type=str)  # E: Incompatible types in assignment (expression has type "partial[str]", variable has type "Callable[..., bool]") \
+                                                                # N: "partial[str].__call__" has type "Callable[[VarArg(Any), KwArg(Any)], str]"
+[builtins fixtures/tuple.pyi]
+
 [case testFunctoolsPartialTypeObject]
 import functools
 from typing import Type, Generic, TypeVar