Add support for itblock node for Ruby 3.4

In tests, prism will always be used for Ruby 3.4+ and tests that
don't pass with `parser` get marked as broken.

Author: Earlopain

changelog/new_support_itblock.md

@@ -0,0 +1 @@
+* [#365](https://github.com/rubocop/rubocop-ast/pull/365): Add support for `itblock` node for Ruby 3.4. ([@earlopain][])

docs/modules/ROOT/pages/node_types.adoc

@@ -170,6 +170,8 @@ The following fields are given when relevant to nodes in the source code:
 
 |numblock|Block that has numbered arguments (`_1`) referenced inside it.|Three children. First child is a `send`/`csend` node representing the way the block is created, second child is an `int` (the number of numeric arguments) and the third child is a body statement.|proc { _1 + _3 }|https://rubydoc.info/github/rubocop/rubocop-ast/RuboCop/AST/BlockNode[BlockNode]
 
+|itblock|Block that has the implicit it parameter (`it`) referenced inside it.|Three children. First child is a `send`/`csend` node representing the way the block is created, second child is the symbol `it` and the third child is a body statement.|proc { _1 + _3 }|N/A
+
 |op_asgn|Operator-assignment - perform an operation and assign the value.|Three children. First child must be an assignment node, second child is the operator (e.g. `:+`) and the third child is the expression node.|a += b|https://rubydoc.info/github/rubocop/rubocop-ast/RuboCop/AST/OpAsgnNode[OpAsgnNode]
 
 |optarg|Optional positional argument. Must come inside an `args`.|One child - a symbol, representing the argument name.|def foo(bar=1)|https://rubydoc.info/github/rubocop/rubocop-ast/RuboCop/AST/ArgNode[ArgNode]

lib/rubocop/ast/builder.rb

@@ -32,6 +32,7 @@ def self.included(base)
         gvasgn:              AsgnNode,
         block:               BlockNode,
         numblock:            BlockNode,
+        itblock:             BlockNode,
         break:               BreakNode,
         case_match:          CaseMatchNode,
         casgn:               CasgnNode,

lib/rubocop/ast/node.rb

@@ -112,7 +112,8 @@ class Node < Parser::AST::Node # rubocop:disable Metrics/ClassLength
         csend: :call,
 
         block: :any_block,
-        numblock: :any_block
+        numblock: :any_block,
+        itblock: :any_block
       }.freeze
       private_constant :GROUP_FOR_TYPE
 

lib/rubocop/ast/node/block_node.rb

@@ -46,10 +46,10 @@ def last_argument
       #
       # @return [Array<Node>]
       def arguments
-        if numblock_type?
-          [].freeze # Numbered parameters have no block arguments.
-        else
+        if block_type?
           node_parts[1]
+        else
+          [].freeze # Numblocks and itblocks have no explicit block arguments.
         end
       end
 
@@ -60,6 +60,8 @@ def arguments
       def argument_list
         if numblock_type?
           numbered_arguments
+        elsif itblock_type?
+          it_arguments
         else
           arguments.argument_list
         end
@@ -153,15 +155,16 @@ def void_context?
 
       private
 
-      # Numbered arguments of this `numblock`.
       def numbered_arguments
-        return [].freeze unless numblock_type?
-
         max_param = children[1]
         1.upto(max_param).map do |i|
           ArgNode.new(:arg, [:"_#{i}"])
         end.freeze
       end
+
+      def it_arguments
+        [ArgNode.new(:arg, [:it])].freeze
+      end
     end
   end
 end

lib/rubocop/ast/node/mixin/method_dispatch_node.rb

@@ -39,10 +39,10 @@ def selector
         end
       end
 
-      # The `block` or `numblock` node associated with this method dispatch, if any.
+      # The `block`, `numblock`, or `itblock` node associated with this method dispatch, if any.
       #
-      # @return [BlockNode, nil] the `block` or `numblock` node associated with this method
-      #                          call or `nil`
+      # @return [BlockNode, nil] the `block`, `numblock`, or `itblock` node associated with this
+      #                          method call or `nil`
       def block_node
         parent if block_literal?
       end

lib/rubocop/ast/traversal.rb

@@ -159,6 +159,7 @@ def children_count_check_code(range)
       def_callback :if, :always, :nil?, :nil?
       def_callback :block, :always, :always, :nil?
       def_callback :numblock, :always, :skip, :nil?
+      def_callback :itblock, :always, :skip, :nil?
       def_callback :defs, :always, :skip, :always, :nil?
 
       def_callback %i[send csend], body: <<~RUBY
@@ -176,7 +177,7 @@ def children_count_check_code(range)
 
       to_define = ::Parser::Meta::NODE_TYPES.to_a
       to_define -= defined
