fix typecheck: def/ref match Generic

Author: xuhuanzy

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

@@ -476,7 +476,7 @@ fn humanize_generic_type(db: &DbIndex, generic: &LuaGenericType, level: RenderLe
         None => return base_id.get_name().to_string(),
     };
 
-    let simple_name = type_decl.get_name();
+    let full_name = type_decl.get_full_name();
     match level {
         RenderLevel::Brief => {
             if type_decl.is_alias() {
@@ -501,7 +501,7 @@ fn humanize_generic_type(db: &DbIndex, generic: &LuaGenericType, level: RenderLe
         .collect::<Vec<_>>()
         .join(",");
 
-    format!("{}<{}>", simple_name, generic_params)
+    format!("{}<{}>", full_name, generic_params)
 }
 
 fn humanize_table_const_type_detail_and_simple(

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

@@ -4,8 +4,8 @@ use emmylua_parser::{
 use rowan::{NodeOrToken, TextRange};
 
 use crate::{
-    diagnostic::checker::assign_type_mismatch::check_table_expr, humanize_type, DiagnosticCode,
-    LuaSemanticDeclId, LuaSignatureId, LuaType, RenderLevel, SemanticDeclLevel, SemanticModel,
+    diagnostic::checker::{assign_type_mismatch::check_table_expr, humanize_lint_type},
+    DiagnosticCode, LuaSemanticDeclId, LuaSignatureId, LuaType, SemanticDeclLevel, SemanticModel,
     SignatureReturnStatus, TypeCheckFailReason, TypeCheckResult,
 };
 
@@ -127,6 +127,8 @@ fn check_return_stat(
             let return_expr_type = &return_expr_types[0];
             let return_expr_range = return_expr_ranges[0];
             let result = semantic_model.type_check(check_type, &return_expr_type);
+            dbg!(&check_type);
+            dbg!(&return_expr_type);
             if !result.is_ok() {
                 if return_expr_type.is_table() {
                     if let Some(return_expr) = return_exprs.get(0) {
@@ -160,34 +162,6 @@ fn check_return_stat(
     Some(())
 }
 
-// fn check_variadic_return_type_match(
-//     context: &mut DiagnosticContext,
-//     semantic_model: &SemanticModel,
-//     start_idx: usize,
-//     variadic_type: &LuaType,
-//     return_expr_types: &[LuaType],
-//     return_expr_ranges: &[TextRange],
-// ) {
-//     let mut idx = start_idx;
-//     for (return_expr_type, return_expr_range) in
-//         return_expr_types.iter().zip(return_expr_ranges.iter())
-//     {
-//         let result = semantic_model.type_check(variadic_type, return_expr_type);
-//         if !result.is_ok() {
-//             add_type_check_diagnostic(
-//                 context,
-//                 semantic_model,
-//                 start_idx + idx,
-//                 *return_expr_range,
-//                 variadic_type,
-//                 return_expr_type,
-//                 result,
-//             );
-//         }
-//         idx += 1;
-//     }
-// }
-
 fn add_type_check_diagnostic(
     context: &mut DiagnosticContext,
     semantic_model: &SemanticModel,
@@ -200,47 +174,28 @@ fn add_type_check_diagnostic(
     let db = semantic_model.get_db();
     match result {
         Ok(_) => return,
-        Err(reason) => match reason {
-            TypeCheckFailReason::TypeNotMatchWithReason(reason) => {
-                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. %{reason}",
-                        index = index + 1,
-                        source = humanize_type(db, &param_type, RenderLevel::Simple),
-                        found = humanize_type(db, &expr_type, RenderLevel::Simple),
-                        reason = ""
-                    )
-                    .to_string(),
-                    None,
-                );
-            }
-            TypeCheckFailReason::TypeRecursion => {
-                context.add_diagnostic(
-                    DiagnosticCode::ReturnTypeMismatch,
-                    range,
-                    "type recursion".into(),
-                    None,
-                );
-            }
-            TypeCheckFailReason::DonotCheck => {}
-        },
+        Err(reason) => {
+            let reason_message = match reason {
+                TypeCheckFailReason::TypeNotMatchWithReason(reason) => reason,
+                TypeCheckFailReason::TypeNotMatch | TypeCheckFailReason::DonotCheck => {
+                    "".to_string()
+                }
+                TypeCheckFailReason::TypeRecursion => "type recursion".to_string(),
+            };
+            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_lint_type(db, &param_type),
+                    found = humanize_lint_type(db, &expr_type),
+                    reason = reason_message
+                )
+                .to_string(),
+                None,
+            );
+        }
     }
 }
 

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

@@ -423,4 +423,27 @@ mod tests {
             "#
         ));
     }
+
+    #[test]
+    fn test_super_alias() {
+        let mut ws = VirtualWorkspace::new_with_init_std_lib();
+        assert!(ws.check_code_for(
+            DiagnosticCode::ReturnTypeMismatch,
+            r#"
+                ---@namespace Test
+
+                ---@alias A fun()
+
+                ---@class B<T>: A
+
+                ---@return A
+                local function subscribe()
+                    ---@type B<string>
+                    local a
+
+                    return a
+                end
+            "#
+        ));
+    }
 }

crates/emmylua_code_analysis/src/semantic/type_check/ref_type.rs

@@ -27,12 +27,16 @@ pub fn check_ref_type_compact(
 
     if type_decl.is_alias() {
         if let Some(origin_type) = type_decl.get_alias_origin(db, None) {
-            return check_general_type_compact(
+            let result = check_general_type_compact(
                 db,
                 &origin_type,
                 compact_type,
                 check_guard.next_level()?,
             );
+            if result.is_err() && origin_type.is_function() {
+                return check_ref_class(db, source_id, compact_type, check_guard);
+            }
+            return result;
         }
 
         return Err(TypeCheckFailReason::TypeNotMatch);
@@ -176,6 +180,17 @@ fn check_ref_class(
         LuaType::Tuple(tuple_type) => {
             check_ref_type_compact_tuple(db, tuple_type, source_id, check_guard.next_level()?)
         }
+        LuaType::Generic(generic) => {
+            let base_type_id = generic.get_base_type_id();
+            if source_id == &base_type_id
+                || is_sub_type_of(db, &base_type_id, source_id)
+                || is_sub_type_of(db, source_id, &base_type_id)
+            {
+                Ok(())
+            } else {
+                Err(TypeCheckFailReason::TypeNotMatch)
+            }
+        }
         _ => {
             if let Some(base_type_id) = get_base_type_id(compact_type) {
                 if source_id == &base_type_id