Better support for the @module feature

CppCXY · CppCXY · commit 86ae47efba57 · 2025-11-12T14:58:44.000+08:00
Fix #842
diff --git a/crates/emmylua_code_analysis/src/compilation/analyzer/doc/mod.rs b/crates/emmylua_code_analysis/src/compilation/analyzer/doc/mod.rs
@@ -34,7 +34,6 @@ impl AnalysisPipeline for DocAnalysisPipeline {
                     &mut generic_index,
                     comment,
                     root.syntax().clone(),
-                    context,
                 );
                 analyze_comment(&mut analyzer);
             }
@@ -71,7 +70,6 @@ pub struct DocAnalyzer<'a> {
     comment: LuaComment,
     root: LuaSyntaxNode,
     is_meta: bool,
-    context: &'a mut AnalyzeContext,
 }
 
 impl<'a> DocAnalyzer<'a> {
@@ -81,7 +79,6 @@ impl<'a> DocAnalyzer<'a> {
         generic_index: &'a mut FileGenericIndex,
         comment: LuaComment,
         root: LuaSyntaxNode,
-        context: &'a mut AnalyzeContext,
     ) -> DocAnalyzer<'a> {
         let is_meta = db.get_module_index().is_meta_file(&file_id);
         DocAnalyzer {
@@ -92,7 +89,6 @@ impl<'a> DocAnalyzer<'a> {
             comment,
             root,
             is_meta,
-            context,
         }
     }
 }
diff --git a/crates/emmylua_code_analysis/src/compilation/analyzer/doc/type_ref_tags.rs b/crates/emmylua_code_analysis/src/compilation/analyzer/doc/type_ref_tags.rs
@@ -12,9 +12,9 @@ use super::{
     tags::{find_owner_closure, get_owner_id_or_report},
 };
 use crate::{
-    InFiled, InferFailReason, LuaOperatorMetaMethod, LuaTypeCache, LuaTypeOwner, OperatorFunction,
+    InFiled, LuaOperatorMetaMethod, LuaTypeCache, LuaTypeOwner, OperatorFunction,
     SignatureReturnStatus, TypeOps,
-    compilation::analyzer::{common::bind_type, unresolve::UnResolveModuleRef},
+    compilation::analyzer::common::bind_type,
     db_index::{
         LuaDeclId, LuaDocParamInfo, LuaDocReturnInfo, LuaMemberId, LuaOperator, LuaSemanticDeclId,
         LuaSignatureId, LuaType,
@@ -335,34 +335,23 @@ pub fn analyze_overload(analyzer: &mut DocAnalyzer, tag: LuaDocTagOverload) -> O
 pub fn analyze_module(analyzer: &mut DocAnalyzer, tag: LuaDocTagModule) -> Option<()> {
     let module_path = tag.get_string_token()?.get_value();
     let module_info = analyzer.db.get_module_index().find_module(&module_path)?;
-    let export_type = module_info.export_type.clone();
     let module_file_id = module_info.file_id;
     let owner_id = get_owner_id_or_report(analyzer, &tag)?;
-    if let Some(export_type) = export_type {
-        match &owner_id {
-            LuaSemanticDeclId::LuaDecl(decl_id) => {
-                analyzer.db.get_type_index_mut().bind_type(
-                    (*decl_id).into(),
-                    LuaTypeCache::DocType(export_type.clone()),
-                );
-            }
-            LuaSemanticDeclId::Member(member_id) => {
-                analyzer.db.get_type_index_mut().bind_type(
-                    (*member_id).into(),
-                    LuaTypeCache::DocType(export_type.clone()),
-                );
-            }
-            _ => {}
+    let module_ref = LuaType::ModuleRef(module_file_id);
+    match &owner_id {
+        LuaSemanticDeclId::LuaDecl(decl_id) => {
+            analyzer
+                .db
+                .get_type_index_mut()
+                .bind_type((*decl_id).into(), LuaTypeCache::DocType(module_ref));
         }
-    } else {
-        let unresolve = UnResolveModuleRef {
-            module_file_id,
-            owner_id,
-        };
-
-        analyzer
-            .context
-            .add_unresolve(unresolve.into(), InferFailReason::None);
+        LuaSemanticDeclId::Member(member_id) => {
+            analyzer
+                .db
+                .get_type_index_mut()
+                .bind_type((*member_id).into(), LuaTypeCache::DocType(module_ref));
+        }
+        _ => {}
     }
 
     Some(())
diff --git a/crates/emmylua_code_analysis/src/compilation/analyzer/unresolve/check_reason.rs b/crates/emmylua_code_analysis/src/compilation/analyzer/unresolve/check_reason.rs
@@ -44,6 +44,10 @@ pub fn check_reach_reason(
             let signature = db.get_signature_index().get(signature_id)?;
             Some(signature.is_resolve_return())
         }
+        InferFailReason::UnResolveModuleExport(file_id) => {
+            let module = db.get_module_index().get_module(*file_id)?;
+            Some(module.export_type.is_some())
+        }
     }
 }
 
@@ -104,6 +108,12 @@ pub fn resolve_as_any(db: &mut DbIndex, reason: &InferFailReason, loop_count: us
                 signature.resolve_return = SignatureReturnStatus::InferResolve;
             }
         }
+        InferFailReason::UnResolveModuleExport(file_id) => {
+            let module = db.get_module_index_mut().get_module_mut(*file_id)?;
+            if module.export_type.is_none() {
+                module.export_type = Some(LuaType::Any);
+            }
+        }
     }
 
     Some(())
diff --git a/crates/emmylua_code_analysis/src/compilation/test/module_annotation.rs b/crates/emmylua_code_analysis/src/compilation/test/module_annotation.rs
@@ -23,7 +23,6 @@ mod test {
         );
 
         let aaa_ty = ws.expr_ty("aaa");
-        let expected = ws.expr_ty("require('a')");
-        assert_eq!(aaa_ty, expected);
+        assert!(aaa_ty.is_module_ref());
     }
 }
