[flake8-commas] Add support for trailing comma checks in type parameter lists (COM812,COM819) (#19390)

## Summary

Fixes #18844

I'm not too sure if the solution is as simple as the way I implemented
it, but I'm curious to see if we are covering all cases correctly here.

---------

Co-authored-by: Brent Westbrook <36778786+ntBre@users.noreply.github.com>
Co-authored-by: Brent Westbrook <brentrwestbrook@gmail.com>

Author: danparizher

crates/ruff_linter/resources/test/fixtures/flake8_commas/COM81.py

@@ -650,3 +650,17 @@ def foo(
     if True else
     "Don't add a trailing comma here ->"
 }"""
+
+type X[
+    T
+] = T
+def f[
+    T
+](): pass
+class C[
+    T
+]: pass
+
+type X[T,] = T
+def f[T,](): pass
+class C[T,]: pass

crates/ruff_linter/src/checkers/tokens.rs

@@ -118,7 +118,7 @@ pub(crate) fn check_tokens(
         Rule::TrailingCommaOnBareTuple,
         Rule::ProhibitedTrailingComma,
     ]) {
-        flake8_commas::rules::trailing_commas(context, tokens, locator, indexer);
+        flake8_commas::rules::trailing_commas(context, tokens, locator, indexer, settings);
     }
 
     if context.is_rule_enabled(Rule::ExtraneousParentheses) {

crates/ruff_linter/src/preview.rs

@@ -225,3 +225,8 @@ pub(crate) const fn is_assert_raises_exception_call_enabled(settings: &LinterSet
 pub(crate) const fn is_add_future_annotations_imports_enabled(settings: &LinterSettings) -> bool {
     settings.preview.is_enabled()
 }
+
+// https://github.com/astral-sh/ruff/pull/19390
+pub(crate) const fn is_trailing_comma_type_params_enabled(settings: &LinterSettings) -> bool {
+    settings.preview.is_enabled()
+}

crates/ruff_linter/src/rules/flake8_commas/mod.rs

@@ -27,4 +27,23 @@ mod tests {
         assert_diagnostics!(snapshot, diagnostics);
         Ok(())
     }
+
+    #[test_case(Path::new("COM81.py"))]
+    #[test_case(Path::new("COM81_syntax_error.py"))]
+    fn preview_rules(path: &Path) -> Result<()> {
+        let snapshot = format!("preview__{}", path.to_string_lossy());
+        let diagnostics = test_path(
+            Path::new("flake8_commas").join(path).as_path(),
+            &settings::LinterSettings {
+                preview: crate::settings::types::PreviewMode::Enabled,
+                ..settings::LinterSettings::for_rules(vec![
+                    Rule::MissingTrailingComma,
+                    Rule::TrailingCommaOnBareTuple,
+                    Rule::ProhibitedTrailingComma,
+                ])
+            },
+        )?;
+        assert_diagnostics!(snapshot, diagnostics);
+        Ok(())
+    }
 }

crates/ruff_linter/src/rules/flake8_commas/rules/trailing_commas.rs

@@ -5,6 +5,8 @@ use ruff_text_size::{Ranged, TextRange};
 
 use crate::Locator;
 use crate::checkers::ast::LintContext;
+use crate::preview::is_trailing_comma_type_params_enabled;
+use crate::settings::LinterSettings;
 use crate::{AlwaysFixableViolation, Violation};
 use crate::{Edit, Fix};
 
@@ -24,6 +26,8 @@ enum TokenType {
     Def,
     For,
     Lambda,
+    Class,
+    Type,
     Irrelevant,
 }
 
@@ -69,6 +73,8 @@ impl From<(TokenKind, TextRange)> for SimpleToken {
             TokenKind::Lbrace => TokenType::OpeningCurlyBracket,
             TokenKind::Rbrace => TokenType::ClosingBracket,
             TokenKind::Def => TokenType::Def,
+            TokenKind::Class => TokenType::Class,
+            TokenKind::Type => TokenType::Type,
             TokenKind::For => TokenType::For,
             TokenKind::Lambda => TokenType::Lambda,
             // Import treated like a function.
@@ -98,6 +104,8 @@ enum ContextType {
     Dict,
     /// Lambda parameter list, e.g. `lambda a, b`.
     LambdaParameters,
+    /// Type parameter list, e.g. `def foo[T, U](): ...`
+    TypeParameters,
 }
 
 /// Comma context - described a comma-delimited "situation".
@@ -243,6 +251,7 @@ pub(crate) fn trailing_commas(
     tokens: &Tokens,
     locator: &Locator,
     indexer: &Indexer,
+    settings: &LinterSettings,
 ) {
     let mut fstrings = 0u32;
     let simple_tokens = tokens.iter().filter_map(|token| {
@@ -290,7 +299,7 @@ pub(crate) fn trailing_commas(
         }
 
         // Update the comma context stack.
-        let context = update_context(token, prev, prev_prev, &mut stack);
+        let context = update_context(token, prev, prev_prev, &mut stack, settings);
 
         check_token(token, prev, prev_prev, context, locator, lint_context);
 
@@ -326,6 +335,7 @@ fn check_token(
             ContextType::No => false,
             ContextType::FunctionParameters => true,
             ContextType::CallArguments => true,
+            ContextType::TypeParameters => true,
             // `(1)` is not equivalent to `(1,)`.
             ContextType::Tuple => context.num_commas != 0,
             // `x[1]` is not equivalent to `x[1,]`.
@@ -408,6 +418,7 @@ fn update_context(
     prev: SimpleToken,
     prev_prev: SimpleToken,
     stack: &mut Vec<Context>,
+    settings: &LinterSettings,
 ) -> Context {
     let new_context = match token.ty {
         TokenType::OpeningBracket => match (prev.ty, prev_prev.ty) {
@@ -417,6 +428,17 @@ fn update_context(
             }
             _ => Context::new(ContextType::Tuple),
         },
+        TokenType::OpeningSquareBracket if is_trailing_comma_type_params_enabled(settings) => {
+            match (prev.ty, prev_prev.ty) {
+                (TokenType::Named, TokenType::Def | TokenType::Class | TokenType::Type) => {
+                    Context::new(ContextType::TypeParameters)
+                }
+                (TokenType::ClosingBracket | TokenType::Named | TokenType::String, _) => {
+                    Context::new(ContextType::Subscript)
+                }
+                _ => Context::new(ContextType::List),
+            }
+        }
         TokenType::OpeningSquareBracket => match prev.ty {
             TokenType::ClosingBracket | TokenType::Named | TokenType::String => {
                 Context::new(ContextType::Subscript)