support generic typeguard

Author: CppCXY

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

@@ -919,4 +919,30 @@ end
         let b_expected = ws.ty("string");
         assert_eq!(b, b_expected);
     }
+
+    #[test]
+    fn test_feature_generic_type_guard() {
+        let mut ws = VirtualWorkspace::new();
+
+        ws.def(
+            r#"
+            ---@generic T
+            ---@param type `T`
+            ---@return TypeGuard<T>
+            local function instanceOf(inst, type)
+                return true
+            end
+            
+            local ret --- @type string | nil
+            
+            if instanceOf(ret, "string") then
+                a = ret
+            end
+            "#,
+        );
+
+        let a = ws.expr_ty("a");
+        let a_expected = ws.ty("string");
+        assert_eq!(a, a_expected);
+    }
 }

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

@@ -291,6 +291,7 @@ impl LuaType {
             LuaType::Nil | LuaType::Boolean | LuaType::Any | LuaType::Unknown => false,
             LuaType::BooleanConst(boolean) | LuaType::DocBooleanConst(boolean) => boolean.clone(),
             LuaType::Union(u) => u.is_always_truthy(),
+            LuaType::TypeGuard(_) => false,
             _ => true,
         }
     }
@@ -299,6 +300,7 @@ impl LuaType {
         match self {
             LuaType::Nil | LuaType::BooleanConst(false) | LuaType::DocBooleanConst(false) => true,
             LuaType::Union(u) => u.is_always_falsy(),
+            LuaType::TypeGuard(_) => false,
             _ => false,
         }
     }
@@ -400,6 +402,7 @@ impl LuaType {
             LuaType::StrTplRef(_) => true,
             LuaType::SelfInfer => true,
             LuaType::MultiLineUnion(inner) => inner.contain_tpl(),
+            LuaType::TypeGuard(inner) => inner.contain_tpl(),
             _ => false,
         }
     }

crates/emmylua_code_analysis/src/semantic/generic/instantiate_type_generic.rs

@@ -45,6 +45,10 @@ pub fn instantiate_type_generic(
                 LuaType::SelfInfer
             }
         }
+        LuaType::TypeGuard(guard) => {
+            let inner = instantiate_type_generic(db, guard.deref(), substitutor);
+            LuaType::TypeGuard(inner.into())
+        }
         _ => ty.clone(),
     }
 }

crates/emmylua_code_analysis/src/semantic/infer/infer_call/mod.rs

@@ -107,15 +107,19 @@ pub fn infer_call_expr_func(
     };
 
     let result = if let Ok(func_ty) = result {
-        unwrapp_return_type(db, cache, func_ty.get_ret().clone(), call_expr).map(|new_ret| {
-            LuaFunctionType::new(
-                func_ty.is_async(),
-                func_ty.is_colon_define(),
-                func_ty.get_params().to_vec(),
-                new_ret,
-            )
-            .into()
-        })
+        let func_ret = func_ty.get_ret();
+        match func_ret {
+            LuaType::TypeGuard(_) => Ok(func_ty),
+            _ => unwrapp_return_type(db, cache, func_ret.clone(), call_expr).map(|new_ret| {
+                LuaFunctionType::new(
+                    func_ty.is_async(),
+                    func_ty.is_colon_define(),
+                    func_ty.get_params().to_vec(),
+                    new_ret,
+                )
+                .into()
+            }),
+        }
     } else {
         result
     };

crates/emmylua_code_analysis/src/semantic/infer/narrow/condition_flow/call_flow.rs

@@ -1,9 +1,9 @@
-use std::ops::Deref;
+use std::{ops::Deref, sync::Arc};
 
 use emmylua_parser::{LuaCallExpr, LuaChunk, LuaExpr};
 
 use crate::{
-    infer_expr,
+    infer_call_expr_func, infer_expr,
     semantic::infer::{
         narrow::{
             condition_flow::InferConditionFlow, get_single_antecedent,
@@ -12,8 +12,8 @@ use crate::{
         },
         VarRefId,
     },
-    DbIndex, FlowNode, FlowTree, InferFailReason, LuaInferCache, LuaSignatureCast, LuaSignatureId,
-    LuaType, TypeOps,
+    DbIndex, FlowNode, FlowTree, InferFailReason, InferGuard, LuaFunctionType, LuaInferCache,
+    LuaSignatureCast, LuaSignatureId, LuaType, TypeOps,
 };
 
 pub fn get_type_at_call_expr(
@@ -35,15 +35,15 @@ pub fn get_type_at_call_expr(
         LuaType::DocFunction(f) => {
             let return_type = f.get_ret();
             match return_type {
-                LuaType::TypeGuard(guard_type) => get_type_at_call_expr_by_type_guard(
+                LuaType::TypeGuard(_) => get_type_at_call_expr_by_type_guard(
                     db,
                     tree,
                     cache,
                     root,
                     var_ref_id,
                     flow_node,
                     call_expr,
-                    guard_type.deref().clone(),
+                    f,
                     condition_flow,
                 ),
                 _ => {
@@ -53,6 +53,25 @@ pub fn get_type_at_call_expr(
             }
         }
         LuaType::Signature(signature_id) => {
+            let Some(signature) = db.get_signature_index().get(&signature_id) else {
+                return Ok(ResultTypeOrContinue::Continue);
+            };
+
+            let ret = signature.get_return_type();
+            if let LuaType::TypeGuard(_) = ret {
+                return get_type_at_call_expr_by_type_guard(
+                    db,
+                    tree,
+                    cache,
+                    root,
+                    var_ref_id,
+                    flow_node,
+                    call_expr,
+                    signature.to_doc_func_type(),
+                    condition_flow,
+                );
+            }
+
             let Some(signature_cast) = db
                 .get_flow_index()
                 .get_signature_cast(&cache.get_file_id(), &signature_id)
@@ -102,7 +121,7 @@ fn get_type_at_call_expr_by_type_guard(
     var_ref_id: &VarRefId,
     flow_node: &FlowNode,
     call_expr: LuaCallExpr,
-    guard_type: LuaType,
+    func_type: Arc<LuaFunctionType>,
     condition_flow: InferConditionFlow,
 ) -> Result<ResultTypeOrContinue, InferFailReason> {
     let Some(arg_list) = call_expr.get_args_list() else {
@@ -121,6 +140,26 @@ fn get_type_at_call_expr_by_type_guard(
         return Ok(ResultTypeOrContinue::Continue);
     }
 
+    let mut return_type = func_type.get_ret().clone();
+    if return_type.contain_tpl() {
+        let call_expr_type = LuaType::DocFunction(func_type);
+        let inst_func = infer_call_expr_func(
+            db,
+            cache,
+            call_expr,
+            call_expr_type,
+            &mut InferGuard::new(),
+            None,
+        )?;
+
+        return_type = inst_func.get_ret().clone();
+    }
+
+    let guard_type = match return_type {
+        LuaType::TypeGuard(guard) => guard.deref().clone(),
+        _ => return Ok(ResultTypeOrContinue::Continue),
+    };
+
     match condition_flow {
         InferConditionFlow::TrueCondition => Ok(ResultTypeOrContinue::Result(guard_type)),
         InferConditionFlow::FalseCondition => {