update infer generic constraint

Author: xuhuanzy

crates/emmylua_code_analysis/src/db_index/signature/signature.rs

@@ -292,19 +292,19 @@ pub enum SignatureReturnStatus {
 #[derive(Debug, Clone)]
 pub struct LuaGenericParamInfo {
     pub name: String,
-    pub type_constraint: Option<LuaType>,
+    pub constraint: Option<LuaType>,
     pub attributes: Option<Vec<LuaAttributeUse>>,
 }
 
 impl LuaGenericParamInfo {
     pub fn new(
         name: String,
-        type_constraint: Option<LuaType>,
+        constraint: Option<LuaType>,
         attributes: Option<Vec<LuaAttributeUse>>,
     ) -> Self {
         Self {
             name,
-            type_constraint,
+            constraint,
             attributes,
         }
     }

crates/emmylua_code_analysis/src/diagnostic/checker/generic/generic_constraint_mismatch.rs

@@ -1,15 +1,14 @@
-use emmylua_parser::{LuaAst, LuaAstNode, LuaCallExpr, LuaDocTagType};
+use emmylua_parser::{LuaAst, LuaAstNode, LuaAstToken, LuaCallExpr, LuaDocTagType};
 use rowan::TextRange;
 
 use crate::diagnostic::{checker::Checker, lua_diagnostic::DiagnosticContext};
 use crate::semantic::{
     CallConstraintContext, build_call_constraint_context, normalize_constraint_type,
 };
 use crate::{
-    DiagnosticCode, DocTypeInferContext, GenericTplId, LuaMemberOwner, LuaSemanticDeclId,
-    LuaSignature, LuaStringTplType, LuaType, RenderLevel, SemanticDeclLevel, SemanticModel,
-    TypeCheckFailReason, TypeCheckResult, TypeSubstitutor, humanize_type, infer_doc_type,
-    instantiate_type_generic,
+    DiagnosticCode, DocTypeInferContext, LuaStringTplType, LuaType, RenderLevel, SemanticModel,
+    TypeCheckFailReason, TypeCheckResult, TypeSubstitutor, VariadicType, humanize_type,
+    infer_doc_type, instantiate_type_generic,
 };
 
 pub struct GenericConstraintMismatchChecker;
@@ -38,47 +37,72 @@ fn check_call_expr(
     semantic_model: &SemanticModel,
     call_expr: LuaCallExpr,
 ) -> Option<()> {
-    let function = semantic_model
-        .infer_expr(call_expr.get_prefix_expr()?.clone())
-        .ok()?;
-    if let LuaType::Signature(signature_id) = function {
-        let signature = semantic_model
-            .get_db()
-            .get_signature_index()
-            .get(&signature_id)?;
-        let Some(CallConstraintContext {
+    let Some((
+        CallConstraintContext {
             params,
             arg_infos,
             substitutor,
-        }) = build_call_constraint_context(semantic_model, &call_expr, signature)
-        else {
-            return Some(());
-        };
+        },
+        doc_func,
+    )) = build_call_constraint_context(semantic_model, &call_expr)
+    else {
+        return Some(());
+    };
 
-        for (i, (_, param_type)) in params.iter().enumerate() {
-            let param_type = if let Some(param_type) = param_type {
-                param_type
-            } else {
-                continue;
-            };
+    let mut arg_ranges = collect_arg_ranges(semantic_model, &call_expr);
+    if call_expr.is_colon_call() && !doc_func.is_colon_define() {
+        let colon_range = call_expr.get_colon_token()?.get_range();
+        arg_ranges.insert(0, colon_range);
+    }
 
-            check_param(
-                context,
-                semantic_model,
-                &call_expr,
-                i,
-                param_type,
-                signature,
-                &arg_infos,
-                false,
-                &substitutor,
-            );
-        }
+    for (i, (_, param_type)) in params.iter().enumerate() {
+        let param_type = if let Some(param_type) = param_type {
+            param_type
+        } else {
+            continue;
+        };
+
+        check_param(
+            context,
+            semantic_model,
+            &call_expr,
+            i,
+            param_type,
+            &arg_infos,
+            &arg_ranges,
+            false,
+            &substitutor,
+        );
     }
 
     Some(())
 }
 
+fn collect_arg_ranges(semantic_model: &SemanticModel, call_expr: &LuaCallExpr) -> Vec<TextRange> {
+    let Some(arg_list) = call_expr.get_args_list() else {
+        return Vec::new();
+    };
+    let arg_exprs = arg_list.get_args().collect::<Vec<_>>();
+    let mut ranges = Vec::new();
+    for expr in arg_exprs {
+        let expr_type = semantic_model
+            .infer_expr(expr.clone())
+            .unwrap_or(LuaType::Unknown);
+        match expr_type {
+            LuaType::Variadic(variadic) => match variadic.as_ref() {
+                VariadicType::Base(_) => ranges.push(expr.get_range()),
+                VariadicType::Multi(values) => {
+                    for _ in values {
+                        ranges.push(expr.get_range());
+                    }
+                }
+            },
+            _ => ranges.push(expr.get_range()),
+        }
+    }
+    ranges
+}
+
 fn check_doc_tag_type(
     context: &mut DiagnosticContext,
     semantic_model: &SemanticModel,
@@ -122,31 +146,20 @@ fn check_param(
     call_expr: &LuaCallExpr,
     param_index: usize,
     param_type: &LuaType,
-    signature: &LuaSignature,
-    arg_infos: &[(LuaType, TextRange)],
+    arg_infos: &[LuaType],
+    arg_ranges: &[TextRange],
     from_union: bool,
     substitutor: &TypeSubstitutor,
 ) -> Option<()> {
     // 应该先通过泛型体操约束到唯一类型再进行检查
     match param_type {
         LuaType::StrTplRef(str_tpl_ref) => {
-            let extend_type = str_tpl_ref
-                .get_constraint()
-                .cloned()
-                .or_else(|| {
-                    get_extend_type(
-                        semantic_model,
-                        call_expr,
-                        str_tpl_ref.get_tpl_id(),
-                        signature,
-                    )
-                })
-                .map(|ty| {
-                    normalize_constraint_type(
-                        semantic_model.get_db(),
-                        instantiate_type_generic(semantic_model.get_db(), &ty, substitutor),
-                    )
-                });
+            let extend_type = str_tpl_ref.get_constraint().cloned().map(|ty| {
+                normalize_constraint_type(
+                    semantic_model.get_db(),
+                    instantiate_type_generic(semantic_model.get_db(), &ty, substitutor),
+                )
+            });
             let arg_expr = call_expr.get_args_list()?.get_args().nth(param_index)?;
             let arg_type = semantic_model.infer_expr(arg_expr.clone()).ok()?;
 
@@ -164,24 +177,15 @@ fn check_param(
             );
         }
         LuaType::TplRef(tpl_ref) | LuaType::ConstTplRef(tpl_ref) => {
-            let extend_type = tpl_ref
-                .get_constraint()
-                .cloned()
-                .or_else(|| {
-                    get_extend_type(semantic_model, call_expr, tpl_ref.get_tpl_id(), signature)
-                })
-                .map(|ty| {
-                    normalize_constraint_type(
-                        semantic_model.get_db(),
-                        instantiate_type_generic(semantic_model.get_db(), &ty, substitutor),
-                    )
-                });
-            validate_tpl_ref(
-                context,
-                semantic_model,
-                &extend_type,
-                arg_infos.get(param_index),
-            );
+            let extend_type = tpl_ref.get_constraint().cloned().map(|ty| {
+                normalize_constraint_type(
+                    semantic_model.get_db(),
+                    instantiate_type_generic(semantic_model.get_db(), &ty, substitutor),
+                )
+            });
+            let arg_type = arg_infos.get(param_index);
+            let arg_range = arg_ranges.get(param_index).copied();
+            validate_tpl_ref(context, semantic_model, &extend_type, arg_type, arg_range);
         }
         LuaType::Union(union_type) => {
             // 如果不是来自 union, 才展开 union 中的每个类型进行检查
@@ -193,8 +197,8 @@ fn check_param(
                         call_expr,
                         param_index,
                         union_member_type,
-                        signature,
                         arg_infos,
+                        arg_ranges,
                         true,
                         substitutor,
                     );
@@ -206,45 +210,6 @@ fn check_param(
     Some(())
 }
 
-fn get_extend_type(
-    semantic_model: &SemanticModel,
-    call_expr: &LuaCallExpr,
-    tpl_id: GenericTplId,
-    signature: &LuaSignature,
-) -> Option<LuaType> {
-    match tpl_id {
-        GenericTplId::Func(tpl_id) => signature
-            .generic_params
-            .get(tpl_id as usize)?
-            .type_constraint
-            .clone(),
-        GenericTplId::Type(tpl_id) => {
-            let prefix_expr = call_expr.get_prefix_expr()?;
-            let semantic_decl = semantic_model.find_decl(
-                prefix_expr.syntax().clone().into(),
-                SemanticDeclLevel::default(),
-            )?;
-            let member_index = semantic_model.get_db().get_member_index();
-            match semantic_decl {
-                LuaSemanticDeclId::Member(member_id) => {
-                    let owner = member_index.get_current_owner(&member_id)?;
-                    match owner {
-                        LuaMemberOwner::Type(type_id) => {
-                            let generic_params = semantic_model
-                                .get_db()
-                                .get_type_index()
-                                .get_generic_params(type_id)?;
-                            generic_params.get(tpl_id as usize)?.type_constraint.clone()
-                        }
-                        _ => None,
-                    }
-                }
-                _ => None,
-            }
-        }
-    }
-}
-
 fn validate_str_tpl_ref(
     context: &mut DiagnosticContext,
     semantic_model: &SemanticModel,
@@ -309,18 +274,20 @@ fn validate_tpl_ref(
     context: &mut DiagnosticContext,
     semantic_model: &SemanticModel,
     extend_type: &Option<LuaType>,
-    arg_info: Option<&(LuaType, TextRange)>,
+    arg_type: Option<&LuaType>,
+    range: Option<TextRange>,
 ) -> Option<()> {
     let extend_type = extend_type.clone()?;
-    let arg_info = arg_info?;
-    let result = semantic_model.type_check_detail(&extend_type, &arg_info.0);
+    let arg_type = arg_type?;
+    let range = range?;
+    let result = semantic_model.type_check_detail(&extend_type, arg_type);
     if result.is_err() {
         add_type_check_diagnostic(
             context,
             semantic_model,
-            arg_info.1,
+            range,
             &extend_type,
-            &arg_info.0,
+            arg_type,
             result,
         );
     }