允予泛型约束来自前面的泛型

Author: xuhuanzy

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

@@ -20,18 +20,12 @@ impl FileGenericIndex {
         }
     }
 
-    pub fn add_generic_scope(
-        &mut self,
-        ranges: Vec<TextRange>,
-        params: Vec<GenericParam>,
-        is_func: bool,
-    ) {
-        let params_id = self.generic_params.len();
-        // 由于我们允许 infer 推断出一个虚拟泛型, 因此需要计算已声明的泛型数量确定其位置
+    pub fn add_generic_scope(&mut self, ranges: Vec<TextRange>, is_func: bool) -> GenericParamId {
+        let params_index = self.generic_params.len();
         let start = self.get_start(&ranges).unwrap_or(0);
         self.generic_params
-            .push(TagGenericParams::new(params, is_func, start));
-        let params_id = GenericParamId::new(params_id);
+            .push(TagGenericParams::new(is_func, start));
+        let params_id = GenericParamId::new(params_index);
         let root_node_ids: Vec<_> = self.root_node_ids.clone();
         for range in ranges {
             let mut added = false;
@@ -53,6 +47,33 @@ impl FileGenericIndex {
                 self.root_node_ids.push(GenericEffectId::new(child_node_id));
             }
         }
+
+        params_id
+    }
+
+    pub fn append_generic_param(&mut self, scope_id: GenericParamId, param: GenericParam) {
+        if let Some(scope) = self.generic_params.get_mut(scope_id.id) {
+            scope.insert_param(param);
+        }
+    }
+
+    pub fn append_generic_params(&mut self, scope_id: GenericParamId, params: Vec<GenericParam>) {
+        for param in params {
+            self.append_generic_param(scope_id, param);
+        }
+    }
+
+    pub fn set_param_constraint(
+        &mut self,
+        scope_id: GenericParamId,
+        name: &str,
+        constraint: Option<LuaType>,
+    ) {
+        if let Some(scope) = self.generic_params.get_mut(scope_id.id)
+            && let Some((_idx, stored_param)) = scope.params.get_mut(name)
+        {
+            stored_param.type_constraint = constraint;
+        }
     }
 
     fn get_start(&self, ranges: &[TextRange]) -> Option<usize> {
@@ -200,14 +221,22 @@ impl GenericEffectId {
 pub struct TagGenericParams {
     params: HashMap<String, (usize, GenericParam)>,
     is_func: bool,
+    next_index: usize,
 }
 
 impl TagGenericParams {
-    pub fn new(generic_params: Vec<GenericParam>, is_func: bool, start: usize) -> Self {
-        let mut params = HashMap::new();
-        for (i, param) in generic_params.into_iter().enumerate() {
-            params.insert(param.name.to_string(), (start + i, param));
+    pub fn new(is_func: bool, start: usize) -> Self {
+        Self {
+            params: HashMap::new(),
+            is_func,
+            next_index: start,
         }
-        Self { params, is_func }
+    }
+
+    fn insert_param(&mut self, param: GenericParam) {
+        let current_index = self.next_index;
+        self.next_index += 1;
+        self.params
+            .insert(param.name.to_string(), (current_index, param));
     }
 }

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

@@ -572,9 +572,12 @@ fn register_inline_func_generics(
         return;
     }
 
+    let scope_id = analyzer
+        .generic_index
+        .add_generic_scope(vec![func.get_range()], true);
     analyzer
         .generic_index
-        .add_generic_scope(vec![func.get_range()], generics, true);
+        .append_generic_params(scope_id, generics);
 }
 
 fn get_colon_define(analyzer: &mut DocAnalyzer) -> Option<bool> {
@@ -739,9 +742,12 @@ fn infer_conditional_type(
         if !infer_params.is_empty() {
             // 条件表达式中 infer 声明的类型参数只允许在`true`分支中使用
             let true_range = when_true.get_range();
+            let scope_id = analyzer
+                .generic_index
+                .add_generic_scope(vec![true_range], false);
             analyzer
                 .generic_index
-                .add_generic_scope(vec![true_range], infer_params.clone(), false);
+                .append_generic_params(scope_id, infer_params.clone());
         }
 
         // 处理条件和分支类型
@@ -788,11 +794,12 @@ fn infer_mapped_type(
         .map(|constraint| infer_type(analyzer, constraint));
     let param = GenericParam::new(SmolStr::new(name), constraint, None);
 
-    analyzer.generic_index.add_generic_scope(
-        vec![mapped_type.get_range()],
-        vec![param.clone()],
-        false,
-    );
+    let scope_id = analyzer
+        .generic_index
+        .add_generic_scope(vec![mapped_type.get_range()], false);
+    analyzer
+        .generic_index
+        .append_generic_param(scope_id, param.clone());
     let position = mapped_type.get_range().start();
     let (id, _) = analyzer.generic_index.find_generic(position, name)?;
 

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

@@ -20,6 +20,7 @@ use crate::{
     },
 };
 use std::sync::Arc;
+use std::vec;
 
 pub fn analyze_class(analyzer: &mut DocAnalyzer, tag: LuaDocTagClass) -> Option<()> {
     let file_id = analyzer.file_id;
@@ -149,9 +150,10 @@ pub fn analyze_alias(analyzer: &mut DocAnalyzer, tag: LuaDocTagAlias) -> Option<
             .get_type_index_mut()
             .add_generic_params(alias_decl_id.clone(), generic_params.clone());
         let range = analyzer.comment.get_range();
+        let scope_id = analyzer.generic_index.add_generic_scope(vec![range], false);
         analyzer
             .generic_index
-            .add_generic_scope(vec![range], generic_params, false);
+            .append_generic_params(scope_id, generic_params);
     }
 
     let origin_type = infer_type(analyzer, tag.get_type()?);
@@ -240,9 +242,10 @@ fn add_generic_index(
         }
     }
 
+    let scope_id = analyzer.generic_index.add_generic_scope(ranges, false);
     analyzer
         .generic_index
-        .add_generic_scope(ranges, generic_params, false);
+        .append_generic_params(scope_id, generic_params);
 }
 
 fn get_local_stat_reference_ranges(
@@ -334,37 +337,40 @@ pub fn analyze_func_generic(analyzer: &mut DocAnalyzer, tag: LuaDocTagGeneric) -
         report_orphan_tag(analyzer, &tag);
         return None;
     };
-    let mut params_result = vec![];
+
+    let scope_id = analyzer.generic_index.add_generic_scope(
+        vec![analyzer.comment.get_range(), comment_owner.get_range()],
+        true,
+    );
+
     let mut param_info = Vec::new();
     if let Some(params_list) = tag.get_generic_decl_list() {
         for param in params_list.get_generic_decl() {
-            let name = if let Some(param) = param.get_name_token() {
-                param.get_name_text().to_string()
-            } else {
+            let Some(name_token) = param.get_name_token() else {
                 continue;
             };
+            let name_text = name_token.get_name_text().to_string();
+            let smol_name = SmolStr::new(name_text.as_str());
+            analyzer
+                .generic_index
+                .append_generic_param(scope_id, GenericParam::new(smol_name.clone(), None, None));
+
             let type_ref = param
                 .get_type()
                 .map(|type_ref| infer_type(analyzer, type_ref));
 
-            params_result.push(GenericParam::new(
-                SmolStr::new(name.as_str()),
+            analyzer.generic_index.set_param_constraint(
+                scope_id,
+                name_text.as_str(),
                 type_ref.clone(),
-                None,
-            ));
-            param_info.push(Arc::new(LuaGenericParamInfo::new(name, type_ref, None)));
+            );
+
+            param_info.push(Arc::new(LuaGenericParamInfo::new(
+                name_text, type_ref, None,
+            )));
         }
     }
 
-    let mut ranges = Vec::new();
-    let range = analyzer.comment.get_range();
-    ranges.push(range);
-    let range = comment_owner.get_range();
-    ranges.push(range);
-    analyzer
-        .generic_index
-        .add_generic_scope(ranges, params_result, true);
-
     let closure = find_owner_closure(analyzer)?;
     let signature_id = LuaSignatureId::from_closure(analyzer.file_id, &closure);
     let signature = analyzer