diff --git a/crates/emmylua_code_analysis/src/db_index/type/humanize_type.rs b/crates/emmylua_code_analysis/src/db_index/type/humanize_type.rs
@@ -110,6 +110,17 @@ pub fn humanize_type(db: &DbIndex, ty: &LuaType, level: RenderLevel) -> String {
         LuaType::Conditional(c) => humanize_conditional_type(db, c, level),
         LuaType::ConditionalInfer(s) => s.to_string(),
         LuaType::Never => "never".to_string(),
+        LuaType::ModuleRef(file_id) => {
+            if let Some(module_info) = db.get_module_index().get_module(*file_id) {
+                humanize_type(
+                    db,
+                    &module_info.export_type.clone().unwrap_or(LuaType::Any),
+                    level,
+                )
+            } else {
+                "module 'unknown'".to_string()
+            }
+        }
         _ => "unknown".to_string(),
     }
 }
diff --git a/crates/emmylua_code_analysis/src/db_index/type/types.rs b/crates/emmylua_code_analysis/src/db_index/type/types.rs
@@ -493,6 +493,10 @@ impl LuaType {
             }
         }
     }
+
+    pub fn is_module_ref(&self) -> bool {
+        matches!(self, LuaType::ModuleRef(_))
+    }
 }
 
 impl TypeVisitTrait for LuaType {
diff --git a/crates/emmylua_code_analysis/src/semantic/infer/infer_fail_reason.rs b/crates/emmylua_code_analysis/src/semantic/infer/infer_fail_reason.rs
@@ -1,6 +1,6 @@
 use emmylua_parser::LuaExpr;
 
-use crate::{InFiled, LuaDeclId, LuaMemberId, LuaSignatureId};
+use crate::{FileId, InFiled, LuaDeclId, LuaMemberId, LuaSignatureId};
 
 #[derive(Debug, PartialEq, Eq, Clone, Hash)]
 pub enum InferFailReason {
@@ -12,6 +12,7 @@ pub enum InferFailReason {
     UnResolveDeclType(LuaDeclId),
     UnResolveMemberType(LuaMemberId),
     UnResolveOperatorCall,
+    UnResolveModuleExport(FileId),
 }
 
 impl InferFailReason {
@@ -24,6 +25,7 @@ impl InferFailReason {
                 | InferFailReason::UnResolveDeclType(_)
                 | InferFailReason::UnResolveMemberType(_)
                 | InferFailReason::UnResolveOperatorCall
+                | InferFailReason::UnResolveModuleExport(_)
         )
     }
 }
diff --git a/crates/emmylua_code_analysis/src/semantic/infer/infer_index.rs b/crates/emmylua_code_analysis/src/semantic/infer/infer_index.rs
@@ -189,6 +189,24 @@ pub fn infer_member_by_member_key(
         LuaType::Namespace(ns) => infer_namespace_member(db, cache, ns, index_expr),
         LuaType::Array(array_type) => infer_array_member(db, cache, array_type, index_expr),
         LuaType::TplRef(tpl) => infer_tpl_ref_member(db, cache, tpl, index_expr, infer_guard),
+        LuaType::ModuleRef(file_id) => {
+            let module_info = db.get_module_index().get_module(*file_id);
+            if let Some(module_info) = module_info {
+                if let Some(export_type) = &module_info.export_type {
+                    return infer_member_by_member_key(
+                        db,
+                        cache,
+                        export_type,
+                        index_expr,
+                        infer_guard,
+                    );
+                } else {
+                    return Err(InferFailReason::UnResolveModuleExport(*file_id));
+                }
+            }
+
+            Err(InferFailReason::FieldNotFound)
+        }
         _ => Err(InferFailReason::FieldNotFound),
     }
 }
