crates/biome_js_analyze/tests/specs/nursery/noPlaywrightNetworkidle/invalid/wait-for-load-state.js (1)

2-3: Optional: Consider one trailing blank line for consistency.

Most other test files in this batch have a single trailing blank line rather than two.

crates/biome_js_analyze/tests/specs/nursery/noPlaywrightForceOption/invalid/click.js (1)

2-3: Optional: Consider one trailing blank line for consistency.

Most other test files in this batch have a single trailing blank line rather than two.

crates/biome_js_analyze/tests/specs/nursery/noPlaywrightValidDescribeCallback/invalid/has-params.js (1)

1-3: Good invalid case for parameterised describe().

This neatly exercises the “no params in describe callback” branch.

If not already covered elsewhere, add a sibling invalid case for an async describe callback to hit that path too.

crates/biome_js_analyze/tests/specs/nursery/noPlaywrightEval/invalid/eval.js (1)

1-1: Covers the $eval pitfall; consider broadening.

Solid invalid sample. To harden coverage, also include: page.$$eval, frame.$eval, and frame.$$eval variants, plus a note in docs pointing to locator.evaluate()/evaluateAll().

crates/biome_js_analyze/tests/specs/nursery/noPlaywrightWaitForSelector/invalid/with-state.js (1)

1-2: Nice invalid fixture; show the preferred pattern too?

This triggers the rule as intended. Consider adding a nearby valid counterpart demonstrating:

• await expect(page.locator('#dialog')).toBeVisible();
• await page.locator('#dialog .button').click();

crates/biome_js_analyze/tests/specs/nursery/noPlaywrightWaitForTimeout/valid/other-methods.js (1)

1-3: Good showcase of timeout-free synchronisation.

These are sensible alternatives. Optional: add await expect(page).toHaveURL('/home'); to mirror the URL case with assertions.

crates/biome_js_analyze/src/lint/nursery/no_playwright_wait_for_navigation.rs (3)

41-47: Add the Test domain so this rule self-enables in test contexts

Include the testing domain to pick up globals like test/describe automatically and avoid surprising activation in non-test code.

-    pub NoPlaywrightWaitForNavigation {
+    pub NoPlaywrightWaitForNavigation {
         version: "next",
         name: "noPlaywrightWaitForNavigation",
         language: "js",
         sources: &[RuleSource::EslintPlaywright("no-wait-for-navigation").same()],
+        domains: &[RuleDomain::Test],
         recommended: false,
     }

Also add the import:

-use biome_analyze::{
-    context::RuleContext, declare_lint_rule, Ast, Rule, RuleDiagnostic, RuleSource,
-};
+use biome_analyze::{
+    context::RuleContext, declare_lint_rule, Ast, Rule, RuleDiagnostic, RuleSource, RuleDomain,
+};

---

96-104: Mark as deprecated and avoid hard-coding “page.” in the message

Tagging the diagnostic as deprecated improves UX in editors. The message should be generic since the receiver could be frame or a variable like myPage.

-                markup! {
-                    "Unexpected use of "<Emphasis>"page.waitForNavigation()"</Emphasis>"."
-                },
+                markup! {
+                    "Unexpected use of "<Emphasis>"waitForNavigation()"</Emphasis>"."
+                },
             )
+            .deprecated()

---

60-77: Broaden callee detection (optional chaining/computed members are missed)

Currently only JsStaticMemberExpression is handled; calls like page?.waitForNavigation() or page["waitForNavigation"]() won’t be flagged. Not a blocker, but worth a follow-up for parity with ESLint.

Would you like me to open a follow-up to add JsComputedMemberExpression and optional-chaining support?

crates/biome_js_analyze/src/lint/nursery/no_playwright_valid_describe_callback.rs (1)

47-53: Add the Test domain to scope this rule correctly

Helps auto-enable where Playwright tests live and keeps noise out of app code.

     pub NoPlaywrightValidDescribeCallback {
         version: "next",
         name: "noPlaywrightValidDescribeCallback",
         language: "js",
         sources: &[RuleSource::EslintPlaywright("valid-describe-callback").same()],
+        domains: &[RuleDomain::Test],
         recommended: false,
     }

And import:

-use biome_analyze::{
-    context::RuleContext, declare_lint_rule, Ast, Rule, RuleDiagnostic, RuleSource,
-};
+use biome_analyze::{
+    context::RuleContext, declare_lint_rule, Ast, Rule, RuleDiagnostic, RuleSource, RuleDomain,
+};

crates/biome_js_analyze/src/lint/nursery/no_playwright_networkidle.rs (1)

39-45: Add the Test domain to scope activation

Keeps this lint where Playwright lives.

     pub NoPlaywrightNetworkidle {
         version: "next",
         name: "noPlaywrightNetworkidle",
         language: "js",
         sources: &[RuleSource::EslintPlaywright("no-networkidle").same()],
+        domains: &[RuleDomain::Test],
         recommended: false,
     }

And update imports:

-use biome_analyze::{
-    context::RuleContext, declare_lint_rule, Ast, Rule, RuleDiagnostic, RuleSource,
-};
+use biome_analyze::{
+    context::RuleContext, declare_lint_rule, Ast, Rule, RuleDiagnostic, RuleSource, RuleDomain,
+};

