update type check object

Author: xuhuanzy

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

@@ -288,6 +288,7 @@ fn check_table_expr_content(
         let Some(member_key) = semantic_model.get_member_key(&field_key) else {
             continue;
         };
+
         let source_type = match semantic_model.infer_member_type(table_type, &member_key) {
             Ok(typ) => typ,
             Err(_) => {

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

@@ -966,4 +966,26 @@ return t
         "#
         ));
     }
+
+    #[test]
+    fn test_object_table() {
+        let mut ws = VirtualWorkspace::new();
+        ws.def(
+            r#"
+        ---@alias A {[string]: string}
+
+        ---@param matchers A
+        function name(matchers)
+        end
+        "#,
+        );
+        assert!(!ws.check_code_for(
+            DiagnosticCode::AssignTypeMismatch,
+            r#"
+            name({
+                toBe = 1,
+            })
+        "#
+        ));
+    }
 }

crates/emmylua_code_analysis/src/semantic/member/infer_raw_member.rs

@@ -46,7 +46,7 @@ fn infer_raw_member_type_guard(
             infer_custom_type_raw_member_type(db, type_id, member_key, infer_guard)
         }
         LuaType::Tuple(tuple) => infer_tuple_raw_member_type(tuple, member_key),
-        LuaType::Object(object) => infer_object_raw_member_type(object, member_key),
+        LuaType::Object(object) => infer_object_raw_member_type(db, object, member_key),
         LuaType::Array(array_type) => {
             infer_array_raw_member_type(db, array_type.get_base(), member_key)
         }
@@ -131,27 +131,27 @@ fn infer_tuple_raw_member_type(
 }
 
 fn infer_object_raw_member_type(
+    db: &DbIndex,
     object: &LuaObjectType,
     member_key: &LuaMemberKey,
 ) -> RawGetMemberTypeResult {
     if let Some(member_type) = object.get_field(member_key) {
         return Ok(member_type.clone());
     }
 
-    // donot support now
-    // let index_accesses = object.get_index_access();
-    // for (key, value) in index_accesses {
-    //     let result = infer_index_metamethod(db, &member_key, &key, value);
-    //     match result {
-    //         Ok(typ) => {
-    //             return Ok(typ);
-    //         }
-    //         Err(InferFailReason::FieldNotFound) => {}
-    //         Err(err) => {
-    //             return Err(err);
-    //         }
-    //     }
-    // }
+    let index_accesses = object.get_index_access();
+    for (key, value) in index_accesses {
+        let access_key_type = match &member_key {
+            LuaMemberKey::Name(name) => LuaType::StringConst(name.clone().into()),
+            LuaMemberKey::Integer(i) => LuaType::IntegerConst(*i),
+            LuaMemberKey::ExprType(lua_type) => lua_type.clone(),
+            LuaMemberKey::None => continue,
+        };
+
+        if check_type_compact(db, key, &access_key_type).is_ok() {
+            return Ok(value.clone());
+        }
+    }
 
     Err(InferFailReason::FieldNotFound)
 }

crates/emmylua_code_analysis/src/semantic/type_check/complex_type/object_type_check.rs

@@ -101,8 +101,10 @@ fn check_object_type_compact_member_owner(
     check_guard: TypeCheckGuard,
 ) -> TypeCheckResult {
     let member_index = context.db.get_member_index();
+    let source_fields = source_object.get_fields();
 
-    for (key, source_type) in source_object.get_fields() {
+    // 检查名称字段
+    for (key, source_type) in source_fields {
         let member_item = match member_index.get_member_item(&member_owner, key) {
             Some(member_item) => member_item,
             None => {
@@ -146,6 +148,82 @@ fn check_object_type_compact_member_owner(
         }
     }
 
+    // 检查索引访问字段
+    let members = member_index.get_members(&member_owner).unwrap_or_default();
+    for (key_type, source_type) in source_object.get_index_access() {
+        for member in &members {
+            let member = *member;
+            if source_fields.contains_key(member.get_key()) {
+                continue;
+            }
+            let member_key_type = match member.get_key() {
+                LuaMemberKey::Integer(i) => LuaType::IntegerConst(*i),
+                LuaMemberKey::Name(name) => LuaType::StringConst(name.clone().into()),
+                LuaMemberKey::ExprType(typ) => typ.clone(),
+                LuaMemberKey::None => continue,
+            };
+
+            let key_match = match check_general_type_compact(
+                context,
+                key_type,
+                &member_key_type,
+                check_guard.next_level()?,
+            ) {
+                Ok(_) => true,
+                Err(err) => {
+                    if err.is_type_not_match() {
+                        false
+                    } else {
+                        return Err(err);
+                    }
+                }
+            };
+
+            if !key_match {
+                continue;
+            }
+
+            let member_type = match context
+                .db
+                .get_type_index()
+                .get_type_cache(&member.get_id().into())
+            {
+                Some(cache) => cache.as_type().clone(),
+                None => continue,
+            };
+
+            match check_general_type_compact(
+                context,
+                source_type,
+                &member_type,
+                check_guard.next_level()?,
+            ) {
+                Ok(_) => {
+                    break;
+                }
+                Err(TypeCheckFailReason::TypeNotMatch) => {
+                    let mut key_display = member.get_key().to_path();
+                    if key_display.is_empty() {
+                        key_display =
+                            humanize_type(context.db, &member_key_type, RenderLevel::Simple);
+                    }
+                    return Err(TypeCheckFailReason::TypeNotMatchWithReason(
+                        t!(
+                            "member %{key} not match, expect %{typ}, but got %{got}",
+                            key = key_display,
+                            typ = humanize_type(context.db, source_type, RenderLevel::Simple),
+                            got = humanize_type(context.db, &member_type, RenderLevel::Simple)
+                        )
+                        .to_string(),
+                    ));
+                }
+                Err(err) => {
+                    return Err(err);
+                }
+            }
+        }
+    }
+
     Ok(())
 }