Move lambdas into their own methods, smarter token finding in on_args_add_block

Author: kddnewton

lib/syntax_tree/node.rb

@@ -2885,27 +2885,15 @@ def deconstruct_keys(_keys)
     end
 
     def format(q)
-      declaration = -> do
-        q.group do
-          q.text("class ")
-          q.format(constant)
-
-          if superclass
-            q.text(" < ")
-            q.format(superclass)
-          end
-        end
-      end
-
       if bodystmt.empty?
         q.group do
-          declaration.call
+          format_declaration(q)
           q.breakable_force
           q.text("end")
         end
       else
         q.group do
-          declaration.call
+          format_declaration(q)
 
           q.indent do
             q.breakable_force
@@ -2917,6 +2905,20 @@ def format(q)
         end
       end
     end
+
+    private
+
+    def format_declaration(q)
+      q.group do
+        q.text("class ")
+        q.format(constant)
+
+        if superclass
+          q.text(" < ")
+          q.format(superclass)
+        end
+      end
+    end
   end
 
   # Comma represents the use of the , operator.
@@ -5122,18 +5124,7 @@ def deconstruct_keys(_keys)
     def format(q)
       parts = keywords.map { |(key, value)| KeywordFormatter.new(key, value) }
       parts << KeywordRestFormatter.new(keyword_rest) if keyword_rest
-
       nested = PATTERNS.include?(q.parent.class)
-      contents = -> do
-        q.group { q.seplist(parts) { |part| q.format(part, stackable: false) } }
-
-        # If there isn't a constant, and there's a blank keyword_rest, then we
-        # have an plain ** that needs to have a `then` after it in order to
-        # parse correctly on the next parse.
-        if !constant && keyword_rest && keyword_rest.value.nil? && !nested
-          q.text(" then")
-        end
-      end
 
       # If there is a constant, we're going to format to have the constant name
       # first and then use brackets.
@@ -5143,7 +5134,7 @@ def format(q)
           q.text("[")
           q.indent do
             q.breakable_empty
-            contents.call
+            format_contents(q, parts, nested)
           end
           q.breakable_empty
           q.text("]")
@@ -5160,7 +5151,7 @@ def format(q)
       # If there's only one pair, then we'll just print the contents provided
       # we're not inside another pattern.
       if !nested && parts.size == 1
-        contents.call
+        format_contents(q, parts, nested)
         return
       end
 
@@ -5170,7 +5161,7 @@ def format(q)
         q.text("{")
         q.indent do
           q.breakable_space
-          contents.call
+          format_contents(q, parts, nested)
         end
 
         if q.target_ruby_version < Gem::Version.new("2.7.3")
@@ -5181,6 +5172,19 @@ def format(q)
         end
       end
     end
+
+    private
+
+    def format_contents(q, parts, nested)
+      q.group { q.seplist(parts) { |part| q.format(part, stackable: false) } }
+
+      # If there isn't a constant, and there's a blank keyword_rest, then we
+      # have an plain ** that needs to have a `then` after it in order to
+      # parse correctly on the next parse.
+      if !constant && keyword_rest && keyword_rest.value.nil? && !nested
+        q.text(" then")
+      end
+    end
   end
 
   # The list of nodes that represent patterns inside of pattern matching so that
@@ -6543,22 +6547,15 @@ def deconstruct_keys(_keys)
     end
 
     def format(q)
-      declaration = -> do
-        q.group do
-          q.text("module ")
-          q.format(constant)
-        end
-      end
-
       if bodystmt.empty?
         q.group do
-          declaration.call
+          format_declaration(q)
           q.breakable_force
           q.text("end")
         end
       else
         q.group do
-          declaration.call
+          format_declaration(q)
 
           q.indent do
             q.breakable_force
@@ -6570,6 +6567,15 @@ def format(q)
         end
       end
     end
+
+    private
+
+    def format_declaration(q)
+      q.group do
+        q.text("module ")
+        q.format(constant)
+      end
+    end
   end
 
   # MRHS represents the values that are being assigned on the right-hand side of
@@ -7023,27 +7029,35 @@ def format(q)
       parts << KeywordRestFormatter.new(keyword_rest) if keyword_rest
       parts << block if block
 
-      contents = -> do
-        q.seplist(parts) { |part| q.format(part) }
-        q.format(rest) if rest.is_a?(ExcessedComma)
+      if parts.empty?
+        q.nest(0) { format_contents(q, parts) }
+        return
       end
 
-      if ![Def, Defs, DefEndless].include?(q.parent.class) || parts.empty?
-        q.nest(0, &contents)
-      else
+      case q.parent
+      when Def, Defs, DefEndless
         q.nest(0) do
           q.text("(")
           q.group do
             q.indent do
               q.breakable_empty
-              contents.call
+              format_contents(q, parts)
             end
             q.breakable_empty
           end
           q.text(")")
         end
+      else
+        q.nest(0) { format_contents(q, parts) }
       end
     end
+
+    private
+
+    def format_contents(q, parts)
+      q.seplist(parts) { |part| q.format(part) }
+      q.format(rest) if rest.is_a?(ExcessedComma)
+    end
   end
 
   # Paren represents using balanced parentheses in a couple places in a Ruby

lib/syntax_tree/parser.rb

@@ -513,23 +513,26 @@ def on_args_add(arguments, argument)
     #     (false | untyped) block
     #   ) -> Args
     def on_args_add_block(arguments, block)
+      end_char = arguments.parts.any? && arguments.location.end_char
+
       # First, see if there is an & operator that could potentially be
       # associated with the block part of this args_add_block. If there is not,
       # then just return the arguments.
-      operator = find_operator(:&)
-      return arguments unless operator
-
-      # If there are any arguments and the operator we found from the list is
-      # not after them, then we're going to return the arguments as-is because
-      # we're looking at an & that occurs before the arguments are done.
-      if arguments.parts.any? &&
-           operator.location.start_char < arguments.location.end_char
-        return arguments
-      end
+      index =
+        tokens.rindex do |token|
+          # If there are any arguments and the operator we found from the list
+          # is not after them, then we're going to return the arguments as-is
+          # because we're looking at an & that occurs before the arguments are
+          # done.
+          return arguments if end_char && token.location.start_char < end_char
+          token.is_a?(Op) && (token.name == :&)
+        end
+
+      return arguments unless index
 
       # Now we know we have an & operator, so we're going to delete it from the
       # list of tokens to make sure it doesn't get confused with anything else.
-      tokens.delete(operator)
+      operator = tokens.delete_at(index)
 
       # Construct the location that represents the block argument.
       location = operator.location