Consider name only for standard and keyword-only parameters

Author: dhruvmanila

crates/red_knot_python_semantic/resources/mdtest/type_properties/is_equivalent_to.md

@@ -130,10 +130,29 @@ other callable should also have a default value.
 from knot_extensions import CallableTypeFromFunction, is_equivalent_to, static_assert
 from typing import Callable
 
-def c1(a: int, /, b: float, c: bool = False, *args: int, d: int = 1, e: str, **kwargs: float) -> None: ...
-def c2(a: int, /, b: float, c: bool = True, *args: int, d: int = 2, e: str, **kwargs: float) -> None: ...
+def f1(a: int = 1) -> None: ...
+def f2(a: int = 2) -> None: ...
 
-static_assert(is_equivalent_to(CallableTypeFromFunction[c1], CallableTypeFromFunction[c2]))
+static_assert(is_equivalent_to(CallableTypeFromFunction[f1], CallableTypeFromFunction[f2]))
+```
+
+The names of the positional-only, variadic and keyword-variadic parameters does not need to be the
+same.
+
+```py
+def f3(a1: int, /, *args1: int, **kwargs2: int) -> None: ...
+def f4(a2: int, /, *args2: int, **kwargs1: int) -> None: ...
+
+static_assert(is_equivalent_to(CallableTypeFromFunction[f3], CallableTypeFromFunction[f4]))
+```
+
+Putting it all together, the following two callables are equivalent:
+
+```py
+def f5(a1: int, /, b: float, c: bool = False, *args1: int, d: int = 1, e: str, **kwargs1: float) -> None: ...
+def f6(a2: int, /, b: float, c: bool = True, *args2: int, d: int = 2, e: str, **kwargs2: float) -> None: ...
+
+static_assert(is_equivalent_to(CallableTypeFromFunction[f5], CallableTypeFromFunction[f6]))
 ```
 
 ### Not equivalent

crates/red_knot_python_semantic/src/types.rs

@@ -4576,34 +4576,47 @@ impl<'db> GeneralCallableType<'db> {
         }
 
         for (self_parameter, other_parameter) in self_parameters.iter().zip(other_parameters) {
-            if self_parameter.name() != other_parameter.name() {
-                return false;
-            }
+            match (self_parameter.kind(), other_parameter.kind()) {
+                (
+                    ParameterKind::PositionalOnly {
+                        default_ty: self_default,
+                        ..
+                    },
+                    ParameterKind::PositionalOnly {
+                        default_ty: other_default,
+                        ..
+                    },
+                ) if self_default.is_some() == other_default.is_some() => {}
 
-            if self_parameter.default_type().is_some() != other_parameter.default_type().is_some() {
-                return false;
-            }
+                (
+                    ParameterKind::PositionalOrKeyword {
+                        name: self_name,
+                        default_ty: self_default,
+                    },
+                    ParameterKind::PositionalOrKeyword {
+                        name: other_name,
+                        default_ty: other_default,
+                    },
+                ) if self_default.is_some() == other_default.is_some()
+                    && self_name == other_name => {}
+
+                (ParameterKind::Variadic { .. }, ParameterKind::Variadic { .. }) => {}
 
-            if !matches!(
-                (self_parameter.kind(), other_parameter.kind()),
                 (
-                    ParameterKind::PositionalOnly { .. },
-                    ParameterKind::PositionalOnly { .. }
-                ) | (
-                    ParameterKind::PositionalOrKeyword { .. },
-                    ParameterKind::PositionalOrKeyword { .. }
-                ) | (
-                    ParameterKind::Variadic { .. },
-                    ParameterKind::Variadic { .. }
-                ) | (
-                    ParameterKind::KeywordOnly { .. },
-                    ParameterKind::KeywordOnly { .. }
-                ) | (
-                    ParameterKind::KeywordVariadic { .. },
-                    ParameterKind::KeywordVariadic { .. }
-                )
-            ) {
-                return false;
+                    ParameterKind::KeywordOnly {
+                        name: self_name,
+                        default_ty: self_default,
+                    },
+                    ParameterKind::KeywordOnly {
+                        name: other_name,
+                        default_ty: other_default,
+                    },
+                ) if self_default.is_some() == other_default.is_some()
+                    && self_name == other_name => {}
+
+                (ParameterKind::KeywordVariadic { .. }, ParameterKind::KeywordVariadic { .. }) => {}
+
+                _ => return false,
             }
 
             if !is_equivalent(