Fix oss build

Summary:
Fix more OSS breakages due to pagable impls in D94933232

Removing `pagable_dep` gate for `starlark-rust/starlark` because it no longer makes sense:
- The OSS breakage came from adding buck2 code that depends on `starlark-rust/starlark` without enabling the `pagable_dep` feature from buck2.
- Enabling `pagable_dep` for `starlark-rust/starlark` no longer makes sense since it now has a non-optional dependency on pagable.
- The non-optional dependency from `starlark-rust/starlark` was added by Nero5023 by using the `tokio` feature instead of `pagable_dep`: D96530196

Reviewed By: Nero5023

Differential Revision: D96976881

fbshipit-source-id: ee78a2447deed1c3097ce9a0397382644cba8ae6

Author: christolliday

starlark/src/environment/globals.rs

@@ -50,7 +50,7 @@ use crate::values::types::function::NativeFunction;
 
 /// The global values available during execution.
 #[derive(Clone, Dupe, Debug, Allocative)]
-#[cfg_attr(feature = "pagable_dep", derive(pagable::PagablePanic))]
+#[derive(pagable::PagablePanic)]
 pub struct Globals(Arc<GlobalsData>);
 
 type GlobalValue = MaybeDocHiddenValue<'static, FrozenValue>;

starlark/src/environment/modules.rs

@@ -77,7 +77,7 @@ enum ModuleError {
 /// these values after the [`FrozenModule`] has been released unless you obtain a reference
 /// to the frozen heap.
 #[derive(Debug, Clone, Dupe, Allocative)]
-#[cfg_attr(feature = "pagable_dep", derive(pagable::PagablePanic))]
+#[derive(pagable::PagablePanic)]
 // We store the two elements separately since the FrozenHeapRef contains
 // a copy of the FrozenModuleData inside it.
 // Two Arc's should still be plenty cheap enough to qualify for `Dupe`.

starlark/src/eval/runtime/profile/mode.rs

@@ -23,7 +23,7 @@ use dupe::Dupe;
 
 /// How to profile starlark code.
 #[derive(Debug, PartialEq, Eq, Hash, Clone, Dupe, Copy, Allocative)]
-#[cfg_attr(feature = "pagable_dep", derive(pagable::Pagable))]
+#[derive(pagable::Pagable)]
 #[non_exhaustive]
 pub enum ProfileMode {
     /// The heap profile mode provides information about the time spent in each function and allocations

starlark/src/values/layout/typed.rs

@@ -77,7 +77,7 @@ pub struct ValueTyped<'v, T: StarlarkValue<'v>>(Value<'v>, marker::PhantomData<T
 /// [`FrozenValue`] wrapper which asserts contained value is of type `<T>`.
 #[derive(Copy_, Clone_, Dupe_, ProvidesStaticType, Allocative)]
 #[allocative(skip)] // Heap owns the value.
-#[cfg_attr(feature = "pagable_dep", derive(pagable::PagablePanic))]
+#[derive(pagable::PagablePanic)]
 #[repr(transparent)]
 pub struct FrozenValueTyped<'v, T: StarlarkValue<'v>>(FrozenValue, marker::PhantomData<&'v T>);
 

starlark/src/values/layout/value.rs

@@ -245,7 +245,7 @@ impl Equivalent<Value<'_>> for FrozenValue {
 /// when working directly with [`FrozenValue`]s. See the type [`OwnedFrozenValue`](crate::values::OwnedFrozenValue)
 /// for a little bit more safety.
 #[derive(Clone, Copy, Dupe, ProvidesStaticType, Allocative)]
-#[cfg_attr(feature = "pagable_dep", derive(pagable::PagablePanic))]
+#[derive(pagable::PagablePanic)]
 // One possible change: moving from Blackhole during GC
 pub struct FrozenValue(
     #[allocative(skip)] // Because it is owned by the heap.

starlark/src/values/owned.rs

@@ -52,7 +52,7 @@ enum OwnedError {
 /// is strongly discouraged. See the other methods which unpack the code, access it as a
 /// [`Value`] (which has a suitable lifetime) or add references to other heaps.
 #[derive(Debug, Clone, Dupe, Allocative)]
-#[cfg_attr(feature = "pagable_dep", derive(pagable::PagablePanic))]
+#[derive(pagable::PagablePanic)]
 pub struct OwnedFrozenValue {
     owner: FrozenHeapRef,
     // Invariant: this FrozenValue must be kept alive by the `owner` field.
@@ -199,7 +199,7 @@ impl OwnedFrozenValue {
 
 /// Same as [`OwnedFrozenValue`] but it is known to contain `T`.
 #[derive(Debug, Clone_, Dupe_, Allocative)]
-#[cfg_attr(feature = "pagable_dep", derive(pagable::PagablePanic))]
+#[derive(pagable::PagablePanic)]
 pub struct OwnedFrozenValueTyped<T: StarlarkValue<'static>> {
     owner: FrozenHeapRef,
     value: FrozenValueTyped<'static, T>,

starlark/src/values/thin_box_slice_frozen_value/packed_impl.rs

@@ -112,7 +112,7 @@ unsafe impl Sync for PackedImpl where FrozenValue: Sync {}
 /// Specifically, this type uses bit packing and other tricks so that it is only
 /// 8 bytes in size, while being allocation free for lengths zero and one. It
 /// depends on the lower bit of a FrozenPointer always being unset.
-#[cfg_attr(feature = "pagable_dep", derive(pagable::PagablePanic))]
+#[derive(pagable::PagablePanic)]
 pub struct ThinBoxSliceFrozenValue<'v>(PackedImpl, PhantomData<&'v ()>);
 
 impl<'v> ThinBoxSliceFrozenValue<'v> {

starlark/src/values/types/type_instance_id.rs

@@ -28,7 +28,7 @@ use crate as starlark;
 #[derive(
     Debug, Copy, Clone, Dupe, Hash, Eq, PartialEq, Ord, PartialOrd, Allocative, Freeze
 )]
-#[cfg_attr(feature = "pagable_dep", derive(pagable::PagablePanic))]
+#[derive(pagable::PagablePanic)]
 pub struct TypeInstanceId(u64);
 
 impl TypeInstanceId {

starlark/src/values/typing/callable.rs

@@ -211,7 +211,7 @@ impl<'v, P: StarlarkCallableParamSpec, R: StarlarkTypeRepr> AllocValue<'v>
 /// Marker for a callable value.
 #[derive(Allocative)]
 #[allocative(bound = "")]
-#[cfg_attr(feature = "pagable_dep", derive(pagable::PagablePanic))]
+#[derive(pagable::PagablePanic)]
 pub struct FrozenStarlarkCallable<
     P: StarlarkCallableParamSpec = StarlarkCallableParamAny,
     R: StarlarkTypeRepr = FrozenValue,

starlark/src/values/value_of_unchecked.rs

@@ -48,7 +48,7 @@ use crate::values::type_repr::StarlarkTypeRepr;
 /// Store value annotated with type, but do not check the type.
 #[derive(Clone_, Copy_, Dupe_, Allocative)]
 #[allocative(bound = "")]
-#[cfg_attr(feature = "pagable_dep", derive(pagable::PagablePanic))]
+#[derive(pagable::PagablePanic)]
 pub struct ValueOfUncheckedGeneric<V: ValueLifetimeless, T: StarlarkTypeRepr>(
     V,
     PhantomData<fn() -> T>,