Document another group of conformance gap involving callables and constructors

Reviewed By: grievejia

Differential Revision: D91738737

fbshipit-source-id: f6c3258cb4432d3dcf0b28355a0acd4c18ed93c1

Author: migeed-z

pyrefly/lib/test/callable.rs

@@ -1261,3 +1261,73 @@ def g():
     return wrap(lambda x: f(x))
     "#,
 );
+
+testcase!(
+    bug = "conformance: Protocol with ParamSpec[...] should be compatible with Protocol using *args: Any, **kwargs: Any",
+    test_protocol_paramspec_ellipsis,
+    r#"
+from typing import Any, Protocol, ParamSpec
+
+P = ParamSpec("P")
+
+class Proto3(Protocol):
+    def __call__(self, a: int, *args: Any, **kwargs: Any) -> None: ...
+
+class Proto4(Protocol[P]):
+    def __call__(self, a: int, *args: P.args, **kwargs: P.kwargs) -> None: ...
+
+class Proto6(Protocol):
+    # Note: conformance uses `*args: Any, *, k: str` which pyrefly incorrectly treats as parse error
+    def __call__(self, a: int, /, *args: Any, k: str, **kwargs: Any) -> None: ...
+
+class Proto7(Protocol):
+    def __call__(self, a: float, /, b: int, *, k: str, m: str) -> None: ...
+
+def test(p4: Proto4[...], p7: Proto7):
+    # Both should be OK per conformance spec - pyrefly incorrectly errors
+    ok10: Proto3 = p4  # E: `Proto4[Ellipsis]` is not assignable to `Proto3`
+    ok11: Proto6 = p7  # E: `Proto7` is not assignable to `Proto6`
+"#,
+);
+
+testcase!(
+    bug = "conformance: Constructor to Callable conversion should work with __new__ and __init__ together",
+    test_constructor_callable_conversion,
+    r#"
+from typing import Callable, ParamSpec, TypeVar, Self, assert_type, overload, Generic
+
+P = ParamSpec("P")
+R = TypeVar("R")
+T = TypeVar("T")
+
+def accepts_callable(cb: Callable[P, R]) -> Callable[P, R]:
+    return cb
+
+class Class3:
+    def __new__(cls, *args, **kwargs) -> Self: ...
+    def __init__(self, x: int) -> None: ...
+
+# pyrefly incorrectly errors on this line - should be OK
+r3 = accepts_callable(Class3)  # E: `type[Class3]` is not assignable to parameter `cb` with type `(*args: Unknown, **kwargs: Unknown) -> Class3`
+
+class Class7(Generic[T]):
+    @overload
+    def __init__(self: "Class7[int]", x: int) -> None: ...
+    @overload
+    def __init__(self: "Class7[str]", x: str) -> None: ...
+    def __init__(self, x: int | str) -> None:
+        pass
+
+r7 = accepts_callable(Class7)
+# pyrefly incorrectly errors on these - should be OK
+assert_type(r7(""), Class7[str])  # E: assert_type(Class7[int], Class7[str]) failed # E: Argument `Literal['']` is not assignable
+
+class Class8(Generic[T]):
+    def __new__(cls, x: list[T], y: list[T]) -> Self:
+        return super().__new__(cls)
+
+r8 = accepts_callable(Class8)
+# pyrefly incorrectly errors on this - should be OK
+assert_type(r8([""], [""]), Class8[str])  # E: assert_type(Class8[Any], Class8[str]) failed
+"#,
+);

pyrefly/lib/test/constructors.rs

@@ -686,3 +686,18 @@ takes_Cstr(C)
 takes_Cstr_wrong(C) # E: Argument `type[C]` is not assignable to parameter `x` with type `(str) -> C[int]` in function `takes_Cstr_wrong`
     "#,
 );
+
+testcase!(
+    bug = "conformance: Should error when class-scoped type variables are used in self annotation of __init__",
+    test_init_class_scoped_typevars_in_self,
+    r#"
+from typing import Generic, TypeVar
+
+T1 = TypeVar("T1")
+T2 = TypeVar("T2")
+
+class Class8(Generic[T1, T2]):
+    def __init__(self: "Class8[T2, T1]") -> None:  # should error: class-scoped type vars used in self annotation
+        pass
+"#,
+);

pyrefly/lib/test/generic_basic.rs

@@ -11,17 +11,16 @@ use crate::test::util::TestEnv;
 use crate::testcase;
 
 testcase!(
-    bug =
-        "We should use the bounds/constraints of the type var to determine the callable input type",
+    bug = "conformance: Should use bounds/constraints of type var to determine callable input type for type[T] constructors",
     test_tyvar_constructor,
     r#"
 def test[T](cls: type[T]) -> T:
-    cls(1)  # Not OK, we should assume object constructor here
+    cls(1)  # should error: no args for object constructor
     return cls()
 class A:
     def __init__(self, x: int) -> None: pass
 def test2[T: A](cls: type[T]) -> T:
-    a1: A = cls()  # Not OK
+    a1: A = cls()  # should error: missing required arg x
     a2: A = cls(1)
     return cls()
 "#,