change: 函数泛型返回值会将 def 转为 ref

Author: xuhuanzy

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

@@ -141,7 +141,10 @@ pub fn instantiate_doc_function(
         }
     }
 
-    let inst_ret_type = instantiate_type_generic(db, &tpl_ret, substitutor);
+    // 将 substitutor 中存储的类型的 def 转为 ref
+    let mut modified_substitutor = substitutor.clone();
+    modified_substitutor.convert_def_to_ref();
+    let inst_ret_type = instantiate_type_generic(db, &tpl_ret, &modified_substitutor);
     LuaType::DocFunction(
         LuaFunctionType::new(is_async, colon_define, new_params, inst_ret_type).into(),
     )

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

@@ -93,4 +93,31 @@ mod test {
         assert_eq!(b, expected_b);
         assert_eq!(c, expected_c);
     }
+
+    #[test]
+    fn test_return() {
+        let mut ws = crate::VirtualWorkspace::new();
+        ws.def(
+            r#"
+                ---@class ab
+                ---@field a number
+                local A
+
+                ---@generic T
+                ---@param a T
+                ---@return T
+                local function name(a)
+                    return a
+                end
+
+                local a = name(A)
+                a.b = 1
+                R = A.b
+        "#,
+        );
+
+        let a = ws.expr_ty("R");
+        let expected = ws.ty("any");
+        assert_eq!(a, expected);
+    }
 }

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

@@ -111,6 +111,31 @@ impl TypeSubstitutor {
     pub fn get_self_type(&self) -> Option<&LuaType> {
         self.self_type.as_ref()
     }
+
+    pub fn convert_def_to_ref(&mut self) {
+        for (_, value) in self.tpl_replace_map.iter_mut() {
+            match value {
+                SubstitutorValue::Type(ty) => {
+                    *ty = convert_type_def_to_ref(ty);
+                }
+                SubstitutorValue::Params(params) => {
+                    for (_, param_ty) in params.iter_mut() {
+                        if let Some(ty) = param_ty {
+                            *ty = convert_type_def_to_ref(ty);
+                        }
+                    }
+                }
+                _ => {}
+            }
+        }
+    }
+}
+
+fn convert_type_def_to_ref(ty: &LuaType) -> LuaType {
+    match ty {
+        LuaType::Def(type_decl_id) => LuaType::Ref(type_decl_id.clone()),
+        _ => ty.clone(),
+    }
 }
 
 #[derive(Debug, Clone)]