No errors for ReadOnly[Required[…]]

Author: sharkdp

crates/ty_python_semantic/resources/mdtest/annotations/unsupported_type_qualifiers.md

@@ -31,11 +31,13 @@ def _(
         ClassVar  # error: [invalid-type-form] "Type qualifier `typing.ClassVar` is not allowed in type expressions (only in annotation expressions)"
         | int
     ),
-    c: ReadOnly,  # error: [invalid-type-form] "Type qualifier `typing.ReadOnly` is not allowed in type expressions (only in annotation expressions, and only with exactly one argument)"
+    c: (
+        ReadOnly | int
+    ),  # error: [invalid-type-form] "Type qualifier `typing.ReadOnly` is not allowed in type expressions (only in annotation expressions, and only with exactly one argument)"
 ) -> None:
     reveal_type(a)  # revealed: Unknown | int
     reveal_type(b)  # revealed: Unknown | int
-    reveal_type(c)  # revealed: Unknown
+    reveal_type(c)  # revealed: Unknown | int
 ```
 
 ## Inheritance

crates/ty_python_semantic/resources/mdtest/typed_dict.md

@@ -432,6 +432,20 @@ def _(person: Person, unknown_key: Any):
     person[unknown_key] = "Eve"
 ```
 
+## `ReadOnly`
+
+`ReadOnly` is not supported yet, but this test makes sure that we do not emit any false positive
+diagnostics:
+
+```py
+from typing_extensions import TypedDict, ReadOnly, Required
+
+class Person(TypedDict, total=False):
+    id: ReadOnly[Required[int]]
+    name: str
+    age: int | None
+```
+
 ## Methods on `TypedDict`
 
 ```py

crates/ty_python_semantic/src/types.rs

@@ -6882,6 +6882,8 @@ bitflags! {
         const REQUIRED = 1 << 3;
         /// `typing_extensions.NotRequired`
         const NOT_REQUIRED = 1 << 4;
+        /// `typing_extensions.ReadOnly`
+        const READ_ONLY = 1 << 5;
     }
 }
 

crates/ty_python_semantic/src/types/infer.rs

@@ -9443,6 +9443,9 @@ impl<'db> TypeInferenceBuilder<'db, '_> {
                         Type::SpecialForm(SpecialFormType::NotRequired) => {
                             TypeAndQualifiers::new(Type::unknown(), TypeQualifiers::NOT_REQUIRED)
                         }
+                        Type::SpecialForm(SpecialFormType::ReadOnly) => {
+                            TypeAndQualifiers::new(Type::unknown(), TypeQualifiers::READ_ONLY)
+                        }
                         Type::ClassLiteral(class)
                             if class.is_known(self.db(), KnownClass::InitVar) =>
                         {
@@ -9521,7 +9524,8 @@ impl<'db> TypeInferenceBuilder<'db, '_> {
                         type_qualifier @ (SpecialFormType::ClassVar
                         | SpecialFormType::Final
                         | SpecialFormType::Required
-                        | SpecialFormType::NotRequired),
+                        | SpecialFormType::NotRequired
+                        | SpecialFormType::ReadOnly),
                     ) => {
                         let arguments = if let ast::Expr::Tuple(tuple) = slice {
                             &*tuple.elts
@@ -9546,6 +9550,9 @@ impl<'db> TypeInferenceBuilder<'db, '_> {
                                 SpecialFormType::NotRequired => {
                                     type_and_qualifiers.add_qualifier(TypeQualifiers::NOT_REQUIRED);
                                 }
+                                SpecialFormType::ReadOnly => {
+                                    type_and_qualifiers.add_qualifier(TypeQualifiers::READ_ONLY);
+                                }
                                 _ => unreachable!(),
                             }
                             type_and_qualifiers
@@ -10832,14 +10839,11 @@ impl<'db> TypeInferenceBuilder<'db, '_> {
                 KnownClass::Deque,
             ),
 
-            SpecialFormType::ReadOnly => {
-                self.infer_type_expression(arguments_slice);
-                todo_type!("`ReadOnly[]` type qualifier")
-            }
             SpecialFormType::ClassVar
             | SpecialFormType::Final
             | SpecialFormType::Required
-            | SpecialFormType::NotRequired => {
+            | SpecialFormType::NotRequired
+            | SpecialFormType::ReadOnly => {
                 if let Some(builder) = self.context.report_lint(&INVALID_TYPE_FORM, subscript) {
                     let diag = builder.into_diagnostic(format_args!(
                         "Type qualifier `{special_form}` is not allowed in type expressions \