Merge pull request #514 from xuhuanzy/fix

update

Author: CppCXY

crates/emmylua_code_analysis/locales/lint.yml

@@ -169,8 +169,8 @@ Cannot use `...` outside a vararg function.:
   en: 'Cannot assign `%{value}` to `%{source}`. %{reason}'
   zh_CN: '不能将 `%{value}` 赋值给 `%{source}`。%{reason}'
   zh_HK: '不能將 `%{value}` 賦值給 `%{source}`。%{reason}'
-'The same file is duplicate requires.':
-  en: 'The same file is duplicate requires.'
+'The same file is required multiple times.':
+  en: 'The same file is required multiple times.'
   zh_CN: '同一个文件被重复 require。'
   zh_HK: '同一個文件被重複 require。'
 'Annotations specify that a return value is required here.':
@@ -241,10 +241,10 @@ Cannot use `...` outside a vararg function.:
   en: "Duplicate index `%{name}`."
   zh_CN: "重复定义的索引 `%{name}`."
   zh_HK: "重複定義的索引 `%{name}`."
-"the generic constraint must be a subclass of `%{source}`. %{reason}":
-  en: "the generic constraint must be a subclass of `%{source}`. %{reason}"
-  zh_CN: "泛型约束要求类型为 `%{source}` 子类。%{reason}"
-  zh_HK: "泛型約束要求類型為 `%{source}` 子類。%{reason}"
+"type `%{found}` does not satisfy the constraint `%{source}`. %{reason}":
+  en: "type `%{found}` does not satisfy the constraint `%{source}`. %{reason}"
+  zh_CN: "泛型约束要求为 `%{source}` 的子类, 但找到了 `%{found}`. %{reason}"
+  zh_HK: "泛型约束要求为 `%{source}` 的子类, 但找到了 `%{found}`. %{reason}"
 "the string template type does not match any type declaration":
   en: "the string template type does not match any type declaration"
   zh_CN: "字符串模板类型与任何类型声明不匹配"

crates/emmylua_code_analysis/resources/schema.json

@@ -119,6 +119,11 @@
     },
     "runtime": {
       "default": {
+        "classDefaultCall": {
+          "forceNonColon": false,
+          "forceReturnSelf": false,
+          "functionName": ""
+        },
         "extensions": [],
         "frameworkVersions": [],
         "requireLikeFunction": [],
@@ -154,6 +159,7 @@
     "strict": {
       "default": {
         "arrayIndex": true,
+        "docBaseConstMatchBaseType": true,
         "metaOverrideFileDefine": true,
         "requirePath": false,
         "typeCall": false
@@ -184,6 +190,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": [
         {
@@ -241,13 +267,6 @@
             "redundant-parameter"
           ]
         },
-        {
-          "description": "Inject field fail",
-          "type": "string",
-          "enum": [
-            "inject-field-fail"
-          ]
-        },
         {
           "description": "Unreachable code",
           "type": "string",
@@ -290,13 +309,6 @@
             "discard-returns"
           ]
         },
-        {
-          "description": "Disable global define",
-          "type": "string",
-          "enum": [
-            "disable-global-define"
-          ]
-        },
         {
           "description": "Undefined field",
           "type": "string",
@@ -339,13 +351,6 @@
             "redefined-label"
           ]
         },
-        {
-          "description": "Name Style check",
-          "type": "string",
-          "enum": [
-            "name-style-check"
-          ]
-        },
         {
           "description": "Code style check",
           "type": "string",
@@ -836,6 +841,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": [],
@@ -907,6 +925,11 @@
           "default": true,
           "type": "boolean"
         },
+        "docBaseConstMatchBaseType": {
+          "description": "Base constant types defined in doc can match base types, allowing int to match `---@alias id 1|2|3`, same for string.",
+          "default": false,
+          "type": "boolean"
+        },
         "metaOverrideFileDefine": {
           "description": "meta define overrides file define",
           "default": true,

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

@@ -56,7 +56,6 @@ pub fn analyze_field(analyzer: &mut DocAnalyzer, tag: LuaDocTagField) -> Option<
             LuaSemanticDeclId::Member(member_id),
         ),
     };
-
     if nullable && !field_type.is_nullable() {
         field_type = TypeOps::Union.apply(analyzer.db, &field_type, &LuaType::Nil);
     }

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

@@ -14,8 +14,8 @@ use crate::{
         AnalyzeError, LuaAliasCallType, LuaFunctionType, LuaGenericType, LuaIndexAccessKey,
         LuaIntersectionType, LuaObjectType, LuaStringTplType, LuaTupleType, LuaType, LuaUnionType,
     },
