fix: infer self

Author: xuhuanzy

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

@@ -1420,7 +1420,7 @@ mod test {
     }
 
     #[test]
-    fn test_key_of() {
+    fn test_keyof() {
         let mut ws = VirtualWorkspace::new();
         ws.def(
             r#"
@@ -1454,4 +1454,28 @@ mod test {
         "#,
         ));
     }
+
+    #[test]
+    fn test_origin_self() {
+        let mut ws = VirtualWorkspace::new();
+        ws.def(
+            r#"
+            ---@class Runner
+            ---@field onCollectStart? fun(self:self)
+
+            ---@type Runner
+            runner = {}
+
+        "#,
+        );
+        assert!(ws.check_code_for(
+            DiagnosticCode::ParamTypeMismatch,
+            r#"
+            local originOnCollectStart = runner.onCollectStart
+            runner.onCollectStart = function(self)
+                originOnCollectStart(self)
+            end
+        "#,
+        ));
+    }
 }

crates/emmylua_code_analysis/src/semantic/generic/instantiate_type/instantiate_func_generic.rs

@@ -1,6 +1,6 @@
 use std::{collections::HashSet, ops::Deref, sync::Arc};
 
-use emmylua_parser::LuaDocTypeList;
+use emmylua_parser::{LuaAstNode, LuaDocTypeList};
 use emmylua_parser::{LuaCallExpr, LuaExpr};
 use internment::ArcIntern;
 
@@ -23,6 +23,7 @@ use crate::{
         infer_expr,
     },
 };
+use crate::{LuaMemberOwner, LuaSemanticDeclId, SemanticDeclLevel, infer_node_semantic_decl};
 
 use super::TypeSubstitutor;
 
@@ -231,16 +232,32 @@ pub fn infer_self_type(
     cache: &mut LuaInferCache,
     call_expr: &LuaCallExpr,
 ) -> Option<LuaType> {
-    let prefix_expr = call_expr.get_prefix_expr();
-    if let Some(prefix_expr) = prefix_expr
-        && let LuaExpr::IndexExpr(index) = prefix_expr
-    {
-        let self_expr = index.get_prefix_expr();
-        if let Some(self_expr) = self_expr {
+    let prefix_expr = call_expr.get_prefix_expr()?;
+    match prefix_expr {
+        LuaExpr::IndexExpr(index) => {
+            let self_expr = index.get_prefix_expr()?;
             let self_type = infer_expr(db, cache, self_expr).ok()?;
             let self_type = build_self_type(db, &self_type);
             return Some(self_type);
         }
+        LuaExpr::NameExpr(name) => {
+            let semantic_decl_id = infer_node_semantic_decl(
+                db,
+                cache,
+                name.syntax().clone(),
+                SemanticDeclLevel::default(),
+            )?;
+            if let LuaSemanticDeclId::Member(member_id) = semantic_decl_id {
+                let owner = db.get_member_index().get_current_owner(&member_id)?;
+                if let LuaMemberOwner::Type(id) = owner {
+                    let typ = LuaType::Ref(id.clone());
+                    let self_type = build_self_type(db, &typ);
+                    return Some(self_type);
+                }
+                return None;
+            }
+        }
+        _ => {}
     }
 
     None

crates/emmylua_code_analysis/src/semantic/semantic_info/infer_expr_semantic_decl.rs

@@ -6,7 +6,7 @@ use emmylua_parser::{
 use crate::{
     DbIndex, LuaDeclId, LuaDeclOrMemberId, LuaInferCache, LuaInstanceType, LuaIntersectionType,
     LuaMemberId, LuaMemberKey, LuaMemberOwner, LuaSemanticDeclId, LuaType, LuaTypeCache,
-    LuaTypeDeclId, LuaUnionType,
+    LuaTypeDeclId, LuaUnionType, TypeOps,
     semantic::{
         infer::find_self_decl_or_member_id, member::get_buildin_type_map_type_id,
         semantic_info::resolve_global_decl_id,
@@ -78,7 +78,8 @@ fn infer_name_expr_semantic_decl(
         .get_type_index()
         .get_type_cache(&decl_id.into())
         .unwrap_or(&LuaTypeCache::InferType(LuaType::Unknown));
-    let is_ref_object = decl_type.is_function() || decl_type.is_table();
+    let remove_nil_type = TypeOps::Remove.apply(db, &decl_type, &LuaType::Nil);
+    let is_ref_object = remove_nil_type.is_function() || remove_nil_type.is_table();
     if decl.is_local() && !is_ref_object {
         return Some(LuaSemanticDeclId::LuaDecl(decl_id));
     }
@@ -89,7 +90,7 @@ fn infer_name_expr_semantic_decl(
 
     if let Some(value_expr_id) = decl.get_value_syntax_id() {
         match value_expr_id.get_kind() {
-            LuaSyntaxKind::NameExpr | LuaSyntaxKind::IndexExpr if decl_type.is_function() => {
+            LuaSyntaxKind::NameExpr | LuaSyntaxKind::IndexExpr if remove_nil_type.is_function() => {
                 let file_id = decl.get_file_id();
                 let tree = db.get_vfs().get_syntax_tree(&file_id)?;
                 // second infer