Prohibit {X: Y} as dict[X, Y] in type expressions

Summary: It is still allowed in regular expressions like `isinstance(1, {"": ""})`.

Reviewed By: ndmitchell

Differential Revision: D48217281

fbshipit-source-id: 5f8caaab8430fb9a78a124c70f14616c6f734a35

starlark/src/eval/compiler/types.rs

@@ -196,11 +196,6 @@ impl<'v> Compiler<'v, '_, '_> {
                 let xs = xs.into_try_map(|x| self.eval_expr_as_type(x))?;
                 Ok(TypeCompiled::type_any_of(xs, self.eval.heap()))
             }
-            TypeExprUnpackP::DictOf(k, v) => {
-                let k = self.eval_expr_as_type(*k)?;
-                let v = self.eval_expr_as_type(*v)?;
-                Ok(TypeCompiled::type_dict_of(k, v, self.eval.heap()))
-            }
             TypeExprUnpackP::Tuple(xs) => {
                 let xs = xs.into_try_map(|x| self.eval_expr_as_type(x))?;
                 Ok(TypeCompiled::type_tuple_of(xs, self.eval.heap()))

starlark/src/syntax/type_expr.rs

@@ -32,8 +32,6 @@ enum TypeExprUnpackError {
     InvalidType(&'static str),
     #[error("Empty list is not allowed in type expression")]
     EmptyListInType,
-    #[error("Only dict literal with single entry is allowed in type expression")]
-    DictNot1InType,
     #[error("Only dot expression of form `ident.ident` is allowed in type expression")]
     DotInType,
 }
@@ -51,10 +49,6 @@ pub(crate) enum TypeExprUnpackP<'a, P: AstPayload> {
         Box<Spanned<TypeExprUnpackP<'a, P>>>,
     ),
     Union(Vec<Spanned<TypeExprUnpackP<'a, P>>>),
-    DictOf(
-        Box<Spanned<TypeExprUnpackP<'a, P>>>,
-        Box<Spanned<TypeExprUnpackP<'a, P>>>,
-    ),
     Tuple(Vec<Spanned<TypeExprUnpackP<'a, P>>>),
     Literal(Spanned<&'a str>),
 }
@@ -182,24 +176,7 @@ impl<'a, P: AstPayload> TypeExprUnpackP<'a, P> {
                     })
                 }
             }
-            ExprP::Dict(xs) => {
-                if xs.len() != 1 {
-                    Err(EvalException::new(
-                        TypeExprUnpackError::DictNot1InType.into(),
-                        expr.span,
-                        codemap,
-                    ))
-                } else {
-                    let (k, v) = &xs[0];
-                    Ok(Spanned {
-                        span,
-                        node: TypeExprUnpackP::DictOf(
-                            Box::new(TypeExprUnpackP::unpack(k, codemap)?),
-                            Box::new(TypeExprUnpackP::unpack(v, codemap)?),
-                        ),
-                    })
-                }
-            }
+            ExprP::Dict(..) => err("dict"),
             ExprP::ListComprehension(..) => err("list comprehension"),
             ExprP::DictComprehension(..) => err("dict comprehension"),
             ExprP::FString(..) => err("f-string"),

starlark/src/typing/ty.rs

@@ -456,10 +456,6 @@ impl Ty {
             TypeExprUnpackP::Union(xs) => {
                 Ty::unions(xs.map(|x| Self::from_expr_impl(x, approximations)))
             }
-            TypeExprUnpackP::DictOf(k, v) => Ty::dict(
-                Self::from_expr_impl(k, approximations),
-                Self::from_expr_impl(v, approximations),
-            ),
             TypeExprUnpackP::Literal(x) => {
                 if x.is_empty() || x.starts_with('_') {
                     Ty::any()