Merge pull request #604 from xuhuanzy/merge

update merge

Author: CppCXY

crates/emmylua_code_analysis/locales/lint.yml

@@ -260,4 +260,8 @@ Cannot use `...` outside a vararg function.:
 "type recursion":
   en: "type recursion"
   zh_CN: "类型递归"
-  zh_HK: "類型遞歸"
+  zh_HK: "類型遞歸"
+"Module '%{module}' is not visible. It has @export restrictions.":
+  en: "Module '%{module}' is not visible. It has @export restrictions."
+  zh_CN: "模块 '%{module}' 不可见。它有 @export 限制。"
+  zh_HK: "模組 '%{module}' 不可見。它有 @export 限制。"

crates/emmylua_code_analysis/resources/schema.json

@@ -46,6 +46,12 @@
         "severity": {}
       }
     },
+    "doc": {
+      "$ref": "#/$defs/EmmyrcDoc",
+      "default": {
+        "privateName": []
+      }
+    },
     "documentColor": {
       "$ref": "#/$defs/EmmyrcDocumentColor",
       "default": {
@@ -384,6 +390,11 @@
           "description": "cast-type-mismatch",
           "type": "string",
           "const": "cast-type-mismatch"
+        },
+        {
+          "description": "require-module-not-visible",
+          "type": "string",
+          "const": "require-module-not-visible"
         }
       ]
     },
@@ -537,6 +548,19 @@
         }
       }
     },
