feat(prettier): handle binary in in for statement init (#1512)

crates/oxc_prettier/src/needs_parens.rs

@@ -44,6 +44,14 @@ impl<'a> Prettier<'a> {
             return true;
         }
 
+        if self.check_kind(kind, parent_kind) {
+            return true;
+        }
+
+        false
+    }
+
+    fn check_kind(&self, kind: AstKind<'a>, parent_kind: AstKind<'a>) -> bool {
         match kind {
             AstKind::NumberLiteral(literal) => {
                 matches!(parent_kind, AstKind::MemberExpression(e) if e.object().span() == literal.span)
@@ -70,6 +78,12 @@ impl<'a> Prettier<'a> {
                     true
                 }
                 AstKind::AssignmentExpression(_) => false,
+                AstKind::ForStatement(stmt)
+                    if stmt.init.as_ref().is_some_and(|e| e.span() == assign_expr.span)
+                        || stmt.update.as_ref().is_some_and(|e| e.span() == assign_expr.span) =>
+                {
+                    false
+                }
                 AstKind::ExpressionStatement(_) => matches!(
                     assign_expr.left,
                     AssignmentTarget::AssignmentTargetPattern(
@@ -107,6 +121,11 @@ impl<'a> Prettier<'a> {
             AstKind::LogicalExpression(e) => self.check_binarish(e.span),
             AstKind::BinaryExpression(e) => match parent_kind {
                 AstKind::UpdateExpression(_) => true,
+                _ if e.operator == BinaryOperator::In
+                    && self.is_path_in_for_statement_initializer(e.span) =>
+                {
+                    true
+                }
                 _ => self.check_binarish(e.span),
             },
             AstKind::MemberExpression(e) => self.check_member_call(e.span()),
@@ -327,6 +346,21 @@ impl<'a> Prettier<'a> {
         false
     }
 
+    fn is_path_in_for_statement_initializer(&self, span: Span) -> bool {
+        let mut node = Some(span);
+        let mut parents = self.nodes.iter().rev();
+        while let Some(n) = node {
+            let parent = parents.next();
+            if let Some(AstKind::ForStatement(stmt)) = parent {
+                if stmt.init.as_ref().is_some_and(|init| init.span() == n) {
+                    return true;
+                }
+            }
+            node = parent.map(GetSpan::span);
+        }
+        false
+    }
+
     fn starts_with_no_lookahead_token(e: &Expression<'a>, span: Span) -> bool {
         match e {
             Expression::BinaryExpression(e) => Self::starts_with_no_lookahead_token(&e.left, span),

tasks/prettier_conformance/prettier.snap.md

@@ -1,4 +1,4 @@
-Compatibility: 144/597 (24.12%)
+Compatibility: 145/597 (24.29%)
 
 # Failed
 
@@ -330,7 +330,6 @@ Compatibility: 144/597 (24.12%)
 * for/continue-and-break-comment-1.js
 * for/continue-and-break-comment-2.js
 * for/continue-and-break-comment-without-blocks.js
-* for/in.js
 
 ### function
 * function/function_expression.js