crates/biome_js_analyze/src/lint/nursery/no_playwright_wait_for_timeout.rs (3)

41-47: Add the Test domain

Same rationale as the other Playwright lints.

     pub NoPlaywrightWaitForTimeout {
         version: "next",
         name: "noPlaywrightWaitForTimeout",
         language: "js",
         sources: &[RuleSource::EslintPlaywright("no-wait-for-timeout").same()],
+        domains: &[RuleDomain::Test],
         recommended: false,
     }

Plus import:

-use biome_analyze::{
-    context::RuleContext, declare_lint_rule, Ast, Rule, RuleDiagnostic, RuleSource,
-};
+use biome_analyze::{
+    context::RuleContext, declare_lint_rule, Ast, Rule, RuleDiagnostic, RuleSource, RuleDomain,
+};

---

96-104: Make the message receiver‑agnostic

The callee may be frame or myPage; keep the copy generic.

-                markup! {
-                    "Unexpected use of "<Emphasis>"page.waitForTimeout()"</Emphasis>"."
-                },
+                markup! {
+                    "Unexpected use of "<Emphasis>"waitForTimeout()"</Emphasis>"."
+                },

---

60-77: Optional: support optional chaining/computed members

As with the navigation rule, page?.waitForTimeout() or page["waitForTimeout"]() won’t match. Worth a follow-up if you aim for full parity with ESLint.

crates/biome_js_analyze/src/lint/nursery/no_playwright_eval.rs (1)

55-65: Broaden member handling (optional chaining/computed) later.

Casting only to JsStaticMemberExpression misses page?.$eval and computed forms. Consider using a member‑union (e.g. AnyJsMemberExpression) and normalising the name.

crates/biome_js_analyze/src/lint/nursery/no_playwright_skipped_test.rs (1)

55-109: Reduce false positives by verifying the identifier binding.

This will also flag Jest/Mocha’s test.skip/describe.skip. Prefer a semantic query and confirm test/describe originate from @playwright/test via ctx.model().

Happy to draft a Semantic<JsCallExpression> variant that resolves the import and keeps your recursive chain logic.

crates/biome_js_analyze/src/lint/nursery/missing_playwright_await.rs (1)

459-492: Async-context helper scope

This helper is local-only; if other rules need it, consider pub(crate) and moving it to a shared utils module to avoid drift with similar logic elsewhere.

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

crates/biome_js_analyze/src/lint/nursery/missing_playwright_await.rs (2)

220-251: Bug: expect.poll(...).toBe(...) slips through due to detection order.

