Fixed a spurious type error when binding a param spec to Any/Callable[..., Any]

PiperOrigin-RevId: 831814821

Author: superbobry

pytype/output.py

@@ -123,7 +123,17 @@ def _value_to_parameter_types(self, node, v, instance, template, seen, view):
     """Get PyTD types for the parameters of an instance of an abstract value."""
     if isinstance(v, abstract.CallableClass):
       assert template == (abstract_utils.ARGS, abstract_utils.RET), template
-      template = list(range(v.num_args)) + [template[1]]
+      should_preserve_paramspec = (
+          v.has_paramspec()
+          and v.num_args == 1
+          and instance
+          and isinstance(
+              instance.get_formal_type_parameter(abstract_utils.ARGS),
+              abstract.Unsolvable,
+          )
+      )
+      if not should_preserve_paramspec:
+        template = list(range(v.num_args)) + [template[1]]
     if self._is_tuple(v, instance):
       if isinstance(v, abstract.TupleClass):
         new_template = range(v.tuple_length)
@@ -176,10 +186,18 @@ def _value_to_parameter_types(self, node, v, instance, template, seen, view):
         else:
           param_values = {self.ctx.convert.unsolvable: view}
         formal_param = v.get_formal_type_parameter(t)
+        if (
+            t == abstract_utils.ARGS
+            and isinstance(v, abstract.CallableClass)
+            and v.has_paramspec()
+            and [*param_values] == [self.ctx.convert.unsolvable]
+        ):
+          # This is a Callable[P, T] where P is unsolvable.
+          arg = pytd.AnythingType()
         # If the instance's parameter value is unsolvable or the parameter type
         # is recursive, we can get a more precise type from the class. Note that
         # we need to be careful not to introduce unbound type parameters.
-        if (
+        elif (
             isinstance(v, abstract.ParameterizedClass)
             and not formal_param.formal
             and (
@@ -281,7 +299,16 @@ def value_instance_to_pytd_type(self, node, v, instance, seen, view):
       if self._is_tuple(v, instance):
         homogeneous = False
       elif v.full_name == "typing.Callable":
-        homogeneous = not isinstance(v, abstract.CallableClass)
+        is_callable_with_unsolvable_paramspec = (
+            isinstance(v, abstract.CallableClass)
+            and v.has_paramspec()
+            and len(type_arguments) == 2
+            and isinstance(type_arguments[0], pytd.AnythingType)
+        )
+        homogeneous = (
+            not isinstance(v, abstract.CallableClass)
+            or is_callable_with_unsolvable_paramspec
+        )
       else:
         homogeneous = len(type_arguments) == 1
       return pytd_utils.MakeClassOrContainerType(

pytype/tests/test_paramspec.py

@@ -1,5 +1,7 @@
 """PEP 612 tests."""
 
+import unittest
+
 from pytype.tests import test_base
 from pytype.tests import test_utils
 
@@ -205,6 +207,35 @@ def g(x: int) -> int:
       assert_type(a, Callable[[int], str])
     """)
 
+  def test_bound_to_any1(self):
+    self.Check("""
+      from typing import Any, Callable, ParamSpec
+
+      P = ParamSpec("P")
+
+      def f(x: Callable[P, int]) -> Callable[P, int]:
+        return x
+
+      def test1(g: Any):
+        assert_type(f(g), Callable[..., int])
+      def test1(g: Callable[..., Any]):
+        assert_type(f(g), Callable[..., int])
+    """)
+
+  @unittest.expectedFailure
+  def test_bound_to_any2(self):
+    self.Check("""
+      from typing import Any, Callable, Concatenate, ParamSpec
+
+      P = ParamSpec("P")
+
+      def f(x: Callable[Concatenate[int, P], int]) -> Callable[Concatenate[int, P], int]:
+        return x
+
+      def test(g: Any):
+        assert_type(f(g), Callable[Concatenate[int, ...], int])
+    """)
+
   def test_typevar(self):
     self.Check("""
       from typing import Callable, Concatenate, List, ParamSpec, TypeVar