+    "EmmyrcDoc": {
+      "type": "object",
+      "properties": {
+        "privateName": {
+          "description": "Treat specific field names as private, e.g. `m_*` means `XXX.m_id` and `XXX.m_type` are private, witch can only be accessed in the class where the definition is located.",
+          "type": "array",
+          "default": [],
+          "items": {
+            "type": "string"
+          }
+        }
+      }
+    },
     "EmmyrcDocumentColor": {
       "type": "object",
       "properties": {

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

@@ -215,6 +215,14 @@ fn infer_generic_type(analyzer: &mut DocAnalyzer, generic_type: &LuaDocGenericTy
             {
                 name_type_decl.get_id()
             } else {
+                analyzer.db.get_diagnostic_index_mut().add_diagnostic(
+                    analyzer.file_id,
+                    AnalyzeError::new(
+                        DiagnosticCode::TypeNotFound,
+                        &t!("Type '%{name}' not found", name = name),
+                        generic_type.get_range(),
+                    ),
+                );
                 return LuaType::Unknown;
             };
 
@@ -228,6 +236,13 @@ fn infer_generic_type(analyzer: &mut DocAnalyzer, generic_type: &LuaDocGenericTy
                     generic_params.push(param_type);
                 }
             }
+            if let Some(name_type) = generic_type.get_name_type() {
+                analyzer.db.get_reference_index_mut().add_type_reference(
+                    analyzer.file_id,
+                    id.clone(),
+                    name_type.get_range(),
+                );
+            }
 
             return LuaType::Generic(LuaGenericType::new(id, generic_params).into());
         }

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

@@ -1,12 +1,14 @@
-use crate::{LuaNoDiscard, LuaSignatureId};
+use crate::{
+    LuaDeclId, LuaExport, LuaExportScope, LuaNoDiscard, LuaSemanticDeclId, LuaSignatureId,
+};
 
 use super::{
     tags::{find_owner_closure, get_owner_id},
     DocAnalyzer,
 };
 use emmylua_parser::{
-    LuaDocDescriptionOwner, LuaDocTagDeprecated, LuaDocTagNodiscard, LuaDocTagSource,
-    LuaDocTagVersion, LuaDocTagVisibility,
+    LuaAst, LuaAstNode, LuaDocDescriptionOwner, LuaDocTagDeprecated, LuaDocTagExport,
+    LuaDocTagNodiscard, LuaDocTagSource, LuaDocTagVersion, LuaDocTagVisibility, LuaTableExpr,
 };
 
 pub fn analyze_visibility(
@@ -110,3 +112,38 @@ pub fn analyze_async(analyzer: &mut DocAnalyzer) -> Option<()> {
 
     Some(())
 }
+
+pub fn analyze_export(analyzer: &mut DocAnalyzer, tag: LuaDocTagExport) -> Option<()> {
+    let owner = analyzer.comment.get_owner()?;
+    let owner_id = match owner {
+        LuaAst::LuaReturnStat(return_stat) => {
+            let return_table_expr = return_stat.child::<LuaTableExpr>()?;
+            LuaSemanticDeclId::LuaDecl(LuaDeclId::new(
+                analyzer.file_id,
+                return_table_expr.get_position(),
+            ))
+        }
+        _ => get_owner_id(analyzer)?,
+    };
+
+    let export_scope = if let Some(scope_text) = tag.get_export_scope() {
+        match scope_text.as_str() {
+            "namespace" => LuaExportScope::Namespace,
+            "global" => LuaExportScope::Global,
+            _ => LuaExportScope::Global, // 默认为 global
+        }
+    } else {
+        LuaExportScope::Global // 没有参数时默认为 global
+    };
+
+    let export = LuaExport {
+        scope: export_scope,
+    };
+
+    analyzer
+        .db
+        .get_property_index_mut()
+        .add_export(analyzer.file_id, owner_id, export);
+
+    Some(())
+}

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

@@ -11,8 +11,8 @@ use super::{
     diagnostic_tags::analyze_diagnostic,
     field_or_operator_def_tags::{analyze_field, analyze_operator},
     property_tags::{
-        analyze_async, analyze_deprecated, analyze_nodiscard, analyze_source, analyze_version,
-        analyze_visibility,
+        analyze_async, analyze_deprecated, analyze_export, analyze_nodiscard, analyze_source,
+        analyze_version, analyze_visibility,
     },
     type_def_tags::{analyze_alias, analyze_class, analyze_enum, analyze_func_generic},
     type_ref_tags::{
@@ -104,6 +104,9 @@ pub fn analyze_tag(analyzer: &mut DocAnalyzer, tag: LuaDocTag) -> Option<()> {
         LuaDocTag::Other(other) => {
             analyze_other(analyzer, other)?;
         }
+        LuaDocTag::Export(export) => {
+            analyze_export(analyzer, export)?;
+        }
         _ => {}
     }
 

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

@@ -23,6 +23,12 @@ use super::{
 };
 
 pub fn analyze_type(analyzer: &mut DocAnalyzer, tag: LuaDocTagType) -> Option<()> {
+    let description = if let Some(des) = tag.get_description() {
+        Some(preprocess_description(&des.get_description_text(), None))
+    } else {
+        None
+    };
+
     let mut type_list = Vec::new();
     for lua_doc_type in tag.get_type_list() {
         let type_ref = infer_type(analyzer, lua_doc_type);
@@ -48,6 +54,17 @@ pub fn analyze_type(analyzer: &mut DocAnalyzer, tag: LuaDocTagType) -> Option<()
                             .db
                             .get_type_index_mut()
                             .bind_type(decl_id.into(), LuaTypeCache::DocType(type_ref.clone()));
+
+                        // bind description
+                        if let Some(ref desc) = description {
+                            if !desc.is_empty() {
+                                analyzer.db.get_property_index_mut().add_description(
+                                    analyzer.file_id,
+                                    LuaSemanticDeclId::LuaDecl(decl_id),
+                                    desc.clone(),
+                                );
+                            }
+                        }
                     }
                     LuaVarExpr::IndexExpr(index_expr) => {
                         let member_id =
@@ -56,6 +73,17 @@ pub fn analyze_type(analyzer: &mut DocAnalyzer, tag: LuaDocTagType) -> Option<()
                             .db
                             .get_type_index_mut()
                             .bind_type(member_id.into(), LuaTypeCache::DocType(type_ref.clone()));
+
+                        // bind description
+                        if let Some(ref desc) = description {
+                            if !desc.is_empty() {
+                                analyzer.db.get_property_index_mut().add_description(
+                                    analyzer.file_id,
+                                    LuaSemanticDeclId::Member(member_id),
+                                    desc.clone(),
+                                );
+                            }
+                        }
                     }
                 }
             }
@@ -75,6 +103,17 @@ pub fn analyze_type(analyzer: &mut DocAnalyzer, tag: LuaDocTagType) -> Option<()
                     .db
                     .get_type_index_mut()
                     .bind_type(decl_id.into(), LuaTypeCache::DocType(type_ref.clone()));
+
+                // bind description
+                if let Some(ref desc) = description {
+                    if !desc.is_empty() {
+                        analyzer.db.get_property_index_mut().add_description(
+                            analyzer.file_id,
+                            LuaSemanticDeclId::LuaDecl(decl_id),
+                            desc.clone(),
+                        );
+                    }
+                }
             }
         }
         LuaAst::LuaTableField(table_field) => {
@@ -85,6 +124,17 @@ pub fn analyze_type(analyzer: &mut DocAnalyzer, tag: LuaDocTagType) -> Option<()
                     .db
                     .get_type_index_mut()
                     .bind_type(member_id.into(), LuaTypeCache::DocType(first_type.clone()));
+
+                // bind description
+                if let Some(ref desc) = description {
+                    if !desc.is_empty() {
+                        analyzer.db.get_property_index_mut().add_description(
+                            analyzer.file_id,
+                            LuaSemanticDeclId::Member(member_id),
+                            desc.clone(),
+                        );
+                    }
+                }
             }
         }
         _ => {}

