Handle type[T] calls where T is bounded by a class (#2381)

Summary:
When types of `type[T]` are called, we currently infer a callable that takes any arguments and returns the type variable T. This is a conformance gap, where we should treat such calls as on `T`. However, the spec made clear that this is not free of problems:

From https://typing.python.org/en/latest/spec/constructors.html#constructor-calls-for-type-t
> It should be noted that such code could be unsafe because the type `type[T]` may represent subclasses of `T`, and those subclasses could redefine the `__new__` and `__init__` methods in a way that is incompatible with the base class. Likewise, the metaclass of `T` could redefine the `__call__` method in a way that is incompatible with the base metaclass.

If `T` is unrestricted, we assume an implicit bound of `object`, and use the callable type `() -> T`.
If `T` is bounded, we use the bound class type to infer the callable signature, but use the type `T` as the return type.

We cannot handle constrained type variables, since we don't have any intersection type support at the call target level, so I'm leaving the current behaviour as is.

Let's assess the impact on open source codebases, since I expect this change will bring some false positives.

#2369

Pull Request resolved: #2381

Test Plan: Ran conformance test suite and fixed 4 failing tests.

Reviewed By: stroxler

Differential Revision: D92900019

Pulled By: migeed-z

fbshipit-source-id: a50b259d559a938e75801f0fd44aff33e83051d7

Author: fangyi-zhou

conformance/third_party/conformance.exp

@@ -3308,6 +3308,61 @@
       "severity": "error",
       "stop_column": 10,
       "stop_line": 59
+    },
+    {
+      "code": -2,
+      "column": 9,
+      "concise_description": "Expected 0 positional arguments, got 1",
+      "description": "Expected 0 positional arguments, got 1",
+      "line": 64,
+      "name": "bad-argument-count",
+      "severity": "error",
+      "stop_column": 10,
+      "stop_line": 64
+    },
+    {
+      "code": -2,
+      "column": 8,
+      "concise_description": "Missing argument `x` in function `Meta1.__call__`",
+      "description": "Missing argument `x` in function `Meta1.__call__`",
+      "line": 72,
+      "name": "missing-argument",
+      "severity": "error",
+      "stop_column": 10,
+      "stop_line": 72
+    },
+    {
+      "code": -2,
+      "column": 8,
+      "concise_description": "Missing argument `y` in function `Meta1.__call__`",
+      "description": "Missing argument `y` in function `Meta1.__call__`",
+      "line": 72,
+      "name": "missing-argument",
+      "severity": "error",
+      "stop_column": 10,
+      "stop_line": 72
+    },
+    {
+      "code": -2,
+      "column": 8,
+      "concise_description": "Missing argument `y` in function `Class2.__new__`",
+      "description": "Missing argument `y` in function `Class2.__new__`",
+      "line": 81,
+      "name": "missing-argument",
+      "severity": "error",
+      "stop_column": 11,
+      "stop_line": 81
+    },
+    {
+      "code": -2,
+      "column": 12,
+      "concise_description": "Argument `Literal[2]` is not assignable to parameter `y` with type `str` in function `Class2.__new__`",
+      "description": "Argument `Literal[2]` is not assignable to parameter `y` with type `str` in function `Class2.__new__`",
+      "line": 82,
+      "name": "bad-argument-type",
+      "severity": "error",
+      "stop_column": 13,
+      "stop_line": 82
     }
   ],
   "constructors_callable.py": [

conformance/third_party/conformance.result

@@ -36,12 +36,7 @@
   "constructors_call_init.py": [],
   "constructors_call_metaclass.py": [],
   "constructors_call_new.py": [],
-  "constructors_call_type.py": [
-    "Line 64: Expected 1 errors",
-    "Line 72: Expected 1 errors",
-    "Line 81: Expected 1 errors",
-    "Line 82: Expected 1 errors"
-  ],
+  "constructors_call_type.py": [],
   "constructors_callable.py": [
     "Line 65: Expected 1 errors",
     "Line 66: Expected 1 errors",

conformance/third_party/results.json

@@ -1,9 +1,9 @@
 {
   "total": 138,
-  "pass": 113,
-  "fail": 25,
-  "pass_rate": 0.82,
-  "differences": 93,
+  "pass": 114,
+  "fail": 24,
+  "pass_rate": 0.83,
+  "differences": 89,
   "passing": [
     "aliases_explicit.py",
     "aliases_newtype.py",
@@ -22,6 +22,7 @@
     "constructors_call_init.py",
     "constructors_call_metaclass.py",
     "constructors_call_new.py",
+    "constructors_call_type.py",
     "constructors_consistency.py",
     "dataclasses_final.py",
     "dataclasses_frozen.py",
@@ -124,7 +125,6 @@
     "aliases_typealiastype.py": 2,
     "annotations_forward_refs.py": 2,
     "callables_annotation.py": 2,
-    "constructors_call_type.py": 4,
     "constructors_callable.py": 8,
     "dataclasses_descriptors.py": 6,
     "dataclasses_slots.py": 2,

pyrefly/lib/alt/call.rs

@@ -84,7 +84,10 @@ pub enum CallTarget {
     /// Method of a class. The `Type` is the self/cls argument.
     BoundMethod(Type, TargetWithTParams<Function>),
     /// A class object.
-    Class(ClassType, ConstructorKind),
+    /// The optional Quantified argument is for the case where this call target
+    /// occurs in a bounded type var, where the current class is being used as
+    /// the upper bound.
+    Class(ClassType, ConstructorKind, Option<Quantified>),
     /// A TypedDict.
     TypedDict(TypedDictInner),
     /// An overloaded function.
@@ -220,6 +223,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 Type::ClassType(cls) => CallTargetLookup::Ok(Box::new(CallTarget::Class(
                     cls,
                     ConstructorKind::BareClassName,
+                    None,
                 ))),
                 Type::TypedDict(TypedDict::TypedDict(typed_dict)) => {
                     CallTargetLookup::Ok(Box::new(CallTarget::TypedDict(typed_dict)))
@@ -230,20 +234,53 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 CallTargetLookup::Ok(Box::new(CallTarget::Class(
                     cls,
                     ConstructorKind::TypeOfClass,
+                    None,
                 )))
             }
-            Type::Type(box Type::Tuple(tuple)) => CallTargetLookup::Ok(Box::new(
-                CallTarget::Class(self.erase_tuple_type(tuple), ConstructorKind::TypeOfClass),
-            )),
-            Type::Type(box Type::Quantified(quantified)) => {
-                CallTargetLookup::Ok(Box::new(CallTarget::Callable(TargetWithTParams(
+            Type::Type(box Type::Tuple(tuple)) => {
+                CallTargetLookup::Ok(Box::new(CallTarget::Class(
+                    self.erase_tuple_type(tuple),
+                    ConstructorKind::TypeOfClass,
                     None,
-                    Callable {
-                        // TODO: use upper bound to determine input parameters
-                        params: Params::Ellipsis,
-                        ret: Type::Quantified(quantified),
-                    },
-                ))))
+                )))
+            }
+            Type::Type(box Type::Quantified(quantified)) => {
+                let call_target = match quantified.restriction() {
+                    Restriction::Unrestricted => {
+                        // Assume this is object.__init__, reject any argument
+                        CallTarget::Callable(TargetWithTParams(
+                            None,
+                            Callable {
+                                params: Params::List(ParamList::new(vec![])),
+                                ret: Type::Quantified(quantified),
+                            },
+                        ))
+                    }
+                    Restriction::Bound(Type::ClassType(cls)) => {
+                        // Use the bound to determine call target, but keep
+                        // the original quantified for the return type to allow
+                        // type variables in the return type to be resolved.
+                        CallTarget::Class(
+                            cls.clone(),
+                            ConstructorKind::TypeOfClass,
+                            Some(*quantified),
+                        )
+                    }
+                    // For unhandled cases, we accept any arguments and return
+                    // the quantified type itself.
+                    // We can't handle constraints because we need to take
+                    // intersection of constructor types of all constraints,
+                    // which is currently not possible.
+                    _ => CallTarget::Callable(TargetWithTParams(
+                        None,
+                        Callable {
+                            // TODO: use upper bound to determine input parameters
+                            params: Params::Ellipsis,
+                            ret: Type::Quantified(quantified),
+                        },
+                    )),
+                };
+                CallTargetLookup::Ok(Box::new(call_target))
             }
             Type::Type(inner) if let Type::Any(style) = *inner => {
                 CallTargetLookup::Ok(Box::new(CallTarget::Any(style)))
@@ -332,6 +369,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 CallTargetLookup::Ok(Box::new(CallTarget::Class(
                     cls,
                     ConstructorKind::TypeOfClass,
+                    None,
                 )))
             }
             Type::Type(box Type::Intersect(box (_, fallback))) => {
@@ -852,7 +890,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             }
         };
         let res = match call_target {
-            CallTarget::Class(cls, constructor_kind) => {
+            CallTarget::Class(cls, constructor_kind, as_quantified_bound) => {
                 if cls.has_qname("typing", "Any") {
                     return self.error(
                         errors,
@@ -903,7 +941,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                         }
                     }
                 };
-                self.construct_class(
+                let constructed_type = self.construct_class(
                     cls,
                     args,
                     keywords,
@@ -912,7 +950,16 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                     errors,
                     context,
                     hint,
-                )
+                );
+                // Override the constructed type with the quantified bound if
+                // this class is being called via a quantified type with a class
+                // bound, to allow calls on TypeVars with class bounds to work
+                // as expected.
+                if let Some(quantified) = as_quantified_bound {
+                    Type::Quantified(Box::new(quantified))
+                } else {
+                    constructed_type
+                }
             }
             CallTarget::TypedDict(td) => self.construct_typed_dict(
                 td,

pyrefly/lib/report/pysa/call_graph.rs

@@ -2288,7 +2288,11 @@ impl<'a> CallGraphVisitor<'a> {
                     })
                     .unwrap()
             }
-            Some(CallTargetLookup::Ok(box crate::alt::call::CallTarget::Class(class_type, _))) => {
+            Some(CallTargetLookup::Ok(box crate::alt::call::CallTarget::Class(
+                class_type,
+                _,
+                _,
+            ))) => {
                 // Constructing a class instance.
                 let (init_method, new_method) = self
                     .module_context

pyrefly/lib/test/generic_basic.rs

@@ -11,18 +11,34 @@ use crate::test::util::TestEnv;
 use crate::testcase;
 
 testcase!(
-    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)  # should error: no args for object constructor
+    cls(1)  # E: Expected 0 positional arguments, got 1
     return cls()
 class A:
     def __init__(self, x: int) -> None: pass
 def test2[T: A](cls: type[T]) -> T:
-    a1: A = cls()  # should error: missing required arg x
+    a1: A = cls()  # E: Missing argument `x` in function `A.__init__`
     a2: A = cls(1)
-    return cls()
+    return cls(1)
+"#,
+);
+
+testcase!(
+    bug = "When determining callable for type[T] where T is a constrained TypeVar, we should take intersection of constructor of all constraints",
+    test_constrained_typevar_constructor,
+    r#"
+from typing import TypeVar
+class A:
+    def __init__(self, x: int) -> None: pass
+class B:
+    def __init__(self, x: int, y: str = "default") -> None: pass
+T = TypeVar("T", A, B)
+def test(cls: type[T]) -> None:
+    cls(1)
+    cls("hello")  # should error: incorrect type of x
+    cls(1, "hello")  # should error: too many arguments
 "#,
 );