[ty] Consolidate rebound-typevar reporting into a single function

Merge `report_rebound_typevar` and `report_rebound_typevar_function`
into a single `report_shadowed_type_variable` that takes the entity
kind ("class"/"function"), name, and range as parameters.

https://claude.ai/code/session_01Eojz9eLtLnKtAF6LcxZczF

Author: claude

crates/ty_python_semantic/src/types/diagnostic.rs

@@ -4942,54 +4942,23 @@ pub(crate) fn report_invalid_type_param_order<'db>(
     }
 }
 
-pub(crate) fn report_rebound_typevar<'db>(
+pub(crate) fn report_shadowed_type_variable<'db>(
     context: &InferContext<'db, '_>,
     typevar_name: &ast::name::Name,
-    class: StaticClassLiteral<'db>,
-    class_node: &ast::StmtClassDef,
-    other_typevar: BoundTypeVarInstance<'db>,
-) {
-    let db = context.db();
-    let Some(builder) = context.report_lint(&SHADOWED_TYPE_VARIABLE, class.header_range(db)) else {
-        return;
-    };
-    let mut diagnostic = builder.into_diagnostic(format_args!(
-        "Generic class `{}` uses type variable `{typevar_name}` already bound by an enclosing scope",
-        class_node.name,
-    ));
-    diagnostic.set_primary_message(format_args!(
-        "`{typevar_name}` used in class definition here"
-    ));
-    let Some(other_definition) = other_typevar.binding_context(db).definition() else {
-        return;
-    };
-    let span = match binding_type(db, other_definition) {
-        Type::ClassLiteral(class) => class.header_span(db),
-        Type::FunctionLiteral(function) => function.spans(db).signature,
-        _ => return,
-    };
-    diagnostic.annotate(Annotation::secondary(span).message(format_args!(
-        "Type variable `{typevar_name}` is bound in this enclosing scope",
-    )));
-}
-
-pub(crate) fn report_rebound_typevar_function<'db>(
-    context: &InferContext<'db, '_>,
-    typevar_name: &ast::name::Name,
-    function_node: &ast::StmtFunctionDef,
+    kind: &str,
+    name: &ast::name::Name,
+    range: TextRange,
     other_typevar: BoundTypeVarInstance<'db>,
 ) {
     let db = context.db();
-    let Some(builder) = context.report_lint(&SHADOWED_TYPE_VARIABLE, function_node.name.range())
-    else {
+    let Some(builder) = context.report_lint(&SHADOWED_TYPE_VARIABLE, range) else {
         return;
     };
     let mut diagnostic = builder.into_diagnostic(format_args!(
-        "Generic function `{}` uses type variable `{typevar_name}` already bound by an enclosing scope",
-        function_node.name,
+        "Generic {kind} `{name}` uses type variable `{typevar_name}` already bound by an enclosing scope",
     ));
     diagnostic.set_primary_message(format_args!(
-        "`{typevar_name}` used in function definition here"
+        "`{typevar_name}` used in {kind} definition here"
     ));
     let Some(other_definition) = other_typevar.binding_context(db).definition() else {
         return;

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

@@ -105,8 +105,8 @@ use crate::types::diagnostic::{
     report_match_pattern_against_typed_dict, report_named_tuple_field_with_leading_underscore,
     report_namedtuple_field_without_default_after_field_with_default, report_not_subscriptable,
     report_possibly_missing_attribute, report_possibly_unresolved_reference,
-    report_rebound_typevar, report_rebound_typevar_function,
-    report_unsupported_augmented_assignment, report_unsupported_base,
+    report_shadowed_type_variable, report_unsupported_augmented_assignment,
+    report_unsupported_base,
     report_unsupported_binary_operation, report_unsupported_comparison,
 };
 use crate::types::enums::is_enum_class_by_inheritance;
@@ -1453,11 +1453,12 @@ impl<'db, 'ast> TypeInferenceBuilder<'db, 'ast> {
                                 if let Some(other_typevar) =
                                     enclosing.binds_named_typevar(self.db(), name)
                                 {
-                                    report_rebound_typevar(
+                                    report_shadowed_type_variable(
                                         &self.context,
                                         name,
-                                        class,
-                                        class_node,
+                                        "class",
+                                        &class_node.name.id,
+                                        class.header_range(self.db()),
                                         other_typevar,
                                     );
                                 }
@@ -1472,11 +1473,12 @@ impl<'db, 'ast> TypeInferenceBuilder<'db, 'ast> {
                         for enclosing in enclosing_generic_contexts(self.db(), self.index, parent) {
                             if let Some(other_typevar) = enclosing.binds_typevar(self.db(), typevar)
                             {
-                                report_rebound_typevar(
+                                report_shadowed_type_variable(
                                     &self.context,
                                     typevar.name(self.db()),
-                                    class,
-                                    class_node,
+                                    "class",
+                                    &class_node.name.id,
+                                    class.header_range(self.db()),
                                     other_typevar,
                                 );
                             }
@@ -3295,10 +3297,12 @@ impl<'db, 'ast> TypeInferenceBuilder<'db, 'ast> {
                     if let Some(other_typevar) =
                         enclosing.binds_named_typevar(self.db(), &param_name.id)
                     {
-                        report_rebound_typevar_function(
+                        report_shadowed_type_variable(
                             &self.context,
                             &param_name.id,
-                            function,
+                            "function",
+                            &function.name.id,
+                            function.name.range(),
                             other_typevar,
                         );
                     }