refactor(generic ): header resolution and defer indexed alias calls

1. 同时移除了对 std.ConstTpl 的兼容性支持

Author: xuhuanzy

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

@@ -6,32 +6,6 @@ use std::sync::Arc;
 
 use crate::{GenericParam, GenericTpl, GenericTplId};
 
-pub trait GenericIndex: std::fmt::Debug {
-    fn add_generic_scope(&mut self, ranges: Vec<TextRange>, is_func: bool) -> GenericScopeId;
-
-    fn append_generic_param(
-        &mut self,
-        scope_id: GenericScopeId,
-        param: GenericParam,
-    ) -> Option<GenericTplId>;
-
-    fn append_generic_params(&mut self, scope_id: GenericScopeId, params: Vec<GenericParam>) {
-        for param in params {
-            let _ = self.append_generic_param(scope_id, param);
-        }
-    }
-
-    fn find_generic(&self, position: TextSize, name: &str) -> Option<(GenericTplId, GenericParam)>;
-
-    fn generic_param_mut(&mut self, tpl_id: GenericTplId) -> Option<&mut GenericParam>;
-
-    fn mark_generic_const(&mut self, tpl_id: GenericTplId) -> Option<GenericParam> {
-        let param = self.generic_param_mut(tpl_id)?;
-        param.is_const = true;
-        Some(param.clone())
-    }
-}
-
 #[derive(Debug, Clone)]
 pub struct FileGenericIndex {
     scopes: Vec<FileGenericScope>,
@@ -61,17 +35,18 @@ impl FileGenericIndex {
                 .sum(),
         )
     }
