Fix: Make when merging rule less aggressive

- Only merge two nested when expressions if both conditions are identifiers, or one uses 'and'
- Always merge three or more nested when expressions
- Add test cases for the new behavior

Co-authored-by: jackfirth <[email protected]>

Author: Copilot

default-recommendations/conditional-shortcuts-test.rkt

@@ -698,20 +698,56 @@ test: "if clause with begin in false branch and commented true branch refactorab
 ------------------------------
 
 
-test: "immediately-nested when expressions can be merged"
+no-change-test: "two when forms with non-trivial conditions"
 --------------------
-(define (f c1 c2)
-  (when c1
-    (when c2
-      (displayln "both passed"))))
+(define (f a b c)
+  (when (a)
+    (when (b)
+      c)))
+--------------------
+
+
+test: "three when forms"
+--------------------
+(define (f a b c d)
+  (when (a)
+    (when (b)
+      (when (c)
+        d))))
 ====================
-(define (f c1 c2)
-  (when (and c1 c2)
-    (displayln "both passed")))
+(define (f a b c d)
+  (when (and (a) (b) (c))
+    d))
+--------------------
+
+
+test: "two when forms with and"
+--------------------
+(define (f a b c d)
+  (when (and (a) (b))
+    (when (c)
+      d)))
+====================
+(define (f a b c d)
+  (when (and (a) (b) (c))
+    d))
+--------------------
+
+
+test: "two when forms with identifiers"
+--------------------
+(define (f a b c)
+  (when a
+    (when b
+      c)))
+====================
+(define (f a b c)
+  (when (and a b)
+    c))
 --------------------
 
 
-test: "nested when with multiple body expressions can be merged"
+test: "two when forms with identifiers and multiple body expressions"
 --------------------
 (define (f c1 c2)
   (when c1

default-recommendations/conditional-shortcuts.rkt

@@ -204,12 +204,68 @@
         (~replacement [else else-expr.refactored ...] #:original else-expr)))
 
 
+;; Syntax class to count and extract deeply nested when expressions
+(define-syntax-class deeply-nested-when-expression
+  #:attributes ([condition 1] [body 1])
+  #:literals (when)
+  
+  ;; Base case: innermost when with any condition
+  (pattern (when inner-condition:expr inner-body:expr ...)
+    #:with (condition ...) #'(inner-condition)
+    #:with (body ...) #'(inner-body ...))
+  
+  ;; Recursive case: nest of when expressions
+  (pattern (when outer-condition:expr nested:deeply-nested-when-expression)
+    #:with (condition ...) #'(outer-condition nested.condition ...)
+    #:with (body ...) #'(nested.body ...)))
+
+
+;; Match three or more nested when expressions
+(define-syntax-class triple-nested-when-expression
+  #:attributes ([condition 1] [body 1])
+  #:literals (when)
+  (pattern (when c1:expr (when c2:expr nested:deeply-nested-when-expression))
+    #:when (>= (length (syntax->list #'(c1 c2 nested.condition ...))) 3)
+    #:with (condition ...) #'(c1 c2 nested.condition ...)
+    #:with (body ...) #'(nested.body ...)))
+
+
+;; Match two nested when where outer has and
+(define-syntax-class double-nested-when-outer-and
+  #:attributes ([condition 1] [body 1])
+  #:literals (when and)
+  (pattern (when (and outer-parts ...) (when inner-condition:expr inner-body:expr ...))
+    #:with (condition ...) #'(outer-parts ... inner-condition)
+    #:with (body ...) #'(inner-body ...)))
+
+
+;; Match two nested when where inner has and
+(define-syntax-class double-nested-when-inner-and
+  #:attributes ([condition 1] [body 1])
+  #:literals (when and)
+  (pattern (when outer-condition:expr (when (and inner-parts ...) inner-body:expr ...))
+    #:with (condition ...) #'(outer-condition inner-parts ...)
+    #:with (body ...) #'(inner-body ...)))
+
+
+;; Match two nested when where both are identifiers
+(define-syntax-class double-nested-when-both-ids
+  #:attributes ([condition 1] [body 1])
+  #:literals (when)
+  (pattern (when outer-id:id (when inner-id:id inner-body:expr ...))
+    #:with (condition ...) #'(outer-id inner-id)
+    #:with (body ...) #'(inner-body ...)))
+
+
 (define-refactoring-rule nested-when-to-compound-when
   #:description
   "Nested `when` expressions can be merged into a single compound `when` expression."
   #:literals (when and)
-  (when outer-condition:expr (when inner-condition:expr body:expr ...))
-  (when (and outer-condition inner-condition) body ...))
+  (~or nested:triple-nested-when-expression
+       nested:double-nested-when-outer-and
+       nested:double-nested-when-inner-and
+       nested:double-nested-when-both-ids)
+  (when (and nested.condition ...) nested.body ...))
 
 
 (define-refactoring-rule ignored-and-to-when