Move if-let-to-cond and and-let-to-cond rules to let-replacement (#659)

Co-authored-by: copilot-swe-agent[bot] <[email protected]>
Co-authored-by: jackfirth <[email protected]>

Author: Copilot

default-recommendations/conditional-shortcuts-test.rkt

@@ -698,260 +698,6 @@ test: "if clause with begin in false branch and commented true branch refactorab
 ------------------------------
 
 
-test: "if clause with let in true branch refactorable to cond"
-------------------------------
-(define (f a b)
-  (if a
-      (let ([x 1])
-        x)
-      b))
-==============================
-(define (f a b)
-  (cond
-    [a
-     (define x 1)
-     x]
-    [else b]))
-------------------------------
-
-
-test: "if clause with let in false branch refactorable to cond"
-------------------------------
-(define (f a b)
-  (if a
-      b
-      (let ([x 1])
-        x)))
-==============================
-(define (f a b)
-  (cond
-    [a b]
-    [else
-     (define x 1)
-     x]))
-------------------------------
-
-
-test: "if clause with let in both branches refactorable to cond"
-------------------------------
-(define (f a)
-  (if a
-      (let ([x 1])
-        x)
-      (let ([x 1])
-        x)))
-==============================
-(define (f a)
-  (cond
-    [a
-     (define x 1)
-     x]
-    [else
-     (define x 1)
-     x]))
-------------------------------
-
-
-test: "if clause with multiline condition and let in true branch refactorable to cond"
-------------------------------
-(define (f a b)
-  (if (a 10000000000000000000000000000000000000
-         20000000000000000000000000000000000000
-         30000000000000000000000000000000000000)
-      (let ([x 1])
-        x)
-      b))
-==============================
-(define (f a b)
-  (cond
-    [(a 10000000000000000000000000000000000000
-        20000000000000000000000000000000000000
-        30000000000000000000000000000000000000)
-     (define x 1)
-     x]
-    [else b]))
-------------------------------
-
-
-test: "if clause with multiline condition and let in false branch refactorable to cond"
-------------------------------
-(define (f a b)
-  (if (a 10000000000000000000000000000000000000
-         20000000000000000000000000000000000000
-         30000000000000000000000000000000000000)
-      b
-      (let ([x 1])
-        x)))
-==============================
-(define (f a b)
-  (cond
-    [(a 10000000000000000000000000000000000000
-        20000000000000000000000000000000000000
-        30000000000000000000000000000000000000)
-     b]
-    [else
-     (define x 1)
-     x]))
-------------------------------
-
-
-test: "if clause with multiline condition and let in both branches refactorable to cond"
-------------------------------
-(define (f a)
-  (if (a 10000000000000000000000000000000000000
-         20000000000000000000000000000000000000
-         30000000000000000000000000000000000000)
-      (let ([x 1])
-        x)
-      (let ([x 1])
-        x)))
-==============================
-(define (f a)
-  (cond
-    [(a 10000000000000000000000000000000000000
-        20000000000000000000000000000000000000
-        30000000000000000000000000000000000000)
-     (define x 1)
-     x]
-    [else
-     (define x 1)
-     x]))
-------------------------------
-
-
-test: "if clause with let in commented true branch refactorable to cond"
-------------------------------
-(define (f a b)
-  (if a
-      ;; This is the true case
-      (let ([x 1])
-        x)
-      b))
-==============================
-(define (f a b)
-  (cond
-    [a
-     ;; This is the true case
-     (define x 1)
-     x]
-    [else b]))
-------------------------------
-
-
-test: "if clause with let in commented false branch refactorable to cond"
-------------------------------
-(define (f a b)
-  (if a
-      b
-      ;; This is the false case
-      (let ([x 1])
-        x)))
-==============================
-(define (f a b)
-  (cond
-    [a b]
-    ;; This is the false case
-    [else
-     (define x 1)
-     x]))
-------------------------------
-
-
-test: "if clause with let in both commented branches refactorable to cond"
-------------------------------
-(define (f a)
-  (if a
-      ;; This is the true case
-      (let ([x 1])
-        x)
-      ;; This is the false case
-      (let ([x 1])
-        x)))
-==============================
-(define (f a)
-  (cond
-    [a
-     ;; This is the true case
-     (define x 1)
-     x]
-    ;; This is the false case
-    [else
-     (define x 1)
-     x]))
-------------------------------
-
-
-
-test: "if clause with let in true branch and commented false branch refactorable to cond"
-------------------------------
-(define (f a b)
-  (if a
-      (let ([x 1])
-        x)
-      ;; This is the false case
-      b))
-==============================
-(define (f a b)
-  (cond
-    [a
-     (define x 1)
-     x]
-    ;; This is the false case
-    [else b]))
-------------------------------
-
-
-test: "if clause with let in false branch and commented true branch refactorable to cond"
-------------------------------
-(define (f a b)
-  (if a
-      ;; This is the true case
-      b
-      (let ([x 1])
-        x)))
-==============================
-(define (f a b)
-  (cond
-    ;; This is the true case
-    [a b]
-    [else
-     (define x 1)
-     x]))
-------------------------------
-
-
-test: "and with let can be refactored to cond with define"
-------------------------------
-(and 'some-condition
-     (let ([x 42])
-       (* x 2)))
-==============================
-(cond
-  ['some-condition
-   (define x 42)
-   (* x 2)]
-  [else #f])
-------------------------------
-
-
-no-change-test: "and without let should not be refactored"
-------------------------------
-(and 'some-condition (* 42 2))
-------------------------------
-
-
-no-change-test: "and with empty let should not be refactored"
-------------------------------
-(and 'some-condition (let () (* 42 2)))
-------------------------------
-
-
-no-change-test: "and with more than two arguments should not be refactored"
-------------------------------
-(and 'some-condition 'another-condition (let ([x 42]) (* x 2)))
-------------------------------
-
-
 test: "immediately-nested when expressions can be merged"
 --------------------
 (define (f c1 c2)

default-recommendations/conditional-shortcuts.rkt

@@ -14,7 +14,7 @@
          resyntax/base
          resyntax/default-recommendations/private/boolean
          resyntax/default-recommendations/private/exception
-         resyntax/default-recommendations/let-replacement/private/let-binding
+         resyntax/default-recommendations/private/if-arm
          resyntax/default-recommendations/private/metafunction
          resyntax/default-recommendations/private/syntax-equivalence
          syntax/parse)
@@ -185,25 +185,6 @@
 
 
 
-(define-syntax-class if-arm
-  #:attributes (uses-begin? uses-let? [refactored 1])
-  #:literals (begin)
-
-  (pattern (begin body ...)
-    #:attr uses-begin? #true
-    #:attr uses-let? #false
-    #:with (refactored ...) #`(~splicing-replacement (body ...) #:original #,this-syntax))
-
-  (pattern :refactorable-let-expression
-    #:attr uses-begin? #false
-    #:attr uses-let? #true)
-
-  (pattern other
-    #:with (refactored ...) #'(other)
-    #:attr uses-begin? #false
-    #:attr uses-let? #false))
-
-
 (define-refactoring-rule if-begin-to-cond
   #:description "Using `cond` instead of `if` here makes `begin` unnecessary"
   #:literals (if void)
@@ -215,28 +196,6 @@
         (~replacement [else else-expr.refactored ...] #:original else-expr)))
 
 
-(define-refactoring-rule if-let-to-cond
-  #:description
-  "`cond` with internal definitions is preferred over `if` with `let`, to reduce nesting"
-  #:literals (if void)
-  (if condition
-      (~and then-expr:if-arm (~not (void)))
-      (~and else-expr:if-arm (~not (void))))
-  #:when (or (attribute then-expr.uses-let?) (attribute else-expr.uses-let?))
-  (cond (~replacement [condition then-expr.refactored ...] #:original-splice (condition then-expr))
-        (~replacement [else else-expr.refactored ...] #:original else-expr)))
-
-
-(define-refactoring-rule and-let-to-cond
-  #:description
-  "Using `cond` allows converting `let` to internal definitions, reducing nesting"
-  #:literals (and cond)
-  (and condition let-expr:refactorable-let-expression)
-  #:when (not (empty? (attribute let-expr.id)))
-  (cond [condition let-expr.refactored ...]
-        [else #false]))
-
-
 (define-refactoring-rule nested-when-to-compound-when
   #:description
   "Nested `when` expressions can be merged into a single compound `when` expression."
@@ -280,13 +239,11 @@ tail expression outside `cond` lets you replace `cond` with `when`."
 (define-refactoring-suite conditional-shortcuts
   #:rules (always-throwing-cond-to-when
            always-throwing-if-to-when
-           and-let-to-cond
            cond-else-cond-to-cond
            cond-void-to-when-or-unless
            explicit-cond-else-void
            if-begin-to-cond
            if-else-false-to-and
-           if-let-to-cond
            if-void-to-when-or-unless
            if-x-else-x-to-and
            ignored-and-to-when