fix Tuple check_field

Author: xuhuanzy

crates/emmylua_code_analysis/src/compilation/test/tuple_test.rs

@@ -41,6 +41,6 @@ mod tests {
             "#,
         );
         let ty = ws.expr_ty("A");
-        assert_eq!(ws.humanize_type(ty), "36|826");
+        assert_eq!(ws.humanize_type(ty), "(36|826)");
     }
 }

crates/emmylua_code_analysis/src/db_index/type/humanize_type.rs

@@ -242,7 +242,7 @@ where
 
     if display_types.len() == 1 {
         if has_function && has_nil {
-            format!("({})?", type_str)
+            format!("{}?", type_str)
         } else {
             format!("{}{}", type_str, if has_nil { "?" } else { "" })
         }

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

@@ -131,55 +131,54 @@ fn is_valid_prefix_type(typ: &LuaType) -> bool {
     }
 }
 
-#[allow(dead_code)]
-fn is_valid_index_key(index_key: &LuaIndexKey) -> bool {
-    match index_key {
-        LuaIndexKey::String(_) | LuaIndexKey::Name(_) | LuaIndexKey::Integer(_) => true,
-        _ => false,
-    }
-}
-
 fn is_valid_member(
     semantic_model: &SemanticModel,
     prefix_typ: &LuaType,
     index_expr: &LuaIndexExpr,
     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;
+    match prefix_typ {
+        LuaType::Global | LuaType::Userdata => return Some(()),
+        LuaType::Array(typ) => {
+            if typ.is_unknown() {
+                return Some(());
+            }
+        }
+        LuaType::Ref(_) => {
+            // 如果类型是 Ref 的 enum, 那么需要检查变量是否为参数, 因为作为参数的 enum 本质上是 value 而不是 enum
+            if check_enum_is_param(semantic_model, prefix_typ, index_expr).is_some() {
+                return None;
+            }
+        }
+        _ => {}
     }
 
     // 检查 member_info
     let need_add_diagnostic =
         match semantic_model.get_semantic_info(index_expr.syntax().clone().into()) {
-            Some(info) => info.semantic_decl.is_none() && info.typ.is_unknown(),
+            Some(info) => {
+                let need = info.semantic_decl.is_none() && info.typ.is_unknown();
+                // TODO: 元组类型的检查或许需要独立出来
+                if !need && matches!(code, DiagnosticCode::InjectField) {
+                    if let LuaType::Tuple(tuple) = prefix_typ {
+                        if tuple.is_infer_resolve() {
+                            return Some(());
+                        } else {
+                            // 元组类型禁止修改
+                            return None;
+                        }
+                    }
+                }
+                need
+            }
             None => true,
         };
 
     if !need_add_diagnostic {
         return Some(());
     }
 
-    match prefix_typ {
-        LuaType::Global => return Some(()),
-        LuaType::Userdata => return Some(()),
-        LuaType::Array(typ) => {
-            if typ.is_unknown() {
-                return Some(());
-            }
-        }
-        _ => {}
-    }
-
     let key_type = if let LuaIndexKey::Expr(expr) = index_key {
         match semantic_model.infer_expr(expr.clone()) {
             Ok(
@@ -235,8 +234,8 @@ fn is_valid_member(
             local field
             local a = Class[field]
     */
-    let key_type_set = get_key_types(&key_type);
-    if key_type_set.is_empty() {
+    let key_types = get_key_types(&key_type);
+    if key_types.is_empty() {
         return None;
     }
 
@@ -247,28 +246,28 @@ fn is_valid_member(
                 match &info.key {
                     LuaMemberKey::ExprType(typ) => {
                         if typ.is_string() {
-                            if key_type_set
+                            if key_types
                                 .iter()
                                 .any(|typ| typ.is_string() || typ.is_str_tpl_ref())
                             {
                                 return Some(());
                             }
                         } else if typ.is_integer() {
-                            if key_type_set.iter().any(|typ| typ.is_integer()) {
+                            if key_types.iter().any(|typ| typ.is_integer()) {
                                 return Some(());
                             }
                         }
                     }
                     LuaMemberKey::Name(_) => {
-                        if key_type_set
+                        if key_types
                             .iter()
                             .any(|typ| typ.is_string() || typ.is_str_tpl_ref())
                         {
                             return Some(());
                         }
                     }
                     LuaMemberKey::Integer(_) => {
-                        if key_type_set.iter().any(|typ| typ.is_integer()) {
+                        if key_types.iter().any(|typ| typ.is_integer()) {
                             return Some(());
                         }
                     }
@@ -281,7 +280,7 @@ fn is_valid_member(
                     if let Some(decl) = semantic_model.get_db().get_type_index().get_type_decl(&id)
                     {
                         if decl.is_enum() {
-                            if key_type_set.iter().any(|typ| match typ {
+                            if key_types.iter().any(|typ| match typ {
                                 LuaType::Ref(key_id) | LuaType::Def(key_id) => id == *key_id,
                                 _ => false,
                             }) {
@@ -433,3 +432,22 @@ fn is_in_conditional_statement<T: LuaAstNode>(node: &T) -> bool {
     }
     false
 }
+
+fn check_enum_is_param(
+    semantic_model: &SemanticModel,
+    prefix_typ: &LuaType,
+    index_expr: &LuaIndexExpr,
+) -> Option<()> {
+    if enum_variable_is_param(
+        semantic_model.get_db(),
+        &mut semantic_model.get_config().borrow_mut(),
+        index_expr,
+        prefix_typ,
+    )
+    .is_some()
+    {
+        return Some(());
+    }
+
+    None
+}

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

@@ -714,7 +714,8 @@ fn infer_member_by_index_table(
                 let members = db
                     .get_member_index()
                     .get_members(&LuaMemberOwner::Element(table_range.clone()));
-                if let Some(members) = members {
+                if let Some(mut members) = members {
+                    members.sort_by(|a, b| a.get_key().cmp(&b.get_key()));
                     let mut result_type = LuaType::Unknown;
                     for member in members {
                         let member_key_type = match member.get_key() {