Implement trait impl method label integrity check

Author: Y-Nak

crates/hir-analysis/src/ty/def_analysis.rs

@@ -1066,14 +1066,16 @@ impl<'db> ImplTraitMethodAnalyzer<'db> {
         let mut subst = self.implementor.subst_table(self.db);
 
         let mut is_err = false;
+        let hir_impl_method = impl_method.hir_func(self.db);
+        let hir_expected_method = expected_method.0.hir_func(self.db);
 
         // Checks if the number of parameters are the same.
         let method_params = impl_method.params(self.db);
         let expected_params = expected_method.0.params(self.db);
         if method_params.len() != expected_params.len() {
             self.diags.push(
                 ImplDiag::method_param_num_mismatch(
-                    impl_method.hir_func(self.db).lazy_span().name().into(),
+                    hir_impl_method.lazy_span().name().into(),
                     expected_params.len(),
                     method_params.len(),
                 )
@@ -1094,8 +1096,7 @@ impl<'db> ImplTraitMethodAnalyzer<'db> {
             let given_kind = method_param.kind(self.db);
 
             if expected_kind != given_kind {
-                let span = impl_method
-                    .hir_func(self.db)
+                let span = hir_impl_method
                     .lazy_span()
                     .generic_params()
                     .param(idx)
@@ -1120,11 +1121,7 @@ impl<'db> ImplTraitMethodAnalyzer<'db> {
         if expected_arg_tys.len() != method_arg_tys.len() {
             self.diags.push(
                 ImplDiag::method_arg_num_mismatch(
-                    impl_method
-                        .hir_func(self.db)
-                        .lazy_span()
-                        .params_moved()
-                        .into(),
+                    hir_impl_method.lazy_span().params_moved().into(),
                     expected_arg_tys.len(),
                     method_arg_tys.len(),
                 )
@@ -1137,6 +1134,48 @@ impl<'db> ImplTraitMethodAnalyzer<'db> {
             return;
         }
 
+        // Checks if the argument labels are the same.
+        for (idx, (expected_param, method_param)) in expected_method
+            .0
+            .hir_params(self.db)
+            .iter()
+            .zip(impl_method.hir_params(self.db))
+            .enumerate()
+        {
+            let Some(expected_label) = expected_param
+                .label
+                .or_else(|| expected_param.name.to_opt())
+            else {
+                continue;
+            };
+
+            let Some(method_label) = method_param.label.or_else(|| method_param.name.to_opt())
+            else {
+                continue;
+            };
+
+            if expected_label != method_label {
+                let primary = hir_impl_method.lazy_span().params_moved().param(idx).into();
+                let sub = hir_expected_method
+                    .lazy_span()
+                    .params_moved()
+                    .param(idx)
+                    .into();
+
+                self.diags.push(
+                    ImplDiag::method_arg_label_mismatch(
+                        self.db,
+                        primary,
+                        sub,
+                        expected_label,
+                        method_label,
+                    )
+                    .into(),
+                );
+                is_err = true;
+            }
+        }
+
         // Checks if the argument types are the same.
         for (idx, (expected_arg_ty, &method_arg_ty)) in
             expected_arg_tys.iter().zip(method_arg_tys).enumerate()

crates/hir-analysis/src/ty/diagnostics.rs

@@ -5,7 +5,7 @@ use common::diagnostics::{
 };
 use hir::{
     diagnostics::DiagnosticVoucher,
-    hir_def::{IdentId, ImplTrait, Trait, TypeAlias as HirTypeAlias},
+    hir_def::{FuncParamName, IdentId, ImplTrait, Trait, TypeAlias as HirTypeAlias},
     span::{DynLazySpan, LazySpan},
     HirDb, SpannedHirDb,
 };
@@ -692,6 +692,12 @@ pub enum ImplDiag {
         given: usize,
     },
 
+    MethodArgLabelMismatch {
+        primary: DynLazySpan,
+        definition: DynLazySpan,
+        message: String,
+    },
+
     MethodArgTyMismatch {
         primary: DynLazySpan,
         message: String,
@@ -782,6 +788,26 @@ impl ImplDiag {
         Self::MethodArgTyMismatch { primary, message }
     }
 
+    pub fn method_arg_label_mismatch(
+        db: &dyn HirAnalysisDb,
+        primary: DynLazySpan,
+        definition: DynLazySpan,
+        expected: FuncParamName,
+        given: FuncParamName,
+    ) -> Self {
+        let message = format!(
+            "expected `{}` label, but the given label is `{}`",
+            expected.pretty_print(db.as_hir_db()),
+            given.pretty_print(db.as_hir_db())
+        );
+
+        Self::MethodArgLabelMismatch {
+            primary,
+            definition,
+            message,
+        }
+    }
+
     pub fn method_ret_type_mismatch(
         db: &dyn HirAnalysisDb,
         primary: DynLazySpan,
@@ -855,10 +881,11 @@ impl ImplDiag {
             Self::MethodTypeParamNumMismatch { .. } => 3,
             Self::MethodTypeParamKindMismatch { .. } => 4,
             Self::MethodArgNumMismatch { .. } => 5,
-            Self::MethodArgTyMismatch { .. } => 6,
-            Self::MethodRetTyMismatch { .. } => 7,
-            Self::MethodStricterBound { .. } => 8,
-            Self::InvalidSelfType { .. } => 9,
+            Self::MethodArgLabelMismatch { .. } => 6,
+            Self::MethodArgTyMismatch { .. } => 7,
+            Self::MethodRetTyMismatch { .. } => 8,
+            Self::MethodStricterBound { .. } => 9,
+            Self::InvalidSelfType { .. } => 10,
         }
     }
 
@@ -891,6 +918,11 @@ impl ImplDiag {
                 "trait method argument number mismatch".to_string()
             }
 
+            Self::MethodArgLabelMismatch { .. } => {
+                "given argument label doesn't match the expected label required by trait"
+                    .to_string()
+            }
+
             Self::MethodArgTyMismatch { .. } => {
                 "given argument type doesn't match the expected type required by trait".to_string()
             }
@@ -1002,6 +1034,21 @@ impl ImplDiag {
                 )]
             }
 
+            Self::MethodArgLabelMismatch {
+                primary,
+                definition,
+                message,
+            } => {
+                vec![
+                    SubDiagnostic::new(LabelStyle::Primary, message.clone(), primary.resolve(db)),
+                    SubDiagnostic::new(
+                        LabelStyle::Secondary,
+                        "argument label is defined here".to_string(),
+                        definition.resolve(db),
+                    ),
+                ]
+            }
+
             Self::MethodArgTyMismatch { primary, message } => {
                 vec![SubDiagnostic::new(
                     LabelStyle::Primary,

crates/hir-analysis/src/ty/ty_def.rs

@@ -7,8 +7,8 @@ use hir::{
         kw,
         prim_ty::{IntTy as HirIntTy, PrimTy as HirPrimTy, UintTy as HirUintTy},
         scope_graph::ScopeId,
-        Contract, Enum, Func, IdentId, IngotId, ItemKind, Partial, Struct,
-        TypeAlias as HirTypeAlias, TypeId as HirTyId, VariantKind,
+        Contract, Enum, Func, FuncParam as HirFuncParam, IdentId, IngotId, ItemKind, Partial,
+        Struct, TypeAlias as HirTypeAlias, TypeId as HirTyId, VariantKind,
     },
     span::DynLazySpan,
 };
@@ -414,6 +414,15 @@ impl FuncDef {
     pub(super) fn constraints(self, db: &dyn HirAnalysisDb) -> ConstraintListId {
         collect_func_def_constraints(db, self)
     }
+
+    pub(super) fn hir_params(self, db: &dyn HirAnalysisDb) -> &[HirFuncParam] {
+        const EMPTY: &[HirFuncParam] = &[];
+        self.hir_func(db)
+            .params(db.as_hir_db())
+            .to_opt()
+            .map(|list| list.data(db.as_hir_db()).as_ref())
+            .unwrap_or(EMPTY)
+    }
 }
 
 /// This struct represents a field of an ADT. If the ADT is an enum, this

crates/hir/src/hir_def/params.rs

@@ -133,6 +133,13 @@ impl FuncParamName {
     pub fn is_self(&self) -> bool {
         self.ident() == Some(kw::SELF)
     }
+
+    pub fn pretty_print(&self, db: &dyn HirDb) -> String {
+        match self {
+            FuncParamName::Ident(name) => name.data(db).to_string(),
+            FuncParamName::Underscore => "_".to_string(),
+        }
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]

crates/uitest/fixtures/ty/def/invalid_self_ty.snap

@@ -3,25 +3,25 @@ source: crates/uitest/tests/ty.rs
 expression: diags
 input_file: crates/uitest/fixtures/ty/def/invalid_self_ty.fe
 ---
-error[6-0009]: invalid type for `self` argument
+error[6-0010]: invalid type for `self` argument
   ┌─ invalid_self_ty.fe:2:18
   │
 2 │     fn foo(self: i32)
   │                  ^^^ type of `self` must starts with `Self`, but the given type is `i32`
 
-error[6-0009]: invalid type for `self` argument
+error[6-0010]: invalid type for `self` argument
   ┌─ invalid_self_ty.fe:6:18
   │
 6 │     fn foo(self: i32) {}
   │                  ^^^ type of `self` must starts with `Self` or `Option<T>`, but the given type is `i32`
 
-error[6-0009]: invalid type for `self` argument
+error[6-0010]: invalid type for `self` argument
    ┌─ invalid_self_ty.fe:16:22
    │
 16 │     fn method1(self: i32) {}
    │                      ^^^ type of `self` must starts with `Self` or `Option`, but the given type is `i32`
 
-error[6-0009]: invalid type for `self` argument
+error[6-0010]: invalid type for `self` argument
    ┌─ invalid_self_ty.fe:20:22
    │
 20 │     fn method2(self: i32) {}

crates/uitest/fixtures/ty/trait_impl/impl_method_arg_mismatch.snap

@@ -9,13 +9,13 @@ error[6-0005]: trait method argument number mismatch
 10 │     fn foo<T, U>(self, t: (T, U)) {}
    │                 ^^^^^^^^^^^^^^^^^ expected 3 arguments here, but 2 given
 
-error[6-0006]: given argument type doesn't match the expected type required by trait
+error[6-0007]: given argument type doesn't match the expected type required by trait
   ┌─ impl_method_arg_mismatch.fe:6:30
   │
 6 │     fn foo<T, U>(self, t: T, u: i32) {}
   │                              ^^^^^^ expected `U` type, but the given type is `i32`
 
-error[6-0006]: given argument type doesn't match the expected type required by trait
+error[6-0007]: given argument type doesn't match the expected type required by trait
    ┌─ impl_method_arg_mismatch.fe:26:15
    │
 26 │     fn foo<T>(x: Self<T>) {}

crates/uitest/fixtures/ty/trait_impl/impl_method_label_mismatch.fe

@@ -0,0 +1,7 @@
+pub trait Foo {
+    fn foo(self, x y: i32, _: u32, z: u32) 
+}
+
+impl Foo for i32 {
+    fn foo(self, y: i32, x: u32, _: u32) {}
+}

crates/uitest/fixtures/ty/trait_impl/impl_method_label_mismatch.snap

@@ -0,0 +1,33 @@
+---
+source: crates/uitest/tests/ty.rs
+expression: diags
+input_file: crates/uitest/fixtures/ty/trait_impl/impl_method_label_mismatch.fe
+---
+error[6-0006]: given argument label doesn't match the expected label required by trait
+  ┌─ impl_method_label_mismatch.fe:6:18
+  │
+2 │     fn foo(self, x y: i32, _: u32, z: u32) 
+  │                  -------- argument label is defined here
+  ·
+6 │     fn foo(self, y: i32, x: u32, _: u32) {}
+  │                  ^^^^^^ expected `x` label, but the given label is `y`
+
+error[6-0006]: given argument label doesn't match the expected label required by trait
+  ┌─ impl_method_label_mismatch.fe:6:26
+  │
+2 │     fn foo(self, x y: i32, _: u32, z: u32) 
+  │                            ------ argument label is defined here
+  ·
+6 │     fn foo(self, y: i32, x: u32, _: u32) {}
+  │                          ^^^^^^ expected `_` label, but the given label is `x`
+
+error[6-0006]: given argument label doesn't match the expected label required by trait
+  ┌─ impl_method_label_mismatch.fe:6:34
+  │
+2 │     fn foo(self, x y: i32, _: u32, z: u32) 
+  │                                    ------ argument label is defined here
+  ·
+6 │     fn foo(self, y: i32, x: u32, _: u32) {}
+  │                                  ^^^^^^ expected `z` label, but the given label is `_`
+
+

crates/uitest/fixtures/ty/trait_impl/impl_method_stricter_bound.snap

@@ -3,13 +3,13 @@ source: crates/uitest/tests/ty.rs
 expression: diags
 input_file: crates/uitest/fixtures/ty/trait_impl/impl_method_stricter_bound.fe
 ---
-error[6-0008]: impl method has stricter bound than the declared method in the trait
+error[6-0009]: impl method has stricter bound than the declared method in the trait
   ┌─ impl_method_stricter_bound.fe:9:8
   │
 9 │     fn foo<T: Bar + Baz, U: Bar>(self, t: T, u: U) {}
   │        ^^^ method has stricter bounds than the declared method in the trait: `T: Bar`, `T: Baz`, `U: Bar`
 
-error[6-0008]: impl method has stricter bound than the declared method in the trait
+error[6-0009]: impl method has stricter bound than the declared method in the trait
    ┌─ impl_method_stricter_bound.fe:18:8
    │
 18 │     fn foo<U>(self, t: T, u: U)