Register TypeCompiledImplAsStarlarkValue with TypeMatcher

Summary:
Add registration support for `TypeCompiledImplAsStarlarkValue<T: TypeMatcher>,` which is a special wrapper type that exposes `TypeMatcher` implementations as Starlark values.

1. **Marker Trait Introduction**: Introduce the `TypeMatcherRegistered` marker trait to indicate that a TypeMatcher type has been properly registered in the vtable registry. This ensures compile-time safety for serialization/deserialization.
2.  All registration code is gated behind the `pagable` feature flag. support backwards compatibility
2. **New #[type_matcher] Derive Macro**: Create a new proc macro in starlark_derive that:
  * Implements the `TypeMatcherRegistered` marker trait for the annotated type
  * Automatically generates vtable registration code for `TypeCompiledImplAsStarlarkValue<Self>`
  * Works for `TypeMatcher` types without generic parameters. Will make it fail in next diff when it have generic parameters

 ---
## Some impl details
1. defined a `TypeMatcherBase` trait that `TypeMatcher` deps on. Base on the cfg pagable to add `TypeMatcherRegistered` or not. This make it easier to mantain.
2. add the `TypeMatcherRegistered` for `T` of `fn alloc` in `TypeMatcherAlloc` when cfg pagable. It is for better error message.
  - With this, error message: P2141029408
  - Without this, error message: P2141030387

Reviewed By: cjhopman

Differential Revision: D90875024

fbshipit-source-id: bbfe8b4c911a709eb2248f5fdcefb03bde8dbf58

Author: Nero5023

starlark/src/lib.rs

@@ -439,6 +439,7 @@
 mod macros;
 
 pub use starlark_derive::starlark_module;
+pub use starlark_derive::type_matcher;
 pub use starlark_syntax::Error;
 pub use starlark_syntax::ErrorKind;
 pub use starlark_syntax::Result;

starlark/src/pagable/vtable_registry.rs

@@ -242,4 +242,36 @@ mod tests {
         let vt = vtable.unwrap();
         assert_eq!(vt.type_name, "list");
     }
+
+    #[test]
+    fn test_type_compiled_non_generic_matcher_is_registered() {
+        // IsAnyOf is a non-generic TypeMatcher, so TypeCompiledImplAsStarlarkValue<IsAnyOf>
+        // should be registered by the #[type_matcher] macro.
+        use crate::values::typing::type_compiled::compiled::TypeCompiledImplAsStarlarkValue;
+        use crate::values::typing::type_compiled::matchers::IsAnyOf;
+        let type_id = DeserTypeId::of::<TypeCompiledImplAsStarlarkValue<IsAnyOf>>();
+        let vtable = lookup_vtable(type_id);
+        assert!(
+            vtable.is_ok(),
+            "Expected TypeCompiledImplAsStarlarkValue<IsAnyOf> to be registered. Available types: {:?}",
+            registered_type_ids()
+        );
+    }
+
+    #[test]
+    fn test_type_compiled_generic_matcher_is_not_registered() {
+        // IsListOf is a generic TypeMatcher (IsListOf<I>), so TypeCompiledImplAsStarlarkValue
+        // for specific instantiations like IsListOf<TypeMatcherBox> should NOT be registered
+        // (the macro skips vtable registration for generic types).
+        use crate::values::typing::type_compiled::compiled::TypeCompiledImplAsStarlarkValue;
+        use crate::values::typing::type_compiled::matcher::TypeMatcherBox;
+        use crate::values::typing::type_compiled::matchers::IsListOf;
+        let type_id =
+            DeserTypeId::of::<TypeCompiledImplAsStarlarkValue<IsListOf<TypeMatcherBox>>>();
+        let vtable = lookup_vtable(type_id);
+        assert!(
+            vtable.is_err(),
+            "Expected TypeCompiledImplAsStarlarkValue<IsListOf<TypeMatcherBox>> to NOT be registered, but it was found"
+        );
+    }
 }

starlark/src/typing/structs.rs

@@ -22,8 +22,10 @@ use std::sync::Arc;
 
 use allocative::Allocative;
 use dupe::Dupe;
+use starlark_derive::type_matcher;
 use starlark_map::sorted_map::SortedMap;
 
+use crate as starlark;
 use crate::typing::Ty;
 use crate::typing::TyBasic;
 use crate::typing::TypingBinOp;
@@ -37,6 +39,16 @@ use crate::values::structs::StructRef;
 use crate::values::typing::type_compiled::alloc::TypeMatcherAlloc;
 use crate::values::typing::type_compiled::matcher::TypeMatcher;
 
