Extract named let loopification rules into separate module (#620)

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

Author: Copilot

default-recommendations.rkt

@@ -27,6 +27,7 @@
                resyntax/default-recommendations/match-shortcuts
                resyntax/default-recommendations/miscellaneous-suggestions
                resyntax/default-recommendations/mutability-predicates
+               resyntax/default-recommendations/named-let-loopification
                resyntax/default-recommendations/numeric-shortcuts
                resyntax/default-recommendations/require-and-provide-suggestions
                resyntax/default-recommendations/string-shortcuts
@@ -62,6 +63,7 @@
          resyntax/default-recommendations/match-shortcuts
          resyntax/default-recommendations/miscellaneous-suggestions
          resyntax/default-recommendations/mutability-predicates
+         resyntax/default-recommendations/named-let-loopification
          resyntax/default-recommendations/numeric-shortcuts
          resyntax/default-recommendations/require-and-provide-suggestions
          resyntax/default-recommendations/string-shortcuts
@@ -104,6 +106,7 @@
             match-shortcuts
             miscellaneous-suggestions
             mutability-predicates
+            named-let-loopification
             numeric-shortcuts
             require-and-provide-suggestions
             string-shortcuts

default-recommendations/for-loop-shortcuts-test.rkt

@@ -624,122 +624,6 @@ test: "nested for/and forms can be flattened to a for*/and form"
 ------------------------------
 
 
-test: "named let loop over counter can be replaced by for in-range"
-------------------------------------------------------------
-(define (f x a b dx)
-  (let loop ([x a])
-    (when (< x b)
-      (displayln x)
-      (loop (+ x dx)))))
-============================================================
-(define (f x a b dx)
-  (for ([x (in-range a b dx)])
-    (displayln x)))
-------------------------------------------------------------
-
-
-no-change-test: "named let loop over counter not refactorable when loop function used elsewhere"
-------------------------------------------------------------
-(define (f x a b dx)
-  (let loop ([x a])
-    (when (< x b)
-      (displayln x)
-      (displayln loop)
-      (loop (+ x dx)))))
-------------------------------------------------------------
-
-
-test: "named let loop with conditional return over vector can be replaced by for/first"
-------------------------------------------------------------
-(define vec (vector 0 1 2 3 4 5))
-(let loop ([i 0])
-  (and (< i (vector-length vec))
-       (let ([x (vector-ref vec i)])
-         (if (> x 3)
-             (+ x 42)
-             (loop (add1 i))))))
-============================================================
-(define vec (vector 0 1 2 3 4 5))
-(let loop ([i 0])
-  (and (< i (vector-length vec))
-       (let ([x (vector-ref vec i)])
-         (if (> x 3)
-             (+ x 42)
-             (loop (+ i 1))))))
-============================================================
-(define vec (vector 0 1 2 3 4 5))
-(for/first ([x (in-vector vec)]
-            #:when (> x 3))
-  (+ x 42))
-------------------------------------------------------------
-
-
-test: "named let loop over list can be replaced by for/list"
-------------------------------------------------------------
-(require racket/list)
-(let loop ([xs (list 1 2 3)])
-  (cond
-    [(null? xs) '()]
-    [else
-     (displayln (car xs))
-     (cons (* (car xs) 10)
-           (loop (cdr xs)))]))
-------------------------------------------------------------
-------------------------------------------------------------
-(require racket/list)
-(let loop ([xs (list 1 2 3)])
-  (cond
-    [(empty? xs) '()]
-    [else
-     (displayln (first xs))
-     (cons (* (first xs) 10)
-           (loop (rest xs)))]))
-------------------------------------------------------------
-------------------------------------------------------------
-(require racket/list)
-(for/list ([x (in-list (list 1 2 3))])
-  (displayln x)
-  (* x 10))
-------------------------------------------------------------
-
-
-test: "named let loop can be replaced with for/and when equivalent"
-------------------------------------------------------------
-(require racket/list)
-(define (f xs big? red?)
-  (let loop ([xs xs])
-    (cond
-      [(empty? xs) #true]
-      [(and (big? (first xs)) (not (red? (car xs))))
-       (loop (rest xs))]
-      [else #false])))
-------------------------------------------------------------
-------------------------------------------------------------
-(require racket/list)
-(define (f xs big? red?)
-  (for/and ([x (in-list xs)])
-    (and (big? x) (not (red? x)))))
-------------------------------------------------------------
-
-
-test: "named let loop can be replaced with for/or when equivalent"
-------------------------------------------------------------
-(require racket/list)
-(define (f xs big? red?)
-  (let loop ([xs xs])
-    (cond
-      [(empty? xs) #false]
-      [(and (big? (first xs)) (not (red? (car xs)))) #true]
-      [else (loop (rest xs))])))
-------------------------------------------------------------
-------------------------------------------------------------
-(require racket/list)
-(define (f xs big? red?)
-  (for/or ([x (in-list xs)])
-    (and (big? x) (not (red? x)))))
-------------------------------------------------------------
-
-
 test: "append-map with for/list can be replaced by for*/list"
 ------------------------------------------------------------
 (require racket/list)
@@ -1071,20 +955,6 @@ test: "shadowed and unused in-value clause refactorable to #:do clause"
 --------------------
 
 
-test: "read-until-eof loop refactorable to for loop with in-port"
---------------------
-(define (print-reads)
-  (let loop ([v (read)])
-    (unless (eof-object? v)
-      (displayln v)
-      (loop (read)))))
-====================
-(define (print-reads)
-  (for ([v (in-port)])
-    (displayln v)))
---------------------
-
-
 test: "index-mutating map to for/list with index"
 --------------------
 (require racket/list)

default-recommendations/for-loop-shortcuts.rkt

@@ -437,130 +437,19 @@ return just that result."
     nested.body ...))
 
 
-(define-refactoring-rule named-let-loop-to-for-in-range
-  #:description "This named `let` expression is equivalent to a `for` loop that uses `in-range`."
-  #:literals (let when < +)
-  (let loop:id ([x:id start:expr])
-    (when (< x2:id (~or stop:id stop:literal-constant))
-      body ...+
-      (loop2:id (+ x3:id (~or step:id step:literal-constant)))))
-  #:when (free-identifier=? (attribute x) (attribute x2))
-  #:when (free-identifier=? (attribute x) (attribute x3))
-  #:when (free-identifier=? (attribute loop) (attribute loop2))
-  #:when (or (not (identifier? (attribute step)))
-             (identifier-binding-unchanged-in-context? (attribute step) this-syntax))
-  #:when (not (syntax-find-first #'(body ...) id:id
-                #:when (free-identifier=? (attribute id) (attribute loop))))
-  (for ([x (in-range start stop step)])
-    body ...))
-
-
-(define-refactoring-rule named-let-loop-to-for/list
-  #:description "This named `let` expression is equivalent to a `for/list` loop."
-  #:literals (let cond else null? empty? null quote car first cdr rest cons)
-  (let loop:id ([vs:id init-list])
-    (cond
-      [(:empty-predicate-by-any-name vs2:id) :empty-list-by-any-name]
-      [else
-       loop-body:expr ...
-       (cons loop-element:expr (loop2:id (:rest-by-any-name vs3:id)))]))
-  #:when (log-resyntax-rule-condition (free-identifier=? #'loop #'loop2))
-  #:when (log-resyntax-rule-condition (free-identifier=? #'vs #'vs2))
-  #:when (log-resyntax-rule-condition (free-identifier=? #'vs #'vs3))
-  #:when (log-resyntax-rule-condition
-          (not
-           (for/or ([body-stx (in-list (cons #'loop-element (attribute loop-body)))])
-             (syntax-find-first body-stx
-               (~and (~var usage (expression-directly-enclosing (attribute vs)))
-                     (~not (:first-by-any-name _)))))))
-  #:cut
 
-  #:with element-id (depluralize-id #'vs)
-
-  #:with (modified-result-element modified-body ...)
-  (for/list ([body-stx (cons #'loop-element (attribute loop-body))])
-    (syntax-traverse body-stx
-      [(:first-by-any-name vs-usage:id)
-       #:when (free-identifier=? (attribute vs-usage) (attribute vs))
-       (attribute element-id)]))
-
-  (for/list ([element-id (in-list init-list)])
-    modified-body ...
-    modified-result-element))
-
-
-(define-refactoring-rule named-let-loop-to-for/and
-  #:description "This named `let` expression is equivalent to a `for/and` loop."
-  #:literals (let cond else)
-  (let loop:id ([vs:id init-list])
-    (cond
-      [(:empty-predicate-by-any-name vs2:id) #true]
-      [element-condition:expr (loop2:id (:rest-by-any-name vs3:id))]
-      [else #false]))
-
-  #:when (free-identifier=? (attribute loop) (attribute loop2))
-  #:when (free-identifier=? (attribute vs) (attribute vs2))
-  #:when (free-identifier=? (attribute vs) (attribute vs3))
-  #:when (not (syntax-find-first (attribute element-condition)
-                (~and (~var usage (expression-directly-enclosing (attribute vs)))
-                      (~not (:first-by-any-name _)))))
-  #:cut
 
-  #:with element-id (depluralize-id (attribute vs))
-  #:with modified-element-condition
-  (syntax-traverse (attribute element-condition)
-    [(:first-by-any-name vs-usage:id)
-     #:when (free-identifier=? (attribute vs-usage) (attribute vs))
-     (attribute element-id)])
-
-  (for/and ([element-id (in-list init-list)])
-    modified-element-condition))
-
-
-(define-refactoring-rule named-let-loop-to-for/or
-  #:description "This named `let` expression is equivalent to a `for/or` loop."
-  #:literals (let cond else)
-  (let loop:id ([vs:id init-list])
-    (cond
-      [(:empty-predicate-by-any-name vs2:id) #false]
-      [element-condition:expr #true]
-      [else (loop2:id (:rest-by-any-name vs3:id))]))
-
-  #:when (free-identifier=? (attribute loop) (attribute loop2))
-  #:when (free-identifier=? (attribute vs) (attribute vs2))
-  #:when (free-identifier=? (attribute vs) (attribute vs3))
-  #:when (not (syntax-find-first (attribute element-condition)
-                (~and (~var usage (expression-directly-enclosing (attribute vs)))
-                      (~not (:first-by-any-name _)))))
-  #:cut
 
-  #:with element-id (depluralize-id (attribute vs))
-  #:with modified-element-condition
-  (syntax-traverse (attribute element-condition)
-    [(:first-by-any-name vs-usage:id)
-     #:when (log-resyntax-rule-condition (free-identifier=? (attribute vs) (attribute vs-usage)))
-     (attribute element-id)])
-
-  (for/or ([element-id (in-list init-list)])
-    modified-element-condition))
-
-
-(define-refactoring-rule named-let-loop-to-for/first-in-vector
-  #:description "This loop can be replaced by a simpler, equivalent `for/first` loop."
-  #:literals (let add1 + vector-length vector-ref if and <)
-  (let loop1:id ([i1:id 0])
-    (and (< i2:id (vector-length vec1:id))
-         (let ([x:id (vector-ref vec2:id i3:id)])
-           (if condition:expr
-               true-branch:expr
-               (loop2:id (~or (add1 i4:id) (+ i4:id 1) (+ 1 i4:id)))))))
-  #:when (and (log-resyntax-rule-condition (free-identifier=? #'loop1 #'loop2))
-              (log-resyntax-rule-condition (free-identifier=? #'i1 #'i2))
-              (log-resyntax-rule-condition (free-identifier=? #'i1 #'i3))
-              (log-resyntax-rule-condition (free-identifier=? #'i1 #'i4))
-              (log-resyntax-rule-condition (free-identifier=? #'vec1 #'vec2)))
-  (for/first ([x (in-vector vec1)] #:when condition)
-    true-branch))
+
+
+
+
+
+
+
+
+
+
 
 
 (define-refactoring-rule or-let-in-for/and-to-filter-clause
@@ -621,18 +510,7 @@ return just that result."
   (for-id (clause-before ... #:do [expr] clause-after ...) body ...))
 
 
-(define-refactoring-rule named-let-read-loop-to-for-in-port
-  #:description
-  "A named `let` that repeatedly calls `read` can be rewritten to a `for` loop using `in-port`."
-  #:literals (let unless read eof-object?)
-  (let loop:id ([v:id (read)])
-    (unless (eof-object? v2:id)
-      body ...
-      (loop2:id (read))))
-  #:when (free-identifier=? (attribute v) (attribute v2))
-  #:when (free-identifier=? (attribute loop) (attribute loop2))
-  (for ([v (in-port)])
-    body ...))
+
 
 
 (define-refactoring-rule index-mutating-map-to-for/list
@@ -673,12 +551,6 @@ return just that result."
            list->set-to-for/set
            list->vector-to-for/vector
            map-to-for
-           named-let-loop-to-for-in-range
-           named-let-loop-to-for/and
-           named-let-loop-to-for/first-in-vector
-           named-let-loop-to-for/list
-           named-let-loop-to-for/or
-           named-let-read-loop-to-for-in-port
            nested-for-to-for*
            nested-for/and-to-for*/and
            nested-for/or-to-for*/or