fix #534

Author: xuhuanzy

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

@@ -5,7 +5,9 @@ use emmylua_parser::{
     LuaIndexKey, LuaRepeatStat, LuaSyntaxKind, LuaVarExpr, LuaWhileStat,
 };
 
-use crate::{DiagnosticCode, InferFailReason, LuaMemberKey, LuaType, SemanticModel};
+use crate::{
+    enum_variable_is_param, DiagnosticCode, InferFailReason, LuaMemberKey, LuaType, SemanticModel,
+};
 
 use super::{humanize_lint_type, Checker, DiagnosticContext};
 
@@ -144,6 +146,18 @@ fn is_valid_member(
     index_key: &LuaIndexKey,
     code: DiagnosticCode,
 ) -> Option<()> {
+    // 如果类型是 Ref 的 enum, 那么需要检查变量是否为参数, 因为作为参数的 enum 本质上是 value 而不是 enum
+    if enum_variable_is_param(
+        semantic_model.get_db(),
+        &mut semantic_model.get_config().borrow_mut(),
+        index_expr,
+        prefix_typ,
+    )
+    .is_some()
+    {
+        return None;
+    }
+
     // 检查 member_info
     let need_add_diagnostic =
         match semantic_model.get_semantic_info(index_expr.syntax().clone().into()) {

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

@@ -612,4 +612,49 @@ mod test {
         "#
         ));
     }
+
+    #[test]
+    fn test_enum_field_1() {
+        let mut ws = VirtualWorkspace::new();
+        ws.def(
+            r#"
+                ---@enum Enum
+                local Enum = {
+                    a = 1,
+                }
+        "#,
+        );
+        assert!(!ws.check_code_for(
+            DiagnosticCode::UndefinedField,
+            r#"
+                ---@param p Enum
+                function func(p)
+                    local x1 = p.a
+                end
+        "#
+        ));
+
+        assert!(!ws.check_code_for(
+            DiagnosticCode::UndefinedField,
+            r#"
+                ---@param p Enum
+                function func(p)
+                    local x1 = p
+                    local x2 = x1.a
+                end
+        "#
+        ));
+
+        assert!(!ws.check_code_for(
+            DiagnosticCode::UndefinedField,
+            r#"
+                ---@param p Enum
+                function func(p)
+                    local x1 = p
+                    local x2 = x1
+                    local x3 = x2.a
+                end
+        "#
+        ));
+    }
 }

crates/emmylua_code_analysis/src/semantic/decl/mod.rs

@@ -0,0 +1,81 @@
+use emmylua_parser::{LuaAstNode, LuaIndexExpr};
+use rowan::NodeOrToken;
+
+use crate::{
+    infer_node_semantic_decl, semantic::semantic_info::infer_token_semantic_decl, DbIndex,
+    LuaDeclId, LuaInferCache, LuaSemanticDeclId, LuaType, SemanticDeclLevel,
+};
+
+pub fn enum_variable_is_param(
+    db: &DbIndex,
+    cache: &mut LuaInferCache,
+    index_expr: &LuaIndexExpr,
+    prefix_typ: &LuaType,
+) -> Option<()> {
+    fn find_enum_origin(
+        db: &DbIndex,
+        cache: &mut LuaInferCache,
+        decl_id: LuaDeclId,
+    ) -> Option<LuaDeclId> {
+        let syntax_tree = db.get_vfs().get_syntax_tree(&decl_id.file_id)?;
+        let root = syntax_tree.get_red_root();
+
+        let node = db
+            .get_decl_index()
+            .get_decl(&decl_id)?
+            .get_value_syntax_id()?
+            .to_node_from_root(&root)?;
+
+        let semantic_decl = match node.into() {
+            NodeOrToken::Node(node) => {
+                infer_node_semantic_decl(db, cache, node, SemanticDeclLevel::NoTrace)
+            }
+            NodeOrToken::Token(token) => {
+                infer_token_semantic_decl(db, cache, token, SemanticDeclLevel::NoTrace)
+            }
+        };
+
+        match semantic_decl {
+            Some(LuaSemanticDeclId::Member(_)) => None,
+            Some(LuaSemanticDeclId::LuaDecl(new_decl_id)) => {
+                let decl = db.get_decl_index().get_decl(&new_decl_id)?;
+                if decl.get_value_syntax_id().is_some() {
+                    Some(find_enum_origin(db, cache, new_decl_id).unwrap_or(new_decl_id))
+                } else {
+                    Some(new_decl_id)
+                }
+            }
+            _ => None,
+        }
+    }
+
+    let LuaType::Ref(id) = prefix_typ else {
+        return None;
+    };
+
+    let type_decl = db.get_type_index().get_type_decl(id)?;
+    if !type_decl.is_enum() {
+        return None;
+    }
+
+    let prefix_expr = index_expr.get_prefix_expr()?;
+    let prefix_decl = infer_node_semantic_decl(
+        db,
+        cache,
+        prefix_expr.syntax().clone(),
+        SemanticDeclLevel::default(),
+    )?;
+
+    let LuaSemanticDeclId::LuaDecl(decl_id) = prefix_decl else {
+        return None;
+    };
+
+    let origin_decl_id = find_enum_origin(db, cache, decl_id).unwrap_or(decl_id);
+    let decl = db.get_decl_index().get_decl(&origin_decl_id)?;
+
+    if decl.is_param() {
+        Some(())
+    } else {
+        None
+    }
+}

