diagnostic add DuplicateDocField, DuplicateSetField, DuplicateIndex

Author: xuhuanzy

crates/emmylua_code_analysis/locales/lint.yml

@@ -233,4 +233,12 @@ Cannot use `...` outside a vararg function.:
   en: "Duplicate class constructor '%{name}'. constructor must have only one."
   zh_CN: "类有重复的 (constructor) 定义 '%{name}'。(constructor) 必须只有一个。"
   zh_HK: "類有重複的 (constructor) 定義 '%{name}'。(constructor) 必須只有一個。"
+"Duplicate field `%{name}`.":
+  en: "Duplicate field `%{name}`."
+  zh_CN: "重复定义的字段 `%{name}`."
+  zh_HK: "重複定義的字段 `%{name}`."
+"Duplicate index `%{name}`.":
+  en: "Duplicate index `%{name}`."
+  zh_CN: "重复定义的索引 `%{name}`."
+  zh_HK: "重複定義的索引 `%{name}`."
 

crates/emmylua_code_analysis/resources/schema.json

@@ -474,6 +474,20 @@
           "enum": [
             "unnecessary-if"
           ]
+        },
+        {
+          "description": "duplicate-set-field",
+          "type": "string",
+          "enum": [
+            "duplicate-set-field"
+          ]
+        },
+        {
+          "description": "duplicate-index",
+          "type": "string",
+          "enum": [
+            "duplicate-index"
+          ]
         }
       ]
     },

crates/emmylua_code_analysis/src/diagnostic/checker/duplicate_field.rs

@@ -0,0 +1,136 @@
+use std::collections::HashMap;
+
+use emmylua_parser::{LuaAstNode, LuaDocTag, LuaDocTagClass};
+
+use crate::{DiagnosticCode, LuaMember, LuaMemberFeature, LuaMemberKey, LuaType, SemanticModel};
+
+use super::{Checker, DiagnosticContext};
+
+pub struct DuplicateFieldChecker;
+
+impl Checker for DuplicateFieldChecker {
+    const CODES: &[DiagnosticCode] = &[
+        DiagnosticCode::DuplicateDocField,
+        DiagnosticCode::DuplicateSetField,
+    ];
+
+    fn check(context: &mut DiagnosticContext, semantic_model: &SemanticModel) {
+        let root = semantic_model.get_root().clone();
+
+        for tag in root.descendants::<LuaDocTag>() {
+            match tag {
+                LuaDocTag::Class(class_tag) => {
+                    check_class_duplicate_field(context, semantic_model, class_tag);
+                }
+                _ => {}
+            }
+        }
+    }
+}
+
+struct DiagnosticMemberInfo<'a> {
+    typ: LuaType,
+    feature: LuaMemberFeature,
+    member: &'a LuaMember,
+}
+
+fn check_class_duplicate_field(
+    context: &mut DiagnosticContext,
+    semantic_model: &SemanticModel,
+    class_tag: LuaDocTagClass,
+) -> Option<()> {
+    let file_id = context.file_id;
+    let name_token = class_tag.get_name_token()?;
+    let name = name_token.get_name_text();
+    let type_decl = context
+        .get_db()
+        .get_type_index()
+        .find_type_decl(file_id, name)?;
+
+    let members = semantic_model
+        .get_db()
+        .get_member_index()
+        .get_members(&type_decl.get_id().into())?;
+
+    let mut member_map: HashMap<&LuaMemberKey, Vec<&LuaMember>> = HashMap::new();
+
+    for member in members.iter() {
+        // 过滤掉 meta 定义的 signature
+        match member.get_feature() {
+            LuaMemberFeature::MetaMethodDecl => {
+                continue;
+            }
+            _ => {}
+        }
+
+        member_map
+            .entry(member.get_key())
+            .or_insert_with(Vec::new)
+            .push(*member);
+    }
+
+    for (key, members) in member_map.iter() {
+        if members.len() < 2 {
+            continue;
+        }
+
+        let mut member_infos = Vec::new();
+        for member in members.iter() {
+            let typ = semantic_model.get_type(member.get_id().into());
+            let feature = member.get_feature();
+            member_infos.push(DiagnosticMemberInfo {
+                typ,
+                feature,
+                member,
+            });
+        }
+
+        // 1. 检查 signature
+        let signatures = member_infos
+            .iter()
+            .filter(|info| matches!(info.typ, LuaType::Signature(_)));
+        if signatures.clone().count() > 1 {
+            for signature in signatures {
+                if signature.member.get_file_id() != file_id {
+                    continue;
+                }
+                context.add_diagnostic(
+                    DiagnosticCode::DuplicateSetField,
+                    signature.member.get_range(),
+                    t!("Duplicate field `%{name}`.", name = key.to_path()).to_string(),
+                    None,
+                );
+            }
+        }
+
+        // 2. 检查 ---@field 成员
+        let field_decls = member_infos
+            .iter()
+            .filter(|info| info.feature.is_field_decl())
+            .collect::<Vec<_>>();
+        // 如果 field_decls 数量大于1，则进一步检查
+        if field_decls.len() > 1 {
+            // 检查是否所有 field_decls 都是 DocFunction
+            let all_doc_functions = field_decls
+                .iter()
+                .all(|info| matches!(info.typ, LuaType::DocFunction(_)));
+
+            // 如果不全是 DocFunction，则报错
+            if !all_doc_functions {
+                for field_decl in &field_decls {
+                    if field_decl.member.get_file_id() == file_id {
+                        context.add_diagnostic(
+                            DiagnosticCode::DuplicateDocField,
+                            // TODO: 范围缩小到名称而不是整个 ---@field
+                            field_decl.member.get_range(),
+                            t!("Duplicate field `%{name}`.", name = key.to_path()).to_string(),
+                            None,
+                        );
+                    }
+                }
+            }
+        }
+    }
+
+    Some(())
+}