+#[derive(Allocative, Eq, PartialEq, Hash, Debug, Clone, Copy, Dupe)]
+struct StructMatcher;
+
+#[type_matcher]
+impl TypeMatcher for StructMatcher {
+    fn matches(&self, value: Value) -> bool {
+        StructRef::is_instance(value)
+    }
+}
+
 /// Struct type.
 #[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Allocative)]
 pub struct TyStruct {
@@ -109,15 +121,6 @@ impl TyCustomImpl for TyStruct {
     }
 
     fn matcher<T: TypeMatcherAlloc>(&self, factory: T) -> T::Result {
-        #[derive(Allocative, Eq, PartialEq, Hash, Debug, Clone, Copy, Dupe)]
-        struct StructMatcher;
-
-        impl TypeMatcher for StructMatcher {
-            fn matches(&self, value: Value) -> bool {
-                StructRef::is_instance(value)
-            }
-        }
-
         factory.alloc(StructMatcher)
     }
 }

starlark/src/values/types/enumeration/matcher.rs

@@ -17,7 +17,9 @@
 
 use allocative::Allocative;
 use dupe::Dupe;
+use starlark_derive::type_matcher;
 
+use crate as starlark;
 use crate::values::Value;
 use crate::values::enumeration::EnumValue;
 use crate::values::types::type_instance_id::TypeInstanceId;
@@ -28,6 +30,7 @@ pub(crate) struct EnumTypeMatcher {
     pub(crate) id: TypeInstanceId,
 }
 
+#[type_matcher]
 impl TypeMatcher for EnumTypeMatcher {
     fn matches(&self, value: Value) -> bool {
         match EnumValue::from_value(value) {

starlark/src/values/types/namespace/typing.rs

@@ -21,8 +21,10 @@ use std::fmt::Formatter;
 
 use allocative::Allocative;
 use dupe::Dupe;
+use starlark_derive::type_matcher;
 use starlark_map::sorted_map::SortedMap;
 
+use crate as starlark;
 use crate::codemap::Span;
 use crate::typing::ParamSpec;
 use crate::typing::Ty;
@@ -40,6 +42,16 @@ use crate::values::types::namespace::value::Namespace;
 use crate::values::typing::type_compiled::alloc::TypeMatcherAlloc;
 use crate::values::typing::type_compiled::matcher::TypeMatcher;
 
+#[derive(Allocative, Eq, PartialEq, Hash, Debug, Clone, Copy, Dupe)]
+struct NamespaceMatcher;
+
+#[type_matcher]
+impl TypeMatcher for NamespaceMatcher {
+    fn matches(&self, value: Value) -> bool {
+        value.starlark_type_id() == StarlarkTypeId::of::<Namespace<'static>>()
+    }
+}
+
 #[derive(
     Allocative, Clone, Copy, Dupe, Debug, Eq, PartialEq, Hash, Ord, PartialOrd
 )]
@@ -106,15 +118,6 @@ impl TyCustomImpl for TyNamespace {
     }
 
     fn matcher<T: TypeMatcherAlloc>(&self, factory: T) -> T::Result {
-        #[derive(Allocative, Eq, PartialEq, Hash, Debug, Clone, Copy, Dupe)]
-        struct NamespaceMatcher;
-
-        impl TypeMatcher for NamespaceMatcher {
-            fn matches(&self, value: Value) -> bool {
-                value.starlark_type_id() == StarlarkTypeId::of::<Namespace<'static>>()
-            }
-        }
-
         factory.alloc(NamespaceMatcher)
     }
 }

starlark/src/values/types/record/matcher.rs

@@ -17,7 +17,9 @@
 
 use allocative::Allocative;
 use dupe::Dupe;
+use starlark_derive::type_matcher;
 
+use crate as starlark;
 use crate::values::Value;
 use crate::values::record::Record;
 use crate::values::types::type_instance_id::TypeInstanceId;
@@ -28,6 +30,7 @@ pub(crate) struct RecordTypeMatcher {
     pub(crate) id: TypeInstanceId,
 }
 
