feature: add class_default_call

xuhuanzy · xuhuanzy · commit 311520829a86 · 2025-06-09T16:37:27.000+08:00
将`signature`添加为默认的`__call`调用目标, 但如果已经显式为`class`声明了`---@overload`则不会添加. 配置以下选项: runtime.class_default_call.function_name = "__init" untime.class_default_call.force_non_colon = true runtime.class_default_call.force_return_self ```lua ---@Class MyClass local M = {} function M:__init(a) end A = M() -- `A` is `MyClass` ```
diff --git a/crates/emmylua_code_analysis/resources/schema.json b/crates/emmylua_code_analysis/resources/schema.json
@@ -119,6 +119,11 @@
     },
     "runtime": {
       "default": {
+        "classDefaultCall": {
+          "forceNonColon": false,
+          "forceReturnSelf": false,
+          "functionName": ""
+        },
         "extensions": [],
         "frameworkVersions": [],
         "requireLikeFunction": [],
@@ -184,6 +189,26 @@
     }
   },
   "definitions": {
+    "ClassDefaultCall": {
+      "type": "object",
+      "properties": {
+        "forceNonColon": {
+          "description": "Mandatory non`:` definition. When `function_name` is not empty, it takes effect.",
+          "default": true,
+          "type": "boolean"
+        },
+        "forceReturnSelf": {
+          "description": "Force to return `self`.",
+          "default": true,
+          "type": "boolean"
+        },
+        "functionName": {
+          "description": "class default overload function. eg. \"__init\".",
+          "default": "",
+          "type": "string"
+        }
+      }
+    },
     "DiagnosticCode": {
       "oneOf": [
         {
@@ -836,6 +861,19 @@
     "EmmyrcRuntime": {
       "type": "object",
       "properties": {
+        "classDefaultCall": {
+          "description": "class default overload function.",
+          "default": {
+            "forceNonColon": false,
+            "forceReturnSelf": false,
+            "functionName": ""
+          },
+          "allOf": [
+            {
+              "$ref": "#/definitions/ClassDefaultCall"
+            }
+          ]
+        },
         "extensions": {
           "description": "file Extensions. eg: .lua, .lua.txt",
           "default": [],
diff --git a/crates/emmylua_code_analysis/src/compilation/analyzer/lua/for_range_stat.rs b/crates/emmylua_code_analysis/src/compilation/analyzer/lua/for_range_stat.rs
@@ -118,7 +118,7 @@ pub fn infer_for_range_iter_expr_func(
                     .iter()
                     .filter_map(|overload_id| {
                         let operator = operator_index.get_operator(overload_id)?;
-                        let func = operator.get_operator_func();
+                        let func = operator.get_operator_func(db);
                         match func {
                             LuaType::DocFunction(f) => Some(f.clone()),
                             _ => None,
diff --git a/crates/emmylua_code_analysis/src/compilation/analyzer/lua/mod.rs b/crates/emmylua_code_analysis/src/compilation/analyzer/lua/mod.rs
@@ -24,7 +24,7 @@ use crate::{
     db_index::{DbIndex, LuaType},
     profile::Profile,
     semantic::infer_expr,
-    FileId, InferFailReason,
+    Emmyrc, FileId, InferFailReason,
 };
 
 use super::AnalyzeContext;
@@ -101,6 +101,10 @@ impl LuaAnalyzer<'_> {
             context,
         }
     }
+
+    pub fn get_emmyrc(&self) -> &Emmyrc {
+        self.db.get_emmyrc()
+    }
 }
 
 impl LuaAnalyzer<'_> {
diff --git a/crates/emmylua_code_analysis/src/compilation/analyzer/lua/stats.rs b/crates/emmylua_code_analysis/src/compilation/analyzer/lua/stats.rs
@@ -9,7 +9,8 @@ use crate::{
         unresolve::{UnResolveDecl, UnResolveMember},
     },
     db_index::{LuaDeclId, LuaMemberId, LuaMemberOwner, LuaType},
-    InFiled, InferFailReason, LuaTypeCache, LuaTypeOwner,
+    InFiled, InferFailReason, LuaOperator, LuaOperatorMetaMethod, LuaOperatorOwner, LuaTypeCache,
+    LuaTypeOwner, OperatorFunction,
 };
 
 use super::LuaAnalyzer;
@@ -417,6 +418,8 @@ pub fn analyze_func_stat(analyzer: &mut LuaAnalyzer, func_stat: LuaFuncStat) ->
         .get_type_index_mut()
         .bind_type(type_owner, LuaTypeCache::InferType(signature_type.clone()));
 
+    try_add_class_default_call(analyzer, func_name, signature_type);
+
     Some(())
 }
 
@@ -500,3 +503,56 @@ fn special_assign_pattern(
 
     Some(())
 }
+
+pub fn try_add_class_default_call(
+    analyzer: &mut LuaAnalyzer,
+    func_name: LuaVarExpr,
+    signature_type: LuaType,
+) -> Option<()> {
+    let LuaType::Signature(signature_id) = signature_type else {
+        return None;
+    };
+
+    let default_name = &analyzer
+        .get_emmyrc()
+        .runtime
+        .class_default_call
+        .function_name;
+
+    if default_name.is_empty() {
+        return None;
+    }
+    if let LuaVarExpr::IndexExpr(index_expr) = func_name {
+        let index_key = index_expr.get_index_key()?;
+        if index_key.get_path_part() == *default_name {
+            let prefix_expr = index_expr.get_prefix_expr()?;
+            match analyzer.infer_expr(&prefix_expr.into()) {
+                Ok(prefix_type) => match prefix_type {
+                    LuaType::Def(decl_id) => {
+                        // 如果已经存在, 则不添加
+                        let call = analyzer.db.get_operator_index().get_operators(
+                            &LuaOperatorOwner::Type(decl_id.clone()),
+                            LuaOperatorMetaMethod::Call,
+                        );
+                        if call.is_some() {
+                            return None;
+                        }
+
+                        let operator = LuaOperator::new(
+                            decl_id.into(),
+                            LuaOperatorMetaMethod::Call,
+                            analyzer.file_id,
+                            index_expr.get_range(),
+                            OperatorFunction::DefaultCall(signature_id),
+                        );
+                        analyzer.db.get_operator_index_mut().add_operator(operator);
+                    }
+                    _ => {}
+                },
+                Err(_) => {}
+            }
+        }
+    }
+
+    Some(())
+}
diff --git a/crates/emmylua_code_analysis/src/compilation/test/overload_test.rs b/crates/emmylua_code_analysis/src/compilation/test/overload_test.rs
@@ -1,5 +1,7 @@
 #[cfg(test)]
 mod test {
+    use std::{ops::Deref, sync::Arc};
+
     use crate::{DiagnosticCode, VirtualWorkspace};
 
     #[test]
@@ -25,4 +27,30 @@ mod test {
         "#
         ));
     }
+
+    #[test]
+    fn test_class_default_call() {
+        let mut ws = VirtualWorkspace::new();
+        let mut emmyrc = ws.analysis.emmyrc.deref().clone();
+        emmyrc.runtime.class_default_call.function_name = "__init".to_string();
+        emmyrc.runtime.class_default_call.force_non_colon = true;
+        emmyrc.runtime.class_default_call.force_return_self = true;
+        ws.analysis.update_config(Arc::new(emmyrc));
+
+        ws.def(
+            r#"
+        ---@class MyClass
+        local M = {}
+        
+        function M:__init(a)
+        end
+
+        A = M()
+        "#,
+        );
+
+        let ty = ws.expr_ty("A");
+        let expected = ws.ty("MyClass");
+        assert_eq!(ws.humanize_type(ty), ws.humanize_type(expected));
+    }
 }
diff --git a/crates/emmylua_code_analysis/src/config/configs/runtime.rs b/crates/emmylua_code_analysis/src/config/configs/runtime.rs
@@ -20,6 +20,9 @@ pub struct EmmyrcRuntime {
     #[serde(default)]
     /// Require pattern. eg. "?.lua", "?/init.lua"
     pub require_pattern: Vec<String>,
+    #[serde(default)]
+    /// class default overload function.
+    pub class_default_call: ClassDefaultCall,
 }
 
 impl Default for EmmyrcRuntime {
@@ -30,6 +33,7 @@ impl Default for EmmyrcRuntime {
             framework_versions: Default::default(),
             extensions: Default::default(),
             require_pattern: Default::default(),
+            class_default_call: Default::default(),
         }
     }
 }
@@ -79,6 +83,24 @@ impl EmmyrcLuaVersion {
     }
 }
 
+#[derive(Serialize, Deserialize, Debug, JsonSchema, Clone, Default)]
+#[serde(rename_all = "camelCase")]
+pub struct ClassDefaultCall {
+    #[serde(default)]
+    /// class default overload function. eg. "__init".
+    pub function_name: String,
+    #[serde(default = "default_true")]
+    /// Mandatory non`:` definition. When `function_name` is not empty, it takes effect.
+    pub force_non_colon: bool,
+    /// Force to return `self`.
+    #[serde(default = "default_true")]
+    pub force_return_self: bool,
+}
+
+fn default_true() -> bool {
+    true
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/crates/emmylua_code_analysis/src/db_index/operators/lua_operator.rs b/crates/emmylua_code_analysis/src/db_index/operators/lua_operator.rs
@@ -23,6 +23,7 @@ pub struct LuaOperator {
 pub enum OperatorFunction {
     Func(Arc<LuaFunctionType>),
     Signature(LuaSignatureId),
+    DefaultCall(LuaSignatureId),
 }
 
 impl LuaOperator {
@@ -71,6 +72,8 @@ impl LuaOperator {
 
                 LuaType::Any
             }
+            // 只有 .field 才有`operand`, call 不会有这个
+            OperatorFunction::DefaultCall(_) => LuaType::Unknown,
         }
     }
 
@@ -92,15 +95,62 @@ impl LuaOperator {
                     }
                 }
 
+                Ok(LuaType::Any)
+            }
+            OperatorFunction::DefaultCall(signature_id) => {
+                let emmyrc = db.get_emmyrc();
+                if emmyrc.runtime.class_default_call.force_return_self {
+                    return Ok(LuaType::SelfInfer);
+                }
+
+                if let Some(signature) = db.get_signature_index().get(signature_id) {
+                    if signature.resolve_return == SignatureReturnStatus::UnResolve {
+                        return Err(InferFailReason::UnResolveSignatureReturn(
+                            signature_id.clone(),
+                        ));
+                    }
+
+                    let return_type = signature.return_docs.get(0);
+                    if let Some(return_type) = return_type {
+                        return Ok(return_type.type_ref.clone());
+                    }
+                }
+
                 Ok(LuaType::Any)
             }
         }
     }
 
