将特性class_ctor命名调整为constructor

Author: xuhuanzy

crates/emmylua_code_analysis/resources/std/builtin.lua

@@ -162,4 +162,4 @@
 --- - `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?)
+---@attribute constructor(name: string, strip_self: boolean?, return_self: boolean?)

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

@@ -2,7 +2,7 @@ use emmylua_parser::LuaCallExpr;
 
 use crate::{
     InferFailReason, LuaType,
-    compilation::analyzer::{lua::LuaAnalyzer, unresolve::UnResolveClassCtor},
+    compilation::analyzer::{lua::LuaAnalyzer, unresolve::UnResolveConstructor},
 };
 
 pub fn analyze_call(analyzer: &mut LuaAnalyzer, call_expr: LuaCallExpr) -> Option<()> {
@@ -15,8 +15,8 @@ pub fn analyze_call(analyzer: &mut LuaAnalyzer, call_expr: LuaCallExpr) -> Optio
         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 {
+                    if attr.id.get_name() == "constructor" {
+                        let unresolve = UnResolveConstructor {
                             file_id: analyzer.file_id,
                             call_expr: call_expr.clone(),
                             signature_id,

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, unresolve::resolve::try_resolve_class_ctor},
+    compilation::analyzer::{AnalysisPipeline, unresolve::resolve::try_resolve_constructor},
     db_index::{DbIndex, LuaDeclId, LuaMemberId, LuaSignatureId},
     profile::Profile,
 };
@@ -201,8 +201,8 @@ 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)
+                    UnResolve::ClassCtor(un_resolve_constructor) => {
+                        try_resolve_constructor(db, cache, un_resolve_constructor)
                     }
                 };
 
@@ -263,7 +263,7 @@ pub enum UnResolve {
     ClosureParentParams(Box<UnResolveParentClosureParams>),
     ModuleRef(Box<UnResolveModuleRef>),
     TableField(Box<UnResolveTableField>),
-    ClassCtor(Box<UnResolveClassCtor>),
+    ClassCtor(Box<UnResolveConstructor>),
 }
 
 #[allow(dead_code)]
@@ -286,7 +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),
+            UnResolve::ClassCtor(un_resolve_constructor) => Some(un_resolve_constructor.file_id),
         }
     }
 }
@@ -435,15 +435,15 @@ impl From<UnResolveTableField> for UnResolve {
 }
 
 #[derive(Debug)]
-pub struct UnResolveClassCtor {
+pub struct UnResolveConstructor {
     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))
+impl From<UnResolveConstructor> for UnResolve {
+    fn from(un_resolve_constructor: UnResolveConstructor) -> Self {
+        UnResolve::ClassCtor(Box::new(un_resolve_constructor))
     }
 }

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

@@ -11,7 +11,7 @@ use crate::{
     compilation::analyzer::{
         common::{add_member, bind_type},
         lua::{analyze_return_point, infer_for_range_iter_expr_func},
-        unresolve::UnResolveClassCtor,
+        unresolve::UnResolveConstructor,
     },
     db_index::{DbIndex, LuaMemberOwner, LuaType},
     find_members_with_key,
@@ -252,36 +252,35 @@ pub fn try_resolve_module_ref(
     Ok(())
 }
 
-#[allow(unused)]
-pub fn try_resolve_class_ctor(
+pub fn try_resolve_constructor(
     db: &mut DbIndex,
     cache: &mut LuaInferCache,
-    unresolve_class_ctor: &mut UnResolveClassCtor,
+    unresolve_constructor: &mut UnResolveConstructor,
 ) -> ResolveResult {
     let signature = db
         .get_signature_index()
-        .get(&unresolve_class_ctor.signature_id)
+        .get(&unresolve_constructor.signature_id)
         .ok_or(InferFailReason::None)?;
     let param_info = signature
-        .get_param_info_by_id(unresolve_class_ctor.param_idx)
+        .get_param_info_by_id(unresolve_constructor.param_idx)
         .ok_or(InferFailReason::None)?;
-    let class_ctor_use = param_info
+    let constructor_use = param_info
         .attributes
         .iter()
         .flatten()
-        .find(|attr| attr.id.get_name() == "class_ctor")
+        .find(|attr| attr.id.get_name() == "constructor")
         .ok_or(InferFailReason::None)?;
     let LuaType::DocStringConst(target_signature_name) =
-        class_ctor_use.args.first().ok_or(InferFailReason::None)?
+        constructor_use.args.first().ok_or(InferFailReason::None)?
     else {
         return Err(InferFailReason::None);
     };
-    let target_type_decl_id = get_class_ctor_target_type(
+    let target_type_decl_id = get_constructor_target_type(
         db,
         cache,
         &param_info.type_ref,
-        unresolve_class_ctor.call_expr.clone(),
-        unresolve_class_ctor.param_idx,
+        unresolve_constructor.call_expr.clone(),
+        unresolve_constructor.param_idx,
     )
     .ok_or(InferFailReason::None)?;
     let target_type = LuaType::Ref(target_type_decl_id);
@@ -290,14 +289,14 @@ pub fn try_resolve_class_ctor(
         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) {
+        if let Some(LuaType::DocBooleanConst(strip_self)) = constructor_use.args.get(1) {
             *strip_self
         } else {
             true
         }
     };
     let return_self = {
-        if let Some(LuaType::DocBooleanConst(return_self)) = class_ctor_use.args.get(2) {
+        if let Some(LuaType::DocBooleanConst(return_self)) = constructor_use.args.get(2) {
             *return_self
         } else {
             true
@@ -358,7 +357,7 @@ fn set_signature_to_default_call(
     Some(())
 }
 
-fn get_class_ctor_target_type(
+fn get_constructor_target_type(
     db: &DbIndex,
     cache: &mut LuaInferCache,
     param_type: &LuaType,

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

@@ -131,7 +131,7 @@ mod test {
         ws.def(
             r#"
             ---@generic T
-            ---@param [class_ctor("__init")] name `T`
+            ---@param [constructor("__init")] name `T`
             ---@return T
             function meta(name)
             end

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

@@ -66,7 +66,7 @@ mod test {
     }
 
     #[test]
-    fn test_class_ctor() {
+    fn test_constructor() {
         let mut ws = VirtualWorkspace::new();
 
         ws.def_files(vec![
@@ -79,10 +79,10 @@ mod test {
             (
                 "meta.lua",
                 r#"
-            ---@attribute class_ctor(name: string, strip_self: boolean?, return_self: boolean?)
+            ---@attribute constructor(name: string, strip_self: boolean?, return_self: boolean?)
 
             ---@generic T
-            ---@param [class_ctor("__init")] name `T`
+            ---@param [constructor("__init")] name `T`
             ---@return T
             function meta(name)
             end
@@ -92,10 +92,10 @@ mod test {
 
         // ws.def(
         //     r#"
-        //     ---@attribute class_ctor(name: string, strip_self: boolean?, return_self: boolean?)
+        //     ---@attribute constructor(name: string, strip_self: boolean?, return_self: boolean?)
 
         //     ---@generic T
-        //     ---@param [class_ctor("__init")] name `T`
+        //     ---@param [constructor("__init")] name `T`
         //     ---@return T
         //     function meta(name)
         //     end

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

@@ -32,10 +32,10 @@ mod test {
         let mut ws = VirtualWorkspace::new();
         ws.def(
             r#"
-            ---@attribute class_ctor(name: string, strip_self: boolean?, return_self: boolean?)
+            ---@attribute constructor(name: string, strip_self: boolean?, return_self: boolean?)
 
             ---@generic T
-            ---@param [class_ctor("__init")] name `T`
+            ---@param [constructor("__init")] name `T`
             ---@return T
             function meta(name)
             end

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

@@ -140,7 +140,7 @@ mod tests {
         ws.def(
             r#"
             ---@generic T
-            ---@param [class_ctor("__init")] name `T`
+            ---@param [constructor("__init")] name `T`
             ---@return T
             function meta(name)
             end