Merge pull request #901 from xuhuanzy/update

update

Author: CppCXY

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

@@ -96,6 +96,7 @@ fn check_call_expr(
     let mut fake_params = func.get_params().to_vec();
     let call_args = call_expr.get_args_list()?.get_args().collect::<Vec<_>>();
     let mut call_args_count = call_args.len();
+    let last_arg_is_dots = call_args.last().is_some_and(is_dots_expr);
     // 根据冒号定义与冒号调用的情况来调整调用参数的数量
     let colon_call = call_expr.is_colon_call();
     let colon_define = func.is_colon_define();
@@ -171,7 +172,16 @@ fn check_call_expr(
         }
     }
     // Check for redundant parameters
-    else if call_args_count > fake_params.len() {
+    else {
+        let mut min_call_args_count = call_args_count;
+        if last_arg_is_dots {
+            min_call_args_count = min_call_args_count.saturating_sub(1);
+        }
+
+        if min_call_args_count <= fake_params.len() {
+            return Some(());
+        }
+
         // 参数定义中最后一个参数是 `...`
         if fake_params.last().is_some_and(|(name, typ)| {
             name == "..." || typ.as_ref().is_some_and(|typ| typ.is_variadic())
@@ -185,6 +195,10 @@ fn check_call_expr(
         }
 
         for (i, arg) in call_args.iter().enumerate() {
+            if last_arg_is_dots && i + 1 == call_args.len() {
+                continue;
+            }
+
             let param_index = i as isize + adjusted_index;
 
             if param_index < 0 || param_index < fake_params.len() as isize {
@@ -197,7 +211,7 @@ fn check_call_expr(
                 t!(
                     "expected %{num} parameters but found %{found_num}",
                     num = fake_params.len(),
-                    found_num = call_args_count,
+                    found_num = min_call_args_count,
                 )
                 .to_string(),
                 None,
@@ -208,6 +222,15 @@ fn check_call_expr(
     Some(())
 }
 
+fn is_dots_expr(expr: &LuaExpr) -> bool {
+    if let LuaExpr::LiteralExpr(literal_expr) = expr
+        && let Some(LuaLiteralToken::Dots(_)) = literal_expr.get_literal()
+    {
+        return true;
+    }
+    false
+}
+
 fn get_params_len(params: &[(String, Option<LuaType>)]) -> Option<usize> {
     if let Some((name, typ)) = params.last() {
         // 如果最后一个参数是可变参数, 则直接返回, 不需要检查

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

@@ -159,4 +159,20 @@ mod test {
         "#
         ));
     }
+
+    #[test]
+    fn test_issue_894() {
+        let mut ws = VirtualWorkspace::new();
+        ws.def(
+            r#"
+            _nop = function() end
+            "#,
+        );
+        assert!(ws.check_code_for(
+            DiagnosticCode::RedundantParameter,
+            r#"
+            function a(...) _nop(...) end
+        "#
+        ));
+    }
 }

crates/emmylua_ls/src/handlers/hover/function/mod.rs

@@ -1,10 +1,9 @@
 use std::{collections::HashSet, sync::Arc, vec};
 
 use emmylua_code_analysis::{
-    AsyncState, DbIndex, InferGuard, LuaDocReturnInfo, LuaFunctionType, LuaMember, LuaMemberKey,
-    LuaMemberOwner, LuaSemanticDeclId, LuaType, RenderLevel, TypeSubstitutor, VariadicType,
-    humanize_type, infer_call_expr_func, instantiate_doc_function,
-    try_extract_signature_id_from_field,
+    AsyncState, DbIndex, InferGuard, LuaDocReturnInfo, LuaFunctionType, LuaMember, LuaMemberOwner,
+    LuaSemanticDeclId, LuaType, RenderLevel, TypeSubstitutor, VariadicType, humanize_type,
+    infer_call_expr_func, instantiate_doc_function, try_extract_signature_id_from_field,
 };
 
 use crate::handlers::hover::{
@@ -289,77 +288,69 @@ fn hover_doc_function_type(
         _ => "",
     };
     let mut is_method = func.is_colon_define();
-    let mut type_label = "function ";
+    let mut type_label = if is_local && owner_member.is_none() {
+        "local function "
+    } else {
+        "function "
+    };
+
     // 有可能来源于类. 例如: `local add = class.add`, `add()`应被视为类方法
     let full_name = if let Some(owner_member) = owner_member {
-        let mut name = String::new();
+        if is_field {
+            type_label = "(field) ";
+        }
+
+        let member_key = owner_member.get_key().to_path();
+        let mut name = String::with_capacity(member_key.len() + 16);
+
+        let mut push_typed_owner_prefix = |prefix: &str, type_decl_id| {
+            name.push_str(prefix);
+            let owner_ty = LuaType::Ref(type_decl_id);
+            is_method = func.is_method(builder.semantic_model, Some(&owner_ty));
+            if is_method {
+                type_label = "(method) ";
+            }
+            name.push(if is_method { ':' } else { '.' });
+        };
+
         let parent_owner = db
             .get_member_index()
             .get_current_owner(&owner_member.get_id());
         if let Some(parent_owner) = parent_owner {
             match parent_owner {
                 LuaMemberOwner::Type(type_decl_id) => {
-                    let global_name =
-                        infer_prefix_global_name(builder.semantic_model, owner_member);
-                    // 如果是全局定义, 则使用定义时的名称
-                    if let Some(global_name) = global_name {
-                        name.push_str(global_name);
-                    } else {
-                        name.push_str(type_decl_id.get_simple_name());
-                    }
-                    if is_field {
-                        type_label = "(field) ";
-                    }
-                    is_method = func.is_method(
-                        builder.semantic_model,
-                        Some(&LuaType::Ref(type_decl_id.clone())),
-                    );
-                    if is_method {
-                        type_label = "(method) ";
-                        name.push(':');
-                    } else {
-                        name.push('.');
-                    }
+                    let prefix = infer_prefix_global_name(builder.semantic_model, owner_member)
+                        .unwrap_or_else(|| type_decl_id.get_simple_name());
+                    push_typed_owner_prefix(prefix, type_decl_id.clone());
                 }
                 LuaMemberOwner::Element(element_id) => {
                     if let Some(LuaType::Ref(type_decl_id) | LuaType::Def(type_decl_id)) =
                         extract_parent_type_from_element(builder.semantic_model, element_id)
                     {
-                        name.push_str(type_decl_id.get_simple_name());
-                        if is_field {
-                            type_label = "(field) ";
-                        }
-                        is_method = func.is_method(
-                            builder.semantic_model,
-                            Some(&LuaType::Ref(type_decl_id.clone())),
+                        push_typed_owner_prefix(
+                            type_decl_id.get_simple_name(),
+                            type_decl_id.clone(),
                         );
-                        if is_method {
-                            type_label = "(method) ";
-                            name.push(':');
-                        } else {
-                            name.push('.');
-                        }
                     } else if let Some(owner_name) =
                         extract_owner_name_from_element(builder.semantic_model, element_id)
                     {
                         name.push_str(&owner_name);
-                        name.push('.');
+                        if is_method {
+                            type_label = "(method) ";
+                        }
+                        name.push(if is_method { ':' } else { '.' });
                     }
                 }
                 _ => {}
             }
         }
 
-        if let LuaMemberKey::Name(n) = owner_member.get_key() {
-            name.push_str(n.as_str());
-        }
+        name.push_str(&member_key);
         name
     } else {
-        if is_local {
-            type_label = "local function ";
-        }
         func_name.to_string()
     };
+
     let params = func
         .get_params()
         .iter()

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

@@ -667,4 +667,24 @@ mod tests {
         ));
         Ok(())
     }
+
+    #[gtest]
+    fn test_table_const_method() -> Result<()> {
+        let mut ws = ProviderVirtualWorkspace::new();
+        check!(ws.check_hover(
+            r#"
+            local M = {}
+
+            ---@param x number
+            function M:abc<??>d(x)
+            end
+
+            M:abcd(1)
+            "#,
+            VirtualHoverResult {
+                value: "```lua\n(method) M:abcd(x: number)\n```".to_string(),
+            },
+        ));
+        Ok(())
+    }
 }

crates/emmylua_ls/std_i18n/builtin/meta.yaml

@@ -90,20 +90,20 @@ entries:
       line: 118
       col: 0
     end:
-      line: 119
+      line: 120
       col: 0
-  hash: '38c2701334822d7a'
-  context_hash: c1905bc5fdb3a411
+  hash: b508ab78f8d1bc46
+  context_hash: de7cc417de1b3246
 - key: std.Unpack
   kind:
     type: doc_block
     indent: ''
   range:
     start:
-      line: 121
+      line: 122
       col: 0
     end:
-      line: 123
+      line: 124
       col: 0
   hash: c7ad7bb74235dc8c
   context_hash: de7cc417de1b3246
@@ -113,10 +113,10 @@ entries:
     indent: ''
   range:
     start:
-      line: 125
+      line: 126
       col: 0
     end:
-      line: 127
+      line: 128
       col: 0
   hash: '7327558f3445dea6'
   context_hash: de7cc417de1b3246
@@ -126,10 +126,10 @@ entries:
     indent: ''
   range:
     start:
-      line: 129
+      line: 130
       col: 0
     end:
-      line: 131
+      line: 132
       col: 0
   hash: '0e263d1e0caa6b3b'
   context_hash: de7cc417de1b3246
@@ -139,36 +139,36 @@ entries:
     indent: ''
   range:
     start:
-      line: 145
+      line: 146
       col: 0
     end:
-      line: 146
+      line: 148
       col: 0
-  hash: d949231b3fc3363d
-  context_hash: ea58ce70c1a97a2a
+  hash: '71b070c2fa27cbf9'
+  context_hash: de7cc417de1b3246
 - key: ConstructorParameters
   kind:
     type: doc_block
     indent: ''
   range:
     start:
-      line: 148
+      line: 150
       col: 0
     end:
-      line: 149
+      line: 152
       col: 0
-  hash: '6537def67aeb8537'
-  context_hash: d32380b12ad01070
+  hash: '2f4bebd14d7824cb'
+  context_hash: de7cc417de1b3246
 - key: Partial
   kind:
     type: doc_block
     indent: ''
   range:
     start:
-      line: 153
+      line: 157
       col: 0
     end:
-      line: 154
+      line: 159
       col: 0
-  hash: caabe7bd856c5ea6
-  context_hash: '7f3cfe2b87b6d515'
+  hash: '5e4213a7c3937182'
+  context_hash: de7cc417de1b3246

crates/emmylua_ls/std_i18n/builtin/zh_CN.yaml

@@ -7,20 +7,20 @@ boolean: |
   都会使条件为假；任何其他值都会使条件为真。
 
 number: |
-  *number* 类型使用两种内部表示，或两个子类型，一个称为 *integer*，
-  另一个称为 *float*。Lua 对何时使用哪种表示有明确的规则，但它也会
-  根据需要在两者之间自动转换。因此，程序员可以选择大部分时候忽略整数
-  和浮点数之间的差异，或者完全控制每个数字的表示。标准 Lua 使用64位
-  整数和双精度（64位）浮点数，但你也可以编译 Lua 使其使用32位整数
-  和/或单精度（32位）浮点数。对于小型机器和嵌入式系统，整数和浮点数
-  都使用32位的选项特别有吸引力。（参见 luaconf.h 文件中的宏 LUA_32BITS。）
+  **number** 类型在内部使用两种表示形式，或称为两种子类型，一种叫做
+  *integer*，另一种叫做 *float*。Lua 对于何时使用哪种表示形式有明确的规则，
+  但也会在需要时自动进行转换。因此，程序员可以选择忽略整数和浮点数之间的差异，
+  也可以完全控制每个数字的表示形式。标准 Lua 使用 64 位整数和双精度（64 位）
+  浮点数，但你也可以将 Lua 编译为使用 32 位整数和/或单精度（32 位）浮点数。
+  对于小型机器和嵌入式系统来说，同时使用 32 位整数和 32 位浮点数的选项特别有吸引力。
+  （参见 `luaconf.h` 文件中的宏 `LUA_32BITS`。）
 
 userdata: |
   *userdata* 类型用于允许将任意 C 数据存储在 Lua 变量中。userdata 值
-  表示一块原始内存。有两种 userdata：*完全 userdata*，是一个由 Lua
-  管理内存块的对象；*轻量 userdata*，仅是一个 C 指针值。userdata 在
-  Lua 中没有预定义的操作，除了赋值和身份测试。通过使用 *元表*，程序员
-  可以为完全 userdata 值定义操作。userdata 值不能在 Lua 中创建或修改，
+  表示一块原始内存。有两种 userdata：*full userdata*，是一个由 Lua
+  管理内存块的对象；*light userdata*，它仅是一个 C 指针值。userdata 在
+  Lua 中没有预定义的操作，除了赋值和相等性测试。通过使用 *metatables*，程序员
+  可以为 full userdata 值定义操作。userdata 值不能在 Lua 中创建或修改，
   只能通过 C API 进行。这保证了宿主程序所拥有数据的完整性。
 
 thread: |
@@ -32,15 +32,14 @@ table: |
   和 NaN 之外的任何 Lua 值的数组。（*NaN* 是 IEEE 754 标准用于表示
   未定义或不可表示的数值结果的特殊浮点值，例如 `0/0`。）表可以是异构的；
   也就是说，它们可以包含所有类型的值（除了 **nil**）。值为 **nil** 的
-  任何键都不被视为表的一部分。相反，不属于表的任何键都有一个关联值 **nil**。
+  任何键都不被视为表的一部分。相反，任何不属于表的键其关联值都为 **nil**。
 
-  表是 Lua 中唯一的数据组织机制；它们可以用来表示普通数组、列表、符号表、
+  表是 Lua 中唯一的数据结构；它们可以用来表示普通数组、列表、符号表、
   集合、记录、图、树等。为了表示记录，Lua 使用字段名作为索引。语言通过
-  提供 `a.name` 作为 `a["name"]` 的语法糖来支持这种表示。在 Lua 中有
-  几种方便的方式来创建表。
+  提供 `a.name` 作为 `a["name"]` 的语法糖来支持这种表示。
 
-  与索引一样，表字段的值可以是任何类型。特别是，由于函数是一等值，表
-  字段可以包含函数。因此表也可以携带 *方法*。
+  与索引一样，表字段的值可以是任何类型。特别地，由于函数是一等公民，表
+  字段可以包含函数。因此表也可以携带 *methods*。
 
   表的索引遵循语言中原始相等的定义。表达式 `a[i]` 和 `a[j]` 当且仅当
   `i` 和 `j` 原始相等（即不使用元方法的相等）时表示相同的表元素。特别地，