crates/emmylua_code_analysis/src/compilation/analyzer/lua/module.rs

@@ -2,7 +2,7 @@ use emmylua_parser::{LuaAstNode, LuaChunk, LuaExpr};
 
 use crate::{
     compilation::analyzer::unresolve::UnResolveModule, db_index::LuaType, InferFailReason,
-    LuaSemanticDeclId, LuaSignatureId,
+    LuaDeclId, LuaSemanticDeclId, LuaSignatureId,
 };
 
 use super::{func_body::analyze_func_body_returns, LuaAnalyzer, LuaReturnPoint};
@@ -67,6 +67,11 @@ fn get_property_owner_id(analyzer: &LuaAnalyzer, expr: LuaExpr) -> Option<LuaSem
         LuaExpr::ClosureExpr(closure) => Some(LuaSemanticDeclId::Signature(
             LuaSignatureId::from_closure(analyzer.file_id, &closure),
         )),
+        // `return {}`
+        LuaExpr::TableExpr(table_expr) => Some(LuaSemanticDeclId::LuaDecl(LuaDeclId::new(
+            analyzer.file_id,
+            table_expr.get_position(),
+        ))),
         _ => None,
     }
 }

crates/emmylua_code_analysis/src/compilation/test/annotation_test.rs

@@ -112,4 +112,16 @@ mod test {
         let expected = ws.ty("string");
         assert_eq!(ty, expected);
     }
+
+    #[test]
+    fn test_generic_type_inference() {
+        let mut ws = VirtualWorkspace::new();
+
+        assert!(!ws.check_code_for(
+            DiagnosticCode::TypeNotFound,
+            r#"
+            ---@class AnonymousObserver<T>: Observer<T>
+        "#,
+        ));
+    }
 }

crates/emmylua_code_analysis/src/compilation/test/export_test.rs

@@ -0,0 +1,26 @@
+#[cfg(test)]
+mod test {
+    use crate::VirtualWorkspace;
+
+    #[test]
+    fn test_1() {
+        let mut ws = VirtualWorkspace::new();
+        ws.def_file(
+            "A.lua",
+            r#"
+
+            ---@export
+            return {
+               newField = 1           
+            }
+        "#,
+        );
+
+        ws.def(
+            r#"
+            local A = require("A")
+            A.newField = 2
+        "#,
+        );
+    }
+}

crates/emmylua_code_analysis/src/compilation/test/flow.rs

@@ -945,4 +945,60 @@ end
         let a_expected = ws.ty("string");
         assert_eq!(a, a_expected);
     }
+
+    #[test]
+    fn test_issue_598() {
+        let mut ws = VirtualWorkspace::new_with_init_std_lib();
+        ws.def(
+            r#"
+            ---@class A<T>
+            A = {}
+            ---@class IDisposable
+            ---@class B<T>: IDisposable
+
+            ---@class AnonymousObserver<T>: IDisposable
+
+            ---@generic T
+            ---@return AnonymousObserver<T>
+            function createAnonymousObserver()
+            end
+            "#,
+        );
+        assert!(ws.check_code_for(
+            DiagnosticCode::ReturnTypeMismatch,
+            r#"
+                ---@param observer fun(value: T) | B<T>
+                ---@return IDisposable
+                function A:subscribe(observer)
+                    local typ = type(observer)
+                    if typ == 'function' then
+                        ---@cast observer fun(value: T)
+                        observer = createAnonymousObserver()
+                    elseif typ == 'table' then
+                        ---@cast observer -function
+                        observer = createAnonymousObserver()
+                    end
+
+                    return observer
+                end
+            "#,
+        ));
+
+        assert!(!ws.check_code_for(
+            DiagnosticCode::ReturnTypeMismatch,
+            r#"
+                ---@param observer fun(value: T) | B<T>
+                ---@return IDisposable
+                function A:test2(observer)
+                    local typ = type(observer)
+                    if typ == 'table' then
+                        ---@cast observer -function
+                        observer = createAnonymousObserver()
+                    end
+
+                    return observer
+                end
+            "#,
+        ));
+    }
 }