@@ -818,6 +836,24 @@ pub fn infer_member_by_operator(
             let base = inst.get_base();
             infer_member_by_operator(db, cache, base, index_expr, infer_guard)
         }
+        LuaType::ModuleRef(file_id) => {
+            let module_info = db.get_module_index().get_module(*file_id);
+            if let Some(module_info) = module_info {
+                if let Some(export_type) = &module_info.export_type {
+                    return infer_member_by_operator(
+                        db,
+                        cache,
+                        export_type,
+                        index_expr,
+                        infer_guard,
+                    );
+                } else {
+                    return Err(InferFailReason::UnResolveModuleExport(*file_id));
+                }
+            }
+
+            Err(InferFailReason::FieldNotFound)
+        }
         _ => Err(InferFailReason::FieldNotFound),
     }
 }
diff --git a/crates/emmylua_code_analysis/src/semantic/member/find_index.rs b/crates/emmylua_code_analysis/src/semantic/member/find_index.rs
@@ -38,6 +38,16 @@ pub fn find_index_operations_guard(
             let base = inst.get_base();
             find_index_operations_guard(db, base, infer_guard)
         }
+        LuaType::ModuleRef(file_id) => {
+            let module_info = db.get_module_index().get_module(*file_id);
+            if let Some(module_info) = module_info
+                && let Some(export_type) = &module_info.export_type
+            {
+                return find_index_operations_guard(db, export_type, infer_guard);
+            }
+
+            None
+        }
         _ => None,
     }
 }
diff --git a/crates/emmylua_code_analysis/src/semantic/member/find_members.rs b/crates/emmylua_code_analysis/src/semantic/member/find_members.rs
@@ -95,6 +95,16 @@ fn find_members_guard(
         LuaType::Global => find_global_members(db, filter),
         LuaType::Instance(inst) => find_instance_members(db, inst, infer_guard, filter),
         LuaType::Namespace(ns) => find_namespace_members(db, ns, filter),
+        LuaType::ModuleRef(file_id) => {
+            let module_info = db.get_module_index().get_module(*file_id);
+            if let Some(module_info) = module_info
+                && let Some(export_type) = &module_info.export_type
+            {
+                return find_members_guard(db, export_type, infer_guard, filter);
+            }
+
+            None
+        }
         _ => None,
     }
 }
diff --git a/crates/emmylua_code_analysis/src/semantic/semantic_info/infer_expr_semantic_decl.rs b/crates/emmylua_code_analysis/src/semantic/semantic_info/infer_expr_semantic_decl.rs
@@ -283,6 +283,20 @@ fn infer_member_semantic_decl_by_member_key(
             semantic_guard.next_level()?,
         ),
         LuaType::Global => infer_global_member_semantic_decl_by_member_key(db, cache, member_key),