crates/emmylua_code_analysis/src/diagnostic/checker/duplicate_index.rs

@@ -0,0 +1,59 @@
+use std::collections::HashMap;
+
+use emmylua_parser::{LuaAstNode, LuaIndexKey, LuaTableExpr};
+
+use crate::{DiagnosticCode, SemanticModel};
+
+use super::{Checker, DiagnosticContext};
+
+pub struct DuplicateIndexChecker;
+
+impl Checker for DuplicateIndexChecker {
+    const CODES: &[DiagnosticCode] = &[DiagnosticCode::DuplicateIndex];
+
+    fn check(context: &mut DiagnosticContext, semantic_model: &SemanticModel) {
+        let root = semantic_model.get_root().clone();
+        for table in root.descendants::<LuaTableExpr>() {
+            check_table_duplicate_index(context, semantic_model, table);
+        }
+    }
+}
+
+fn check_table_duplicate_index(
+    context: &mut DiagnosticContext,
+    _: &SemanticModel,
+    table: LuaTableExpr,
+) -> Option<()> {
+    let fields = table.get_fields();
+    let mut index_map: HashMap<String, Vec<LuaIndexKey>> = HashMap::new();
+
+    for field in fields {
+        let key = field.get_field_key();
+        if let Some(key) = key {
+            index_map
+                .entry(key.get_path_part().to_string())
+                .or_insert_with(Vec::new)
+                .push(key);
+        }
+    }
+
+    for (name, keys) in index_map {
+        if keys.len() > 1 {
+            for key in keys {
+                let range = if let Some(range) = key.get_range() {
+                    range
+                } else {
+                    continue;
+                };
+                context.add_diagnostic(
+                    DiagnosticCode::DuplicateIndex,
+                    range,
+                    t!("Duplicate index `%{name}`.", name = name).to_string(),
+                    None,
+                );
+            }
+        }
+    }
+
+    Some(())
+}

