Merge pull request #252 from xuhuanzy/diagnostic

diagnostic

Author: CppCXY

crates/emmylua_code_analysis/locales/lint.yml

@@ -101,10 +101,10 @@ tuple member %{idx} not match, expect %{typ}, but got %{got}:
   zh_CN: '元组成员 %{idx} 不匹配，期望 %{typ}，但得到 %{got}'
   zh_HK: '元組成員 %{idx} 不匹配，期望 %{typ}，但得到 %{got}'
 
-Annotations specify that return value %{index} has a type of `%{source}`, returning value of type `%{found}` here instead.:
-  en: Annotations specify that return value %{index} has a type of `%{source}`, returning value of type `%{found}` here instead.
-  zh_CN: '第 %{index} 个返回值的类型为 `%{source}`，但实际返回类型为 `%{found}`。'
-  zh_HK: '第 %{index} 個回傳值的類型為 `%{source}` ，但實際回傳的是 `%{found}`。'
+Annotations specify that return value %{index} has a type of `%{source}`, returning value of type `%{found}` here instead. %{reason}.:
+  en: Annotations specify that return value %{index} has a type of `%{source}`, returning value of type `%{found}` here instead. %{reason}.
+  zh_CN: '第 %{index} 个返回值的类型为 `%{source}`，但实际返回类型为 `%{found}`。 %{reason}。'
+  zh_HK: '第 %{index} 個回傳值的類型為 `%{source}` ，但實際回傳的是 `%{found}`。 %{reason}。'
 Annotations specify that at most %{max} return value(s) are required, found %{rmax} returned here instead.:
   en: 'Annotations specify that at most %{max} return value(s) are required, found %{rmax} returned here instead.'
   zh_CN: '最多只有 %{max} 个返回值，但此处返回了 %{rmax} 个'
@@ -217,3 +217,8 @@ Cannot use `...` outside a vararg function.:
   en: "type `%{name}` not found."
   zh_CN: "类型 `%{name}` 未找到。"
   zh_HK: "類型 `%{name}` 未找到。"
+"Duplicate class constructor '%{name}'. constructor must have only one.":
+  en: "Duplicate class constructor '%{name}'. constructor must have only one."
+  zh_CN: "类有重复的 (constructor) 定义 '%{name}'。(constructor) 必须只有一个。"
+  zh_HK: "類有重複的 (constructor) 定義 '%{name}'。(constructor) 必須只有一個。"
+

crates/emmylua_code_analysis/resources/std/coroutine.lua

@@ -19,7 +19,7 @@ coroutine = {}
 ---
 --- Creates a new coroutine, with body `f`. `f` must be a Lua function. Returns
 --- this new coroutine, an object with type `"thread"`.
----@param f async fun(...):...
+---@param f async fun(...):any...
 ---@return thread
 ---@nodiscard
 function coroutine.create(f) end
@@ -93,8 +93,8 @@ function coroutine.status(co) end
 --- passed to the function behave as the extra arguments to `resume`. Returns
 --- the same values returned by `resume`, except the first
 --- boolean. In case of error, propagates the error.
----@param f async fun(...):...
----@return fun(...):...
+---@param f async fun(...):any...
+---@return fun(...):any...
 ---@nodiscard
 function coroutine.wrap(f) end
 

crates/emmylua_code_analysis/resources/std/debug.lua

@@ -93,7 +93,7 @@ function debug.gethook(thread) end
 --- with a name for the current function, if a reasonable name can be found,
 --- and the expression `debug.getinfo(print)` returns a table with all available
 --- information about the `print` function.
----@overload fun(f: int|function, what?: InfoWhat):DebugInfo
+---@overload fun(f: int|function, what?: Infowhat):DebugInfo
 ---@param thread thread
 ---@param f function
 ---@param what? Infowhat

crates/emmylua_code_analysis/resources/std/os.lua

@@ -193,7 +193,7 @@ function os.setlocale(locale, category) end
 --- documented in the `os.date` function, so that they represent the same time
 --- as before the call but with values inside their valid ranges.
 ---@param date? std.osdateparam
----@return number
+---@return integer
 function os.time(date) end
 
 ---

crates/emmylua_code_analysis/resources/std/table.lua

@@ -98,10 +98,9 @@ function table.remove(list, pos) end
 ---
 --- The sort algorithm is not stable: elements considered equal by the given
 --- order may have their relative positions changed by the sort.
----@overload fun(list:table):integer
 ---@generic V
 ---@param list V[]
