fix: #127 - Handle ASI in a single line conditionally braced body.

Closes #127.

Author: dsherret

src/parsing/node_helpers.rs

@@ -195,3 +195,11 @@ pub fn is_test_library_call_expr(node: &CallExpr, module: &Module) -> bool {
 pub fn is_optional_call_expr<'a>(node: &dyn NodeTrait<'a>) -> bool {
     return node.parent().unwrap().kind() == NodeKind::OptChainExpr;
 }
+
+pub fn is_expr_stmt_or_body_with_single_expr_stmt<'a>(node: Node<'a>) -> bool {
+    match node {
+        Node::ExprStmt(_) => true,
+        Node::BlockStmt(block) => block.stmts.len() == 1 && block.stmts[0].is::<ExprStmt>(),
+        _ => false,
+    }
+}

src/parsing/parser.rs

@@ -3321,7 +3321,17 @@ fn parse_expr_stmt<'a>(stmt: &'a ExprStmt, context: &mut Context<'a>) -> PrintIt
         let parsed_node = parsed_node.into_rc_path();
         return if should_add_semi_colon(&parsed_node).unwrap_or(false) {
             let mut items = PrintItems::new();
-            items.push_str(";");
+            if let Some(brace_condition_ref) = context.take_expr_stmt_single_line_parent_brace_ref() {
+                // Do not add a semi-colon when the semi-colon is within an if stmt or for-like stmt where
+                // there are no braces on the parent (ex. `if (true) []`) as this would break the code.
+                items.push_condition(if_true(
+                    "semiColonIfBrace",
+                    move |context| context.get_resolved_condition(&brace_condition_ref),
+                    ";".into(),
+                ));
+            } else {
+                items.push_str(";");
+            }
             items.extend(parsed_node.into());
             items
         } else {
@@ -6447,6 +6457,11 @@ fn parse_conditional_brace_body<'a>(opts: ParseConditionalBraceBodyOptions<'a>,
     }, vec![end_info]);
     let open_brace_condition_ref = open_brace_condition.get_reference();
 
+    // store the brace condition if ASI and the body is an expression statement
+    if context.config.semi_colons == SemiColons::Asi && node_helpers::is_expr_stmt_or_body_with_single_expr_stmt(opts.body_node) {
+        context.store_expr_stmt_single_line_parent_brace_ref(open_brace_condition_ref);
+    }
+
     // parse body
     let mut items = PrintItems::new();
     items.push_info(start_info);

src/parsing/parser_types.rs

@@ -21,6 +21,7 @@ pub struct Context<'a> {
     pub end_statement_or_member_infos: Stack<Info>,
     before_comments_start_info_stack: Stack<(Span, Info)>,
     if_stmt_last_brace_condition_ref: Option<ConditionReference>,
+    expr_stmt_single_line_parent_brace_ref: Option<ConditionReference>,
     /// Used for ensuring nodes are parsed in order.
     #[cfg(debug_assertions)]
     pub last_parsed_node_pos: u32,
@@ -48,6 +49,7 @@ impl<'a> Context<'a> {
             end_statement_or_member_infos: Stack::new(),
             before_comments_start_info_stack: Stack::new(),
             if_stmt_last_brace_condition_ref: None,
+            expr_stmt_single_line_parent_brace_ref: None,
             #[cfg(debug_assertions)]
             last_parsed_node_pos: 0,
         }
@@ -89,6 +91,14 @@ impl<'a> Context<'a> {
         self.if_stmt_last_brace_condition_ref.take()
     }
 
+    pub fn store_expr_stmt_single_line_parent_brace_ref(&mut self, condition_reference: ConditionReference) {
+        self.expr_stmt_single_line_parent_brace_ref = Some(condition_reference);
+    }
+
+    pub fn take_expr_stmt_single_line_parent_brace_ref(&mut self) -> Option<ConditionReference> {
+        self.expr_stmt_single_line_parent_brace_ref.take()
+    }
+
     pub fn get_or_create_current_before_comments_start_info(&mut self) -> Info {
         let current_span = self.current_node.span();
         if let Some((span, info)) = self.before_comments_start_info_stack.peek() {

tests/specs/issues/issue0127.txt

@@ -0,0 +1,28 @@
+~~ semiColons: asi, useBraces: preferNone ~~
+== should handle ASI in single line conditionally braced parent statements ==
+for (const test of asdf)
+    []
+
+for (const test in asdf)
+    []
+
+for (let i = 0; i < 10; i++)
+    []
+
+if (true) []
+
+while (true) []
+
+[expect]
+for (const test of asdf)
+    []
+
+for (const test in asdf)
+    []
+
+for (let i = 0; i < 10; i++)
+    []
+
+if (true) []
+
+while (true) []