-}
-
-impl GenericIndex for FileGenericIndex {
-    fn add_generic_scope(&mut self, ranges: Vec<TextRange>, is_func: bool) -> GenericScopeId {
+    pub(super) fn add_generic_scope(
+        &mut self,
+        ranges: Vec<TextRange>,
+        is_func: bool,
+    ) -> GenericScopeId {
         let scope_id = GenericScopeId::new(self.scopes.len());
         let next_tpl_id = self.next_tpl_id(&ranges, is_func);
         self.scopes.push(FileGenericScope::new(ranges, next_tpl_id));
         scope_id
     }
 
-    fn append_generic_param(
+    pub(super) fn append_generic_param(
         &mut self,
         scope_id: GenericScopeId,
         param: GenericParam,
@@ -82,26 +57,50 @@ impl GenericIndex for FileGenericIndex {
         None
     }
 
+    pub(super) fn append_generic_params(
+        &mut self,
+        scope_id: GenericScopeId,
+        params: Vec<GenericParam>,
+    ) {
+        for param in params {
+            let _ = self.append_generic_param(scope_id, param);
+        }
+    }
+
     /// Find generic parameter by position and name.
-    fn find_generic(&self, position: TextSize, name: &str) -> Option<(GenericTplId, GenericParam)> {
+    pub(super) fn find_generic(
+        &self,
+        position: TextSize,
+        name: &str,
+    ) -> Option<(GenericTplId, GenericParam)> {
         for scope in self.scopes.iter().rev() {
             if !scope.contains(position) {
                 continue;
             }
 
-            if let Some((id, param)) = scope.params.get(name) {
+            if let Some((id, param)) = scope
+                .params
+                .iter()
+                .rev()
+                .find(|(_, param)| param.name == name)
+            {
                 return Some((*id, param.clone()));
             }
         }
 
         None
     }
 
-    fn generic_param_mut(&mut self, tpl_id: GenericTplId) -> Option<&mut GenericParam> {
+    pub(super) fn update_generic_param(
+        &mut self,
+        tpl_id: GenericTplId,
+        param: GenericParam,
+    ) -> Option<()> {
         for scope in self.scopes.iter_mut().rev() {
-            for (id, param) in scope.params.values_mut() {
+            for (id, current_param) in &mut scope.params {
                 if *id == tpl_id {
-                    return Some(param);
+                    *current_param = param;
+                    return Some(());
                 }
             }
         }
@@ -124,15 +123,15 @@ impl GenericScopeId {
 #[derive(Debug, Clone, PartialEq, Eq)]
 struct FileGenericScope {
     ranges: Vec<TextRange>,
-    params: HashMap<String, (GenericTplId, GenericParam)>,
+    params: Vec<(GenericTplId, GenericParam)>,
     next_tpl_id: GenericTplId,
 }
 
 impl FileGenericScope {
     fn new(ranges: Vec<TextRange>, next_tpl_id: GenericTplId) -> Self {
         Self {
             ranges,
-            params: HashMap::new(),
+            params: Vec::new(),
             next_tpl_id,
         }
     }
@@ -144,7 +143,7 @@ impl FileGenericScope {
     fn insert_param(&mut self, param: GenericParam) -> GenericTplId {
         let tpl_id = self.next_tpl_id;
         self.next_tpl_id = self.next_tpl_id.with_idx((tpl_id.get_idx() + 1) as u32);
-        self.params.insert(param.name.to_string(), (tpl_id, param));
+        self.params.push((tpl_id, param));
         tpl_id
     }
 

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

@@ -1,7 +1,7 @@
 use std::sync::Arc;
 
 use emmylua_parser::{
-    LuaAst, LuaAstNode, LuaClosureExpr, LuaComment, LuaDocBinaryType, LuaDocConditionalType,
+    LuaAst, LuaAstNode, LuaComment, LuaDocBinaryType, LuaDocConditionalType,
     LuaDocDescriptionOwner, LuaDocFuncType, LuaDocGenericDecl, LuaDocGenericDeclList,
     LuaDocGenericType, LuaDocIndexAccessType, LuaDocMappedType, LuaDocMultiLineUnionType,
     LuaDocObjectFieldKey, LuaDocObjectType, LuaDocStrTplType, LuaDocType, LuaDocUnaryType,
@@ -13,8 +13,8 @@ use smol_str::SmolStr;
 
 use crate::{
     AsyncState, DiagnosticCode, FileId, GenericParam, GenericTpl, InFiled, LuaAliasCallKind,
-    LuaArrayLen, LuaArrayType, LuaMultiLineUnion, LuaSignatureId, LuaTupleStatus, LuaTypeDeclId,
-    TypeOps, VariadicType, complete_type_generic_args,
+    LuaArrayLen, LuaArrayType, LuaMultiLineUnion, LuaTupleStatus, LuaTypeDeclId, TypeOps,
+    VariadicType, complete_type_generic_args,
     db_index::{
         AnalyzeError, DbIndex, LuaAliasCallType, LuaConditionalType, LuaFunctionType,
         LuaGenericType, LuaIndexAccessKey, LuaIntersectionType, LuaMappedType, LuaObjectType,
@@ -23,15 +23,15 @@ use crate::{
 };
 
 use super::{
-    file_generic_index::{ConditionalInferIndex, GenericIndex},
+    file_generic_index::{ConditionalInferIndex, FileGenericIndex},
     preprocess_description,
 };
 
 #[derive(Debug)]
 pub struct DocTypeAnalyzeContext<'a> {
     pub db: &'a mut DbIndex,
     pub file_id: FileId,
-    pub generic_index: &'a mut dyn GenericIndex,
+    pub generic_index: &'a mut FileGenericIndex,
     pub workspace_id: WorkspaceId,
     comment: Option<LuaComment>,
     options: DocTypeAnalyzeOptions,
@@ -70,7 +70,7 @@ impl<'a> DocTypeAnalyzeContext<'a> {
     pub fn new(
         db: &'a mut DbIndex,
         file_id: FileId,
-        generic_index: &'a mut dyn GenericIndex,
+        generic_index: &'a mut FileGenericIndex,
         workspace_id: WorkspaceId,
     ) -> Self {
         Self {
@@ -109,70 +109,6 @@ impl<'a> DocTypeAnalyzeContext<'a> {
                 .add_type_reference(self.file_id, type_id, range);
         }
     }
-
-    // TODO: 为`std.ConstTpl`实现的兼容性代码, 应在下一版本中移除
-    fn mark_generic_const(&mut self, tpl: &GenericTpl) -> GenericTpl {
-        let tpl_id = tpl.get_tpl_id();
-        let param = self
-            .generic_index
-            .mark_generic_const(tpl_id)
-            .unwrap_or_else(|| {
-                let mut param = tpl.get_param().clone();
-                param.is_const = true;
-                param
-            });
-
-        if tpl_id.is_func()
-            && let Some(signature_id) = self.current_signature_id()
-            && let Some(signature) = self.db.get_signature_index_mut().get_mut(&signature_id)
-        {
-            if let Some(signature_param) = signature.generic_params.get_mut(tpl_id.get_idx()) {
-                signature_param.is_const = true;
-            }
-
-            for overload in &mut signature.overloads {
-                let mut generic_params = overload.get_generic_params().to_vec();
-                let mut changed = false;
-                for generic_param in &mut generic_params {
-                    if generic_param.get_tpl_id() == tpl_id && !generic_param.is_const() {
-                        *generic_param = generic_param.with_const(true);
-                        changed = true;
-                    }
-                }
-
-                if changed {
-                    *overload = Arc::new(LuaFunctionType::new(
-                        overload.get_async_state(),
-                        overload.is_colon_define(),
-                        overload.is_variadic(),
-                        overload.get_params().to_vec(),
-                        overload.get_ret().clone(),
-                        Some(generic_params),
-                    ));
-                }
-            }
-        }
-
-        GenericTpl::new(
-            tpl_id,
-            param.name,
-            param.constraint,
-            param.default,
-            true,
-            param.attributes,
-        )
-    }
-
-    fn current_signature_id(&self) -> Option<LuaSignatureId> {
-        let owner = self.comment.as_ref()?.get_owner()?;
-        let closure = match owner {
-            LuaAst::LuaFuncStat(func) => func.get_closure(),
-            LuaAst::LuaLocalFuncStat(local_func) => local_func.get_closure(),
-            owner => owner.descendants::<LuaClosureExpr>().next(),
-        }?;
-
-        Some(LuaSignatureId::from_closure(self.file_id, &closure))
-    }
 }
 
 pub fn infer_type(analyzer: &mut DocTypeAnalyzeContext<'_>, node: LuaDocType) -> LuaType {
@@ -541,14 +477,6 @@ fn infer_special_generic_type(
 
             return Some(LuaType::TypeGuard(first_param.into()));
         }
-        "std.ConstTpl" => {
-            let first_doc_param_type = generic_type.get_generic_types()?.get_types().next()?;
-            let first_param = infer_type(analyzer, first_doc_param_type);
-            if let LuaType::TplRef(tpl) = first_param {
-                let const_tpl = analyzer.mark_generic_const(&tpl);
-                return Some(LuaType::TplRef(Arc::new(const_tpl)));
-            }
-        }
         "Language" => {
             let first_doc_param_type = generic_type.get_generic_types()?.get_types().next()?;
             let first_param = infer_type(analyzer, first_doc_param_type);
@@ -790,35 +718,52 @@ fn register_inline_func_generics(
         .generic_index
         .add_generic_scope(vec![func.get_range()], true);
     let mut generic_params = Vec::new();
-    for param in generic_list.get_generic_decl() {
-        let Some(name_token) = param.get_name_token() else {
+    let mut declared_params = Vec::new();
+    for generic_decl in generic_list.get_generic_decl() {
+        let Some(name_token) = generic_decl.get_name_token() else {
             continue;
         };
 
-        let constraint = param
+        let placeholder = GenericParam::new(
+            SmolStr::new(name_token.get_name_text()),
+            None,
+            None,
+            generic_decl.has_const_modifier(),
+            None,
+        );
+        if let Some(tpl_id) = analyzer
+            .generic_index
+            .append_generic_param(scope_id, placeholder.clone())
+        {
+            declared_params.push((tpl_id, generic_decl, placeholder.name));
+        }
+    }
+
+    for (tpl_id, generic_decl, name) in declared_params {
+        let constraint = generic_decl
             .get_constraint_type()
             .map(|ty| infer_type(analyzer, ty));
-        let default_type = param.get_default_type().map(|ty| infer_type(analyzer, ty));
+        let default_type = generic_decl
+            .get_default_type()
+            .map(|ty| infer_type(analyzer, ty));
         let generic_param = GenericParam::new(
-            SmolStr::new(name_token.get_name_text()),
+            name,
             constraint,
             default_type,
-            param.has_const_modifier(),
+            generic_decl.has_const_modifier(),
             None,
         );
-        if let Some(tpl_id) = analyzer
+        let _ = analyzer
             .generic_index
-            .append_generic_param(scope_id, generic_param.clone())
-        {
-            generic_params.push(GenericTpl::new(
-                tpl_id,
-                generic_param.name,
-                generic_param.constraint,
-                generic_param.default,
-                generic_param.is_const,
-                generic_param.attributes,
-            ));
-        }
+            .update_generic_param(tpl_id, generic_param.clone());
+        generic_params.push(GenericTpl::new(
+            tpl_id,
+            generic_param.name,
+            generic_param.constraint,
+            generic_param.default,
+            generic_param.is_const,
+            generic_param.attributes,
+        ));
     }
     generic_params
 }