+        LuaType::ModuleRef(file_id) => {
+            let module_info = db.get_module_index().get_module(*file_id)?;
+            if let Some(export_type) = &module_info.export_type {
+                infer_member_semantic_decl_by_member_key(
+                    db,
+                    cache,
+                    export_type,
+                    member_key,
+                    semantic_guard.next_level()?,
+                )
+            } else {
+                None
+            }
+        }
         _ => None,
     }
 }
diff --git a/crates/emmylua_code_analysis/src/semantic/type_check/mod.rs b/crates/emmylua_code_analysis/src/semantic/type_check/mod.rs
@@ -167,6 +167,7 @@ fn check_general_type_compact(
             }
             Err(TypeCheckFailReason::TypeNotMatch)
         }
+        LuaType::ModuleRef(_) => Ok(()),
         _ => Err(TypeCheckFailReason::TypeNotMatch),
     }
 }
@@ -222,6 +223,12 @@ fn escape_type(db: &DbIndex, typ: &LuaType) -> Option<LuaType> {
             return Some(union);
         }
         LuaType::TypeGuard(_) => return Some(LuaType::Boolean),
+        LuaType::ModuleRef(file_id) => {
+            let module_info = db.get_module_index().get_module(*file_id)?;
+            if let Some(export_type) = &module_info.export_type {
+                return Some(export_type.clone());
+            }
+        }
         _ => {}
     }
 
