Prohibit [X] syntax for runtime types

Reviewed By: cjhopman

Differential Revision: D48933761

fbshipit-source-id: 6f4e5dc6498ea86f3d561884ce79d98f9d8da1df

Author: stepancheg

starlark/src/values/typing/type_compiled/compiled.rs

@@ -73,6 +73,8 @@ enum TypingError {
     InvalidTypeAnnotation(String),
     #[error("`{{A: B}}` cannot be used as type, perhaps you meant `dict[A, B]`")]
     Dict,
+    #[error("`[X]` cannot be used as type, perhaps you meant `list[X]`")]
+    List,
     /// The given type annotation does not exist, but the user might have forgotten quotes around
     /// it
     #[error(r#"Found `{0}` instead of a valid type annotation. Perhaps you meant `"{1}"`?"#)]
@@ -420,12 +422,8 @@ impl<'v> TypeCompiled<Value<'v>> {
     /// Parse `[t1, t2, ...]` as type.
     fn from_list(t: &ListRef<'v>, heap: &'v Heap) -> anyhow::Result<TypeCompiled<Value<'v>>> {
         match t.content() {
-            [] => Err(TypingError::InvalidTypeAnnotation(t.to_string()).into()),
-            [t] => {
-                let t = TypeCompiled::new(*t, heap)?;
-                Ok(TypeCompiled::type_list_of(t, heap))
-            }
-            ts => {
+            [] | [_] => Err(TypingError::List.into()),
+            ts @ [_, _, ..] => {
                 // A union type, can match any
                 let ts = ts.try_map(|t| TypeCompiled::new(*t, heap))?;
                 Ok(TypeCompiled::type_any_of(ts, heap))
@@ -473,6 +471,8 @@ impl TypeCompiled<FrozenValue> {
 fn invalid_type_annotation<'v>(ty: Value<'v>, heap: &'v Heap) -> TypingError {
     if DictRef::from_value(ty).is_some() {
         TypingError::Dict
+    } else if ListRef::from_value(ty).is_some() {
+        TypingError::List
     } else if let Some(name) = ty
         .get_attr("type", heap)
         .ok()

starlark/src/values/typing/type_compiled/tests.rs

@@ -103,7 +103,7 @@ isinstance(None, None)
 isinstance(assert_type, "function")
 isinstance([], list[int])
 isinstance([], list[typing.Any])
-isinstance([1, 2, 3], [int])
+isinstance([1, 2, 3], list[int])
 isinstance(None, [None, int])
 isinstance('test', int | str)
 isinstance(('test', None), (str, None))
@@ -118,13 +118,13 @@ not isinstance({"test": 1, 8: 2}, dict[str, int])
 not isinstance({"test": 1, "more": None}, dict[str, int])
 
 isinstance(1, "")
-isinstance([1,2,"test"], ["_a"])
+isinstance([1,2,"test"], list["_a"])
 "#,
     );
 
     // Checking types fails for invalid types
     a.fail("isinstance(None, isinstance)", "not a valid type");
-    a.fail("isinstance(None, [])", "not a valid type");
+    a.fail("isinstance(None, [])", "cannot be used as type");
     a.fail(
         "isinstance(None, {'1': '', '2': ''})",
         "cannot be used as type",
@@ -180,7 +180,7 @@ fn test_type_compiled_display() {
 
     t("typing.Any", "\"\"");
     t("list[typing.Any]", "list");
-    t("list[typing.Any]", "[\"\"]");
+    t("list[typing.Any]", "list[\"\"]");
     t("None", "None");
     t("\"a\" | \"b\"", "[\"a\", \"b\"]");
 }