Handle generic type parameters in TypeMatcher registration

Summary:
Handle generic type parameters in TypeMatcher registration

1. The `#[type_matcher]` macro now raises a compile-time error when applied to a type with generic parameters. The error has the instruction to how to handle the issue. So ai agent can follow it to resolve it.
2. For generic types, developers must manually register concrete instantiations by:
   1. From the error message of rust check to discover needed registrations
   2. Adding a blanket `unsafe impl TypeMatcherRegistered`
   3. Adding `register_type_matcher!` for each concrete instantiation

Reviewed By: cjhopman

Differential Revision: D90875026

fbshipit-source-id: 384d06a7f82ec6d12e6a5ed80ce0c18150dc3f8b

Author: Nero5023

starlark/src/pagable/vtable_register.rs

@@ -62,3 +62,26 @@ macro_rules! register_special_avalue_frozen {
 }
 
 pub(crate) use register_special_avalue_frozen;
+
+/// Macro to register a vtable for a generic `TypeMatcher` implementation.
+///
+/// This macro is for generic `TypeMatcher` types (like `IsListOf<TypeMatcherBox>`,
+/// `IsDictOf<TypeMatcherBox, TypeMatcherBox>`) that cannot use the `#[type_matcher]`
+/// attribute macro (which only supports non-generic types).
+///
+/// # Example
+///
+/// ```ignore
+/// register_type_matcher!(IsTupleOf<TypeMatcherBox>);
+/// ```
+#[macro_export]
+macro_rules! register_type_matcher {
+    ($matcher:ty) => {
+        #[cfg(feature = "pagable")]
+        $crate::register_avalue_simple_frozen!(
+            $crate::values::typing::TypeCompiledImplAsStarlarkValue<
+                $matcher,
+            >
+        );
+    };
+}

starlark/src/pagable/vtable_registry.rs

@@ -259,19 +259,19 @@ mod tests {
     }
 
     #[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).
+    fn test_type_compiled_generic_matcher_is_registered() {
+        // IsListOf is a generic TypeMatcher (IsListOf<I>). Specific instantiations
+        // are registered via register_type_matcher! (e.g., IsListOf<TypeMatcherBox>).
         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"
+            vtable.is_ok(),
+            "Expected TypeCompiledImplAsStarlarkValue<IsListOf<TypeMatcherBox>> to be registered. Available types: {:?}",
+            registered_type_ids()
         );
     }
 }

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

@@ -20,6 +20,7 @@ use dupe::Dupe;
 use starlark_derive::type_matcher;
 
 use crate as starlark;
+use crate::register_type_matcher;
 use crate::typing::starlark_value::TyStarlarkValue;
 use crate::values::UnpackValue;
 use crate::values::Value;
@@ -35,6 +36,7 @@ use crate::values::tuple::value::Tuple;
 use crate::values::types::int::int_or_big::StarlarkIntRef;
 use crate::values::typing::type_compiled::matcher::TypeMatcher;
 use crate::values::typing::type_compiled::matcher::TypeMatcherBox;
+use crate::values::typing::type_compiled::matcher::TypeMatcherRegistered;
 
 #[derive(Clone, Copy, Dupe, Allocative, Debug)]
 pub(crate) struct IsAny;
