Merge remote-tracking branch 'EmmyLuaLs/main' into attribute

Author: xuhuanzy

crates/emmylua_code_analysis/src/compilation/analyzer/lua/for_range_stat.rs

@@ -1,4 +1,4 @@
-use emmylua_parser::{LuaAstNode, LuaAstToken, LuaExpr, LuaForRangeStat};
+use emmylua_parser::{LuaAstToken, LuaExpr, LuaForRangeStat};
 
 use crate::{
     DbIndex, InferFailReason, LuaDeclId, LuaInferCache, LuaOperatorMetaMethod, LuaType,
@@ -79,7 +79,6 @@ pub fn infer_for_range_iter_expr_func(
     }
 
     let iter_func_expr = iter_exprs[0].clone();
-    let root = iter_func_expr.get_root();
     let first_expr_type = infer_expr(db, cache, iter_func_expr)?;
     let doc_function = match first_expr_type {
         LuaType::DocFunction(func) => func,
@@ -150,7 +149,6 @@ pub fn infer_for_range_iter_expr_func(
         db,
         cache,
         substitutor: &mut substitutor,
-        root,
         call_expr: None,
     };
     let params = doc_function

crates/emmylua_code_analysis/src/db_index/signature/signature.rs

@@ -11,7 +11,7 @@ use crate::{
     FileId,
     db_index::{LuaFunctionType, LuaType},
 };
-use crate::{LuaAttributeUse, SemanticModel, VariadicType};
+use crate::{LuaAttributeUse, SemanticModel, VariadicType, first_param_may_not_self};
 
 #[derive(Debug)]
 pub struct LuaSignature {
@@ -137,11 +137,8 @@ impl LuaSignature {
             match owner_type {
                 Some(owner_type) => {
                     // 一些类型不应该被视为 method
-                    if let (LuaType::Ref(_) | LuaType::Def(_), _) = (owner_type, param_type)
-                        && (param_type.is_any()
-                            || param_type.is_table()
-                            || param_type.is_class_tpl()
-                            || param_type.is_str_tpl_ref())
+                    if matches!(owner_type, LuaType::Ref(_) | LuaType::Def(_))
+                        && first_param_may_not_self(param_type)
                     {
                         return false;
                     }
@@ -195,7 +192,7 @@ impl LuaDocParamInfo {
     }
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct LuaDocReturnInfo {
     pub name: Option<String>,
     pub type_ref: LuaType,

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

@@ -299,3 +299,15 @@ fn get_real_type_with_depth<'a>(
         _ => Some(typ),
     }
 }
+
+// 第一个参数是否不应该视为 self
+pub fn first_param_may_not_self(typ: &LuaType) -> bool {
+    if typ.is_table() || matches!(typ, LuaType::Ref(_) | LuaType::Def(_) | LuaType::Any) {
+        return false;
+    }
+    if let LuaType::Union(u) = typ {
+        return u.into_vec().iter().any(first_param_may_not_self);
+    }
+
+    true
+}

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

@@ -12,6 +12,7 @@ use smol_str::SmolStr;
 use crate::{
     AsyncState, DbIndex, FileId, InFiled, SemanticModel,
     db_index::{LuaMemberKey, LuaSignatureId, r#type::type_visit_trait::TypeVisitTrait},
+    first_param_may_not_self,
 };
 
 use super::{TypeOps, type_decl::LuaTypeDeclId};
@@ -689,8 +690,8 @@ impl LuaFunctionType {
                     match owner_type {
                         Some(owner_type) => {
                             // 一些类型不应该被视为 method
-                            if let (LuaType::Ref(_) | LuaType::Def(_), _) = (owner_type, t)
-                                && (t.is_any() || t.is_table() || t.is_class_tpl())
+                            if matches!(owner_type, LuaType::Ref(_) | LuaType::Def(_))
+                                && first_param_may_not_self(t)
                             {
                                 return false;
                             }

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

@@ -55,6 +55,16 @@ impl Checker for UnusedChecker {
                             ).to_string(),
                             None)
                     }
+                    UnusedCheckResult::UnusedSelf(range) => {
+                        context.add_diagnostic(
+                            DiagnosticCode::Unused,
+                            range,
+                            t!(
+                                "Implicit self is never used, if this is intentional, please use '.' instead of ':' to define the method",
+                            ).to_string(),
+                            None,
+                        );
+                    }
                 }
             }
         }
@@ -64,6 +74,7 @@ impl Checker for UnusedChecker {
 enum UnusedCheckResult {
     Unused(TextRange),
     AssignedButNotRead(TextRange),
+    UnusedSelf(TextRange),
 }
 
 fn get_unused_check_result(
@@ -73,9 +84,15 @@ fn get_unused_check_result(
 ) -> Result<(), UnusedCheckResult> {
     let decl_range = decl.get_range();
     let file_id = decl.get_file_id();
-    let decl_ref = ref_index
-        .get_decl_references(&file_id, &decl.get_id())
-        .ok_or(UnusedCheckResult::Unused(decl_range))?;
+    let decl_ref = match ref_index.get_decl_references(&file_id, &decl.get_id()) {
+        Some(decl_ref) => decl_ref,
+        None => {
+            if decl.is_implicit_self() {
+                return Err(UnusedCheckResult::UnusedSelf(decl_range));
+            }
+            return Err(UnusedCheckResult::Unused(decl_range));
+        }
+    };
 
     if decl_ref.cells.is_empty() {
         return Err(UnusedCheckResult::Unused(decl_range));

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::{LuaAstNode, LuaCallExpr, LuaExpr};
+use emmylua_parser::{LuaCallExpr, LuaExpr};
 use internment::ArcIntern;
 
 use crate::{
@@ -63,7 +63,6 @@ pub fn instantiate_func_generic(
         db,
         cache,
         substitutor: &mut substitutor,
-        root: call_expr.get_root(),
         call_expr: Some(call_expr.clone()),
     };
     if !generic_tpls.is_empty() {

crates/emmylua_code_analysis/src/semantic/generic/tpl_context.rs

@@ -1,4 +1,4 @@
-use emmylua_parser::{LuaCallExpr, LuaSyntaxNode};
+use emmylua_parser::LuaCallExpr;
 
 use crate::{DbIndex, LuaInferCache, TypeSubstitutor};
 
@@ -7,6 +7,5 @@ pub struct TplContext<'a> {
     pub db: &'a DbIndex,
     pub cache: &'a mut LuaInferCache,
     pub substitutor: &'a mut TypeSubstitutor,
-    pub root: LuaSyntaxNode,
     pub call_expr: Option<LuaCallExpr>,
 }

crates/emmylua_code_analysis/src/semantic/infer/infer_call/mod.rs

@@ -13,7 +13,8 @@ use super::{
 };
 use crate::{
     CacheEntry, DbIndex, InFiled, LuaFunctionType, LuaGenericType, LuaInstanceType,
-    LuaOperatorMetaMethod, LuaOperatorOwner, LuaSignatureId, LuaType, LuaTypeDeclId, LuaUnionType,
+    LuaOperatorMetaMethod, LuaOperatorOwner, LuaSignature, LuaSignatureId, LuaType, LuaTypeDeclId,
+    LuaUnionType,
 };
 use crate::{
     InferGuardRef,
@@ -179,6 +180,7 @@ fn infer_signature_doc_function(
     if !signature.is_resolve_return() {
         return Err(InferFailReason::UnResolveSignatureReturn(signature_id));
     }
+    let is_generic = signature_is_generic(db, cache, &signature, &call_expr).unwrap_or(false);
     let overloads = &signature.overloads;
     if overloads.is_empty() {
         let mut fake_doc_function = LuaFunctionType::new(
@@ -187,7 +189,7 @@ fn infer_signature_doc_function(
             signature.get_type_params(),
             signature.get_return_type(),
         );
-        if signature.is_generic() {
+        if is_generic {
             fake_doc_function = instantiate_func_generic(db, cache, &fake_doc_function, call_expr)?;
         }
 
@@ -207,7 +209,7 @@ fn infer_signature_doc_function(
             cache,
             new_overloads,
             call_expr.clone(),
-            signature.is_generic(),
+            is_generic,
             args_count,
         )
     }
@@ -654,3 +656,23 @@ fn check_can_infer(
 
     Ok(())
 }
+
+fn signature_is_generic(
+    db: &DbIndex,
+    cache: &mut LuaInferCache,
+    signature: &LuaSignature,
+    call_expr: &LuaCallExpr,
+) -> Option<bool> {
+    if signature.is_generic() {
+        return Some(true);
+    }
+    let LuaExpr::IndexExpr(index_expr) = call_expr.get_prefix_expr()? else {
+        return None;
+    };
+    let prefix_type = infer_expr(db, cache, index_expr.get_prefix_expr()?).ok()?;
+    match prefix_type {
+        // 对于 Generic 直接认为是泛型
+        LuaType::Generic(_) => Some(true),
+        _ => Some(prefix_type.contain_tpl()),
+    }
+}

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

@@ -738,10 +738,6 @@ fn infer_generic_member(
     let generic_params = generic_type.get_params();
     let substitutor = TypeSubstitutor::from_type_array(generic_params.clone());
 
-    // TODO: this is just a hack to support inheritance from the generic objects
-    // like `---@class box<T>: T`. Should be rewritten: generic types should
-    // be passed to the called instantiate_type_generic() in some kind of a
-    // context.
     if let LuaType::Ref(base_type_decl_id) = &base_type {
         let result = infer_generic_members_from_super_generics(
             db,

crates/emmylua_code_analysis/src/semantic/mod.rs

@@ -51,8 +51,9 @@ use crate::{LuaFunctionType, LuaMemberId, LuaMemberKey, LuaTypeOwner};
 pub use generic::*;
 pub use guard::{InferGuard, InferGuardRef};
 pub use infer::InferFailReason;
+pub use infer::infer_call_expr_func;
+pub(crate) use infer::infer_expr;
 pub use infer::infer_param;
-pub(crate) use infer::{infer_call_expr_func, infer_expr};
 use overload_resolve::resolve_signature;
 pub use semantic_info::SemanticDeclLevel;
 pub use type_check::{TypeCheckFailReason, TypeCheckResult};