Allow building type qualifiers like NotRequired[...] at runtime (#5450)

Summary:
The idea is:

- If we have a subscript expression, like `x = my_list[0]` where we know that `my_list` is a `list[int]`, then `x` gets inferred as `int`. That's what https://github.com/meta/pyrefly/blob/8003f9b3d96b207c916c4a5c5ba039fb568cb857/pyrefly/lib/alt/expr.rs#L945-L951 does
- If however we have a subscript assignment like `x = NotRequired[int]`, then `NotRequired` is a `_SpecialForm` which is typed to return `object` for `__getitem__`, so we need to infer `x` as `object` rather than reporting it as an invalid annotation
- For cases in class definitions, like `class MyClass(TypedDict, total=False)`, however, we want to preserve the current behaviour and raise on something like `extra_items=NotRequired[int]`, which is why in `fn expr_class_keyword` we need to pass down `Some(TypeFormContext::ClassKeyword)` so that `if type_form_context.is_none()` in `expr_infer_without_shape_comment` doesn't evaluate to `true`

Note that `x: NotRequired[int]` still gets checked as-before, as this change only covers the `if type_form_context.is_none()` case, and in the `x: NotRequired[int]` case, there is a type form context

Fixes #5429

- [x] I am a human, and I fully understand the code I am submitting.

I used Claude to generate the code, but the description here is fully written by me

Pull Request resolved: #5450

Reviewed By: rchen152

Differential Revision: D128312510

fbshipit-source-id: a6ffbb2c8dc35645e4270cdffc18a112963ef627

Author: MarcoGorelli

conformance/third_party/conformance.exp

@@ -13742,21 +13742,21 @@
     {
       "code": -2,
       "column": 18,
-      "concise_description": "`ClassVar` is not allowed in this context",
-      "description": "`ClassVar` is not allowed in this context",
+      "concise_description": "`object` is not assignable to `TypeForm[Any]`",
+      "description": "`object` is not assignable to `TypeForm[Any]`",
       "line": 71,
-      "name": "invalid-annotation",
+      "name": "bad-assignment",
       "severity": "error",
       "stop_column": 31,
       "stop_line": 71
     },
     {
       "code": -2,
       "column": 18,
-      "concise_description": "`Final` is not allowed in this context",
-      "description": "`Final` is not allowed in this context",
+      "concise_description": "`object` is not assignable to `TypeForm[Any]`",
+      "description": "`object` is not assignable to `TypeForm[Any]`",
       "line": 72,
-      "name": "invalid-annotation",
+      "name": "bad-assignment",
       "severity": "error",
       "stop_column": 28,
       "stop_line": 72

pyrefly/lib/alt/expr.rs

@@ -946,13 +946,32 @@ impl<'ctx, 'answer, Ans: LookupAnswer> AnswersSolver<'ctx, 'answer, Ans> {
                         // already been checked.
                         check_deprecation = false;
                     }
-                    self.subscript_infer(
-                        &base,
-                        &x.slice,
-                        x.range(),
-                        type_form_context.unwrap_or(TypeFormContext::TypeExpression),
-                        errors,
-                    )
+                    // A qualifier like `NotRequired[int]` is a legal runtime value, which
+                    // typeshed types as `object`.
+                    if type_form_context.is_none()
+                        && let Type::Type(inner) = base.ty()
+                        && matches!(
+                            **inner,
+                            Type::SpecialForm(
+                                SpecialForm::ClassVar
+                                    | SpecialForm::Final
+                                    | SpecialForm::ReadOnly
+                                    | SpecialForm::Required
+                                    | SpecialForm::NotRequired
+                            )
+                        )
+                    {
+                        self.expr_infer(&x.slice, errors);
+                        TypeInfo::of_ty(self.heap.mk_class_type(self.stdlib.object().clone()))
+                    } else {
+                        self.subscript_infer(
+                            &base,
+                            &x.slice,
+                            x.range(),
+                            type_form_context.unwrap_or(TypeFormContext::TypeExpression),
+                            errors,
+                        )
+                    }
                 }
             }
             Expr::Named(x) => match &*x.target {

pyrefly/lib/alt/solve.rs

@@ -796,6 +796,11 @@ impl<'ctx, 'answer, Ans: LookupAnswer> AnswersSolver<'ctx, 'answer, Ans> {
                     ty: Some(self.expr_infer(&x.slice, errors)),
                 }
             }
+            // Check subscripts as type forms so that misplaced qualifiers are reported.
+            Expr::Subscript(_) => Annotation::new_type(
+                self.expr_infer_impl(x, None, errors, Some(TypeFormContext::ClassKeyword))
+                    .into_ty(),
+            ),
             _ => Annotation::new_type(self.expr_infer(x, errors)),
         }
     }

pyrefly/lib/test/simple.rs

@@ -2940,6 +2940,26 @@ Z = Annotated[0, 'not a type']  # E: Expected a type form, got instance of `Lite
     "#,
 );
 
+// https://github.com/facebook/pyrefly/issues/5429
+testcase!(
+    test_qualifier_subscript_as_runtime_value,
+    r#"
+from typing import Any, ClassVar, Final, assert_type
+from typing_extensions import NotRequired, ReadOnly, Required
+def mark_optional(hints: dict[str, Any]) -> dict[str, Any]:
+    return {key: NotRequired[hint] for key, hint in hints.items()}
+def f(hint: Any) -> None:
+    assert_type(NotRequired[hint], object)
+    assert_type(Required[int], object)
+    assert_type(ReadOnly[int], object)
+    assert_type(ClassVar[int], object)
+    assert_type(Final[int], object)
+    NotRequired[undefined]  # E: Could not find name `undefined`
+X = NotRequired[int]
+def g(x: X) -> None: ...  # E: Expected a type form, got instance of `object`
+    "#,
+);
+
 testcase!(
     test_typing_annotated_alias,
     r#"