diff --git a/crates/emmylua_ls/src/handlers/hover/build_hover.rs b/crates/emmylua_ls/src/handlers/hover/build_hover.rs
@@ -249,8 +249,12 @@ fn build_member_hover(
         } else {
             let member_hover_type =
                 get_hover_type(builder, builder.semantic_model).unwrap_or(typ.clone());
-            let type_humanize_text =
-                hover_humanize_type(builder, &member_hover_type, Some(RenderLevel::Simple));
+            let level = if member_hover_type.is_module_ref() {
+                builder.detail_render_level
+            } else {
+                RenderLevel::Simple
+            };
+            let type_humanize_text = hover_humanize_type(builder, &member_hover_type, Some(level));
             builder
                 .set_type_description(format!("(field) {}: {}", member_name, type_humanize_text));
             builder.set_location_path(Some(member));

Original file line number	Diff line number	Diff line change
`@@ -34,7 +34,6 @@ impl AnalysisPipeline for DocAnalysisPipeline {`
`34`	`34`	`&mut generic_index,`
`35`	`35`	`comment,`
`36`	`36`	`root.syntax().clone(),`
`37`		`- context,`
`38`	`37`	`);`
`39`	`38`	`analyze_comment(&mut analyzer);`
`40`	`39`	`}`
`@@ -71,7 +70,6 @@ pub struct DocAnalyzer<'a> {`
`71`	`70`	`comment: LuaComment,`
`72`	`71`	`root: LuaSyntaxNode,`
`73`	`72`	`is_meta: bool,`
`74`		`- context: &'a mut AnalyzeContext,`
`75`	`73`	`}`
`76`	`74`
`77`	`75`	`impl<'a> DocAnalyzer<'a> {`
`@@ -81,7 +79,6 @@ impl<'a> DocAnalyzer<'a> {`
`81`	`79`	`generic_index: &'a mut FileGenericIndex,`
`82`	`80`	`comment: LuaComment,`
`83`	`81`	`root: LuaSyntaxNode,`
`84`		`- context: &'a mut AnalyzeContext,`
`85`	`82`	`) -> DocAnalyzer<'a> {`
`86`	`83`	`let is_meta = db.get_module_index().is_meta_file(&file_id);`
`87`	`84`	`DocAnalyzer {`
`@@ -92,7 +89,6 @@ impl<'a> DocAnalyzer<'a> {`
`92`	`89`	`comment,`
`93`	`90`	`root,`
`94`	`91`	`is_meta,`
`95`		`- context,`
`96`	`92`	`}`
`97`	`93`	`}`
`98`	`94`	`}`
Original file line number	Diff line number	Diff line change
`@@ -44,6 +44,10 @@ pub fn check_reach_reason(`
`44`	`44`	`let signature = db.get_signature_index().get(signature_id)?;`
`45`	`45`	`Some(signature.is_resolve_return())`
`46`	`46`	`}`
	`47`	`+ InferFailReason::UnResolveModuleExport(file_id) => {`
	`48`	`+ let module = db.get_module_index().get_module(*file_id)?;`
	`49`	`+ Some(module.export_type.is_some())`
	`50`	`+ }`
`47`	`51`	`}`
`48`	`52`	`}`
`49`	`53`
`@@ -104,6 +108,12 @@ pub fn resolve_as_any(db: &mut DbIndex, reason: &InferFailReason, loop_count: us`
`104`	`108`	`signature.resolve_return = SignatureReturnStatus::InferResolve;`
`105`	`109`	`}`
`106`	`110`	`}`
	`111`	`+ InferFailReason::UnResolveModuleExport(file_id) => {`
	`112`	`+ let module = db.get_module_index_mut().get_module_mut(*file_id)?;`
	`113`	`+ if module.export_type.is_none() {`
	`114`	`+ module.export_type = Some(LuaType::Any);`
	`115`	`+ }`
	`116`	`+ }`
`107`	`117`	`}`
`108`	`118`
`109`	`119`	`Some(())`
Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,6 @@ mod test {`
`23`	`23`	`);`
`24`	`24`
`25`	`25`	`let aaa_ty = ws.expr_ty("aaa");`
`26`		`- let expected = ws.expr_ty("require('a')");`
`27`		`- assert_eq!(aaa_ty, expected);`
	`26`	`+ assert!(aaa_ty.is_module_ref());`
`28`	`27`	`}`
`29`	`28`	`}`
Original file line number	Diff line number	Diff line change
`@@ -493,6 +493,10 @@ impl LuaType {`
`493`	`493`	`}`
`494`	`494`	`}`
`495`	`495`	`}`
	`496`	`+`
	`497`	`+ pub fn is_module_ref(&self) -> bool {`
	`498`	`+ matches!(self, LuaType::ModuleRef(_))`
	`499`	`+ }`
`496`	`500`	`}`
`497`	`501`
`498`	`502`	`impl TypeVisitTrait for LuaType {`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`use emmylua_parser::LuaExpr;`
`2`	`2`
`3`		`-use crate::{InFiled, LuaDeclId, LuaMemberId, LuaSignatureId};`
	`3`	`+use crate::{FileId, InFiled, LuaDeclId, LuaMemberId, LuaSignatureId};`
`4`	`4`
`5`	`5`	`#[derive(Debug, PartialEq, Eq, Clone, Hash)]`
`6`	`6`	`pub enum InferFailReason {`
`@@ -12,6 +12,7 @@ pub enum InferFailReason {`
`12`	`12`	`UnResolveDeclType(LuaDeclId),`
`13`	`13`	`UnResolveMemberType(LuaMemberId),`
`14`	`14`	`UnResolveOperatorCall,`
	`15`	`+ UnResolveModuleExport(FileId),`
`15`	`16`	`}`
`16`	`17`
`17`	`18`	`impl InferFailReason {`
`@@ -24,6 +25,7 @@ impl InferFailReason {`
`24`	`25`	`\| InferFailReason::UnResolveDeclType(_)`
`25`	`26`	`\| InferFailReason::UnResolveMemberType(_)`
`26`	`27`	`\| InferFailReason::UnResolveOperatorCall`
	`28`	`+ \| InferFailReason::UnResolveModuleExport(_)`
`27`	`29`	`)`
`28`	`30`	`}`
`29`	`31`	`}`
Original file line number	Diff line number	Diff line change
`@@ -38,6 +38,16 @@ pub fn find_index_operations_guard(`
`38`	`38`	`let base = inst.get_base();`
`39`	`39`	`find_index_operations_guard(db, base, infer_guard)`
`40`	`40`	`}`
	`41`	`+ LuaType::ModuleRef(file_id) => {`
	`42`	`+ let module_info = db.get_module_index().get_module(*file_id);`
	`43`	`+ if let Some(module_info) = module_info`
	`44`	`+ && let Some(export_type) = &module_info.export_type`
	`45`	`+ {`
	`46`	`+ return find_index_operations_guard(db, export_type, infer_guard);`
	`47`	`+ }`
	`48`	`+`
	`49`	`+ None`
	`50`	`+ }`
`41`	`51`	`_ => None,`
`42`	`52`	`}`
`43`	`53`	`}`