Allow specifying desired analyzers in refactoring rules (#717)

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

Author: Copilot

base.rkt

@@ -139,11 +139,13 @@
   (define-refactoring-rule id:id
     #:description description
     (~optional (~seq #:uses-universal-tagged-syntax? uses-universal-tagged-syntax?))
+    (~optional (~seq #:analyzers analyzers))
     parse-option:syntax-parse-option ...
     pattern
     pattern-directive:syntax-parse-pattern-directive ...
     replacement)
   #:declare description (expr/c #'string?)
+  #:declare analyzers (expr/c #'(sequence/c expansion-analyzer?))
 
   #:attr partial-match-log-statement
   (and (not (empty? (attribute pattern-directive)))
@@ -159,9 +161,7 @@
      #:name 'id
      #:description (string->immutable-string description.c)
      #:uses-universal-tagged-syntax? (~? uses-universal-tagged-syntax? #false)
-     #:analyzers (set identifier-usage-analyzer
-                      ignored-result-values-analyzer
-                      variable-mutability-analyzer)
+     #:analyzers (for/set ([analyzer (~? analyzers.c '())]) analyzer)
      #:transformer
      (λ (stx)
        (syntax-parse stx
@@ -175,6 +175,7 @@
 (define-syntax-parse-rule
   (define-definition-context-refactoring-rule id:id
     #:description (~var description (expr/c #'string?))
+    (~optional (~seq #:analyzers (~var analyzers (expr/c #'(sequence/c expansion-analyzer?)))))
     parse-option:syntax-parse-option ...
     splicing-pattern
     pattern-directive:syntax-parse-pattern-directive ...
@@ -227,6 +228,7 @@
 
     (define-refactoring-rule id
       #:description description
+      (~? (~@ #:analyzers analyzers))
       (~var expression expression-matching-id)
       expression.refactored)))
 
@@ -275,7 +277,8 @@
 
 (module+ test
   (require rackunit
-           resyntax/private/analyzer)
+           resyntax/private/analyzer
+           resyntax/private/syntax-property-bundle)
 
   (test-case "refactoring-rule stores analyzers"
     (define-refactoring-rule test-rule
@@ -285,18 +288,36 @@
 
     (check-true (refactoring-rule? test-rule))
     (check-true (set? (refactoring-rule-analyzers test-rule)))
-    (check-equal? (set-count (refactoring-rule-analyzers test-rule)) 3)
-    (check-true (for/and ([analyzer (in-set (refactoring-rule-analyzers test-rule))])
-                  (expansion-analyzer? analyzer))))
+    ;; Without #:analyzers, should have empty set (breaking change from previous behavior
+    ;; where rules had 3 default analyzers - identifier-usage, ignored-result-values, and
+    ;; variable-mutability analyzers)
+    (check-equal? (set-count (refactoring-rule-analyzers test-rule)) 0))
+
+  (test-case "refactoring-rule with explicit analyzers"
+    (define test-analyzer (make-expansion-analyzer (λ (stx) (syntax-property-bundle)) #:name 'test))
+    (define-refactoring-rule test-rule-with-analyzers
+      #:description "test rule with analyzers"
+      #:analyzers (list test-analyzer)
+      pattern
+      replacement)
+    
+    (check-true (refactoring-rule? test-rule-with-analyzers))
+    (check-equal? (set-count (refactoring-rule-analyzers test-rule-with-analyzers)) 1)
+    (check-true (set-member? (refactoring-rule-analyzers test-rule-with-analyzers) test-analyzer)))
 
   (test-case "refactoring-suite combines analyzers from rules"
+    (define analyzer1 (make-expansion-analyzer (λ (stx) (syntax-property-bundle)) #:name 'analyzer1))
+    (define analyzer2 (make-expansion-analyzer (λ (stx) (syntax-property-bundle)) #:name 'analyzer2))
+    
     (define-refactoring-rule rule1
       #:description "rule 1"
+      #:analyzers (list analyzer1)
       pattern1
       replacement1)
 
     (define-refactoring-rule rule2
       #:description "rule 2"
+      #:analyzers (list analyzer2)
       pattern2
       replacement2)
 
@@ -305,33 +326,42 @@
     (check-true (refactoring-suite? suite))
     (check-equal? (length (refactoring-suite-rules suite)) 2)
     (check-true (set? (refactoring-suite-analyzers suite)))
-    ;; All rules have the same analyzers, so the combined set should have 3 unique analyzers
-    (check-equal? (set-count (refactoring-suite-analyzers suite)) 3)
-    (check-true (for/and ([analyzer (in-set (refactoring-suite-analyzers suite))])
-                  (expansion-analyzer? analyzer))))
+    ;; Should have 2 unique analyzers from the two rules. Sets automatically deduplicate
+    ;; analyzers, so if both rules used the same analyzer, the count would be 1.
+    (check-equal? (set-count (refactoring-suite-analyzers suite)) 2)
+    (check-true (set-member? (refactoring-suite-analyzers suite) analyzer1))
+    (check-true (set-member? (refactoring-suite-analyzers suite) analyzer2)))
 
   (test-case "nested suites combine analyzers correctly"
+    (define analyzer1 (make-expansion-analyzer (λ (stx) (syntax-property-bundle)) #:name 'analyzer1))
+    
     (define-refactoring-rule inner-rule
       #:description "inner rule"
+      #:analyzers (list analyzer1)
       inner-pattern
       inner-replacement)
 
     (define inner-suite (refactoring-suite #:rules (list inner-rule)))
 
     (define-refactoring-rule outer-rule
       #:description "outer rule"
+      #:analyzers (list analyzer1)
       outer-pattern
       outer-replacement)
 
     (define outer-suite (refactoring-suite #:rules (list outer-rule inner-rule)))
 
-    (check-equal? (set-count (refactoring-suite-analyzers inner-suite)) 3)
-    ;; Both rules have the same analyzers, so deduplicated should still be 3
-    (check-equal? (set-count (refactoring-suite-analyzers outer-suite)) 3))
+    (check-equal? (set-count (refactoring-suite-analyzers inner-suite)) 1)
+    ;; Both rules have the same analyzer, so deduplicated should still be 1
+    (check-equal? (set-count (refactoring-suite-analyzers outer-suite)) 1))
 
   (test-case "define-refactoring-suite with nested suites preserves analyzers"
+    (define analyzer-a (make-expansion-analyzer (λ (stx) (syntax-property-bundle)) #:name 'analyzer-a))
+    (define analyzer-b (make-expansion-analyzer (λ (stx) (syntax-property-bundle)) #:name 'analyzer-b))
+    
     (define-refactoring-rule rule-a
       #:description "Rule A"
+      #:analyzers (list analyzer-a)
       pattern-a
       replacement-a)
 
@@ -340,6 +370,7 @@
 
     (define-refactoring-rule rule-b
       #:description "Rule B"
+      #:analyzers (list analyzer-b)
       pattern-b
       replacement-b)
 
@@ -349,7 +380,7 @@
 
     ;; Suite B should have both rules
     (check-equal? (length (refactoring-suite-rules suite-b)) 2)
-    ;; And should have 3 analyzers (deduplicated from both rules)
-    (check-equal? (set-count (refactoring-suite-analyzers suite-b)) 3)
+    ;; And should have 2 unique analyzers (one from each rule)
+    (check-equal? (set-count (refactoring-suite-analyzers suite-b)) 2)
     (check-true (for/and ([analyzer (in-set (refactoring-suite-analyzers suite-b))])
                   (expansion-analyzer? analyzer)))))

default-recommendations/conditional-shortcuts.rkt

@@ -12,6 +12,7 @@
 (require (for-syntax racket/base)
          racket/list
          resyntax/base
+         resyntax/default-recommendations/analyzers/ignored-result-values
          resyntax/default-recommendations/private/boolean
          resyntax/default-recommendations/private/exception
          resyntax/default-recommendations/private/if-arm
@@ -229,6 +230,7 @@
 
 (define-refactoring-rule ignored-and-to-when
   #:description "This `and` expression's result is ignored. Using `when` makes this clearer."
+  #:analyzers (list ignored-result-values-analyzer)
   #:literals (and)
   (and condition:expr body:expr)
   #:when (syntax-property this-syntax 'expression-result)
@@ -238,6 +240,7 @@
 
 (define-refactoring-rule explicit-cond-else-void
   #:description "Add an explicit `[else (void)]` clause to make the default behavior clear."
+  #:analyzers (list ignored-result-values-analyzer)
   #:literals (cond else void)
   (cond-id:cond (~and clause (~not [else . _])) ...)
   #:when (equal? (syntax-property this-syntax 'expression-result) 'ignored)

default-recommendations/definition-shortcuts.rkt

@@ -14,6 +14,7 @@
          racket/match
          rebellion/private/static-name
          resyntax/base
+         resyntax/default-recommendations/analyzers/identifier-usage
          syntax/parse)
 
 
@@ -33,6 +34,7 @@
 
 (define-definition-context-refactoring-rule inline-unnecessary-define
   #:description "This variable is returned immediately and can be inlined."
+  #:analyzers (list identifier-usage-analyzer)
   #:literals (define)
   (~seq body-before ... (~and definition (define id1:id expr)) id2:id)
   #:when (free-identifier=? #'id1 #'id2)

default-recommendations/dict-suggestions.rkt

@@ -12,6 +12,7 @@
 (require racket/dict
          racket/set
          resyntax/base
+         resyntax/default-recommendations/analyzers/identifier-usage
          syntax/parse)
 
 
@@ -45,6 +46,7 @@
 
 (define-refactoring-rule in-dict-to-in-dict-keys
   #:description "This `in-dict` can be replaced with `in-dict-keys` since the value is not used."
+  #:analyzers (list identifier-usage-analyzer)
   #:literals (in-dict)
   (for-id:id (clause-before ... [(key:id value:id) (in-dict dict-expr)] clause-after ...) body ...)
   #:when ((literal-set->predicate simple-for-loops) (attribute for-id))
@@ -54,6 +56,7 @@
 
 (define-refactoring-rule in-dict-to-in-dict-values
   #:description "This `in-dict` can be replaced with `in-dict-values` since the key is not used."
+  #:analyzers (list identifier-usage-analyzer)
   #:literals (in-dict)
   (for-id:id (clause-before ... [(key:id value:id) (in-dict dict-expr)] clause-after ...) body ...)
   #:when ((literal-set->predicate simple-for-loops) (attribute for-id))

default-recommendations/function-definition-shortcuts.rkt

@@ -13,6 +13,7 @@
          guard
          racket/list
          resyntax/base
+         resyntax/default-recommendations/analyzers/identifier-usage
          resyntax/default-recommendations/private/lambda-by-any-name
          resyntax/default-recommendations/private/list-function
          resyntax/default-recommendations/private/syntax-lines
@@ -144,6 +145,7 @@
 (define-refactoring-rule empty-checked-rest-args-to-optional-arg
   #:description
   "This function definition uses rest arguments in a way equivalent to using an optional argument."
+  #:analyzers (list identifier-usage-analyzer)
   #:literals (define if)
 
   (define (f arg ... . rest-args:id)

default-recommendations/let-replacement/let-replacement.rkt

@@ -14,6 +14,7 @@
          racket/set
          rebellion/private/static-name
          resyntax/base
+         resyntax/default-recommendations/analyzers/identifier-usage
          resyntax/default-recommendations/private/definition-context
          resyntax/default-recommendations/private/syntax-identifier-sets
          resyntax/default-recommendations/let-replacement/private/let-binding
@@ -28,6 +29,7 @@
 (define-definition-context-refactoring-rule let-to-define
   #:description
   "Internal definitions are recommended instead of `let` expressions, to reduce nesting."
+  #:analyzers (list identifier-usage-analyzer)
   (~seq leading-body ... let-expression:refactorable-let-expression)
   #:with (replacement ...)
   (if (empty? (attribute leading-body))
@@ -40,7 +42,8 @@
   #:description "This `let` expression can be pulled up into multiple `define` expressions."
   #:literals (define let)
   (~seq body-before ...
-        (~and original-definition (define id:id (let ([nested-id:id nested-expr:expr] ...) expr:expr)))
+        (~and original-definition
+              (define id:id (let ([nested-id:id nested-expr:expr] ...) expr:expr)))
         body-after ...)
   #:when (for/and ([nested-expr (in-list (attribute nested-expr))])
            (identifier-binding-unchanged-in-context? (attribute id) nested-expr))

default-recommendations/list-shortcuts.rkt

@@ -16,6 +16,7 @@
          racket/sequence
          racket/set
          resyntax/base
+         resyntax/default-recommendations/analyzers/ignored-result-values
          resyntax/default-recommendations/private/lambda-by-any-name
          resyntax/default-recommendations/private/literal-constant
          resyntax/default-recommendations/private/syntax-identifier-sets
@@ -131,6 +132,7 @@
 (define-refactoring-rule ignored-map-to-for-each
   #:description
   "The result of this `map` expression is unused. Make that explicit with `for-each` instead."
+  #:analyzers (list ignored-result-values-analyzer)
   #:literals (map)
   (map proc list ...)
   #:when (equal? (syntax-property this-syntax 'expression-result) 'ignored)

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

@@ -13,6 +13,7 @@
          racket/list
          racket/set
          resyntax/base
+         resyntax/default-recommendations/analyzers/identifier-usage
          resyntax/default-recommendations/loops/private/syntax-classes
          resyntax/default-recommendations/private/boolean
          resyntax/default-recommendations/private/lambda-by-any-name
@@ -242,6 +243,7 @@ return just that result."
   #:description
   "The `or` expression in this `for` loop can be replaced by a filtering clause, letting you use\
  `define` instead of `let` in the loop body."
+  #:analyzers (list identifier-usage-analyzer)
   #:literals (for/and for*/and or)
   ((~and loop-id (~or for/and for*/and))
    (~and original-clauses (clause ...))
@@ -270,6 +272,7 @@ return just that result."
 
 (define-refactoring-rule in-hash-to-in-hash-keys
   #:description "This `in-hash` can be replaced with `in-hash-keys` since the value is not used."
+  #:analyzers (list identifier-usage-analyzer)
   #:literals (in-hash)
   (for-id:id (clause-before ... [(key:id value:id) (in-hash hash-expr)] clause-after ...) body ...)
   #:when ((literal-set->predicate simple-for-loops) (attribute for-id))

default-recommendations/match-shortcuts.rkt

@@ -13,6 +13,7 @@
          racket/match
          racket/set
          resyntax/base
+         resyntax/default-recommendations/analyzers/identifier-usage
          resyntax/default-recommendations/private/lambda-by-any-name
          resyntax/default-recommendations/private/syntax-identifier-sets
          resyntax/default-recommendations/private/syntax-lines
@@ -249,6 +250,7 @@
   #:description "These list element variable definitions can be expressed more succinctly with \
 `match-define`. Note that the suggested replacement raises an error if the list contains more \
 elements than expected."
+  #:analyzers (list identifier-usage-analyzer)
   #:literals (define)
   (~seq body-before ... (~and definition (define v:id ref-expr:list-ref-expr)) ...+ body-after ...+)
   #:do [(define num-vars (length (attribute v)))]

default-recommendations/unused-binding-suggestions.rkt

@@ -11,6 +11,7 @@
 
 (require racket/list
          resyntax/base
+         resyntax/default-recommendations/analyzers/identifier-usage
          resyntax/default-recommendations/private/pure-expression
          syntax/parse)
 
@@ -27,6 +28,7 @@
 
 (define-definition-context-refactoring-rule unused-definition
   #:description "This definition is not used."
+  #:analyzers (list identifier-usage-analyzer)
   (~seq before ... definition:side-effect-free-definition first-after remaining-after ...)
   #:when (equal? (syntax-property (attribute definition.id) 'usage-count) 0)
   (before ...