Return FrozenStringValue from StarlarkValue::get_type_value

Summary: More assertions with types.

Reviewed By: ndmitchell

Differential Revision: D30892350

fbshipit-source-id: a434db7a8cc42780d75402cb61db1e04e723ec29

Author: stepancheg

starlark/src/eval/fragment/expr.rs

@@ -66,7 +66,7 @@ impl ExprCompiledValue {
             Self::Value(x) => box move |_| Ok(x.to_value()),
             Self::Compiled(x) => x,
             Self::Type(x) => expr!("type", x, |_eval| {
-                x.get_ref().get_type_value().to_value()
+                x.get_ref().get_type_value().unpack().to_value()
             })
             .as_compiled(),
         }

starlark/src/eval/fragment/known.rs

@@ -88,16 +88,18 @@ impl Compiler<'_> {
         // In practice people only really use the empty versions as constants.
         match &expr.node {
             ExprP::Dict(xs) if xs.is_empty() => {
-                return ExprCompiledValue::Value(Dict::get_type_value_static());
+                return ExprCompiledValue::Value(Dict::get_type_value_static().unpack());
             }
             ExprP::List(xs) if xs.is_empty() => {
-                return ExprCompiledValue::Value(List::get_type_value_static());
+                return ExprCompiledValue::Value(List::get_type_value_static().unpack());
             }
             // No need to handle Tuple as it will become frozen if it has no inner-calls
             _ => {}
         }
         match self.expr(expr) {
-            ExprCompiledValue::Value(x) => ExprCompiledValue::Value(x.to_value().get_type_value()),
+            ExprCompiledValue::Value(x) => {
+                ExprCompiledValue::Value(x.to_value().get_type_value().unpack())
+            }
             x => ExprCompiledValue::Type(box x),
         }
     }

starlark/src/macros/mod.rs

@@ -24,14 +24,14 @@ macro_rules! starlark_type {
         fn get_type(&self) -> &'static str {
             $typ
         }
-        fn get_type_value(&self) -> $crate::values::FrozenValue {
+        fn get_type_value(&self) -> $crate::values::FrozenStringValue {
             Self::get_type_value_static()
         }
-        fn get_type_value_static() -> $crate::values::FrozenValue {
+        fn get_type_value_static() -> $crate::values::FrozenStringValue {
             const N: usize = $typ.len();
             static RES: $crate::values::ConstFrozenStringN<N> =
                 $crate::values::ConstFrozenStringN::new($typ);
-            RES.unpack()
+            RES.erase()
         }
     };
 }

starlark/src/stdlib/funcs.rs

@@ -913,7 +913,7 @@ pub(crate) fn global_functions(builder: &mut GlobalsBuilder) {
     /// # "#);
     /// ```
     fn r#type(ref a: Value) -> Value<'v> {
-        Ok(a.get_type_value().to_value())
+        Ok(a.get_type_value().unpack().to_value())
     }
 
     /// [zip](

starlark/src/values/layout/avalue.rs

@@ -24,7 +24,8 @@ use crate::{
         layout::arena::{AValueHeader, AValueRepr},
         none::NoneType,
         string::StarlarkStr,
-        ComplexValue, Freezer, FrozenValue, Heap, SimpleValue, StarlarkValue, Tracer, Value,
+        ComplexValue, Freezer, FrozenStringValue, FrozenValue, Heap, SimpleValue, StarlarkValue,
+        Tracer, Value,
     },
 };
 use gazebo::{any::AnyLifetime, cast, coerce::Coerce};
@@ -298,10 +299,10 @@ impl<'v, Mode: 'static, T: StarlarkValue<'v>> StarlarkValue<'v> for Wrapper<Mode
     fn get_type(&self) -> &'static str {
         self.1.get_type()
     }