Detect expect.poll before gating on async matchers; otherwise sync matchers (e.g. toBe) short-circuit and poll is missed.

 fn get_async_expect_matcher(call_expr: &JsCallExpression) -> Option<MissingAwaitType> {
     let callee = call_expr.callee().ok()?;
-    // Must be a member expression (matcher call)
-    let member_expr = callee.as_js_static_member_expression()?;
-
-    // Get the matcher name
-    let member = member_expr.member().ok()?;
-    let name = member.as_js_name()?;
-    let token = name.value_token().ok()?;
-    let matcher_name = token.text_trimmed().to_string();
-
-    // Check if it's an async Playwright matcher
-    if !ASYNC_PLAYWRIGHT_MATCHERS.contains(&matcher_name.as_str()) {
-        return None;
-    }
-
-    // Walk up the chain to find if this is an expect() call
-    let object = member_expr.object().ok()?;
-
-    // Check for expect.poll
-    if has_poll_in_chain(&object) {
-        return Some(MissingAwaitType::ExpectPoll);
-    }
+    // Must be a member expression (matcher call)
+    let member_expr = callee.as_js_static_member_expression()?;
+
+    // Walk up the chain first and catch `expect.poll(...)`
+    let object = member_expr.object().ok()?;
+    if has_poll_in_chain(&object) {
+        return Some(MissingAwaitType::ExpectPoll);
+    }
+
+    // Get the matcher name
+    let member = member_expr.member().ok()?;
+    let name = member.as_js_name()?;
+    let token = name.value_token().ok()?;
+    let matcher_name = token.text_trimmed().to_string();
+
+    // Check if it's an async Playwright matcher
+    if !ASYNC_PLAYWRIGHT_MATCHERS.contains(&matcher_name.as_str()) {
+        return None;
+    }
 
     // Check if the chain starts with expect
-    if has_expect_in_chain(&object) {
+    if has_expect_in_chain(&object) {
         return Some(MissingAwaitType::ExpectMatcher(matcher_name));
     }

---

164-189: Auto-fix may serialise Promise.all([...]); prefer awaiting the outer call.

When an offending call is inside a non‑awaited/returned Promise.all, awaiting the inner call changes semantics. Wrap the enclosing Promise.all(...) instead.

 fn action(ctx: &RuleContext<Self>, _: &Self::State) -> Option<JsRuleAction> {
     let call_expr = ctx.query();
@@
     if !is_in_async_context(call_expr.syntax()) {
         return None;
     }
 
-    let mut mutation = ctx.root().begin();
+    // If inside Promise.all([...]) that itself isn’t awaited/returned, fix the outer call.
+    if let Some(promise_all) = find_enclosing_promise_all(call_expr) {
+        if !is_call_awaited_or_returned(&promise_all) {
+            let mut mutation = ctx.root().begin();
+            let await_expr = make::js_await_expression(make::token(T![await]), promise_all.clone().into());
+            mutation.replace_element(promise_all.into_syntax().into(), await_expr.into_syntax().into());
+            return Some(JsRuleAction::new(
+                ctx.metadata().action_category(ctx.category(), ctx.group()),
+                Applicability::MaybeIncorrect,
+                markup! { "Add await to Promise.all" }.to_owned(),
+                mutation,
+            ));
+        }
+    }
+
+    let mut mutation = ctx.root().begin();
@@
     Some(JsRuleAction::new(
         ctx.metadata().action_category(ctx.category(), ctx.group()),
         Applicability::MaybeIncorrect,
         markup! { "Add await" }.to_owned(),
         mutation,
     ))
 }

crates/biome_js_analyze/src/lint/nursery/no_playwright_valid_describe_callback.rs (1)

54-57: Report non‑function callbacks; align with ESLint.

Right now non‑function callbacks like describe('x', 42) return None (Line 142), so they slip through. ESLint flags these. Add a NotFunction reason and diagnose it. Also consider flagging return inside the callback for closer parity.

 pub enum InvalidReason {
     Async,
     HasParameters,
+    NotFunction,
 }

@@
         match callback_expr {
             AnyJsExpression::JsArrowFunctionExpression(arrow) => {
@@
             }
             AnyJsExpression::JsFunctionExpression(func) => {
@@
             }
-            _ => return None, // Not a function, but we won't report this
+            _ => return Some(InvalidReason::NotFunction),
         }
@@
     fn diagnostic(ctx: &RuleContext<Self>, state: &Self::State) -> Option<RuleDiagnostic> {
@@
-        let (message, note) = match state {
+        let (message, note) = match state {
             InvalidReason::Async => (
@@
             ),
             InvalidReason::HasParameters => (
@@
             ),
+            InvalidReason::NotFunction => (
+                markup! { "Second argument to "<Emphasis>"describe()"</Emphasis>" must be a function." },
+                markup! { "Pass a synchronous callback function with no parameters." },
+            ),
         };

Optional parity improvement (brief sketch): after validating arrow/function, scan the body for return statements and report another reason (e.g., ReturnsFromCallback). Happy to wire this if you want it in this batch.

Also applies to: 108-145, 151-160

crates/biome_js_analyze/src/lint/nursery/no_playwright_force_option.rs (1)

5-5: Two fixes: (1) scope to Playwright receivers; (2) detect identifier force keys.

• Without receiver checks, any .click({ force: true }) is flagged (false positives).
• has_force_true only matches string-literal keys, missing the common { force: true } identifier form.

- use biome_js_syntax::{AnyJsExpression, JsCallExpression, JsObjectExpression};
+ use biome_js_syntax::{AnyJsExpression, AnyJsObjectMemberName, JsCallExpression, JsObjectExpression};
@@
         if !METHODS_WITH_FORCE.contains(&method_name) {
             return None;
         }
 
+        // Narrow to likely Playwright receivers (page/frame/... or locator/getBy* chain)
+        let object = member_expr.object().ok()?;
+        let object_text = match object {
+            AnyJsExpression::JsIdentifierExpression(id) => {
+                id.name().ok()?.value_token().ok()?.text_trimmed().to_string()
+            }
+            AnyJsExpression::JsStaticMemberExpression(member) => {
+                member.member().ok()?.as_js_name()?.value_token().ok()?.text_trimmed().to_string()
+            }
+            AnyJsExpression::JsCallExpression(call) => {
+                // e.g. page.locator(...).click(...)
+                let callee = call.callee().ok()?;
+                if let Some(m) = biome_js_syntax::JsStaticMemberExpression::cast_ref(callee.syntax()) {
+                    let name = m.member().ok()?.as_js_name()?.value_token().ok()?.text_trimmed();
+                    if ["locator","getByRole","getByText","getByLabel","getByTitle","getByAltText","getByPlaceholder","getByTestId"].contains(&name) {
+                        "__pw_locator__".to_string()
+                    } else {
+                        return None;
+                    }
+                } else {
+                    return None;
+                }
+            }
+            _ => return None,
+        };
+        if !(object_text == "page"
+            || object_text == "frame"
+            || object_text.ends_with("Page")
+            || object_text.ends_with("Frame")
+            || object_text == "__pw_locator__")
+        {
+            return None;
+        }
+
@@
 fn has_force_true(obj_expr: &JsObjectExpression) -> bool {
     for member in obj_expr.members().into_iter().flatten() {
         if let Some(prop) = member.as_js_property_object_member() {
-            // Check if property name is 'force'
-            if let Ok(name) = prop.name() {
-                if let Some(name_node) = name.as_js_literal_member_name() {
-                    if let Ok(name_token) = name_node.value() {
-                        if name_token.text_trimmed() == "force" {
-                            // Check if value is true
-                            if let Ok(value) = prop.value() {
-                                if let Some(literal) = value.as_any_js_literal_expression() {
-                                    if let Some(bool_lit) =
-                                        literal.as_js_boolean_literal_expression()
-                                    {
-                                        if let Ok(value_token) = bool_lit.value_token() {
-                                            if value_token.text_trimmed() == "true" {
-                                                return true;
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
+            if let Ok(name) = prop.name() {
+                let is_force_key = match name {
+                    AnyJsObjectMemberName::JsName(n) => {
+                        n.value_token().ok().map_or(false, |t| t.text_trimmed() == "force")
+                    }
+                    AnyJsObjectMemberName::JsLiteralMemberName(lit) => {
+                        lit.value().ok().map_or(false, |t| {
+                            let txt = t.text_trimmed();
+                            txt == "force" || txt.trim_matches(['"', '\'']).eq("force")
+                        })
+                    }
+                };
+                if is_force_key {
+                    if let Ok(value) = prop.value() {
+                        if let Some(literal) = value.as_any_js_literal_expression() {
+                            if let Some(bool_lit) = literal.as_js_boolean_literal_expression() {
+                                if let Ok(value_token) = bool_lit.value_token() {
+                                    if value_token.text_trimmed() == "true" {
+                                        return true;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
         }
     }
 
     false
 }

I can add snapshot tests for identifier keys and non‑PW receivers to keep this tight.

Also applies to: 77-87, 88-102, 124-154

crates/biome_js_analyze/src/lint/nursery/no_playwright_networkidle.rs (1)

58-68: Add a page/frame receiver guard to avoid false positives.

Right now any waitForLoadState/navigation-like call is flagged regardless of receiver. This will trip on non‑Playwright APIs. Mirror the receiver guard used in sibling rules (page/frame or names ending with Page/Frame) before method checks.

Apply this diff after computing method_name:

         let method_name = member_text.text_trimmed();
 
+        // Ensure the receiver is page/frame-like to avoid false positives
+        let object = member_expr.object().ok()?;
+        let object_text = match object {
+            AnyJsExpression::JsIdentifierExpression(id) => {
+                id.name().ok()?.value_token().ok()?.text_trimmed().to_string()
+            }
+            AnyJsExpression::JsStaticMemberExpression(member) => {
+                member.member().ok()?.as_js_name()?.value_token().ok()?.text_trimmed().to_string()
+            }
+            _ => return None,
+        };
+        let is_page_like = object_text == "page"
+            || object_text == "frame"
+            || object_text.ends_with("Page")
+            || object_text.ends_with("Frame");
+        if !is_page_like {
+            return None;
+        }

Also applies to: 69-87, 89-103

crates/biome_js_analyze/src/lint/nursery/no_playwright_eval.rs (1)

105-107: Make the diagnostic object‑agnostic (don’t hard‑code page.).

This rule also triggers on frames/custom page vars; message should not pin the receiver.

-                    "Unexpected use of "<Emphasis>"page."{{state}}"()"</Emphasis>"."
+                    "Unexpected use of "<Emphasis>"{{state}}()"</Emphasis>"."

crates/biome_js_analyze/src/lint/nursery/no_playwright_element_handle.rs (1)

119-127: Note text assumes page.; generalise it.

Apply the earlier suggestion so guidance fits frame/variables too.

-                "Element handles like "<Emphasis>"page."{{state}}"()"</Emphasis>" are discouraged."
+                "Element handles like "<Emphasis>"{{state}}()"</Emphasis>" are discouraged."

-                "Use "<Emphasis>"page.locator()"</Emphasis>" or other locator methods like "<Emphasis>"getByRole()"</Emphasis>" instead."
+                "Use "<Emphasis>"locator()"</Emphasis>" or other locator methods like "<Emphasis>"getByRole()"</Emphasis>" instead."

crates/biome_js_analyze/src/lint/nursery/no_playwright_wait_for_selector.rs (1)

108-116: Message assumes page.; make it generic.

Drop the receiver name to avoid misleading users when it’s frame or a variable.

-                    "Unexpected use of "<Emphasis>"page.waitForSelector()"</Emphasis>"."
+                    "Unexpected use of "<Emphasis>"waitForSelector()"</Emphasis>"."

crates/biome_rule_options/src/no_playwright_force_option.rs (1)

1-6: Solid; add a short rustdoc for consistency.

Pattern matches other options. Add a brief comment to aid generated docs and future readers.

+/// Options for the `noPlaywrightForceOption` rule.
+/// Empty placeholder, kept for compatibility with future configuration.
+/// Mirrors `eslint-plugin-playwright/no-force-option`.
 #[derive(Default, Clone, Debug, Deserialize, Deserializable, Eq, PartialEq, Serialize)]

Based on learnings.

crates/biome_rule_options/src/no_playwright_eval.rs (1)

1-6: All good; add rustdoc for discoverability.

Consistent derives/serde. Please add a brief doc comment so it shows up in generated docs.

+/// Options for the `noPlaywrightEval` rule.
+/// Empty; reserved for future flags and schema generation.
+/// Mirrors `eslint-plugin-playwright/no-eval`.
 #[derive(Default, Clone, Debug, Deserialize, Deserializable, Eq, PartialEq, Serialize)]

Based on learnings.

crates/biome_rule_options/src/no_playwright_wait_for_selector.rs (1)

1-6: Nice one; tiny follow-up: add rustdoc.

The struct is correct; add a short doc describing the rule and why the options are empty.

+/// Options for the `noPlaywrightWaitForSelector` rule.
+/// Empty placeholder kept for forwards compatibility and schema generation.
+/// Mirrors `eslint-plugin-playwright/no-wait-for-selector`.
 #[derive(Default, Clone, Debug, Deserialize, Deserializable, Eq, PartialEq, Serialize)]

Based on learnings.

crates/biome_rule_options/src/missing_playwright_await.rs (1)

3-6: Add rustdoc for the options type.

Tiny nit: document the options struct to meet the crate’s “document rules/options” guideline.

 #[derive(Default, Clone, Debug, Deserialize, Deserializable, Eq, PartialEq, Serialize)]
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
 #[serde(rename_all = "camelCase", deny_unknown_fields, default)]
-pub struct MissingPlaywrightAwaitOptions {}
+/// Options for the `missingPlaywrightAwait` rule. Currently no configuration.
+pub struct MissingPlaywrightAwaitOptions {}

Based on learnings.

crates/biome_js_analyze/src/lint/nursery/no_playwright_page_pause.rs (1)

111-120: Message mentions only page.pause() but rule also matches frame.pause().

Widen the phrasing to avoid confusion (or compute the receiver and format dynamically).

-                markup! {
-                    "Unexpected use of "<Emphasis>"page.pause()"</Emphasis>"."
-                },
+                markup! {
+                    "Unexpected use of "<Emphasis>"pause()"</Emphasis>" on Playwright Page/Frame."
+                },
@@
-                <Emphasis>"page.pause()"</Emphasis>" is a debugging utility and should not be committed to version control."
+                <Emphasis>"pause()"</Emphasis>" is a debugging utility and should not be committed to version control."

crates/biome_js_analyze/src/lint/nursery/no_playwright_networkidle.rs (1)

128-151: Handle quoted property keys for waitUntil.

name_token.text_trimmed() == "waitUntil" misses { 'waitUntil': 'networkidle' }. Trim quotes to support both forms.

-                    if let Ok(name_token) = name_node.value() {
-                        if name_token.text_trimmed() == "waitUntil" {
+                    if let Ok(name_token) = name_node.value() {
+                        let key = name_token.text_trimmed().trim_matches(&['\'', '"'][..]);
+                        if key == "waitUntil" {

crates/biome_js_analyze/src/lint/nursery/no_playwright_eval.rs (1)

66-94: Consider extracting a shared “is page/frame‑like” helper.

This receiver check logic is duplicated across Playwright rules (eval/element-handle/etc.). Extract to a small internal helper to keep behaviour consistent.

crates/biome_js_analyze/src/lint/nursery/no_playwright_skipped_test.rs (1)

73-102: Deduplicate chain-detection with the focused-test rule.

is_test_or_describe_object is effectively the same in focused/skip rules. Extract to a shared helper to avoid divergence.

crates/biome_js_analyze/src/lint/nursery/no_playwright_focused_test.rs (1)

74-103: Share the test/describe chain matcher with sibling rules.

Same helper exists in the skipped-test rule; centralise it for consistency and easier maintenance.

crates/biome_js_analyze/src/lint/nursery/no_playwright_wait_for_timeout.rs (2)

107-115: Make the primary message receiver‑agnostic.

Don’t assume the callee is named page; keep it generic.

-                    "Unexpected use of "<Emphasis>"page.waitForTimeout()"</Emphasis>"."
+                    "Unexpected use of "<Emphasis>"waitForTimeout()"</Emphasis>"."

---

60-88: DRY the page/frame detection and consider optional chaining/computed members.

The object extraction repeats across rules and ignores patterns like page?.waitForTimeout(...) or page['waitForTimeout'](...). Extract a shared helper (e.g., nursery::playwright_utils::is_page_or_frame) and broaden callee handling to cover optional/computed members. Keeps rules consistent and reduces false negatives.

Add tests for:

• await page?.waitForTimeout(1000)
• await ctx.page.waitForTimeout(1000)
• await (page)['waitForTimeout'](1000)

crates/biome_js_analyze/src/lint/nursery/no_playwright_element_handle.rs (1)

77-96: Consolidate page/frame detection into a shared utility.

Same object‑resolution logic appears in multiple rules; extract once (e.g., playwright_utils::is_page_or_frame) and reuse. Easier to extend (optional chaining, aliases) in one place.

crates/biome_js_analyze/src/lint/nursery/no_playwright_wait_for_selector.rs (1)

70-88: Reuse a shared is_page_or_frame helper and support optional/computed callee shapes.

Mirror the approach across Playwright rules to avoid drift and catch page?.waitForSelector() / page['waitForSelector']().

Please add tests for the optional/computed cases and context.page.waitForSelector(...).

crates/biome_js_analyze/src/lint/nursery/no_playwright_useless_await.rs (2)

63-79: Include filter in LOCATOR_METHODS.

locator.filter() returns a Locator; awaiting it is equally useless.

 const LOCATOR_METHODS: &[&str] = &[
     "and",
+    "filter",
     "first",
     "getByAltText",
     "getByLabel",

---

210-240: Promote is_page_or_frame to a shared module and reuse in other rules.

This helper exists here but similar logic is duplicated elsewhere. Extract to a small playwright_utils module in nursery and import from rules to keep behaviour aligned.

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_analyze/CONTRIBUTING.md:0-0
Timestamp: 2025-10-15T09:20:19.139Z
Learning: Applies to crates/biome_analyze/crates/biome_rule_options/lib/**/*.rs : For options types, derive Serialize, Deserialize, Deserializable (and JsonSchema under the schema feature) and use #[serde(rename_all="camelCase", deny_unknown_fields, default)] with skip_serializing_if where appropriate

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_analyze/CONTRIBUTING.md:0-0
Timestamp: 2025-10-15T09:20:19.139Z
Learning: Applies to crates/biome_analyze/**/lib/src/{lint,assist}/**/*.rs : Use declare_lint_rule! with version set to "next" for every rule definition

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_analyze/CONTRIBUTING.md:0-0
Timestamp: 2025-10-15T09:20:19.139Z
Learning: Applies to crates/biome_analyze/**/tests/quick_test.rs : Use the quick test at biome_js_analyze/tests/quick_test.rs by un-ignoring and adjusting SOURCE and RuleFilter for ad-hoc checks

crates/biome_js_analyze/src/lint/nursery/no_playwright_wait_for_selector.rs (1)

104-104: Make the diagnostic message generic.

The rule matches frame.waitForSelector() and other receivers (lines 86-89), but the message hard-codes page.. Use the generic form instead.

-                    "Unexpected use of "<Emphasis>"page.waitForSelector()"</Emphasis>"."
+                    "Unexpected use of "<Emphasis>"waitForSelector()"</Emphasis>"."

crates/biome_js_analyze/src/lint/nursery/no_playwright_element_handle.rs (1)

119-124: Generalise diagnostics: drop hard‑coded “page.” prefix.

Keep guidance receiver‑agnostic so it’s correct for frame, this.page, etc. Apply:

-            .note(markup! {
-                "Element handles like "<Emphasis>"page."{{state_text}}"()"</Emphasis>" are discouraged."
-            })
+            .note(markup! {
+                "Element handles like "<Emphasis>"{{state_text}}"()"</Emphasis>" are discouraged."
+            })
-            .note(markup! {
-                "Use "<Emphasis>"page.locator()"</Emphasis>" or other locator methods like "<Emphasis>"getByRole()"</Emphasis>" instead."
-            })
+            .note(markup! {
+                "Use "<Emphasis>"locator()"</Emphasis>" or other locator methods like "<Emphasis>"getByRole()"</Emphasis>" instead."
+            })

crates/biome_js_analyze/src/lint/nursery/no_playwright_element_handle.rs (3)

63-80: Also handle bracket access and optional chaining.

Calls like page['$']('a') and page?.$('a') won’t be caught. Consider matching JsComputedMemberExpression (string literal "$" or "$$") and optional‑chained members too, with tests.

Add tests for:

• await page['$']('#id')
• await page?.$('button')

---

9-9: Tweak rule summary to be receiver‑agnostic.

Minor copy edit to match the generalised notes:

-    /// Disallow usage of element handles (`page.$()` and `page.$$()`).
+    /// Disallow usage of element handles (e.g. `.$()` and `. $$()`), commonly seen as `page.$()/page.$$()` or `frame.$()`.

---

81-105: De‑duplicate “page‑like receiver” detection across Playwright rules.

no_playwright_eval implements near‑identical object/member extraction. Extract a tiny helper (e.g. is_page_like(&AnyJsExpression) -> bool) in a shared module and reuse here and there to keep fixes in one place.

Also applies to: 63-75

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

Learnt from: CR
PR: biomejs/biome#0
File: CONTRIBUTING.md:0-0
Timestamp: 2025-10-15T09:19:01.347Z
Learning: Applies to .changeset/*.md : End every sentence in a changeset with a period

crates/biome_js_analyze/src/lint/nursery/no_playwright_wait_for_navigation.rs (1)

101-105: Use receiver‑agnostic primary message.

The rule fires for frame and other receivers; message still hard‑codes page..

-                    "Unexpected use of "<Emphasis>"page.waitForNavigation()"</Emphasis>"."
+                    "Unexpected use of "<Emphasis>"waitForNavigation()"</Emphasis>"."

crates/biome_js_analyze/src/lint/nursery/no_playwright_eval.rs (1)

104-108: Make the message object‑agnostic.

Avoid hard‑coding page.; the rule also targets frames/custom pages.

-                    "Unexpected use of "<Emphasis>"page."{{state_text}}"()"</Emphasis>"."
+                    "Unexpected use of "<Emphasis>"{{state_text}}"()</Emphasis>"."

crates/biome_js_analyze/src/lint/nursery/missing_playwright_await.rs (2)

243-274: expect.poll() with synchronous matchers is still not detected.

The early return at line 256 prevents detection of expect.poll(...).toBe(...) where toBe isn't in ASYNC_PLAYWRIGHT_MATCHERS. Check for poll before validating the matcher.

Apply this diff:

 fn get_async_expect_matcher(call_expr: &JsCallExpression) -> Option<MissingAwaitType> {
     let callee = call_expr.callee().ok()?;
 
     // Must be a member expression (matcher call)
     let member_expr = callee.as_js_static_member_expression()?;
+
+    // Walk up the chain first
+    let object = member_expr.object().ok()?;
+
+    // Check for expect.poll (must come before matcher validation)
+    if has_poll_in_chain(&object) {
+        return Some(MissingAwaitType::ExpectPoll);
+    }
 
     // Get the matcher name
     let member = member_expr.member().ok()?;
     let name = member.as_js_name()?;
     let token = name.value_token().ok()?;
     let matcher_name = token.token_text_trimmed();
 
     // Check if it's an async Playwright matcher
     if !ASYNC_PLAYWRIGHT_MATCHERS.contains(&matcher_name.text()) {
         return None;
     }
 
-    // Walk up the chain to find if this is an expect() call
-    let object = member_expr.object().ok()?;
-
-    // Check for expect.poll
-    if has_poll_in_chain(&object) {
-        return Some(MissingAwaitType::ExpectPoll);
-    }
-
     // Check if the chain starts with expect
     if has_expect_in_chain(&object) {
         return Some(MissingAwaitType::ExpectMatcher(matcher_name));
     }
 
     None
 }

---

437-439: Expand to cover Promise.allSettled(), Promise.any(), and Promise.race().

Awaited calls inside Promise.allSettled([...]), Promise.any([...]), or Promise.race([...]) currently escape detection.

Apply this diff:

 fn is_promise_all(call: &JsCallExpression) -> bool {
-    is_member_call_pattern(call, "Promise", "all")
+    if let Ok(callee) = call.callee() {
+        if let Some(member) = callee.as_js_static_member_expression() {
+            if let Ok(member_name) = member.member() {
+                if let Some(name) = member_name.as_js_name() {
+                    if let Ok(token) = name.value_token() {
+                        let method = token.text_trimmed();
+                        if matches!(method, "all" | "allSettled" | "any" | "race") {
+                            if let Ok(object) = member.object() {
+                                if let AnyJsExpression::JsIdentifierExpression(id) = object {
+                                    if let Ok(obj_name) = id.name() {
+                                        if let Ok(obj_token) = obj_name.value_token() {
+                                            return obj_token.text_trimmed() == "Promise";
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    false
 }

crates/biome_rule_options/src/no_playwright_wait_for_navigation.rs (1)

1-6: Add rustdoc comment to the struct.

Per coding guidelines, inline rustdoc is required. Document what this options type configures.

+/// Options for the `noPlaywrightWaitForNavigation` rule.
+/// Currently empty; reserved for future configuration.
 #[derive(Default, Clone, Debug, Deserialize, Deserializable, Eq, PartialEq, Serialize)]

As per coding guidelines.

crates/biome_js_analyze/src/lint/nursery/no_playwright_networkidle.rs (1)

55-87: Add receiver guard to prevent false positives.

The rule matches waitForLoadState("networkidle") on any receiver, not just Playwright page/frame objects. Add the same page/frame guard used in the other Playwright rules.

Apply this diff:

         let member_expr = JsStaticMemberExpression::cast_ref(callee.syntax())?;
         let member_name = member_expr.member().ok()?;
         let member_text = member_name.as_js_name()?.value_token().ok()?;
         let method_name = member_text.text_trimmed();
 
+        // Ensure receiver is page/frame-like to avoid false positives
+        let object = member_expr.object().ok()?;
+        let object_text = match object {
+            AnyJsExpression::JsIdentifierExpression(id) => {
+                id.name().ok()?.value_token().ok()?.token_text_trimmed()
+            }
+            AnyJsExpression::JsStaticMemberExpression(member) => {
+                member.member().ok()?.as_js_name()?.value_token().ok()?.token_text_trimmed()
+            }
+            _ => return None,
+        };
+        let is_page_like = object_text == "page"
+            || object_text == "frame"
+            || object_text.ends_with("Page")
+            || object_text.ends_with("Frame");
+        if !is_page_like {
+            return None;
+        }
+
         // Check if it's one of the navigation methods
         let is_navigation_method = matches!(

crates/biome_js_analyze/src/lint/nursery/no_playwright_wait_for_selector.rs (1)

97-114: Generalise diagnostic messages.

The messages hardcode page. which is incorrect for other receivers like frame.waitForSelector(). Remove the receiver prefix.

Apply this diff:

             RuleDiagnostic::new(
                 rule_category!(),
                 node.range(),
                 markup! {
-                    "Unexpected use of "<Emphasis>"page.waitForSelector()"</Emphasis>"."
+                    "Unexpected use of "<Emphasis>"waitForSelector()"</Emphasis>"."
                 },
             )
             .note(markup! {
-                "Use locator-based "<Emphasis>"page.locator()"</Emphasis>" or "<Emphasis>"page.getByRole()"</Emphasis>" APIs instead."
+                "Use locator-based "<Emphasis>"locator()"</Emphasis>" or "<Emphasis>"getByRole()"</Emphasis>" APIs instead."
             })

crates/biome_js_analyze/src/lint/nursery/no_playwright_element_handle.rs (1)

108-129: Generalise diagnostic notes.

The notes hardcode page. which is incorrect for other receivers. Remove the receiver prefix to make guidance applicable to any Playwright actor.

Apply this diff:

             .note(markup! {
-                "Element handles like "<Emphasis>"page."{{state_text}}"()"</Emphasis>" are discouraged."
+                "Element handles like "<Emphasis>{{state_text}}"()"</Emphasis>" are discouraged."
             })
             .note(markup! {
-                "Use "<Emphasis>"page.locator()"</Emphasis>" or other locator methods like "<Emphasis>"getByRole()"</Emphasis>" instead."
+                "Use "<Emphasis>"locator()"</Emphasis>" or other locator methods like "<Emphasis>"getByRole()"</Emphasis>" instead."
             })

crates/biome_js_analyze/tests/specs/nursery/noPlaywrightWaitForTimeout/invalid/in-test.js (1)

1-4: Good invalid fixture for waitForTimeout.

Covers the canonical misuse. For extra bite, consider a sibling case using aliases or other targets:

• const p = page; await p.waitForTimeout(1000)
• await frame.waitForTimeout(1000)

crates/biome_js_analyze/tests/specs/nursery/noPlaywrightForceOption/invalid/click.js (1)

1-1: Forceful, in the right way.

Nice invalid for { force: true } on a locator click. If not elsewhere, add twins for:

• await page.click('button', { force: true })
• await page.locator('btn').click({ force: !!1 }) // truthy variant

crates/biome_js_analyze/tests/specs/nursery/noPlaywrightUselessAwait/invalid/getByRole.js (1)

1-1: Crisp “useless await” example.

getByRole returns a Locator; awaiting it should be flagged. Consider adding a guard case elsewhere to ensure no false positives on chains like await page.getByRole('button').click() (await applies to click, not the locator creation).

crates/biome_js_analyze/tests/specs/nursery/noPlaywrightUselessAwait/valid/sync-no-await.js (1)

1-3: Solid valid samples.

These ensure we don’t penalise synchronous locator retrieval. Optional: add an assignment form to widen coverage:

• const btn = page.getByRole('button');

crates/biome_js_analyze/tests/specs/nursery/noPlaywrightElementHandle/invalid/dollar-dollar.js (1)

1-1: Right on target for ElementHandle APIs.

Good catch on $$. To fully mirror eslint-plugin-playwright parity, consider siblings for:

• const el = await page.$('#id')
• const kids = await handle.$$('.child')

crates/biome_js_analyze/src/lint/nursery/no_playwright_valid_describe_callback.rs (1)

70-96: Broaden detection: returns/generators and test.describe.parallel/serial.

• Add a check that the callback body contains no return statements.
• Treat generator functions (function*) as invalid.
• Recognise test.describe.parallel(...) / test.describe.serial(...) (callee chain where final member isn’t describe but the parent is).

Happy to sketch these out if you want this in the first batch.

Also applies to: 102-128

crates/biome_js_analyze/tests/specs/nursery/noPlaywrightWaitForNavigation/invalid/simple.js (1)

1-2: Add one more invalid for frame.waitForNavigation().

Helps prove the rule isn’t page‑only (and guards against regressions). Happy to add it if you like.

crates/biome_js_analyze/src/lint/nursery/no_playwright_force_option.rs (1)

74-101: Scope to Playwright receivers to avoid false positives.

Limit matches to page/frame/*Page/*Frame or locator/getBy* chains.

@@
-        // Check the arguments for { force: true }
+        // Narrow to Playwright receivers to avoid false positives
+        let object = member_expr.object().ok()?;
+        if !is_playwright_receiver(&object) {
+            return None;
+        }
+
+        // Check the arguments for { force: true }
         let args = call_expr.arguments().ok()?;
@@
         None
     }
@@
+fn is_playwright_receiver(expr: &AnyJsExpression) -> bool {
+    match expr {
+        AnyJsExpression::JsIdentifierExpression(id) => {
+            let t = id.name().ok()?.value_token().ok()?.text_trimmed();
+            t == "page" || t == "frame" || t.ends_with("Page") || t.ends_with("Frame")
+        }
+        AnyJsExpression::JsStaticMemberExpression(member) => {
+            let t = member.member().ok()?.as_js_name()?.value_token().ok()?.text_trimmed();
+            t == "page" || t == "frame" || t.ends_with("Page") || t.ends_with("Frame")
+        }
+        AnyJsExpression::JsCallExpression(call) => {
+            // e.g. page.locator(...).click(...)
+            let callee = call.callee().ok()?;
+            let m = JsStaticMemberExpression::cast_ref(callee.syntax())?;
+            let name = m.member().ok()?.as_js_name()?.value_token().ok()?.text_trimmed();
+            matches!(name.as_str(), "locator" | "getByRole" | "getByText" | "getByLabel" | "getByTitle" | "getByAltText" | "getByPlaceholder" | "getByTestId")
+        }
+        _ => false,
+    }
+}