Minor refactoring of strings

Summary:
* change `ConstFrozenStringN` from

```
pub struct ConstFrozenStringN<const N: usize> {
    vtable: AValueHeader,
    object: StarlarkStr,
    payload: [u8; N],
}
```

to

```
pub struct ConstFrozenStringN<const N: usize> {
    repr: AValueRepr<StarlarkStr>,
    payload: [u8; N],
}
```

* change `ConstFrozenString` from

```
pub struct ConstFrozenString(&'static AValueHeader);
```

to

```
pub struct ConstFrozenString(&'static AValueRepr<StarlarkStr>);
```

and also
* make `AValueRepr` fields `pub(crate)`
* remove `AValueRepr::header()` method (because fields are `pub(crate)` now
* add `FrozenValue::new_repr` constructor

This is mostly for safety/readability.

Reviewed By: ndmitchell

Differential Revision: D30876688

fbshipit-source-id: 2fdeb457c73e080ca0f6147438a6197988366ee1

Author: stepancheg

starlark/src/values/layout/arena.rs

@@ -53,8 +53,8 @@ pub(crate) struct AValueHeader(DynMetadata<dyn AValue<'static>>);
 /// How object is represented in arena.
 #[repr(C)]
 pub(crate) struct AValueRepr<T> {
-    header: AValueHeader,
-    payload: T,
+    pub(crate) header: AValueHeader,
+    pub(crate) payload: T,
 }
 
 /// This is object written over [`AValueRepr`] during GC.
@@ -309,10 +309,6 @@ impl<T> AValueRepr<T> {
             payload,
         }
     }
-
-    pub(crate) const fn header(&self) -> &AValueHeader {
-        &self.header
-    }
 }
 
 impl Drop for Arena {

starlark/src/values/layout/avalue.rs

@@ -41,23 +41,23 @@ pub(crate) static VALUE_NONE: &AValueHeader = {
     const DYN: &dyn AValue<'static> = &PAYLOAD;
     static DATA: AValueRepr<Wrapper<Basic, NoneType>> =
         AValueRepr::with_metadata(metadata(DYN), PAYLOAD);
-    DATA.header()
+    &DATA.header
 };
 
 pub(crate) static VALUE_FALSE: &AValueHeader = {
     const PAYLOAD: Wrapper<Basic, bool> = Wrapper(Basic, false);
     const DYN: &dyn AValue<'static> = &PAYLOAD;
     static DATA: AValueRepr<Wrapper<Basic, bool>> =
         AValueRepr::with_metadata(metadata(DYN), PAYLOAD);
-    DATA.header()
+    &DATA.header
 };
 
 pub(crate) static VALUE_TRUE: &AValueHeader = {
     const PAYLOAD: Wrapper<Basic, bool> = Wrapper(Basic, true);
     const DYN: &dyn AValue<'static> = &PAYLOAD;
     static DATA: AValueRepr<Wrapper<Basic, bool>> =
         AValueRepr::with_metadata(metadata(DYN), PAYLOAD);
-    DATA.header()
+    &DATA.header
 };
 
 pub(crate) const VALUE_STR_A_VALUE_PTR: AValueHeader = {

starlark/src/values/layout/constant.rs

@@ -16,7 +16,7 @@
  */
 
 use crate::values::{
-    layout::{arena::AValueHeader, avalue::VALUE_STR_A_VALUE_PTR, value::FrozenValue},
+    layout::{arena::AValueRepr, avalue::VALUE_STR_A_VALUE_PTR, value::FrozenValue},
     string::StarlarkStr,
 };
 use gazebo::prelude::*;
@@ -25,8 +25,7 @@ use std::intrinsics::copy_nonoverlapping;
 /// A constant string that can be converted to a [`FrozenValue`].
 #[repr(C)] // Must match this layout on the heap
 pub struct ConstFrozenStringN<const N: usize> {
-    vtable: AValueHeader,
-    object: StarlarkStr,
+    repr: AValueRepr<StarlarkStr>,
     payload: [u8; N],
 }
 
@@ -40,8 +39,10 @@ impl<const N: usize> ConstFrozenStringN<N> {
             copy_nonoverlapping(s.as_ptr(), payload.as_mut_ptr(), N)
         };
         Self {
-            vtable: VALUE_STR_A_VALUE_PTR,
-            object: unsafe { StarlarkStr::new(N) },
+            repr: AValueRepr {
+                header: VALUE_STR_A_VALUE_PTR,
+                payload: unsafe { StarlarkStr::new(N) },
+            },
             payload,
         }
     }
@@ -53,7 +54,7 @@ impl<const N: usize> ConstFrozenStringN<N> {
 
     /// Erase the type parameter, giving a slightly nicer user experience.
     pub const fn erase(&'static self) -> ConstFrozenString {
-        ConstFrozenString(&self.vtable)
+        ConstFrozenString(&self.repr)
     }
 }
 
@@ -70,12 +71,12 @@ impl<const N: usize> ConstFrozenStringN<N> {
 /// assert_eq!(Some("magic"), fv.to_value().unpack_str());
 /// ```
 #[derive(Copy, Clone, Dupe)]
-pub struct ConstFrozenString(&'static AValueHeader);
+pub struct ConstFrozenString(&'static AValueRepr<StarlarkStr>);
 
 impl ConstFrozenString {
     /// Obtain the [`FrozenValue`] for a [`ConstFrozenString`].
     pub fn unpack(self) -> FrozenValue {
-        FrozenValue::new_ptr(self.0)
+        FrozenValue::new_repr(self.0)
     }
 }
 

starlark/src/values/layout/value.rs

@@ -31,13 +31,14 @@
 
 use crate::values::{
     layout::{
-        arena::AValueHeader,
+        arena::{AValueHeader, AValueRepr},
         avalue::{basic_ref, AValue, VALUE_FALSE, VALUE_NONE, VALUE_TRUE},
         constant::VALUE_EMPTY_STRING,
         pointer::Pointer,
         pointer_i32::PointerI32,
     },
     string::StarlarkStr,
+    StarlarkValue,
 };
 use either::Either;
 use gazebo::{
@@ -192,6 +193,10 @@ impl FrozenValue {
         Self(Pointer::new_frozen(x))
     }
 
+    pub(crate) fn new_repr<'a, T: StarlarkValue<'a>>(x: &'static AValueRepr<T>) -> Self {
+        Self::new_ptr(&x.header)
+    }
+
     pub(crate) fn new_ptr_usize(x: usize) -> Self {
         Self(Pointer::new_frozen_usize(x))
     }