@@ -83,7 +85,11 @@ impl TypeMatcher for IsList {
 #[derive(Clone, Allocative, Debug)]
 pub(crate) struct IsListOf<I: TypeMatcher>(pub(crate) I);
 
-#[type_matcher]
+unsafe impl<I: TypeMatcher> TypeMatcherRegistered for IsListOf<I> {}
+register_type_matcher!(IsListOf<IsStr>);
+register_type_matcher!(IsListOf<StarlarkTypeIdMatcher>);
+register_type_matcher!(IsListOf<TypeMatcherBox>);
+
 impl<I: TypeMatcher> TypeMatcher for IsListOf<I> {
     fn matches(&self, value: Value) -> bool {
         match ListRef::from_value(value) {
@@ -96,7 +102,10 @@ impl<I: TypeMatcher> TypeMatcher for IsListOf<I> {
 #[derive(Clone, Allocative, Debug)]
 pub(crate) struct IsTupleOf<A: TypeMatcher>(pub(crate) A);
 
-#[type_matcher]
+unsafe impl<A: TypeMatcher> TypeMatcherRegistered for IsTupleOf<A> {}
+register_type_matcher!(IsTupleOf<StarlarkTypeIdMatcher>);
+register_type_matcher!(IsTupleOf<TypeMatcherBox>);
+
 impl<A: TypeMatcher> TypeMatcher for IsTupleOf<A> {
     fn matches(&self, value: Value) -> bool {
         match Tuple::from_value(value) {
@@ -137,7 +146,9 @@ impl TypeMatcher for IsTupleElems0 {
 #[derive(Clone, Allocative, Debug)]
 pub(crate) struct IsTupleElems1<A: TypeMatcher>(pub(crate) A);
 
-#[type_matcher]
+unsafe impl<A: TypeMatcher> TypeMatcherRegistered for IsTupleElems1<A> {}
+register_type_matcher!(IsTupleElems1<TypeMatcherBox>);
+
 impl<A: TypeMatcher> TypeMatcher for IsTupleElems1<A> {
     fn matches(&self, value: Value) -> bool {
         match Tuple::from_value(value).map(|t| t.content()) {
@@ -150,7 +161,10 @@ impl<A: TypeMatcher> TypeMatcher for IsTupleElems1<A> {
 #[derive(Clone, Allocative, Debug)]
 pub(crate) struct IsTupleElems2<A: TypeMatcher, B: TypeMatcher>(pub(crate) A, pub(crate) B);
 
-#[type_matcher]
+unsafe impl<A: TypeMatcher, B: TypeMatcher> TypeMatcherRegistered for IsTupleElems2<A, B> {}
+register_type_matcher!(IsTupleElems2<StarlarkTypeIdMatcher, StarlarkTypeIdMatcher>);
+register_type_matcher!(IsTupleElems2<TypeMatcherBox, TypeMatcherBox>);
+
 impl<A: TypeMatcher, B: TypeMatcher> TypeMatcher for IsTupleElems2<A, B> {
     fn matches(&self, value: Value) -> bool {
         match Tuple::from_value(value).map(|t| t.content()) {
@@ -173,7 +187,15 @@ impl TypeMatcher for IsDict {
 #[derive(Clone, Allocative, Debug)]
 pub(crate) struct IsDictOf<K: TypeMatcher, V: TypeMatcher>(pub(crate) K, pub(crate) V);
 
-#[type_matcher]
+unsafe impl<K: TypeMatcher, V: TypeMatcher> TypeMatcherRegistered for IsDictOf<K, V> {}
+register_type_matcher!(IsDictOf<IsStr, TypeMatcherBox>);
+register_type_matcher!(IsDictOf<StarlarkTypeIdMatcher, TypeMatcherBox>);
+register_type_matcher!(IsDictOf<TypeMatcherBox, TypeMatcherBox>);
+register_type_matcher!(IsDictOf<IsAny, TypeMatcherBox>);
+register_type_matcher!(IsDictOf<TypeMatcherBox, IsAny>);
+register_type_matcher!(IsDictOf<IsStr, IsAny>);
+register_type_matcher!(IsDictOf<StarlarkTypeIdMatcher, IsAny>);
+
 impl<K: TypeMatcher, V: TypeMatcher> TypeMatcher for IsDictOf<K, V> {
     fn matches(&self, value: Value) -> bool {
         match DictRef::from_value(value) {
@@ -198,7 +220,11 @@ impl TypeMatcher for IsSet {
 #[derive(Clone, Allocative, Debug)]
 pub(crate) struct IsSetOf<I: TypeMatcher>(pub(crate) I);
 
-#[type_matcher]
+unsafe impl<I: TypeMatcher> TypeMatcherRegistered for IsSetOf<I> {}
+register_type_matcher!(IsSetOf<IsStr>);
+register_type_matcher!(IsSetOf<StarlarkTypeIdMatcher>);
+register_type_matcher!(IsSetOf<TypeMatcherBox>);
+
 impl<I: TypeMatcher> TypeMatcher for IsSetOf<I> {
     fn matches(&self, value: Value) -> bool {
         match SetRef::unpack_value_opt(value) {
@@ -211,7 +237,14 @@ impl<I: TypeMatcher> TypeMatcher for IsSetOf<I> {
 #[derive(Clone, Allocative, Debug)]
 pub(crate) struct IsAnyOfTwo<A: TypeMatcher, B: TypeMatcher>(pub(crate) A, pub(crate) B);
 
-#[type_matcher]
+unsafe impl<A: TypeMatcher, B: TypeMatcher> TypeMatcherRegistered for IsAnyOfTwo<A, B> {}
+register_type_matcher!(IsAnyOfTwo<IsNone, IsStr>);
+register_type_matcher!(IsAnyOfTwo<IsNone, IsInt>);
+register_type_matcher!(IsAnyOfTwo<IsNone, StarlarkTypeIdMatcher>);
+register_type_matcher!(IsAnyOfTwo<IsNone, IsList>);
+register_type_matcher!(IsAnyOfTwo<IsNone, TypeMatcherBox>);
+register_type_matcher!(IsAnyOfTwo<TypeMatcherBox, TypeMatcherBox>);
+
 impl<A: TypeMatcher, B: TypeMatcher> TypeMatcher for IsAnyOfTwo<A, B> {
     fn matches(&self, value: Value) -> bool {
         self.0.matches(value) || self.1.matches(value)

starlark_derive/src/type_matcher.rs

@@ -80,32 +80,44 @@ fn derive_type_matcher_impl(_attr: TokenStream, input: TokenStream) -> syn::Resu
 
     // Get the generics from the impl block
     let generics = &item_impl.generics;
-    let (impl_generics, _, where_clause) = generics.split_for_impl();
 
     // Check if the impl block has generic type parameters (not just lifetimes)
     let has_type_params = generics.type_params().next().is_some();
 
+    // Generic types are not supported - they require special handling for vtable registration
+    if has_type_params {
+        return Err(syn::Error::new(
+            generics.span(),
+            "#[type_matcher] does not support generic type parameters. \
+             For generic TypeMatcher implementations: \
+             1. Remove #[type_matcher] attribute from the impl block, \
+             2. Run build or `arc rust-check` with `pagable` feature to find call sites, \
+             3. Errors show types like `YourType<X>: TypeMatcherRegistered is not satisfied`. \
+                Two cases for X: \
+                a) Concrete type (e.g., `IsStr`, `IsNone`, `StarlarkTypeIdMatcher`) - use directly \
+                b) `impl TypeMatcher` - trace CALLERS to find concrete type, usually `TypeMatcherBox` \
+                   from `TypeMatcherBoxAlloc.ty(...)` \
+             4. Add blanket unsafe impl: `unsafe impl<...> TypeMatcherRegistered for YourType<...> {}`, \
+             5. Add `register_type_matcher!(YourType<ConcreteArg>);` for each concrete instantiation. \
+             Example: IsListOf errors show IsListOf<IsStr> (case a) and IsListOf<impl TypeMatcher> (case b). \
+             Register both: `register_type_matcher!(IsListOf<IsStr>);` \
+                           `register_type_matcher!(IsListOf<TypeMatcherBox>);`",
+        ));
+    }
+
     // Generate TypeMatcherRegistered impl for both generic and non-generic types.
-    // TODO(nero): Only generate this impl for non-generic types.
     let registered_impl = quote! {
         // SAFETY: This impl is generated by the #[type_matcher] macro.
         // For non-generic types, the vtable is also registered below.
-        unsafe impl #impl_generics starlark::values::typing::TypeMatcherRegistered
+        unsafe impl starlark::values::typing::TypeMatcherRegistered
             for #self_ty
-            #where_clause
         {}
     };
 
-    // Generate vtable registration only for non-generic types.
-    let vtable_registration = if has_type_params {
-        // Generic type - skip vtable registration
-        TokenStream::new()
-    } else {
-        quote! {
-            starlark::register_avalue_simple_frozen!(
-                starlark::values::typing::TypeCompiledImplAsStarlarkValue<#self_ty>
-            );
-        }
+    // Generate vtable registration
+    let vtable_registration = quote! {
+
+        starlark::register_type_matcher!(#self_ty);
     };
 
     // Return the original impl block plus the generated code