[ty] Emit an error if a TypeVarTuple is used to subscript Generic or Protocol without being unpacked

Author: AlexWaygood

crates/ty_python_semantic/resources/mdtest/annotations/unsupported_special_types.md

@@ -45,3 +45,10 @@ class Baz[*Ts]: ...
 # TODO: false positive
 z: Baz[int, str, bytes]  # error: [not-subscriptable]
 ```
+
+And we also provide some basic validation in some cases:
+
+```py
+# error: [invalid-generic-class] "`TypeVarTuple` must be unpacked with `*` or `Unpack[]` when used as an argument to `Generic`"
+class Spam(Generic[Ts]): ...
+```

crates/ty_python_semantic/src/types/infer/builder.rs

@@ -15208,14 +15208,17 @@ impl<'db, 'ast> TypeInferenceBuilder<'db, 'ast> {
             NotYetSupported,
             /// A duplicate typevar was provided.
             DuplicateTypevar(&'db str),
+            /// A `TypeVarTuple` was provided but not unpacked.
+            TypeVarTupleMustBeUnpacked,
         }
 
         impl<'db> LegacyGenericContextError<'db> {
             const fn into_type(self) -> Type<'db> {
                 match self {
                     LegacyGenericContextError::InvalidArgument(_)
                     | LegacyGenericContextError::VariadicTupleArguments
-                    | LegacyGenericContextError::DuplicateTypevar(_) => Type::unknown(),
+                    | LegacyGenericContextError::DuplicateTypevar(_)
+                    | LegacyGenericContextError::TypeVarTupleMustBeUnpacked => Type::unknown(),
                     LegacyGenericContextError::NotYetSupported => {
                         todo_type!("ParamSpecs and TypeVarTuples")
                     }
@@ -15257,6 +15260,10 @@ impl<'db, 'ast> TypeInferenceBuilder<'db, 'ast> {
                                 typevar.name(db),
                             ));
                         }
+                    } else if let Type::NominalInstance(instance) = argument_ty
+                        && instance.has_known_class(db, KnownClass::TypeVarTuple)
+                    {
+                        return Err(LegacyGenericContextError::TypeVarTupleMustBeUnpacked);
                     } else if any_over_type(
                         db,
                         argument_ty,
@@ -15309,7 +15316,18 @@ impl<'db, 'ast> TypeInferenceBuilder<'db, 'ast> {
                             },
                         ))
                     }
-                    Err(error) => Ok(error.into_type()),
+                    Err(LegacyGenericContextError::TypeVarTupleMustBeUnpacked) => {
+                        Err(SubscriptError::new(
+                            Type::unknown(),
+                            SubscriptErrorKind::TypeVarTupleNotUnpacked {
+                                origin: LegacyGenericOrigin::Generic,
+                            },
+                        ))
+                    }
+                    Err(
+                        error @ (LegacyGenericContextError::NotYetSupported
+                        | LegacyGenericContextError::VariadicTupleArguments),
+                    ) => Ok(error.into_type()),
                 }
             }
             Type::SpecialForm(SpecialFormType::Protocol) => {
@@ -15335,7 +15353,18 @@ impl<'db, 'ast> TypeInferenceBuilder<'db, 'ast> {
                             },
                         ))
                     }
-                    Err(error) => Ok(error.into_type()),
+                    Err(LegacyGenericContextError::TypeVarTupleMustBeUnpacked) => {
+                        Err(SubscriptError::new(
+                            Type::unknown(),
+                            SubscriptErrorKind::TypeVarTupleNotUnpacked {
+                                origin: LegacyGenericOrigin::Protocol,
+                            },
+                        ))
+                    }
+                    Err(
+                        error @ (LegacyGenericContextError::NotYetSupported
+                        | LegacyGenericContextError::VariadicTupleArguments),
+                    ) => Ok(error.into_type()),
                 }
             }
             Type::SpecialForm(SpecialFormType::Concatenate) => {

crates/ty_python_semantic/src/types/subscript.rs

@@ -147,6 +147,8 @@ pub(crate) enum SubscriptErrorKind<'db> {
         origin: LegacyGenericOrigin,
         typevar_name: &'db str,
     },
+    /// A `TypeVarTuple` was provided to `Generic` or `Protocol` without being unpacked.
+    TypeVarTupleNotUnpacked { origin: LegacyGenericOrigin },
 }
 
 impl<'db> SubscriptError<'db> {
@@ -334,6 +336,14 @@ impl<'db> SubscriptErrorKind<'db> {
                     ));
                 }
             }
+            Self::TypeVarTupleNotUnpacked { origin } => {
+                if let Some(builder) = context.report_lint(&INVALID_GENERIC_CLASS, subscript) {
+                    builder.into_diagnostic(format_args!(
+                        "`TypeVarTuple` must be unpacked with `*` or `Unpack[]` when \
+                        used as an argument to `{origin}`",
+                    ));
+                }
+            }
         }
     }