----@param comp fun(a:V, b:V):boolean
+---@param comp? fun(a:V, b:V):boolean
 ---@return integer
 function table.sort(list, comp) end
 

crates/emmylua_code_analysis/src/compilation/analyzer/decl/docs.rs

@@ -47,6 +47,9 @@ fn get_attrib_value(
                 "exact" => {
                     attr |= LuaTypeAttribute::Exact;
                 }
+                "constructor" => {
+                    attr |= LuaTypeAttribute::Constructor;
+                }
                 _ => {}
             }
         }

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

@@ -390,6 +390,10 @@ impl LuaModuleIndex {
         file_ids
     }
 
+    pub fn is_std(&self, file_id: &FileId) -> bool {
+        self.get_std_file_ids().contains(file_id)
+    }
+
     pub fn get_main_workspace_file_ids(&self) -> Vec<FileId> {
         let mut file_ids = Vec::new();
         for module_info in self.file_module_map.values() {

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

@@ -21,7 +21,8 @@ flags! {
         Key,
         Partial,
         Exact,
-        Meta
+        Meta,
+        Constructor,
     }
 }
 

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

@@ -43,13 +43,16 @@ fn check_duplicate_class(context: &mut DiagnosticContext, class_tag: LuaDocTagCl
     if locations.len() > 1 {
         let mut type_times = 0;
         let mut partial_times = 0;
+        let mut constructor_times = 0;
         for location in locations {
             let attrib = location.attrib;
             if attrib.contains(LuaTypeAttribute::Meta) {
                 continue;
             }
             if attrib.contains(LuaTypeAttribute::Partial) {
                 partial_times += 1;
+            } else if attrib.contains(LuaTypeAttribute::Constructor) {
+                constructor_times += 1;
             } else {
                 type_times += 1;
             }
@@ -70,6 +73,18 @@ fn check_duplicate_class(context: &mut DiagnosticContext, class_tag: LuaDocTagCl
                 None,
             );
         }
+        if constructor_times > 1 {
+            context.add_diagnostic(
+                DiagnosticCode::DuplicateType,
+                range,
+                t!(
+                    "Duplicate class constructor '%{name}'. constructor must have only one.",
+                    name = name
+                )
+                .to_string(),
+                None,
+            );
+        }
     }
 
     Some(())

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

@@ -1,9 +1,9 @@
-use emmylua_parser::{LuaAstNode, LuaClosureExpr, LuaReturnStat};
-use rowan::TextRange;
+use emmylua_parser::{LuaAstNode, LuaClosureExpr, LuaExpr, LuaReturnStat};
+use rowan::{NodeOrToken, TextRange};
 
 use crate::{
-    humanize_type, DiagnosticCode, LuaSignatureId, LuaType, RenderLevel, SemanticModel,
-    SignatureReturnStatus, TypeCheckFailReason, TypeCheckResult,
+    humanize_type, DiagnosticCode, LuaSemanticDeclId, LuaSignatureId, LuaType, RenderLevel,
+    SemanticModel, SignatureReturnStatus, TypeCheckFailReason, TypeCheckResult,
 };
 
 use super::{get_own_return_stats, Checker, DiagnosticContext};
@@ -49,7 +49,12 @@ fn check_return_stat(
             &return_stat.get_expr_list().collect::<Vec<_>>(),
             None,
         )?;
-        let return_expr_types = infos.iter().map(|(typ, _)| typ.clone()).collect::<Vec<_>>();
+        let mut return_expr_types = infos.iter().map(|(typ, _)| typ.clone()).collect::<Vec<_>>();
+        // 解决 setmetatable 的返回值类型问题
+        let setmetatable_index = has_setmetatable(semantic_model, return_stat);
+        if let Some(setmetatable_index) = setmetatable_index {
+            return_expr_types[setmetatable_index] = LuaType::Any;
+        }
         let return_expr_ranges = infos
             .iter()
             .map(|(_, range)| range.clone())
@@ -62,7 +67,6 @@ fn check_return_stat(
             if return_expr_types.len() < index {
                 break;
             }
-
             check_variadic_return_type_match(
                 context,
                 semantic_model,
@@ -136,25 +140,38 @@ fn add_type_check_diagnostic(
         Ok(_) => return,
         Err(reason) => match reason {
             TypeCheckFailReason::TypeNotMatchWithReason(reason) => {
-                context.add_diagnostic(DiagnosticCode::ParamTypeNotMatch, range, reason, None);
+                context.add_diagnostic(
+                    DiagnosticCode::ReturnTypeMismatch,
+                    range,
+                    t!(
+                        "Annotations specify that return value %{index} has a type of `%{source}`, returning value of type `%{found}` here instead. %{reason}.",
+                        index = index + 1,
+                        source = humanize_type(db, &param_type, RenderLevel::Simple),
+                        found = humanize_type(db, &expr_type, RenderLevel::Simple),
+                        reason = reason
+                    )
+                    .to_string(),
+                    None,
+                );
             }
             TypeCheckFailReason::TypeNotMatch => {
                 context.add_diagnostic(
                     DiagnosticCode::ReturnTypeMismatch,
                     range,
                     t!(
-                        "Annotations specify that return value %{index} has a type of `%{source}`, returning value of type `%{found}` here instead.",
+                        "Annotations specify that return value %{index} has a type of `%{source}`, returning value of type `%{found}` here instead. %{reason}.",
                         index = index + 1,
                         source = humanize_type(db, &param_type, RenderLevel::Simple),
-                        found = humanize_type(db, &expr_type, RenderLevel::Simple)
+                        found = humanize_type(db, &expr_type, RenderLevel::Simple),
+                        reason = ""
                     )
                     .to_string(),
                     None,
                 );
             }
             TypeCheckFailReason::TypeRecursion => {
                 context.add_diagnostic(
-                    DiagnosticCode::ParamTypeNotMatch,
+                    DiagnosticCode::ReturnTypeMismatch,
                     range,
                     "type recursion".into(),
                     None,
@@ -163,3 +180,31 @@ fn add_type_check_diagnostic(
         },
     }
 }
+
+fn has_setmetatable(semantic_model: &SemanticModel, return_stat: &LuaReturnStat) -> Option<usize> {
+    for (index, expr) in return_stat.get_expr_list().enumerate() {
+        if let LuaExpr::CallExpr(call_expr) = expr {
+            if let Some(prefix_expr) = call_expr.get_prefix_expr() {
+                let semantic_info = semantic_model
+                    .get_semantic_info(NodeOrToken::Node(prefix_expr.syntax().clone().into()))?;
+
+                if let Some(LuaSemanticDeclId::LuaDecl(decl_id)) = semantic_info.semantic_decl {
+                    let decl = semantic_model.get_db().get_decl_index().get_decl(&decl_id);
+
+                    if let Some(decl) = decl {
+                        if decl.is_global()
+                            && semantic_model
+                                .get_db()
+                                .get_module_index()
+                                .is_std(&decl.get_file_id())
+                            && decl.get_name() == "setmetatable"
+                        {
+                            return Some(index);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    None
+}

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

@@ -2,6 +2,26 @@
 mod test {
     use crate::{DiagnosticCode, VirtualWorkspace};
 
+    #[test]
+    fn test_issue_249() {
+        let mut ws = VirtualWorkspace::new();
+
+        assert!(ws.check_code_for(
+            DiagnosticCode::MissingParameter,
+            r#"
+            ---@param path string
+            ---@return string? realpath
+            ---@overload fun(path:string, callback:function):userdata
+            function realpath(path)
+            end
+
+            local path = realpath('/', function(err, path)
+            end)
+
+        "#
+        ));
+    }
+
     #[test]
     fn test_1() {
         let mut ws = VirtualWorkspace::new();

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

@@ -2,6 +2,43 @@
 mod tests {
     use crate::{DiagnosticCode, VirtualWorkspace};
 
+    #[test]
+    fn test_issue_242() {
+        let mut ws = VirtualWorkspace::new_with_init_std_lib();
+
+        assert!(ws.check_code_for_namespace(
+            DiagnosticCode::ReturnTypeMismatch,
+            r#"
+                local setmetatable = setmetatable
+                --- @class A
+                local A = {}
+
+                function A:method() end
+
+                --- @return A
+                function new()
+                return setmetatable({}, { __index = A })
+                end
+        "#
+        ));
+
+        assert!(ws.check_code_for_namespace(
+            DiagnosticCode::ReturnTypeMismatch,
+            r#"
+                --- @class A
+                local A = {}
+                A.__index = A
+
+                function A:method() end
+
+                --- @return A
+                function new()
+                return setmetatable({}, A)
+                end
+        "#
+        ));
+    }
+
     #[test]
     fn test_issue_220() {
         let mut ws = VirtualWorkspace::new();