Merge pull request #538 from xuhuanzy/fix

update

Author: CppCXY

CHANGELOG.md

@@ -2,6 +2,76 @@
 
 # 0.8.1 (unreleased)
 
+`CHG` Generic constraint (StrTplRef) removes the protection for string: 
+```lua
+---@generic T: string -- need to remove `: string`
+---@param a `T`
+---@return T
+local function class(a)
+end
+
+---@class A
+
+lcoal A = class("A") -- error
+```
+
+`NEW` Explicitly declared `Tuple` are immutable.
+```lua
+---@type [1, 2]
+local a = {1, 2}
+
+a[1] = 3 -- error
+```
+
+`FIX` Hover `function` now can show the corresponding doc comment.
+
+`NEW` Added the configuration item `classDefaultCall`, which is used to declare a method with the specified name as the default `__call` for a class. The effect is equivalent to `---@overload fun()`, but with a lower priority. If an explicitly declared `---@overload fun()` exists, `classDefaultCall` will have no effect on the class.
+
+```json
+{
+  "runtime": {
+    "classDefaultCall": {
+      "functionName": "__init",
+      "forceNonColon": true,
+      "forceReturnSelf": true
+    }
+  },
+}
+```
+
+```lua
+---@class MyClass
+local M = {}
+
+-- `functionName` is `__init`, so the call will be treated as `__init`
+function M:__init(a)
+    -- `forceReturnSelf` is `true`, so the call will return `self`. even if the method does not return `self` or returns some other value.
+end
+
+
+-- `forceNonColon` is `true`, so the call can be called without `:` and without passing `self`
+-- `forceReturnSelf` is `true`, so the call will return `self`
+A = M() -- `A` is `MyClass`
+```
+
+
+`NEW` Added `docBaseConstMatchBaseType` configuration item, default is `false`. Base constant types defined in doc can match base types, allowing int to match `---@alias id 1|2|3`, same for string.
+
+```json
+{
+  "strict": {
+    "docBaseConstMatchBaseType": true
+  },
+}
+```
+
+`FIX` When `enum` is used as a function parameter, it is treated as a value rather than the `enum` itself.
+
+`FIX` When the expected type of a table field is a function, function completion is available.
+
+`NEW` `inlay_hint` params hint can now jump to the actual type definition.
+
+
 # 0.8.0
 
 `NEW` Implement `std.Unpack` type for better type inference of the `unpack` function, and `std.Rawget` type for better type inference of the `rawget` function

crates/emmylua_code_analysis/src/compilation/analyzer/unresolve/resolve.rs

