Seal AnyLifetime instead of having it be unsafe

Summary: Doesn't have to be unsafe to implement if no one can implement it

Reviewed By: Nero5023

Differential Revision: D74131158

fbshipit-source-id: 5e3550564bba20d85065cae6cdc8b000a3b981ba

Author: JakobDegen

starlark-rust/starlark/src/any.rs

@@ -45,7 +45,7 @@ pub unsafe trait ProvidesStaticType<'a> {
 /// Note `ProvidesStaticType` and `AnyLifetime` cannot be the same type,
 /// because `AnyLifetime` need to be object safe,
 /// and `ProvidesStaticType` has type member.
-unsafe impl<'a, T: ProvidesStaticType<'a> + 'a + ?Sized> AnyLifetime<'a> for T {
+impl<'a, T: ProvidesStaticType<'a> + 'a + ?Sized> AnyLifetime<'a> for T {
     fn static_type_id() -> TypeId
     where
         Self: Sized,
@@ -58,15 +58,14 @@ unsafe impl<'a, T: ProvidesStaticType<'a> + 'a + ?Sized> AnyLifetime<'a> for T {
     }
 }
 
-/// Like [`Any`](std::any::Any), but while [`Any`](std::any::Any) requires `'static`,
-/// this version allows a lifetime parameter.
+/// Like [`Any`](std::any::Any), but while [`Any`](std::any::Any) requires `'static`, this version
+/// allows a lifetime parameter.
 ///
-/// Code using this trait is _unsafe_ if your implementation of the inner
-/// methods do not meet the invariants listed. Therefore, it is recommended you
-/// use one of the helper macros.
+/// Code using this trait is _unsafe_ if your implementation of the inner methods do not meet the
+/// invariants listed. Therefore, it is recommended you use one of the helper macros.
 ///
-/// If your data type is of the form `Foo` or `Foo<'v>` you can derive
-/// `AnyLifetime`:
+/// You cannot implement this trait directly. You should instead implement `ProvidesStaticType`,
+/// usually via the derive macro:
 ///
 /// ```
 /// use starlark::any::ProvidesStaticType;
@@ -76,8 +75,8 @@ unsafe impl<'a, T: ProvidesStaticType<'a> + 'a + ?Sized> AnyLifetime<'a> for T {
 /// struct Foo2<'a>(&'a ());
 /// ```
 ///
-/// For more complicated context or constraints, you can implement `ProvidesStaticType`
-/// directly.
+/// If your data type is not of the form `Foo` or `Foo<'v>` you may need to implement
+/// `ProvidesStaticType` directly.
 ///
 /// ```
 /// use starlark::any::ProvidesStaticType;
@@ -94,7 +93,7 @@ unsafe impl<'a, T: ProvidesStaticType<'a> + 'a + ?Sized> AnyLifetime<'a> for T {
 /// }
 /// # }
 /// ```
-pub unsafe trait AnyLifetime<'a>: 'a {
+pub trait AnyLifetime<'a>: seal::ProvidesStaticTypeSealed<'a> + 'a {
     /// Must return the `TypeId` of `Self` but where the lifetimes are changed
     /// to `'static`. Must be consistent with `static_type_of`.
     fn static_type_id() -> TypeId
@@ -108,6 +107,12 @@ pub unsafe trait AnyLifetime<'a>: 'a {
     // Required so we can have a `dyn AnyLifetime`.
 }
 
+mod seal {
+    /// A bound required by `AnyLifetime<'a>` for sealing it
+    pub trait ProvidesStaticTypeSealed<'a> {}
+    impl<'a, T: super::ProvidesStaticType<'a> + ?Sized> ProvidesStaticTypeSealed<'a> for T {}
+}
+
 impl<'a> dyn AnyLifetime<'a> {
     /// Is the value of type `T`.
     pub fn is<T: AnyLifetime<'a>>(&self) -> bool {