WIP: fuse-map-with-for rule implementation in progress

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

Author: Copilot

default-recommendations/loops/fuse-map-with-for-test.rkt

@@ -0,0 +1,92 @@
+#lang resyntax/test
+
+
+require: resyntax/default-recommendations/loops/fuse-map-with-for fuse-map-with-for
+
+
+header:
+- #lang racket/base
+
+
+test: "map producing list for for* loop can be fused"
+--------------------
+(define (f xs g h)
+  (define ys (map (λ (x) (g x)) xs))
+  (for* ([y (in-list ys)]
+         [z (in-list (h y))])
+    (displayln z)))
+====================
+(define (f xs g h)
+  (for* ([x (in-list xs)]
+         [y (in-list (g x))]
+         [z (in-list (h y))])
+    (displayln z)))
+--------------------
+
+
+test: "map producing list for for loop can be fused"
+--------------------
+(define (f xs g)
+  (define ys (map (λ (x) (g x)) xs))
+  (for ([y (in-list ys)])
+    (displayln y)))
+====================
+(define (f xs g)
+  (for ([x (in-list xs)])
+    (define y (g x))
+    (displayln y)))
+--------------------
+
+
+no-change-test: "map with short lambda but ys used elsewhere not refactorable"
+--------------------
+(define (f xs g h)
+  (define ys (map (λ (x) (g x)) xs))
+  (for* ([y (in-list ys)]
+         [z (in-list (h y))])
+    (displayln z))
+  (displayln ys))
+--------------------
+
+
+no-change-test: "map with non-short lambda not refactorable"
+--------------------
+(define (f xs)
+  (define ys (map (λ (x) (+ x 1)) xs))
+  (for ([y (in-list ys)])
+    (displayln y)))
+--------------------
+
+
+test: "map with lambda that has multiple body forms is refactorable"
+--------------------
+(define (f xs g)
+  (define ys (map (λ (x) (displayln x) (g x)) xs))
+  (for ([y (in-list ys)])
+    (displayln y)))
+====================
+(define (f xs g)
+  (for ([x (in-list xs)])
+    (displayln x)
+    (define y (g x))
+    (displayln y)))
+--------------------
+
+
+test: "map with long single-body lambda is refactorable"
+--------------------
+(define (f xs)
+  (define long-name 42)
+  (define ys
+    (map (λ (x)
+           (+ x long-name))
+         xs))
+  (for ([y (in-list ys)])
+    (displayln y)))
+====================
+(define (f xs)
+  (define long-name 42)
+  (for ([x (in-list xs)])
+    (define y (+ x long-name))
+    (displayln y)))
+--------------------

default-recommendations/loops/fuse-map-with-for.rkt

@@ -0,0 +1,101 @@
+#lang racket/base
+
+
+(require racket/contract/base)
+
+
+(provide
+ (contract-out
+  [fuse-map-with-for refactoring-suite?]))
+
+
+(require resyntax/base
+         resyntax/default-recommendations/analyzers/identifier-usage
+         resyntax/default-recommendations/let-replacement/private/let-binding
+         resyntax/default-recommendations/private/lambda-by-any-name
+         syntax/parse)
+
+
+;@----------------------------------------------------------------------------------------------------
+
+
+;; A short lambda suitable for fusing with a for loop. Needs both single-attribute and 
+;; multi-attribute versions of the body for different template contexts.
+(define-syntax-class fuseable-map-lambda
+  #:attributes (x single-body [multi-body 1])
+
+  ;; Lambdas with let expressions that can be refactored - must come first as it's most specific
+  (pattern
+    (_:lambda-by-any-name (x:id)
+                          original-body:body-with-refactorable-let-expression)
+    #:attr [multi-body 1] (attribute original-body.refactored)
+    ;; For single body, we need to wrap multiple forms in a begin
+    #:attr single-body #'(begin original-body.refactored ...))
+
+  ;; Lambdas with multiple body forms (two or more)
+  (pattern (_:lambda-by-any-name (x:id) first-form second-form rest-form ...)
+    #:attr [multi-body 1] (cons (attribute first-form)
+                                 (cons (attribute second-form) (attribute rest-form)))
+    #:attr single-body #'(begin first-form second-form rest-form ...))
+
+  ;; Short lambdas with a single body form
+  (pattern (_:lambda-by-any-name (x:id) only-form)
+    #:attr [multi-body 1] (list (attribute only-form))
+    #:attr single-body #'only-form))
+
+
+(define-definition-context-refactoring-rule fuse-map-with-for-rule
+  #:description
+  "A `map` expression producing a list for a `for` loop can be fused with the loop."
+  #:analyzers (list identifier-usage-analyzer)
+  #:literals (define map in-list for for*)
+  (~seq body-before ...
+        (define ys:id (map function:fuseable-map-lambda list-expr:expr))
+        ((~or for-id:for for-id:for*)
+         (~and original-clauses
+               ([y-var:id (in-list ys-usage:id)] remaining-clause ...+))
+         for-body ...)
+        body-after ...)
+
+  ;; Check that ys is only used in the for loop, not elsewhere
+  #:when (free-identifier=? (attribute ys) (attribute ys-usage))
+  #:when (equal? (syntax-property #'ys 'usage-count) 1)
+
+  ;; Generate the refactored code - fuse as nested clauses
+  (body-before ...
+   (for-id ([function.x (in-list list-expr)]
+            [y-var (in-list (function.multi-body ...))]
+            remaining-clause ...)
+           for-body ...)
+   body-after ...))
+
+
+;; Rule for when there are no remaining clauses - use internal definition
+(define-definition-context-refactoring-rule fuse-map-with-for-single-clause-rule
+  #:description
+  "A `map` expression producing a list for a `for` loop can be fused with the loop."
+  #:analyzers (list identifier-usage-analyzer)
+  #:literals (define map in-list for for*)
+  (~seq body-before ...
+        (define ys:id (map function:fuseable-map-lambda list-expr:expr))
+        ((~or for-id:for for-id:for*)
+         (~and original-clauses
+               ([y-var:id (in-list ys-usage:id)]))
+         for-body ...)
+        body-after ...)
+
+  ;; Check that ys is only used in the for loop, not elsewhere
+  #:when (free-identifier=? (attribute ys) (attribute ys-usage))
+  #:when (equal? (syntax-property #'ys 'usage-count) 1)
+
+  ;; Generate the refactored code - use internal definition
+  (body-before ...
+   (for-id ([function.x (in-list list-expr)])
+           (define y-var function.single-body)
+           for-body ...)
+   body-after ...))
+
+
+(define-refactoring-suite fuse-map-with-for
+  #:rules (fuse-map-with-for-rule
+           fuse-map-with-for-single-clause-rule))