Make TyBasic::List intersect with TyStarlarkValue::new::<List>

Summary:
I'm not sure whether we should allow `TyStarlarkValue::new::<List>`.

Allow it for now, and make intersect work. Safe anyway.

Reviewed By: ianlevesque

Differential Revision: D48935562

fbshipit-source-id: 67226088df6e289e0e95767530ad55a46db12abd

Author: stepancheg

starlark/src/typing/oracle/ctx.rs

@@ -833,11 +833,13 @@ impl<'a> TypingOracleCtx<'a> {
             (TyBasic::Name(_), TyBasic::StarlarkValue(_)) => true,
             (TyBasic::Name(x), y) => Some(x.as_str()) == y.as_name(),
             (TyBasic::List(x), TyBasic::List(y)) => self.intersects(x, y),
+            (TyBasic::List(_), TyBasic::StarlarkValue(y)) => y.is_list(),
             (TyBasic::Dict(x_k, x_v), TyBasic::Dict(y_k, y_v)) => {
                 self.intersects(x_k, y_k) && self.intersects(x_v, y_v)
             }
+            (TyBasic::Dict(..), TyBasic::StarlarkValue(y)) => y.is_dict(),
             (TyBasic::Tuple(x), TyBasic::Tuple(y)) => TyTuple::intersects(x, y, self),
-            (TyBasic::Tuple(_), t) => t.is_tuple(),
+            (TyBasic::Tuple(_), TyBasic::StarlarkValue(y)) => y.is_tuple(),
             (TyBasic::Iter(x), TyBasic::Iter(y)) => self.intersects(x, y),
             (TyBasic::Iter(x), y) | (y, TyBasic::Iter(x)) => match self.iter_item_basic(y) {
                 Ok(yy) => self.intersects(x, &yy),

starlark/src/typing/starlark_value.rs

@@ -35,7 +35,9 @@ use crate::typing::TypingBinOp;
 use crate::typing::TypingOracleCtx;
 use crate::typing::TypingUnOp;
 use crate::values::bool::StarlarkBool;
+use crate::values::dict::value::FrozenDict;
 use crate::values::float::StarlarkFloat;
+use crate::values::list::value::FrozenList;
 use crate::values::none::NoneType;
 use crate::values::starlark_type_id::StarlarkTypeId;
 use crate::values::string::StarlarkStr;
@@ -180,6 +182,21 @@ impl TyStarlarkValue {
         self == TyStarlarkValue::new::<StarlarkBigInt>()
     }
 
+    pub(crate) fn is_list(self) -> bool {
+        self.self_check();
+        self == TyStarlarkValue::new::<FrozenList>()
+    }
+
+    pub(crate) fn is_dict(self) -> bool {
+        self.self_check();
+        self == TyStarlarkValue::new::<FrozenDict>()
+    }
+
+    pub(crate) fn is_tuple(self) -> bool {
+        self.self_check();
+        self == TyStarlarkValue::new::<Tuple>()
+    }
+
     /// Result of applying unary operator to this type.
     pub(crate) fn un_op(self, un_op: TypingUnOp) -> Result<TyStarlarkValue, ()> {
         let has = match un_op {