-    pub fn get_operator_func(&self) -> LuaType {
+    pub fn get_operator_func(&self, db: &DbIndex) -> LuaType {
         match &self.func {
             OperatorFunction::Func(func) => LuaType::DocFunction(func.clone()),
             OperatorFunction::Signature(signature) => LuaType::Signature(*signature),
+            OperatorFunction::DefaultCall(signature_id) => {
+                let emmyrc = db.get_emmyrc();
+
+                if let Some(signature) = db.get_signature_index().get(signature_id) {
+                    let params = signature.get_type_params();
+                    let is_colon_define = if emmyrc.runtime.class_default_call.force_non_colon {
+                        false
+                    } else {
+                        signature.is_colon_define
+                    };
+                    let return_type = if emmyrc.runtime.class_default_call.force_return_self {
+                        LuaType::SelfInfer
+                    } else {
+                        signature.get_return_type()
+                    };
+                    let func_type = LuaFunctionType::new(
+                        signature.is_async,
+                        is_colon_define,
+                        params,
+                        return_type,
+                    );
+                    return LuaType::DocFunction(Arc::new(func_type));
+                }
+
+                LuaType::Signature(*signature_id)
+            }
         }
     }
 
diff --git a/crates/emmylua_code_analysis/src/semantic/infer/infer_call/mod.rs b/crates/emmylua_code_analysis/src/semantic/infer/infer_call/mod.rs
@@ -252,7 +252,7 @@ fn infer_type_doc_function(
         let operator = operator_index
             .get_operator(overload_id)
             .ok_or(InferFailReason::None)?;
-        let func = operator.get_operator_func();
+        let func = operator.get_operator_func(db);
         match func {
             LuaType::DocFunction(f) => {
                 if f.contain_self() {
@@ -326,7 +326,7 @@ fn infer_generic_type_doc_function(
         let operator = operator_index
             .get_operator(overload_id)
             .ok_or(InferFailReason::None)?;
-        let func = operator.get_operator_func();
+        let func = operator.get_operator_func(db);
         match func {
             LuaType::DocFunction(_) => {
                 let new_f = instantiate_type_generic(db, &func, &substitutor);
@@ -403,7 +403,7 @@ fn infer_table_type_doc_function(db: &DbIndex, table: InFiled<TextRange>) -> Inf
             .get_operator_index()
             .get_operator(operator_id)
             .ok_or(InferFailReason::None)?;
-        let func = operator.get_operator_func();
+        let func = operator.get_operator_func(db);
         match func {
             LuaType::DocFunction(func) => {
                 return Ok(func.into());
diff --git a/crates/emmylua_code_analysis/src/semantic/type_check/func_type.rs b/crates/emmylua_code_analysis/src/semantic/type_check/func_type.rs
@@ -198,7 +198,7 @@ fn check_doc_func_type_compact_for_custom_type(
                 .get_operator_index()
                 .get_operator(operator_id)
                 .ok_or(TypeCheckFailReason::TypeNotMatch)?;
-            let call_type = operator.get_operator_func();
+            let call_type = operator.get_operator_func(db);
             match call_type {
                 LuaType::DocFunction(doc_func) => {
                     match check_doc_func_type_compact_for_params(
diff --git a/crates/emmylua_ls/src/handlers/signature_helper/build_signature_helper.rs b/crates/emmylua_ls/src/handlers/signature_helper/build_signature_helper.rs
@@ -276,7 +276,7 @@ fn build_type_signature_help(
 
     for operator_id in operator_ids {
         let operator = db.get_operator_index().get_operator(operator_id)?;
-        let call_type = operator.get_operator_func();
+        let call_type = operator.get_operator_func(db);
         match call_type {
             LuaType::DocFunction(func_type) => {
                 return build_doc_function_signature_help(
@@ -336,7 +336,7 @@ fn build_table_call_signature_help(
         .get_operators(&operator_owner, LuaOperatorMetaMethod::Call)?
         .first()?;
     let operator = db.get_operator_index().get_operator(operator_ids)?;
-    let call_type = operator.get_operator_func();
+    let call_type = operator.get_operator_func(db);
     match call_type {
         LuaType::DocFunction(func_type) => {
             return build_doc_function_signature_help(builder, &func_type, colon_call, current_idx);

Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@ use crate::{`
`24`	`24`	`db_index::{DbIndex, LuaType},`
`25`	`25`	`profile::Profile,`
`26`	`26`	`semantic::infer_expr,`
`27`		`- FileId, InferFailReason,`
	`27`	`+ Emmyrc, FileId, InferFailReason,`
`28`	`28`	`};`
`29`	`29`
`30`	`30`	`use super::AnalyzeContext;`
`@@ -101,6 +101,10 @@ impl LuaAnalyzer<'_> {`
`101`	`101`	`context,`
`102`	`102`	`}`
`103`	`103`	`}`
	`104`	`+`
	`105`	`+ pub fn get_emmyrc(&self) -> &Emmyrc {`
	`106`	`+ self.db.get_emmyrc()`
	`107`	`+ }`
`104`	`108`	`}`
`105`	`109`
`106`	`110`	`impl LuaAnalyzer<'_> {`