Move rules from miscellaneous-suggestions to appropriate suites with tests

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

Author: Copilot

default-recommendations/conditional-shortcuts-test.rkt

@@ -828,3 +828,49 @@ no-change-test: "cond with unshared tail expression not refactorable to when"
     [else
      (displayln "false tail")]))
 --------------------
+
+
+test: "if with else cond can be flattened to cond"
+- (if 'a 'b (cond ['c 'd] ['e 'f]))
+------------------------------
+(cond
+  ['a 'b]
+  ['c 'd]
+  ['e 'f])
+------------------------------
+
+
+test: "cond with else-if can be collapsed"
+- (cond ['a 'b] ['c 'd] [else (if 'e 'f 'g)])
+------------------------------
+(cond
+  ['a 'b]
+  ['c 'd]
+  ['e 'f]
+  [else 'g])
+------------------------------
+
+
+test: "cond with begin in clause can be simplified"
+------------------------------
+(cond ['a (begin 'b 'c 'd)])
+==============================
+(cond
+  ['a
+   'b
+   'c
+   'd])
+------------------------------
+
+
+test: "cond with begin in middle clause can be simplified"
+------------------------------
+(cond ['a 'b] ['c (begin 'd 'e)] ['f 'g])
+==============================
+(cond
+  ['a 'b]
+  ['c
+   'd
+   'e]
+  ['f 'g])
+------------------------------

default-recommendations/conditional-shortcuts.rkt

@@ -236,13 +236,42 @@ tail expression outside `cond` lets you replace `cond` with `when`."
    body-after ...))
 
 
+(define if-begin-to-cond-message
+  "The `cond` form supports multiple body expressions in each branch, making `begin` unnecessary.")
+
+
+(define-refactoring-rule if-else-cond-to-cond
+  #:description if-begin-to-cond-message
+  #:literals (if cond)
+  (if condition then-branch (cond clause ...))
+  (cond [condition then-branch] clause ...))
+
+
+(define-refactoring-rule cond-else-if-to-cond
+  #:description "The `else`-`if` branch of this `cond` expression can be collapsed into the `cond`\
+ expression."
+  #:literals (cond else if)
+  (cond clause ... [else (if inner-condition inner-then-branch else-branch)])
+  (cond clause ... [inner-condition inner-then-branch] [else else-branch]))
+
+
+(define-refactoring-rule cond-begin-to-cond
+  #:description "The bodies of `cond` clauses are already implicitly wrapped in `begin`."
+  #:literals (cond begin)
+  (cond clause-before ... [condition (begin body ...)] clause-after ...)
+  (cond clause-before ... [condition body ...] clause-after ...))
+
+
 (define-refactoring-suite conditional-shortcuts
   #:rules (always-throwing-cond-to-when
            always-throwing-if-to-when
            cond-else-cond-to-cond
+           cond-else-if-to-cond
            cond-void-to-when-or-unless
+           cond-begin-to-cond
            explicit-cond-else-void
            if-begin-to-cond
+           if-else-cond-to-cond
            if-else-false-to-and
            if-void-to-when-or-unless
            if-x-else-x-to-and

default-recommendations/match-shortcuts-test.rkt

@@ -474,4 +474,34 @@ test: "refactoring list element variable definitions to match-define doesn't ref
 ------------------------------
 
 
+test: "and with match on same identifier can be simplified"
+------------------------------
+(define (f x)
+  (and x (match x [1 2])))
+==============================
+(define (f x)
+  (match x
+    [#f #f]
+    [1 2]))
+------------------------------
+
+
+test: "and with match on same identifier preserves formatting"
+------------------------------
+(define (foo some-var)
+  (and some-var
+       (match some-var
+         ['first-case 'first-result]
+         ['second-case 'second-result])))
+==============================
+(define (foo some-var)
+  (match some-var
+    [#f #f]
+    ['first-case 'first-result]
+    ['second-case 'second-result]))
+------------------------------
+
+
+no-change-test: "and with match on different identifiers not refactorable"
+- (define (foo x y) (and x (match y ['a 'b] ['c 'd])))
 

default-recommendations/match-shortcuts.rkt

@@ -265,8 +265,18 @@ elements than expected."
   (body-before ... (~focus-replacement-on match-definition) body-after ...))
 
 
+(define-refactoring-rule and-match-to-match
+  #:description "This `and` expression can be turned into a clause of the inner `match` expression,\
+ reducing nesting."
+  #:literals (and match)
+  (and and-subject:id (match match-subject:id match-clause ...))
+  #:when (free-identifier=? #'and-subject #'match-subject)
+  (match match-subject [#false #false] match-clause ...))
+
+
 (define-refactoring-suite match-shortcuts
-  #:rules (list-element-definitions-to-match-define
+  #:rules (and-match-to-match
+           list-element-definitions-to-match-define
            match-conditional-to-when
            predicate-pattern-with-lambda-to-when
            remove-unnecessary-root-and-pattern