Reduce aggressiveness of nested when merging rule (#705)

Co-authored-by: copilot-swe-agent[bot] <[email protected]>
Co-authored-by: jackfirth <[email protected]>
Co-authored-by: Jack Firth <[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,27 @@
         (~replacement [else else-expr.refactored ...] #:original else-expr)))
 
 
+(define-syntax-class nested-when-expression
+  #:attributes ([condition 1] [body 1] depth)
+  #:literals (when and)
+
+  (pattern (when (~or (and subcondition ...) first-condition)
+             (~or nested:nested-when-expression (~seq only-body ...)))
+    #:with (condition ...)
+    #'((~? (~@ subcondition ...) first-condition) (~? (~@ nested.condition ...)))
+    #:attr [body 1] (or (attribute nested.body) (attribute only-body))
+    #:attr depth (add1 (or (attribute nested.depth) 0))))
+
+
 (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 ...))
+  when-expr:nested-when-expression
+  #:when (or (>= (attribute when-expr.depth) 3)
+             (>= (length (attribute when-expr.condition)) 3)
+             (and (equal? (attribute when-expr.depth) 2)
+                  (andmap identifier? (attribute when-expr.condition))))
+  (when (and when-expr.condition ...) when-expr.body ...))
 
 
 (define-refactoring-rule ignored-and-to-when