添加---@Attribute class_ctor

用于取代配置项`runtime.class_default_call`

Author: xuhuanzy

crates/emmylua_code_analysis/resources/std/builtin.lua

@@ -154,3 +154,12 @@
 ---
 --- Receives a string parameter for the alias name.
 ---@attribute index_alias(name: string)
+
+--- This attribute must be applied to function parameters, and the function parameter's type must be a string template generic,
+--- used to specify the default constructor of a class.
+---
+--- Parameters:
+--- - `name` - The name of the constructor
+--- - `strip_self` - Whether the `self` parameter can be omitted when calling the constructor, defaults to `true`
+--- - `return_self` - Whether the constructor is forced to return `self`, defaults to `true`
+---@attribute class_ctor(name: string, strip_self: boolean?, return_self: boolean?)

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

@@ -0,0 +1,38 @@
+use emmylua_parser::LuaCallExpr;
+
+use crate::{
+    InferFailReason, LuaType,
+    compilation::analyzer::{lua::LuaAnalyzer, unresolve::UnResolveClassCtor},
+};
+
+pub fn analyze_call(analyzer: &mut LuaAnalyzer, call_expr: LuaCallExpr) -> Option<()> {
+    let prefix_expr = call_expr.clone().get_prefix_expr()?;
+    match analyzer.infer_expr(&prefix_expr) {
+        Ok(expr_type) => {
+            let LuaType::Signature(signature_id) = expr_type else {
+                return Some(());
+            };
+            let signature = analyzer.db.get_signature_index().get(&signature_id)?;
+            for (idx, param_info) in signature.param_docs.iter() {
+                if let Some(ref attrs) = param_info.attributes {
+                    for attr in attrs.iter() {
+                        if attr.id.get_name() == "class_ctor" {
+                            let unresolve = UnResolveClassCtor {
+                                file_id: analyzer.file_id,
+                                call_expr: call_expr.clone(),
+                                signature_id: signature_id,
+                                param_idx: *idx,
+                            };
+                            analyzer
+                                .context
+                                .add_unresolve(unresolve.into(), InferFailReason::None);
+                            return Some(());
+                        }
+                    }
+                }
+            }
+        }
+        Err(_) => {}
+    }
+    Some(())
+}

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

@@ -1,3 +1,4 @@
+mod call;
 mod closure;
 mod for_range_stat;
 mod func_body;