-      to_define -= %i[numargs ident] # transient
+      to_define -= %i[numargs itarg ident] # transient
       to_define -= %i[blockarg_expr restarg_expr] # obsolete
       to_define -= %i[objc_kwarg objc_restarg objc_varargs] # mac_ruby
       def_callback to_define, body: <<~RUBY

spec/rubocop/ast/block_node_spec.rb

@@ -47,6 +47,14 @@
         it { expect(block_node.arguments).to be_empty }
       end
     end
+
+    context '>= Ruby 3.4', :ruby34, broken_on: :parser do
+      context 'using implicit `it` parameter' do
+        let(:source) { 'foo { it }' }
+
+        it { expect(block_node.arguments).to be_empty }
+      end
+    end
   end
 
   describe '#argument_list' do
@@ -81,6 +89,14 @@
         end
       end
     end
+
+    context '>= Ruby 3.4', :ruby34, broken_on: :parser do
+      context 'using implicit `it` parameter' do
+        let(:source) { 'foo { it }' }
+
+        it { expect(names).to eq(%i[it]) }
+      end
+    end
   end
 
   describe '#arguments?' do
@@ -121,6 +137,14 @@
         it { is_expected.not_to be_arguments }
       end
     end
+
+    context '>= Ruby 3.4', :ruby34 do
+      context 'using implicit `it` parameter' do
+        let(:source) { 'foo { it }' }
+
+        it { is_expected.not_to be_arguments }
+      end
+    end
   end
 
   describe '#braces?' do
@@ -341,6 +365,14 @@
         it { expect(block_node.first_argument).to be_nil }
       end
     end
+
+    context '>= Ruby 3.4', :ruby34 do
+      context 'using implicit `it` parameter' do
+        let(:source) { 'foo { it }' }
+
+        it { expect(block_node.first_argument).to be_nil }
+      end
+    end
   end
 
   describe '#last_argument' do

spec/rubocop/ast/node_spec.rb

@@ -491,6 +491,40 @@ def used?
         end
       end
     end
+
+    context 'using Ruby >= 3.4', :ruby34 do
+      context 'class definition with an itblock' do
+        let(:src) { 'Class.new { do_something(it) }' }
+
+        it 'matches' do
+          expect(node).to be_class_constructor
+        end
+      end
+
+      context 'module definition with an itblock' do
+        let(:src) { 'Module.new { do_something(it) }' }
+
+        it 'matches' do
+          expect(node).to be_class_constructor
+        end
+      end
+
+      context 'Struct definition with an itblock' do
+        let(:src) { 'Struct.new(:foo, :bar) { do_something(it) }' }
+
+        it 'matches' do
+          expect(node).to be_class_constructor
+        end
+      end
+
+      context 'Data definition with an itblock' do
+        let(:src) { 'Data.define(:foo, :bar) { do_something(it) }' }
+
+        it 'matches' do
+          expect(node).to be_class_constructor
+        end
+      end
+    end
   end
 
   describe '#struct_constructor?' do

spec/rubocop/ast/send_node_spec.rb

@@ -206,6 +206,21 @@ module Foo
         it { expect(send_node).to be_bare_access_modifier }
       end
     end
+
+    context 'with Ruby >= 3.4', :ruby34 do
+      context 'when node is access modifier in itblock' do
+        let(:source) do
+          <<~RUBY
+            included do
+            it
+            >> module_function <<
+            end
+          RUBY
+        end
+
+        it { expect(send_node).to be_bare_access_modifier }
+      end
+    end
   end
 
   describe '#non_bare_access_modifier?' do
@@ -339,6 +354,19 @@ module Foo
         end
       end
 
+      context 'with Ruby >= 3.4', :ruby27 do
+        context 'when parent is an itblock in a macro scope' do
+          let(:source) do
+            ['concern :Auth do',
+             '>>bar :baz<<',
+             '  bar it',
+             'end'].join("\n")
+          end
+
+          it { expect(send_node).to be_macro }
+        end
+      end
+
       context 'when parent is a block not in a macro scope' do
         let(:source) { <<~RUBY }
           class Foo
@@ -1106,6 +1134,14 @@ def bar
         it { expect(send_node).to be_block_literal }
       end
     end
+
+    context 'with Ruby >= 3.4', :ruby27 do
+      context 'with an itblock literal' do
+        let(:source) { '>> foo.bar << { baz(it) }' }
+
+        it { expect(send_node).to be_block_literal }
+      end
+    end
   end
 
   describe '#arithmetic_operation?' do
@@ -1154,6 +1190,14 @@ def bar
         it { expect(send_node.block_node).to be_numblock_type }
       end
     end
+
+    context 'with Ruby >= 3.4', :ruby34, broken_on: :parser do
+      context 'with an itblock literal' do
+        let(:source) { '>>foo.bar<< { baz(it) }' }
+
+        it { expect(send_node.block_node).to be_itblock_type }
+      end
+    end
   end
 
   describe '#splat_argument?' do