Support invariant containers

Summary:
For issue #1799

Invariant containers have to be handled differently than the rest of the containers. There are two options I can think of

1- Do not expand the inner type of the container. This wil make lax mode more strict

2- Choose a covariant type as the output type to invariant container type. This option is more flexible but can accept containers that shouldn't be accepted

I went with option 2 for this solution because 1- It's more flexible and 2- The signature will look better on the IDE

If there are any other ideas people think I should consider, I'd be happy to look into those as well.

I tested the example list/set example on pydantic as well, and it works as expected. So Pydantic does provide this level of flexibility.

Reviewed By: yangdanny97

Differential Revision: D88768895

fbshipit-source-id: a2929229eee3c4206ff2617d6eaf20bdfa2c981d

Author: migeed-z

crates/pyrefly_types/src/stdlib.rs

@@ -370,6 +370,10 @@ impl Stdlib {
         Self::apply(&self.list, vec![x])
     }
 
+    pub fn list_object(&self) -> &Class {
+        &Self::unwrap(&self.list).0
+    }
+
     pub fn deque(&self, x: Type) -> ClassType {
         Self::apply(&self.deque, vec![x])
     }
@@ -410,6 +414,10 @@ impl Stdlib {
         Self::apply(&self.set, vec![x])
     }
 
+    pub fn set_object(&self) -> &Class {
+        &Self::unwrap(&self.set).0
+    }
+
     pub fn iterable(&self, x: Type) -> ClassType {
         Self::apply(&self.iterable, vec![x])
     }

pyrefly/lib/alt/class/pydantic_lax.rs

@@ -137,12 +137,17 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         class_obj: &Class,
         expanded_targs: &[Type],
     ) -> Option<Type> {
-        // Extract first type argument (element type for most containers, key type for dict)
+        // Extract first type argument
         let first_ty = expanded_targs
             .first()
             .cloned()
             .unwrap_or_else(Type::any_implicit);
 
+        // Invariant single-element containers: use Iterable to allow covariance
+        if class_obj == self.stdlib.list_object() || class_obj == self.stdlib.set_object() {
+            return Some(self.stdlib.iterable(first_ty).to_type());
+        }
+
         // Single-element containers
         if class_obj.has_toplevel_qname(ModuleName::collections().as_str(), "deque") {
             return Some(self.class_types_to_union(vec![
@@ -165,19 +170,6 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 self.stdlib.tuple(first_ty),
             ]));
         }
-
-        // Two-element containers
-        if class_obj == self.stdlib.dict_object() {
-            let val_ty = expanded_targs
-                .get(1)
-                .cloned()
-                .unwrap_or_else(Type::any_implicit);
-            return Some(self.class_types_to_union(vec![
-                self.stdlib.dict(first_ty.clone(), val_ty.clone()),
-                self.stdlib.mapping(first_ty, val_ty),
-            ]));
-        }
-
         None
     }
 
@@ -187,6 +179,15 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             Type::ClassType(cls) if !cls.targs().as_slice().is_empty() => {
                 let class_obj = cls.class_object();
                 let targs = cls.targs().as_slice();
+
+                // Special handling for dict: don't expand key type (Mapping is invariant in key)
+                if class_obj == self.stdlib.dict_object() {
+                    let key_ty = targs.first().cloned().unwrap_or_else(Type::any_implicit);
+                    let val_ty = targs.get(1).cloned().unwrap_or_else(Type::any_implicit);
+                    let expanded_val = self.expand_type_for_lax_mode(&val_ty);
+                    return self.stdlib.mapping(key_ty, expanded_val).to_type();
+                }
+
                 let expanded_targs = self.expand_types(targs);
 
                 // Check for container type conversions

pyrefly/lib/test/pydantic/strictness.rs

@@ -172,7 +172,8 @@ from pydantic import BaseModel
 class Model(BaseModel):
     x: List[int] = [0, 1]
 
-reveal_type(Model.__init__) # E: revealed type: (self: Model, *, x: list[LaxInt] = ..., **Unknown) -> None
+# list[int] is converted to Iterable[LaxInt] to handle invariance
+reveal_type(Model.__init__) # E: revealed type: (self: Model, *, x: Iterable[LaxInt] = ..., **Unknown) -> None
 
 class Model2(BaseModel):
     q: deque[int]
@@ -182,12 +183,18 @@ reveal_type(Model2.__init__) # E: revealed type: (self: Model2, *, q: deque[LaxI
 class Model3(BaseModel):
     d: dict[str, int]
 
-reveal_type(Model3.__init__) # E: revealed type: (self: Model3, *, d: Mapping[LaxStr, LaxInt] | dict[LaxStr, LaxInt], **Unknown) -> None
+reveal_type(Model3.__init__) # E: revealed type: (self: Model3, *, d: Mapping[str, LaxInt], **Unknown) -> None
 
 class Model4(BaseModel):
     f: frozenset[int]
 
 reveal_type(Model4.__init__) # E: revealed type: (self: Model4, *, f: deque[LaxInt] | dict_keys[LaxInt, LaxInt] | dict_values[LaxInt, LaxInt] | frozenset[LaxInt] | list[LaxInt] | set[LaxInt] | tuple[Decimal | bool | bytes | float | int | str, ...], **Unknown) -> None
+
+class Model5(BaseModel):
+    s: set[int]
+
+# set[int] is converted to Iterable[LaxInt] to handle invariance
+reveal_type(Model5.__init__) # E: revealed type: (self: Model5, *, s: Iterable[LaxInt], **Unknown) -> None
     "#,
 );
 
@@ -205,3 +212,43 @@ class Model(BaseModel):
 reveal_type(Model.__init__)  # E: revealed type: (self: Model, *, y: Decimal | bool | bytes | float | int | str, **Unknown) -> None
     "#,
 );
+
+pydantic_testcase!(
+    test_lax_mode_list_and_set_invariance,
+    r#"
+from pydantic import BaseModel
+from collections import deque
+from typing import reveal_type
+
+class TestModel(BaseModel):
+    name: str
+    things: list[str]
+    tags: set[str]
+
+list_of_things = ["thing1", "thing2"]
+set_of_tags = {"tag1", "tag2"}
+a = TestModel(name="test", things=list_of_things, tags=set_of_tags)
+
+deque_of_bytes: deque[bytes] = deque([b"thing1", b"thing2"])
+b = TestModel(name="test", things=deque_of_bytes, tags=set_of_tags)
+
+# When reading the field back, you get the original declared type (list[str]), not Iterable[LaxStr]
+reveal_type(a.things)  # E: revealed type: list[str]
+reveal_type(a.tags)    # E: revealed type: set[str]
+    "#,
+);
+
+pydantic_testcase!(
+    test_lax_mode_dict_invariance,
+    r#"
+from pydantic import BaseModel
+from typing import reveal_type
+
+class TestModel(BaseModel):
+    name: str
+    metadata: dict[str, str]
+
+my_dict = {"key1": "value1", "key2": "value2"}
+a = TestModel(name="test", metadata=my_dict)
+    "#,
+);