@@ -22,7 +23,7 @@ use stats::{
 
 use crate::{
     Emmyrc, FileId, InferFailReason,
-    compilation::analyzer::AnalysisPipeline,
+    compilation::analyzer::{AnalysisPipeline, lua::call::analyze_call},
     db_index::{DbIndex, LuaType},
     profile::Profile,
     semantic::infer_expr,
@@ -81,6 +82,8 @@ fn analyze_node(analyzer: &mut LuaAnalyzer, node: LuaAst) {
         LuaAst::LuaCallExpr(call_expr) => {
             if call_expr.is_setmetatable() {
                 analyze_setmetatable(analyzer, call_expr);
+            } else {
+                analyze_call(analyzer, call_expr);
             }
         }
         _ => {}

crates/emmylua_code_analysis/src/compilation/analyzer/unresolve/check_reason.rs

@@ -18,6 +18,7 @@ pub fn check_reach_reason(
     match reason {
         InferFailReason::None
         | InferFailReason::FieldNotFound
+        | InferFailReason::UnResolveOperatorCall
         | InferFailReason::RecursiveInfer => Some(true),
         InferFailReason::UnResolveDeclType(decl_id) => {
             let decl = db.get_decl_index().get_decl(decl_id)?;
@@ -60,6 +61,7 @@ pub fn resolve_as_any(db: &mut DbIndex, reason: &InferFailReason, loop_count: us
     match reason {
         InferFailReason::None
         | InferFailReason::FieldNotFound
+        | InferFailReason::UnResolveOperatorCall
         | InferFailReason::RecursiveInfer => {
             return Some(());
         }

crates/emmylua_code_analysis/src/compilation/analyzer/unresolve/mod.rs

@@ -7,7 +7,7 @@ use std::collections::HashMap;
 
 use crate::{
     FileId, InferFailReason, LuaMemberFeature, LuaSemanticDeclId,
-    compilation::analyzer::AnalysisPipeline,
+    compilation::analyzer::{AnalysisPipeline, unresolve::resolve::try_resolve_class_ctor},
     db_index::{DbIndex, LuaDeclId, LuaMemberId, LuaSignatureId},
     profile::Profile,
 };
@@ -201,6 +201,9 @@ fn try_resolve(
                     UnResolve::TableField(un_resolve_table_field) => {
                         try_resolve_table_field(db, cache, un_resolve_table_field)
                     }
+                    UnResolve::ClassCtor(un_resolve_class_ctor) => {
+                        try_resolve_class_ctor(db, cache, un_resolve_class_ctor)
+                    }
                 };
 
                 match resolve_result {
@@ -213,6 +216,12 @@ fn try_resolve(
                             retain_unresolve.push((unresolve, InferFailReason::FieldNotFound));
                         }
                     }
+                    Err(InferFailReason::UnResolveOperatorCall) => {
+                        if !cache.get_config().analysis_phase.is_force() {
+                            retain_unresolve
+                                .push((unresolve, InferFailReason::UnResolveOperatorCall));
+                        }
+                    }
                     Err(reason) => {
                         if reason != *check_reason {
                             changed = true;
@@ -254,6 +263,7 @@ pub enum UnResolve {
     ClosureParentParams(Box<UnResolveParentClosureParams>),
     ModuleRef(Box<UnResolveModuleRef>),
     TableField(Box<UnResolveTableField>),
+    ClassCtor(Box<UnResolveClassCtor>),
 }
 
 #[allow(dead_code)]
@@ -276,6 +286,7 @@ impl UnResolve {
             }
             UnResolve::TableField(un_resolve_table_field) => Some(un_resolve_table_field.file_id),
             UnResolve::ModuleRef(_) => None,
+            UnResolve::ClassCtor(un_resolve_class_ctor) => Some(un_resolve_class_ctor.file_id),
         }
     }
 }
@@ -422,3 +433,17 @@ impl From<UnResolveTableField> for UnResolve {
         UnResolve::TableField(Box::new(un_resolve_table_field))
     }
 }
+
+#[derive(Debug)]
+pub struct UnResolveClassCtor {
+    pub file_id: FileId,
+    pub call_expr: LuaCallExpr,
+    pub signature_id: LuaSignatureId,
+    pub param_idx: usize,
+}
+
+impl From<UnResolveClassCtor> for UnResolve {
+    fn from(un_resolve_class_ctor: UnResolveClassCtor) -> Self {
+        UnResolve::ClassCtor(Box::new(un_resolve_class_ctor))
+    }
+}

crates/emmylua_code_analysis/src/compilation/analyzer/unresolve/resolve.rs

@@ -1,15 +1,20 @@
 use std::ops::Deref;
 
-use emmylua_parser::{LuaAstNode, LuaAstToken, LuaExpr, LuaLocalStat, LuaTableExpr};
+use emmylua_parser::{
+    LuaAstNode, LuaAstToken, LuaCallExpr, LuaExpr, LuaIndexExpr, LuaLocalStat, LuaTableExpr,
+};
 
 use crate::{
-    InFiled, InferFailReason, LuaDeclId, LuaMember, LuaMemberId, LuaMemberKey, LuaSemanticDeclId,
-    LuaTypeCache, SignatureReturnStatus, TypeOps,
+    InFiled, InferFailReason, LuaDeclId, LuaMember, LuaMemberId, LuaMemberInfo, LuaMemberKey,
+    LuaOperator, LuaOperatorMetaMethod, LuaOperatorOwner, LuaSemanticDeclId, LuaTypeCache,
+    LuaTypeDeclId, OperatorFunction, SignatureReturnStatus, TypeOps,
     compilation::analyzer::{
         common::{add_member, bind_type},
         lua::{analyze_return_point, infer_for_range_iter_expr_func},
+        unresolve::UnResolveClassCtor,
     },
     db_index::{DbIndex, LuaMemberOwner, LuaType},
+    find_members_with_key,
     semantic::{LuaInferCache, infer_expr},
 };
 
@@ -246,3 +251,146 @@ pub fn try_resolve_module_ref(
 
     Ok(())
 }
+
+#[allow(unused)]
+pub fn try_resolve_class_ctor(
+    db: &mut DbIndex,
+    cache: &mut LuaInferCache,
+    unresolve_class_ctor: &mut UnResolveClassCtor,
+) -> ResolveResult {
+    let signature = db
+        .get_signature_index()
+        .get(&unresolve_class_ctor.signature_id)
+        .ok_or(InferFailReason::None)?;
+    let param_info = signature
+        .get_param_info_by_id(unresolve_class_ctor.param_idx)
+        .ok_or(InferFailReason::None)?;
+    let class_ctor_use = param_info
+        .attributes
+        .iter()
+        .flatten()
+        .find(|attr| attr.id.get_name() == "class_ctor")
+        .ok_or(InferFailReason::None)?;
+    let LuaType::DocStringConst(target_signature_name) =
+        class_ctor_use.args.get(0).ok_or(InferFailReason::None)?
+    else {
+        return Err(InferFailReason::None);
+    };
+    let target_type_decl_id = get_class_ctor_target_type(
+        db,
+        cache,
+        &param_info.type_ref,
+        unresolve_class_ctor.call_expr.clone(),
+        unresolve_class_ctor.param_idx,
+    )
+    .ok_or(InferFailReason::None)?;
+    let target_type = LuaType::Ref(target_type_decl_id);
+    let member_key = LuaMemberKey::Name(target_signature_name.deref().clone());
+    let members =
+        find_members_with_key(db, &target_type, member_key, false).ok_or(InferFailReason::None)?;
+    let ctor_signature_member = members.first().ok_or(InferFailReason::None)?;
+    let strip_self = {
+        if let Some(LuaType::DocBooleanConst(strip_self)) = class_ctor_use.args.get(1) {
+            *strip_self
+        } else {
+            true
+        }
+    };
+    let return_self = {
+        if let Some(LuaType::DocBooleanConst(return_self)) = class_ctor_use.args.get(2) {
+            *return_self
+        } else {
+            true
+        }
+    };
+    set_signature_to_default_call(db, cache, ctor_signature_member, strip_self, return_self)
+        .ok_or(InferFailReason::None)?;
+
+    Ok(())
+}
+
+fn set_signature_to_default_call(
+    db: &mut DbIndex,
+    cache: &mut LuaInferCache,
+    member_info: &LuaMemberInfo,
+    strip_self: bool,
+    return_self: bool,
+) -> Option<()> {
+    let LuaType::Signature(signature_id) = member_info.typ else {
+        return None;
+    };
+    let Some(LuaSemanticDeclId::Member(member_id)) = member_info.property_owner_id else {
+        return None;
+    };
+    // 我们仍然需要再做一次判断确定是否来源于`Def`类型
+    let root = db
+        .get_vfs()
+        .get_syntax_tree(&member_id.file_id)?
+        .get_red_root();
+    let index_expr = LuaIndexExpr::cast(member_id.get_syntax_id().to_node_from_root(&root)?)?;
+    let prefix_expr = index_expr.get_prefix_expr()?;
+    let prefix_type = infer_expr(db, cache, prefix_expr.clone()).ok()?;
+    let LuaType::Def(decl_id) = prefix_type else {
+        return None;
+    };
+    // 如果已经存在显式的`__call`定义, 则不添加
+    let call = 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,
+        member_id.file_id,
+        // 必须指向名称, 使用 index_expr 的完整范围不会跳转到函数上
+        index_expr.get_name_token()?.syntax().text_range(),
+        OperatorFunction::DefaultClassCtor {
+            id: signature_id,
+            strip_self,
+            return_self,
+        },
+    );
+    db.get_operator_index_mut().add_operator(operator);
+    Some(())
+}
+
+fn get_class_ctor_target_type(
+    db: &DbIndex,
+    cache: &mut LuaInferCache,
+    param_type: &LuaType,
+    call_expr: LuaCallExpr,
+    call_index: usize,
+) -> Option<LuaTypeDeclId> {
+    match param_type {
+        LuaType::StrTplRef(str_tpl) => {
+            let name = {
+                let arg_expr = call_expr
+                    .get_args_list()?
+                    .get_args()
+                    .nth(call_index)?
+                    .clone();
+                let name = infer_expr(db, cache, arg_expr).ok()?;
+                match name {
+                    LuaType::StringConst(s) => s.to_string(),
+                    _ => return None,
+                }
+            };
+
+            let prefix = str_tpl.get_prefix();
+            let suffix = str_tpl.get_suffix();
+            let type_decl_id: LuaTypeDeclId =
+                LuaTypeDeclId::new(format!("{}{}{}", prefix, name, suffix).as_str());
+            let type_decl = db.get_type_index().get_type_decl(&type_decl_id)?;
+            if type_decl.is_class() {
+                return Some(type_decl_id);
+            }
+        }
+        _ => {}
+    }
+
+    None
+}

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

@@ -64,4 +64,50 @@ mod test {
         "#,
         );
     }
+
+    #[test]
+    fn test_class_ctor() {
+        let mut ws = VirtualWorkspace::new();
+
+        ws.def_files(vec![
+            (
+                "init.lua",
+                r#"
+                A = meta("A")
+                "#,
+            ),
+            (
+                "meta.lua",
+                r#"
+            ---@attribute class_ctor(name: string, strip_self: boolean?, return_self: boolean?)
+
+            ---@generic T
+            ---@param [class_ctor("__init")] name `T`
+            ---@return T
+            function meta(name)
+            end
+                "#,
+            ),
+        ]);
+
+        // ws.def(
+        //     r#"
+        //     ---@attribute class_ctor(name: string, strip_self: boolean?, return_self: boolean?)
+
+        //     ---@generic T
+        //     ---@param [class_ctor("__init")] name `T`
+        //     ---@return T
+        //     function meta(name)
+        //     end
+        // "#,
+        // );
+        // ws.def(
+        //     r#"
+        //     A = meta("A")
+
+        //     function A:__init(a)
+        //     end
+        // "#,
+        // );
+    }
 }