support sync fun()

Author: CppCXY

crates/emmylua_code_analysis/resources/std/global.lua

@@ -245,7 +245,7 @@ function pairs(t) end
 --- `pcall` also returns all results from the call, after this first result. In
 --- case of any error, `pcall` returns **false** plus the error message.
 ---@generic T, R, R1
----@param f fun(...: T...): R1, R...
+---@param f sync fun(...: T...): R1, R...
 ---@param ... T...
 ---@return boolean, R1|string, R...
 function pcall(f, ...) end
@@ -443,7 +443,7 @@ _VERSION = "Lua 5.4"
 --- This function is similar to `pcall`, except that it sets a new message
 --- handler `msgh`.
 ---@generic T, R
----@param f fun(...:T...): R...
+---@param f sync fun(...:T...): R...
 ---@param msgh fun(err:string):void
 ---@param ... T...
 ---@return boolean, R...

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

@@ -6,8 +6,8 @@ use emmylua_parser::{
 };
 
 use crate::{
-    AnalyzeError, DiagnosticCode, LuaFunctionType, LuaMemberFeature, LuaMemberId, LuaSignatureId,
-    LuaTypeCache, OperatorFunction, TypeOps,
+    AnalyzeError, AsyncState, DiagnosticCode, LuaFunctionType, LuaMemberFeature, LuaMemberId,
+    LuaSignatureId, LuaTypeCache, OperatorFunction, TypeOps,
     compilation::analyzer::doc::preprocess_description,
     db_index::{
         LuaMember, LuaMemberKey, LuaMemberOwner, LuaOperator, LuaOperatorMetaMethod,
@@ -95,7 +95,7 @@ pub fn analyze_field(analyzer: &mut DocAnalyzer, tag: LuaDocTagField) -> Option<
                 analyzer.file_id,
                 range,
                 OperatorFunction::Func(Arc::new(LuaFunctionType::new(
-                    false,
+                    AsyncState::None,
                     false,
                     vec![
                         (
@@ -188,7 +188,7 @@ pub fn analyze_operator(analyzer: &mut DocAnalyzer, tag: LuaDocTagOperator) -> O
         analyzer.file_id,
         name_token.get_range(),
         OperatorFunction::Func(Arc::new(LuaFunctionType::new(
-            false,
+            AsyncState::None,
             false,
             operands,
             return_type,

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

@@ -10,7 +10,7 @@ use rowan::TextRange;
 use smol_str::SmolStr;
 
 use crate::{
-    DiagnosticCode, GenericTpl, InFiled, LuaAliasCallKind, LuaArrayLen, LuaArrayType,
+    AsyncState, DiagnosticCode, GenericTpl, InFiled, LuaAliasCallKind, LuaArrayLen, LuaArrayType,
     LuaMultiLineUnion, LuaTupleStatus, LuaTypeDeclId, TypeOps, VariadicType,
     db_index::{
         AnalyzeError, LuaAliasCallType, LuaFunctionType, LuaGenericType, LuaIndexAccessKey,
@@ -478,7 +478,13 @@ fn infer_func_type(analyzer: &mut DocAnalyzer, func: &LuaDocFuncType) -> LuaType
         }
     }
 
-    let is_async = func.is_async();
+    let async_state = if func.is_async() {
+        AsyncState::Async
+    } else if func.is_sync() {
+        AsyncState::Sync
+    } else {
+        AsyncState::None
+    };
 
     let mut is_colon = false;
     if let Some(parent) = func.get_parent::<LuaAst>() {
@@ -506,7 +512,7 @@ fn infer_func_type(analyzer: &mut DocAnalyzer, func: &LuaDocFuncType) -> LuaType
     };
 
     LuaType::DocFunction(
-        LuaFunctionType::new(is_async, is_colon, params_result, return_type).into(),
+        LuaFunctionType::new(async_state, is_colon, params_result, return_type).into(),
     )
 }
 

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

@@ -1,5 +1,6 @@
 use crate::{
-    LuaDeclId, LuaExport, LuaExportScope, LuaNoDiscard, LuaSemanticDeclId, LuaSignatureId,
+    AsyncState, LuaDeclId, LuaExport, LuaExportScope, LuaNoDiscard, LuaSemanticDeclId,
+    LuaSignatureId,
 };
 
 use super::{
@@ -110,7 +111,7 @@ pub fn analyze_async(analyzer: &mut DocAnalyzer, tag: LuaDocTagAsync) -> Option<
         .get_signature_index_mut()
         .get_mut(&signature_id)?;
 
-    signature.is_async = true;
+    signature.async_state = AsyncState::Async;
 
     Some(())
 }

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

@@ -50,22 +50,22 @@ pub fn try_resolve_call_closure_params(
         _ => {}
     }
 
-    let (is_async, params_to_insert) = if let Some(param_type) =
+    let (async_state, params_to_insert) = if let Some(param_type) =
         call_doc_func.get_params().get(param_idx)
     {
         let Some(param_type) = get_real_type(db, &param_type.1.as_ref().unwrap_or(&LuaType::Any))
         else {
             return Ok(());
         };
         match param_type {
-            LuaType::DocFunction(func) => (func.is_async(), func.get_params().to_vec()),
+            LuaType::DocFunction(func) => (func.get_async_state(), func.get_params().to_vec()),
             LuaType::Union(union_types) => {
                 if let Some(LuaType::DocFunction(func)) = union_types
                     .into_vec()
                     .iter()
                     .find(|typ| matches!(typ, LuaType::DocFunction(_)))
                 {
-                    (func.is_async(), func.get_params().to_vec())
+                    (func.get_async_state(), func.get_params().to_vec())
                 } else {
                     return Ok(());
                 }
@@ -98,7 +98,7 @@ pub fn try_resolve_call_closure_params(
         );
     }
 
-    signature.is_async = is_async;
+    signature.async_state = async_state;
 
     Ok(())
 }
@@ -394,7 +394,7 @@ fn resolve_closure_member_type(
                 db,
                 closure_params,
                 &LuaFunctionType::new(
-                    signature.is_async,
+                    signature.async_state,
                     signature.is_colon_define,
                     final_params,
                     final_ret,
@@ -437,9 +437,7 @@ fn resolve_doc_function(
         .get_mut(&closure_params.signature_id)
         .ok_or(InferFailReason::None)?;
 
-    if doc_func.is_async() {
-        signature.is_async = true;
-    }
+    signature.async_state = doc_func.get_async_state();
 
     let mut doc_params = doc_func.get_params().to_vec();
     // doc_func 是往上追溯的有效签名, signature 是未解析的签名

crates/emmylua_code_analysis/src/db_index/operators/lua_operator.rs

@@ -141,7 +141,7 @@ impl LuaOperator {
                         signature.get_return_type()
                     };
                     let func_type = LuaFunctionType::new(
-                        signature.is_async,
+                        signature.async_state,
                         is_colon_define,
                         params,
                         return_type,

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

@@ -0,0 +1,6 @@
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum AsyncState {
+    None,
+    Async,
+    Sync,
+}

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

@@ -1,5 +1,9 @@
+mod async_state;
+mod signature;
+
 use std::collections::{HashMap, HashSet};
 
+pub use async_state::AsyncState;
 pub use signature::{
     LuaDocParamInfo, LuaDocReturnInfo, LuaNoDiscard, LuaSignature, LuaSignatureId,
     SignatureReturnStatus,
@@ -9,8 +13,6 @@ use crate::FileId;
 
 use super::traits::LuaIndex;
 
-mod signature;
-
 #[derive(Debug)]
 pub struct LuaSignatureIndex {
     signatures: HashMap<LuaSignatureId, LuaSignature>,

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

@@ -6,6 +6,7 @@ use std::{collections::HashMap, sync::Arc};
 use emmylua_parser::{LuaAstNode, LuaClosureExpr, LuaDocFuncType};
 use rowan::TextSize;
 
+use crate::db_index::signature::async_state::AsyncState;
 use crate::{
     FileId,
     db_index::{LuaFunctionType, LuaType},
@@ -21,7 +22,7 @@ pub struct LuaSignature {
     pub return_docs: Vec<LuaDocReturnInfo>,
     pub resolve_return: SignatureReturnStatus,
     pub is_colon_define: bool,
-    pub is_async: bool,
+    pub async_state: AsyncState,
     pub nodiscard: Option<LuaNoDiscard>,
 }
 
@@ -41,7 +42,7 @@ impl LuaSignature {
             return_docs: Vec::new(),
             resolve_return: SignatureReturnStatus::UnResolve,
             is_colon_define: false,
-            is_async: false,
+            async_state: AsyncState::None,
             nodiscard: None,
         }
     }
@@ -157,7 +158,7 @@ impl LuaSignature {
         let params = self.get_type_params();
         let return_type = self.get_return_type();
         let func_type =
-            LuaFunctionType::new(self.is_async, self.is_colon_define, params, return_type);
+            LuaFunctionType::new(self.async_state, self.is_colon_define, params, return_type);
         Arc::new(func_type)
     }
 
@@ -168,7 +169,7 @@ impl LuaSignature {
         }
 
         let return_type = self.get_return_type();
-        let func_type = LuaFunctionType::new(self.is_async, false, params, return_type);
+        let func_type = LuaFunctionType::new(self.async_state, false, params, return_type);
         Arc::new(func_type)
     }
 }

crates/emmylua_code_analysis/src/db_index/type/humanize_type.rs

@@ -3,9 +3,10 @@ use std::collections::HashSet;
 use itertools::Itertools;
 
 use crate::{
-    DbIndex, GenericTpl, LuaAliasCallType, LuaFunctionType, LuaGenericType, LuaInstanceType,
-    LuaIntersectionType, LuaMemberKey, LuaMemberOwner, LuaObjectType, LuaSignatureId,
-    LuaStringTplType, LuaTupleType, LuaType, LuaTypeDeclId, LuaUnionType, VariadicType,
+    AsyncState, DbIndex, GenericTpl, LuaAliasCallType, LuaFunctionType, LuaGenericType,
+    LuaInstanceType, LuaIntersectionType, LuaMemberKey, LuaMemberOwner, LuaObjectType,
+    LuaSignatureId, LuaStringTplType, LuaTupleType, LuaType, LuaTypeDeclId, LuaUnionType,
+    VariadicType,
 };
 
 use super::{LuaAliasCallKind, LuaMultiLineUnion};
@@ -359,10 +360,10 @@ fn humanize_doc_function_type(
         return "fun(...) -> ...".to_string();
     }
 
-    let prev = if lua_func.is_async() {
-        "async fun"
-    } else {
-        "fun"
+    let prev = match lua_func.get_async_state() {
+        AsyncState::None => "fun",
+        AsyncState::Async => "async fun",
+        AsyncState::Sync => "sync fun",
     };
     let params = lua_func
         .get_params()