crates/emmylua_code_analysis/src/diagnostic/checker/mod.rs

@@ -10,6 +10,8 @@ mod code_style;
 mod code_style_check;
 mod deprecated;
 mod discard_returns;
+mod duplicate_field;
+mod duplicate_index;
 mod duplicate_require;
 mod duplicate_type;
 mod incomplete_signature_doc;
@@ -87,6 +89,8 @@ pub fn check_file(context: &mut DiagnosticContext, semantic_model: &SemanticMode
     run_check::<check_return_count::CheckReturnCount>(context, semantic_model);
     run_check::<unbalanced_assignments::UnbalancedAssignmentsChecker>(context, semantic_model);
     run_check::<check_param_count::CheckParamCountChecker>(context, semantic_model);
+    run_check::<duplicate_field::DuplicateFieldChecker>(context, semantic_model);
+    run_check::<duplicate_index::DuplicateIndexChecker>(context, semantic_model);
 
     run_check::<code_style::non_literal_expressions_in_assert::NonLiteralExpressionsInAssertChecker>(
         context,

crates/emmylua_code_analysis/src/diagnostic/lua_diagnostic_code.rs

@@ -92,6 +92,10 @@ pub enum DiagnosticCode {
     UnnecessaryAssert,
     /// unnecessary-if
     UnnecessaryIf,
+    /// duplicate-set-field
+    DuplicateSetField,
+    /// duplicate-index
+    DuplicateIndex,
 
     #[serde(skip)]
     All,

crates/emmylua_code_analysis/src/diagnostic/test/duplicate_doc_field_test.rs

@@ -0,0 +1,97 @@
+#[cfg(test)]
+mod test {
+    use crate::{DiagnosticCode, VirtualWorkspace};
+
+    #[test]
+    fn test_duplicate_field() {
+        let mut ws = VirtualWorkspace::new();
+
+        assert!(!ws.check_code_for_namespace(
+            DiagnosticCode::DuplicateDocField,
+            r#"
+            ---@class Test
+            ---@field name string
+            ---@field name string
+            local Test = {}
+
+            Test.name = 1
+            "#
+        ));
+
+        assert!(ws.check_code_for_namespace(
+            DiagnosticCode::DuplicateDocField,
+            r#"
+            ---@class Test
+            ---@field name string
+            ---@field age number
+            local Test = {}
+            "#
+        ));
+
+        assert!(!ws.check_code_for_namespace(
+            DiagnosticCode::DuplicateDocField,
+            r#"
+            ---@class Test
+            ---@field name string
+            ---@field name number
+            local Test = {}
+            "#
+        ));
+
+        assert!(ws.check_code_for_namespace(
+            DiagnosticCode::DuplicateDocField,
+            r#"
+            ---@class Test1
+            ---@field name string
+
+            ---@class Test2
+            ---@field name string
+            "#
+        ));
+    }
+
+    #[test]
+    fn test_duplicate_function_1() {
+        let mut ws = VirtualWorkspace::new();
+
+        assert!(ws.check_code_for_namespace(
+            DiagnosticCode::DuplicateDocField,
+            r#"
+            ---@class Test
+            ---@field a fun()
+            local Test = {}
+
+            function Test.a()
+            end
+            "#
+        ));
+
+        assert!(ws.check_code_for_namespace(
+            DiagnosticCode::DuplicateDocField,
+            r#"
+            ---@class Test
+            ---@field a fun()
+            ---@field a fun()
+            local Test = {}
+
+            function Test.a()
+            end
+            "#
+        ));
+
+        assert!(!ws.check_code_for_namespace(
+            DiagnosticCode::DuplicateSetField,
+            r#"
+            ---@class Test
+            ---@field a fun()
+            local Test = {}
+
+            function Test.a()
+            end
+            
+            function Test.a()
+            end
+            "#
+        ));
+    }
+}