crates/emmylua_code_analysis/src/semantic/infer/infer_index.rs

@@ -11,6 +11,7 @@ use crate::{
         DbIndex, LuaGenericType, LuaIntersectionType, LuaMemberKey, LuaObjectType,
         LuaOperatorMetaMethod, LuaTupleType, LuaType, LuaTypeDeclId, LuaUnionType,
     },
+    enum_variable_is_param,
     semantic::{
         generic::{instantiate_type_generic, TypeSubstitutor},
         member::get_buildin_type_map_type_id,
@@ -211,15 +212,32 @@ fn infer_custom_type_member(
         .ok_or(InferFailReason::None)?;
     if type_decl.is_alias() {
         if let Some(origin_type) = type_decl.get_alias_origin(db, None) {
-            return infer_member_by_member_key(db, cache, &origin_type, index_expr, infer_guard);
+            return infer_member_by_member_key(
+                db,
+                cache,
+                &origin_type,
+                index_expr.clone(),
+                infer_guard,
+            );
         } else {
-            return Err(InferFailReason::None);
+            return Err(InferFailReason::FieldNotFound);
         }
     }
+    match &index_expr {
+        LuaIndexMemberExpr::IndexExpr(index_expr) => {
+            if enum_variable_is_param(db, cache, index_expr, &LuaType::Ref(prefix_type_id.clone()))
+                .is_some()
+            {
+                return Err(InferFailReason::None);
+            }
+        }
+        _ => {}
+    }
 
     let owner = LuaMemberOwner::Type(prefix_type_id.clone());
     let index_key = index_expr.get_index_key().ok_or(InferFailReason::None)?;
     let key = LuaMemberKey::from_index_key(db, cache, &index_key)?;
+
     if let Some(member_item) = db.get_member_index().get_member_item(&owner, &key) {
         return member_item.resolve_type(db);
     }

crates/emmylua_code_analysis/src/semantic/mod.rs

@@ -1,4 +1,5 @@
 mod cache;
+mod decl;
 mod generic;
 mod infer;
 mod member;
@@ -33,6 +34,7 @@ use semantic_info::{
 pub(crate) use type_check::check_type_compact;
 use type_check::is_sub_type_of;
 use visibility::check_visibility;
+pub use decl::enum_variable_is_param;
 
 use crate::{db_index::LuaTypeDeclId, Emmyrc, LuaDocument, LuaSemanticDeclId};
 use crate::{

crates/emmylua_ls/src/handlers/completion/providers/member_provider.rs

@@ -1,4 +1,6 @@
-use emmylua_code_analysis::{DbIndex, LuaMemberInfo, LuaSemanticDeclId, LuaType, LuaTypeDeclId};
+use emmylua_code_analysis::{
+    enum_variable_is_param, DbIndex, LuaMemberInfo, LuaSemanticDeclId, LuaType, LuaTypeDeclId,
+};
 use emmylua_parser::{LuaAstNode, LuaAstToken, LuaIndexExpr, LuaStringToken};
 
 use crate::handlers::completion::{
@@ -25,6 +27,16 @@ pub fn add_completion(builder: &mut CompletionBuilder) -> Option<()> {
 
     let prefix_expr = index_expr.get_prefix_expr()?;
     let prefix_type = builder.semantic_model.infer_expr(prefix_expr.into()).ok()?;
+    // 如果是枚举类型且为函数参数, 则不进行补全
+    if enum_variable_is_param(
+        builder.semantic_model.get_db(),
+        &mut builder.semantic_model.get_config().borrow_mut(),
+        &index_expr,
+        &prefix_type,
+    )
+    .is_some() {
+        return None;
+    }
     let member_info_map = builder.semantic_model.get_member_info_map(&prefix_type)?;
     for (_, member_infos) in member_info_map.iter() {
         add_resolve_member_infos(builder, &member_infos, completion_status);

crates/emmylua_ls/src/handlers/test/completion_test.rs

@@ -729,4 +729,27 @@ mod tests {
             CompletionTriggerKind::INVOKED,
         ));
     }
+
+    #[test]
+    fn test_enum_field_1() {
+        let mut ws = ProviderVirtualWorkspace::new();
+        ws.def(
+            r#"
+                ---@enum Enum
+                local Enum = {
+                    a = 1,
+                }
+        "#,
+        );
+        assert!(ws.check_completion_with_kind(
+            r#"
+                ---@param p Enum
+                function func(p)
+                    local x1 = p.<??>
+                end
+            "#,
+            vec![],
+            CompletionTriggerKind::TRIGGER_CHARACTER,
+        ));
+    }
 }