Merge pull request #648 from xuhuanzy/merge

update based on flow

Author: CppCXY

crates/emmylua_code_analysis/locales/lint.yml

@@ -268,3 +268,8 @@ Cannot use `...` outside a vararg function.:
 "Unknown doc tag: `%{name}`":
   en: "Unknown doc tag: `%{name}`"
   # TODO: translate
+
+"Value '%{value}' does not match any enum value. Expected one of: %{enum_values}":
+  en: "Value '%{value}' does not match any enum value. Expected one of: %{enum_values}"
+  zh_CN: "值 '%{value}' 与任何枚举值都不匹配。应为以下之一: %{enum_values}"
+  zh_HK: "值 '%{value}' 與任何枚舉值都不匹配。應為以下之一: %{enum_values}"

crates/emmylua_code_analysis/resources/schema.json

@@ -63,6 +63,7 @@
       "$ref": "#/$defs/EmmyrcInlayHint",
       "default": {
         "enable": true,
+        "enumParamHint": false,
         "indexHint": true,
         "localHint": true,
         "metaCallHint": true,
@@ -401,6 +402,11 @@
           "description": "require-module-not-visible",
           "type": "string",
           "const": "require-module-not-visible"
+        },
+        {
+          "description": "enum-value-mismatch",
+          "type": "string",
+          "const": "enum-value-mismatch"
         }
       ]
     },
@@ -632,6 +638,11 @@
           "type": "boolean",
           "default": true
         },
