update attribute constructor

Author: xuhuanzy

crates/emmylua_code_analysis/resources/std/builtin.lua

@@ -159,15 +159,16 @@
 --- used to specify the default constructor of a class.
 ---
 --- Parameters:
---- - `name` - The name of the constructor
+--- - `name` - The name of the method as a constructor.
+--- - `root_class` - Used to mark the root class, will implicitly inherit this class, such as `System.Object` in c#. Defaults to empty.
 --- - `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 constructor(name: string, strip_self: boolean?, return_self: boolean?)
+---@attribute constructor(name: string, root_class: string?, strip_self: boolean?, return_self: boolean?)
 
 --- Associates `getter` and `setter` methods with a field. Currently provides only definition navigation functionality,
 --- and the target methods must reside within the same class.
 ---
---- params:
+--- Parameters:
 --- - convention: Naming convention, defaults to `camelCase`. Implicitly adds `get` and `set` prefixes. eg: `_age` -> `getAge`, `setAge`.
 --- - getter: Getter method name. Takes precedence over `convention`.
 --- - setter: Setter method name. Takes precedence over `convention`.

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

@@ -13,21 +13,17 @@ pub fn analyze_call(analyzer: &mut LuaAnalyzer, call_expr: LuaCallExpr) -> Optio
         };
         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() == "constructor" {
-                        let unresolve = UnResolveConstructor {
-                            file_id: analyzer.file_id,
-                            call_expr: call_expr.clone(),
-                            signature_id,
-                            param_idx: *idx,
-                        };
-                        analyzer
-                            .context
-                            .add_unresolve(unresolve.into(), InferFailReason::None);
-                        return Some(());
-                    }
-                }
+            if param_info.get_attribute_by_name("constructor").is_some() {
+                let unresolve = UnResolveConstructor {
+                    file_id: analyzer.file_id,
+                    call_expr: call_expr.clone(),
+                    signature_id,
+                    param_idx: *idx,
+                };
+                analyzer
+                    .context
+                    .add_unresolve(unresolve.into(), InferFailReason::None);
+                return Some(());
             }
         }
     }

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

@@ -257,58 +257,92 @@ pub fn try_resolve_constructor(
     cache: &mut LuaInferCache,
     unresolve_constructor: &mut UnResolveConstructor,
 ) -> ResolveResult {
-    let signature = db
-        .get_signature_index()
-        .get(&unresolve_constructor.signature_id)
-        .ok_or(InferFailReason::None)?;
-    let param_info = signature
-        .get_param_info_by_id(unresolve_constructor.param_idx)
-        .ok_or(InferFailReason::None)?;
-    let constructor_use = param_info
-        .attributes
-        .iter()
-        .flatten()
-        .find(|attr| attr.id.get_name() == "constructor")
-        .ok_or(InferFailReason::None)?;
-    let target_signature_type = constructor_use
-        .args
-        .first()
-        .and_then(|(_, typ)| typ.as_ref())
-        .ok_or(InferFailReason::None)?;
-    let LuaType::DocStringConst(target_signature_name) = target_signature_type else {
-        return Err(InferFailReason::None);
-    };
-    let target_type_decl_id = get_constructor_target_type(
+    let (param_type, target_signature_name, root_class, strip_self, return_self) = {
+        let signature = db
+            .get_signature_index()
+            .get(&unresolve_constructor.signature_id)
+            .ok_or(InferFailReason::None)?;
+        let param_info = signature
+            .get_param_info_by_id(unresolve_constructor.param_idx)
+            .ok_or(InferFailReason::None)?;
+        let constructor_use = param_info
+            .get_attribute_by_name("constructor")
+            .ok_or(InferFailReason::None)?;
+
+        // 作为构造函数的方法名
+        let target_signature_name = constructor_use
+            .get_param_by_name("name")
+            .and_then(|typ| match typ {
+                LuaType::DocStringConst(value) => Some(value.deref().clone()),
+                _ => None,
+            })
+            .ok_or(InferFailReason::None)?;
+        // 作为构造函数的根类
+        let root_class =
+            constructor_use
+                .get_param_by_name("root_class")
+                .and_then(|typ| match typ {
+                    LuaType::DocStringConst(value) => Some(value.deref().clone()),
+                    _ => None,
+                });
+        // 是否可以省略self参数
+        let strip_self = constructor_use
+            .get_param_by_name("strip_self")
+            .and_then(|typ| match typ {
+                LuaType::DocBooleanConst(value) => Some(*value),
+                _ => None,
+            })
+            .unwrap_or(true);
+        // 是否返回self
+        let return_self = constructor_use
+            .get_param_by_name("return_self")
+            .and_then(|typ| match typ {
+                LuaType::DocBooleanConst(value) => Some(*value),
+                _ => None,
+            })
+            .unwrap_or(true);
+
+        Ok::<_, InferFailReason>((
+            param_info.type_ref.clone(),
+            target_signature_name,
+            root_class,
+            strip_self,
+            return_self,
+        ))
+    }?;
+
+    // 需要添加构造函数的目标类型
+    let target_id = get_constructor_target_type(
         db,
         cache,
-        &param_info.type_ref,
+        &param_type,
         unresolve_constructor.call_expr.clone(),
         unresolve_constructor.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());
+
+    // 添加根类
+    if let Some(root_class) = root_class {
+        let root_type_id = LuaTypeDeclId::new(&root_class);
+        if let Some(type_decl) = db.get_type_index().get_type_decl(&root_type_id) {
+            if type_decl.is_class() {
+                let root_type = LuaType::Ref(root_type_id.clone());
+                db.get_type_index_mut().add_super_type(
+                    target_id.clone(),
+                    unresolve_constructor.file_id,
+                    root_type,
+                );
+            }
+        }
+    }
+
+    // 添加构造函数
+    let target_type = LuaType::Ref(target_id);
+    let member_key = LuaMemberKey::Name(target_signature_name);
     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 = constructor_use
-        .args
-        .get(1)
-        .and_then(|(_, typ)| typ.as_ref())
-        .and_then(|typ| match typ {
-            LuaType::DocBooleanConst(value) => Some(*value),
-            _ => None,
-        })
-        .unwrap_or(true);
-    let return_self = constructor_use
-        .args
-        .get(2)
-        .and_then(|(_, typ)| typ.as_ref())
-        .and_then(|typ| match typ {
-            LuaType::DocBooleanConst(value) => Some(*value),
-            _ => None,
-        })
-        .unwrap_or(true);
+
     set_signature_to_default_call(db, cache, ctor_signature_member, strip_self, return_self)
         .ok_or(InferFailReason::None)?;
 

crates/emmylua_code_analysis/src/db_index/signature/signature.rs

@@ -185,6 +185,15 @@ pub struct LuaDocParamInfo {
     pub attributes: Option<Vec<LuaAttributeUse>>,
 }
 
+impl LuaDocParamInfo {
+    pub fn get_attribute_by_name(&self, name: &str) -> Option<&LuaAttributeUse> {
+        self.attributes
+            .iter()
+            .flatten()
+            .find(|attr| attr.id.get_name() == name)
+    }
+}
+
 #[derive(Debug)]
 pub struct LuaDocReturnInfo {
     pub name: Option<String>,

crates/emmylua_ls/src/handlers/test/inlay_hint_test.rs

@@ -136,7 +136,7 @@ mod tests {
 
     #[gtest]
     fn test_class_call_hint() -> Result<()> {
-        let mut ws = ProviderVirtualWorkspace::new();
+        let mut ws = ProviderVirtualWorkspace::new_with_init_std_lib();
         ws.def(
             r#"
             ---@generic T