Extend Lint/UnusedBlockArgument rule with corrections

spec/ameba/rule/lint/unused_block_argument_spec.cr

@@ -5,105 +5,118 @@ module Ameba::Rule::Lint
 
   describe UnusedBlockArgument do
     it "doesn't report if it is an instance var argument" do
-      s = Source.new %(
+      expect_no_issues subject, <<-CRYSTAL
         class A
           def initialize(&@callback)
           end
         end
-      )
+        CRYSTAL
-      subject.catch(s).should be_valid
     end
 
     it "doesn't report if anonymous" do
-      s = Source.new %(
+      expect_no_issues subject, <<-CRYSTAL
         def method(a, b, c, &)
         end
-      )
+        CRYSTAL
-      subject.catch(s).should be_valid
     end
 
     it "doesn't report if argument name starts with a `_`" do
-      s = Source.new %(
+      expect_no_issues subject, <<-CRYSTAL
         def method(a, b, c, &_block)
         end
-      )
+        CRYSTAL
-      subject.catch(s).should be_valid
     end
 
     it "doesn't report if it is a block and used" do
-      s = Source.new %(
+      expect_no_issues subject, <<-CRYSTAL
         def method(a, b, c, &block)
           block.call
         end
-      )
+        CRYSTAL
-      subject.catch(s).should be_valid
     end
 
     it "reports if block arg is not used" do
-      s = Source.new %(
+      source = expect_issue subject, <<-CRYSTAL
         def method(a, b, c, &block)
+                           # ^ error: Unused block argument `block`. [...]
         end
-      )
+        CRYSTAL
-      subject.catch(s).should_not be_valid
+
+      expect_correction source, <<-CRYSTAL
+        def method(a, b, c, &_block)
+        end
+        CRYSTAL
     end
 
     it "reports if unused and there is yield" do
-      s = Source.new %(
+      source = expect_issue subject, <<-CRYSTAL
         def method(a, b, c, &block)
+                           # ^ error: Use `&` as an argument name to indicate that it won't be referenced.
           3.times do |i|
             i.try do
               yield i
             end
           end
         end
-      )
+        CRYSTAL
-      subject.catch(s).should_not be_valid
+
+      expect_correction source, <<-CRYSTAL
+        def method(a, b, c, &)
+          3.times do |i|
+            i.try do
+              yield i
+            end
+          end
+        end
+        CRYSTAL
     end
 
     it "doesn't report if anonymous and there is yield" do
-      s = Source.new %(
+      expect_no_issues subject, <<-CRYSTAL
         def method(a, b, c, &)
           yield 1
         end
-      )
+        CRYSTAL
-      subject.catch(s).should be_valid
     end
 
     it "doesn't report if variable is referenced implicitly" do
-      s = Source.new %(
+      expect_no_issues subject, <<-CRYSTAL
         class Bar < Foo
           def method(a, b, c, &block)
             super
           end
         end
-      )
+        CRYSTAL
-      subject.catch(s).should be_valid
     end
 
     context "super" do
       it "reports if variable is not referenced implicitly by super" do
-        s = Source.new %(
+        source = expect_issue subject, <<-CRYSTAL
           class Bar < Foo
             def method(a, b, c, &block)
+                               # ^ error: Unused block argument `block`. [...]
               super a, b, c
             end
           end
-        )
+          CRYSTAL
-        subject.catch(s).should_not be_valid
+
-        s.issues.first.message.should eq "Unused block argument `block`. If it's necessary, " \
+        expect_correction source, <<-CRYSTAL
-                                         "use `_block` as an argument name to indicate " \
+          class Bar < Foo
-                                         "that it won't be used."
+            def method(a, b, c, &_block)
+              super a, b, c
+            end
+          end
+          CRYSTAL
       end
     end
 
     context "macro" do
       it "doesn't report if it is a used macro block argument" do
-        s = Source.new %(
+        expect_no_issues subject, <<-CRYSTAL
           macro my_macro(&block)
             {% block %}
           end
-        )
+          CRYSTAL
-        subject.catch(s).should be_valid
       end
     end
   end

src/ameba/rule/lint/unused_block_argument.cr

@@ -31,6 +31,8 @@ module Ameba::Rule::Lint
   #   Enabled: true
   # ```
   class UnusedBlockArgument < Base
+    include AST::Util
+
     properties do
       description "Disallows unused block arguments"
     end
@@ -51,12 +53,27 @@ module Ameba::Rule::Lint
       return if block_arg.anonymous?
       return if scope.references?(block_arg.variable)
 
+      location = block_arg.node.location
+      end_location = location.try &.adjust(column_number: block_arg.name.size - 1)
+
       if scope.yields?
+        if location && end_location
+          issue_for block_arg.node, MSG_YIELDED do |corrector|
+            corrector.remove(location, end_location)
+          end
+        else
           issue_for block_arg.node, MSG_YIELDED
+        end
       else
         return if block_arg.ignored?
+        if location && end_location
+          issue_for block_arg.node, MSG_UNUSED % block_arg.name do |corrector|
+            corrector.insert_before(location, '_')
+          end
+        else
           issue_for block_arg.node, MSG_UNUSED % block_arg.name
         end
       end
     end
+  end
 end