@@ -150,7 +150,7 @@ fn merge_table_field_to_def(
     let file_id = cache.get_file_id();
     let local_name = table_expr
         .get_parent::<LuaLocalStat>()?
-        .get_value_local_name(LuaExpr::TableExpr(table_expr.clone()))?;
+        .get_local_name_by_value(LuaExpr::TableExpr(table_expr.clone()))?;
     let decl_id = LuaDeclId::new(file_id, local_name.get_position());
     let type_cache = db.get_type_index().get_type_cache(&decl_id.into())?;
     if let LuaType::Def(id) = type_cache.deref() {

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

@@ -689,22 +689,36 @@ fn humanize_signature_type(
         .collect::<Vec<_>>()
         .join(", ");
 
-    let rets = signature
-        .return_docs
-        .iter()
-        .map(|ret| humanize_type(db, &ret.type_ref, level.next_level()))
-        .collect::<Vec<_>>();
-
     let generic_str = if generics.is_empty() {
         "".to_string()
     } else {
         format!("<{}>", generics)
     };
 
-    let ret_str = if rets.is_empty() {
-        "".to_string()
-    } else {
-        format!(" -> {}", rets.join(","))
+    let ret_str = {
+        let ret_type = signature.get_return_type();
+        let return_nil = match ret_type {
+            LuaType::Variadic(variadic) => match variadic.get_type(0) {
+                Some(LuaType::Nil) => true,
+                _ => false,
+            },
+            _ => ret_type.is_nil(),
+        };
+
+        if return_nil {
+            "".to_string()
+        } else {
+            let rets = signature
+                .return_docs
+                .iter()
+                .map(|ret| humanize_type(db, &ret.type_ref, level.next_level()))
+                .collect::<Vec<_>>();
+            if rets.is_empty() {
+                "".to_string()
+            } else {
+                format!(" -> {}", rets.join(","))
+            }
+        }
     };
 
     format!("fun{}({}){}", generic_str, params, ret_str)

crates/emmylua_ls/src/handlers/inlay_hint/build_function_hint.rs

@@ -76,7 +76,7 @@ pub fn build_closure_hint(
     Some(())
 }
 
-fn build_label_parts(semantic_model: &SemanticModel, typ: &LuaType) -> Vec<InlayHintLabelPart> {
+pub fn build_label_parts(semantic_model: &SemanticModel, typ: &LuaType) -> Vec<InlayHintLabelPart> {
     let mut parts: Vec<InlayHintLabelPart> = Vec::new();
     match typ {
         LuaType::Union(union) => {
@@ -116,6 +116,10 @@ fn build_label_parts(semantic_model: &SemanticModel, typ: &LuaType) -> Vec<Inlay
         }
         result.push(part);
     }
+    // 如果只有一个`nil`标签, 那么将其改为": nil"
+    if result.len() == 1 && result[0].value == "?" {
+        result[0].value = ": nil".to_string();
+    }
     result
 }
 
@@ -153,9 +157,10 @@ fn get_type_location(semantic_model: &SemanticModel, typ: &LuaType) -> Option<Lo
             let lsp_range = document.to_lsp_range(location.range)?;
             Some(Location::new(document.get_uri(), lsp_range))
         }
+        LuaType::Array(base) => get_type_location(semantic_model, base),
         LuaType::Any => get_base_type_location(semantic_model, "any"),
         LuaType::Nil => get_base_type_location(semantic_model, "nil"),
-        LuaType::Unknown => get_base_type_location(semantic_model, "string"),
+        LuaType::Unknown => get_base_type_location(semantic_model, "unknown"),
         LuaType::Userdata => get_base_type_location(semantic_model, "userdata"),
         LuaType::Function => get_base_type_location(semantic_model, "function"),
         LuaType::Thread => get_base_type_location(semantic_model, "thread"),

crates/emmylua_ls/src/handlers/inlay_hint/build_inlay_hint.rs

@@ -2,20 +2,19 @@ use std::collections::HashMap;
 
 use emmylua_code_analysis::{
     FileId, InferGuard, LuaFunctionType, LuaMemberId, LuaMemberKey, LuaSemanticDeclId, LuaType,
-    RenderLevel, SemanticModel,
+    SemanticModel,
 };
-use emmylua_parser::LuaTokenKind;
 use emmylua_parser::{
-    LuaAst, LuaAstNode, LuaCallExpr, LuaExpr, LuaFuncStat, LuaIndexExpr, LuaLocalName, LuaStat,
-    LuaSyntaxId, LuaVarExpr,
+    LuaAst, LuaAstNode, LuaCallExpr, LuaExpr, LuaFuncStat, LuaIndexExpr, LuaLocalFuncStat,
+    LuaLocalName, LuaLocalStat, LuaStat, LuaSyntaxId, LuaVarExpr,
 };
+use emmylua_parser::{LuaAstToken, LuaTokenKind};
 use lsp_types::{InlayHint, InlayHintKind, InlayHintLabel, InlayHintLabelPart, Location};
 use rowan::NodeOrToken;
 
-use emmylua_code_analysis::humanize_type;
 use rowan::TokenAtOffset;
 
-use crate::handlers::inlay_hint::build_function_hint::build_closure_hint;
+use crate::handlers::inlay_hint::build_function_hint::{build_closure_hint, build_label_parts};
 
 pub fn build_inlay_hints(semantic_model: &SemanticModel) -> Option<Vec<InlayHint>> {
     let mut result = Vec::new();
@@ -300,21 +299,48 @@ fn build_local_name_hint(
     if !semantic_model.get_emmyrc().hint.local_hint {
         return Some(());
     }
+    // local function 不显示
+    if let Some(parent) = local_name.syntax().parent() {
+        if LuaLocalFuncStat::can_cast(parent.kind().into()) {
+            return Some(());
+        }
+        if LuaLocalStat::can_cast(parent.kind().into()) {
+            let local_stat = LuaLocalStat::cast(parent)?;
+            let local_names = local_stat.get_local_name_list();
+            for (i, ln) in local_names.enumerate() {
+                if local_name == ln {
+                    if let Some(value_expr) = local_stat.get_value_exprs().nth(i) {
+                        if let LuaExpr::ClosureExpr(_) = value_expr {
+                            return Some(());
+                        }
+                    }
+                }
+            }
+        }
+    }
 
     let typ = semantic_model
-        .get_semantic_info(NodeOrToken::Node(local_name.syntax().clone()))?
-        .typ
-        .clone();
+        .get_semantic_info(NodeOrToken::Token(
+            local_name.get_name_token()?.syntax().clone(),
+        ))?
+        .typ;
+
+    // 目前没时间完善结合 ast 的类型过滤, 所以只允许一些类型显示
+    match typ {
+        LuaType::Def(_) | LuaType::Ref(_) => {}
+        _ => {
+            return Some(());
+        }
+    }
 
     let document = semantic_model.get_document();
-    let db = semantic_model.get_db();
     let range = local_name.get_range();
     let lsp_range = document.to_lsp_range(range)?;
 
-    let typ_desc = humanize_type(db, &typ, RenderLevel::Simple);
+    let label_parts = build_label_parts(semantic_model, &typ);
     let hint = InlayHint {
         kind: Some(InlayHintKind::TYPE),
-        label: InlayHintLabel::String(format!(": {}", typ_desc)),
+        label: InlayHintLabel::LabelParts(label_parts),
         position: lsp_range.end,
         text_edits: None,
         tooltip: None,

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

@@ -54,4 +54,41 @@ mod tests {
         let location = extract_first_label_part_location(first).unwrap();
         assert!(location.uri.path().as_str().ends_with("builtin.lua"));
     }
+
+    #[test]
+    fn test_local_hint_1() {
+        let mut ws = ProviderVirtualWorkspace::new();
+        let result = ws
+            .check_inlay_hint(
+                r#"
+                local a = 1
+            "#,
+            )
+            .unwrap();
+        assert!(result.is_empty());
+    }
+
+    #[test]
+    fn test_local_hint_2() {
+        let mut ws = ProviderVirtualWorkspace::new();
+        let result = ws
+            .check_inlay_hint(
+                r#"
+                local function test()
+                end
+            "#,
+            )
+            .unwrap();
+        assert!(result.is_empty());
+
+        let result = ws
+            .check_inlay_hint(
+                r#"
+                local test = function()
+                end
+            "#,
+            )
+            .unwrap();
+        assert!(result.is_empty());
+    }
 }

crates/emmylua_ls/src/handlers/test_lib/mod.rs

@@ -315,7 +315,6 @@ impl ProviderVirtualWorkspace {
     pub fn check_inlay_hint(&mut self, block_str: &str) -> Option<Vec<InlayHint>> {
         let file_id = self.def(&block_str);
         let result = inlay_hint(&self.analysis, file_id);
-        dbg!(&result);
         return result;
     }
 }

crates/emmylua_parser/src/syntax/node/lua/stat.rs

@@ -215,7 +215,7 @@ impl LuaLocalStat {
         self.children()
     }
 
-    pub fn get_value_local_name(&self, value: LuaExpr) -> Option<LuaLocalName> {
+    pub fn get_local_name_by_value(&self, value: LuaExpr) -> Option<LuaLocalName> {
         let local_names = self.get_local_name_list();
         let value_exprs = self.get_value_exprs().collect::<Vec<_>>();