-    DiagnosticCode, GenericTpl, InFiled, LuaAliasCallKind, LuaMultiLineUnion, LuaTypeDeclId,
-    TypeOps, VariadicType,
+    DiagnosticCode, GenericTpl, InFiled, LuaAliasCallKind, LuaMultiLineUnion, LuaTupleStatus,
+    LuaTypeDeclId, TypeOps, VariadicType,
 };
 
 use super::{preprocess_description, DocAnalyzer};
@@ -82,7 +82,7 @@ pub fn infer_type(analyzer: &mut DocAnalyzer, node: LuaDocType) -> LuaType {
                 }
                 types.push(t);
             }
-            return LuaType::Tuple(LuaTupleType::new(types).into());
+            return LuaType::Tuple(LuaTupleType::new(types, LuaTupleStatus::DocResolve).into());
         }
         LuaDocType::Generic(generic_type) => {
             return infer_generic_type(analyzer, generic_type);

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,

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<'_> {

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(())
+}

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

@@ -21,15 +21,12 @@ pub fn check_reach_reason(
         | InferFailReason::RecursiveInfer => Some(true),
         InferFailReason::UnResolveDeclType(decl_id) => {
             let decl = db.get_decl_index().get_decl(decl_id)?;
-            if decl.is_param() {
+            let typ = db.get_type_index().get_type_cache(&decl_id.clone().into());
+            if typ.is_none() && decl.is_param() {
                 return Some(infer_param(db, decl).is_ok());
             }
 
-            Some(
-                db.get_type_index()
-                    .get_type_cache(&decl_id.clone().into())
-                    .is_some(),
-            )
+            Some(typ.is_some())
         }
         InferFailReason::UnResolveMemberType(member_id) => {
             let member = db.get_member_index().get_member(member_id)?;
@@ -52,13 +49,14 @@ pub fn check_reach_reason(
 pub fn resolve_all_reason(
     db: &mut DbIndex,
     reason_unresolves: &mut HashMap<InferFailReason, Vec<UnResolve>>,
+    loop_count: usize,
 ) {
     for (reason, _) in reason_unresolves.iter_mut() {
-        resolve_as_any(db, reason);
+        resolve_as_any(db, reason, loop_count);
     }
 }
 
-pub fn resolve_as_any(db: &mut DbIndex, reason: &InferFailReason) -> Option<()> {
+pub fn resolve_as_any(db: &mut DbIndex, reason: &InferFailReason, loop_count: usize) -> Option<()> {
     match reason {
         InferFailReason::None
         | InferFailReason::FieldNotFound
@@ -72,6 +70,10 @@ pub fn resolve_as_any(db: &mut DbIndex, reason: &InferFailReason) -> Option<()>
             );
         }
         InferFailReason::UnResolveMemberType(member_id) => {
+            // 第一次循环不处理, 或许需要判断`unresolves`是否全为取值再跳过?
+            if loop_count == 0 {
+                return Some(());
+            }
             let member = db.get_member_index().get_member(member_id)?;
             let key = member.get_key();
             let owner = db.get_member_index().get_current_owner(&member_id)?;

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

@@ -19,7 +19,7 @@ use resolve::{
     try_resolve_module_ref, try_resolve_return_point, try_resolve_table_field,
 };
 use resolve_closure::{
-    try_resolve_closure_params, try_resolve_closure_parent_params, try_resolve_closure_return,
+    try_resolve_call_closure_params, try_resolve_closure_parent_params, try_resolve_closure_return,
 };
 
 use super::{infer_manager::InferCacheManager, lua::LuaReturnPoint, AnalyzeContext};
@@ -50,7 +50,7 @@ pub fn analyze(db: &mut DbIndex, context: &mut AnalyzeContext) {
             infer_manager.set_force();
         }
 
-        resolve_all_reason(db, &mut reason_resolve);
+        resolve_all_reason(db, &mut reason_resolve, loop_count);
 
         if loop_count >= 5 {
             break;
@@ -179,7 +179,7 @@ fn try_resolve(
                         try_resolve_return_point(db, cache, un_resolve_return)
                     }
                     UnResolve::ClosureParams(un_resolve_closure_params) => {
-                        try_resolve_closure_params(db, cache, un_resolve_closure_params)
+                        try_resolve_call_closure_params(db, cache, un_resolve_closure_params)
                     }
                     UnResolve::ClosureReturn(un_resolve_closure_return) => {
                         try_resolve_closure_return(db, cache, un_resolve_closure_return)

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

@@ -100,7 +100,7 @@ pub fn try_resolve_table_field(
         LuaType::IntegerConst(i) => LuaMemberKey::Integer(i),
         _ => {
             if field_type.is_table() {
-                LuaMemberKey::Expr(field_type)
+                LuaMemberKey::ExprType(field_type)
             } else {
                 return Err(InferFailReason::None);
             }