review #1/#6: traverse match guards + object/array literals (await placement, async-lowerability, review facts)

check_await_placement_expr, expr_first_await (AST RS0411 path), and
collect_body_facts_in_expr now recurse into match-arm guards and object/array
literal children instead of treating them as leaves. 'let xs = [await load()]' is
now correctly rejected (RS0411); review facts inside guards/object/array literals
are now collected. First slice of the central-traversal fix.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: Haofei

crates/rsscript/src/analyzer.rs

@@ -4847,6 +4847,10 @@ fn expr_first_await(expr: &Expr) -> Option<crate::diagnostic::Span> {
         | Expr::Try { value, .. } => expr_first_await(value),
         Expr::Closure { body, .. } => block_first_await(body),
         Expr::Match { value, arms, .. } => expr_first_await(value)
+            .or_else(|| {
+                arms.iter()
+                    .find_map(|arm| arm.guard.as_ref().and_then(expr_first_await))
+            })
             .or_else(|| arms.iter().find_map(|arm| block_first_await(&arm.body))),
         Expr::MapLiteral { entries, .. } => entries
             .iter()
@@ -4856,9 +4860,11 @@ fn expr_first_await(expr: &Expr) -> Option<crate::diagnostic::Span> {
                     .iter()
                     .find_map(|entry| expr_first_await(&entry.value))
             }),
-        Expr::ObjectLiteral { .. }
-        | Expr::ArrayLiteral { .. }
-        | Expr::Ident(..)
+        Expr::ObjectLiteral { fields, .. } => fields
+            .iter()
+            .find_map(|field| expr_first_await(&field.value)),
+        Expr::ArrayLiteral { items, .. } => items.iter().find_map(expr_first_await),
+        Expr::Ident(..)
         | Expr::Number(..)
         | Expr::String(..)
         | Expr::MultilineString(..)

crates/rsscript/src/checks/body.rs

@@ -2757,6 +2757,9 @@ fn check_await_placement_expr(
         HirExpr::Match { value, arms, .. } => {
             check_await_placement_expr(analyzer, value, function_is_async);
             for arm in arms {
+                if let Some(guard) = &arm.guard {
+                    check_await_placement_expr(analyzer, guard, function_is_async);
+                }
                 check_await_placement(analyzer, &arm.body, function_is_async);
             }
         }
@@ -2766,9 +2769,17 @@ fn check_await_placement_expr(
                 check_await_placement_expr(analyzer, &entry.value, function_is_async);
             }
         }
-        HirExpr::ObjectLiteral { .. }
-        | HirExpr::ArrayLiteral { .. }
-        | HirExpr::Ident { .. }
+        HirExpr::ObjectLiteral { fields, .. } => {
+            for field in fields {
+                check_await_placement_expr(analyzer, &field.value, function_is_async);
+            }
+        }
+        HirExpr::ArrayLiteral { items, .. } => {
+            for item in items {
+                check_await_placement_expr(analyzer, item, function_is_async);
+            }
+        }
+        HirExpr::Ident { .. }
         | HirExpr::Number { .. }
         | HirExpr::String { .. }
         | HirExpr::Unknown(_) => {}

crates/rsscript/src/hir.rs

@@ -2366,18 +2366,29 @@ fn collect_body_facts_in_expr(
         Expr::Match { value, arms, .. } => {
             collect_body_facts_in_expr(hir, function_name, value, value_types, facts);
             for arm in arms {
+                if let Some(guard) = &arm.guard {
+                    collect_body_facts_in_expr(hir, function_name, guard, value_types, facts);
+                }
                 collect_body_facts_in_block(hir, function_name, &arm.body, value_types, facts);
             }
         }
-        Expr::ObjectLiteral { .. } => {}
+        Expr::ObjectLiteral { fields, .. } => {
+            for field in fields {
+                collect_body_facts_in_expr(hir, function_name, &field.value, value_types, facts);
+            }
+        }
         Expr::MapLiteral { entries, .. } => {
             for entry in entries {
                 collect_body_facts_in_expr(hir, function_name, &entry.key, value_types, facts);
                 collect_body_facts_in_expr(hir, function_name, &entry.value, value_types, facts);
             }
         }
-        Expr::ArrayLiteral { .. }
-        | Expr::Ident(_, _)
+        Expr::ArrayLiteral { items, .. } => {
+            for item in items {
+                collect_body_facts_in_expr(hir, function_name, item, value_types, facts);
+            }
+        }
+        Expr::Ident(_, _)
         | Expr::Number(_, _)
         | Expr::String(_, _)
         | Expr::MultilineString(_, _)