Fix inference against Any

JukkaL · Nov 23, 2021 · Nov 18, 2021 · Nov 18, 2021 · Nov 18, 2021 · Nov 18, 2021
commit a3cb0ad3b1f19bc026db6625ecf98bc1d46db18c
diff --git a/mypy/constraints.py b/mypy/constraints.py
@@ -7,7 +7,8 @@
     CallableType, Type, TypeVisitor, UnboundType, AnyType, NoneType, TypeVarType, Instance,
     TupleType, TypedDictType, UnionType, Overloaded, ErasedType, PartialType, DeletedType,
     UninhabitedType, TypeType, TypeVarId, TypeQuery, is_named_instance, TypeOfAny, LiteralType,
-    ProperType, ParamSpecType, get_proper_type, TypeAliasType, is_union_with_any
+    ProperType, ParamSpecType, get_proper_type, TypeAliasType, is_union_with_any,
+    callable_with_ellipsis
 )
 from mypy.maptype import map_instance_to_supertype
 import mypy.subtypes
@@ -575,11 +576,17 @@ def visit_callable_type(self, template: CallableType) -> List[Constraint]:
                                          self.direction))
             return res
         elif isinstance(self.actual, AnyType):
-            # FIX what if generic
-            res = self.infer_against_any(template.arg_types, self.actual)
+            param_spec = template.param_spec()
             any_type = AnyType(TypeOfAny.from_another_any, source_any=self.actual)
-            res.extend(infer_constraints(template.ret_type, any_type, self.direction))
-            return res
+            if param_spec is None:
+                # FIX what if generic
+                res = self.infer_against_any(template.arg_types, self.actual)
+                res.extend(infer_constraints(template.ret_type, any_type, self.direction))
+                return res
+            else:
+                return [Constraint(param_spec.id,
+                                   SUBTYPE_OF,
+                                   callable_with_ellipsis(any_type, any_type, template.fallback))]
         elif isinstance(self.actual, Overloaded):
             return self.infer_against_overloaded(self.actual, template)
         elif isinstance(self.actual, TypeType):

diff --git a/mypy/typeanal.py b/mypy/typeanal.py
@@ -17,7 +17,7 @@
     StarType, PartialType, EllipsisType, UninhabitedType, TypeType, CallableArgument,
     TypeQuery, union_items, TypeOfAny, LiteralType, RawExpressionType,
     PlaceholderType, Overloaded, get_proper_type, TypeAliasType,
-    TypeVarLikeType, ParamSpecType, ParamSpecFlavor
+    TypeVarLikeType, ParamSpecType, ParamSpecFlavor, callable_with_ellipsis
 )
 
 from mypy.nodes import (
@@ -747,12 +747,7 @@ def analyze_callable_type(self, t: UnboundType) -> Type:
         if len(t.args) == 0:
             # Callable (bare). Treat as Callable[..., Any].
             any_type = self.get_omitted_any(t)
-            ret = CallableType([any_type, any_type],
-                               [nodes.ARG_STAR, nodes.ARG_STAR2],
-                               [None, None],
-                               ret_type=any_type,
-                               fallback=fallback,
-                               is_ellipsis_args=True)
+            ret = callable_with_ellipsis(any_type, any_type,fallback)
         elif len(t.args) == 2:
             callable_args = t.args[0]
             ret_type = t.args[1]
@@ -769,13 +764,9 @@ def analyze_callable_type(self, t: UnboundType) -> Type:
                                    fallback=fallback)
             elif isinstance(callable_args, EllipsisType):
                 # Callable[..., RET] (with literal ellipsis; accept arbitrary arguments)
-                ret = CallableType([AnyType(TypeOfAny.explicit),
-                                    AnyType(TypeOfAny.explicit)],
-                                   [nodes.ARG_STAR, nodes.ARG_STAR2],
-                                   [None, None],
-                                   ret_type=ret_type,
-                                   fallback=fallback,
-                                   is_ellipsis_args=True)
+                ret = callable_with_ellipsis(AnyType(TypeOfAny.explicit),
+                                             ret_type=ret_type,
+                                             fallback=fallback)
             else:
                 # Callable[P, RET] (where P is ParamSpec)
                 maybe_ret = self.analyze_callable_args_for_paramspec(

diff --git a/mypy/types.py b/mypy/types.py
@@ -2489,3 +2489,15 @@ def is_literal_type(typ: ProperType, fallback_fullname: str, value: LiteralValue
     for key, obj in names.items()
     if isinstance(obj, type) and issubclass(obj, Type) and obj is not Type
 }
+
+
+def callable_with_ellipsis(any_type: AnyType,
+                           ret_type: Type,
+                           fallback: Instance) -> CallableType:
+    """Construct type Callable[..., ret_type]."""
+    return CallableType([any_type, any_type],
+                        [ARG_STAR, ARG_STAR2],
+                        [None, None],
+                        ret_type=ret_type,
+                        fallback=fallback,
+                        is_ellipsis_args=True)
diff --git a/test-data/unit/check-parameter-specification.test b/test-data/unit/check-parameter-specification.test
@@ -191,3 +191,17 @@ def f(x: int, y: str, z: int, a: str) -> None: ...
 
 x = register(f, 1, '', 1, '')
 [builtins fixtures/dict.pyi]
+
+[case testParamSpecInferredFromAny]
+from typing import Callable, Any
+from typing_extensions import ParamSpec
+
+P = ParamSpec('P')
+
+def f(x: Callable[P, int]) -> Callable[P, str]: ...
+
+g: Any
+reveal_type(f(g))  # N: Revealed type is "def (*Any, **Any) -> builtins.str"
+
+f(g)(1, 3, x=1, y=2)
+[builtins fixtures/tuple.pyi]