+        "enumParamHint": {
+          "description": "Whether to enable enum parameter hints.",
+          "type": "boolean",
+          "default": false
+        },
         "indexHint": {
           "description": "Whether to enable index hints.",
           "type": "boolean",

crates/emmylua_code_analysis/src/compilation/analyzer/doc/field_or_operator_def_tags.rs

@@ -144,6 +144,9 @@ pub fn analyze_field(analyzer: &mut DocAnalyzer, tag: LuaDocTagField) -> Option<
     }
 
     if !description.is_empty() {
+        // 不需要传入`owner`, 当前`owner`的效果是判断是否为`signature`, 如果是则不移除`['#', '@']`首字符
+        // 但以`field`定义的必须移除首字符
+        let description = preprocess_description(&description, None);
         analyzer.db.get_property_index_mut().add_description(
             analyzer.file_id,
             property_owner.clone(),

crates/emmylua_code_analysis/src/compilation/analyzer/doc/mod.rs

@@ -93,12 +93,12 @@ impl<'a> DocAnalyzer<'a> {
 }
 
 pub fn preprocess_description(mut description: &str, owner: Option<&LuaSemanticDeclId>) -> String {
-    let has_remove_start_char = if let Some(owner) = owner {
+    let need_remove_start_char = if let Some(owner) = owner {
         !matches!(owner, LuaSemanticDeclId::Signature(_))
     } else {
         true
     };
-    if has_remove_start_char {
+    if need_remove_start_char {
         if description.starts_with(['#', '@']) {
             description = description.trim_start_matches(|c| c == '#' || c == '@');
         }

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

@@ -155,6 +155,7 @@ pub fn infer_for_range_iter_expr_func(
         cache,
         substitutor: &mut substitutor,
         root: root,
+        call_expr: None,
     };
     let params = doc_function
         .get_params()

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

@@ -445,7 +445,10 @@ pub fn analyze_table_field(analyzer: &mut LuaAnalyzer, field: LuaTableField) ->
     let value_expr = field.get_value_expr()?;
     let member_id = LuaMemberId::new(field.get_syntax_id(), analyzer.file_id);
     let value_type = match analyzer.infer_expr(&value_expr.clone().into()) {
-        Ok(value_type) => value_type,
+        Ok(value_type) => match value_type {
+            LuaType::Def(ref_id) => LuaType::Ref(ref_id),
+            _ => value_type,
+        },
         Err(InferFailReason::None) => LuaType::Unknown,
         Err(reason) => {
             let unresolve = UnResolveMember {

crates/emmylua_code_analysis/src/compilation/test/annotation_test.rs

@@ -125,6 +125,66 @@ mod test {
         ));
     }
 
+    #[test]
+    fn test_generic_type_extends() {
+        let mut ws = VirtualWorkspace::new();
+        let mut emmyrc = ws.get_emmyrc();
+        emmyrc.runtime.class_default_call.force_non_colon = true;
+        emmyrc.runtime.class_default_call.force_return_self = true;
+        emmyrc.runtime.class_default_call.function_name = "__init".to_string();
+        ws.update_emmyrc(emmyrc);
+        ws.def(
+            r#"
+            ---@class State
+            ---@field a string
+
+            ---@class StateMachine<T: State>
+            ---@field aaa T
+            ---@field new fun(self: self): self
+            StateMachine = {}
+
+            ---@return self
+            function StateMachine:abc()
+            end
+
+            
+            ---@return self
+            function StateMachine:__init()
+            end
+            "#,
+        );
+        {
+            ws.def(
+                r#"
+            A = StateMachine:new()
+            "#,
+            );
+            let ty = ws.expr_ty("A");
+            let expected = ws.ty("StateMachine<State>");
+            assert_eq!(ty, expected);
+        }
+        {
+            ws.def(
+                r#"
+            B = StateMachine:abc()
+            "#,
+            );
+            let ty = ws.expr_ty("B");
+            let expected = ws.ty("StateMachine<State>");
+            assert_eq!(ty, expected);
+        }
+        {
+            ws.def(
+                r#"
+            C = StateMachine:abc()
+            "#,
+            );
+            let ty = ws.expr_ty("C");
+            let expected = ws.ty("StateMachine<State>");
+            assert_eq!(ty, expected);
+        }
+    }
+
     #[test]
     fn test_type_return_usage() {
         let mut ws = VirtualWorkspace::new();

crates/emmylua_code_analysis/src/compilation/test/flow.rs

@@ -1258,4 +1258,30 @@ end
             "#,
         ));
     }
+
+    #[test]
+    fn test_self_1() {
+        let mut ws = VirtualWorkspace::new();
+        ws.def(
+            r#"
+            ---@class Node
+            ---@field parent? Node 
+
+            ---@class Subject<T>: Node
+            ---@field package root? Node 
+            Subject = {}
+            "#,
+        );
+        ws.def(
+            r#"
+            function Subject:add()
+                if self == self.parent then
+                    A = self
+                end
+            end
+            "#,
+        );
+        let a = ws.expr_ty("A");
+        assert_eq!(ws.humanize_type(a), "Node");
+    }
 }

crates/emmylua_code_analysis/src/compilation/test/generic_test.rs

@@ -67,4 +67,33 @@ mod test {
         let expected = ws.ty("fun(b:string, c:table)");
         assert_eq!(bar_ty, expected);
     }
+
+    #[test]
+    fn test_generic_params() {
+        let mut ws = VirtualWorkspace::new();
+        ws.def(
+            r#"
+            ---@class Observable<T>
+            ---@class Subject<T>: Observable<T>
+
+            ---@generic T
+            ---@param ... Observable<T>
+            ---@return Observable<T>
+            function concat(...)
+            end
+            "#,
+        );
+
+        ws.def(
+            r#"
+            ---@type Subject<number>
+            local s1
+            A = concat(s1)
+            "#,
+        );
+
+        let a_ty = ws.expr_ty("A");
+        let expected = ws.ty("Observable<number>");
+        assert_eq!(a_ty, expected);
+    }
 }

crates/emmylua_code_analysis/src/config/configs/inlayhint.rs

@@ -23,6 +23,9 @@ pub struct EmmyrcInlayHint {
     /// Whether to enable meta __call operator hints.
     #[serde(default = "default_true")]
     pub meta_call_hint: bool,
+    /// Whether to enable enum parameter hints.
+    #[serde(default = "default_false")]
+    pub enum_param_hint: bool,
 }
 
 impl Default for EmmyrcInlayHint {
@@ -34,10 +37,15 @@ impl Default for EmmyrcInlayHint {
             local_hint: default_true(),
             override_hint: default_true(),
             meta_call_hint: default_true(),
+            enum_param_hint: default_false(),
         }
     }
 }
 
 fn default_true() -> bool {
     true
 }
+
+fn default_false() -> bool {
+    false
+}