special handle for pcall in check await in sync

Author: CppCXY

crates/emmylua_code_analysis/src/diagnostic/checker/await_in_sync.rs

@@ -1,7 +1,7 @@
-use emmylua_parser::{LuaAstNode, LuaCallExpr, LuaClosureExpr};
+use emmylua_parser::{LuaAstNode, LuaCallArgList, LuaCallExpr, LuaClosureExpr, LuaExpr};
 use rowan::NodeOrToken;
 
-use crate::{DiagnosticCode, LuaPropertyOwnerId, LuaSignatureId, SemanticModel};
+use crate::{DiagnosticCode, LuaPropertyOwnerId, LuaSignatureId, LuaType, SemanticModel};
 
 use super::DiagnosticContext;
 
@@ -10,7 +10,8 @@ pub const CODES: &[DiagnosticCode] = &[DiagnosticCode::AwaitInSync];
 pub fn check(context: &mut DiagnosticContext, semantic_model: &SemanticModel) -> Option<()> {
     let root = semantic_model.get_root().clone();
     for call_expr in root.descendants::<LuaCallExpr>() {
-        check_call_expr(context, semantic_model, call_expr);
+        check_call_expr(context, semantic_model, call_expr.clone());
+        check_pcall_or_xpcall(context, semantic_model, call_expr);
     }
 
     Some(())
@@ -21,9 +22,9 @@ fn check_call_expr(
     semantic_model: &SemanticModel,
     call_expr: LuaCallExpr,
 ) -> Option<()> {
-    let prefix_node = call_expr.get_prefix_expr()?;
+    let prefix_expr = call_expr.get_prefix_expr()?;
     let property_owner =
-        semantic_model.get_property_owner_id(NodeOrToken::Node(prefix_node.syntax().clone()))?;
+        semantic_model.get_property_owner_id(NodeOrToken::Node(prefix_expr.syntax().clone()))?;
 
     let property = semantic_model
         .get_db()
@@ -33,7 +34,7 @@ fn check_call_expr(
         if !check_call_is_in_async_function(semantic_model, call_expr).unwrap_or(false) {
             context.add_diagnostic(
                 DiagnosticCode::AwaitInSync,
-                prefix_node.get_range(),
+                prefix_expr.get_range(),
                 "await in sync function".to_string(),
                 None,
             );
@@ -43,17 +44,90 @@ fn check_call_expr(
     Some(())
 }
 
+fn check_pcall_or_xpcall(
+    context: &mut DiagnosticContext,
+    semantic_model: &SemanticModel,
+    call_expr: LuaCallExpr,
+) -> Option<()> {
+    let prefix_expr = call_expr.get_prefix_expr()?;
+    if let LuaExpr::NameExpr(name_expr) = prefix_expr {
+        let name = name_expr.get_name_text()?;
+        if name == "pcall" || name == "xpcall" {
+            let arg_list = call_expr.get_args_list()?;
+            let first_arg = arg_list.get_args().next()?;
+            let range = first_arg.get_range();
+            let arg_type = semantic_model.infer_expr(first_arg)?;
+            let is_async = match &arg_type {
+                LuaType::DocFunction(f) => f.is_async(),
+                LuaType::Signature(sig) => {
+                    let property_owner = LuaPropertyOwnerId::Signature(*sig);
+
+                    let property = semantic_model
+                        .get_db()
+                        .get_property_index()
+                        .get_property(property_owner)?;
+                    property.is_async
+                }
+                _ => return None,
+            };
+
+            if is_async {
+                if !check_call_is_in_async_function(semantic_model, call_expr).unwrap_or(false) {
+                    context.add_diagnostic(
+                        DiagnosticCode::AwaitInSync,
+                        range,
+                        "await in sync function".to_string(),
+                        None,
+                    );
+                }
+            }
+        }
+    }
+
+    Some(())
+}
+
 fn check_call_is_in_async_function(
     semantic_model: &SemanticModel,
     call_expr: LuaCallExpr,
 ) -> Option<bool> {
     let file_id = semantic_model.get_file_id();
-    let closure = call_expr.ancestors::<LuaClosureExpr>().next()?;
-    let signature_id = LuaSignatureId::from_closure(file_id, &closure);
-    let property_owner = LuaPropertyOwnerId::Signature(signature_id);
-    let property = semantic_model
-        .get_db()
-        .get_property_index()
-        .get_property(property_owner)?;
-    Some(property.is_async)
+    let closures = call_expr.ancestors::<LuaClosureExpr>();
+    for closure in closures {
+        let signature_id = LuaSignatureId::from_closure(file_id, &closure);
+        let property_owner = LuaPropertyOwnerId::Signature(signature_id);
+        let is_async = match semantic_model
+            .get_db()
+            .get_property_index()
+            .get_property(property_owner)
+        {
+            Some(p) => p.is_async,
+            None => false,
+        };
+        if is_async {
+            return Some(true);
+        }
+
+        if !is_in_pcall_or_xpcall(closure).unwrap_or(false) {
+            break;
+        }
+    }
+
+    Some(false)
+}
+
+// special case
+fn is_in_pcall_or_xpcall(closure: LuaClosureExpr) -> Option<bool> {
+    let call_expr = closure
+        .get_parent::<LuaCallArgList>()?
+        .get_parent::<LuaCallExpr>()?;
+    let prefix_expr = call_expr.get_prefix_expr()?;
+    if let LuaExpr::NameExpr(name_expr) = prefix_expr {
+        let name = name_expr.get_name_text()?;
+        if name == "pcall" || name == "xpcall" {
+            return Some(true);
+        }
+    }
+
+    Some(false)
 }

crates/emmylua_code_analysis/src/diagnostic/test/await_in_sync_test.rs

@@ -83,4 +83,37 @@ mod test {
         "#
         ));
     }
+
+    #[test]
+    fn test_issue_101() {
+        let mut ws = crate::VirtualWorkspace::new();
+
+        ws.def(
+            r#"
+        --- @async
+        function bar() end
+        "#,
+        );
+
+        assert!(ws.check_code_for(
+            DiagnosticCode::AwaitInSync,
+            r#"
+        --- @async
+        function foo()
+            pcall(function()
+                bar() -- EXPECTED OK
+            end)
+        end
+        "#
+        ));
+
+        assert!(!ws.check_code_for(
+            DiagnosticCode::AwaitInSync,
+            r#"
+        function baz()
+            pcall(bar)
+        end
+        "#
+        ));
+    }
 }