-    fn get_type_value(&self) -> FrozenValue {
+    fn get_type_value(&self) -> FrozenStringValue {
         self.1.get_type_value()
     }
-    fn get_type_value_static() -> FrozenValue {
+    fn get_type_value_static() -> FrozenStringValue {
         T::get_type_value_static()
     }
     fn matches_type(&self, ty: &str) -> bool {

starlark/src/values/mod.rs

@@ -566,7 +566,7 @@ impl<'v> Value<'v> {
         self.invoke(location, params, eval)
     }
 
-    pub fn get_type_value(self) -> FrozenValue {
+    pub fn get_type_value(self) -> FrozenStringValue {
         self.get_ref().get_type_value()
     }
 }

starlark/src/values/traits.rs

@@ -34,8 +34,8 @@ use crate::{
     environment::Globals,
     eval::{Arguments, Evaluator},
     values::{
-        docs::DocItem, function::FUNCTION_TYPE, ControlError, Freezer, FrozenValue, Heap, Tracer,
-        Value, ValueError,
+        docs::DocItem, function::FUNCTION_TYPE, ControlError, Freezer, FrozenStringValue, Heap,
+        Tracer, Value, ValueError,
     },
 };
 use gazebo::any::AnyLifetime;
@@ -339,20 +339,20 @@ pub trait StarlarkValue<'v>: 'v + AnyLifetime<'v> + AsStarlarkValue<'v> + Debug
     /// Usually implemented by the [`starlark_type!`] macro.
     fn get_type(&self) -> &'static str;
 
-    /// Like get_type, but returns a reusable [`FrozenValue`] pointer to it.
-    /// This function deliberately doesn't take a heap, as it would not be performant
-    /// to allocate a new value each time.
+    /// Like [`get_type`](Self::get_type), but returns a reusable [`FrozenStringValue`]
+    /// pointer to it. This function deliberately doesn't take a heap,
+    /// as it would not be performant to allocate a new value each time.
     ///
     /// Usually implemented by the [`starlark_type!`] macro.
-    fn get_type_value(&self) -> FrozenValue;
+    fn get_type_value(&self) -> FrozenStringValue;
 
     /// Like [`get_type_value`](Self::get_type_value), but does not require `self`.
     ///
     /// This function must return the same statically-allocated instance as
     /// [`get_type_value`](Self::get_type_value).
     ///
     /// Usually implemented by the [`starlark_type!`] macro.
-    fn get_type_value_static() -> FrozenValue
+    fn get_type_value_static() -> FrozenStringValue
     where
         Self: Sized;
 

starlark/src/values/types/dict.rs

@@ -24,8 +24,8 @@ use crate::{
     values::{
         comparison::equals_small_map, error::ValueError, iter::ARefIterator,
         string::hash_string_value, AllocFrozenValue, AllocValue, ComplexValue, Freezer, FromValue,
-        FrozenHeap, FrozenValue, Heap, SimpleValue, StarlarkValue, Trace, UnpackValue, Value,
-        ValueLike,
+        FrozenHeap, FrozenStringValue, FrozenValue, Heap, SimpleValue, StarlarkValue, Trace,
+        UnpackValue, Value, ValueLike,
     },
 };
 use gazebo::{
@@ -150,7 +150,7 @@ impl<'v> Dict<'v> {
     /// The result of calling `type()` on dictionaries.
     pub const TYPE: &'static str = "dict";
 
-    pub fn get_type_value_static() -> FrozenValue {
+    pub fn get_type_value_static() -> FrozenStringValue {
         DictGen::<FrozenDict>::get_type_value_static()
     }
 

starlark/src/values/types/list.rs

@@ -25,8 +25,9 @@ use crate::{
         error::ValueError,
         index::{apply_slice, convert_index},
         iter::ARefIterator,
-        AllocFrozenValue, AllocValue, ComplexValue, Freezer, FromValue, FrozenHeap, FrozenValue,
-        Heap, SimpleValue, StarlarkValue, UnpackValue, Value, ValueLike,
+        AllocFrozenValue, AllocValue, ComplexValue, Freezer, FromValue, FrozenHeap,
+        FrozenStringValue, FrozenValue, Heap, SimpleValue, StarlarkValue, UnpackValue, Value,
+        ValueLike,
     },
 };
 use gazebo::{
@@ -183,7 +184,7 @@ impl<'v> List<'v> {
     /// The result of calling `type()` on lists.
     pub const TYPE: &'static str = "list";
 
-    pub fn get_type_value_static() -> FrozenValue {
+    pub fn get_type_value_static() -> FrozenStringValue {
         ListGen::<FrozenList>::get_type_value_static()
     }