When evaluating type(x) == "y" do identity comparison before string content comparison

Reviewed By: ndmitchell

Differential Revision: D30919274

fbshipit-source-id: 73c3148a3476bc1857e68bac103643e9b7177c33

Author: stepancheg

starlark/src/eval/fragment/expr.rs

@@ -34,9 +34,8 @@ use crate::{
         dict::Dict,
         function::{BoundMethod, NativeAttribute},
         list::List,
-        string::StarlarkStr,
         tuple::{FrozenTuple, Tuple},
-        AttrType, FrozenHeap, FrozenValue, Heap, Value, ValueError, ValueLike,
+        AttrType, FrozenHeap, FrozenStringValue, FrozenValue, Heap, Value, ValueError, ValueLike,
     },
 };
 use gazebo::{coerce::coerce_ref, prelude::*};
@@ -122,11 +121,10 @@ fn try_eval_type_is(
 ) -> Result<ExprCompiledValue, (ExprCompiledValue, ExprCompiledValue)> {
     match (l, r) {
         (ExprCompiledValue::Type(l), ExprCompiledValue::Value(r)) => {
-            if let Some(r) = r.downcast_frozen_ref::<StarlarkStr>() {
-                let t = r.map(|r| r.unpack());
+            if let Some(t) = FrozenStringValue::new(r) {
                 let cmp = maybe_not.as_fn();
                 Ok(expr!("type_is", l, |_eval| {
-                    Value::new_bool(cmp(l.get_type() == t.as_ref()))
+                    Value::new_bool(cmp(l.get_type_value() == t))
                 }))
             } else {
                 Err((ExprCompiledValue::Type(l), ExprCompiledValue::Value(r)))

starlark/src/values/layout/constant.rs

@@ -28,6 +28,7 @@ use std::{
     fmt,
     fmt::{Debug, Formatter},
     intrinsics::copy_nonoverlapping,
+    ptr,
 };
 
 /// A constant string that can be converted to a [`FrozenValue`].
@@ -100,6 +101,14 @@ unsafe impl<'v> CoerceKey<StringValue<'v>> for FrozenStringValue {}
 unsafe impl<'v> Coerce<StringValue<'v>> for StringValue<'v> {}
 unsafe impl<'v> CoerceKey<StringValue<'v>> for StringValue<'v> {}
 
+impl PartialEq for FrozenStringValue {
+    fn eq(&self, other: &Self) -> bool {
+        ptr::eq(self, other) || self.as_str() == other.as_str()
+    }
+}
+
+impl Eq for FrozenStringValue {}
+
 impl FrozenStringValue {
     /// Obtain the [`FrozenValue`] for a [`FrozenStringValue`].
     pub fn unpack(self) -> FrozenValue {
@@ -113,6 +122,20 @@ impl FrozenStringValue {
         debug_assert!(value.unpack_str().is_some());
         FrozenStringValue(&*(value.0.ptr_value() as *const AValueRepr<StarlarkStr>))
     }
+
+    /// Construct from a value. Returns [`None`] if a value does not contain a string.
+    pub(crate) fn new(value: FrozenValue) -> Option<FrozenStringValue> {
+        if value.unpack_str().is_some() {
+            Some(unsafe { Self::new_unchecked(value) })
+        } else {
+            None
+        }
+    }
+
+    /// Get a string.
+    pub(crate) fn as_str(self) -> &'static str {
+        self.0.payload.unpack()
+    }
 }
 
 impl<'v> StringValue<'v> {