+#[type_matcher]
 impl TypeMatcher for RecordTypeMatcher {
     fn matches(&self, value: Value) -> bool {
         match Record::from_value(value) {

starlark/src/values/typing.rs

@@ -36,6 +36,8 @@ pub use crate::values::typing::callable::param::StarlarkCallableParamSpec;
 pub use crate::values::typing::iter::StarlarkIter;
 pub use crate::values::typing::never::StarlarkNever;
 pub use crate::values::typing::type_compiled::compiled::TypeCompiled;
+pub use crate::values::typing::type_compiled::compiled::TypeCompiledImplAsStarlarkValue;
 pub use crate::values::typing::type_compiled::matcher::TypeMatcher;
+pub use crate::values::typing::type_compiled::matcher::TypeMatcherRegistered;
 pub use crate::values::typing::type_compiled::type_matcher_factory::TypeMatcherFactory;
 pub use crate::values::typing::type_type::TypeType;

starlark/src/values/typing/type_compiled/alloc.rs

@@ -47,6 +47,19 @@ use crate::values::typing::type_compiled::type_matcher_factory::TypeMatcherFacto
 pub trait TypeMatcherAlloc: Sized {
     type Result;
 
+    // When the `pagable` feature is enabled, we explicitly require `TypeMatcherRegistered`,
+    // although it is reuqired by TypeMatcher.
+    // It can produce better error messages. Generic matchers that not impls TypeMatcherRegistered
+    // will have concrete type in the error messages.
+    #[cfg(feature = "pagable")]
+    fn alloc<
+        T: TypeMatcher + crate::values::typing::type_compiled::matcher::TypeMatcherRegistered,
+    >(
+        self,
+        matcher: T,
+    ) -> Self::Result;
+
+    #[cfg(not(feature = "pagable"))]
     fn alloc<T: TypeMatcher>(self, matcher: T) -> Self::Result;
 
     fn custom(self, custom: &TyCustom) -> Self::Result;

starlark/src/values/typing/type_compiled/compiled.rs

@@ -26,6 +26,7 @@ use allocative::Allocative;
 use dupe::Dupe;
 use starlark_derive::starlark_module;
 use starlark_derive::starlark_value;
+use starlark_derive::type_matcher;
 use starlark_map::StarlarkHasher;
 use starlark_syntax::slice_vec_ext::SliceExt;
 use starlark_syntax::slice_vec_ext::VecExt;
@@ -119,6 +120,7 @@ where
     ProvidesStaticType,
     NoSerialize
 )]
+/// A compiled type expression wrapped as a Starlark value with a type matcher.
 pub struct TypeCompiledImplAsStarlarkValue<T: 'static> {
     type_compiled_impl: T,
     ty: Ty,
@@ -143,6 +145,7 @@ where
 #[derive(Hash, Eq, PartialEq, Debug, Clone, Allocative)]
 pub struct DummyTypeMatcher;
 
+#[type_matcher]
 impl TypeMatcher for DummyTypeMatcher {
     fn matches(&self, _value: Value) -> bool {
         unreachable!()

starlark/src/values/typing/type_compiled/matcher.rs

@@ -18,15 +18,52 @@
 use std::fmt::Debug;
 
 use allocative::Allocative;
+use starlark_derive::type_matcher;
 
+use crate as starlark;
 use crate::typing::custom::TyCustom;
 use crate::values::Value;
 use crate::values::typing::type_compiled::alloc::TypeMatcherAlloc;
 use crate::values::typing::type_compiled::type_matcher_factory::TypeMatcherFactory;
 
+/// Marker trait for type matchers which are registered.
+///
+/// This trait is automatically implemented by the `#[type_matcher]` proc macro.
+///
+/// # Safety
+///
+/// This trait must only be implemented by the `#[type_matcher]` proc macro,
+/// which ensures the type is properly registered in the vtable registry.
+/// Manual implementations may break deserialization.
+#[cfg_attr(not(feature = "pagable"), allow(dead_code))]
+pub unsafe trait TypeMatcherRegistered {}
+
+/// Base trait for type matchers
+///
+///  When `pagable` is enabled, matchers must also implement `TypeMatcherRegistered`
+/// to ensure they are registered.
+#[cfg(feature = "pagable")]
+pub trait TypeMatcherBase:
+    TypeMatcherRegistered + Allocative + Debug + Clone + Sized + Send + Sync + 'static
+{
+}
+
+#[cfg(feature = "pagable")]
+impl<T> TypeMatcherBase for T where
+    T: TypeMatcherRegistered + Allocative + Debug + Clone + Sized + Send + Sync + 'static
+{
+}
+
+/// Base trait for type matchers
+#[cfg(not(feature = "pagable"))]
+pub trait TypeMatcherBase: Allocative + Debug + Clone + Sized + Send + Sync + 'static {}
+
+#[cfg(not(feature = "pagable"))]
+impl<T> TypeMatcherBase for T where T: Allocative + Debug + Clone + Sized + Send + Sync + 'static {}
+
 /// Runtime type matcher. E.g. when `isinstance(1, int)` is called,
 /// implementation of `TypeMatcher` for `int` is used.
-pub trait TypeMatcher: Allocative + Debug + Clone + Sized + Send + Sync + 'static {
+pub trait TypeMatcher: TypeMatcherBase {
     /// Check if the value matches the type.
     fn matches(&self, value: Value) -> bool;
     /// True if this matcher matches any value.
@@ -71,6 +108,7 @@ impl Clone for TypeMatcherBox {
     }
 }
 
+#[type_matcher]
 impl TypeMatcher for TypeMatcherBox {
     fn matches(&self, value: Value) -> bool {
         self.0.matches_dyn(value)